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