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