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