1 /* 2 * Bus & driver management routines for devices within 3 * a MacIO ASIC. Interface to new driver model mostly 4 * stolen from the PCI version. 5 * 6 * Copyright (C) 2005 Ben. Herrenschmidt (benh@kernel.crashing.org) 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 * TODO: 14 * 15 * - Don't probe below media bay by default, but instead provide 16 * some hooks for media bay to dynamically add/remove it's own 17 * sub-devices. 18 */ 19 20 #include <linux/string.h> 21 #include <linux/kernel.h> 22 #include <linux/pci.h> 23 #include <linux/pci_ids.h> 24 #include <linux/init.h> 25 #include <linux/module.h> 26 #include <linux/slab.h> 27 #include <linux/of_address.h> 28 #include <linux/of_irq.h> 29 30 #include <asm/machdep.h> 31 #include <asm/macio.h> 32 #include <asm/pmac_feature.h> 33 #include <asm/prom.h> 34 #include <asm/pci-bridge.h> 35 36 #undef DEBUG 37 38 #define MAX_NODE_NAME_SIZE (20 - 12) 39 40 static struct macio_chip *macio_on_hold; 41 42 static int macio_bus_match(struct device *dev, struct device_driver *drv) 43 { 44 const struct of_device_id * matches = drv->of_match_table; 45 46 if (!matches) 47 return 0; 48 49 return of_match_device(matches, dev) != NULL; 50 } 51 52 struct macio_dev *macio_dev_get(struct macio_dev *dev) 53 { 54 struct device *tmp; 55 56 if (!dev) 57 return NULL; 58 tmp = get_device(&dev->ofdev.dev); 59 if (tmp) 60 return to_macio_device(tmp); 61 else 62 return NULL; 63 } 64 65 void macio_dev_put(struct macio_dev *dev) 66 { 67 if (dev) 68 put_device(&dev->ofdev.dev); 69 } 70 71 72 static int macio_device_probe(struct device *dev) 73 { 74 int error = -ENODEV; 75 struct macio_driver *drv; 76 struct macio_dev *macio_dev; 77 const struct of_device_id *match; 78 79 drv = to_macio_driver(dev->driver); 80 macio_dev = to_macio_device(dev); 81 82 if (!drv->probe) 83 return error; 84 85 macio_dev_get(macio_dev); 86 87 match = of_match_device(drv->driver.of_match_table, dev); 88 if (match) 89 error = drv->probe(macio_dev, match); 90 if (error) 91 macio_dev_put(macio_dev); 92 93 return error; 94 } 95 96 static int macio_device_remove(struct device *dev) 97 { 98 struct macio_dev * macio_dev = to_macio_device(dev); 99 struct macio_driver * drv = to_macio_driver(dev->driver); 100 101 if (dev->driver && drv->remove) 102 drv->remove(macio_dev); 103 macio_dev_put(macio_dev); 104 105 return 0; 106 } 107 108 static void macio_device_shutdown(struct device *dev) 109 { 110 struct macio_dev * macio_dev = to_macio_device(dev); 111 struct macio_driver * drv = to_macio_driver(dev->driver); 112 113 if (dev->driver && drv->shutdown) 114 drv->shutdown(macio_dev); 115 } 116 117 static int macio_device_suspend(struct device *dev, pm_message_t state) 118 { 119 struct macio_dev * macio_dev = to_macio_device(dev); 120 struct macio_driver * drv = to_macio_driver(dev->driver); 121 122 if (dev->driver && drv->suspend) 123 return drv->suspend(macio_dev, state); 124 return 0; 125 } 126 127 static int macio_device_resume(struct device * dev) 128 { 129 struct macio_dev * macio_dev = to_macio_device(dev); 130 struct macio_driver * drv = to_macio_driver(dev->driver); 131 132 if (dev->driver && drv->resume) 133 return drv->resume(macio_dev); 134 return 0; 135 } 136 137 extern struct device_attribute macio_dev_attrs[]; 138 139 struct bus_type macio_bus_type = { 140 .name = "macio", 141 .match = macio_bus_match, 142 .uevent = of_device_uevent_modalias, 143 .probe = macio_device_probe, 144 .remove = macio_device_remove, 145 .shutdown = macio_device_shutdown, 146 .suspend = macio_device_suspend, 147 .resume = macio_device_resume, 148 .dev_attrs = macio_dev_attrs, 149 }; 150 151 static int __init macio_bus_driver_init(void) 152 { 153 return bus_register(&macio_bus_type); 154 } 155 156 postcore_initcall(macio_bus_driver_init); 157 158 159 /** 160 * macio_release_dev - free a macio device structure when all users of it are 161 * finished. 162 * @dev: device that's been disconnected 163 * 164 * Will be called only by the device core when all users of this macio device 165 * are done. This currently means never as we don't hot remove any macio 166 * device yet, though that will happen with mediabay based devices in a later 167 * implementation. 168 */ 169 static void macio_release_dev(struct device *dev) 170 { 171 struct macio_dev *mdev; 172 173 mdev = to_macio_device(dev); 174 kfree(mdev); 175 } 176 177 /** 178 * macio_resource_quirks - tweak or skip some resources for a device 179 * @np: pointer to the device node 180 * @res: resulting resource 181 * @index: index of resource in node 182 * 183 * If this routine returns non-null, then the resource is completely 184 * skipped. 185 */ 186 static int macio_resource_quirks(struct device_node *np, struct resource *res, 187 int index) 188 { 189 /* Only quirks for memory resources for now */ 190 if ((res->flags & IORESOURCE_MEM) == 0) 191 return 0; 192 193 /* Grand Central has too large resource 0 on some machines */ 194 if (index == 0 && !strcmp(np->name, "gc")) 195 res->end = res->start + 0x1ffff; 196 197 /* Airport has bogus resource 2 */ 198 if (index >= 2 && !strcmp(np->name, "radio")) 199 return 1; 200 201 #ifndef CONFIG_PPC64 202 /* DBDMAs may have bogus sizes */ 203 if ((res->start & 0x0001f000) == 0x00008000) 204 res->end = res->start + 0xff; 205 #endif /* CONFIG_PPC64 */ 206 207 /* ESCC parent eats child resources. We could have added a 208 * level of hierarchy, but I don't really feel the need 209 * for it 210 */ 211 if (!strcmp(np->name, "escc")) 212 return 1; 213 214 /* ESCC has bogus resources >= 3 */ 215 if (index >= 3 && !(strcmp(np->name, "ch-a") && 216 strcmp(np->name, "ch-b"))) 217 return 1; 218 219 /* Media bay has too many resources, keep only first one */ 220 if (index > 0 && !strcmp(np->name, "media-bay")) 221 return 1; 222 223 /* Some older IDE resources have bogus sizes */ 224 if (!(strcmp(np->name, "IDE") && strcmp(np->name, "ATA") && 225 strcmp(np->type, "ide") && strcmp(np->type, "ata"))) { 226 if (index == 0 && (res->end - res->start) > 0xfff) 227 res->end = res->start + 0xfff; 228 if (index == 1 && (res->end - res->start) > 0xff) 229 res->end = res->start + 0xff; 230 } 231 return 0; 232 } 233 234 static void macio_create_fixup_irq(struct macio_dev *dev, int index, 235 unsigned int line) 236 { 237 unsigned int irq; 238 239 irq = irq_create_mapping(NULL, line); 240 if (irq != NO_IRQ) { 241 dev->interrupt[index].start = irq; 242 dev->interrupt[index].flags = IORESOURCE_IRQ; 243 dev->interrupt[index].name = dev_name(&dev->ofdev.dev); 244 } 245 if (dev->n_interrupts <= index) 246 dev->n_interrupts = index + 1; 247 } 248 249 static void macio_add_missing_resources(struct macio_dev *dev) 250 { 251 struct device_node *np = dev->ofdev.dev.of_node; 252 unsigned int irq_base; 253 254 /* Gatwick has some missing interrupts on child nodes */ 255 if (dev->bus->chip->type != macio_gatwick) 256 return; 257 258 /* irq_base is always 64 on gatwick. I have no cleaner way to get 259 * that value from here at this point 260 */ 261 irq_base = 64; 262 263 /* Fix SCC */ 264 if (strcmp(np->name, "ch-a") == 0) { 265 macio_create_fixup_irq(dev, 0, 15 + irq_base); 266 macio_create_fixup_irq(dev, 1, 4 + irq_base); 267 macio_create_fixup_irq(dev, 2, 5 + irq_base); 268 printk(KERN_INFO "macio: fixed SCC irqs on gatwick\n"); 269 } 270 271 /* Fix media-bay */ 272 if (strcmp(np->name, "media-bay") == 0) { 273 macio_create_fixup_irq(dev, 0, 29 + irq_base); 274 printk(KERN_INFO "macio: fixed media-bay irq on gatwick\n"); 275 } 276 277 /* Fix left media bay childs */ 278 if (dev->media_bay != NULL && strcmp(np->name, "floppy") == 0) { 279 macio_create_fixup_irq(dev, 0, 19 + irq_base); 280 macio_create_fixup_irq(dev, 1, 1 + irq_base); 281 printk(KERN_INFO "macio: fixed left floppy irqs\n"); 282 } 283 if (dev->media_bay != NULL && strcasecmp(np->name, "ata4") == 0) { 284 macio_create_fixup_irq(dev, 0, 14 + irq_base); 285 macio_create_fixup_irq(dev, 0, 3 + irq_base); 286 printk(KERN_INFO "macio: fixed left ide irqs\n"); 287 } 288 } 289 290 static void macio_setup_interrupts(struct macio_dev *dev) 291 { 292 struct device_node *np = dev->ofdev.dev.of_node; 293 unsigned int irq; 294 int i = 0, j = 0; 295 296 for (;;) { 297 struct resource *res; 298 299 if (j >= MACIO_DEV_COUNT_IRQS) 300 break; 301 res = &dev->interrupt[j]; 302 irq = irq_of_parse_and_map(np, i++); 303 if (irq == NO_IRQ) 304 break; 305 res->start = irq; 306 res->flags = IORESOURCE_IRQ; 307 res->name = dev_name(&dev->ofdev.dev); 308 if (macio_resource_quirks(np, res, i - 1)) { 309 memset(res, 0, sizeof(struct resource)); 310 continue; 311 } else 312 j++; 313 } 314 dev->n_interrupts = j; 315 } 316 317 static void macio_setup_resources(struct macio_dev *dev, 318 struct resource *parent_res) 319 { 320 struct device_node *np = dev->ofdev.dev.of_node; 321 struct resource r; 322 int index; 323 324 for (index = 0; of_address_to_resource(np, index, &r) == 0; index++) { 325 struct resource *res; 326 if (index >= MACIO_DEV_COUNT_RESOURCES) 327 break; 328 res = &dev->resource[index]; 329 *res = r; 330 res->name = dev_name(&dev->ofdev.dev); 331 332 if (macio_resource_quirks(np, res, index)) { 333 memset(res, 0, sizeof(struct resource)); 334 continue; 335 } 336 /* Currently, we consider failure as harmless, this may 337 * change in the future, once I've found all the device 338 * tree bugs in older machines & worked around them 339 */ 340 if (insert_resource(parent_res, res)) { 341 printk(KERN_WARNING "Can't request resource " 342 "%d for MacIO device %s\n", 343 index, dev_name(&dev->ofdev.dev)); 344 } 345 } 346 dev->n_resources = index; 347 } 348 349 /** 350 * macio_add_one_device - Add one device from OF node to the device tree 351 * @chip: pointer to the macio_chip holding the device 352 * @np: pointer to the device node in the OF tree 353 * @in_bay: set to 1 if device is part of a media-bay 354 * 355 * When media-bay is changed to hotswap drivers, this function will 356 * be exposed to the bay driver some way... 357 */ 358 static struct macio_dev * macio_add_one_device(struct macio_chip *chip, 359 struct device *parent, 360 struct device_node *np, 361 struct macio_dev *in_bay, 362 struct resource *parent_res) 363 { 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.parent = parent; 380 dev->ofdev.dev.bus = &macio_bus_type; 381 dev->ofdev.dev.release = macio_release_dev; 382 dev->ofdev.dev.dma_parms = &dev->dma_parms; 383 384 /* Standard DMA paremeters */ 385 dma_set_max_seg_size(&dev->ofdev.dev, 65536); 386 dma_set_seg_boundary(&dev->ofdev.dev, 0xffffffff); 387 388 #ifdef CONFIG_PCI 389 /* Set the DMA ops to the ones from the PCI device, this could be 390 * fishy if we didn't know that on PowerMac it's always direct ops 391 * or iommu ops that will work fine 392 * 393 * To get all the fields, copy all archdata 394 */ 395 dev->ofdev.dev.archdata = chip->lbus.pdev->dev.archdata; 396 #endif /* CONFIG_PCI */ 397 398 #ifdef DEBUG 399 printk("preparing mdev @%p, ofdev @%p, dev @%p, kobj @%p\n", 400 dev, &dev->ofdev, &dev->ofdev.dev, &dev->ofdev.dev.kobj); 401 #endif 402 403 /* MacIO itself has a different reg, we use it's PCI base */ 404 if (np == chip->of_node) { 405 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s", 406 chip->lbus.index, 407 #ifdef CONFIG_PCI 408 (unsigned int)pci_resource_start(chip->lbus.pdev, 0), 409 #else 410 0, /* NuBus may want to do something better here */ 411 #endif 412 MAX_NODE_NAME_SIZE, np->name); 413 } else { 414 reg = of_get_property(np, "reg", NULL); 415 dev_set_name(&dev->ofdev.dev, "%1d.%08x:%.*s", 416 chip->lbus.index, 417 reg ? *reg : 0, MAX_NODE_NAME_SIZE, np->name); 418 } 419 420 /* Setup interrupts & resources */ 421 macio_setup_interrupts(dev); 422 macio_setup_resources(dev, parent_res); 423 macio_add_missing_resources(dev); 424 425 /* Register with core */ 426 if (of_device_register(&dev->ofdev) != 0) { 427 printk(KERN_DEBUG"macio: device registration error for %s!\n", 428 dev_name(&dev->ofdev.dev)); 429 kfree(dev); 430 return NULL; 431 } 432 433 return dev; 434 } 435 436 static int macio_skip_device(struct device_node *np) 437 { 438 if (strncmp(np->name, "battery", 7) == 0) 439 return 1; 440 if (strncmp(np->name, "escc-legacy", 11) == 0) 441 return 1; 442 return 0; 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 (np = NULL; (np = of_get_next_child(pnode, np)) != NULL;) { 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 (strncmp(np->name, "media-bay", 9) == 0) 490 mbdev = mdev; 491 else if (strncmp(np->name, "escc", 4) == 0) 492 sdev = mdev; 493 } 494 495 /* Add media bay devices if any */ 496 if (mbdev) { 497 pnode = mbdev->ofdev.dev.of_node; 498 for (np = NULL; (np = of_get_next_child(pnode, np)) != NULL;) { 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 (np = NULL; (np = of_get_next_child(pnode, np)) != NULL;) { 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 = (char *) "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