linux/drivers/macintosh/macio_asic.c
<<
>>
Prefs
   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
  35static struct macio_chip      *macio_on_hold;
  36
  37static 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
  47struct 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
  60void macio_dev_put(struct macio_dev *dev)
  61{
  62        if (dev)
  63                put_device(&dev->ofdev.dev);
  64}
  65
  66
  67static 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
  91static 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
 103static 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
 112static 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
 122static 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
 132extern const struct attribute_group *macio_dev_groups[];
 133
 134struct 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
 146static int __init macio_bus_driver_init(void)
 147{
 148        return bus_register(&macio_bus_type);
 149}
 150
 151postcore_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 */
 164static 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 */
 181static 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
 229static 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
 244static 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
 285static 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
 312static 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 */
 353static 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#if defined(CONFIG_PCI) && defined(CONFIG_DMA_OPS)
 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 && CONFIG_DMA_OPS */
 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
 435static 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 */
 452static 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 */
 523int 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 */
 536void macio_unregister_driver(struct macio_driver *drv)
 537{
 538        driver_unregister(&drv->driver);
 539}
 540
 541/* Managed MacIO resources */
 542struct macio_devres {
 543        u32     res_mask;
 544};
 545
 546static 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
 559int 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
 572static 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 */
 591int 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
 609err_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 */
 624void 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 */
 648int 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
 657err_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
 669void 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
 680static 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
 740static 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 */
 749static 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};
 757MODULE_DEVICE_TABLE (pci, pci_ids);
 758
 759/* pci driver glue; this is a "new style" PCI driver module */
 760static 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
 770static 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
 782module_init(macio_module_init);
 783
 784EXPORT_SYMBOL(macio_register_driver);
 785EXPORT_SYMBOL(macio_unregister_driver);
 786EXPORT_SYMBOL(macio_dev_get);
 787EXPORT_SYMBOL(macio_dev_put);
 788EXPORT_SYMBOL(macio_request_resource);
 789EXPORT_SYMBOL(macio_release_resource);
 790EXPORT_SYMBOL(macio_request_resources);
 791EXPORT_SYMBOL(macio_release_resources);
 792EXPORT_SYMBOL(macio_enable_devres);
 793
 794