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