1// SPDX-License-Identifier: GPL-2.0 2#define pr_fmt(fmt) "OF: " fmt 3 4#include <linux/device.h> 5#include <linux/fwnode.h> 6#include <linux/io.h> 7#include <linux/ioport.h> 8#include <linux/logic_pio.h> 9#include <linux/module.h> 10#include <linux/of_address.h> 11#include <linux/pci.h> 12#include <linux/pci_regs.h> 13#include <linux/sizes.h> 14#include <linux/slab.h> 15#include <linux/string.h> 16#include <linux/dma-direct.h> /* for bus_dma_region */ 17 18#include "of_private.h" 19 20/* Max address size we deal with */ 21#define OF_MAX_ADDR_CELLS 4 22#define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS) 23#define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0) 24 25/* Debug utility */ 26#ifdef DEBUG 27static void of_dump_addr(const char *s, const __be32 *addr, int na) 28{ 29 pr_debug("%s", s); 30 while (na--) 31 pr_cont(" %08x", be32_to_cpu(*(addr++))); 32 pr_cont("\n"); 33} 34#else 35static void of_dump_addr(const char *s, const __be32 *addr, int na) { } 36#endif 37 38/* Callbacks for bus specific translators */ 39struct of_bus { 40 const char *name; 41 const char *addresses; 42 int (*match)(struct device_node *parent); 43 void (*count_cells)(struct device_node *child, 44 int *addrc, int *sizec); 45 u64 (*map)(__be32 *addr, const __be32 *range, 46 int na, int ns, int pna, int fna); 47 int (*translate)(__be32 *addr, u64 offset, int na); 48 int flag_cells; 49 unsigned int (*get_flags)(const __be32 *addr); 50}; 51 52/* 53 * Default translator (generic bus) 54 */ 55 56static void of_bus_default_count_cells(struct device_node *dev, 57 int *addrc, int *sizec) 58{ 59 if (addrc) 60 *addrc = of_n_addr_cells(dev); 61 if (sizec) 62 *sizec = of_n_size_cells(dev); 63} 64 65static u64 of_bus_default_map(__be32 *addr, const __be32 *range, 66 int na, int ns, int pna, int fna) 67{ 68 u64 cp, s, da; 69 70 cp = of_read_number(range + fna, na - fna); 71 s = of_read_number(range + na + pna, ns); 72 da = of_read_number(addr + fna, na - fna); 73 74 pr_debug("default map, cp=%llx, s=%llx, da=%llx\n", cp, s, da); 75 76 if (da < cp || da >= (cp + s)) 77 return OF_BAD_ADDR; 78 return da - cp; 79} 80 81static int of_bus_default_translate(__be32 *addr, u64 offset, int na) 82{ 83 u64 a = of_read_number(addr, na); 84 memset(addr, 0, na * 4); 85 a += offset; 86 if (na > 1) 87 addr[na - 2] = cpu_to_be32(a >> 32); 88 addr[na - 1] = cpu_to_be32(a & 0xffffffffu); 89 90 return 0; 91} 92 93static unsigned int of_bus_default_flags_get_flags(const __be32 *addr) 94{ 95 return of_read_number(addr, 1); 96} 97 98static unsigned int of_bus_default_get_flags(const __be32 *addr) 99{ 100 return IORESOURCE_MEM; 101} 102 103static u64 of_bus_default_flags_map(__be32 *addr, const __be32 *range, int na, 104 int ns, int pna, int fna) 105{ 106 /* Check that flags match */ 107 if (*addr != *range) 108 return OF_BAD_ADDR; 109 110 return of_bus_default_map(addr, range, na, ns, pna, fna); 111} 112 113static int of_bus_default_flags_translate(__be32 *addr, u64 offset, int na) 114{ 115 /* Keep "flags" part (high cell) in translated address */ 116 return of_bus_default_translate(addr + 1, offset, na - 1); 117} 118 119#ifdef CONFIG_PCI 120static unsigned int of_bus_pci_get_flags(const __be32 *addr) 121{ 122 unsigned int flags = 0; 123 u32 w = be32_to_cpup(addr); 124 125 if (!IS_ENABLED(CONFIG_PCI)) 126 return 0; 127 128 switch((w >> 24) & 0x03) { 129 case 0x01: 130 flags |= IORESOURCE_IO; 131 break; 132 case 0x02: /* 32 bits */ 133 flags |= IORESOURCE_MEM; 134 break; 135 136 case 0x03: /* 64 bits */ 137 flags |= IORESOURCE_MEM | IORESOURCE_MEM_64; 138 break; 139 } 140 if (w & 0x40000000) 141 flags |= IORESOURCE_PREFETCH; 142 return flags; 143} 144 145/* 146 * PCI bus specific translator 147 */ 148 149static bool of_node_is_pcie(struct device_node *np) 150{ 151 bool is_pcie = of_node_name_eq(np, "pcie"); 152 153 if (is_pcie) 154 pr_warn_once("%pOF: Missing device_type\n", np); 155 156 return is_pcie; 157} 158 159static int of_bus_pci_match(struct device_node *np) 160{ 161 /* 162 * "pciex" is PCI Express 163 * "vci" is for the /chaos bridge on 1st-gen PCI powermacs 164 * "ht" is hypertransport 165 * 166 * If none of the device_type match, and that the node name is 167 * "pcie", accept the device as PCI (with a warning). 168 */ 169 return of_node_is_type(np, "pci") || of_node_is_type(np, "pciex") || 170 of_node_is_type(np, "vci") || of_node_is_type(np, "ht") || 171 of_node_is_pcie(np); 172} 173 174static void of_bus_pci_count_cells(struct device_node *np, 175 int *addrc, int *sizec) 176{ 177 if (addrc) 178 *addrc = 3; 179 if (sizec) 180 *sizec = 2; 181} 182 183static u64 of_bus_pci_map(__be32 *addr, const __be32 *range, int na, int ns, 184 int pna, int fna) 185{ 186 unsigned int af, rf; 187 188 af = of_bus_pci_get_flags(addr); 189 rf = of_bus_pci_get_flags(range); 190 191 /* Check address type match */ 192 if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO)) 193 return OF_BAD_ADDR; 194 195 return of_bus_default_map(addr, range, na, ns, pna, fna); 196} 197 198#endif /* CONFIG_PCI */ 199 200/* 201 * of_pci_range_to_resource - Create a resource from an of_pci_range 202 * @range: the PCI range that describes the resource 203 * @np: device node where the range belongs to 204 * @res: pointer to a valid resource that will be updated to 205 * reflect the values contained in the range. 206 * 207 * Returns -EINVAL if the range cannot be converted to resource. 208 * 209 * Note that if the range is an IO range, the resource will be converted 210 * using pci_address_to_pio() which can fail if it is called too early or 211 * if the range cannot be matched to any host bridge IO space (our case here). 212 * To guard against that we try to register the IO range first. 213 * If that fails we know that pci_address_to_pio() will do too. 214 */ 215int of_pci_range_to_resource(struct of_pci_range *range, 216 struct device_node *np, struct resource *res) 217{ 218 int err; 219 res->flags = range->flags; 220 res->parent = res->child = res->sibling = NULL; 221 res->name = np->full_name; 222 223 if (res->flags & IORESOURCE_IO) { 224 unsigned long port; 225 err = pci_register_io_range(&np->fwnode, range->cpu_addr, 226 range->size); 227 if (err) 228 goto invalid_range; 229 port = pci_address_to_pio(range->cpu_addr); 230 if (port == (unsigned long)-1) { 231 err = -EINVAL; 232 goto invalid_range; 233 } 234 res->start = port; 235 } else { 236 if ((sizeof(resource_size_t) < 8) && 237 upper_32_bits(range->cpu_addr)) { 238 err = -EINVAL; 239 goto invalid_range; 240 } 241 242 res->start = range->cpu_addr; 243 } 244 res->end = res->start + range->size - 1; 245 return 0; 246 247invalid_range: 248 res->start = (resource_size_t)OF_BAD_ADDR; 249 res->end = (resource_size_t)OF_BAD_ADDR; 250 return err; 251} 252EXPORT_SYMBOL(of_pci_range_to_resource); 253 254/* 255 * of_range_to_resource - Create a resource from a ranges entry 256 * @np: device node where the range belongs to 257 * @index: the 'ranges' index to convert to a resource 258 * @res: pointer to a valid resource that will be updated to 259 * reflect the values contained in the range. 260 * 261 * Returns ENOENT if the entry is not found or EINVAL if the range cannot be 262 * converted to resource. 263 */ 264int of_range_to_resource(struct device_node *np, int index, struct resource *res) 265{ 266 int ret, i = 0; 267 struct of_range_parser parser; 268 struct of_range range; 269 270 ret = of_range_parser_init(&parser, np); 271 if (ret) 272 return ret; 273 274 for_each_of_range(&parser, &range) 275 if (i++ == index) 276 return of_pci_range_to_resource(&range, np, res); 277 278 return -ENOENT; 279} 280EXPORT_SYMBOL(of_range_to_resource); 281 282/* 283 * ISA bus specific translator 284 */ 285 286static int of_bus_isa_match(struct device_node *np) 287{ 288 return of_node_name_eq(np, "isa"); 289} 290 291static void of_bus_isa_count_cells(struct device_node *child, 292 int *addrc, int *sizec) 293{ 294 if (addrc) 295 *addrc = 2; 296 if (sizec) 297 *sizec = 1; 298} 299 300static u64 of_bus_isa_map(__be32 *addr, const __be32 *range, int na, int ns, 301 int pna, int fna) 302{ 303 /* Check address type match */ 304 if ((addr[0] ^ range[0]) & cpu_to_be32(1)) 305 return OF_BAD_ADDR; 306 307 return of_bus_default_map(addr, range, na, ns, pna, fna); 308} 309 310static unsigned int of_bus_isa_get_flags(const __be32 *addr) 311{ 312 unsigned int flags = 0; 313 u32 w = be32_to_cpup(addr); 314 315 if (w & 1) 316 flags |= IORESOURCE_IO; 317 else 318 flags |= IORESOURCE_MEM; 319 return flags; 320} 321 322static int of_bus_default_flags_match(struct device_node *np) 323{ 324 return of_bus_n_addr_cells(np) == 3; 325} 326 327/* 328 * Array of bus specific translators 329 */ 330 331static struct of_bus of_busses[] = { 332#ifdef CONFIG_PCI 333 /* PCI */ 334 { 335 .name = "pci", 336 .addresses = "assigned-addresses", 337 .match = of_bus_pci_match, 338 .count_cells = of_bus_pci_count_cells, 339 .map = of_bus_pci_map, 340 .translate = of_bus_default_flags_translate, 341 .flag_cells = 1, 342 .get_flags = of_bus_pci_get_flags, 343 }, 344#endif /* CONFIG_PCI */ 345 /* ISA */ 346 { 347 .name = "isa", 348 .addresses = "reg", 349 .match = of_bus_isa_match, 350 .count_cells = of_bus_isa_count_cells, 351 .map = of_bus_isa_map, 352 .translate = of_bus_default_flags_translate, 353 .flag_cells = 1, 354 .get_flags = of_bus_isa_get_flags, 355 }, 356 /* Default with flags cell */ 357 { 358 .name = "default-flags", 359 .addresses = "reg", 360 .match = of_bus_default_flags_match, 361 .count_cells = of_bus_default_count_cells, 362 .map = of_bus_default_flags_map, 363 .translate = of_bus_default_flags_translate, 364 .flag_cells = 1, 365 .get_flags = of_bus_default_flags_get_flags, 366 }, 367 /* Default */ 368 { 369 .name = "default", 370 .addresses = "reg", 371 .match = NULL, 372 .count_cells = of_bus_default_count_cells, 373 .map = of_bus_default_map, 374 .translate = of_bus_default_translate, 375 .get_flags = of_bus_default_get_flags, 376 }, 377}; 378 379static struct of_bus *of_match_bus(struct device_node *np) 380{ 381 int i; 382 383 for (i = 0; i < ARRAY_SIZE(of_busses); i++) 384 if (!of_busses[i].match || of_busses[i].match(np)) 385 return &of_busses[i]; 386 BUG(); 387 return NULL; 388} 389 390static int of_empty_ranges_quirk(struct device_node *np) 391{ 392 if (IS_ENABLED(CONFIG_PPC)) { 393 /* To save cycles, we cache the result for global "Mac" setting */ 394 static int quirk_state = -1; 395 396 /* PA-SEMI sdc DT bug */ 397 if (of_device_is_compatible(np, "1682m-sdc")) 398 return true; 399 400 /* Make quirk cached */ 401 if (quirk_state < 0) 402 quirk_state = 403 of_machine_is_compatible("Power Macintosh") || 404 of_machine_is_compatible("MacRISC"); 405 return quirk_state; 406 } 407 return false; 408} 409 410static int of_translate_one(struct device_node *parent, struct of_bus *bus, 411 struct of_bus *pbus, __be32 *addr, 412 int na, int ns, int pna, const char *rprop) 413{ 414 const __be32 *ranges; 415 unsigned int rlen; 416 int rone; 417 u64 offset = OF_BAD_ADDR; 418 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 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 * This quirk also applies for 'dma-ranges' which frequently exist in 436 * child nodes without 'dma-ranges' in the parent nodes. --RobH 437 */ 438 ranges = of_get_property(parent, rprop, &rlen); 439 if (ranges == NULL && !of_empty_ranges_quirk(parent) && 440 strcmp(rprop, "dma-ranges")) { 441 pr_debug("no ranges; cannot translate\n"); 442 return 1; 443 } 444 if (ranges == NULL || rlen == 0) { 445 offset = of_read_number(addr, na); 446 memset(addr, 0, pna * 4); 447 pr_debug("empty ranges; 1:1 translation\n"); 448 goto finish; 449 } 450 451 pr_debug("walking ranges...\n"); 452 453 /* Now walk through the ranges */ 454 rlen /= 4; 455 rone = na + pna + ns; 456 for (; rlen >= rone; rlen -= rone, ranges += rone) { 457 offset = bus->map(addr, ranges, na, ns, pna, bus->flag_cells); 458 if (offset != OF_BAD_ADDR) 459 break; 460 } 461 if (offset == OF_BAD_ADDR) { 462 pr_debug("not found !\n"); 463 return 1; 464 } 465 memcpy(addr, ranges + na, 4 * pna); 466 467 finish: 468 of_dump_addr("parent translation for:", addr, pna); 469 pr_debug("with offset: %llx\n", offset); 470 471 /* Translate it into parent bus space */ 472 return pbus->translate(addr, offset, pna); 473} 474 475/* 476 * Translate an address from the device-tree into a CPU physical address, 477 * this walks up the tree and applies the various bus mappings on the 478 * way. 479 * 480 * Note: We consider that crossing any level with #size-cells == 0 to mean 481 * that translation is impossible (that is we are not dealing with a value 482 * that can be mapped to a cpu physical address). This is not really specified 483 * that way, but this is traditionally the way IBM at least do things 484 * 485 * Whenever the translation fails, the *host pointer will be set to the 486 * device that had registered logical PIO mapping, and the return code is 487 * relative to that node. 488 */ 489static u64 __of_translate_address(struct device_node *node, 490 struct device_node *(*get_parent)(const struct device_node *), 491 const __be32 *in_addr, const char *rprop, 492 struct device_node **host) 493{ 494 struct device_node *dev __free(device_node) = of_node_get(node); 495 struct device_node *parent __free(device_node) = get_parent(dev); 496 struct of_bus *bus, *pbus; 497 __be32 addr[OF_MAX_ADDR_CELLS]; 498 int na, ns, pna, pns; 499 500 pr_debug("** translation for device %pOF **\n", dev); 501 502 *host = NULL; 503 504 if (parent == NULL) 505 return OF_BAD_ADDR; 506 bus = of_match_bus(parent); 507 508 /* Count address cells & copy address locally */ 509 bus->count_cells(dev, &na, &ns); 510 if (!OF_CHECK_COUNTS(na, ns)) { 511 pr_debug("Bad cell count for %pOF\n", dev); 512 return OF_BAD_ADDR; 513 } 514 memcpy(addr, in_addr, na * 4); 515 516 pr_debug("bus is %s (na=%d, ns=%d) on %pOF\n", 517 bus->name, na, ns, parent); 518 of_dump_addr("translating address:", addr, na); 519 520 /* Translate */ 521 for (;;) { 522 struct logic_pio_hwaddr *iorange; 523 524 /* Switch to parent bus */ 525 of_node_put(dev); 526 dev = parent; 527 parent = get_parent(dev); 528 529 /* If root, we have finished */ 530 if (parent == NULL) { 531 pr_debug("reached root node\n"); 532 return of_read_number(addr, na); 533 } 534 535 /* 536 * For indirectIO device which has no ranges property, get 537 * the address from reg directly. 538 */ 539 iorange = find_io_range_by_fwnode(&dev->fwnode); 540 if (iorange && (iorange->flags != LOGIC_PIO_CPU_MMIO)) { 541 u64 result = of_read_number(addr + 1, na - 1); 542 pr_debug("indirectIO matched(%pOF) 0x%llx\n", 543 dev, result); 544 *host = no_free_ptr(dev); 545 return result; 546 } 547 548 /* Get new parent bus and counts */ 549 pbus = of_match_bus(parent); 550 pbus->count_cells(dev, &pna, &pns); 551 if (!OF_CHECK_COUNTS(pna, pns)) { 552 pr_err("Bad cell count for %pOF\n", dev); 553 return OF_BAD_ADDR; 554 } 555 556 pr_debug("parent bus is %s (na=%d, ns=%d) on %pOF\n", 557 pbus->name, pna, pns, parent); 558 559 /* Apply bus translation */ 560 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop)) 561 return OF_BAD_ADDR; 562 563 /* Complete the move up one level */ 564 na = pna; 565 ns = pns; 566 bus = pbus; 567 568 of_dump_addr("one level translation:", addr, na); 569 } 570 571 unreachable(); 572} 573 574u64 of_translate_address(struct device_node *dev, const __be32 *in_addr) 575{ 576 struct device_node *host; 577 u64 ret; 578 579 ret = __of_translate_address(dev, of_get_parent, 580 in_addr, "ranges", &host); 581 if (host) { 582 of_node_put(host); 583 return OF_BAD_ADDR; 584 } 585 586 return ret; 587} 588EXPORT_SYMBOL(of_translate_address); 589 590#ifdef CONFIG_HAS_DMA 591struct device_node *__of_get_dma_parent(const struct device_node *np) 592{ 593 struct of_phandle_args args; 594 int ret, index; 595 596 index = of_property_match_string(np, "interconnect-names", "dma-mem"); 597 if (index < 0) 598 return of_get_parent(np); 599 600 ret = of_parse_phandle_with_args(np, "interconnects", 601 "#interconnect-cells", 602 index, &args); 603 if (ret < 0) 604 return of_get_parent(np); 605 606 return of_node_get(args.np); 607} 608#endif 609 610static struct device_node *of_get_next_dma_parent(struct device_node *np) 611{ 612 struct device_node *parent; 613 614 parent = __of_get_dma_parent(np); 615 of_node_put(np); 616 617 return parent; 618} 619 620u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr) 621{ 622 struct device_node *host; 623 u64 ret; 624 625 ret = __of_translate_address(dev, __of_get_dma_parent, 626 in_addr, "dma-ranges", &host); 627 628 if (host) { 629 of_node_put(host); 630 return OF_BAD_ADDR; 631 } 632 633 return ret; 634} 635EXPORT_SYMBOL(of_translate_dma_address); 636 637/** 638 * of_translate_dma_region - Translate device tree address and size tuple 639 * @dev: device tree node for which to translate 640 * @prop: pointer into array of cells 641 * @start: return value for the start of the DMA range 642 * @length: return value for the length of the DMA range 643 * 644 * Returns a pointer to the cell immediately following the translated DMA region. 645 */ 646const __be32 *of_translate_dma_region(struct device_node *dev, const __be32 *prop, 647 phys_addr_t *start, size_t *length) 648{ 649 struct device_node *parent __free(device_node) = __of_get_dma_parent(dev); 650 u64 address, size; 651 int na, ns; 652 653 if (!parent) 654 return NULL; 655 656 na = of_bus_n_addr_cells(parent); 657 ns = of_bus_n_size_cells(parent); 658 659 address = of_translate_dma_address(dev, prop); 660 if (address == OF_BAD_ADDR) 661 return NULL; 662 663 size = of_read_number(prop + na, ns); 664 665 if (start) 666 *start = address; 667 668 if (length) 669 *length = size; 670 671 return prop + na + ns; 672} 673EXPORT_SYMBOL(of_translate_dma_region); 674 675const __be32 *__of_get_address(struct device_node *dev, int index, int bar_no, 676 u64 *size, unsigned int *flags) 677{ 678 const __be32 *prop; 679 unsigned int psize; 680 struct device_node *parent __free(device_node) = of_get_parent(dev); 681 struct of_bus *bus; 682 int onesize, i, na, ns; 683 684 if (parent == NULL) 685 return NULL; 686 687 /* match the parent's bus type */ 688 bus = of_match_bus(parent); 689 if (strcmp(bus->name, "pci") && (bar_no >= 0)) 690 return NULL; 691 692 bus->count_cells(dev, &na, &ns); 693 if (!OF_CHECK_ADDR_COUNT(na)) 694 return NULL; 695 696 /* Get "reg" or "assigned-addresses" property */ 697 prop = of_get_property(dev, bus->addresses, &psize); 698 if (prop == NULL) 699 return NULL; 700 psize /= 4; 701 702 onesize = na + ns; 703 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) { 704 u32 val = be32_to_cpu(prop[0]); 705 /* PCI bus matches on BAR number instead of index */ 706 if (((bar_no >= 0) && ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0))) || 707 ((index >= 0) && (i == index))) { 708 if (size) 709 *size = of_read_number(prop + na, ns); 710 if (flags) 711 *flags = bus->get_flags(prop); 712 return prop; 713 } 714 } 715 return NULL; 716} 717EXPORT_SYMBOL(__of_get_address); 718 719/** 720 * of_property_read_reg - Retrieve the specified "reg" entry index without translating 721 * @np: device tree node for which to retrieve "reg" from 722 * @idx: "reg" entry index to read 723 * @addr: return value for the untranslated address 724 * @size: return value for the entry size 725 * 726 * Returns -EINVAL if "reg" is not found. Returns 0 on success with addr and 727 * size values filled in. 728 */ 729int of_property_read_reg(struct device_node *np, int idx, u64 *addr, u64 *size) 730{ 731 const __be32 *prop = of_get_address(np, idx, size, NULL); 732 733 if (!prop) 734 return -EINVAL; 735 736 *addr = of_read_number(prop, of_n_addr_cells(np)); 737 738 return 0; 739} 740EXPORT_SYMBOL(of_property_read_reg); 741 742static int parser_init(struct of_pci_range_parser *parser, 743 struct device_node *node, const char *name) 744{ 745 int rlen; 746 747 parser->node = node; 748 parser->pna = of_n_addr_cells(node); 749 parser->na = of_bus_n_addr_cells(node); 750 parser->ns = of_bus_n_size_cells(node); 751 parser->dma = !strcmp(name, "dma-ranges"); 752 parser->bus = of_match_bus(node); 753 754 parser->range = of_get_property(node, name, &rlen); 755 if (parser->range == NULL) 756 return -ENOENT; 757 758 parser->end = parser->range + rlen / sizeof(__be32); 759 760 return 0; 761} 762 763int of_pci_range_parser_init(struct of_pci_range_parser *parser, 764 struct device_node *node) 765{ 766 return parser_init(parser, node, "ranges"); 767} 768EXPORT_SYMBOL_GPL(of_pci_range_parser_init); 769 770int of_pci_dma_range_parser_init(struct of_pci_range_parser *parser, 771 struct device_node *node) 772{ 773 return parser_init(parser, node, "dma-ranges"); 774} 775EXPORT_SYMBOL_GPL(of_pci_dma_range_parser_init); 776#define of_dma_range_parser_init of_pci_dma_range_parser_init 777 778struct of_pci_range *of_pci_range_parser_one(struct of_pci_range_parser *parser, 779 struct of_pci_range *range) 780{ 781 int na = parser->na; 782 int ns = parser->ns; 783 int np = parser->pna + na + ns; 784 int busflag_na = parser->bus->flag_cells; 785 786 if (!range) 787 return NULL; 788 789 if (!parser->range || parser->range + np > parser->end) 790 return NULL; 791 792 range->flags = parser->bus->get_flags(parser->range); 793 794 range->bus_addr = of_read_number(parser->range + busflag_na, na - busflag_na); 795 796 if (parser->dma) 797 range->cpu_addr = of_translate_dma_address(parser->node, 798 parser->range + na); 799 else 800 range->cpu_addr = of_translate_address(parser->node, 801 parser->range + na); 802 range->size = of_read_number(parser->range + parser->pna + na, ns); 803 804 parser->range += np; 805 806 /* Now consume following elements while they are contiguous */ 807 while (parser->range + np <= parser->end) { 808 u32 flags = 0; 809 u64 bus_addr, cpu_addr, size; 810 811 flags = parser->bus->get_flags(parser->range); 812 bus_addr = of_read_number(parser->range + busflag_na, na - busflag_na); 813 if (parser->dma) 814 cpu_addr = of_translate_dma_address(parser->node, 815 parser->range + na); 816 else 817 cpu_addr = of_translate_address(parser->node, 818 parser->range + na); 819 size = of_read_number(parser->range + parser->pna + na, ns); 820 821 if (flags != range->flags) 822 break; 823 if (bus_addr != range->bus_addr + range->size || 824 cpu_addr != range->cpu_addr + range->size) 825 break; 826 827 range->size += size; 828 parser->range += np; 829 } 830 831 return range; 832} 833EXPORT_SYMBOL_GPL(of_pci_range_parser_one); 834 835static u64 of_translate_ioport(struct device_node *dev, const __be32 *in_addr, 836 u64 size) 837{ 838 u64 taddr; 839 unsigned long port; 840 struct device_node *host; 841 842 taddr = __of_translate_address(dev, of_get_parent, 843 in_addr, "ranges", &host); 844 if (host) { 845 /* host-specific port access */ 846 port = logic_pio_trans_hwaddr(&host->fwnode, taddr, size); 847 of_node_put(host); 848 } else { 849 /* memory-mapped I/O range */ 850 port = pci_address_to_pio(taddr); 851 } 852 853 if (port == (unsigned long)-1) 854 return OF_BAD_ADDR; 855 856 return port; 857} 858 859#ifdef CONFIG_HAS_DMA 860/** 861 * of_dma_get_range - Get DMA range info and put it into a map array 862 * @np: device node to get DMA range info 863 * @map: dma range structure to return 864 * 865 * Look in bottom up direction for the first "dma-ranges" property 866 * and parse it. Put the information into a DMA offset map array. 867 * 868 * dma-ranges format: 869 * DMA addr (dma_addr) : naddr cells 870 * CPU addr (phys_addr_t) : pna cells 871 * size : nsize cells 872 * 873 * It returns -ENODEV if "dma-ranges" property was not found for this 874 * device in the DT. 875 */ 876int of_dma_get_range(struct device_node *np, const struct bus_dma_region **map) 877{ 878 struct device_node *node __free(device_node) = of_node_get(np); 879 const __be32 *ranges = NULL; 880 bool found_dma_ranges = false; 881 struct of_range_parser parser; 882 struct of_range range; 883 struct bus_dma_region *r; 884 int len, num_ranges = 0; 885 886 while (node) { 887 ranges = of_get_property(node, "dma-ranges", &len); 888 889 /* Ignore empty ranges, they imply no translation required */ 890 if (ranges && len > 0) 891 break; 892 893 /* Once we find 'dma-ranges', then a missing one is an error */ 894 if (found_dma_ranges && !ranges) 895 return -ENODEV; 896 897 found_dma_ranges = true; 898 899 node = of_get_next_dma_parent(node); 900 } 901 902 if (!node || !ranges) { 903 pr_debug("no dma-ranges found for node(%pOF)\n", np); 904 return -ENODEV; 905 } 906 of_dma_range_parser_init(&parser, node); 907 for_each_of_range(&parser, &range) { 908 if (range.cpu_addr == OF_BAD_ADDR) { 909 pr_err("translation of DMA address(%llx) to CPU address failed node(%pOF)\n", 910 range.bus_addr, node); 911 continue; 912 } 913 num_ranges++; 914 } 915 916 if (!num_ranges) 917 return -EINVAL; 918 919 r = kcalloc(num_ranges + 1, sizeof(*r), GFP_KERNEL); 920 if (!r) 921 return -ENOMEM; 922 923 /* 924 * Record all info in the generic DMA ranges array for struct device, 925 * returning an error if we don't find any parsable ranges. 926 */ 927 *map = r; 928 of_dma_range_parser_init(&parser, node); 929 for_each_of_range(&parser, &range) { 930 pr_debug("dma_addr(%llx) cpu_addr(%llx) size(%llx)\n", 931 range.bus_addr, range.cpu_addr, range.size); 932 if (range.cpu_addr == OF_BAD_ADDR) 933 continue; 934 r->cpu_start = range.cpu_addr; 935 r->dma_start = range.bus_addr; 936 r->size = range.size; 937 r++; 938 } 939 return 0; 940} 941#endif /* CONFIG_HAS_DMA */ 942 943/** 944 * of_dma_get_max_cpu_address - Gets highest CPU address suitable for DMA 945 * @np: The node to start searching from or NULL to start from the root 946 * 947 * Gets the highest CPU physical address that is addressable by all DMA masters 948 * in the sub-tree pointed by np, or the whole tree if NULL is passed. If no 949 * DMA constrained device is found, it returns PHYS_ADDR_MAX. 950 */ 951phys_addr_t __init of_dma_get_max_cpu_address(struct device_node *np) 952{ 953 phys_addr_t max_cpu_addr = PHYS_ADDR_MAX; 954 struct of_range_parser parser; 955 phys_addr_t subtree_max_addr; 956 struct device_node *child; 957 struct of_range range; 958 const __be32 *ranges; 959 u64 cpu_end = 0; 960 int len; 961 962 if (!np) 963 np = of_root; 964 965 ranges = of_get_property(np, "dma-ranges", &len); 966 if (ranges && len) { 967 of_dma_range_parser_init(&parser, np); 968 for_each_of_range(&parser, &range) 969 if (range.cpu_addr + range.size > cpu_end) 970 cpu_end = range.cpu_addr + range.size - 1; 971 972 if (max_cpu_addr > cpu_end) 973 max_cpu_addr = cpu_end; 974 } 975 976 for_each_available_child_of_node(np, child) { 977 subtree_max_addr = of_dma_get_max_cpu_address(child); 978 if (max_cpu_addr > subtree_max_addr) 979 max_cpu_addr = subtree_max_addr; 980 } 981 982 return max_cpu_addr; 983} 984 985/** 986 * of_dma_is_coherent - Check if device is coherent 987 * @np: device node 988 * 989 * It returns true if "dma-coherent" property was found 990 * for this device in the DT, or if DMA is coherent by 991 * default for OF devices on the current platform and no 992 * "dma-noncoherent" property was found for this device. 993 */ 994bool of_dma_is_coherent(struct device_node *np) 995{ 996 struct device_node *node __free(device_node) = of_node_get(np); 997 998 while (node) { 999 if (of_property_read_bool(node, "dma-coherent")) 1000 return true; 1001 1002 if (of_property_read_bool(node, "dma-noncoherent")) 1003 return false; 1004 1005 node = of_get_next_dma_parent(node); 1006 } 1007 return dma_default_coherent; 1008} 1009EXPORT_SYMBOL_GPL(of_dma_is_coherent); 1010 1011/** 1012 * of_mmio_is_nonposted - Check if device uses non-posted MMIO 1013 * @np: device node 1014 * 1015 * Returns true if the "nonposted-mmio" property was found for 1016 * the device's bus. 1017 * 1018 * This is currently only enabled on builds that support Apple ARM devices, as 1019 * an optimization. 1020 */ 1021static bool of_mmio_is_nonposted(struct device_node *np) 1022{ 1023 if (!IS_ENABLED(CONFIG_ARCH_APPLE)) 1024 return false; 1025 1026 struct device_node *parent __free(device_node) = of_get_parent(np); 1027 if (!parent) 1028 return false; 1029 1030 return of_property_read_bool(parent, "nonposted-mmio"); 1031} 1032 1033static int __of_address_to_resource(struct device_node *dev, int index, int bar_no, 1034 struct resource *r) 1035{ 1036 u64 taddr; 1037 const __be32 *addrp; 1038 u64 size; 1039 unsigned int flags; 1040 const char *name = NULL; 1041 1042 addrp = __of_get_address(dev, index, bar_no, &size, &flags); 1043 if (addrp == NULL) 1044 return -EINVAL; 1045 1046 /* Get optional "reg-names" property to add a name to a resource */ 1047 if (index >= 0) 1048 of_property_read_string_index(dev, "reg-names", index, &name); 1049 1050 if (flags & IORESOURCE_MEM) 1051 taddr = of_translate_address(dev, addrp); 1052 else if (flags & IORESOURCE_IO) 1053 taddr = of_translate_ioport(dev, addrp, size); 1054 else 1055 return -EINVAL; 1056 1057 if (taddr == OF_BAD_ADDR) 1058 return -EINVAL; 1059 memset(r, 0, sizeof(struct resource)); 1060 1061 if (of_mmio_is_nonposted(dev)) 1062 flags |= IORESOURCE_MEM_NONPOSTED; 1063 1064 r->start = taddr; 1065 r->end = taddr + size - 1; 1066 r->flags = flags; 1067 r->name = name ? name : dev->full_name; 1068 1069 return 0; 1070} 1071 1072/** 1073 * of_address_to_resource - Translate device tree address and return as resource 1074 * @dev: Caller's Device Node 1075 * @index: Index into the array 1076 * @r: Pointer to resource array 1077 * 1078 * Returns -EINVAL if the range cannot be converted to resource. 1079 * 1080 * Note that if your address is a PIO address, the conversion will fail if 1081 * the physical address can't be internally converted to an IO token with 1082 * pci_address_to_pio(), that is because it's either called too early or it 1083 * can't be matched to any host bridge IO space 1084 */ 1085int of_address_to_resource(struct device_node *dev, int index, 1086 struct resource *r) 1087{ 1088 return __of_address_to_resource(dev, index, -1, r); 1089} 1090EXPORT_SYMBOL_GPL(of_address_to_resource); 1091 1092int of_pci_address_to_resource(struct device_node *dev, int bar, 1093 struct resource *r) 1094{ 1095 1096 if (!IS_ENABLED(CONFIG_PCI)) 1097 return -ENOSYS; 1098 1099 return __of_address_to_resource(dev, -1, bar, r); 1100} 1101EXPORT_SYMBOL_GPL(of_pci_address_to_resource); 1102 1103/** 1104 * of_iomap - Maps the memory mapped IO for a given device_node 1105 * @np: the device whose io range will be mapped 1106 * @index: index of the io range 1107 * 1108 * Returns a pointer to the mapped memory 1109 */ 1110void __iomem *of_iomap(struct device_node *np, int index) 1111{ 1112 struct resource res; 1113 1114 if (of_address_to_resource(np, index, &res)) 1115 return NULL; 1116 1117 if (res.flags & IORESOURCE_MEM_NONPOSTED) 1118 return ioremap_np(res.start, resource_size(&res)); 1119 else 1120 return ioremap(res.start, resource_size(&res)); 1121} 1122EXPORT_SYMBOL(of_iomap); 1123 1124/* 1125 * of_io_request_and_map - Requests a resource and maps the memory mapped IO 1126 * for a given device_node 1127 * @device: the device whose io range will be mapped 1128 * @index: index of the io range 1129 * @name: name "override" for the memory region request or NULL 1130 * 1131 * Returns a pointer to the requested and mapped memory or an ERR_PTR() encoded 1132 * error code on failure. Usage example: 1133 * 1134 * base = of_io_request_and_map(node, 0, "foo"); 1135 * if (IS_ERR(base)) 1136 * return PTR_ERR(base); 1137 */ 1138void __iomem *of_io_request_and_map(struct device_node *np, int index, 1139 const char *name) 1140{ 1141 struct resource res; 1142 void __iomem *mem; 1143 1144 if (of_address_to_resource(np, index, &res)) 1145 return IOMEM_ERR_PTR(-EINVAL); 1146 1147 if (!name) 1148 name = res.name; 1149 if (!request_mem_region(res.start, resource_size(&res), name)) 1150 return IOMEM_ERR_PTR(-EBUSY); 1151 1152 if (res.flags & IORESOURCE_MEM_NONPOSTED) 1153 mem = ioremap_np(res.start, resource_size(&res)); 1154 else 1155 mem = ioremap(res.start, resource_size(&res)); 1156 1157 if (!mem) { 1158 release_mem_region(res.start, resource_size(&res)); 1159 return IOMEM_ERR_PTR(-ENOMEM); 1160 } 1161 1162 return mem; 1163} 1164EXPORT_SYMBOL(of_io_request_and_map); 1165