sys/dev/virtual/virtio/pci/virtio_pci.c

   1 /*-
   2  * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/virtio/pci/virtio_pci.c,v 1.3 2012/04/14 05:48:04 grehan Exp $
  27  */
  28
  29 /* Driver for the VirtIO PCI interface. */
  30
  31 #include <sys/cdefs.h>
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/bus.h>
  36 #include <sys/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/malloc.h>
  39
  40 #include <bus/pci/pcivar.h>
  41 #include <bus/pci/pcireg.h>
  42
  43 #include <sys/bus.h>
  44 #include <sys/param.h>
  45 #include <sys/rman.h>
  46
  47 #include <dev/virtual/virtio/virtio/virtio.h>
  48 #include <dev/virtual/virtio/virtio/virtqueue.h>
  49 #include "virtio_pci.h"
  50 #include "virtio_if.h"
  51 #include "virtio_bus_if.h"
  52
  53 struct vtpci_softc {
  54         device_t                         vtpci_dev;
  55         struct resource                 *vtpci_res;
  56         struct resource                 *vtpci_msix_res;
  57         uint64_t                         vtpci_features;
  58         uint32_t                         vtpci_flags;
  59         int                              vtpci_irq_type;
  60         int                              vtpci_irq_rid;
  61 #define VIRTIO_PCI_FLAG_NO_MSI           0x0001
  62 #define VIRTIO_PCI_FLAG_MSI              0x0002
  63 #define VIRTIO_PCI_FLAG_NO_MSIX          0x0010
  64 #define VIRTIO_PCI_FLAG_MSIX             0x0020
  65 #define VIRTIO_PCI_FLAG_SHARED_MSIX      0x0040
  66
  67         device_t                         vtpci_child_dev;
  68         struct virtio_feature_desc      *vtpci_child_feat_desc;
  69
  70         /*
  71          * Ideally, each virtqueue that the driver provides a callback for
  72          * will receive its own MSIX vector. If there are not sufficient
  73          * vectors available, we will then attempt to have all the VQs
  74          * share one vector. Note that when using MSIX, the configuration
  75          * changed notifications must be on their own vector.
  76          *
  77          * If MSIX is not available, we will attempt to have the whole
  78          * device share one MSI vector, and then, finally, one legacy
  79          * interrupt.
  80          */
  81         int                              vtpci_nvqs;
  82         struct vtpci_virtqueue {
  83                 struct virtqueue *vq;
  84
  85                 /* Index into vtpci_intr_res[] below. Unused, then -1. */
  86                 int               ires_idx;
  87         } vtpci_vqx[VIRTIO_MAX_VIRTQUEUES];
  88
  89         /*
  90          * When using MSIX interrupts, the first element of vtpci_intr_res[]
  91          * is always the configuration changed notifications. The remaining
  92          * element(s) are used for the virtqueues.
  93          *
  94          * With MSI and legacy interrupts, only the first element of
  95          * vtpci_intr_res[] is used.
  96          */
  97         int                              vtpci_nintr_res;
  98         struct vtpci_intr_resource {
  99                 struct resource *irq;
 100                 int              rid;
 101                 void            *intrhand;
 102         } vtpci_intr_res[1 + VIRTIO_MAX_VIRTQUEUES];
 103 };
 104
 105 static int      vtpci_probe(device_t);
 106 static int      vtpci_attach(device_t);
 107 static int      vtpci_detach(device_t);
 108 static int      vtpci_suspend(device_t);
 109 static int      vtpci_resume(device_t);
 110 static int      vtpci_shutdown(device_t);
 111 static void     vtpci_driver_added(device_t, driver_t *);
 112 static void     vtpci_child_detached(device_t, device_t);
 113 static int      vtpci_read_ivar(device_t, device_t, int, uintptr_t *);
 114 static int      vtpci_write_ivar(device_t, device_t, int, uintptr_t);
 115
 116 static uint64_t vtpci_negotiate_features(device_t, uint64_t);
 117 static int      vtpci_with_feature(device_t, uint64_t);
 118 static int      vtpci_alloc_virtqueues(device_t, int, int,
 119                     struct vq_alloc_info *);
 120 static int      vtpci_setup_intr(device_t);
 121 static void     vtpci_stop(device_t);
 122 static int      vtpci_reinit(device_t, uint64_t);
 123 static void     vtpci_reinit_complete(device_t);
 124 static void     vtpci_notify_virtqueue(device_t, uint16_t);
 125 static uint8_t  vtpci_get_status(device_t);
 126 static void     vtpci_set_status(device_t, uint8_t);
 127 static void     vtpci_read_dev_config(device_t, bus_size_t, void *, int);
 128 static void     vtpci_write_dev_config(device_t, bus_size_t, void *, int);
 129
 130 static void     vtpci_describe_features(struct vtpci_softc *, const char *,
 131                     uint64_t);
 132 static void     vtpci_probe_and_attach_child(struct vtpci_softc *);
 133
 134 static int      vtpci_alloc_interrupts(struct vtpci_softc *, int, int,
 135                     struct vq_alloc_info *);
 136 static int      vtpci_alloc_intr_resources(struct vtpci_softc *, int,
 137                     struct vq_alloc_info *);
 138 static int      vtpci_alloc_msi(struct vtpci_softc *);
 139 static int      vtpci_alloc_msix(struct vtpci_softc *, int);
 140 static int      vtpci_register_msix_vector(struct vtpci_softc *, int, int);
 141
 142 static void     vtpci_free_interrupts(struct vtpci_softc *);
 143 static void     vtpci_free_virtqueues(struct vtpci_softc *);
 144 static void     vtpci_release_child_resources(struct vtpci_softc *);
 145 static void     vtpci_reset(struct vtpci_softc *);
 146
 147 static int      vtpci_legacy_intr(void *);
 148 static int      vtpci_vq_shared_intr(void *);
 149 static int      vtpci_vq_intr(void *);
 150 static int      vtpci_config_intr(void *);
 151
 152 /*
 153  * I/O port read/write wrappers.
 154  */
 155 #define vtpci_read_config_1(sc, o)      bus_read_1((sc)->vtpci_res, (o))
 156 #define vtpci_read_config_2(sc, o)      bus_read_2((sc)->vtpci_res, (o))
 157 #define vtpci_read_config_4(sc, o)      bus_read_4((sc)->vtpci_res, (o))
 158 #define vtpci_write_config_1(sc, o, v)  bus_write_1((sc)->vtpci_res, (o), (v))
 159 #define vtpci_write_config_2(sc, o, v)  bus_write_2((sc)->vtpci_res, (o), (v))
 160 #define vtpci_write_config_4(sc, o, v)  bus_write_4((sc)->vtpci_res, (o), (v))
 161
 162 /* Tunables. */
 163 static int vtpci_disable_msix = 0;
 164 TUNABLE_INT("hw.virtio.pci.disable_msix", &vtpci_disable_msix);
 165
 166 static device_method_t vtpci_methods[] = {
 167         /* Device interface. */
 168         DEVMETHOD(device_probe,                   vtpci_probe),
 169         DEVMETHOD(device_attach,                  vtpci_attach),
 170         DEVMETHOD(device_detach,                  vtpci_detach),
 171         DEVMETHOD(device_suspend,                 vtpci_suspend),
 172         DEVMETHOD(device_resume,                  vtpci_resume),
 173         DEVMETHOD(device_shutdown,                vtpci_shutdown),
 174
 175         /* Bus interface. */
 176         DEVMETHOD(bus_driver_added,               vtpci_driver_added),
 177         DEVMETHOD(bus_child_detached,             vtpci_child_detached),
 178         DEVMETHOD(bus_read_ivar,                  vtpci_read_ivar),
 179         DEVMETHOD(bus_write_ivar,                 vtpci_write_ivar),
 180
 181         /* VirtIO bus interface. */
 182         DEVMETHOD(virtio_bus_negotiate_features,  vtpci_negotiate_features),
 183         DEVMETHOD(virtio_bus_with_feature,        vtpci_with_feature),
 184         DEVMETHOD(virtio_bus_alloc_virtqueues,    vtpci_alloc_virtqueues),
 185         DEVMETHOD(virtio_bus_setup_intr,          vtpci_setup_intr),
 186         DEVMETHOD(virtio_bus_stop,                vtpci_stop),
 187         DEVMETHOD(virtio_bus_reinit,              vtpci_reinit),
 188         DEVMETHOD(virtio_bus_reinit_complete,     vtpci_reinit_complete),
 189         DEVMETHOD(virtio_bus_notify_vq,           vtpci_notify_virtqueue),
 190         DEVMETHOD(virtio_bus_read_device_config,  vtpci_read_dev_config),
 191         DEVMETHOD(virtio_bus_write_device_config, vtpci_write_dev_config),
 192
 193         { 0, 0 }
 194 };
 195
 196 static driver_t vtpci_driver = {
 197         "virtio_pci",
 198         vtpci_methods,
 199         sizeof(struct vtpci_softc)
 200 };
 201
 202 devclass_t vtpci_devclass;
 203
 204 DRIVER_MODULE(virtio_pci, pci, vtpci_driver, vtpci_devclass, 0, 0);
 205 MODULE_VERSION(virtio_pci, 1);
 206 MODULE_DEPEND(virtio_pci, pci, 1, 1, 1);
 207 MODULE_DEPEND(virtio_pci, virtio, 1, 1, 1);
 208
 209 static int
 210 vtpci_probe(device_t dev)
 211 {
 212         char desc[36];
 213         const char *name;
 214
 215         if (pci_get_vendor(dev) != VIRTIO_PCI_VENDORID)
 216                 return (ENXIO);
 217
 218         if (pci_get_device(dev) < VIRTIO_PCI_DEVICEID_MIN ||
 219             pci_get_device(dev) > VIRTIO_PCI_DEVICEID_MAX)
 220                 return (ENXIO);
 221
 222         if (pci_get_revid(dev) != VIRTIO_PCI_ABI_VERSION)
 223                 return (ENXIO);
 224
 225         name = virtio_device_name(pci_get_subdevice(dev));
 226         if (name == NULL)
 227                 name = "Unknown";
 228
 229         ksnprintf(desc, sizeof(desc), "VirtIO PCI %s adapter", name);
 230         device_set_desc_copy(dev, desc);
 231
 232         return (BUS_PROBE_DEFAULT);
 233 }
 234
 235 static int
 236 vtpci_attach(device_t dev)
 237 {
 238         struct vtpci_softc *sc;
 239         device_t child;
 240         int rid;
 241
 242         sc = device_get_softc(dev);
 243         sc->vtpci_dev = dev;
 244
 245         pci_enable_busmaster(dev);
 246
 247         rid = PCIR_BAR(0);
 248         sc->vtpci_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
 249             RF_ACTIVE);
 250         if (sc->vtpci_res == NULL) {
 251                 device_printf(dev, "cannot map I/O space\n");
 252                 return (ENXIO);
 253         }
 254
 255         if (pci_find_extcap(dev, PCIY_MSI, NULL) != 0)
 256                 sc->vtpci_flags |= VIRTIO_PCI_FLAG_NO_MSI;
 257         /* XXX(vsrinivas): Check out how to get MSI-X */
 258 #if OLD_MSI
 259         if (pci_find_extcap(dev, PCIY_MSIX, NULL) == 0) {
 260                 rid = PCIR_BAR(1);
 261                 sc->vtpci_msix_res = bus_alloc_resource_any(dev,
 262                     SYS_RES_MEMORY, &rid, RF_ACTIVE);
 263         }
 264 #endif
 265         if (sc->vtpci_msix_res == NULL)
 266                 sc->vtpci_flags |= VIRTIO_PCI_FLAG_NO_MSIX;
 267
 268         vtpci_reset(sc);
 269
 270         /* Tell the host we've noticed this device. */
 271         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
 272
 273         if ((child = device_add_child(dev, NULL, -1)) == NULL) {
 274                 device_printf(dev, "cannot create child device\n");
 275                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
 276                 vtpci_detach(dev);
 277                 return (ENOMEM);
 278         }
 279
 280         sc->vtpci_child_dev = child;
 281         vtpci_probe_and_attach_child(sc);
 282
 283         return (0);
 284 }
 285
 286 static int
 287 vtpci_detach(device_t dev)
 288 {
 289         struct vtpci_softc *sc;
 290         device_t child;
 291         int error;
 292
 293         sc = device_get_softc(dev);
 294
 295         if ((child = sc->vtpci_child_dev) != NULL) {
 296                 error = device_delete_child(dev, child);
 297                 if (error)
 298                         return (error);
 299                 sc->vtpci_child_dev = NULL;
 300         }
 301
 302         vtpci_reset(sc);
 303
 304         if (sc->vtpci_msix_res != NULL) {
 305                 bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(1),
 306                     sc->vtpci_msix_res);
 307                 sc->vtpci_msix_res = NULL;
 308         }
 309
 310         if (sc->vtpci_res != NULL) {
 311                 bus_release_resource(dev, SYS_RES_IOPORT, PCIR_BAR(0),
 312                     sc->vtpci_res);
 313                 sc->vtpci_res = NULL;
 314         }
 315
 316         return (0);
 317 }
 318
 319 static int
 320 vtpci_suspend(device_t dev)
 321 {
 322
 323         return (bus_generic_suspend(dev));
 324 }
 325
 326 static int
 327 vtpci_resume(device_t dev)
 328 {
 329
 330         return (bus_generic_resume(dev));
 331 }
 332
 333 static int
 334 vtpci_shutdown(device_t dev)
 335 {
 336
 337         (void) bus_generic_shutdown(dev);
 338         /* Forcibly stop the host device. */
 339         vtpci_stop(dev);
 340
 341         return (0);
 342 }
 343
 344 static void
 345 vtpci_driver_added(device_t dev, driver_t *driver)
 346 {
 347         struct vtpci_softc *sc;
 348
 349         sc = device_get_softc(dev);
 350
 351         vtpci_probe_and_attach_child(sc);
 352 }
 353
 354 static void
 355 vtpci_child_detached(device_t dev, device_t child)
 356 {
 357         struct vtpci_softc *sc;
 358
 359         sc = device_get_softc(dev);
 360
 361         vtpci_reset(sc);
 362         vtpci_release_child_resources(sc);
 363 }
 364
 365 static int
 366 vtpci_read_ivar(device_t dev, device_t child, int index, uintptr_t *result)
 367 {
 368         struct vtpci_softc *sc;
 369
 370         sc = device_get_softc(dev);
 371
 372         if (sc->vtpci_child_dev != child)
 373                 return (ENOENT);
 374
 375         switch (index) {
 376         case VIRTIO_IVAR_DEVTYPE:
 377                 *result = pci_get_subdevice(dev);
 378                 break;
 379         default:
 380                 return (ENOENT);
 381         }
 382
 383         return (0);
 384 }
 385
 386 static int
 387 vtpci_write_ivar(device_t dev, device_t child, int index, uintptr_t value)
 388 {
 389         struct vtpci_softc *sc;
 390
 391         sc = device_get_softc(dev);
 392
 393         if (sc->vtpci_child_dev != child)
 394                 return (ENOENT);
 395
 396         switch (index) {
 397         case VIRTIO_IVAR_FEATURE_DESC:
 398                 sc->vtpci_child_feat_desc = (void *) value;
 399                 break;
 400         default:
 401                 return (ENOENT);
 402         }
 403
 404         return (0);
 405 }
 406
 407 static uint64_t
 408 vtpci_negotiate_features(device_t dev, uint64_t child_features)
 409 {
 410         struct vtpci_softc *sc;
 411         uint64_t host_features, features;
 412
 413         sc = device_get_softc(dev);
 414
 415         host_features = vtpci_read_config_4(sc, VIRTIO_PCI_HOST_FEATURES);
 416         vtpci_describe_features(sc, "host", host_features);
 417
 418         /*
 419          * Limit negotiated features to what the driver, virtqueue, and
 420          * host all support.
 421          */
 422         features = host_features & child_features;
 423         features = virtqueue_filter_features(features);
 424         sc->vtpci_features = features;
 425
 426         vtpci_describe_features(sc, "negotiated", features);
 427         vtpci_write_config_4(sc, VIRTIO_PCI_GUEST_FEATURES, features);
 428
 429         return (features);
 430 }
 431
 432 static int
 433 vtpci_with_feature(device_t dev, uint64_t feature)
 434 {
 435         struct vtpci_softc *sc;
 436
 437         sc = device_get_softc(dev);
 438
 439         return ((sc->vtpci_features & feature) != 0);
 440 }
 441
 442 static int
 443 vtpci_alloc_virtqueues(device_t dev, int flags, int nvqs,
 444     struct vq_alloc_info *vq_info)
 445 {
 446         struct vtpci_softc *sc;
 447         struct vtpci_virtqueue *vqx;
 448         struct vq_alloc_info *info;
 449         int queue, error;
 450         uint16_t vq_size;
 451
 452         sc = device_get_softc(dev);
 453
 454         if (sc->vtpci_nvqs != 0 || nvqs <= 0 ||
 455             nvqs > VIRTIO_MAX_VIRTQUEUES)
 456                 return (EINVAL);
 457
 458         error = vtpci_alloc_interrupts(sc, flags, nvqs, vq_info);
 459         if (error) {
 460                 device_printf(dev, "cannot allocate interrupts\n");
 461                 return (error);
 462         }
 463
 464         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
 465                 error = vtpci_register_msix_vector(sc,
 466                     VIRTIO_MSI_CONFIG_VECTOR, 0);
 467                 if (error)
 468                         return (error);
 469         }
 470
 471         for (queue = 0; queue < nvqs; queue++) {
 472                 vqx = &sc->vtpci_vqx[queue];
 473                 info = &vq_info[queue];
 474
 475                 vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);
 476
 477                 vq_size = vtpci_read_config_2(sc, VIRTIO_PCI_QUEUE_NUM);
 478                 error = virtqueue_alloc(dev, queue, vq_size,
 479                     VIRTIO_PCI_VRING_ALIGN, 0xFFFFFFFFUL, info, &vqx->vq);
 480                 if (error)
 481                         return (error);
 482
 483                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
 484                         error = vtpci_register_msix_vector(sc,
 485                             VIRTIO_MSI_QUEUE_VECTOR, vqx->ires_idx);
 486                         if (error)
 487                                 return (error);
 488                 }
 489
 490                 vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN,
 491                     virtqueue_paddr(vqx->vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT);
 492
 493                 *info->vqai_vq = vqx->vq;
 494                 sc->vtpci_nvqs++;
 495         }
 496
 497         return (0);
 498 }
 499
 500 static int
 501 vtpci_setup_intr(device_t dev)
 502 {
 503         struct vtpci_softc *sc;
 504         struct vtpci_intr_resource *ires;
 505         struct vtpci_virtqueue *vqx;
 506         int i, flags, error;
 507
 508         sc = device_get_softc(dev);
 509         flags = INTR_MPSAFE;
 510         ires = &sc->vtpci_intr_res[0];
 511
 512         if ((sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) == 0) {
 513                 error = bus_setup_intr(dev, ires->irq, flags,
 514                 (driver_intr_t *)    vtpci_legacy_intr, sc, &ires->intrhand, NULL);
 515
 516                 return (error);
 517         }
 518
 519         error = bus_setup_intr(dev, ires->irq, flags,(driver_intr_t *) vtpci_config_intr,
 520              sc, &ires->intrhand, NULL);
 521         if (error)
 522                 return (error);
 523
 524         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX) {
 525                 ires = &sc->vtpci_intr_res[1];
 526                 error = bus_setup_intr(dev, ires->irq, flags,
 527                  (driver_intr_t *)   vtpci_vq_shared_intr, sc, &ires->intrhand, NULL);
 528
 529                 return (error);
 530         }
 531
 532         /* Setup an interrupt handler for each virtqueue. */
 533         for (i = 0; i < sc->vtpci_nvqs; i++) {
 534                 vqx = &sc->vtpci_vqx[i];
 535                 if (vqx->ires_idx < 1)
 536                         continue;
 537
 538                 ires = &sc->vtpci_intr_res[vqx->ires_idx];
 539                 error = bus_setup_intr(dev, ires->irq, flags,
 540                   (driver_intr_t *)  vtpci_vq_intr, vqx->vq, &ires->intrhand, NULL);
 541                 if (error)
 542                         return (error);
 543         }
 544
 545         return (0);
 546 }
 547
 548 static void
 549 vtpci_stop(device_t dev)
 550 {
 551
 552         vtpci_reset(device_get_softc(dev));
 553 }
 554
 555 static int
 556 vtpci_reinit(device_t dev, uint64_t features)
 557 {
 558         struct vtpci_softc *sc;
 559         struct vtpci_virtqueue *vqx;
 560         struct virtqueue *vq;
 561         int queue, error;
 562         uint16_t vq_size;
 563
 564         sc = device_get_softc(dev);
 565
 566         /*
 567          * Redrive the device initialization. This is a bit of an abuse
 568          * of the specification, but both VirtualBox and QEMU/KVM seem
 569          * to play nice. We do not allow the host device to change from
 570          * what was originally negotiated beyond what the guest driver
 571          * changed (MSIX state should not change, number of virtqueues
 572          * and their size remain the same, etc).
 573          */
 574
 575         if (vtpci_get_status(dev) != VIRTIO_CONFIG_STATUS_RESET)
 576                 vtpci_stop(dev);
 577
 578         /*
 579          * Quickly drive the status through ACK and DRIVER. The device
 580          * does not become usable again until vtpci_reinit_complete().
 581          */
 582         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
 583         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
 584
 585         vtpci_negotiate_features(dev, features);
 586
 587         if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
 588                 error = vtpci_register_msix_vector(sc,
 589                     VIRTIO_MSI_CONFIG_VECTOR, 0);
 590                 if (error)
 591                         return (error);
 592         }
 593
 594         for (queue = 0; queue < sc->vtpci_nvqs; queue++) {
 595                 vqx = &sc->vtpci_vqx[queue];
 596                 vq = vqx->vq;
 597
 598                 KASSERT(vq != NULL, ("vq %d not allocated", queue));
 599                 vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_SEL, queue);
 600
 601                 vq_size = vtpci_read_config_2(sc, VIRTIO_PCI_QUEUE_NUM);
 602                 error = virtqueue_reinit(vq, vq_size);
 603                 if (error)
 604                         return (error);
 605
 606                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
 607                         error = vtpci_register_msix_vector(sc,
 608                             VIRTIO_MSI_QUEUE_VECTOR, vqx->ires_idx);
 609                         if (error)
 610                                 return (error);
 611                 }
 612
 613                 vtpci_write_config_4(sc, VIRTIO_PCI_QUEUE_PFN,
 614                     virtqueue_paddr(vqx->vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT);
 615         }
 616
 617         return (0);
 618 }
 619
 620 static void
 621 vtpci_reinit_complete(device_t dev)
 622 {
 623
 624         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
 625 }
 626
 627 static void
 628 vtpci_notify_virtqueue(device_t dev, uint16_t queue)
 629 {
 630         struct vtpci_softc *sc;
 631
 632         sc = device_get_softc(dev);
 633
 634         vtpci_write_config_2(sc, VIRTIO_PCI_QUEUE_NOTIFY, queue);
 635 }
 636
 637 static uint8_t
 638 vtpci_get_status(device_t dev)
 639 {
 640         struct vtpci_softc *sc;
 641
 642         sc = device_get_softc(dev);
 643
 644         return (vtpci_read_config_1(sc, VIRTIO_PCI_STATUS));
 645 }
 646
 647 static void
 648 vtpci_set_status(device_t dev, uint8_t status)
 649 {
 650         struct vtpci_softc *sc;
 651
 652         sc = device_get_softc(dev);
 653
 654         if (status != VIRTIO_CONFIG_STATUS_RESET)
 655                 status |= vtpci_get_status(dev);
 656
 657         vtpci_write_config_1(sc, VIRTIO_PCI_STATUS, status);
 658 }
 659
 660 static void
 661 vtpci_read_dev_config(device_t dev, bus_size_t offset,
 662     void *dst, int length)
 663 {
 664         struct vtpci_softc *sc;
 665         bus_size_t off;
 666         uint8_t *d;
 667         int size;
 668
 669         sc = device_get_softc(dev);
 670         off = VIRTIO_PCI_CONFIG(sc) + offset;
 671
 672         for (d = dst; length > 0; d += size, off += size, length -= size) {
 673                 if (length >= 4) {
 674                         size = 4;
 675                         *(uint32_t *)d = vtpci_read_config_4(sc, off);
 676                 } else if (length >= 2) {
 677                         size = 2;
 678                         *(uint16_t *)d = vtpci_read_config_2(sc, off);
 679                 } else {
 680                         size = 1;
 681                         *d = vtpci_read_config_1(sc, off);
 682                 }
 683         }
 684 }
 685
 686 static void
 687 vtpci_write_dev_config(device_t dev, bus_size_t offset,
 688     void *src, int length)
 689 {
 690         struct vtpci_softc *sc;
 691         bus_size_t off;
 692         uint8_t *s;
 693         int size;
 694
 695         sc = device_get_softc(dev);
 696         off = VIRTIO_PCI_CONFIG(sc) + offset;
 697
 698         for (s = src; length > 0; s += size, off += size, length -= size) {
 699                 if (length >= 4) {
 700                         size = 4;
 701                         vtpci_write_config_4(sc, off, *(uint32_t *)s);
 702                 } else if (length >= 2) {
 703                         size = 2;
 704                         vtpci_write_config_2(sc, off, *(uint16_t *)s);
 705                 } else {
 706                         size = 1;
 707                         vtpci_write_config_1(sc, off, *s);
 708                 }
 709         }
 710 }
 711
 712 static void
 713 vtpci_describe_features(struct vtpci_softc *sc, const char *msg,
 714     uint64_t features)
 715 {
 716         device_t dev, child;
 717
 718         dev = sc->vtpci_dev;
 719         child = sc->vtpci_child_dev;
 720
 721         if (device_is_attached(child) && bootverbose == 0)
 722                 return;
 723
 724         virtio_describe(dev, msg, features, sc->vtpci_child_feat_desc);
 725 }
 726
 727 static void
 728 vtpci_probe_and_attach_child(struct vtpci_softc *sc)
 729 {
 730         device_t dev, child;
 731
 732         dev = sc->vtpci_dev;
 733         child = sc->vtpci_child_dev;
 734
 735         if (child == NULL)
 736                 return;
 737
 738         if (device_get_state(child) != DS_NOTPRESENT)
 739                 return;
 740
 741         if (device_probe_child(dev, child) != 0)
 742                 return;
 743
 744         vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER);
 745         if (DEVICE_ATTACH(child) != 0) {
 746                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_FAILED);
 747                 vtpci_reset(sc);
 748                 vtpci_release_child_resources(sc);
 749
 750                 /* Reset status for future attempt. */
 751                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_ACK);
 752         } else
 753                 vtpci_set_status(dev, VIRTIO_CONFIG_STATUS_DRIVER_OK);
 754 }
 755
 756 static int
 757 vtpci_alloc_interrupts(struct vtpci_softc *sc, int flags, int nvqs,
 758     struct vq_alloc_info *vq_info)
 759 {
 760         int i, nvectors, error;
 761
 762         /*
 763          * Only allocate a vector for virtqueues that are actually
 764          * expecting an interrupt.
 765          */
 766         for (nvectors = 0, i = 0; i < nvqs; i++)
 767                 if (vq_info[i].vqai_intr != NULL)
 768                         nvectors++;
 769
 770         if (vtpci_disable_msix != 0 ||
 771             sc->vtpci_flags & VIRTIO_PCI_FLAG_NO_MSIX ||
 772             flags & VIRTIO_ALLOC_VQS_DISABLE_MSIX ||
 773             vtpci_alloc_msix(sc, nvectors) != 0) {
 774                 /*
 775                  * Use MSI interrupts if available. Otherwise, we fallback
 776                  * to legacy interrupts.
 777                  */
 778                 if ((sc->vtpci_flags & VIRTIO_PCI_FLAG_NO_MSI) == 0 &&
 779                     vtpci_alloc_msi(sc) == 0)
 780                         sc->vtpci_flags |= VIRTIO_PCI_FLAG_MSI;
 781
 782                 sc->vtpci_nintr_res = 1;
 783         }
 784
 785         error = vtpci_alloc_intr_resources(sc, nvqs, vq_info);
 786
 787         return (error);
 788 }
 789
 790 static int
 791 vtpci_alloc_intr_resources(struct vtpci_softc *sc, int nvqs,
 792     struct vq_alloc_info *vq_info)
 793 {
 794         device_t dev;
 795         struct resource *irq;
 796         struct vtpci_virtqueue *vqx;
 797         int i, rid, flags, res_idx;
 798
 799         dev = sc->vtpci_dev;
 800         flags = RF_ACTIVE;
 801
 802         if ((sc->vtpci_flags &
 803             (VIRTIO_PCI_FLAG_MSI | VIRTIO_PCI_FLAG_MSIX)) == 0) {
 804                 rid = 0;
 805                 flags |= RF_SHAREABLE;
 806         } else
 807                 rid = 1;
 808
 809         for (i = 0; i < sc->vtpci_nintr_res; i++) {
 810                 irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, flags);
 811                 if (irq == NULL)
 812                         return (ENXIO);
 813
 814                 sc->vtpci_intr_res[i].irq = irq;
 815                 sc->vtpci_intr_res[i].rid = rid++;
 816         }
 817
 818         /*
 819          * Map the virtqueue into the correct index in vq_intr_res[]. Note the
 820          * first index is reserved for configuration changes notifications.
 821          */
 822         for (i = 0, res_idx = 1; i < nvqs; i++) {
 823                 vqx = &sc->vtpci_vqx[i];
 824
 825                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_MSIX) {
 826                         if (vq_info[i].vqai_intr == NULL)
 827                                 vqx->ires_idx = -1;
 828                         else if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX)
 829                                 vqx->ires_idx = res_idx;
 830                         else
 831                                 vqx->ires_idx = res_idx++;
 832                 } else
 833                         vqx->ires_idx = -1;
 834         }
 835
 836         return (0);
 837 }
 838
 839 static int
 840 vtpci_alloc_msi(struct vtpci_softc *sc)
 841 {
 842         device_t dev;
 843         int nmsi;
 844         u_int irq_flags;
 845
 846         dev = sc->vtpci_dev;
 847         nmsi = pci_msi_count(dev);
 848
 849         if (nmsi < 1)
 850                 return (1);
 851
 852         sc->vtpci_irq_rid = 0;
 853         sc->vtpci_irq_type = pci_alloc_1intr(dev, 1,
 854             &sc->vtpci_irq_rid, &irq_flags);
 855
 856
 857         return (1);
 858 }
 859
 860 static int
 861 vtpci_alloc_msix(struct vtpci_softc *sc, int nvectors)
 862 {
 863         /* XXX(vsrinivas): Huh? Is this how MSI-X works?*/
 864         /* XXX(vsrinivas): All of this was disabled... */
 865 #ifdef OLD_MSI
 866         device_t dev;
 867         int nmsix, cnt, required;
 868
 869         dev = sc->vtpci_dev;
 870
 871         nmsix = pci_msix_count(dev);
 872         if (nmsix < 1)
 873                 return (1);
 874
 875         /* An additional vector is needed for the config changes. */
 876         required = nvectors + 1;
 877         if (nmsix >= required) {
 878                 cnt = required;
 879                 if (pci_alloc_msix(dev, &cnt) == 0 && cnt >= required)
 880                         goto out;
 881
 882                 pci_release_msi(dev);
 883         }
 884
 885         /* Attempt shared MSIX configuration. */
 886         required = 2;
 887         if (nmsix >= required) {
 888                 cnt = required;
 889                 if (pci_alloc_msix(dev, &cnt) == 0 && cnt >= required) {
 890                         sc->vtpci_flags |= VIRTIO_PCI_FLAG_SHARED_MSIX;
 891                         goto out;
 892                 }
 893
 894                 pci_release_msi(dev);
 895         }
 896
 897         return (1);
 898
 899 out:
 900         sc->vtpci_nintr_res = required;
 901         sc->vtpci_flags |= VIRTIO_PCI_FLAG_MSIX;
 902
 903         if (bootverbose) {
 904                 if (sc->vtpci_flags & VIRTIO_PCI_FLAG_SHARED_MSIX)
 905                         device_printf(dev, "using shared virtqueue MSIX\n");
 906                 else
 907                         device_printf(dev, "using per virtqueue MSIX\n");
 908         }
 909 #endif
 910         return (0);
 911 }
 912
 913 static int
 914 vtpci_register_msix_vector(struct vtpci_softc *sc, int offset, int res_idx)
 915 {
 916         device_t dev;
 917         uint16_t vector;
 918
 919         dev = sc->vtpci_dev;
 920
 921         if (offset != VIRTIO_MSI_CONFIG_VECTOR &&
 922             offset != VIRTIO_MSI_QUEUE_VECTOR)
 923                 return (EINVAL);
 924
 925         if (res_idx != -1) {
 926                 /* Map from rid to host vector. */
 927                 vector = sc->vtpci_intr_res[res_idx].rid - 1;
 928         } else
 929                 vector = VIRTIO_MSI_NO_VECTOR;
 930
 931         /* The first resource is special; make sure it is used correctly. */
 932         if (res_idx == 0) {
 933                 KASSERT(vector == 0, ("unexpected config vector"));
 934                 KASSERT(offset == VIRTIO_MSI_CONFIG_VECTOR,
 935                     ("unexpected config offset"));
 936         }
 937
 938         vtpci_write_config_2(sc, offset, vector);
 939
 940         if (vtpci_read_config_2(sc, offset) != vector) {
 941                 device_printf(dev, "insufficient host resources for "
 942                     "MSIX interrupts\n");
 943                 return (ENODEV);
 944         }
 945
 946         return (0);
 947 }
 948
 949 static void
 950 vtpci_free_interrupts(struct vtpci_softc *sc)
 951 {
 952         device_t dev;
 953         struct vtpci_intr_resource *ires;
 954         int i;
 955
 956         dev = sc->vtpci_dev;
 957         sc->vtpci_nintr_res = 0;
 958
 959         if (sc->vtpci_flags & (VIRTIO_PCI_FLAG_MSI | VIRTIO_PCI_FLAG_MSIX)) {
 960                 pci_release_msi(dev);
 961                 sc->vtpci_flags &= ~(VIRTIO_PCI_FLAG_MSI |
 962                     VIRTIO_PCI_FLAG_MSIX | VIRTIO_PCI_FLAG_SHARED_MSIX);
 963         }
 964
 965         for (i = 0; i < 1 + VIRTIO_MAX_VIRTQUEUES; i++) {
 966                 ires = &sc->vtpci_intr_res[i];
 967
 968                 if (ires->intrhand != NULL) {
 969                         bus_teardown_intr(dev, ires->irq, ires->intrhand);
 970                         ires->intrhand = NULL;
 971                 }
 972
 973                 if (ires->irq != NULL) {
 974                         bus_release_resource(dev, SYS_RES_IRQ, ires->rid,
 975                             ires->irq);
 976                         ires->irq = NULL;
 977                 }
 978
 979                 ires->rid = -1;
 980         }
 981 }
 982
 983 static void
 984 vtpci_free_virtqueues(struct vtpci_softc *sc)
 985 {
 986         struct vtpci_virtqueue *vqx;
 987         int i;
 988
 989         sc->vtpci_nvqs = 0;
 990
 991         for (i = 0; i < VIRTIO_MAX_VIRTQUEUES; i++) {
 992                 vqx = &sc->vtpci_vqx[i];
 993
 994                 if (vqx->vq != NULL) {
 995                         virtqueue_free(vqx->vq);
 996                         vqx->vq = NULL;
 997                 }
 998         }
 999 }
