1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Bus & driver management routines for devices within 4 * a MacIO ASIC. Interface to new driver model mostly 5 * stolen from the PCI version. 6 * 7 * Copyright (C) 2005 Ben. Herrenschmidt (benh@kernel.crashing.org) 8 * 9 * TODO: 10 * 11 * - Don't probe below media bay by default, but instead provide 12 * some hooks for media bay to dynamically add/remove it's own 13 * sub-devices. 14 */ 15 16 #include <linux/string.h> 17 #include <linux/kernel.h> 18 #include <linux/pci.h> 19 #include <linux/pci_ids.h> 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/of.h> 24 #include <linux/of_address.h> 25 #include <linux/of_device.h> 26 #include <linux/of_irq.h> 27 28 #include <asm/machdep.h> 29 #include <asm/macio.h> 30 #include <asm/pmac_feature.h> 31 32 #undef DEBUG 33 34 #define MAX_NODE_NAME_SIZE (20 - 12) 35 36 static struct macio_chip *macio_on_hold; 37 38 static int macio_bus_match(struct device *dev, struct device_driver *drv) 39 { 40 const struct of_device_id * matches = drv->of_match_table; 41 42 if (!matches) 43 return 0; 44 45 return of_match_device(matches, dev) != NULL; 46 } 47 48 struct macio_dev *macio_dev_get(struct macio_dev *dev) 49 { 50 struct device *tmp; 51 52 if (!dev) 53 return NULL; 54 tmp = get_device(&dev->ofdev.dev); 55 if (tmp) 56 return to_macio_device(tmp); 57 else 58 return NULL; 59 } 60 61 void macio_dev_put(struct macio_dev *dev) 62 { 63 if (dev) 64 put_device(&dev->ofdev.dev); 65 } 66 67 68 static int macio_device_probe(struct device *dev) 69 { 70 int error = -ENODEV; 71 struct macio_driver *drv; 72 struct macio_dev *macio_dev; 73 const struct of_device_id *match; 74 75 drv = to_macio_driver(dev->driver); 76 macio_dev = to_macio_device(dev); 77 78 if (!drv->probe) 79 return error; 80 81 macio_dev_get(macio_dev); 82 83 match = of_match_device(drv->driver.of_match_table, dev); 84 if (match) 85 error = drv->probe(macio_dev, match); 86 if (error) 87 macio_dev_put(macio_dev); 88 89 return error; 90 } 91 92 static void macio_device_remove(struct device *dev) 93 { 94 struct macio_dev * macio_dev = to_macio_device(dev); 95 struct macio_driver * drv = to_macio_driver(dev->driver); 96 97 if (dev->driver && drv->remove) 98 drv->remove(macio_dev); 99 macio_dev_put(macio_dev); 100 } 101 102 static void macio_device_shutdown(struct device *dev) 103 { 104 struct macio_dev * macio_dev = to_macio_device(dev); 105 struct macio_driver * drv = to_macio_driver(dev->driver); 106 107 if (dev->driver && drv->shutdown) 108 drv->shutdown(macio_dev); 109 } 110 111 static int macio_device_suspend(struct device *dev, pm_message_t state) 112 { 113 struct macio_dev * macio_dev = to_macio_device(dev); 114 struct macio_driver * drv = to_macio_driver(dev->driver); 115 116 if (dev->driver && drv->suspend) 117 return drv->suspend(macio_dev, state); 118 return 0; 119 } 120 121 static int macio_device_resume(struct device * dev) 122 { 123 struct macio_dev * macio_dev = to_macio_device(dev); 124 struct macio_driver * drv = to_macio_driver(dev->driver); 125 126 if (dev->driver && drv->resume) 127 return drv->resume(macio_dev); 128 return 0; 129 } 130 131 static int macio_device_modalias(const struct device *dev, struct kobj_uevent_env *env) 132 { 133 return of_device_uevent_modalias(dev, env); 134 } 135 136 extern const struct attribute_group *macio_dev_groups[]; 137 138 struct bus_type macio_bus_type = { 139 .name = "macio", 140 .match = macio_bus_match, 141 .uevent = macio_device_modalias, 142 .probe = macio_device_probe, 143 .remove = macio_device_remove, 144 .shutdown = macio_device_shutdown, 145 .suspend = macio_device_suspend, 146 .resume = macio_device_resume, 147 .dev_groups = macio_dev_groups, 148 }; 149 150 static int __init macio_bus_driver_init(void) 151 { 152 return bus_register(&macio_bus_type); 153 } 154 155 postcore_initcall(macio_bus_driver_init); 156 157 158 /** 159 * macio_release_dev - free a macio device structure when all users of it are 160 * finished. 161 * @dev: device that's been disconnected 162 * 163 * Will be called only by the device core when all users of this macio device 164 * are done. This currently means never as we don't hot remove any macio 165 * device yet, though that will happen with mediabay based devices in a later 166 * implementation. 167 */ 168 static void macio_release_dev(struct device *dev) 169 { 170 struct macio_dev *mdev; 171 172 mdev = to_macio_device(dev); 173 kfree(mdev); 174 } 175 176 /** 177 * macio_resource_quirks - tweak or skip some resources for a device 178 * @np: pointer to the device node 179 * @res: resulting resource 180 * @index: index of resource in node 181 * 182 * If this routine returns non-null, then the resource is completely 183 * skipped. 184 */ 185 static int macio_resource_quirks(struct device_node *np, struct resource *res, 186 int index) 187 { 188 /* Only quirks for memory resources for now */ 189 if ((res->flags & IORESOURCE_MEM) == 0) 190 return 0; 191 192 /* Grand Central has too large resource 0 on some machines */ 193 if (index == 0 && of_node_name_eq(np, "gc")) 194 res->end = res->start + 0x1ffff; 195 196 /* Airport has bogus resource 2 */ 197 if (index >= 2 && of_node_name_eq(np, "radio")) 198 return 1; 199 200 #ifndef CONFIG_PPC64 201 /* DBDMAs may have bogus sizes */ 202 if ((res->start & 0x0001f000) == 0x00008000) 203 res->end = res->start + 0xff; 204 #endif /* CONFIG_PPC64 */ 205 206 /* ESCC parent eats child resources. We could have added a 207 * level of hierarchy, but I don't really feel the need 208 * for it 209 */ 210 if (of_node_name_eq(np, "escc")) 211 return 1; 212 213 /* ESCC has bogus resources >= 3 */ 214 if (index >= 3 && (of_node_name_eq(np, "ch-a") || 215 of_node_name_eq(np, "ch-b"))) 216 return 1; 217 218 /* Media bay has too many resources, keep only first one */ 219 if (index > 0 && of_node_name_eq(np, "media-bay")) 220 return 1; 221 222 /* Some older IDE resources have bogus sizes */ 223 if (of_node_name_eq(np, "IDE") || of_node_name_eq(np, "ATA") || 224 of_node_is_type(np, "ide") || of_node_is_type(np, "ata")) { 225 if (index == 0 && (res->end - res->start) > 0xfff) 226 res->end = res->start + 0xfff; 227 if (index == 1 && (res->end - res->start) > 0xff) 228 res->end = res->start + 0xff; 229 } 230 return 0; 231 } 232 233 static void macio_create_fixup_irq(struct macio_dev *dev, int index, 234 unsigned int line) 235 { 236 unsigned int irq; 237 238 irq = irq_create_mapping(NULL, line); 239 if (!irq) { 240 dev->interrupt[index].start = irq; 241 dev->interrupt[index].flags = IORESOURCE_IRQ; 242 dev->interrupt[index].name = dev_name(&dev->ofdev.dev); 243 } 244 if (dev->n_interrupts <= index) 245 dev->n_interrupts = index + 1; 246 } 247 248 static void macio_add_missing_resources(struct macio_dev *dev) 249 { 250 struct device_node *np = dev->ofdev.dev.of_node; 251 unsigned int irq_base; 252 253 /* Gatwick has some missing interrupts on child nodes */ 254 if (dev->bus->chip->type != macio_gatwick) 255 return; 256 257 /* irq_base is always 64 on gatwick. I have no cleaner way to get 258 * that value from here at this point 259 */ 260 irq_base = 64; 261 262 /* Fix SCC */ 263 if (of_node_name_eq(np, "ch-a")) { 264 macio_create_fixup_irq(dev, 0, 15 + irq_base); 265 macio_create_fixup_irq(dev, 1, 4 + irq_base); 266 macio_create_fixup_irq(dev, 2, 5 + irq_base); 267 printk(KERN_INFO "macio: fixed SCC irqs on gatwick\n"); 268 } 269 270 /* Fix media-bay */ 271 if (of_node_name_eq(np, "media-bay")) { 272 macio_create_fixup_irq(dev, 0, 29 + irq_base); 273 printk(KERN_INFO "macio: fixed media-bay irq on gatwick\n"); 274 } 275 276 /* Fix left media bay childs */ 277 if (dev->media_bay != NULL && of_node_name_eq(np, "floppy")) { 278 macio_create_fixup_irq(dev, 0, 19 + irq_base); 279 macio_create_fixup_irq(dev, 1, 1 + irq_base); 280 printk(KERN_INFO "macio: fixed left floppy irqs\n"); 281 } 282 if (dev->media_bay != NULL && of_node_name_eq(np, "ata4")) { 283 macio_create_fixup_irq(dev, 0, 14 + irq_base); 284 macio_create_fixup_irq(dev, 0, 3 + irq_base); 285 printk(KERN_INFO "macio: fixed left ide irqs\n"); 286 } 287 } 288 289 static void macio_setup_interrupts(struct macio_dev *dev) 290 { 291 struct device_node *np = dev->ofdev.dev.of_node; 292 unsigned int irq; 293 int i = 0, j = 0; 294 295 for (;;) { 296 struct resource *res; 297 298 if (j >= MACIO_DEV_COUNT_IRQS) 299 break; 300 res = &dev->interrupt[j]; 301 irq = irq_of_parse_and_map(np, i++); 302 if (!irq) 303 break; 304 res->start = irq; 305 res->flags = IORESOURCE_IRQ; 306 res->name = dev_name(&dev->ofdev.dev); 307 if (macio_resource_quirks(np, res, i - 1)) { 308 memset(res, 0, sizeof(struct resource)); 309 continue; 310 } else 311 j++; 312 } 313 dev->n_interrupts = j; 314 } 315 316 static void macio_setup_resources(struct macio_dev *dev, 317 struct resource *parent_res) 318 { 319 struct device_node *np = dev->ofdev.dev.of_node; 320 struct resource r; 321 int index; 322 323 for (index = 0; of_address_to_resource(np, index, &r) == 0; index++) { 324 struct resource *res; 325 if (index >= MACIO_DEV_COUNT_RESOURCES) 326 break; 327 res = &dev->resource[index]; 328 *res = r; 329 res->name = dev_name(&dev->ofdev.dev); 330 331 if (macio_resource_quirks(np, res, index)) { 332 memset(res, 0, sizeof(struct resource)); 333 continue; 334 } 335 /* Currently, we consider failure as harmless, this may 336 * change in the future, once I've found all the device 337 * tree bugs in older machines & worked around them 338 */ 339 if (insert_resource(parent_res, res)) { 340 printk(KERN_WARNING "Can't request resource " 341 "%d for MacIO device %s\n", 342 index, dev_name(&dev->ofdev.dev)); 343 } 344 } 345 dev->n_resources = index; 346 } 347 348 /** 349 * macio_add_one_device - Add one device from OF node to the device tree 350 * @chip: pointer to the macio_chip holding the device 351 * @np: pointer to the device node in the OF tree 352 * @in_bay: set to 1 if device is part of a media-bay 353 * 354 * When media-bay is changed to hotswap drivers, this function will 355 * be exposed to the bay driver some way... 356 */ 357 static struct macio_dev * macio_add_one_device(struct macio_chip *chip, 358 struct device *parent, 359 struct device_node *np, 360 struct macio_dev *in_bay, 361 struct resource *parent_res) 362 { 363 char name[MAX_NODE_NAME_SIZE + 1]; 364 struct macio_dev *dev; 365 const u32 *reg; 366 367 if (np == NULL) 368 return NULL; 369 370 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 371 if (!dev) 372 return NULL; 373 374 dev->bus = &chip->lbus; 375 dev->media_bay = in_bay; 376 dev->ofdev.dev.of_node = np; 377 dev->ofdev.archdata.dma_mask = 0xffffffffUL; 378 dev->ofdev.dev.dma_mask = &dev->ofdev.archdata.dma_mask; 379 dev->ofdev.dev.coherent_dma_mask = dev->ofdev.archdata.dma_mask; 380 dev->ofdev.dev.parent = parent; 381 dev->ofdev.dev.bus = &macio_bus_type; 382 dev->ofdev.dev.release = macio_release_dev; 383 dev->ofdev.dev.dma_parms = &dev->dma_parms; 384 385 /* Standard DMA paremeters */ 386 dma_set_max_seg_size(&dev->ofdev.dev, 65536); 387 dma_set_seg_boundary(&dev->ofdev.dev, 0xffffffff); 388 389 #if defined(CONFIG_PCI) && defined(CONFIG_DMA_OPS) 390 /* Set the DMA ops to the ones from the PCI device, this could be 391 * fishy if we didn't know that on PowerMac it's always direct ops 392 * or iommu ops that will work fine 393 * 394 * To get all the fields, copy all archdata 395 */ 396 dev->ofdev.dev.archdata = chip->lbus.pdev->dev.archdata; 397 dev->ofdev.dev.dma_ops = chip->lbus.pdev->dev.dma_ops; 398 #endif /* CONFIG_PCI && CONFIG_DMA_OPS */ 399 400 #ifdef DEBUG 401 printk("preparing mdev @%p, ofdev @%p, dev @%p, kobj @%p\n", 402 dev, &dev->ofdev, &dev->ofdev.dev, &dev->ofdev.dev.kobj); 403 #endif 404 405 /* MacIO itself has a different reg, we use it's PCI base */ 406 snprintf(name, sizeof(name), "%pOFn", np); 407 if (np == chip->of_node) { 408 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s", 409 chip->lbus.index, 410 #ifdef CONFIG_PCI 411 (unsigned int)pci_resource_start(chip->lbus.pdev, 0), 412 #else 413 0, /* NuBus may want to do something better here */ 414 #endif 415 MAX_NODE_NAME_SIZE, name); 416 } else { 417 reg = of_get_property(np, "reg", NULL); 418 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s", 419 chip->lbus.index, 420 reg ? *reg : 0, MAX_NODE_NAME_SIZE, name); 421 } 422 423 /* Setup interrupts & resources */ 424 macio_setup_interrupts(dev); 425 macio_setup_resources(dev, parent_res); 426 macio_add_missing_resources(dev); 427 428 /* Register with core */ 429 if (of_device_register(&dev->ofdev) != 0) { 430 printk(KERN_DEBUG"macio: device registration error for %s!\n", 431 dev_name(&dev->ofdev.dev)); 432 put_device(&dev->ofdev.dev); 433 return NULL; 434 } 435 436 return dev; 437 } 438 439 static int macio_skip_device(struct device_node *np) 440 { 441 return of_node_name_prefix(np, "battery") || 442 of_node_name_prefix(np, "escc-legacy"); 443 } 444 445 /** 446 * macio_pci_add_devices - Adds sub-devices of mac-io to the device tree 447 * @chip: pointer to the macio_chip holding the devices 448 * 449 * This function will do the job of extracting devices from the 450 * Open Firmware device tree, build macio_dev structures and add 451 * them to the Linux device tree. 452 * 453 * For now, childs of media-bay are added now as well. This will 454 * change rsn though. 455 */ 456 static void macio_pci_add_devices(struct macio_chip *chip) 457 { 458 struct device_node *np, *pnode; 459 struct macio_dev *rdev, *mdev, *mbdev = NULL, *sdev = NULL; 460 struct device *parent = NULL; 461 struct resource *root_res = &iomem_resource; 462 463 /* Add a node for the macio bus itself */ 464 #ifdef CONFIG_PCI 465 if (chip->lbus.pdev) { 466 parent = &chip->lbus.pdev->dev; 467 root_res = &chip->lbus.pdev->resource[0]; 468 } 469 #endif 470 pnode = of_node_get(chip->of_node); 471 if (pnode == NULL) 472 return; 473 474 /* Add macio itself to hierarchy */ 475 rdev = macio_add_one_device(chip, parent, pnode, NULL, root_res); 476 if (rdev == NULL) 477 return; 478 root_res = &rdev->resource[0]; 479 480 /* First scan 1st level */ 481 for_each_child_of_node(pnode, np) { 482 if (macio_skip_device(np)) 483 continue; 484 of_node_get(np); 485 mdev = macio_add_one_device(chip, &rdev->ofdev.dev, np, NULL, 486 root_res); 487 if (mdev == NULL) 488 of_node_put(np); 489 else if (of_node_name_prefix(np, "media-bay")) 490 mbdev = mdev; 491 else if (of_node_name_prefix(np, "escc")) 492 sdev = mdev; 493 } 494 495 /* Add media bay devices if any */ 496 if (mbdev) { 497 pnode = mbdev->ofdev.dev.of_node; 498 for_each_child_of_node(pnode, np) { 499 if (macio_skip_device(np)) 500 continue; 501 of_node_get(np); 502 if (macio_add_one_device(chip, &mbdev->ofdev.dev, np, 503 mbdev, root_res) == NULL) 504 of_node_put(np); 505 } 506 } 507 508 /* Add serial ports if any */ 509 if (sdev) { 510 pnode = sdev->ofdev.dev.of_node; 511 for_each_child_of_node(pnode, np) { 512 if (macio_skip_device(np)) 513 continue; 514 of_node_get(np); 515 if (macio_add_one_device(chip, &sdev->ofdev.dev, np, 516 NULL, root_res) == NULL) 517 of_node_put(np); 518 } 519 } 520 } 521 522 523 /** 524 * macio_register_driver - Registers a new MacIO device driver 525 * @drv: pointer to the driver definition structure 526 */ 527 int macio_register_driver(struct macio_driver *drv) 528 { 529 /* initialize common driver fields */ 530 drv->driver.bus = &macio_bus_type; 531 532 /* register with core */ 533 return driver_register(&drv->driver); 534 } 535 536 /** 537 * macio_unregister_driver - Unregisters a new MacIO device driver 538 * @drv: pointer to the driver definition structure 539 */ 540 void macio_unregister_driver(struct macio_driver *drv) 541 { 542 driver_unregister(&drv->driver); 543 } 544 545 /* Managed MacIO resources */ 546 struct macio_devres { 547 u32 res_mask; 548 }; 549 550 static void maciom_release(struct device *gendev, void *res) 551 { 552 struct macio_dev *dev = to_macio_device(gendev); 553 struct macio_devres *dr = res; 554 int i, max; 555 556 max = min(dev->n_resources, 32); 557 for (i = 0; i < max; i++) { 558 if (dr->res_mask & (1 << i)) 559 macio_release_resource(dev, i); 560 } 561 } 562 563 int macio_enable_devres(struct macio_dev *dev) 564 { 565 struct macio_devres *dr; 566 567 dr = devres_find(&dev->ofdev.dev, maciom_release, NULL, NULL); 568 if (!dr) { 569 dr = devres_alloc(maciom_release, sizeof(*dr), GFP_KERNEL); 570 if (!dr) 571 return -ENOMEM; 572 } 573 return devres_get(&dev->ofdev.dev, dr, NULL, NULL) != NULL; 574 } 575 576 static struct macio_devres * find_macio_dr(struct macio_dev *dev) 577 { 578 return devres_find(&dev->ofdev.dev, maciom_release, NULL, NULL); 579 } 580 581 /** 582 * macio_request_resource - Request an MMIO resource 583 * @dev: pointer to the device holding the resource 584 * @resource_no: resource number to request 585 * @name: resource name 586 * 587 * Mark memory region number @resource_no associated with MacIO 588 * device @dev as being reserved by owner @name. Do not access 589 * any address inside the memory regions unless this call returns 590 * successfully. 591 * 592 * Returns 0 on success, or %EBUSY on error. A warning 593 * message is also printed on failure. 594 */ 595 int macio_request_resource(struct macio_dev *dev, int resource_no, 596 const char *name) 597 { 598 struct macio_devres *dr = find_macio_dr(dev); 599 600 if (macio_resource_len(dev, resource_no) == 0) 601 return 0; 602 603 if (!request_mem_region(macio_resource_start(dev, resource_no), 604 macio_resource_len(dev, resource_no), 605 name)) 606 goto err_out; 607 608 if (dr && resource_no < 32) 609 dr->res_mask |= 1 << resource_no; 610 611 return 0; 612 613 err_out: 614 printk (KERN_WARNING "MacIO: Unable to reserve resource #%d:%lx@%lx" 615 " for device %s\n", 616 resource_no, 617 macio_resource_len(dev, resource_no), 618 macio_resource_start(dev, resource_no), 619 dev_name(&dev->ofdev.dev)); 620 return -EBUSY; 621 } 622 623 /** 624 * macio_release_resource - Release an MMIO resource 625 * @dev: pointer to the device holding the resource 626 * @resource_no: resource number to release 627 */ 628 void macio_release_resource(struct macio_dev *dev, int resource_no) 629 { 630 struct macio_devres *dr = find_macio_dr(dev); 631 632 if (macio_resource_len(dev, resource_no) == 0) 633 return; 634 release_mem_region(macio_resource_start(dev, resource_no), 635 macio_resource_len(dev, resource_no)); 636 if (dr && resource_no < 32) 637 dr->res_mask &= ~(1 << resource_no); 638 } 639 640 /** 641 * macio_request_resources - Reserve all memory resources 642 * @dev: MacIO device whose resources are to be reserved 643 * @name: Name to be associated with resource. 644 * 645 * Mark all memory regions associated with MacIO device @dev as 646 * being reserved by owner @name. Do not access any address inside 647 * the memory regions unless this call returns successfully. 648 * 649 * Returns 0 on success, or %EBUSY on error. A warning 650 * message is also printed on failure. 651 */ 652 int macio_request_resources(struct macio_dev *dev, const char *name) 653 { 654 int i; 655 656 for (i = 0; i < dev->n_resources; i++) 657 if (macio_request_resource(dev, i, name)) 658 goto err_out; 659 return 0; 660 661 err_out: 662 while(--i >= 0) 663 macio_release_resource(dev, i); 664 665 return -EBUSY; 666 } 667 668 /** 669 * macio_release_resources - Release reserved memory resources 670 * @dev: MacIO device whose resources were previously reserved 671 */ 672 673 void macio_release_resources(struct macio_dev *dev) 674 { 675 int i; 676 677 for (i = 0; i < dev->n_resources; i++) 678 macio_release_resource(dev, i); 679 } 680 681 682 #ifdef CONFIG_PCI 683 684 static int macio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 685 { 686 struct device_node* np; 687 struct macio_chip* chip; 688 689 if (ent->vendor != PCI_VENDOR_ID_APPLE) 690 return -ENODEV; 691 692 /* Note regarding refcounting: We assume pci_device_to_OF_node() is 693 * ported to new OF APIs and returns a node with refcount incremented. 694 */ 695 np = pci_device_to_OF_node(pdev); 696 if (np == NULL) 697 return -ENODEV; 698 699 /* The above assumption is wrong !!! 700 * fix that here for now until I fix the arch code 701 */ 702 of_node_get(np); 703 704 /* We also assume that pmac_feature will have done a get() on nodes 705 * stored in the macio chips array 706 */ 707 chip = macio_find(np, macio_unknown); 708 of_node_put(np); 709 if (chip == NULL) 710 return -ENODEV; 711 712 /* XXX Need locking ??? */ 713 if (chip->lbus.pdev == NULL) { 714 chip->lbus.pdev = pdev; 715 chip->lbus.chip = chip; 716 pci_set_drvdata(pdev, &chip->lbus); 717 pci_set_master(pdev); 718 } 719 720 printk(KERN_INFO "MacIO PCI driver attached to %s chipset\n", 721 chip->name); 722 723 /* 724 * HACK ALERT: The WallStreet PowerBook and some OHare based machines 725 * have 2 macio ASICs. I must probe the "main" one first or IDE 726 * ordering will be incorrect. So I put on "hold" the second one since 727 * it seem to appear first on PCI 728 */ 729 if (chip->type == macio_gatwick || chip->type == macio_ohareII) 730 if (macio_chips[0].lbus.pdev == NULL) { 731 macio_on_hold = chip; 732 return 0; 733 } 734 735 macio_pci_add_devices(chip); 736 if (macio_on_hold && macio_chips[0].lbus.pdev != NULL) { 737 macio_pci_add_devices(macio_on_hold); 738 macio_on_hold = NULL; 739 } 740 741 return 0; 742 } 743 744 static void macio_pci_remove(struct pci_dev* pdev) 745 { 746 panic("removing of macio-asic not supported !\n"); 747 } 748 749 /* 750 * MacIO is matched against any Apple ID, it's probe() function 751 * will then decide wether it applies or not 752 */ 753 static const struct pci_device_id pci_ids[] = { { 754 .vendor = PCI_VENDOR_ID_APPLE, 755 .device = PCI_ANY_ID, 756 .subvendor = PCI_ANY_ID, 757 .subdevice = PCI_ANY_ID, 758 759 }, { /* end: all zeroes */ } 760 }; 761 MODULE_DEVICE_TABLE (pci, pci_ids); 762 763 /* pci driver glue; this is a "new style" PCI driver module */ 764 static struct pci_driver macio_pci_driver = { 765 .name = "macio", 766 .id_table = pci_ids, 767 768 .probe = macio_pci_probe, 769 .remove = macio_pci_remove, 770 }; 771 772 #endif /* CONFIG_PCI */ 773 774 static int __init macio_module_init (void) 775 { 776 #ifdef CONFIG_PCI 777 int rc; 778 779 rc = pci_register_driver(&macio_pci_driver); 780 if (rc) 781 return rc; 782 #endif /* CONFIG_PCI */ 783 return 0; 784 } 785 786 module_init(macio_module_init); 787 788 EXPORT_SYMBOL(macio_register_driver); 789 EXPORT_SYMBOL(macio_unregister_driver); 790 EXPORT_SYMBOL(macio_dev_get); 791 EXPORT_SYMBOL(macio_dev_put); 792 EXPORT_SYMBOL(macio_request_resource); 793 EXPORT_SYMBOL(macio_release_resource); 794 EXPORT_SYMBOL(macio_request_resources); 795 EXPORT_SYMBOL(macio_release_resources); 796 EXPORT_SYMBOL(macio_enable_devres); 797 798