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