1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2011, Bryan Venteicher <bryanv@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice unmodified, this list of conditions, and the following 12 * disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /* Driver for the legacy VirtIO PCI interface. */ 30 31 #include <sys/cdefs.h> 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/bus.h> 35 #include <sys/lock.h> 36 #include <sys/kernel.h> 37 #include <sys/module.h> 38 #include <sys/endian.h> 39 40 #include <machine/bus.h> 41 #include <machine/resource.h> 42 #include <sys/bus.h> 43 #include <sys/rman.h> 44 45 #include <dev/pci/pcivar.h> 46 #include <dev/pci/pcireg.h> 47 48 #include <dev/virtio/virtio.h> 49 #include <dev/virtio/virtqueue.h> 50 #include <dev/virtio/pci/virtio_pci.h> 51 #include <dev/virtio/pci/virtio_pci_legacy_var.h> 52 53 #include "virtio_bus_if.h" 54 #include "virtio_pci_if.h" 55 #include "virtio_if.h" 56 57 struct vtpci_legacy_softc { 58 device_t vtpci_dev; 59 struct vtpci_common vtpci_common; 60 int vtpci_res_type; 61 struct resource *vtpci_res; 62 struct resource *vtpci_msix_table_res; 63 struct resource *vtpci_msix_pba_res; 64 }; 65 66 static int vtpci_legacy_probe(device_t); 67 static int vtpci_legacy_attach(device_t); 68 static int vtpci_legacy_detach(device_t); 69 static int vtpci_legacy_suspend(device_t); 70 static int vtpci_legacy_resume(device_t); 71 static int vtpci_legacy_shutdown(device_t); 72 73 static void vtpci_legacy_driver_added(device_t, driver_t *); 74 static void vtpci_legacy_child_detached(device_t, device_t); 75 static int vtpci_legacy_read_ivar(device_t, device_t, int, uintptr_t *); 76 static int vtpci_legacy_write_ivar(device_t, device_t, int, uintptr_t); 77 78 static uint8_t vtpci_legacy_read_isr(device_t); 79 static uint16_t vtpci_legacy_get_vq_size(device_t, int); 80 static bus_size_t vtpci_legacy_get_vq_notify_off(device_t, int); 81 static void vtpci_legacy_set_vq(device_t, struct virtqueue *); 82 static void vtpci_legacy_disable_vq(device_t, int); 83 static int vtpci_legacy_register_cfg_msix(device_t, 84 struct vtpci_interrupt *); 85 static int vtpci_legacy_register_vq_msix(device_t, int idx, 86 struct vtpci_interrupt *); 87 88 static uint64_t vtpci_legacy_negotiate_features(device_t, uint64_t); 89 static int vtpci_legacy_with_feature(device_t, uint64_t); 90 static int vtpci_legacy_alloc_virtqueues(device_t, int, int, 91 struct vq_alloc_info *); 92 static int vtpci_legacy_setup_interrupts(device_t, enum intr_type); 93 static void vtpci_legacy_stop(device_t); 94 static int vtpci_legacy_reinit(device_t, uint64_t); 95 static void vtpci_legacy_reinit_complete(device_t); 96 static void vtpci_legacy_notify_vq(device_t, uint16_t, bus_size_t); 97 static void vtpci_legacy_read_dev_config(device_t, bus_size_t, void *, int); 98 static void vtpci_legacy_write_dev_config(device_t, bus_size_t, const void *, int); 99 100 static bool vtpci_legacy_setup_msix(struct vtpci_legacy_softc *sc); 101 static void vtpci_legacy_teardown_msix(struct vtpci_legacy_softc *sc); 102 static int vtpci_legacy_alloc_resources(struct vtpci_legacy_softc *); 103 static void vtpci_legacy_free_resources(struct vtpci_legacy_softc *); 104 105 static void vtpci_legacy_probe_and_attach_child(struct vtpci_legacy_softc *); 106 107 static uint8_t vtpci_legacy_get_status(struct vtpci_legacy_softc *); 108 static void vtpci_legacy_set_status(struct vtpci_legacy_softc *, uint8_t); 109 static void vtpci_legacy_select_virtqueue(struct vtpci_legacy_softc *, int); 110 static void vtpci_legacy_reset(struct vtpci_legacy_softc *); 111 112 #define VIRTIO_PCI_LEGACY_CONFIG(_sc) \ 113 VIRTIO_PCI_CONFIG_OFF(vtpci_is_msix_enabled(&(_sc)->vtpci_common)) 114 115 #define vtpci_legacy_read_config_1(sc, o) \ 116 bus_read_1((sc)->vtpci_res, (o)) 117 #define vtpci_legacy_write_config_1(sc, o, v) \ 118 bus_write_1((sc)->vtpci_res, (o), (v)) 119 /* 120 * VirtIO specifies that PCI Configuration area is guest endian. However, 121 * since PCI devices are inherently little-endian, on big-endian systems 122 * the bus layer transparently converts it to BE. For virtio-legacy, this 123 * conversion is undesired, so an extra byte swap is required to fix it. 124 */ 125 #define vtpci_legacy_read_config_2(sc, o) \ 126 le16toh(bus_read_2((sc)->vtpci_res, (o))) 127 #define vtpci_legacy_read_config_4(sc, o) \ 128 le32toh(bus_read_4((sc)->vtpci_res, (o))) 129 #define vtpci_legacy_write_config_2(sc, o, v) \ 130 bus_write_2((sc)->vtpci_res, (o), (htole16(v))) 131 #define vtpci_legacy_write_config_4(sc, o, v) \ 132 bus_write_4((sc)->vtpci_res, (o), (htole32(v))) 133 /* PCI Header LE. On BE systems the bus layer takes care of byte swapping. */ 134 #define vtpci_legacy_read_header_2(sc, o) \ 135 bus_read_2((sc)->vtpci_res, (o)) 136 #define vtpci_legacy_read_header_4(sc, o) \ 137 bus_read_4((sc)->vtpci_res, (o)) 138 #define vtpci_legacy_write_header_2(sc, o, v) \ 139 bus_write_2((sc)->vtpci_res, (o), (v)) 140 #define vtpci_legacy_write_header_4(sc, o, v) \ 141 bus_write_4((sc)->vtpci_res, (o), (v)) 142 143 static device_method_t vtpci_legacy_methods[] = { 144 /* Device interface. */ 145 DEVMETHOD(device_probe, vtpci_legacy_probe), 146 DEVMETHOD(device_attach, vtpci_legacy_attach), 147 DEVMETHOD(device_detach, vtpci_legacy_detach), 148 DEVMETHOD(device_suspend, vtpci_legacy_suspend), 149 DEVMETHOD(device_resume, vtpci_legacy_resume), 150 DEVMETHOD(device_shutdown, vtpci_legacy_shutdown), 151 152 /* Bus interface. */ 153 DEVMETHOD(bus_driver_added, vtpci_legacy_driver_added), 154 DEVMETHOD(bus_child_detached, vtpci_legacy_child_detached), 155 DEVMETHOD(bus_child_pnpinfo, virtio_child_pnpinfo), 156 DEVMETHOD(bus_read_ivar, vtpci_legacy_read_ivar), 157 DEVMETHOD(bus_write_ivar, vtpci_legacy_write_ivar), 158 159 /* VirtIO PCI interface. */ 160 DEVMETHOD(virtio_pci_read_isr, vtpci_legacy_read_isr), 161 DEVMETHOD(virtio_pci_get_vq_size, vtpci_legacy_get_vq_size), 162 DEVMETHOD(virtio_pci_get_vq_notify_off, vtpci_legacy_get_vq_notify_off), 163 DEVMETHOD(virtio_pci_set_vq, vtpci_legacy_set_vq), 164 DEVMETHOD(virtio_pci_disable_vq, vtpci_legacy_disable_vq), 165 DEVMETHOD(virtio_pci_register_cfg_msix, vtpci_legacy_register_cfg_msix), 166 DEVMETHOD(virtio_pci_register_vq_msix, vtpci_legacy_register_vq_msix), 167 168 /* VirtIO bus interface. */ 169 DEVMETHOD(virtio_bus_negotiate_features, vtpci_legacy_negotiate_features), 170 DEVMETHOD(virtio_bus_with_feature, vtpci_legacy_with_feature), 171 DEVMETHOD(virtio_bus_alloc_virtqueues, vtpci_legacy_alloc_virtqueues), 172 DEVMETHOD(virtio_bus_setup_intr, vtpci_legacy_setup_interrupts), 173 DEVMETHOD(virtio_bus_stop, vtpci_legacy_stop), 174 DEVMETHOD(virtio_bus_reinit, vtpci_legacy_reinit), 175 DEVMETHOD(virtio_bus_reinit_complete, vtpci_legacy_reinit_complete), 176 DEVMETHOD(virtio_bus_notify_vq, vtpci_legacy_notify_vq), 177 DEVMETHOD(virtio_bus_read_device_config, vtpci_legacy_read_dev_config), 178 DEVMETHOD(virtio_bus_write_device_config, vtpci_legacy_write_dev_config), 179 180 DEVMETHOD_END 181 }; 182 183 static driver_t vtpci_legacy_driver = { 184 .name = "virtio_pci", 185 .methods = vtpci_legacy_methods, 186 .size = sizeof(struct vtpci_legacy_softc) 187 }; 188 189 DRIVER_MODULE(virtio_pci_legacy, pci, vtpci_legacy_driver, 0, 0); 190 191 static int 192 vtpci_legacy_probe(device_t dev) 193 { 194 char desc[64]; 195 const char *name; 196 197 if (pci_get_vendor(dev) != VIRTIO_PCI_VENDORID) 198 return (ENXIO); 199 200 if (pci_get_device(dev) < VIRTIO_PCI_DEVICEID_MIN || 201 pci_get_device(dev) > VIRTIO_PCI_DEVICEID_LEGACY_MAX) 202 return (ENXIO); 203 204 if (pci_get_revid(dev) != VIRTIO_PCI_ABI_VERSION) 205 return (ENXIO); 206 207 name = virtio_device_name(pci_get_subdevice(dev)); 208 if (name == NULL) 209 name = "Unknown"; 210 211 snprintf(desc, sizeof(desc), "VirtIO PCI (legacy) %s adapter", name); 212 device_set_desc_copy(dev, desc); 213 214 /* Prefer transitional modern VirtIO PCI. */ 215 return (BUS_PROBE_LOW_PRIORITY); 216 } 217 218 static int 219 vtpci_legacy_attach(device_t dev) 220 { 221 struct vtpci_legacy_softc *sc; 222 int error; 223 224 sc = device_get_softc(dev); 225 sc->vtpci_dev = dev; 226 vtpci_init(&sc->vtpci_common, dev, false); 227 228 error = vtpci_legacy_alloc_resources(sc); 229 if (error) { 230 device_printf(dev, "cannot map I/O space nor memory space\n"); 231 return (error); 232 } 233 234 if (vtpci_is_msix_available(&sc->vtpci_common) && 235 !vtpci_legacy_setup_msix(sc)) { 236 device_printf(dev, "cannot setup MSI-x resources\n"); 237 error = ENXIO; 238 goto fail; 239 } 240 241 vtpci_legacy_reset(sc); 242 243 /* Tell the host we've noticed this device. */ 244 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK); 245 246 error = vtpci_add_child(&sc->vtpci_common); 247 if (error) 248 goto fail; 249 250 vtpci_legacy_probe_and_attach_child(sc); 251 252 return (0); 253 254 fail: 255 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_FAILED); 256 vtpci_legacy_detach(dev); 257 258 return (error); 259 } 260 261 static int 262 vtpci_legacy_detach(device_t dev) 263 { 264 struct vtpci_legacy_softc *sc; 265 int error; 266 267 sc = device_get_softc(dev); 268 269 error = vtpci_delete_child(&sc->vtpci_common); 270 if (error) 271 return (error); 272 273 vtpci_legacy_reset(sc); 274 vtpci_legacy_teardown_msix(sc); 275 vtpci_legacy_free_resources(sc); 276 277 return (0); 278 } 279 280 static int 281 vtpci_legacy_suspend(device_t dev) 282 { 283 return (bus_generic_suspend(dev)); 284 } 285 286 static int 287 vtpci_legacy_resume(device_t dev) 288 { 289 return (bus_generic_resume(dev)); 290 } 291 292 static int 293 vtpci_legacy_shutdown(device_t dev) 294 { 295 (void) bus_generic_shutdown(dev); 296 /* Forcibly stop the host device. */ 297 vtpci_legacy_stop(dev); 298 299 return (0); 300 } 301 302 static void 303 vtpci_legacy_driver_added(device_t dev, driver_t *driver) 304 { 305 vtpci_legacy_probe_and_attach_child(device_get_softc(dev)); 306 } 307 308 static void 309 vtpci_legacy_child_detached(device_t dev, device_t child) 310 { 311 struct vtpci_legacy_softc *sc; 312 313 sc = device_get_softc(dev); 314 315 vtpci_legacy_reset(sc); 316 vtpci_child_detached(&sc->vtpci_common); 317 318 /* After the reset, retell the host we've noticed this device. */ 319 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK); 320 } 321 322 static int 323 vtpci_legacy_read_ivar(device_t dev, device_t child, int index, 324 uintptr_t *result) 325 { 326 struct vtpci_legacy_softc *sc; 327 struct vtpci_common *cn; 328 329 sc = device_get_softc(dev); 330 cn = &sc->vtpci_common; 331 332 if (vtpci_child_device(cn) != child) 333 return (ENOENT); 334 335 switch (index) { 336 case VIRTIO_IVAR_DEVTYPE: 337 *result = pci_get_subdevice(dev); 338 break; 339 default: 340 return (vtpci_read_ivar(cn, index, result)); 341 } 342 343 return (0); 344 } 345 346 static int 347 vtpci_legacy_write_ivar(device_t dev, device_t child, int index, uintptr_t value) 348 { 349 struct vtpci_legacy_softc *sc; 350 struct vtpci_common *cn; 351 352 sc = device_get_softc(dev); 353 cn = &sc->vtpci_common; 354 355 if (vtpci_child_device(cn) != child) 356 return (ENOENT); 357 358 switch (index) { 359 default: 360 return (vtpci_write_ivar(cn, index, value)); 361 } 362 363 return (0); 364 } 365 366 static uint64_t 367 vtpci_legacy_negotiate_features(device_t dev, uint64_t child_features) 368 { 369 struct vtpci_legacy_softc *sc; 370 uint64_t host_features, features; 371 372 sc = device_get_softc(dev); 373 host_features = vtpci_legacy_read_header_4(sc, VIRTIO_PCI_HOST_FEATURES); 374 375 features = vtpci_negotiate_features(&sc->vtpci_common, 376 child_features, host_features); 377 vtpci_legacy_write_header_4(sc, VIRTIO_PCI_GUEST_FEATURES, features); 378 379 return (features); 380 } 381 382 static int 383 vtpci_legacy_with_feature(device_t dev, uint64_t feature) 384 { 385 struct vtpci_legacy_softc *sc; 386 387 sc = device_get_softc(dev); 388 389 return (vtpci_with_feature(&sc->vtpci_common, feature)); 390 } 391 392 static int 393 vtpci_legacy_alloc_virtqueues(device_t dev, int flags, int nvqs, 394 struct vq_alloc_info *vq_info) 395 { 396 struct vtpci_legacy_softc *sc; 397 struct vtpci_common *cn; 398 399 sc = device_get_softc(dev); 400 cn = &sc->vtpci_common; 401 402 return (vtpci_alloc_virtqueues(cn, flags, nvqs, vq_info)); 403 } 404 405 static int 406 vtpci_legacy_setup_interrupts(device_t dev, enum intr_type type) 407 { 408 struct vtpci_legacy_softc *sc; 409 410 sc = device_get_softc(dev); 411 412 return (vtpci_setup_interrupts(&sc->vtpci_common, type)); 413 } 414 415 static void 416 vtpci_legacy_stop(device_t dev) 417 { 418 vtpci_legacy_reset(device_get_softc(dev)); 419 } 420 421 static int 422 vtpci_legacy_reinit(device_t dev, uint64_t features) 423 { 424 struct vtpci_legacy_softc *sc; 425 struct vtpci_common *cn; 426 int error; 427 428 sc = device_get_softc(dev); 429 cn = &sc->vtpci_common; 430 431 /* 432 * Redrive the device initialization. This is a bit of an abuse of 433 * the specification, but VirtualBox, QEMU/KVM, and BHyVe seem to 434 * play nice. 435 * 436 * We do not allow the host device to change from what was originally 437 * negotiated beyond what the guest driver changed. MSIX state should 438 * not change, number of virtqueues and their size remain the same, etc. 439 * This will need to be rethought when we want to support migration. 440 */ 441 442 if (vtpci_legacy_get_status(sc) != VIRTIO_CONFIG_STATUS_RESET) 443 vtpci_legacy_stop(dev); 444 445 /* 446 * Quickly drive the status through ACK and DRIVER. The device does 447 * not become usable again until DRIVER_OK in reinit complete. 448 */ 449 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_ACK); 450 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER); 451 452 vtpci_legacy_negotiate_features(dev, features); 453 454 error = vtpci_reinit(cn); 455 if (error) 456 return (error); 457 458 return (0); 459 } 460 461 static void 462 vtpci_legacy_reinit_complete(device_t dev) 463 { 464 struct vtpci_legacy_softc *sc; 465 466 sc = device_get_softc(dev); 467 468 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER_OK); 469 } 470 471 static void 472 vtpci_legacy_notify_vq(device_t dev, uint16_t queue, bus_size_t offset) 473 { 474 struct vtpci_legacy_softc *sc; 475 476 sc = device_get_softc(dev); 477 MPASS(offset == VIRTIO_PCI_QUEUE_NOTIFY); 478 479 vtpci_legacy_write_header_2(sc, offset, queue); 480 } 481 482 static uint8_t 483 vtpci_legacy_get_status(struct vtpci_legacy_softc *sc) 484 { 485 return (vtpci_legacy_read_config_1(sc, VIRTIO_PCI_STATUS)); 486 } 487 488 static void 489 vtpci_legacy_set_status(struct vtpci_legacy_softc *sc, uint8_t status) 490 { 491 if (status != VIRTIO_CONFIG_STATUS_RESET) 492 status |= vtpci_legacy_get_status(sc); 493 494 vtpci_legacy_write_config_1(sc, VIRTIO_PCI_STATUS, status); 495 } 496 497 static void 498 vtpci_legacy_read_dev_config(device_t dev, bus_size_t offset, 499 void *dst, int length) 500 { 501 struct vtpci_legacy_softc *sc; 502 bus_size_t off; 503 uint8_t *d; 504 int i; 505 506 sc = device_get_softc(dev); 507 off = VIRTIO_PCI_LEGACY_CONFIG(sc) + offset; 508 509 d = dst; 510 for (i = 0; i < length; i++) { 511 d[i] = vtpci_legacy_read_config_1(sc, off + i); 512 } 513 } 514 515 static void 516 vtpci_legacy_write_dev_config(device_t dev, bus_size_t offset, 517 const void *src, int length) 518 { 519 struct vtpci_legacy_softc *sc; 520 bus_size_t off; 521 const uint8_t *s; 522 int i; 523 524 sc = device_get_softc(dev); 525 off = VIRTIO_PCI_LEGACY_CONFIG(sc) + offset; 526 527 s = src; 528 for (i = 0; i < length; i++) { 529 vtpci_legacy_write_config_1(sc, off + i, s[i]); 530 } 531 } 532 533 static bool 534 vtpci_legacy_setup_msix(struct vtpci_legacy_softc *sc) 535 { 536 device_t dev; 537 int rid, table_rid; 538 539 dev = sc->vtpci_dev; 540 541 rid = table_rid = pci_msix_table_bar(dev); 542 if (rid != PCIR_BAR(0)) { 543 sc->vtpci_msix_table_res = bus_alloc_resource_any( 544 dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); 545 if (sc->vtpci_msix_table_res == NULL) 546 return (false); 547 } 548 549 rid = pci_msix_pba_bar(dev); 550 if (rid != table_rid && rid != PCIR_BAR(0)) { 551 sc->vtpci_msix_pba_res = bus_alloc_resource_any( 552 dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); 553 if (sc->vtpci_msix_pba_res == NULL) 554 return (false); 555 } 556 557 return (true); 558 } 559 560 static void 561 vtpci_legacy_teardown_msix(struct vtpci_legacy_softc *sc) 562 { 563 device_t dev; 564 565 dev = sc->vtpci_dev; 566 567 if (sc->vtpci_msix_pba_res != NULL) { 568 bus_release_resource(dev, SYS_RES_MEMORY, 569 rman_get_rid(sc->vtpci_msix_pba_res), 570 sc->vtpci_msix_pba_res); 571 sc->vtpci_msix_pba_res = NULL; 572 } 573 if (sc->vtpci_msix_table_res != NULL) { 574 bus_release_resource(dev, SYS_RES_MEMORY, 575 rman_get_rid(sc->vtpci_msix_table_res), 576 sc->vtpci_msix_table_res); 577 sc->vtpci_msix_table_res = NULL; 578 } 579 } 580 581 static int 582 vtpci_legacy_alloc_resources(struct vtpci_legacy_softc *sc) 583 { 584 const int res_types[] = { SYS_RES_IOPORT, SYS_RES_MEMORY }; 585 device_t dev; 586 int rid, i; 587 588 dev = sc->vtpci_dev; 589 590 /* 591 * Most hypervisors export the common configuration structure in IO 592 * space, but some use memory space; try both. 593 */ 594 for (i = 0; nitems(res_types); i++) { 595 rid = PCIR_BAR(0); 596 sc->vtpci_res_type = res_types[i]; 597 sc->vtpci_res = bus_alloc_resource_any(dev, res_types[i], &rid, 598 RF_ACTIVE); 599 if (sc->vtpci_res != NULL) 600 break; 601 } 602 if (sc->vtpci_res == NULL) 603 return (ENXIO); 604 605 return (0); 606 } 607 608 static void 609 vtpci_legacy_free_resources(struct vtpci_legacy_softc *sc) 610 { 611 device_t dev; 612 613 dev = sc->vtpci_dev; 614 615 if (sc->vtpci_res != NULL) { 616 bus_release_resource(dev, sc->vtpci_res_type, PCIR_BAR(0), 617 sc->vtpci_res); 618 sc->vtpci_res = NULL; 619 } 620 } 621 622 static void 623 vtpci_legacy_probe_and_attach_child(struct vtpci_legacy_softc *sc) 624 { 625 device_t dev, child; 626 627 dev = sc->vtpci_dev; 628 child = vtpci_child_device(&sc->vtpci_common); 629 630 if (child == NULL || device_get_state(child) != DS_NOTPRESENT) 631 return; 632 633 if (device_probe(child) != 0) 634 return; 635 636 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER); 637 638 if (device_attach(child) != 0) { 639 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_FAILED); 640 /* Reset status for future attempt. */ 641 vtpci_legacy_child_detached(dev, child); 642 } else { 643 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_DRIVER_OK); 644 VIRTIO_ATTACH_COMPLETED(child); 645 } 646 } 647 648 static int 649 vtpci_legacy_register_msix(struct vtpci_legacy_softc *sc, int offset, 650 struct vtpci_interrupt *intr) 651 { 652 uint16_t vector; 653 654 if (intr != NULL) { 655 /* Map from guest rid to host vector. */ 656 vector = intr->vti_rid - 1; 657 } else 658 vector = VIRTIO_MSI_NO_VECTOR; 659 660 vtpci_legacy_write_header_2(sc, offset, vector); 661 return (vtpci_legacy_read_header_2(sc, offset) == vector ? 0 : ENODEV); 662 } 663 664 static int 665 vtpci_legacy_register_cfg_msix(device_t dev, struct vtpci_interrupt *intr) 666 { 667 struct vtpci_legacy_softc *sc; 668 int error; 669 670 sc = device_get_softc(dev); 671 672 error = vtpci_legacy_register_msix(sc, VIRTIO_MSI_CONFIG_VECTOR, intr); 673 if (error) { 674 device_printf(dev, 675 "unable to register config MSIX interrupt\n"); 676 return (error); 677 } 678 679 return (0); 680 } 681 682 static int 683 vtpci_legacy_register_vq_msix(device_t dev, int idx, 684 struct vtpci_interrupt *intr) 685 { 686 struct vtpci_legacy_softc *sc; 687 int error; 688 689 sc = device_get_softc(dev); 690 691 vtpci_legacy_select_virtqueue(sc, idx); 692 error = vtpci_legacy_register_msix(sc, VIRTIO_MSI_QUEUE_VECTOR, intr); 693 if (error) { 694 device_printf(dev, 695 "unable to register virtqueue MSIX interrupt\n"); 696 return (error); 697 } 698 699 return (0); 700 } 701 702 static void 703 vtpci_legacy_reset(struct vtpci_legacy_softc *sc) 704 { 705 /* 706 * Setting the status to RESET sets the host device to the 707 * original, uninitialized state. 708 */ 709 vtpci_legacy_set_status(sc, VIRTIO_CONFIG_STATUS_RESET); 710 (void) vtpci_legacy_get_status(sc); 711 } 712 713 static void 714 vtpci_legacy_select_virtqueue(struct vtpci_legacy_softc *sc, int idx) 715 { 716 vtpci_legacy_write_header_2(sc, VIRTIO_PCI_QUEUE_SEL, idx); 717 } 718 719 static uint8_t 720 vtpci_legacy_read_isr(device_t dev) 721 { 722 struct vtpci_legacy_softc *sc; 723 724 sc = device_get_softc(dev); 725 726 return (vtpci_legacy_read_config_1(sc, VIRTIO_PCI_ISR)); 727 } 728 729 static uint16_t 730 vtpci_legacy_get_vq_size(device_t dev, int idx) 731 { 732 struct vtpci_legacy_softc *sc; 733 734 sc = device_get_softc(dev); 735 736 vtpci_legacy_select_virtqueue(sc, idx); 737 return (vtpci_legacy_read_header_2(sc, VIRTIO_PCI_QUEUE_NUM)); 738 } 739 740 static bus_size_t 741 vtpci_legacy_get_vq_notify_off(device_t dev, int idx) 742 { 743 return (VIRTIO_PCI_QUEUE_NOTIFY); 744 } 745 746 static void 747 vtpci_legacy_set_vq(device_t dev, struct virtqueue *vq) 748 { 749 struct vtpci_legacy_softc *sc; 750 751 sc = device_get_softc(dev); 752 753 vtpci_legacy_select_virtqueue(sc, virtqueue_index(vq)); 754 vtpci_legacy_write_header_4(sc, VIRTIO_PCI_QUEUE_PFN, 755 virtqueue_paddr(vq) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT); 756 } 757 758 static void 759 vtpci_legacy_disable_vq(device_t dev, int idx) 760 { 761 struct vtpci_legacy_softc *sc; 762 763 sc = device_get_softc(dev); 764 765 vtpci_legacy_select_virtqueue(sc, idx); 766 vtpci_legacy_write_header_4(sc, VIRTIO_PCI_QUEUE_PFN, 0); 767 } 768