1 /*- 2 * Copyright (c) 2015 Ruslan Bukin <br@bsdpad.com> 3 * Copyright (c) 2014,2016 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * This software was developed by Andrew Turner under 7 * the sponsorship of the FreeBSD Foundation. 8 * 9 * This software was developed by Semihalf under 10 * the sponsorship of the FreeBSD Foundation. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 /* Generic ECAM PCIe driver FDT attachment */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include "opt_platform.h" 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/bus.h> 44 #include <sys/kernel.h> 45 #include <sys/malloc.h> 46 #include <sys/module.h> 47 #include <sys/rman.h> 48 49 #if defined(INTRNG) 50 #include <machine/intr.h> 51 #endif 52 53 #include <dev/ofw/openfirm.h> 54 #include <dev/ofw/ofw_bus.h> 55 #include <dev/ofw/ofw_bus_subr.h> 56 #include <dev/ofw/ofw_pci.h> 57 58 #include <dev/pci/pcivar.h> 59 #include <dev/pci/pcireg.h> 60 #include <dev/pci/pcib_private.h> 61 #include <dev/pci/pci_host_generic.h> 62 #include <dev/pci/pci_host_generic_fdt.h> 63 64 #include <machine/intr.h> 65 66 #include "pcib_if.h" 67 68 #define PCI_IO_WINDOW_OFFSET 0x1000 69 70 #define SPACE_CODE_SHIFT 24 71 #define SPACE_CODE_MASK 0x3 72 #define SPACE_CODE_IO_SPACE 0x1 73 #define PROPS_CELL_SIZE 1 74 #define PCI_ADDR_CELL_SIZE 2 75 76 /* OFW bus interface */ 77 struct generic_pcie_ofw_devinfo { 78 struct ofw_bus_devinfo di_dinfo; 79 struct resource_list di_rl; 80 }; 81 82 /* Forward prototypes */ 83 84 static int generic_pcie_fdt_probe(device_t dev); 85 static int parse_pci_mem_ranges(device_t, struct generic_pcie_core_softc *); 86 static int generic_pcie_fdt_release_resource(device_t dev, device_t child, 87 int type, int rid, struct resource *res); 88 static int generic_pcie_ofw_bus_attach(device_t); 89 static const struct ofw_bus_devinfo *generic_pcie_ofw_get_devinfo(device_t, 90 device_t); 91 92 static __inline void 93 get_addr_size_cells(phandle_t node, pcell_t *addr_cells, pcell_t *size_cells) 94 { 95 96 *addr_cells = 2; 97 /* Find address cells if present */ 98 OF_getencprop(node, "#address-cells", addr_cells, sizeof(*addr_cells)); 99 100 *size_cells = 2; 101 /* Find size cells if present */ 102 OF_getencprop(node, "#size-cells", size_cells, sizeof(*size_cells)); 103 } 104 105 static int 106 generic_pcie_fdt_probe(device_t dev) 107 { 108 109 if (!ofw_bus_status_okay(dev)) 110 return (ENXIO); 111 112 if (ofw_bus_is_compatible(dev, "pci-host-ecam-generic")) { 113 device_set_desc(dev, "Generic PCI host controller"); 114 return (BUS_PROBE_GENERIC); 115 } 116 if (ofw_bus_is_compatible(dev, "arm,gem5_pcie")) { 117 device_set_desc(dev, "GEM5 PCIe host controller"); 118 return (BUS_PROBE_DEFAULT); 119 } 120 121 return (ENXIO); 122 } 123 124 int 125 pci_host_generic_attach(device_t dev) 126 { 127 struct generic_pcie_fdt_softc *sc; 128 uint64_t phys_base; 129 uint64_t pci_base; 130 uint64_t size; 131 phandle_t node; 132 int error; 133 int tuple; 134 135 sc = device_get_softc(dev); 136 137 /* Retrieve 'ranges' property from FDT */ 138 if (bootverbose) 139 device_printf(dev, "parsing FDT for ECAM%d:\n", sc->base.ecam); 140 if (parse_pci_mem_ranges(dev, &sc->base)) 141 return (ENXIO); 142 143 /* Attach OFW bus */ 144 if (generic_pcie_ofw_bus_attach(dev) != 0) 145 return (ENXIO); 146 147 node = ofw_bus_get_node(dev); 148 if (sc->base.coherent == 0) { 149 sc->base.coherent = OF_hasprop(node, "dma-coherent"); 150 } 151 if (bootverbose) 152 device_printf(dev, "Bus is%s cache-coherent\n", 153 sc->base.coherent ? "" : " not"); 154 155 error = pci_host_generic_core_attach(dev); 156 if (error != 0) 157 return (error); 158 159 for (tuple = 0; tuple < MAX_RANGES_TUPLES; tuple++) { 160 phys_base = sc->base.ranges[tuple].phys_base; 161 pci_base = sc->base.ranges[tuple].pci_base; 162 size = sc->base.ranges[tuple].size; 163 if (phys_base == 0 || size == 0) 164 continue; /* empty range element */ 165 if (sc->base.ranges[tuple].flags & FLAG_MEM) { 166 error = rman_manage_region(&sc->base.mem_rman, 167 phys_base, phys_base + size - 1); 168 } else if (sc->base.ranges[tuple].flags & FLAG_IO) { 169 error = rman_manage_region(&sc->base.io_rman, 170 pci_base + PCI_IO_WINDOW_OFFSET, 171 pci_base + PCI_IO_WINDOW_OFFSET + size - 1); 172 } else 173 continue; 174 if (error) { 175 device_printf(dev, "rman_manage_region() failed." 176 "error = %d\n", error); 177 rman_fini(&sc->base.mem_rman); 178 return (error); 179 } 180 } 181 182 ofw_bus_setup_iinfo(node, &sc->pci_iinfo, sizeof(cell_t)); 183 184 device_add_child(dev, "pci", -1); 185 return (bus_generic_attach(dev)); 186 } 187 188 static int 189 parse_pci_mem_ranges(device_t dev, struct generic_pcie_core_softc *sc) 190 { 191 pcell_t pci_addr_cells, parent_addr_cells; 192 pcell_t attributes, size_cells; 193 cell_t *base_ranges; 194 int nbase_ranges; 195 phandle_t node; 196 int i, j, k; 197 int tuple; 198 199 node = ofw_bus_get_node(dev); 200 201 OF_getencprop(node, "#address-cells", &pci_addr_cells, 202 sizeof(pci_addr_cells)); 203 OF_getencprop(node, "#size-cells", &size_cells, 204 sizeof(size_cells)); 205 OF_getencprop(OF_parent(node), "#address-cells", &parent_addr_cells, 206 sizeof(parent_addr_cells)); 207 208 if (parent_addr_cells > 2 || pci_addr_cells != 3 || size_cells > 2) { 209 device_printf(dev, 210 "Unexpected number of address or size cells in FDT\n"); 211 return (ENXIO); 212 } 213 214 nbase_ranges = OF_getproplen(node, "ranges"); 215 sc->nranges = nbase_ranges / sizeof(cell_t) / 216 (parent_addr_cells + pci_addr_cells + size_cells); 217 base_ranges = malloc(nbase_ranges, M_DEVBUF, M_WAITOK); 218 OF_getencprop(node, "ranges", base_ranges, nbase_ranges); 219 220 for (i = 0, j = 0; i < sc->nranges; i++) { 221 attributes = (base_ranges[j++] >> SPACE_CODE_SHIFT) & \ 222 SPACE_CODE_MASK; 223 if (attributes == SPACE_CODE_IO_SPACE) { 224 sc->ranges[i].flags |= FLAG_IO; 225 } else { 226 sc->ranges[i].flags |= FLAG_MEM; 227 } 228 229 sc->ranges[i].pci_base = 0; 230 for (k = 0; k < (pci_addr_cells - 1); k++) { 231 sc->ranges[i].pci_base <<= 32; 232 sc->ranges[i].pci_base |= base_ranges[j++]; 233 } 234 sc->ranges[i].phys_base = 0; 235 for (k = 0; k < parent_addr_cells; k++) { 236 sc->ranges[i].phys_base <<= 32; 237 sc->ranges[i].phys_base |= base_ranges[j++]; 238 } 239 sc->ranges[i].size = 0; 240 for (k = 0; k < size_cells; k++) { 241 sc->ranges[i].size <<= 32; 242 sc->ranges[i].size |= base_ranges[j++]; 243 } 244 } 245 246 for (; i < MAX_RANGES_TUPLES; i++) { 247 /* zero-fill remaining tuples to mark empty elements in array */ 248 sc->ranges[i].pci_base = 0; 249 sc->ranges[i].phys_base = 0; 250 sc->ranges[i].size = 0; 251 } 252 253 if (bootverbose) { 254 for (tuple = 0; tuple < MAX_RANGES_TUPLES; tuple++) { 255 device_printf(dev, 256 "\tPCI addr: 0x%jx, CPU addr: 0x%jx, Size: 0x%jx\n", 257 sc->ranges[tuple].pci_base, 258 sc->ranges[tuple].phys_base, 259 sc->ranges[tuple].size); 260 } 261 } 262 263 free(base_ranges, M_DEVBUF); 264 return (0); 265 } 266 267 static int 268 generic_pcie_fdt_route_interrupt(device_t bus, device_t dev, int pin) 269 { 270 struct generic_pcie_fdt_softc *sc; 271 struct ofw_pci_register reg; 272 uint32_t pintr, mintr[4]; 273 phandle_t iparent; 274 int intrcells; 275 276 sc = device_get_softc(bus); 277 pintr = pin; 278 279 bzero(®, sizeof(reg)); 280 reg.phys_hi = (pci_get_bus(dev) << OFW_PCI_PHYS_HI_BUSSHIFT) | 281 (pci_get_slot(dev) << OFW_PCI_PHYS_HI_DEVICESHIFT) | 282 (pci_get_function(dev) << OFW_PCI_PHYS_HI_FUNCTIONSHIFT); 283 284 intrcells = ofw_bus_lookup_imap(ofw_bus_get_node(dev), 285 &sc->pci_iinfo, ®, sizeof(reg), &pintr, sizeof(pintr), 286 mintr, sizeof(mintr), &iparent); 287 if (intrcells) { 288 pintr = ofw_bus_map_intr(dev, iparent, intrcells, mintr); 289 return (pintr); 290 } 291 292 device_printf(bus, "could not route pin %d for device %d.%d\n", 293 pin, pci_get_slot(dev), pci_get_function(dev)); 294 return (PCI_INVALID_IRQ); 295 } 296 297 static int 298 generic_pcie_fdt_release_resource(device_t dev, device_t child, int type, 299 int rid, struct resource *res) 300 { 301 302 #if defined(NEW_PCIB) && defined(PCI_RES_BUS) 303 if (type == PCI_RES_BUS) { 304 return (pci_host_generic_core_release_resource(dev, child, type, 305 rid, res)); 306 } 307 #endif 308 309 /* For PCIe devices that do not have FDT nodes, use PCIB method */ 310 if ((int)ofw_bus_get_node(child) <= 0) { 311 return (pci_host_generic_core_release_resource(dev, child, type, 312 rid, res)); 313 } 314 315 /* For other devices use OFW method */ 316 return (bus_generic_release_resource(dev, child, type, rid, res)); 317 } 318 319 struct resource * 320 pci_host_generic_alloc_resource(device_t dev, device_t child, int type, 321 int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags) 322 { 323 struct generic_pcie_fdt_softc *sc; 324 struct generic_pcie_ofw_devinfo *di; 325 struct resource_list_entry *rle; 326 int i; 327 328 #if defined(NEW_PCIB) && defined(PCI_RES_BUS) 329 if (type == PCI_RES_BUS) { 330 return (pci_host_generic_core_alloc_resource(dev, child, type, rid, 331 start, end, count, flags)); 332 } 333 #endif 334 335 /* For PCIe devices that do not have FDT nodes, use PCIB method */ 336 if ((int)ofw_bus_get_node(child) <= 0) 337 return (pci_host_generic_core_alloc_resource(dev, child, type, 338 rid, start, end, count, flags)); 339 340 /* For other devices use OFW method */ 341 sc = device_get_softc(dev); 342 343 if (RMAN_IS_DEFAULT_RANGE(start, end)) { 344 if ((di = device_get_ivars(child)) == NULL) 345 return (NULL); 346 if (type == SYS_RES_IOPORT) 347 type = SYS_RES_MEMORY; 348 349 /* Find defaults for this rid */ 350 rle = resource_list_find(&di->di_rl, type, *rid); 351 if (rle == NULL) 352 return (NULL); 353 354 start = rle->start; 355 end = rle->end; 356 count = rle->count; 357 } 358 359 if (type == SYS_RES_MEMORY) { 360 /* Remap through ranges property */ 361 for (i = 0; i < MAX_RANGES_TUPLES; i++) { 362 if (start >= sc->base.ranges[i].phys_base && 363 end < (sc->base.ranges[i].pci_base + 364 sc->base.ranges[i].size)) { 365 start -= sc->base.ranges[i].phys_base; 366 start += sc->base.ranges[i].pci_base; 367 end -= sc->base.ranges[i].phys_base; 368 end += sc->base.ranges[i].pci_base; 369 break; 370 } 371 } 372 373 if (i == MAX_RANGES_TUPLES) { 374 device_printf(dev, "Could not map resource " 375 "%#jx-%#jx\n", start, end); 376 return (NULL); 377 } 378 } 379 380 return (bus_generic_alloc_resource(dev, child, type, rid, start, 381 end, count, flags)); 382 } 383 384 static int 385 generic_pcie_fdt_activate_resource(device_t dev, device_t child, int type, 386 int rid, struct resource *r) 387 { 388 struct generic_pcie_fdt_softc *sc; 389 uint64_t phys_base; 390 uint64_t pci_base; 391 uint64_t size; 392 int found; 393 int res; 394 int i; 395 396 sc = device_get_softc(dev); 397 398 if ((res = rman_activate_resource(r)) != 0) 399 return (res); 400 401 switch(type) { 402 case SYS_RES_IOPORT: 403 found = 0; 404 for (i = 0; i < MAX_RANGES_TUPLES; i++) { 405 pci_base = sc->base.ranges[i].pci_base; 406 phys_base = sc->base.ranges[i].phys_base; 407 size = sc->base.ranges[i].size; 408 409 if ((rid > pci_base) && (rid < (pci_base + size))) { 410 found = 1; 411 break; 412 } 413 } 414 if (found) { 415 rman_set_start(r, rman_get_start(r) + phys_base); 416 rman_set_end(r, rman_get_end(r) + phys_base); 417 res = BUS_ACTIVATE_RESOURCE(device_get_parent(dev), 418 child, type, rid, r); 419 } else { 420 device_printf(dev, 421 "Failed to activate IOPORT resource\n"); 422 res = 0; 423 } 424 break; 425 case SYS_RES_MEMORY: 426 res = BUS_ACTIVATE_RESOURCE(device_get_parent(dev), child, 427 type, rid, r); 428 break; 429 default: 430 break; 431 } 432 433 return (res); 434 } 435 436 static int 437 generic_pcie_fdt_deactivate_resource(device_t dev, device_t child, int type, 438 int rid, struct resource *r) 439 { 440 int res; 441 442 if ((res = rman_deactivate_resource(r)) != 0) 443 return (res); 444 445 switch(type) { 446 case SYS_RES_IOPORT: 447 case SYS_RES_MEMORY: 448 res = BUS_DEACTIVATE_RESOURCE(device_get_parent(dev), child, 449 type, rid, r); 450 break; 451 default: 452 break; 453 } 454 455 return (res); 456 } 457 458 static int 459 generic_pcie_fdt_alloc_msi(device_t pci, device_t child, int count, 460 int maxcount, int *irqs) 461 { 462 #if defined(INTRNG) 463 phandle_t msi_parent; 464 int err; 465 466 err = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), 467 &msi_parent, NULL); 468 if (err != 0) 469 return (err); 470 return (intr_alloc_msi(pci, child, msi_parent, count, maxcount, 471 irqs)); 472 #else 473 return (ENXIO); 474 #endif 475 } 476 477 static int 478 generic_pcie_fdt_release_msi(device_t pci, device_t child, int count, int *irqs) 479 { 480 #if defined(INTRNG) 481 phandle_t msi_parent; 482 int err; 483 484 err = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), 485 &msi_parent, NULL); 486 if (err != 0) 487 return (err); 488 return (intr_release_msi(pci, child, msi_parent, count, irqs)); 489 #else 490 return (ENXIO); 491 #endif 492 } 493 494 static int 495 generic_pcie_fdt_map_msi(device_t pci, device_t child, int irq, uint64_t *addr, 496 uint32_t *data) 497 { 498 #if defined(INTRNG) 499 phandle_t msi_parent; 500 int err; 501 502 err = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), 503 &msi_parent, NULL); 504 if (err != 0) 505 return (err); 506 return (intr_map_msi(pci, child, msi_parent, irq, addr, data)); 507 #else 508 return (ENXIO); 509 #endif 510 } 511 512 static int 513 generic_pcie_fdt_alloc_msix(device_t pci, device_t child, int *irq) 514 { 515 #if defined(INTRNG) 516 phandle_t msi_parent; 517 int err; 518 519 err = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), 520 &msi_parent, NULL); 521 if (err != 0) 522 return (err); 523 return (intr_alloc_msix(pci, child, msi_parent, irq)); 524 #else 525 return (ENXIO); 526 #endif 527 } 528 529 static int 530 generic_pcie_fdt_release_msix(device_t pci, device_t child, int irq) 531 { 532 #if defined(INTRNG) 533 phandle_t msi_parent; 534 int err; 535 536 err = ofw_bus_msimap(ofw_bus_get_node(pci), pci_get_rid(child), 537 &msi_parent, NULL); 538 if (err != 0) 539 return (err); 540 return (intr_release_msix(pci, child, msi_parent, irq)); 541 #else 542 return (ENXIO); 543 #endif 544 } 545 546 int 547 generic_pcie_get_id(device_t pci, device_t child, enum pci_id_type type, 548 uintptr_t *id) 549 { 550 phandle_t node; 551 int err; 552 uint32_t rid; 553 uint16_t pci_rid; 554 555 if (type != PCI_ID_MSI) 556 return (pcib_get_id(pci, child, type, id)); 557 558 node = ofw_bus_get_node(pci); 559 pci_rid = pci_get_rid(child); 560 561 err = ofw_bus_msimap(node, pci_rid, NULL, &rid); 562 if (err != 0) 563 return (err); 564 *id = rid; 565 566 return (0); 567 } 568 569 static const struct ofw_bus_devinfo * 570 generic_pcie_ofw_get_devinfo(device_t bus __unused, device_t child) 571 { 572 struct generic_pcie_ofw_devinfo *di; 573 574 di = device_get_ivars(child); 575 return (&di->di_dinfo); 576 } 577 578 /* Helper functions */ 579 580 static int 581 generic_pcie_ofw_bus_attach(device_t dev) 582 { 583 struct generic_pcie_ofw_devinfo *di; 584 device_t child; 585 phandle_t parent, node; 586 pcell_t addr_cells, size_cells; 587 588 parent = ofw_bus_get_node(dev); 589 if (parent > 0) { 590 get_addr_size_cells(parent, &addr_cells, &size_cells); 591 /* Iterate through all bus subordinates */ 592 for (node = OF_child(parent); node > 0; node = OF_peer(node)) { 593 594 /* Allocate and populate devinfo. */ 595 di = malloc(sizeof(*di), M_DEVBUF, M_WAITOK | M_ZERO); 596 if (ofw_bus_gen_setup_devinfo(&di->di_dinfo, node) != 0) { 597 free(di, M_DEVBUF); 598 continue; 599 } 600 601 /* Initialize and populate resource list. */ 602 resource_list_init(&di->di_rl); 603 ofw_bus_reg_to_rl(dev, node, addr_cells, size_cells, 604 &di->di_rl); 605 ofw_bus_intr_to_rl(dev, node, &di->di_rl, NULL); 606 607 /* Add newbus device for this FDT node */ 608 child = device_add_child(dev, NULL, -1); 609 if (child == NULL) { 610 resource_list_free(&di->di_rl); 611 ofw_bus_gen_destroy_devinfo(&di->di_dinfo); 612 free(di, M_DEVBUF); 613 continue; 614 } 615 616 device_set_ivars(child, di); 617 } 618 } 619 620 return (0); 621 } 622 623 static device_method_t generic_pcie_fdt_methods[] = { 624 DEVMETHOD(device_probe, generic_pcie_fdt_probe), 625 DEVMETHOD(device_attach, pci_host_generic_attach), 626 DEVMETHOD(bus_alloc_resource, pci_host_generic_alloc_resource), 627 DEVMETHOD(bus_release_resource, generic_pcie_fdt_release_resource), 628 DEVMETHOD(bus_activate_resource, generic_pcie_fdt_activate_resource), 629 DEVMETHOD(bus_deactivate_resource,generic_pcie_fdt_deactivate_resource), 630 631 /* pcib interface */ 632 DEVMETHOD(pcib_route_interrupt, generic_pcie_fdt_route_interrupt), 633 DEVMETHOD(pcib_alloc_msi, generic_pcie_fdt_alloc_msi), 634 DEVMETHOD(pcib_release_msi, generic_pcie_fdt_release_msi), 635 DEVMETHOD(pcib_alloc_msix, generic_pcie_fdt_alloc_msix), 636 DEVMETHOD(pcib_release_msix, generic_pcie_fdt_release_msix), 637 DEVMETHOD(pcib_map_msi, generic_pcie_fdt_map_msi), 638 DEVMETHOD(pcib_get_id, generic_pcie_get_id), 639 DEVMETHOD(pcib_request_feature, pcib_request_feature_allow), 640 641 /* ofw_bus interface */ 642 DEVMETHOD(ofw_bus_get_devinfo, generic_pcie_ofw_get_devinfo), 643 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat), 644 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model), 645 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name), 646 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node), 647 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type), 648 649 DEVMETHOD_END 650 }; 651 652 DEFINE_CLASS_1(pcib, generic_pcie_fdt_driver, generic_pcie_fdt_methods, 653 sizeof(struct generic_pcie_fdt_softc), generic_pcie_core_driver); 654 655 static devclass_t generic_pcie_fdt_devclass; 656 657 DRIVER_MODULE(pcib, simplebus, generic_pcie_fdt_driver, 658 generic_pcie_fdt_devclass, 0, 0); 659 DRIVER_MODULE(pcib, ofwbus, generic_pcie_fdt_driver, generic_pcie_fdt_devclass, 660 0, 0); 661