1 #include <linux/string.h> 2 #include <linux/kernel.h> 3 #include <linux/of.h> 4 #include <linux/init.h> 5 #include <linux/export.h> 6 #include <linux/mod_devicetable.h> 7 #include <linux/slab.h> 8 #include <linux/errno.h> 9 #include <linux/irq.h> 10 #include <linux/of_device.h> 11 #include <linux/of_platform.h> 12 #include <asm/spitfire.h> 13 14 #include "of_device_common.h" 15 16 void __iomem *of_ioremap(struct resource *res, unsigned long offset, unsigned long size, char *name) 17 { 18 unsigned long ret = res->start + offset; 19 struct resource *r; 20 21 if (res->flags & IORESOURCE_MEM) 22 r = request_mem_region(ret, size, name); 23 else 24 r = request_region(ret, size, name); 25 if (!r) 26 ret = 0; 27 28 return (void __iomem *) ret; 29 } 30 EXPORT_SYMBOL(of_ioremap); 31 32 void of_iounmap(struct resource *res, void __iomem *base, unsigned long size) 33 { 34 if (res->flags & IORESOURCE_MEM) 35 release_mem_region((unsigned long) base, size); 36 else 37 release_region((unsigned long) base, size); 38 } 39 EXPORT_SYMBOL(of_iounmap); 40 41 /* 42 * PCI bus specific translator 43 */ 44 45 static int of_bus_pci_match(struct device_node *np) 46 { 47 if (!strcmp(np->name, "pci")) { 48 const char *model = of_get_property(np, "model", NULL); 49 50 if (model && !strcmp(model, "SUNW,simba")) 51 return 0; 52 53 /* Do not do PCI specific frobbing if the 54 * PCI bridge lacks a ranges property. We 55 * want to pass it through up to the next 56 * parent as-is, not with the PCI translate 57 * method which chops off the top address cell. 58 */ 59 if (!of_find_property(np, "ranges", NULL)) 60 return 0; 61 62 return 1; 63 } 64 65 return 0; 66 } 67 68 static int of_bus_simba_match(struct device_node *np) 69 { 70 const char *model = of_get_property(np, "model", NULL); 71 72 if (model && !strcmp(model, "SUNW,simba")) 73 return 1; 74 75 /* Treat PCI busses lacking ranges property just like 76 * simba. 77 */ 78 if (!strcmp(np->name, "pci")) { 79 if (!of_find_property(np, "ranges", NULL)) 80 return 1; 81 } 82 83 return 0; 84 } 85 86 static int of_bus_simba_map(u32 *addr, const u32 *range, 87 int na, int ns, int pna) 88 { 89 return 0; 90 } 91 92 static void of_bus_pci_count_cells(struct device_node *np, 93 int *addrc, int *sizec) 94 { 95 if (addrc) 96 *addrc = 3; 97 if (sizec) 98 *sizec = 2; 99 } 100 101 static int of_bus_pci_map(u32 *addr, const u32 *range, 102 int na, int ns, int pna) 103 { 104 u32 result[OF_MAX_ADDR_CELLS]; 105 int i; 106 107 /* Check address type match */ 108 if (!((addr[0] ^ range[0]) & 0x03000000)) 109 goto type_match; 110 111 /* Special exception, we can map a 64-bit address into 112 * a 32-bit range. 113 */ 114 if ((addr[0] & 0x03000000) == 0x03000000 && 115 (range[0] & 0x03000000) == 0x02000000) 116 goto type_match; 117 118 return -EINVAL; 119 120 type_match: 121 if (of_out_of_range(addr + 1, range + 1, range + na + pna, 122 na - 1, ns)) 123 return -EINVAL; 124 125 /* Start with the parent range base. */ 126 memcpy(result, range + na, pna * 4); 127 128 /* Add in the child address offset, skipping high cell. */ 129 for (i = 0; i < na - 1; i++) 130 result[pna - 1 - i] += 131 (addr[na - 1 - i] - 132 range[na - 1 - i]); 133 134 memcpy(addr, result, pna * 4); 135 136 return 0; 137 } 138 139 static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) 140 { 141 u32 w = addr[0]; 142 143 /* For PCI, we override whatever child busses may have used. */ 144 flags = 0; 145 switch((w >> 24) & 0x03) { 146 case 0x01: 147 flags |= IORESOURCE_IO; 148 break; 149 150 case 0x02: /* 32 bits */ 151 case 0x03: /* 64 bits */ 152 flags |= IORESOURCE_MEM; 153 break; 154 } 155 if (w & 0x40000000) 156 flags |= IORESOURCE_PREFETCH; 157 return flags; 158 } 159 160 /* 161 * FHC/Central bus specific translator. 162 * 163 * This is just needed to hard-code the address and size cell 164 * counts. 'fhc' and 'central' nodes lack the #address-cells and 165 * #size-cells properties, and if you walk to the root on such 166 * Enterprise boxes all you'll get is a #size-cells of 2 which is 167 * not what we want to use. 168 */ 169 static int of_bus_fhc_match(struct device_node *np) 170 { 171 return !strcmp(np->name, "fhc") || 172 !strcmp(np->name, "central"); 173 } 174 175 #define of_bus_fhc_count_cells of_bus_sbus_count_cells 176 177 /* 178 * Array of bus specific translators 179 */ 180 181 static struct of_bus of_busses[] = { 182 /* PCI */ 183 { 184 .name = "pci", 185 .addr_prop_name = "assigned-addresses", 186 .match = of_bus_pci_match, 187 .count_cells = of_bus_pci_count_cells, 188 .map = of_bus_pci_map, 189 .get_flags = of_bus_pci_get_flags, 190 }, 191 /* SIMBA */ 192 { 193 .name = "simba", 194 .addr_prop_name = "assigned-addresses", 195 .match = of_bus_simba_match, 196 .count_cells = of_bus_pci_count_cells, 197 .map = of_bus_simba_map, 198 .get_flags = of_bus_pci_get_flags, 199 }, 200 /* SBUS */ 201 { 202 .name = "sbus", 203 .addr_prop_name = "reg", 204 .match = of_bus_sbus_match, 205 .count_cells = of_bus_sbus_count_cells, 206 .map = of_bus_default_map, 207 .get_flags = of_bus_default_get_flags, 208 }, 209 /* FHC */ 210 { 211 .name = "fhc", 212 .addr_prop_name = "reg", 213 .match = of_bus_fhc_match, 214 .count_cells = of_bus_fhc_count_cells, 215 .map = of_bus_default_map, 216 .get_flags = of_bus_default_get_flags, 217 }, 218 /* Default */ 219 { 220 .name = "default", 221 .addr_prop_name = "reg", 222 .match = NULL, 223 .count_cells = of_bus_default_count_cells, 224 .map = of_bus_default_map, 225 .get_flags = of_bus_default_get_flags, 226 }, 227 }; 228 229 static struct of_bus *of_match_bus(struct device_node *np) 230 { 231 int i; 232 233 for (i = 0; i < ARRAY_SIZE(of_busses); i ++) 234 if (!of_busses[i].match || of_busses[i].match(np)) 235 return &of_busses[i]; 236 BUG(); 237 return NULL; 238 } 239 240 static int __init build_one_resource(struct device_node *parent, 241 struct of_bus *bus, 242 struct of_bus *pbus, 243 u32 *addr, 244 int na, int ns, int pna) 245 { 246 const u32 *ranges; 247 int rone, rlen; 248 249 ranges = of_get_property(parent, "ranges", &rlen); 250 if (ranges == NULL || rlen == 0) { 251 u32 result[OF_MAX_ADDR_CELLS]; 252 int i; 253 254 memset(result, 0, pna * 4); 255 for (i = 0; i < na; i++) 256 result[pna - 1 - i] = 257 addr[na - 1 - i]; 258 259 memcpy(addr, result, pna * 4); 260 return 0; 261 } 262 263 /* Now walk through the ranges */ 264 rlen /= 4; 265 rone = na + pna + ns; 266 for (; rlen >= rone; rlen -= rone, ranges += rone) { 267 if (!bus->map(addr, ranges, na, ns, pna)) 268 return 0; 269 } 270 271 /* When we miss an I/O space match on PCI, just pass it up 272 * to the next PCI bridge and/or controller. 273 */ 274 if (!strcmp(bus->name, "pci") && 275 (addr[0] & 0x03000000) == 0x01000000) 276 return 0; 277 278 return 1; 279 } 280 281 static int __init use_1to1_mapping(struct device_node *pp) 282 { 283 /* If we have a ranges property in the parent, use it. */ 284 if (of_find_property(pp, "ranges", NULL) != NULL) 285 return 0; 286 287 /* If the parent is the dma node of an ISA bus, pass 288 * the translation up to the root. 289 * 290 * Some SBUS devices use intermediate nodes to express 291 * hierarchy within the device itself. These aren't 292 * real bus nodes, and don't have a 'ranges' property. 293 * But, we should still pass the translation work up 294 * to the SBUS itself. 295 */ 296 if (!strcmp(pp->name, "dma") || 297 !strcmp(pp->name, "espdma") || 298 !strcmp(pp->name, "ledma") || 299 !strcmp(pp->name, "lebuffer")) 300 return 0; 301 302 /* Similarly for all PCI bridges, if we get this far 303 * it lacks a ranges property, and this will include 304 * cases like Simba. 305 */ 306 if (!strcmp(pp->name, "pci")) 307 return 0; 308 309 return 1; 310 } 311 312 static int of_resource_verbose; 313 314 static void __init build_device_resources(struct platform_device *op, 315 struct device *parent) 316 { 317 struct platform_device *p_op; 318 struct of_bus *bus; 319 int na, ns; 320 int index, num_reg; 321 const void *preg; 322 323 if (!parent) 324 return; 325 326 p_op = to_platform_device(parent); 327 bus = of_match_bus(p_op->dev.of_node); 328 bus->count_cells(op->dev.of_node, &na, &ns); 329 330 preg = of_get_property(op->dev.of_node, bus->addr_prop_name, &num_reg); 331 if (!preg || num_reg == 0) 332 return; 333 334 /* Convert to num-cells. */ 335 num_reg /= 4; 336 337 /* Convert to num-entries. */ 338 num_reg /= na + ns; 339 340 /* Prevent overrunning the op->resources[] array. */ 341 if (num_reg > PROMREG_MAX) { 342 printk(KERN_WARNING "%s: Too many regs (%d), " 343 "limiting to %d.\n", 344 op->dev.of_node->full_name, num_reg, PROMREG_MAX); 345 num_reg = PROMREG_MAX; 346 } 347 348 op->resource = op->archdata.resource; 349 op->num_resources = num_reg; 350 for (index = 0; index < num_reg; index++) { 351 struct resource *r = &op->resource[index]; 352 u32 addr[OF_MAX_ADDR_CELLS]; 353 const u32 *reg = (preg + (index * ((na + ns) * 4))); 354 struct device_node *dp = op->dev.of_node; 355 struct device_node *pp = p_op->dev.of_node; 356 struct of_bus *pbus, *dbus; 357 u64 size, result = OF_BAD_ADDR; 358 unsigned long flags; 359 int dna, dns; 360 int pna, pns; 361 362 size = of_read_addr(reg + na, ns); 363 memcpy(addr, reg, na * 4); 364 365 flags = bus->get_flags(addr, 0); 366 367 if (use_1to1_mapping(pp)) { 368 result = of_read_addr(addr, na); 369 goto build_res; 370 } 371 372 dna = na; 373 dns = ns; 374 dbus = bus; 375 376 while (1) { 377 dp = pp; 378 pp = dp->parent; 379 if (!pp) { 380 result = of_read_addr(addr, dna); 381 break; 382 } 383 384 pbus = of_match_bus(pp); 385 pbus->count_cells(dp, &pna, &pns); 386 387 if (build_one_resource(dp, dbus, pbus, addr, 388 dna, dns, pna)) 389 break; 390 391 flags = pbus->get_flags(addr, flags); 392 393 dna = pna; 394 dns = pns; 395 dbus = pbus; 396 } 397 398 build_res: 399 memset(r, 0, sizeof(*r)); 400 401 if (of_resource_verbose) 402 printk("%s reg[%d] -> %llx\n", 403 op->dev.of_node->full_name, index, 404 result); 405 406 if (result != OF_BAD_ADDR) { 407 if (tlb_type == hypervisor) 408 result &= 0x0fffffffffffffffUL; 409 410 r->start = result; 411 r->end = result + size - 1; 412 r->flags = flags; 413 } 414 r->name = op->dev.of_node->name; 415 } 416 } 417 418 static struct device_node * __init 419 apply_interrupt_map(struct device_node *dp, struct device_node *pp, 420 const u32 *imap, int imlen, const u32 *imask, 421 unsigned int *irq_p) 422 { 423 struct device_node *cp; 424 unsigned int irq = *irq_p; 425 struct of_bus *bus; 426 phandle handle; 427 const u32 *reg; 428 int na, num_reg, i; 429 430 bus = of_match_bus(pp); 431 bus->count_cells(dp, &na, NULL); 432 433 reg = of_get_property(dp, "reg", &num_reg); 434 if (!reg || !num_reg) 435 return NULL; 436 437 imlen /= ((na + 3) * 4); 438 handle = 0; 439 for (i = 0; i < imlen; i++) { 440 int j; 441 442 for (j = 0; j < na; j++) { 443 if ((reg[j] & imask[j]) != imap[j]) 444 goto next; 445 } 446 if (imap[na] == irq) { 447 handle = imap[na + 1]; 448 irq = imap[na + 2]; 449 break; 450 } 451 452 next: 453 imap += (na + 3); 454 } 455 if (i == imlen) { 456 /* Psycho and Sabre PCI controllers can have 'interrupt-map' 457 * properties that do not include the on-board device 458 * interrupts. Instead, the device's 'interrupts' property 459 * is already a fully specified INO value. 460 * 461 * Handle this by deciding that, if we didn't get a 462 * match in the parent's 'interrupt-map', and the 463 * parent is an IRQ translator, then use the parent as 464 * our IRQ controller. 465 */ 466 if (pp->irq_trans) 467 return pp; 468 469 return NULL; 470 } 471 472 *irq_p = irq; 473 cp = of_find_node_by_phandle(handle); 474 475 return cp; 476 } 477 478 static unsigned int __init pci_irq_swizzle(struct device_node *dp, 479 struct device_node *pp, 480 unsigned int irq) 481 { 482 const struct linux_prom_pci_registers *regs; 483 unsigned int bus, devfn, slot, ret; 484 485 if (irq < 1 || irq > 4) 486 return irq; 487 488 regs = of_get_property(dp, "reg", NULL); 489 if (!regs) 490 return irq; 491 492 bus = (regs->phys_hi >> 16) & 0xff; 493 devfn = (regs->phys_hi >> 8) & 0xff; 494 slot = (devfn >> 3) & 0x1f; 495 496 if (pp->irq_trans) { 497 /* Derived from Table 8-3, U2P User's Manual. This branch 498 * is handling a PCI controller that lacks a proper set of 499 * interrupt-map and interrupt-map-mask properties. The 500 * Ultra-E450 is one example. 501 * 502 * The bit layout is BSSLL, where: 503 * B: 0 on bus A, 1 on bus B 504 * D: 2-bit slot number, derived from PCI device number as 505 * (dev - 1) for bus A, or (dev - 2) for bus B 506 * L: 2-bit line number 507 */ 508 if (bus & 0x80) { 509 /* PBM-A */ 510 bus = 0x00; 511 slot = (slot - 1) << 2; 512 } else { 513 /* PBM-B */ 514 bus = 0x10; 515 slot = (slot - 2) << 2; 516 } 517 irq -= 1; 518 519 ret = (bus | slot | irq); 520 } else { 521 /* Going through a PCI-PCI bridge that lacks a set of 522 * interrupt-map and interrupt-map-mask properties. 523 */ 524 ret = ((irq - 1 + (slot & 3)) & 3) + 1; 525 } 526 527 return ret; 528 } 529 530 static int of_irq_verbose; 531 532 static unsigned int __init build_one_device_irq(struct platform_device *op, 533 struct device *parent, 534 unsigned int irq) 535 { 536 struct device_node *dp = op->dev.of_node; 537 struct device_node *pp, *ip; 538 unsigned int orig_irq = irq; 539 int nid; 540 541 if (irq == 0xffffffff) 542 return irq; 543 544 if (dp->irq_trans) { 545 irq = dp->irq_trans->irq_build(dp, irq, 546 dp->irq_trans->data); 547 548 if (of_irq_verbose) 549 printk("%s: direct translate %x --> %x\n", 550 dp->full_name, orig_irq, irq); 551 552 goto out; 553 } 554 555 /* Something more complicated. Walk up to the root, applying 556 * interrupt-map or bus specific translations, until we hit 557 * an IRQ translator. 558 * 559 * If we hit a bus type or situation we cannot handle, we 560 * stop and assume that the original IRQ number was in a 561 * format which has special meaning to it's immediate parent. 562 */ 563 pp = dp->parent; 564 ip = NULL; 565 while (pp) { 566 const void *imap, *imsk; 567 int imlen; 568 569 imap = of_get_property(pp, "interrupt-map", &imlen); 570 imsk = of_get_property(pp, "interrupt-map-mask", NULL); 571 if (imap && imsk) { 572 struct device_node *iret; 573 int this_orig_irq = irq; 574 575 iret = apply_interrupt_map(dp, pp, 576 imap, imlen, imsk, 577 &irq); 578 579 if (of_irq_verbose) 580 printk("%s: Apply [%s:%x] imap --> [%s:%x]\n", 581 op->dev.of_node->full_name, 582 pp->full_name, this_orig_irq, 583 of_node_full_name(iret), irq); 584 585 if (!iret) 586 break; 587 588 if (iret->irq_trans) { 589 ip = iret; 590 break; 591 } 592 } else { 593 if (!strcmp(pp->name, "pci")) { 594 unsigned int this_orig_irq = irq; 595 596 irq = pci_irq_swizzle(dp, pp, irq); 597 if (of_irq_verbose) 598 printk("%s: PCI swizzle [%s] " 599 "%x --> %x\n", 600 op->dev.of_node->full_name, 601 pp->full_name, this_orig_irq, 602 irq); 603 604 } 605 606 if (pp->irq_trans) { 607 ip = pp; 608 break; 609 } 610 } 611 dp = pp; 612 pp = pp->parent; 613 } 614 if (!ip) 615 return orig_irq; 616 617 irq = ip->irq_trans->irq_build(op->dev.of_node, irq, 618 ip->irq_trans->data); 619 if (of_irq_verbose) 620 printk("%s: Apply IRQ trans [%s] %x --> %x\n", 621 op->dev.of_node->full_name, ip->full_name, orig_irq, irq); 622 623 out: 624 nid = of_node_to_nid(dp); 625 if (nid != -1) { 626 cpumask_t numa_mask; 627 628 cpumask_copy(&numa_mask, cpumask_of_node(nid)); 629 irq_set_affinity(irq, &numa_mask); 630 } 631 632 return irq; 633 } 634 635 static struct platform_device * __init scan_one_device(struct device_node *dp, 636 struct device *parent) 637 { 638 struct platform_device *op = kzalloc(sizeof(*op), GFP_KERNEL); 639 const unsigned int *irq; 640 struct dev_archdata *sd; 641 int len, i; 642 643 if (!op) 644 return NULL; 645 646 sd = &op->dev.archdata; 647 sd->op = op; 648 649 op->dev.of_node = dp; 650 651 irq = of_get_property(dp, "interrupts", &len); 652 if (irq) { 653 op->archdata.num_irqs = len / 4; 654 655 /* Prevent overrunning the op->irqs[] array. */ 656 if (op->archdata.num_irqs > PROMINTR_MAX) { 657 printk(KERN_WARNING "%s: Too many irqs (%d), " 658 "limiting to %d.\n", 659 dp->full_name, op->archdata.num_irqs, PROMINTR_MAX); 660 op->archdata.num_irqs = PROMINTR_MAX; 661 } 662 memcpy(op->archdata.irqs, irq, op->archdata.num_irqs * 4); 663 } else { 664 op->archdata.num_irqs = 0; 665 } 666 667 build_device_resources(op, parent); 668 for (i = 0; i < op->archdata.num_irqs; i++) 669 op->archdata.irqs[i] = build_one_device_irq(op, parent, op->archdata.irqs[i]); 670 671 op->dev.parent = parent; 672 op->dev.bus = &platform_bus_type; 673 if (!parent) 674 dev_set_name(&op->dev, "root"); 675 else 676 dev_set_name(&op->dev, "%08x", dp->phandle); 677 678 if (of_device_register(op)) { 679 printk("%s: Could not register of device.\n", 680 dp->full_name); 681 kfree(op); 682 op = NULL; 683 } 684 685 return op; 686 } 687 688 static void __init scan_tree(struct device_node *dp, struct device *parent) 689 { 690 while (dp) { 691 struct platform_device *op = scan_one_device(dp, parent); 692 693 if (op) 694 scan_tree(dp->child, &op->dev); 695 696 dp = dp->sibling; 697 } 698 } 699 700 static int __init scan_of_devices(void) 701 { 702 struct device_node *root = of_find_node_by_path("/"); 703 struct platform_device *parent; 704 705 parent = scan_one_device(root, NULL); 706 if (!parent) 707 return 0; 708 709 scan_tree(root->child, &parent->dev); 710 return 0; 711 } 712 postcore_initcall(scan_of_devices); 713 714 static int __init of_debug(char *str) 715 { 716 int val = 0; 717 718 get_option(&str, &val); 719 if (val & 1) 720 of_resource_verbose = 1; 721 if (val & 2) 722 of_irq_verbose = 1; 723 return 1; 724 } 725 726 __setup("of_debug=", of_debug); 727