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 */ 43struct hppa_dma_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 printk(", additional addresses: "); 877 for (k = 0; k < dev->num_addrs; k++) 878 printk("0x%lx ", dev->addr[k]); 879 } 880 printk("\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