1000
1001 static void
1002 vtpci_release_child_resources(struct vtpci_softc *sc)
1003 {
1004
1005         vtpci_free_interrupts(sc);
1006         vtpci_free_virtqueues(sc);
1007 }
1008
1009 static void
1010 vtpci_reset(struct vtpci_softc *sc)
1011 {
1012
1013         /*
1014          * Setting the status to RESET sets the host device to
1015          * the original, uninitialized state.
1016          */
1017         vtpci_set_status(sc->vtpci_dev, VIRTIO_CONFIG_STATUS_RESET);
1018 }
1019
1020 static int
1021 vtpci_legacy_intr(void *xsc)
1022 {
1023         struct vtpci_softc *sc;
1024         struct vtpci_virtqueue *vqx;
1025         int i;
1026         uint8_t isr;
1027
1028         sc = xsc;
1029         vqx = &sc->vtpci_vqx[0];
1030
1031         /* Reading the ISR also clears it. */
1032         isr = vtpci_read_config_1(sc, VIRTIO_PCI_ISR);
1033
1034         if (isr & VIRTIO_PCI_ISR_CONFIG)
1035                 vtpci_config_intr(sc);
1036
1037         if (isr & VIRTIO_PCI_ISR_INTR)
1038                 for (i = 0; i < sc->vtpci_nvqs; i++, vqx++)
1039                         virtqueue_intr(vqx->vq);
1040
1041         return isr;
1042 }
1043
1044 static int
1045 vtpci_vq_shared_intr(void *xsc)
1046 {
1047         struct vtpci_softc *sc;
1048         struct vtpci_virtqueue *vqx;
1049         int i, rc;
1050
1051         rc = 0;
1052         sc = xsc;
1053         vqx = &sc->vtpci_vqx[0];
1054
1055         for (i = 0; i < sc->vtpci_nvqs; i++, vqx++)
1056                 rc |= virtqueue_intr(vqx->vq);
1057
1058         return rc;
1059 }
1060
1061 static int
1062 vtpci_vq_intr(void *xvq)
1063 {
1064         struct virtqueue *vq;
1065         int rc;
1066
1067         vq = xvq;
1068         rc = virtqueue_intr(vq);
1069
1070         return rc;
1071 }
1072
1073 static int
1074 vtpci_config_intr(void *xsc)
1075 {
1076         struct vtpci_softc *sc;
1077         device_t child;
1078         int rc;
1079
1080         rc = 0;
1081         sc = xsc;
1082         child = sc->vtpci_child_dev;
1083
1084         if (child != NULL)
1085                 rc = VIRTIO_CONFIG_CHANGE(child);
1086
1087         return rc;
1088 }