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 */ 43 const struct dma_map_ops *hppa_dma_ops __read_mostly; 44 EXPORT_SYMBOL(hppa_dma_ops); 45 46 static struct device root = { 47 .init_name = "parisc", 48 }; 49 50 static 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 60 static struct device * 61 parse_tree_node(struct device *parent, int index, struct hardware_path *modpath); 62 63 struct recurse_struct { 64 void * obj; 65 int (*fn)(struct device *, void *); 66 }; 67 68 static 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 88 static 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 */ 102 static 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 124 static 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 138 static int __exit 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 */ 153 int 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 } 181 EXPORT_SYMBOL(register_parisc_driver); 182 183 184 struct match_count { 185 struct parisc_driver * driver; 186 int count; 187 }; 188 189 static 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 */ 208 int __init 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 */ 226 int unregister_parisc_driver(struct parisc_driver *driver) 227 { 228 driver_unregister(&driver->drv); 229 return 0; 230 } 231 EXPORT_SYMBOL(unregister_parisc_driver); 232 233 struct find_data { 234 unsigned long hpa; 235 struct parisc_device * dev; 236 }; 237 238 static 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 252 static 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 */ 271 const struct parisc_device * 272 find_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 */ 292 static 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 315 static 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 */ 336 char *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 } 344 EXPORT_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 */ 356 void get_pci_node_path(struct pci_dev *pdev, struct hardware_path *path) 357 { 358 get_node_path(&pdev->dev, path); 359 } 360 EXPORT_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 */ 371 char *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 } 378 EXPORT_SYMBOL(print_pci_hwpath); 379 380 #endif /* defined(CONFIG_PCI) || defined(CONFIG_ISA) */ 381 382 static 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 400 struct parisc_device * __init 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 426 struct match_id_data { 427 char id; 428 struct parisc_device * dev; 429 }; 430 431 static 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 */ 451 static struct parisc_device * __init alloc_tree_node( 452 struct device *parent, char id) 453 { 454 struct match_id_data d = { 455 .id = id, 456 }; 457 if (device_for_each_child(parent, &d, match_by_id)) 458 return d.dev; 459 else 460 return create_tree_node(id, parent); 461 } 462 463 static struct parisc_device *create_parisc_device(struct hardware_path *modpath) 464 { 465 int i; 466 struct device *parent = &root; 467 for (i = 0; i < 6; i++) { 468 if (modpath->bc[i] == -1) 469 continue; 470 parent = &alloc_tree_node(parent, modpath->bc[i])->dev; 471 } 472 return alloc_tree_node(parent, modpath->mod); 473 } 474 475 struct parisc_device * __init 476 alloc_pa_dev(unsigned long hpa, struct hardware_path *mod_path) 477 { 478 int status; 479 unsigned long bytecnt; 480 u8 iodc_data[32]; 481 struct parisc_device *dev; 482 const char *name; 483 484 /* Check to make sure this device has not already been added - Ryan */ 485 if (find_device_by_addr(hpa) != NULL) 486 return NULL; 487 488 status = pdc_iodc_read(&bytecnt, hpa, 0, &iodc_data, 32); 489 if (status != PDC_OK) 490 return NULL; 491 492 dev = create_parisc_device(mod_path); 493 if (dev->id.hw_type != HPHW_FAULTY) { 494 printk(KERN_ERR "Two devices have hardware path [%s]. " 495 "IODC data for second device: " 496 "%02x%02x%02x%02x%02x%02x\n" 497 "Rearranging GSC cards sometimes helps\n", 498 parisc_pathname(dev), iodc_data[0], iodc_data[1], 499 iodc_data[3], iodc_data[4], iodc_data[5], iodc_data[6]); 500 return NULL; 501 } 502 503 dev->id.hw_type = iodc_data[3] & 0x1f; 504 dev->id.hversion = (iodc_data[0] << 4) | ((iodc_data[1] & 0xf0) >> 4); 505 dev->id.hversion_rev = iodc_data[1] & 0x0f; 506 dev->id.sversion = ((iodc_data[4] & 0x0f) << 16) | 507 (iodc_data[5] << 8) | iodc_data[6]; 508 dev->hpa.name = parisc_pathname(dev); 509 dev->hpa.start = hpa; 510 /* This is awkward. The STI spec says that gfx devices may occupy 511 * 32MB or 64MB. Unfortunately, we don't know how to tell whether 512 * it's the former or the latter. Assumptions either way can hurt us. 513 */ 514 if (hpa == 0xf4000000 || hpa == 0xf8000000) { 515 dev->hpa.end = hpa + 0x03ffffff; 516 } else if (hpa == 0xf6000000 || hpa == 0xfa000000) { 517 dev->hpa.end = hpa + 0x01ffffff; 518 } else { 519 dev->hpa.end = hpa + 0xfff; 520 } 521 dev->hpa.flags = IORESOURCE_MEM; 522 name = parisc_hardware_description(&dev->id); 523 if (name) { 524 strlcpy(dev->name, name, sizeof(dev->name)); 525 } 526 527 /* Silently fail things like mouse ports which are subsumed within 528 * the keyboard controller 529 */ 530 if ((hpa & 0xfff) == 0 && insert_resource(&iomem_resource, &dev->hpa)) 531 printk("Unable to claim HPA %lx for device %s\n", 532 hpa, name); 533 534 return dev; 535 } 536 537 static int parisc_generic_match(struct device *dev, struct device_driver *drv) 538 { 539 return match_device(to_parisc_driver(drv), to_parisc_device(dev)); 540 } 541 542 static ssize_t make_modalias(struct device *dev, char *buf) 543 { 544 const struct parisc_device *padev = to_parisc_device(dev); 545 const struct parisc_device_id *id = &padev->id; 546 547 return sprintf(buf, "parisc:t%02Xhv%04Xrev%02Xsv%08X\n", 548 (u8)id->hw_type, (u16)id->hversion, (u8)id->hversion_rev, 549 (u32)id->sversion); 550 } 551 552 static int parisc_uevent(struct device *dev, struct kobj_uevent_env *env) 553 { 554 const struct parisc_device *padev; 555 char modalias[40]; 556 557 if (!dev) 558 return -ENODEV; 559 560 padev = to_parisc_device(dev); 561 if (!padev) 562 return -ENODEV; 563 564 if (add_uevent_var(env, "PARISC_NAME=%s", padev->name)) 565 return -ENOMEM; 566 567 make_modalias(dev, modalias); 568 if (add_uevent_var(env, "MODALIAS=%s", modalias)) 569 return -ENOMEM; 570 571 return 0; 572 } 573 574 #define pa_dev_attr(name, field, format_string) \ 575 static ssize_t name##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 576 { \ 577 struct parisc_device *padev = to_parisc_device(dev); \ 578 return sprintf(buf, format_string, padev->field); \ 579 } \ 580 static DEVICE_ATTR_RO(name); 581 582 #define pa_dev_attr_id(field, format) pa_dev_attr(field, id.field, format) 583 584 pa_dev_attr(irq, irq, "%u\n"); 585 pa_dev_attr_id(hw_type, "0x%02x\n"); 586 pa_dev_attr(rev, id.hversion_rev, "0x%x\n"); 587 pa_dev_attr_id(hversion, "0x%03x\n"); 588 pa_dev_attr_id(sversion, "0x%05x\n"); 589 590 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 591 { 592 return make_modalias(dev, buf); 593 } 594 static DEVICE_ATTR_RO(modalias); 595 596 static struct attribute *parisc_device_attrs[] = { 597 &dev_attr_irq.attr, 598 &dev_attr_hw_type.attr, 599 &dev_attr_rev.attr, 600 &dev_attr_hversion.attr, 601 &dev_attr_sversion.attr, 602 &dev_attr_modalias.attr, 603 NULL, 604 }; 605 ATTRIBUTE_GROUPS(parisc_device); 606 607 struct bus_type parisc_bus_type = { 608 .name = "parisc", 609 .match = parisc_generic_match, 610 .uevent = parisc_uevent, 611 .dev_groups = parisc_device_groups, 612 .probe = parisc_driver_probe, 613 .remove = __exit_p(parisc_driver_remove), 614 }; 615 616 /** 617 * register_parisc_device - Locate a driver to manage this device. 618 * @dev: The parisc device. 619 * 620 * Search the driver list for a driver that is willing to manage 621 * this device. 622 */ 623 int __init register_parisc_device(struct parisc_device *dev) 624 { 625 if (!dev) 626 return 0; 627 628 if (dev->driver) 629 return 1; 630 631 return 0; 632 } 633 634 /** 635 * match_pci_device - Matches a pci device against a given hardware path 636 * entry. 637 * @dev: the generic device (known to be contained by a pci_dev). 638 * @index: the current BC index 639 * @modpath: the hardware path. 640 * @return: true if the device matches the hardware path. 641 */ 642 static int match_pci_device(struct device *dev, int index, 643 struct hardware_path *modpath) 644 { 645 struct pci_dev *pdev = to_pci_dev(dev); 646 int id; 647 648 if (index == 5) { 649 /* we are at the end of the path, and on the actual device */ 650 unsigned int devfn = pdev->devfn; 651 return ((modpath->bc[5] == PCI_SLOT(devfn)) && 652 (modpath->mod == PCI_FUNC(devfn))); 653 } 654 655 /* index might be out of bounds for bc[] */ 656 if (index >= 6) 657 return 0; 658 659 id = PCI_SLOT(pdev->devfn) | (PCI_FUNC(pdev->devfn) << 5); 660 return (modpath->bc[index] == id); 661 } 662 663 /** 664 * match_parisc_device - Matches a parisc device against a given hardware 665 * path entry. 666 * @dev: the generic device (known to be contained by a parisc_device). 667 * @index: the current BC index 668 * @modpath: the hardware path. 669 * @return: true if the device matches the hardware path. 670 */ 671 static int match_parisc_device(struct device *dev, int index, 672 struct hardware_path *modpath) 673 { 674 struct parisc_device *curr = to_parisc_device(dev); 675 char id = (index == 6) ? modpath->mod : modpath->bc[index]; 676 677 return (curr->hw_path == id); 678 } 679 680 struct parse_tree_data { 681 int index; 682 struct hardware_path * modpath; 683 struct device * dev; 684 }; 685 686 static int check_parent(struct device * dev, void * data) 687 { 688 struct parse_tree_data * d = data; 689 690 if (check_dev(dev)) { 691 if (dev->bus == &parisc_bus_type) { 692 if (match_parisc_device(dev, d->index, d->modpath)) 693 d->dev = dev; 694 } else if (dev_is_pci(dev)) { 695 if (match_pci_device(dev, d->index, d->modpath)) 696 d->dev = dev; 697 } else if (dev->bus == NULL) { 698 /* we are on a bus bridge */ 699 struct device *new = parse_tree_node(dev, d->index, d->modpath); 700 if (new) 701 d->dev = new; 702 } 703 } 704 return d->dev != NULL; 705 } 706 707 /** 708 * parse_tree_node - returns a device entry in the iotree 709 * @parent: the parent node in the tree 710 * @index: the current BC index 711 * @modpath: the hardware_path struct to match a device against 712 * @return: The corresponding device if found, NULL otherwise. 713 * 714 * Checks all the children of @parent for a matching @id. If none 715 * found, it returns NULL. 716 */ 717 static struct device * 718 parse_tree_node(struct device *parent, int index, struct hardware_path *modpath) 719 { 720 struct parse_tree_data d = { 721 .index = index, 722 .modpath = modpath, 723 }; 724 725 struct recurse_struct recurse_data = { 726 .obj = &d, 727 .fn = check_parent, 728 }; 729 730 if (device_for_each_child(parent, &recurse_data, descend_children)) 731 /* nothing */; 732 733 return d.dev; 734 } 735 736 /** 737 * hwpath_to_device - Finds the generic device corresponding to a given hardware path. 738 * @modpath: the hardware path. 739 * @return: The target device, NULL if not found. 740 */ 741 struct device *hwpath_to_device(struct hardware_path *modpath) 742 { 743 int i; 744 struct device *parent = &root; 745 for (i = 0; i < 6; i++) { 746 if (modpath->bc[i] == -1) 747 continue; 748 parent = parse_tree_node(parent, i, modpath); 749 if (!parent) 750 return NULL; 751 } 752 if (dev_is_pci(parent)) /* pci devices already parse MOD */ 753 return parent; 754 else 755 return parse_tree_node(parent, 6, modpath); 756 } 757 EXPORT_SYMBOL(hwpath_to_device); 758 759 /** 760 * device_to_hwpath - Populates the hwpath corresponding to the given device. 761 * @param dev the target device 762 * @param path pointer to a previously allocated hwpath struct to be filled in 763 */ 764 void device_to_hwpath(struct device *dev, struct hardware_path *path) 765 { 766 struct parisc_device *padev; 767 if (dev->bus == &parisc_bus_type) { 768 padev = to_parisc_device(dev); 769 get_node_path(dev->parent, path); 770 path->mod = padev->hw_path; 771 } else if (dev_is_pci(dev)) { 772 get_node_path(dev, path); 773 } 774 } 775 EXPORT_SYMBOL(device_to_hwpath); 776 777 #define BC_PORT_MASK 0x8 778 #define BC_LOWER_PORT 0x8 779 780 #define BUS_CONVERTER(dev) \ 781 ((dev->id.hw_type == HPHW_IOA) || (dev->id.hw_type == HPHW_BCPORT)) 782 783 #define IS_LOWER_PORT(dev) \ 784 ((gsc_readl(dev->hpa.start + offsetof(struct bc_module, io_status)) \ 785 & BC_PORT_MASK) == BC_LOWER_PORT) 786 787 #define MAX_NATIVE_DEVICES 64 788 #define NATIVE_DEVICE_OFFSET 0x1000 789 790 #define FLEX_MASK F_EXTEND(0xfffc0000) 791 #define IO_IO_LOW offsetof(struct bc_module, io_io_low) 792 #define IO_IO_HIGH offsetof(struct bc_module, io_io_high) 793 #define READ_IO_IO_LOW(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_LOW) 794 #define READ_IO_IO_HIGH(dev) (unsigned long)(signed int)gsc_readl(dev->hpa.start + IO_IO_HIGH) 795 796 static void walk_native_bus(unsigned long io_io_low, unsigned long io_io_high, 797 struct device *parent); 798 799 static void walk_lower_bus(struct parisc_device *dev) 800 { 801 unsigned long io_io_low, io_io_high; 802 803 if (!BUS_CONVERTER(dev) || IS_LOWER_PORT(dev)) 804 return; 805 806 if (dev->id.hw_type == HPHW_IOA) { 807 io_io_low = (unsigned long)(signed int)(READ_IO_IO_LOW(dev) << 16); 808 io_io_high = io_io_low + MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET; 809 } else { 810 io_io_low = (READ_IO_IO_LOW(dev) + ~FLEX_MASK) & FLEX_MASK; 811 io_io_high = (READ_IO_IO_HIGH(dev)+ ~FLEX_MASK) & FLEX_MASK; 812 } 813 814 walk_native_bus(io_io_low, io_io_high, &dev->dev); 815 } 816 817 /** 818 * walk_native_bus -- Probe a bus for devices 819 * @io_io_low: Base address of this bus. 820 * @io_io_high: Last address of this bus. 821 * @parent: The parent bus device. 822 * 823 * A native bus (eg Runway or GSC) may have up to 64 devices on it, 824 * spaced at intervals of 0x1000 bytes. PDC may not inform us of these 825 * devices, so we have to probe for them. Unfortunately, we may find 826 * devices which are not physically connected (such as extra serial & 827 * keyboard ports). This problem is not yet solved. 828 */ 829 static void __init walk_native_bus(unsigned long io_io_low, 830 unsigned long io_io_high, struct device *parent) 831 { 832 int i, devices_found = 0; 833 unsigned long hpa = io_io_low; 834 struct hardware_path path; 835 836 get_node_path(parent, &path); 837 do { 838 for(i = 0; i < MAX_NATIVE_DEVICES; i++, hpa += NATIVE_DEVICE_OFFSET) { 839 struct parisc_device *dev; 840 841 /* Was the device already added by Firmware? */ 842 dev = find_device_by_addr(hpa); 843 if (!dev) { 844 path.mod = i; 845 dev = alloc_pa_dev(hpa, &path); 846 if (!dev) 847 continue; 848 849 register_parisc_device(dev); 850 devices_found++; 851 } 852 walk_lower_bus(dev); 853 } 854 } while(!devices_found && hpa < io_io_high); 855 } 856 857 #define CENTRAL_BUS_ADDR F_EXTEND(0xfff80000) 858 859 /** 860 * walk_central_bus - Find devices attached to the central bus 861 * 862 * PDC doesn't tell us about all devices in the system. This routine 863 * finds devices connected to the central bus. 864 */ 865 void __init walk_central_bus(void) 866 { 867 walk_native_bus(CENTRAL_BUS_ADDR, 868 CENTRAL_BUS_ADDR + (MAX_NATIVE_DEVICES * NATIVE_DEVICE_OFFSET), 869 &root); 870 } 871 872 static void print_parisc_device(struct parisc_device *dev) 873 { 874 char hw_path[64]; 875 static int count; 876 877 print_pa_hwpath(dev, hw_path); 878 printk(KERN_INFO "%d. %s at 0x%px [%s] { %d, 0x%x, 0x%.3x, 0x%.5x }", 879 ++count, dev->name, (void*) dev->hpa.start, hw_path, dev->id.hw_type, 880 dev->id.hversion_rev, dev->id.hversion, dev->id.sversion); 881 882 if (dev->num_addrs) { 883 int k; 884 pr_cont(", additional addresses: "); 885 for (k = 0; k < dev->num_addrs; k++) 886 pr_cont("0x%lx ", dev->addr[k]); 887 } 888 pr_cont("\n"); 889 } 890 891 /** 892 * init_parisc_bus - Some preparation to be done before inventory 893 */ 894 void __init init_parisc_bus(void) 895 { 896 if (bus_register(&parisc_bus_type)) 897 panic("Could not register PA-RISC bus type\n"); 898 if (device_register(&root)) 899 panic("Could not register PA-RISC root device\n"); 900 get_device(&root); 901 } 902 903 static __init void qemu_header(void) 904 { 905 int num; 906 unsigned long *p; 907 908 pr_info("--- cut here ---\n"); 909 pr_info("/* AUTO-GENERATED HEADER FILE FOR SEABIOS FIRMWARE */\n"); 910 pr_cont("/* generated with Linux kernel */\n"); 911 pr_cont("/* search for PARISC_QEMU_MACHINE_HEADER in Linux */\n\n"); 912 913 pr_info("#define PARISC_MODEL \"%s\"\n\n", 914 boot_cpu_data.pdc.sys_model_name); 915 916 pr_info("#define PARISC_PDC_MODEL 0x%lx, 0x%lx, 0x%lx, " 917 "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx\n\n", 918 #define p ((unsigned long *)&boot_cpu_data.pdc.model) 919 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]); 920 #undef p 921 922 pr_info("#define PARISC_PDC_VERSION 0x%04lx\n\n", 923 boot_cpu_data.pdc.versions); 924 925 pr_info("#define PARISC_PDC_CPUID 0x%04lx\n\n", 926 boot_cpu_data.pdc.cpuid); 927 928 pr_info("#define PARISC_PDC_CAPABILITIES 0x%04lx\n\n", 929 boot_cpu_data.pdc.capabilities); 930 931 pr_info("#define PARISC_PDC_ENTRY_ORG 0x%04lx\n\n", 932 #ifdef CONFIG_64BIT 933 (unsigned long)(PAGE0->mem_pdc_hi) << 32 | 934 #endif 935 (unsigned long)PAGE0->mem_pdc); 936 937 pr_info("#define PARISC_PDC_CACHE_INFO"); 938 p = (unsigned long *) &cache_info; 939 for (num = 0; num < sizeof(cache_info); num += sizeof(unsigned long)) { 940 if (((num % 5) == 0)) { 941 pr_cont(" \\\n"); 942 pr_info("\t"); 943 } 944 pr_cont("%s0x%04lx", 945 num?", ":"", *p++); 946 } 947 pr_cont("\n\n"); 948 } 949 950 static __init int qemu_print_hpa(struct device *lin_dev, void *data) 951 { 952 struct parisc_device *dev = to_parisc_device(lin_dev); 953 unsigned long hpa = dev->hpa.start; 954 955 pr_cont("\t{\t.hpa = 0x%08lx,\\\n", hpa); 956 pr_cont("\t\t.iodc = &iodc_data_hpa_%08lx,\\\n", hpa); 957 pr_cont("\t\t.mod_info = &mod_info_hpa_%08lx,\\\n", hpa); 958 pr_cont("\t\t.mod_path = &mod_path_hpa_%08lx,\\\n", hpa); 959 pr_cont("\t\t.num_addr = HPA_%08lx_num_addr,\\\n", hpa); 960 pr_cont("\t\t.add_addr = { HPA_%08lx_add_addr } },\\\n", hpa); 961 return 0; 962 } 963 964 965 static __init void qemu_footer(void) 966 { 967 pr_info("\n\n#define PARISC_DEVICE_LIST \\\n"); 968 for_each_padev(qemu_print_hpa, NULL); 969 pr_cont("\t{ 0, }\n"); 970 pr_info("--- cut here ---\n"); 971 } 972 973 /* print iodc data of the various hpa modules for qemu inclusion */ 974 static __init int qemu_print_iodc_data(struct device *lin_dev, void *data) 975 { 976 struct parisc_device *dev = to_parisc_device(lin_dev); 977 unsigned long count; 978 unsigned long hpa = dev->hpa.start; 979 int status; 980 struct pdc_iodc iodc_data; 981 982 int mod_index; 983 struct pdc_system_map_mod_info pdc_mod_info; 984 struct pdc_module_path mod_path; 985 986 status = pdc_iodc_read(&count, hpa, 0, 987 &iodc_data, sizeof(iodc_data)); 988 if (status != PDC_OK) { 989 pr_info("No IODC data for hpa 0x%08lx\n", hpa); 990 return 0; 991 } 992 993 pr_info("\n"); 994 995 pr_info("#define HPA_%08lx_DESCRIPTION \"%s\"\n", 996 hpa, parisc_hardware_description(&dev->id)); 997 998 mod_index = 0; 999 do { 1000 status = pdc_system_map_find_mods(&pdc_mod_info, 1001 &mod_path, mod_index++); 1002 } while (status == PDC_OK && pdc_mod_info.mod_addr != hpa); 1003 1004 pr_info("static struct pdc_system_map_mod_info" 1005 " mod_info_hpa_%08lx = {\n", hpa); 1006 #define DO(member) \ 1007 pr_cont("\t." #member " = 0x%x,\n", \ 1008 (unsigned int)pdc_mod_info.member) 1009 DO(mod_addr); 1010 DO(mod_pgs); 1011 DO(add_addrs); 1012 pr_cont("};\n"); 1013 #undef DO 1014 pr_info("static struct pdc_module_path " 1015 "mod_path_hpa_%08lx = {\n", hpa); 1016 pr_cont("\t.path = { "); 1017 pr_cont(".flags = 0x%x, ", mod_path.path.flags); 1018 pr_cont(".bc = { 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x }, ", 1019 (unsigned char)mod_path.path.bc[0], 1020 (unsigned char)mod_path.path.bc[1], 1021 (unsigned char)mod_path.path.bc[2], 1022 (unsigned char)mod_path.path.bc[3], 1023 (unsigned char)mod_path.path.bc[4], 1024 (unsigned char)mod_path.path.bc[5]); 1025 pr_cont(".mod = 0x%x ", mod_path.path.mod); 1026 pr_cont(" },\n"); 1027 pr_cont("\t.layers = { 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x }\n", 1028 mod_path.layers[0], mod_path.layers[1], mod_path.layers[2], 1029 mod_path.layers[3], mod_path.layers[4], mod_path.layers[5]); 1030 pr_cont("};\n"); 1031 1032 pr_info("static struct pdc_iodc iodc_data_hpa_%08lx = {\n", hpa); 1033 #define DO(member) \ 1034 pr_cont("\t." #member " = 0x%04lx,\n", \ 1035 (unsigned long)iodc_data.member) 1036 DO(hversion_model); 1037 DO(hversion); 1038 DO(spa); 1039 DO(type); 1040 DO(sversion_rev); 1041 DO(sversion_model); 1042 DO(sversion_opt); 1043 DO(rev); 1044 DO(dep); 1045 DO(features); 1046 DO(checksum); 1047 DO(length); 1048 #undef DO 1049 pr_cont("\t/* pad: 0x%04x, 0x%04x */\n", 1050 iodc_data.pad[0], iodc_data.pad[1]); 1051 pr_cont("};\n"); 1052 1053 pr_info("#define HPA_%08lx_num_addr %d\n", hpa, dev->num_addrs); 1054 pr_info("#define HPA_%08lx_add_addr ", hpa); 1055 count = 0; 1056 if (dev->num_addrs == 0) 1057 pr_cont("0"); 1058 while (count < dev->num_addrs) { 1059 pr_cont("0x%08lx, ", dev->addr[count]); 1060 count++; 1061 } 1062 pr_cont("\n\n"); 1063 1064 return 0; 1065 } 1066 1067 1068 1069 static int print_one_device(struct device * dev, void * data) 1070 { 1071 struct parisc_device * pdev = to_parisc_device(dev); 1072 1073 if (check_dev(dev)) 1074 print_parisc_device(pdev); 1075 return 0; 1076 } 1077 1078 /** 1079 * print_parisc_devices - Print out a list of devices found in this system 1080 */ 1081 void __init print_parisc_devices(void) 1082 { 1083 for_each_padev(print_one_device, NULL); 1084 #define PARISC_QEMU_MACHINE_HEADER 0 1085 if (PARISC_QEMU_MACHINE_HEADER) { 1086 qemu_header(); 1087 for_each_padev(qemu_print_iodc_data, NULL); 1088 qemu_footer(); 1089 } 1090 } 1091