linux/arch/parisc/kernel/drivers.c
<<
>>
Prefs
   1/*
   2 * drivers.c
   3 *
   4 * This program is free software; you can redistribute it and/or
   5 * modify it under the terms of the GNU General Public License
   6 * as published by the Free Software Foundation; either version
   7 * 2 of the License, or (at your option) any later version.
   8 *
   9 * Copyright (c) 1999 The Puffin Group
  10 * Copyright (c) 2001 Matthew Wilcox for Hewlett Packard
  11 * Copyright (c) 2001 Helge Deller <deller@gmx.de>
  12 * Copyright (c) 2001,2002 Ryan Bradetich 
  13 * Copyright (c) 2004-2005 Thibaut VARENE <varenet@parisc-linux.org>
  14 * 
  15 * The file handles registering devices and drivers, then matching them.
  16 * It's the closest we get to a dating agency.
  17 *
  18 * If you're thinking about modifying this file, here are some gotchas to
  19 * bear in mind:
  20 *  - 715/Mirage device paths have a dummy device between Lasi and its children
  21 *  - The EISA adapter may show up as a sibling or child of Wax
  22 *  - Dino has an optionally functional serial port.  If firmware enables it,
  23 *    it shows up as a child of Dino.  If firmware disables it, the buswalk
  24 *    finds it and it shows up as a child of Cujo
  25 *  - Dino has both parisc and pci devices as children
  26 *  - parisc devices are discovered in a random order, including children
  27 *    before parents in some cases.
  28 */
  29
  30#include <linux/slab.h>
  31#include <linux/types.h>
  32#include <linux/kernel.h>
  33#include <linux/pci.h>
  34#include <linux/spinlock.h>
  35#include <linux/string.h>
  36#include <linux/export.h>
  37#include <asm/hardware.h>
  38#include <asm/io.h>
  39#include <asm/pdc.h>
  40#include <asm/parisc-device.h>
  41
  42/* See comments in include/asm-parisc/pci.h */
  43const struct dma_map_ops *hppa_dma_ops __read_mostly;
  44EXPORT_SYMBOL(hppa_dma_ops);
  45
  46static struct device root = {
  47        .init_name = "parisc",
  48};
  49
  50static inline int check_dev(struct device *dev)
  51{
  52        if (dev->bus == &parisc_bus_type) {
  53                struct parisc_device *pdev;
  54                pdev = to_parisc_device(dev);
  55                return pdev->id.hw_type != HPHW_FAULTY;
  56        }
  57        return 1;
  58}
  59
  60static struct device *
  61parse_tree_node(struct device *parent, int index, struct hardware_path *modpath);
  62
  63struct recurse_struct {
  64        void * obj;
  65        int (*fn)(struct device *, void *);
  66};
  67
  68static int descend_children(struct device * dev, void * data)
  69{
  70        struct recurse_struct * recurse_data = (struct recurse_struct *)data;
  71
  72        if (recurse_data->fn(dev, recurse_data->obj))
  73                return 1;
  74        else
  75                return device_for_each_child(dev, recurse_data, descend_children);
  76}
  77
  78/**
  79 *      for_each_padev - Iterate over all devices in the tree
  80 *      @fn:    Function to call for each device.
  81 *      @data:  Data to pass to the called function.
  82 *
  83 *      This performs a depth-first traversal of the tree, calling the
  84 *      function passed for each node.  It calls the function for parents
  85 *      before children.
  86 */
  87
  88static int for_each_padev(int (*fn)(struct device *, void *), void * data)
  89{
  90        struct recurse_struct recurse_data = {
  91                .obj    = data,
  92                .fn     = fn,
  93        };
  94        return device_for_each_child(&root, &recurse_data, descend_children);
  95}
  96
  97/**
  98 * match_device - Report whether this driver can handle this device
  99 * @driver: the PA-RISC driver to try
 100 * @dev: the PA-RISC device to try
 101 */
 102static int match_device(struct parisc_driver *driver, struct parisc_device *dev)
 103{
 104        const struct parisc_device_id *ids;
 105
 106        for (ids = driver->id_table; ids->sversion; ids++) {
 107                if ((ids->sversion != SVERSION_ANY_ID) &&
 108                    (ids->sversion != dev->id.sversion))
 109                        continue;
 110
 111                if ((ids->hw_type != HWTYPE_ANY_ID) &&
 112                    (ids->hw_type != dev->id.hw_type))
 113                        continue;
 114
 115                if ((ids->hversion != HVERSION_ANY_ID) &&
 116                    (ids->hversion != dev->id.hversion))
 117                        continue;
 118
 119                return 1;
 120        }
 121        return 0;
 122}
 123
 124static int parisc_driver_probe(struct device *dev)
 125{
 126        int rc;
 127        struct parisc_device *pa_dev = to_parisc_device(dev);
 128        struct parisc_driver *pa_drv = to_parisc_driver(dev->driver);
 129
 130        rc = pa_drv->probe(pa_dev);
 131
 132        if (!rc)
 133                pa_dev->driver = pa_drv;
 134
 135        return rc;
 136}
 137
 138static int parisc_driver_remove(struct device *dev)
 139{
 140        struct parisc_device *pa_dev = to_parisc_device(dev);
 141        struct parisc_driver *pa_drv = to_parisc_driver(dev->driver);
 142        if (pa_drv->remove)
 143                pa_drv->remove(pa_dev);
 144
 145        return 0;
 146}
 147        
 148
 149/**
 150 * register_parisc_driver - Register this driver if it can handle a device
 151 * @driver: the PA-RISC driver to try
 152 */
 153int register_parisc_driver(struct parisc_driver *driver)
 154{
 155        /* FIXME: we need this because apparently the sti
 156         * driver can be registered twice */
 157        if(driver->drv.name) {
 158                printk(KERN_WARNING 
 159                       "BUG: skipping previously registered driver %s\n",
 160                       driver->name);
 161                return 1;
 162        }
 163
 164        if (!driver->probe) {
 165                printk(KERN_WARNING 
 166                       "BUG: driver %s has no probe routine\n",
 167                       driver->name);
 168                return 1;
 169        }
 170
 171        driver->drv.bus = &parisc_bus_type;
 172
 173        /* We install our own probe and remove routines */
 174        WARN_ON(driver->drv.probe != NULL);
 175        WARN_ON(driver->drv.remove != NULL);
 176
 177        driver->drv.name = driver->name;
 178
 179        return driver_register(&driver->drv);
 180}
 181EXPORT_SYMBOL(register_parisc_driver);
 182
 183
 184struct match_count {
 185        struct parisc_driver * driver;
 186        int count;
 187};
 188
 189static int match_and_count(struct device * dev, void * data)
 190{
 191        struct match_count * m = data;
 192        struct parisc_device * pdev = to_parisc_device(dev);
 193
 194        if (check_dev(dev)) {
 195                if (match_device(m->driver, pdev))
 196                        m->count++;
 197        }
 198        return 0;
 199}
 200
 201/**
 202 * count_parisc_driver - count # of devices this driver would match
 203 * @driver: the PA-RISC driver to try
 204 *
 205 * Use by IOMMU support to "guess" the right size IOPdir.
 206 * Formula is something like memsize/(num_iommu * entry_size).
 207 */
 208int count_parisc_driver(struct parisc_driver *driver)
 209{
 210        struct match_count m = {
 211                .driver = driver,
 212                .count  = 0,
 213        };
 214
 215        for_each_padev(match_and_count, &m);
 216
 217        return m.count;
 218}
 219
 220
 221
 222/**
 223 * unregister_parisc_driver - Unregister this driver from the list of drivers
 224 * @driver: the PA-RISC driver to unregister
 225 */
 226int unregister_parisc_driver(struct parisc_driver *driver)
 227{
 228        driver_unregister(&driver->drv);
 229        return 0;
 230}
 231EXPORT_SYMBOL(unregister_parisc_driver);
 232
 233struct find_data {
 234        unsigned long hpa;
 235        struct parisc_device * dev;
 236};
 237
 238static int find_device(struct device * dev, void * data)
 239{
 240        struct parisc_device * pdev = to_parisc_device(dev);
 241        struct find_data * d = (struct find_data*)data;
 242
 243        if (check_dev(dev)) {
 244                if (pdev->hpa.start == d->hpa) {
 245                        d->dev = pdev;
 246                        return 1;
 247                }
 248        }
 249        return 0;
 250}
 251
 252static struct parisc_device *find_device_by_addr(unsigned long hpa)
 253{
 254        struct find_data d = {
 255                .hpa    = hpa,
 256        };
 257        int ret;
 258
 259        ret = for_each_padev(find_device, &d);
 260        return ret ? d.dev : NULL;
 261}
 262
 263/**
 264 * find_pa_parent_type - Find a parent of a specific type
 265 * @dev: The device to start searching from
 266 * @type: The device type to search for.
 267 *
 268 * Walks up the device tree looking for a device of the specified type.
 269 * If it finds it, it returns it.  If not, it returns NULL.
 270 */
 271const struct parisc_device *
 272find_pa_parent_type(const struct parisc_device *padev, int type)
 273{
 274        const struct device *dev = &padev->dev;
 275        while (dev != &root) {
 276                struct parisc_device *candidate = to_parisc_device(dev);
 277                if (candidate->id.hw_type == type)
 278                        return candidate;
 279                dev = dev->parent;
 280        }
 281
 282        return NULL;
 283}
 284
 285/*
 286 * get_node_path fills in @path with the firmware path to the device.
 287 * Note that if @node is a parisc device, we don't fill in the 'mod' field.
 288 * This is because both callers pass the parent and fill in the mod
 289 * themselves.  If @node is a PCI device, we do fill it in, even though this
 290 * is inconsistent.
 291 */
 292static void get_node_path(struct device *dev, struct hardware_path *path)
 293{
 294        int i = 5;
 295        memset(&path->bc, -1, 6);
 296
 297        if (dev_is_pci(dev)) {
 298                unsigned int devfn = to_pci_dev(dev)->devfn;
 299                path->mod = PCI_FUNC(devfn);
 300                path->bc[i--] = PCI_SLOT(devfn);
 301                dev = dev->parent;
 302        }
 303
 304        while (dev != &root) {
 305                if (dev_is_pci(dev)) {
 306                        unsigned int devfn = to_pci_dev(dev)->devfn;
 307                        path->bc[i--] = PCI_SLOT(devfn) | (PCI_FUNC(devfn)<< 5);
 308                } else if (dev->bus == &parisc_bus_type) {
 309                        path->bc[i--] = to_parisc_device(dev)->hw_path;
 310                }
 311                dev = dev->parent;
 312        }
 313}
 314
 315static char *print_hwpath(struct hardware_path *path, char *output)
 316{
 317        int i;
 318        for (i = 0; i < 6; i++) {
 319                if (path->bc[i] == -1)
 320                        continue;
 321                output += sprintf(output, "%u/", (unsigned char) path->bc[i]);
 322        }
 323        output += sprintf(output, "%u", (unsigned char) path->mod);
 324        return output;
 325}
 326
 327/**
 328 * print_pa_hwpath - Returns hardware path for PA devices
 329 * dev: The device to return the path for
 330 * output: Pointer to a previously-allocated array to place the path in.
 331 *
 332 * This function fills in the output array with a human-readable path
 333 * to a PA device.  This string is compatible with that used by PDC, and
 334 * may be printed on the outside of the box.
 335 */
 336char *print_pa_hwpath(struct parisc_device *dev, char *output)
 337{
 338        struct hardware_path path;
 339
 340        get_node_path(dev->dev.parent, &path);
 341        path.mod = dev->hw_path;
 342        return print_hwpath(&path, output);
 343}
 344EXPORT_SYMBOL(print_pa_hwpath);
 345
 346#if defined(CONFIG_PCI) || defined(CONFIG_ISA)
 347/**
 348 * get_pci_node_path - Determines the hardware path for a PCI device
 349 * @pdev: The device to return the path for
 350 * @path: Pointer to a previously-allocated array to place the path in.
 351 *
 352 * This function fills in the hardware_path structure with the route to
 353 * the specified PCI device.  This structure is suitable for passing to
 354 * PDC calls.
 355 */
 356void get_pci_node_path(struct pci_dev *pdev, struct hardware_path *path)
 357{
 358        get_node_path(&pdev->dev, path);
 359}
 360EXPORT_SYMBOL(get_pci_node_path);
 361
 362/**
 363 * print_pci_hwpath - Returns hardware path for PCI devices
 364 * dev: The device to return the path for
 365 * output: Pointer to a previously-allocated array to place the path in.
 366 *
 367 * This function fills in the output array with a human-readable path
 368 * to a PCI device.  This string is compatible with that used by PDC, and
 369 * may be printed on the outside of the box.
 370 */
 371char *print_pci_hwpath(struct pci_dev *dev, char *output)
 372{
 373        struct hardware_path path;
 374
 375        get_pci_node_path(dev, &path);
 376        return print_hwpath(&path, output);
 377}
 378EXPORT_SYMBOL(print_pci_hwpath);
 379
 380#endif /* defined(CONFIG_PCI) || defined(CONFIG_ISA) */
 381
 382static void setup_bus_id(struct parisc_device *padev)
 383{
 384        struct hardware_path path;
 385        char name[28];
 386        char *output = name;
 387        int i;
 388
 389        get_node_path(padev->dev.parent, &path);
 390
 391        for (i = 0; i < 6; i++) {
 392                if (path.bc[i] == -1)
 393                        continue;
 394                output += sprintf(output, "%u:", (unsigned char) path.bc[i]);
 395        }
 396        sprintf(output, "%u", (unsigned char) padev->hw_path);
 397        dev_set_name(&padev->dev, name);
 398}
 399
 400struct parisc_device * create_tree_node(char id, struct device *parent)
 401{
 402        struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 403        if (!dev)
 404                return NULL;
 405
 406        dev->hw_path = id;
 407        dev->id.hw_type = HPHW_FAULTY;
 408
 409        dev->dev.parent = parent;
 410        setup_bus_id(dev);
 411
 412        dev->dev.bus = &parisc_bus_type;
 413        dev->dma_mask = 0xffffffffUL;   /* PARISC devices are 32-bit */
 414
 415        /* make the generic dma mask a pointer to the parisc one */
 416        dev->dev.dma_mask = &dev->dma_mask;
 417        dev->dev.coherent_dma_mask = dev->dma_mask;
 418        if (device_register(&dev->dev)) {
 419                kfree(dev);
 420                return NULL;
 421        }
 422
 423        return dev;
 424}
 425
 426struct match_id_data {
 427        char id;
 428        struct parisc_device * dev;
 429};
 430
 431static int match_by_id(struct device * dev, void * data)
 432{
 433        struct parisc_device * pdev = to_parisc_device(dev);
 434        struct match_id_data * d = data;
 435
 436        if (pdev->hw_path == d->id) {
 437                d->dev = pdev;
 438                return 1;
 439        }
 440        return 0;
 441}
 442
 443/**
 444 * alloc_tree_node - returns a device entry in the iotree
 445 * @parent: the parent node in the tree
 446 * @id: the element of the module path for this entry
 447 *
 448 * Checks all the children of @parent for a matching @id.  If none
 449 * found, it allocates a new device and returns it.
 450 */
 451static struct parisc_device * alloc_tree_node(struct device *parent, char id)
 452{
 453        struct match_id_data d = {
 454                .id = id,
 455        };
 456        if (device_for_each_child(parent, &d, match_by_id))
 457                return d.dev;
 458        else
 459                return create_tree_node(id, parent);
 460}
 461
 462static struct parisc_device *create_parisc_device(struct hardware_path *modpath)
 463{
 464        int i;
 465        struct device *parent = &root;
 466        for (i = 0; i < 6; i++) {
 467                if (modpath->bc[i] == -1)
 468                        continue;
 469                parent = &alloc_tree_node(parent, modpath->bc[i])->dev;
 470        }
 471        return alloc_tree_node(parent, modpath->mod);
 472}
 473
 474struct parisc_device *
 475alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path)
 476{
 477        int status;
 478        unsigned long bytecnt;
 479        u8 iodc_data[32];
 480        struct parisc_device *dev;
 481        const char *name;
 482
 483        /* Check to make sure this device has not already been added - Ryan */
 484        if (find_device_by_addr(hpa) != NULL)
 485                return NULL;
 486
 487        status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32);
 488        if (status != PDC_OK)
 489                return NULL;
 490
 491        dev = create_parisc_device(mod_path);
 492        if (dev->id.hw_type != HPHW_FAULTY) {
 493                printk(KERN_ERR "Two devices have hardware path [%s].  "
 494                                "IODC data for second device: "
 495                                "%02x%02x%02x%02x%02x%02x\n"
 496                                "Rearranging GSC cards sometimes helps\n",
 497                        parisc_pathname(dev), iodc_data[0], iodc_data[1],
 498                        iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]);
 499                return NULL;
 500        }
 501
 502        dev->id.hw_type = iodc_data[3] & 0x1f;
 503        dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4);
 504        dev->id.hversion_rev = iodc_data[1] & 0x0f;
 505        dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) |
 506                        (iodc_data[5] << 8) | iodc_data[6];
 507        dev->hpa.name = parisc_pathname(dev);
 508        dev->hpa.start = hpa;
 509        /* This is awkward.  The STI spec says that gfx devices may occupy
 510         * 32MB or 64MB.  Unfortunately, we don't know how to tell whether
 511         * it's the former or the latter.  Assumptions either way can hurt us.
 512         */
 513        if (hpa == 0xf4000000 || hpa == 0xf8000000) {
 514                dev->hpa.end = hpa + 0x03ffffff;
 515        } else if (hpa == 0xf6000000 || hpa == 0xfa000000) {
 516                dev->hpa.end = hpa + 0x01ffffff;
 517        } else {
 518                dev->hpa.end = hpa + 0xfff;
 519        }
 520        dev->hpa.flags = IORESOURCE_MEM;
 521        name = parisc_hardware_description(&dev->id);
 522        if (name) {
 523                strlcpy(dev->name, name, sizeof(dev->name));
 524        }
 525
 526        /* Silently fail things like mouse ports which are subsumed within
 527         * the keyboard controller
 528         */
 529        if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa))
 530                printk("Unable to claim HPA %lx for device %s\n",
 531                                hpa, name);
 532
 533        return dev;
 534}
 535
 536static int parisc_generic_match(struct device *dev, struct device_driver *drv)
 537{
 538        return match_device(to_parisc_driver(drv), to_parisc_device(dev));
 539}
 540
 541static ssize_t make_modalias(struct device *dev, char *buf)
 542{
 543        const struct parisc_device *padev = to_parisc_device(dev);
 544        const struct parisc_device_id *id = &padev->id;
 545
 546        return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n",
 547                (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev,
 548                (u32)id->sversion);
 549}
 550
 551static int parisc_uevent(struct device *dev, struct kobj_uevent_env *env)
 552{
 553        const struct parisc_device *padev;
 554        char modalias[40];
 555
 556        if (!dev)
 557                return -ENODEV;
 558
 559        padev = to_parisc_device(dev);
 560        if (!padev)
 561                return -ENODEV;
 562
 563        if (add_uevent_var(env, "PARISC_NAME=%s", padev->name))
 564                return -ENOMEM;
 565
 566        make_modalias(dev, modalias);
 567        if (add_uevent_var(env, "MODALIAS=%s", modalias))
 568                return -ENOMEM;
 569
 570        return 0;
 571}
 572
 573#define pa_dev_attr(name, field, format_string)                         \
 574static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf)                \
 575{                                                                       \
 576        struct parisc_device *padev = to_parisc_device(dev);            \
 577        return sprintf(buf, format_string, padev->field);               \
 578}
 579
 580#define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format)
 581
 582pa_dev_attr(irq, irq, "%u\n");
 583pa_dev_attr_id(hw_type, "0x%02x\n");
 584pa_dev_attr(rev, id.hversion_rev, "0x%x\n");
 585pa_dev_attr_id(hversion, "0x%03x\n");
 586pa_dev_attr_id(sversion, "0x%05x\n");
 587
 588static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
 589{
 590        return make_modalias(dev, buf);
 591}
 592
 593static struct device_attribute parisc_device_attrs[] = {
 594        __ATTR_RO(irq),
 595        __ATTR_RO(hw_type),
 596        __ATTR_RO(rev),
 597        __ATTR_RO(hversion),
 598        __ATTR_RO(sversion),
 599        __ATTR_RO(modalias),
 600        __ATTR_NULL,
 601};
 602
 603struct bus_type parisc_bus_type = {
 604        .name = "parisc",
 605        .match = parisc_generic_match,
 606        .uevent = parisc_uevent,
 607        .dev_attrs = parisc_device_attrs,
 608        .probe = parisc_driver_probe,
 609        .remove = parisc_driver_remove,
 610};
 611
 612/**
 613 * register_parisc_device - Locate a driver to manage this device.
 614 * @dev: The parisc device.
 615 *
 616 * Search the driver list for a driver that is willing to manage
 617 * this device.
 618 */
 619int register_parisc_device(struct parisc_device *dev)
 620{
 621        if (!dev)
 622                return 0;
 623
 624        if (dev->driver)
 625                return 1;
 626
 627        return 0;
 628}
 629
 630/**
 631 * match_pci_device - Matches a pci device against a given hardware path
 632 * entry.
 633 * @dev: the generic device (known to be contained by a pci_dev).
 634 * @index: the current BC index
 635 * @modpath: the hardware path.
 636 * @return: true if the device matches the hardware path.
 637 */
 638static int match_pci_device(struct device *dev, int index,
 639                struct hardware_path *modpath)
 640{
 641        struct pci_dev *pdev = to_pci_dev(dev);
 642        int id;
 643
 644        if (index == 5) {
 645                /* we are at the end of the path, and on the actual device */
 646                unsigned int devfn = pdev->devfn;
 647                return ((modpath->bc[5] == PCI_SLOT(devfn)) &&
 648                                        (modpath->mod == PCI_FUNC(devfn)));
 649        }
 650
 651        id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5);
 652        return (modpath->bc[index] == id);
 653}
 654
 655/**
 656 * match_parisc_device - Matches a parisc device against a given hardware
 657 * path entry.
 658 * @dev: the generic device (known to be contained by a parisc_device).
 659 * @index: the current BC index
 660 * @modpath: the hardware path.
 661 * @return: true if the device matches the hardware path.
 662 */
 663static int match_parisc_device(struct device *dev, int index,
 664                struct hardware_path *modpath)
 665{
 666        struct parisc_device *curr = to_parisc_device(dev);
 667        char id = (index == 6) ? modpath->mod : modpath->bc[index];
 668
 669        return (curr->hw_path == id);
 670}
 671
 672struct parse_tree_data {
 673        int index;
 674        struct hardware_path * modpath;
 675        struct device * dev;
 676};
 677
 678static int check_parent(struct device * dev, void * data)
 679{
 680        struct parse_tree_data * d = data;
 681
 682        if (check_dev(dev)) {
 683                if (dev->bus == &parisc_bus_type) {
 684                        if (match_parisc_device(dev, d->index, d->modpath))
 685                                d->dev = dev;
 686                } else if (dev_is_pci(dev)) {
 687                        if (match_pci_device(dev, d->index, d->modpath))
 688                                d->dev = dev;
 689                } else if (dev->bus == NULL) {
 690                        /* we are on a bus bridge */
 691                        struct device *new = parse_tree_node(dev, d->index, d->modpath);
 692                        if (new)
 693                                d->dev = new;
 694                }
 695        }
 696        return d->dev != NULL;
 697}
 698
 699/**
 700 * parse_tree_node - returns a device entry in the iotree
 701 * @parent: the parent node in the tree
 702 * @index: the current BC index
 703 * @modpath: the hardware_path struct to match a device against
 704 * @return: The corresponding device if found, NULL otherwise.
 705 *
 706 * Checks all the children of @parent for a matching @id.  If none
 707 * found, it returns NULL.
 708 */
 709static struct device *
 710parse_tree_node(struct device *parent, int index, struct hardware_path *modpath)
 711{
 712        struct parse_tree_data d = {
 713                .index          = index,
 714                .modpath        = modpath,
 715        };
 716
 717        struct recurse_struct recurse_data = {
 718                .obj    = &d,
 719                .fn     = check_parent,
 720        };
 721
 722        if (device_for_each_child(parent, &recurse_data, descend_children))
 723                /* nothing */;
 724
 725        return d.dev;
 726}
 727
 728/**
 729 * hwpath_to_device - Finds the generic device corresponding to a given hardware path.
 730 * @modpath: the hardware path.
 731 * @return: The target device, NULL if not found.
 732 */
 733struct device *hwpath_to_device(struct hardware_path *modpath)
 734{
 735        int i;
 736        struct device *parent = &root;
 737        for (i = 0; i < 6; i++) {
 738                if (modpath->bc[i] == -1)
 739                        continue;
 740                parent = parse_tree_node(parent, i, modpath);
 741                if (!parent)
 742                        return NULL;
 743        }
 744        if (dev_is_pci(parent)) /* pci devices already parse MOD */
 745                return parent;
 746        else
 747                return parse_tree_node(parent, 6, modpath);
 748}
 749EXPORT_SYMBOL(hwpath_to_device);
 750
 751/**
 752 * device_to_hwpath - Populates the hwpath corresponding to the given device.
 753 * @param dev the target device
 754 * @param path pointer to a previously allocated hwpath struct to be filled in
 755 */
 756void device_to_hwpath(struct device *dev, struct hardware_path *path)
 757{
 758        struct parisc_device *padev;
 759        if (dev->bus == &parisc_bus_type) {
 760                padev = to_parisc_device(dev);
 761                get_node_path(dev->parent, path);
 762                path->mod = padev->hw_path;
 763        } else if (dev_is_pci(dev)) {
 764                get_node_path(dev, path);
 765        }
 766}
 767EXPORT_SYMBOL(device_to_hwpath);
 768
 769#define BC_PORT_MASK 0x8
 770#define BC_LOWER_PORT 0x8
 771
 772#define BUS_CONVERTER(dev) \
 773        ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT))
 774
 775#define IS_LOWER_PORT(dev) \
 776        ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \
 777                & BC_PORT_MASK) == BC_LOWER_PORT)
 778
 779#define MAX_NATIVE_DEVICES 64
 780#define NATIVE_DEVICE_OFFSET 0x1000
 781
 782#define FLEX_MASK       F_EXTEND(0xfffc0000)
 783#define IO_IO_LOW       offsetof(struct bc_module, io_io_low)
 784#define IO_IO_HIGH      offsetof(struct bc_module, io_io_high)
 785#define READ_IO_IO_LOW(dev)  (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW)
 786#define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH)
 787
 788static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,
 789                            struct device *parent);
 790
 791void walk_lower_bus(struct parisc_device *dev)
 792{
 793        unsigned long io_io_low, io_io_high;
 794
 795        if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev))
 796                return;
 797
 798        if (dev->id.hw_type == HPHW_IOA) {
 799                io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16);
 800                io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET;
 801        } else {
 802                io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK;
 803                io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK;
 804        }
 805
 806        walk_native_bus(io_io_low, io_io_high, &dev->dev);
 807}
 808
 809/**
 810 * walk_native_bus -- Probe a bus for devices
 811 * @io_io_low: Base address of this bus.
 812 * @io_io_high: Last address of this bus.
 813 * @parent: The parent bus device.
 814 * 
 815 * A native bus (eg Runway or GSC) may have up to 64 devices on it,
 816 * spaced at intervals of 0x1000 bytes.  PDC may not inform us of these
 817 * devices, so we have to probe for them.  Unfortunately, we may find
 818 * devices which are not physically connected (such as extra serial &
 819 * keyboard ports).  This problem is not yet solved.
 820 */
 821static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high,
 822                            struct device *parent)
 823{
 824        int i, devices_found = 0;
 825        unsigned long hpa = io_io_low;
 826        struct hardware_path path;
 827
 828        get_node_path(parent, &path);
 829        do {
 830                for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) {
 831                        struct parisc_device *dev;
 832
 833                        /* Was the device already added by Firmware? */
 834                        dev = find_device_by_addr(hpa);
 835                        if (!dev) {
 836                                path.mod = i;
 837                                dev = alloc_pa_dev(hpa, &path);
 838                                if (!dev)
 839                                        continue;
 840
 841                                register_parisc_device(dev);
 842                                devices_found++;
 843                        }
 844                        walk_lower_bus(dev);
 845                }
 846        } while(!devices_found && hpa < io_io_high);
 847}
 848
 849#define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000)
 850
 851/**
 852 * walk_central_bus - Find devices attached to the central bus
 853 *
 854 * PDC doesn't tell us about all devices in the system.  This routine
 855 * finds devices connected to the central bus.
 856 */
 857void walk_central_bus(void)
 858{
 859        walk_native_bus(CENTRAL_BUS_ADDR,
 860                        CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET),
 861                        &root);
 862}
 863
 864static void print_parisc_device(struct parisc_device *dev)
 865{
 866        char hw_path[64];
 867        static int count;
 868
 869        print_pa_hwpath(dev, hw_path);
 870        printk(KERN_INFO "%d. %s at 0x%p [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }",
 871                ++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type,
 872                dev->id.hversion_rev, dev->id.hversion, dev->id.sversion);
 873
 874        if (dev->num_addrs) {
 875                int k;
 876                pr_cont(", additional addresses: ");
 877                for (k = 0; k < dev->num_addrs; k++)
 878                        pr_cont("0x%lx ", dev->addr[k]);
 879        }
 880        pr_cont("\n");
 881}
 882
 883/**
 884 * init_parisc_bus - Some preparation to be done before inventory
 885 */
 886void init_parisc_bus(void)
 887{
 888        if (bus_register(&parisc_bus_type))
 889                panic("Could not register PA-RISC bus type\n");
 890        if (device_register(&root))
 891                panic("Could not register PA-RISC root device\n");
 892        get_device(&root);
 893}
 894
 895
 896static int print_one_device(struct device * dev, void * data)
 897{
 898        struct parisc_device * pdev = to_parisc_device(dev);
 899
 900        if (check_dev(dev))
 901                print_parisc_device(pdev);
 902        return 0;
 903}
 904
 905/**
 906 * print_parisc_devices - Print out a list of devices found in this system
 907 */
 908void print_parisc_devices(void)
 909{
 910        for_each_padev(print_one_device, NULL);
 911}
 912