1 2 #include <linux/device.h> 3 #include <linux/io.h> 4 #include <linux/ioport.h> 5 #include <linux/module.h> 6 #include <linux/of_address.h> 7 #include <linux/pci_regs.h> 8 #include <linux/string.h> 9 10 /* Max address size we deal with */ 11 #define OF_MAX_ADDR_CELLS 4 12 #define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS) 13 #define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0) 14 15 static struct of_bus *of_match_bus(struct device_node *np); 16 static int __of_address_to_resource(struct device_node *dev, 17 const __be32 *addrp, u64 size, unsigned int flags, 18 const char *name, struct resource *r); 19 20 /* Debug utility */ 21 #ifdef DEBUG 22 static void of_dump_addr(const char *s, const __be32 *addr, int na) 23 { 24 printk(KERN_DEBUG "%s", s); 25 while (na--) 26 printk(" %08x", be32_to_cpu(*(addr++))); 27 printk("\n"); 28 } 29 #else 30 static void of_dump_addr(const char *s, const __be32 *addr, int na) { } 31 #endif 32 33 /* Callbacks for bus specific translators */ 34 struct of_bus { 35 const char *name; 36 const char *addresses; 37 int (*match)(struct device_node *parent); 38 void (*count_cells)(struct device_node *child, 39 int *addrc, int *sizec); 40 u64 (*map)(__be32 *addr, const __be32 *range, 41 int na, int ns, int pna); 42 int (*translate)(__be32 *addr, u64 offset, int na); 43 unsigned int (*get_flags)(const __be32 *addr); 44 }; 45 46 /* 47 * Default translator (generic bus) 48 */ 49 50 static void of_bus_default_count_cells(struct device_node *dev, 51 int *addrc, int *sizec) 52 { 53 if (addrc) 54 *addrc = of_n_addr_cells(dev); 55 if (sizec) 56 *sizec = of_n_size_cells(dev); 57 } 58 59 static u64 of_bus_default_map(__be32 *addr, const __be32 *range, 60 int na, int ns, int pna) 61 { 62 u64 cp, s, da; 63 64 cp = of_read_number(range, na); 65 s = of_read_number(range + na + pna, ns); 66 da = of_read_number(addr, na); 67 68 pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n", 69 (unsigned long long)cp, (unsigned long long)s, 70 (unsigned long long)da); 71 72 /* 73 * If the number of address cells is larger than 2 we assume the 74 * mapping doesn't specify a physical address. Rather, the address 75 * specifies an identifier that must match exactly. 76 */ 77 if (na > 2 && memcmp(range, addr, na * 4) != 0) 78 return OF_BAD_ADDR; 79 80 if (da < cp || da >= (cp + s)) 81 return OF_BAD_ADDR; 82 return da - cp; 83 } 84 85 static int of_bus_default_translate(__be32 *addr, u64 offset, int na) 86 { 87 u64 a = of_read_number(addr, na); 88 memset(addr, 0, na * 4); 89 a += offset; 90 if (na > 1) 91 addr[na - 2] = cpu_to_be32(a >> 32); 92 addr[na - 1] = cpu_to_be32(a & 0xffffffffu); 93 94 return 0; 95 } 96 97 static unsigned int of_bus_default_get_flags(const __be32 *addr) 98 { 99 return IORESOURCE_MEM; 100 } 101 102 #ifdef CONFIG_PCI 103 /* 104 * PCI bus specific translator 105 */ 106 107 static int of_bus_pci_match(struct device_node *np) 108 { 109 /* 110 * "vci" is for the /chaos bridge on 1st-gen PCI powermacs 111 * "ht" is hypertransport 112 */ 113 return !strcmp(np->type, "pci") || !strcmp(np->type, "vci") || 114 !strcmp(np->type, "ht"); 115 } 116 117 static void of_bus_pci_count_cells(struct device_node *np, 118 int *addrc, int *sizec) 119 { 120 if (addrc) 121 *addrc = 3; 122 if (sizec) 123 *sizec = 2; 124 } 125 126 static unsigned int of_bus_pci_get_flags(const __be32 *addr) 127 { 128 unsigned int flags = 0; 129 u32 w = be32_to_cpup(addr); 130 131 switch((w >> 24) & 0x03) { 132 case 0x01: 133 flags |= IORESOURCE_IO; 134 break; 135 case 0x02: /* 32 bits */ 136 case 0x03: /* 64 bits */ 137 flags |= IORESOURCE_MEM; 138 break; 139 } 140 if (w & 0x40000000) 141 flags |= IORESOURCE_PREFETCH; 142 return flags; 143 } 144 145 static u64 of_bus_pci_map(__be32 *addr, const __be32 *range, int na, int ns, 146 int pna) 147 { 148 u64 cp, s, da; 149 unsigned int af, rf; 150 151 af = of_bus_pci_get_flags(addr); 152 rf = of_bus_pci_get_flags(range); 153 154 /* Check address type match */ 155 if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO)) 156 return OF_BAD_ADDR; 157 158 /* Read address values, skipping high cell */ 159 cp = of_read_number(range + 1, na - 1); 160 s = of_read_number(range + na + pna, ns); 161 da = of_read_number(addr + 1, na - 1); 162 163 pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n", 164 (unsigned long long)cp, (unsigned long long)s, 165 (unsigned long long)da); 166 167 if (da < cp || da >= (cp + s)) 168 return OF_BAD_ADDR; 169 return da - cp; 170 } 171 172 static int of_bus_pci_translate(__be32 *addr, u64 offset, int na) 173 { 174 return of_bus_default_translate(addr + 1, offset, na - 1); 175 } 176 177 const __be32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size, 178 unsigned int *flags) 179 { 180 const __be32 *prop; 181 unsigned int psize; 182 struct device_node *parent; 183 struct of_bus *bus; 184 int onesize, i, na, ns; 185 186 /* Get parent & match bus type */ 187 parent = of_get_parent(dev); 188 if (parent == NULL) 189 return NULL; 190 bus = of_match_bus(parent); 191 if (strcmp(bus->name, "pci")) { 192 of_node_put(parent); 193 return NULL; 194 } 195 bus->count_cells(dev, &na, &ns); 196 of_node_put(parent); 197 if (!OF_CHECK_ADDR_COUNT(na)) 198 return NULL; 199 200 /* Get "reg" or "assigned-addresses" property */ 201 prop = of_get_property(dev, bus->addresses, &psize); 202 if (prop == NULL) 203 return NULL; 204 psize /= 4; 205 206 onesize = na + ns; 207 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) { 208 u32 val = be32_to_cpu(prop[0]); 209 if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) { 210 if (size) 211 *size = of_read_number(prop + na, ns); 212 if (flags) 213 *flags = bus->get_flags(prop); 214 return prop; 215 } 216 } 217 return NULL; 218 } 219 EXPORT_SYMBOL(of_get_pci_address); 220 221 int of_pci_address_to_resource(struct device_node *dev, int bar, 222 struct resource *r) 223 { 224 const __be32 *addrp; 225 u64 size; 226 unsigned int flags; 227 228 addrp = of_get_pci_address(dev, bar, &size, &flags); 229 if (addrp == NULL) 230 return -EINVAL; 231 return __of_address_to_resource(dev, addrp, size, flags, NULL, r); 232 } 233 EXPORT_SYMBOL_GPL(of_pci_address_to_resource); 234 235 int of_pci_range_parser_init(struct of_pci_range_parser *parser, 236 struct device_node *node) 237 { 238 const int na = 3, ns = 2; 239 int rlen; 240 241 parser->node = node; 242 parser->pna = of_n_addr_cells(node); 243 parser->np = parser->pna + na + ns; 244 245 parser->range = of_get_property(node, "ranges", &rlen); 246 if (parser->range == NULL) 247 return -ENOENT; 248 249 parser->end = parser->range + rlen / sizeof(__be32); 250 251 return 0; 252 } 253 EXPORT_SYMBOL_GPL(of_pci_range_parser_init); 254 255 struct of_pci_range *of_pci_range_parser_one(struct of_pci_range_parser *parser, 256 struct of_pci_range *range) 257 { 258 const int na = 3, ns = 2; 259 260 if (!range) 261 return NULL; 262 263 if (!parser->range || parser->range + parser->np > parser->end) 264 return NULL; 265 266 range->pci_space = parser->range[0]; 267 range->flags = of_bus_pci_get_flags(parser->range); 268 range->pci_addr = of_read_number(parser->range + 1, ns); 269 range->cpu_addr = of_translate_address(parser->node, 270 parser->range + na); 271 range->size = of_read_number(parser->range + parser->pna + na, ns); 272 273 parser->range += parser->np; 274 275 /* Now consume following elements while they are contiguous */ 276 while (parser->range + parser->np <= parser->end) { 277 u32 flags, pci_space; 278 u64 pci_addr, cpu_addr, size; 279 280 pci_space = be32_to_cpup(parser->range); 281 flags = of_bus_pci_get_flags(parser->range); 282 pci_addr = of_read_number(parser->range + 1, ns); 283 cpu_addr = of_translate_address(parser->node, 284 parser->range + na); 285 size = of_read_number(parser->range + parser->pna + na, ns); 286 287 if (flags != range->flags) 288 break; 289 if (pci_addr != range->pci_addr + range->size || 290 cpu_addr != range->cpu_addr + range->size) 291 break; 292 293 range->size += size; 294 parser->range += parser->np; 295 } 296 297 return range; 298 } 299 EXPORT_SYMBOL_GPL(of_pci_range_parser_one); 300 301 #endif /* CONFIG_PCI */ 302 303 /* 304 * ISA bus specific translator 305 */ 306 307 static int of_bus_isa_match(struct device_node *np) 308 { 309 return !strcmp(np->name, "isa"); 310 } 311 312 static void of_bus_isa_count_cells(struct device_node *child, 313 int *addrc, int *sizec) 314 { 315 if (addrc) 316 *addrc = 2; 317 if (sizec) 318 *sizec = 1; 319 } 320 321 static u64 of_bus_isa_map(__be32 *addr, const __be32 *range, int na, int ns, 322 int pna) 323 { 324 u64 cp, s, da; 325 326 /* Check address type match */ 327 if ((addr[0] ^ range[0]) & cpu_to_be32(1)) 328 return OF_BAD_ADDR; 329 330 /* Read address values, skipping high cell */ 331 cp = of_read_number(range + 1, na - 1); 332 s = of_read_number(range + na + pna, ns); 333 da = of_read_number(addr + 1, na - 1); 334 335 pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n", 336 (unsigned long long)cp, (unsigned long long)s, 337 (unsigned long long)da); 338 339 if (da < cp || da >= (cp + s)) 340 return OF_BAD_ADDR; 341 return da - cp; 342 } 343 344 static int of_bus_isa_translate(__be32 *addr, u64 offset, int na) 345 { 346 return of_bus_default_translate(addr + 1, offset, na - 1); 347 } 348 349 static unsigned int of_bus_isa_get_flags(const __be32 *addr) 350 { 351 unsigned int flags = 0; 352 u32 w = be32_to_cpup(addr); 353 354 if (w & 1) 355 flags |= IORESOURCE_IO; 356 else 357 flags |= IORESOURCE_MEM; 358 return flags; 359 } 360 361 /* 362 * Array of bus specific translators 363 */ 364 365 static struct of_bus of_busses[] = { 366 #ifdef CONFIG_PCI 367 /* PCI */ 368 { 369 .name = "pci", 370 .addresses = "assigned-addresses", 371 .match = of_bus_pci_match, 372 .count_cells = of_bus_pci_count_cells, 373 .map = of_bus_pci_map, 374 .translate = of_bus_pci_translate, 375 .get_flags = of_bus_pci_get_flags, 376 }, 377 #endif /* CONFIG_PCI */ 378 /* ISA */ 379 { 380 .name = "isa", 381 .addresses = "reg", 382 .match = of_bus_isa_match, 383 .count_cells = of_bus_isa_count_cells, 384 .map = of_bus_isa_map, 385 .translate = of_bus_isa_translate, 386 .get_flags = of_bus_isa_get_flags, 387 }, 388 /* Default */ 389 { 390 .name = "default", 391 .addresses = "reg", 392 .match = NULL, 393 .count_cells = of_bus_default_count_cells, 394 .map = of_bus_default_map, 395 .translate = of_bus_default_translate, 396 .get_flags = of_bus_default_get_flags, 397 }, 398 }; 399 400 static struct of_bus *of_match_bus(struct device_node *np) 401 { 402 int i; 403 404 for (i = 0; i < ARRAY_SIZE(of_busses); i++) 405 if (!of_busses[i].match || of_busses[i].match(np)) 406 return &of_busses[i]; 407 BUG(); 408 return NULL; 409 } 410 411 static int of_translate_one(struct device_node *parent, struct of_bus *bus, 412 struct of_bus *pbus, __be32 *addr, 413 int na, int ns, int pna, const char *rprop) 414 { 415 const __be32 *ranges; 416 unsigned int rlen; 417 int rone; 418 u64 offset = OF_BAD_ADDR; 419 420 /* Normally, an absence of a "ranges" property means we are 421 * crossing a non-translatable boundary, and thus the addresses 422 * below the current not cannot be converted to CPU physical ones. 423 * Unfortunately, while this is very clear in the spec, it's not 424 * what Apple understood, and they do have things like /uni-n or 425 * /ht nodes with no "ranges" property and a lot of perfectly 426 * useable mapped devices below them. Thus we treat the absence of 427 * "ranges" as equivalent to an empty "ranges" property which means 428 * a 1:1 translation at that level. It's up to the caller not to try 429 * to translate addresses that aren't supposed to be translated in 430 * the first place. --BenH. 431 * 432 * As far as we know, this damage only exists on Apple machines, so 433 * This code is only enabled on powerpc. --gcl 434 */ 435 ranges = of_get_property(parent, rprop, &rlen); 436 #if !defined(CONFIG_PPC) 437 if (ranges == NULL) { 438 pr_err("OF: no ranges; cannot translate\n"); 439 return 1; 440 } 441 #endif /* !defined(CONFIG_PPC) */ 442 if (ranges == NULL || rlen == 0) { 443 offset = of_read_number(addr, na); 444 memset(addr, 0, pna * 4); 445 pr_debug("OF: empty ranges; 1:1 translation\n"); 446 goto finish; 447 } 448 449 pr_debug("OF: walking ranges...\n"); 450 451 /* Now walk through the ranges */ 452 rlen /= 4; 453 rone = na + pna + ns; 454 for (; rlen >= rone; rlen -= rone, ranges += rone) { 455 offset = bus->map(addr, ranges, na, ns, pna); 456 if (offset != OF_BAD_ADDR) 457 break; 458 } 459 if (offset == OF_BAD_ADDR) { 460 pr_debug("OF: not found !\n"); 461 return 1; 462 } 463 memcpy(addr, ranges + na, 4 * pna); 464 465 finish: 466 of_dump_addr("OF: parent translation for:", addr, pna); 467 pr_debug("OF: with offset: %llx\n", (unsigned long long)offset); 468 469 /* Translate it into parent bus space */ 470 return pbus->translate(addr, offset, pna); 471 } 472 473 /* 474 * Translate an address from the device-tree into a CPU physical address, 475 * this walks up the tree and applies the various bus mappings on the 476 * way. 477 * 478 * Note: We consider that crossing any level with #size-cells == 0 to mean 479 * that translation is impossible (that is we are not dealing with a value 480 * that can be mapped to a cpu physical address). This is not really specified 481 * that way, but this is traditionally the way IBM at least do things 482 */ 483 static u64 __of_translate_address(struct device_node *dev, 484 const __be32 *in_addr, const char *rprop) 485 { 486 struct device_node *parent = NULL; 487 struct of_bus *bus, *pbus; 488 __be32 addr[OF_MAX_ADDR_CELLS]; 489 int na, ns, pna, pns; 490 u64 result = OF_BAD_ADDR; 491 492 pr_debug("OF: ** translation for device %s **\n", dev->full_name); 493 494 /* Increase refcount at current level */ 495 of_node_get(dev); 496 497 /* Get parent & match bus type */ 498 parent = of_get_parent(dev); 499 if (parent == NULL) 500 goto bail; 501 bus = of_match_bus(parent); 502 503 /* Count address cells & copy address locally */ 504 bus->count_cells(dev, &na, &ns); 505 if (!OF_CHECK_COUNTS(na, ns)) { 506 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 507 dev->full_name); 508 goto bail; 509 } 510 memcpy(addr, in_addr, na * 4); 511 512 pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n", 513 bus->name, na, ns, parent->full_name); 514 of_dump_addr("OF: translating address:", addr, na); 515 516 /* Translate */ 517 for (;;) { 518 /* Switch to parent bus */ 519 of_node_put(dev); 520 dev = parent; 521 parent = of_get_parent(dev); 522 523 /* If root, we have finished */ 524 if (parent == NULL) { 525 pr_debug("OF: reached root node\n"); 526 result = of_read_number(addr, na); 527 break; 528 } 529 530 /* Get new parent bus and counts */ 531 pbus = of_match_bus(parent); 532 pbus->count_cells(dev, &pna, &pns); 533 if (!OF_CHECK_COUNTS(pna, pns)) { 534 printk(KERN_ERR "prom_parse: Bad cell count for %s\n", 535 dev->full_name); 536 break; 537 } 538 539 pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n", 540 pbus->name, pna, pns, parent->full_name); 541 542 /* Apply bus translation */ 543 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop)) 544 break; 545 546 /* Complete the move up one level */ 547 na = pna; 548 ns = pns; 549 bus = pbus; 550 551 of_dump_addr("OF: one level translation:", addr, na); 552 } 553 bail: 554 of_node_put(parent); 555 of_node_put(dev); 556 557 return result; 558 } 559 560 u64 of_translate_address(struct device_node *dev, const __be32 *in_addr) 561 { 562 return __of_translate_address(dev, in_addr, "ranges"); 563 } 564 EXPORT_SYMBOL(of_translate_address); 565 566 u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr) 567 { 568 return __of_translate_address(dev, in_addr, "dma-ranges"); 569 } 570 EXPORT_SYMBOL(of_translate_dma_address); 571 572 bool of_can_translate_address(struct device_node *dev) 573 { 574 struct device_node *parent; 575 struct of_bus *bus; 576 int na, ns; 577 578 parent = of_get_parent(dev); 579 if (parent == NULL) 580 return false; 581 582 bus = of_match_bus(parent); 583 bus->count_cells(dev, &na, &ns); 584 585 of_node_put(parent); 586 587 return OF_CHECK_COUNTS(na, ns); 588 } 589 EXPORT_SYMBOL(of_can_translate_address); 590 591 const __be32 *of_get_address(struct device_node *dev, int index, u64 *size, 592 unsigned int *flags) 593 { 594 const __be32 *prop; 595 unsigned int psize; 596 struct device_node *parent; 597 struct of_bus *bus; 598 int onesize, i, na, ns; 599 600 /* Get parent & match bus type */ 601 parent = of_get_parent(dev); 602 if (parent == NULL) 603 return NULL; 604 bus = of_match_bus(parent); 605 bus->count_cells(dev, &na, &ns); 606 of_node_put(parent); 607 if (!OF_CHECK_ADDR_COUNT(na)) 608 return NULL; 609 610 /* Get "reg" or "assigned-addresses" property */ 611 prop = of_get_property(dev, bus->addresses, &psize); 612 if (prop == NULL) 613 return NULL; 614 psize /= 4; 615 616 onesize = na + ns; 617 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) 618 if (i == index) { 619 if (size) 620 *size = of_read_number(prop + na, ns); 621 if (flags) 622 *flags = bus->get_flags(prop); 623 return prop; 624 } 625 return NULL; 626 } 627 EXPORT_SYMBOL(of_get_address); 628 629 static int __of_address_to_resource(struct device_node *dev, 630 const __be32 *addrp, u64 size, unsigned int flags, 631 const char *name, struct resource *r) 632 { 633 u64 taddr; 634 635 if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) 636 return -EINVAL; 637 taddr = of_translate_address(dev, addrp); 638 if (taddr == OF_BAD_ADDR) 639 return -EINVAL; 640 memset(r, 0, sizeof(struct resource)); 641 if (flags & IORESOURCE_IO) { 642 unsigned long port; 643 port = pci_address_to_pio(taddr); 644 if (port == (unsigned long)-1) 645 return -EINVAL; 646 r->start = port; 647 r->end = port + size - 1; 648 } else { 649 r->start = taddr; 650 r->end = taddr + size - 1; 651 } 652 r->flags = flags; 653 r->name = name ? name : dev->full_name; 654 655 return 0; 656 } 657 658 /** 659 * of_address_to_resource - Translate device tree address and return as resource 660 * 661 * Note that if your address is a PIO address, the conversion will fail if 662 * the physical address can't be internally converted to an IO token with 663 * pci_address_to_pio(), that is because it's either called to early or it 664 * can't be matched to any host bridge IO space 665 */ 666 int of_address_to_resource(struct device_node *dev, int index, 667 struct resource *r) 668 { 669 const __be32 *addrp; 670 u64 size; 671 unsigned int flags; 672 const char *name = NULL; 673 674 addrp = of_get_address(dev, index, &size, &flags); 675 if (addrp == NULL) 676 return -EINVAL; 677 678 /* Get optional "reg-names" property to add a name to a resource */ 679 of_property_read_string_index(dev, "reg-names", index, &name); 680 681 return __of_address_to_resource(dev, addrp, size, flags, name, r); 682 } 683 EXPORT_SYMBOL_GPL(of_address_to_resource); 684 685 struct device_node *of_find_matching_node_by_address(struct device_node *from, 686 const struct of_device_id *matches, 687 u64 base_address) 688 { 689 struct device_node *dn = of_find_matching_node(from, matches); 690 struct resource res; 691 692 while (dn) { 693 if (of_address_to_resource(dn, 0, &res)) 694 continue; 695 if (res.start == base_address) 696 return dn; 697 dn = of_find_matching_node(dn, matches); 698 } 699 700 return NULL; 701 } 702 703 704 /** 705 * of_iomap - Maps the memory mapped IO for a given device_node 706 * @device: the device whose io range will be mapped 707 * @index: index of the io range 708 * 709 * Returns a pointer to the mapped memory 710 */ 711 void __iomem *of_iomap(struct device_node *np, int index) 712 { 713 struct resource res; 714 715 if (of_address_to_resource(np, index, &res)) 716 return NULL; 717 718 return ioremap(res.start, resource_size(&res)); 719 } 720 EXPORT_SYMBOL(of_iomap); 721