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