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