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