fdt_common.c revision 330897
1/*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2009-2014 The FreeBSD Foundation 5 * All rights reserved. 6 * 7 * This software was developed by Andrew Turner under sponsorship from 8 * the FreeBSD Foundation. 9 * This software was developed by Semihalf under sponsorship from 10 * the FreeBSD Foundation. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34#include <sys/cdefs.h> 35__FBSDID("$FreeBSD: stable/11/sys/dev/fdt/fdt_common.c 330897 2018-03-14 03:19:51Z eadler $"); 36 37#include <sys/param.h> 38#include <sys/systm.h> 39#include <sys/kernel.h> 40#include <sys/module.h> 41#include <sys/bus.h> 42#include <sys/limits.h> 43 44#include <machine/resource.h> 45 46#include <dev/fdt/fdt_common.h> 47#include <dev/ofw/ofw_bus.h> 48#include <dev/ofw/ofw_bus_subr.h> 49#include <dev/ofw/openfirm.h> 50 51#include "ofw_bus_if.h" 52 53#ifdef DEBUG 54#define debugf(fmt, args...) do { printf("%s(): ", __func__); \ 55 printf(fmt,##args); } while (0) 56#else 57#define debugf(fmt, args...) 58#endif 59 60#define FDT_COMPAT_LEN 255 61#define FDT_TYPE_LEN 64 62 63#define FDT_REG_CELLS 4 64 65vm_paddr_t fdt_immr_pa; 66vm_offset_t fdt_immr_va; 67vm_offset_t fdt_immr_size; 68 69struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head); 70 71static int 72fdt_get_range_by_busaddr(phandle_t node, u_long addr, u_long *base, 73 u_long *size) 74{ 75 pcell_t ranges[32], *rangesptr; 76 pcell_t addr_cells, size_cells, par_addr_cells; 77 u_long bus_addr, par_bus_addr, pbase, psize; 78 int err, i, len, tuple_size, tuples; 79 80 if (node == 0) { 81 *base = 0; 82 *size = ULONG_MAX; 83 return (0); 84 } 85 86 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0) 87 return (ENXIO); 88 /* 89 * Process 'ranges' property. 90 */ 91 par_addr_cells = fdt_parent_addr_cells(node); 92 if (par_addr_cells > 2) { 93 return (ERANGE); 94 } 95 96 len = OF_getproplen(node, "ranges"); 97 if (len < 0) 98 return (-1); 99 if (len > sizeof(ranges)) 100 return (ENOMEM); 101 if (len == 0) { 102 return (fdt_get_range_by_busaddr(OF_parent(node), addr, 103 base, size)); 104 } 105 106 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0) 107 return (EINVAL); 108 109 tuple_size = addr_cells + par_addr_cells + size_cells; 110 tuples = len / (tuple_size * sizeof(cell_t)); 111 112 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2) 113 return (ERANGE); 114 115 *base = 0; 116 *size = 0; 117 118 for (i = 0; i < tuples; i++) { 119 rangesptr = &ranges[i * tuple_size]; 120 121 bus_addr = fdt_data_get((void *)rangesptr, addr_cells); 122 if (bus_addr != addr) 123 continue; 124 rangesptr += addr_cells; 125 126 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells); 127 rangesptr += par_addr_cells; 128 129 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr, 130 &pbase, &psize); 131 if (err > 0) 132 return (err); 133 if (err == 0) 134 *base = pbase; 135 else 136 *base = par_bus_addr; 137 138 *size = fdt_data_get((void *)rangesptr, size_cells); 139 140 return (0); 141 } 142 143 return (EINVAL); 144} 145 146int 147fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size) 148{ 149 pcell_t ranges[6], *rangesptr; 150 pcell_t addr_cells, size_cells, par_addr_cells; 151 u_long par_bus_addr, pbase, psize; 152 int err, len, tuple_size, tuples; 153 154 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0) 155 return (ENXIO); 156 /* 157 * Process 'ranges' property. 158 */ 159 par_addr_cells = fdt_parent_addr_cells(node); 160 if (par_addr_cells > 2) 161 return (ERANGE); 162 163 len = OF_getproplen(node, "ranges"); 164 if (len > sizeof(ranges)) 165 return (ENOMEM); 166 if (len == 0) { 167 *base = 0; 168 *size = ULONG_MAX; 169 return (0); 170 } 171 172 if (!(range_id < len)) 173 return (ERANGE); 174 175 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0) 176 return (EINVAL); 177 178 tuple_size = sizeof(pcell_t) * (addr_cells + par_addr_cells + 179 size_cells); 180 tuples = len / tuple_size; 181 182 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2) 183 return (ERANGE); 184 185 *base = 0; 186 *size = 0; 187 rangesptr = &ranges[range_id]; 188 189 *base = fdt_data_get((void *)rangesptr, addr_cells); 190 rangesptr += addr_cells; 191 192 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells); 193 rangesptr += par_addr_cells; 194 195 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr, 196 &pbase, &psize); 197 if (err == 0) 198 *base += pbase; 199 else 200 *base += par_bus_addr; 201 202 *size = fdt_data_get((void *)rangesptr, size_cells); 203 return (0); 204} 205 206int 207fdt_immr_addr(vm_offset_t immr_va) 208{ 209 phandle_t node; 210 u_long base, size; 211 int r; 212 213 /* 214 * Try to access the SOC node directly i.e. through /aliases/. 215 */ 216 if ((node = OF_finddevice("soc")) != 0) 217 if (fdt_is_compatible(node, "simple-bus")) 218 goto moveon; 219 /* 220 * Find the node the long way. 221 */ 222 if ((node = OF_finddevice("/")) == 0) 223 return (ENXIO); 224 225 if ((node = fdt_find_compatible(node, "simple-bus", 0)) == 0) 226 return (ENXIO); 227 228moveon: 229 if ((r = fdt_get_range(node, 0, &base, &size)) == 0) { 230 fdt_immr_pa = base; 231 fdt_immr_va = immr_va; 232 fdt_immr_size = size; 233 } 234 235 return (r); 236} 237 238/* 239 * This routine is an early-usage version of the ofw_bus_is_compatible() when 240 * the ofw_bus I/F is not available (like early console routines and similar). 241 * Note the buffer has to be on the stack since malloc() is usually not 242 * available in such cases either. 243 */ 244int 245fdt_is_compatible(phandle_t node, const char *compatstr) 246{ 247 char buf[FDT_COMPAT_LEN]; 248 char *compat; 249 int len, onelen, l, rv; 250 251 if ((len = OF_getproplen(node, "compatible")) <= 0) 252 return (0); 253 254 compat = (char *)&buf; 255 bzero(compat, FDT_COMPAT_LEN); 256 257 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0) 258 return (0); 259 260 onelen = strlen(compatstr); 261 rv = 0; 262 while (len > 0) { 263 if (strncasecmp(compat, compatstr, onelen) == 0) { 264 /* Found it. */ 265 rv = 1; 266 break; 267 } 268 /* Slide to the next sub-string. */ 269 l = strlen(compat) + 1; 270 compat += l; 271 len -= l; 272 } 273 274 return (rv); 275} 276 277int 278fdt_is_compatible_strict(phandle_t node, const char *compatible) 279{ 280 char compat[FDT_COMPAT_LEN]; 281 282 if (OF_getproplen(node, "compatible") <= 0) 283 return (0); 284 285 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0) 286 return (0); 287 288 if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0) 289 /* This fits. */ 290 return (1); 291 292 return (0); 293} 294 295phandle_t 296fdt_find_compatible(phandle_t start, const char *compat, int strict) 297{ 298 phandle_t child; 299 300 /* 301 * Traverse all children of 'start' node, and find first with 302 * matching 'compatible' property. 303 */ 304 for (child = OF_child(start); child != 0; child = OF_peer(child)) 305 if (fdt_is_compatible(child, compat)) { 306 if (strict) 307 if (!fdt_is_compatible_strict(child, compat)) 308 continue; 309 return (child); 310 } 311 return (0); 312} 313 314phandle_t 315fdt_depth_search_compatible(phandle_t start, const char *compat, int strict) 316{ 317 phandle_t child, node; 318 319 /* 320 * Depth-search all descendants of 'start' node, and find first with 321 * matching 'compatible' property. 322 */ 323 for (node = OF_child(start); node != 0; node = OF_peer(node)) { 324 if (fdt_is_compatible(node, compat) && 325 (strict == 0 || fdt_is_compatible_strict(node, compat))) { 326 return (node); 327 } 328 child = fdt_depth_search_compatible(node, compat, strict); 329 if (child != 0) 330 return (child); 331 } 332 return (0); 333} 334 335int 336fdt_is_enabled(phandle_t node) 337{ 338 char *stat; 339 int ena, len; 340 341 len = OF_getprop_alloc(node, "status", sizeof(char), 342 (void **)&stat); 343 344 if (len <= 0) 345 /* It is OK if no 'status' property. */ 346 return (1); 347 348 /* Anything other than 'okay' means disabled. */ 349 ena = 0; 350 if (strncmp((char *)stat, "okay", len) == 0) 351 ena = 1; 352 353 OF_prop_free(stat); 354 return (ena); 355} 356 357int 358fdt_is_type(phandle_t node, const char *typestr) 359{ 360 char type[FDT_TYPE_LEN]; 361 362 if (OF_getproplen(node, "device_type") <= 0) 363 return (0); 364 365 if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0) 366 return (0); 367 368 if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0) 369 /* This fits. */ 370 return (1); 371 372 return (0); 373} 374 375int 376fdt_parent_addr_cells(phandle_t node) 377{ 378 pcell_t addr_cells; 379 380 /* Find out #address-cells of the superior bus. */ 381 if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells, 382 sizeof(addr_cells)) <= 0) 383 return (2); 384 385 return ((int)fdt32_to_cpu(addr_cells)); 386} 387 388int 389fdt_pm_is_enabled(phandle_t node) 390{ 391 int ret; 392 393 ret = 1; 394 395#if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY) 396 ret = fdt_pm(node); 397#endif 398 return (ret); 399} 400 401u_long 402fdt_data_get(void *data, int cells) 403{ 404 405 if (cells == 1) 406 return (fdt32_to_cpu(*((uint32_t *)data))); 407 408 return (fdt64_to_cpu(*((uint64_t *)data))); 409} 410 411int 412fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells) 413{ 414 pcell_t cell; 415 int cell_size; 416 417 /* 418 * Retrieve #{address,size}-cells. 419 */ 420 cell_size = sizeof(cell); 421 if (OF_getprop(node, "#address-cells", &cell, cell_size) < cell_size) 422 cell = 2; 423 *addr_cells = fdt32_to_cpu((int)cell); 424 425 if (OF_getprop(node, "#size-cells", &cell, cell_size) < cell_size) 426 cell = 1; 427 *size_cells = fdt32_to_cpu((int)cell); 428 429 if (*addr_cells > 3 || *size_cells > 2) 430 return (ERANGE); 431 return (0); 432} 433 434int 435fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start, 436 u_long *count) 437{ 438 439 /* Address portion. */ 440 if (addr_cells > 2) 441 return (ERANGE); 442 443 *start = fdt_data_get((void *)data, addr_cells); 444 data += addr_cells; 445 446 /* Size portion. */ 447 if (size_cells > 2) 448 return (ERANGE); 449 450 *count = fdt_data_get((void *)data, size_cells); 451 return (0); 452} 453 454int 455fdt_regsize(phandle_t node, u_long *base, u_long *size) 456{ 457 pcell_t reg[4]; 458 int addr_cells, len, size_cells; 459 460 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells)) 461 return (ENXIO); 462 463 if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg)) 464 return (ENOMEM); 465 466 len = OF_getprop(node, "reg", ®, sizeof(reg)); 467 if (len <= 0) 468 return (EINVAL); 469 470 *base = fdt_data_get(®[0], addr_cells); 471 *size = fdt_data_get(®[addr_cells], size_cells); 472 return (0); 473} 474 475int 476fdt_reg_to_rl(phandle_t node, struct resource_list *rl) 477{ 478 u_long end, count, start; 479 pcell_t *reg, *regptr; 480 pcell_t addr_cells, size_cells; 481 int tuple_size, tuples; 482 int i, rv; 483 long busaddr, bussize; 484 485 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0) 486 return (ENXIO); 487 if (fdt_get_range(OF_parent(node), 0, &busaddr, &bussize)) { 488 busaddr = 0; 489 bussize = 0; 490 } 491 492 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 493 tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)®); 494 debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells); 495 debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size); 496 if (tuples <= 0) 497 /* No 'reg' property in this node. */ 498 return (0); 499 500 regptr = reg; 501 for (i = 0; i < tuples; i++) { 502 503 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start, 504 &count); 505 if (rv != 0) { 506 resource_list_free(rl); 507 goto out; 508 } 509 reg += addr_cells + size_cells; 510 511 /* Calculate address range relative to base. */ 512 start += busaddr; 513 end = start + count - 1; 514 515 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start, 516 end, count); 517 518 resource_list_add(rl, SYS_RES_MEMORY, i, start, end, 519 count); 520 } 521 rv = 0; 522 523out: 524 OF_prop_free(regptr); 525 return (rv); 526} 527 528int 529fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc) 530{ 531 phandle_t phy_node; 532 pcell_t phy_handle, phy_reg; 533 uint32_t i; 534 device_t parent, child; 535 536 if (OF_getencprop(node, "phy-handle", (void *)&phy_handle, 537 sizeof(phy_handle)) <= 0) 538 return (ENXIO); 539 540 phy_node = OF_node_from_xref(phy_handle); 541 542 if (OF_getprop(phy_node, "reg", (void *)&phy_reg, 543 sizeof(phy_reg)) <= 0) 544 return (ENXIO); 545 546 *phy_addr = fdt32_to_cpu(phy_reg); 547 548 /* 549 * Search for softc used to communicate with phy. 550 */ 551 552 /* 553 * Step 1: Search for ancestor of the phy-node with a "phy-handle" 554 * property set. 555 */ 556 phy_node = OF_parent(phy_node); 557 while (phy_node != 0) { 558 if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle, 559 sizeof(phy_handle)) > 0) 560 break; 561 phy_node = OF_parent(phy_node); 562 } 563 if (phy_node == 0) 564 return (ENXIO); 565 566 /* 567 * Step 2: For each device with the same parent and name as ours 568 * compare its node with the one found in step 1, ancestor of phy 569 * node (stored in phy_node). 570 */ 571 parent = device_get_parent(dev); 572 i = 0; 573 child = device_find_child(parent, device_get_name(dev), i); 574 while (child != NULL) { 575 if (ofw_bus_get_node(child) == phy_node) 576 break; 577 i++; 578 child = device_find_child(parent, device_get_name(dev), i); 579 } 580 if (child == NULL) 581 return (ENXIO); 582 583 /* 584 * Use softc of the device found. 585 */ 586 *phy_sc = (void *)device_get_softc(child); 587 588 return (0); 589} 590 591int 592fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt) 593{ 594 pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS]; 595 pcell_t *reservep; 596 phandle_t memory, root; 597 uint32_t memory_size; 598 int addr_cells, size_cells; 599 int i, max_size, res_len, rv, tuple_size, tuples; 600 601 max_size = sizeof(reserve); 602 root = OF_finddevice("/"); 603 memory = OF_finddevice("/memory"); 604 if (memory == -1) { 605 rv = ENXIO; 606 goto out; 607 } 608 609 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells, 610 &size_cells)) != 0) 611 goto out; 612 613 if (addr_cells > 2) { 614 rv = ERANGE; 615 goto out; 616 } 617 618 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 619 620 res_len = OF_getproplen(root, "memreserve"); 621 if (res_len <= 0 || res_len > sizeof(reserve)) { 622 rv = ERANGE; 623 goto out; 624 } 625 626 if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) { 627 rv = ENXIO; 628 goto out; 629 } 630 631 memory_size = 0; 632 tuples = res_len / tuple_size; 633 reservep = (pcell_t *)&reserve; 634 for (i = 0; i < tuples; i++) { 635 636 rv = fdt_data_to_res(reservep, addr_cells, size_cells, 637 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size); 638 639 if (rv != 0) 640 goto out; 641 642 reservep += addr_cells + size_cells; 643 } 644 645 *mrcnt = i; 646 rv = 0; 647out: 648 return (rv); 649} 650 651int 652fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint64_t *memsize) 653{ 654 pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS]; 655 pcell_t *regp; 656 phandle_t memory; 657 uint64_t memory_size; 658 int addr_cells, size_cells; 659 int i, max_size, reg_len, rv, tuple_size, tuples; 660 661 max_size = sizeof(reg); 662 memory = OF_finddevice("/memory"); 663 if (memory == -1) { 664 rv = ENXIO; 665 goto out; 666 } 667 668 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells, 669 &size_cells)) != 0) 670 goto out; 671 672 if (addr_cells > 2) { 673 rv = ERANGE; 674 goto out; 675 } 676 677 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells); 678 reg_len = OF_getproplen(memory, "reg"); 679 if (reg_len <= 0 || reg_len > sizeof(reg)) { 680 rv = ERANGE; 681 goto out; 682 } 683 684 if (OF_getprop(memory, "reg", reg, reg_len) <= 0) { 685 rv = ENXIO; 686 goto out; 687 } 688 689 memory_size = 0; 690 tuples = reg_len / tuple_size; 691 regp = (pcell_t *)® 692 for (i = 0; i < tuples; i++) { 693 694 rv = fdt_data_to_res(regp, addr_cells, size_cells, 695 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size); 696 697 if (rv != 0) 698 goto out; 699 700 regp += addr_cells + size_cells; 701 memory_size += mr[i].mr_size; 702 } 703 704 if (memory_size == 0) { 705 rv = ERANGE; 706 goto out; 707 } 708 709 *mrcnt = i; 710 if (memsize != NULL) 711 *memsize = memory_size; 712 rv = 0; 713out: 714 return (rv); 715} 716 717int 718fdt_get_unit(device_t dev) 719{ 720 const char * name; 721 722 name = ofw_bus_get_name(dev); 723 name = strchr(name, '@') + 1; 724 725 return (strtol(name,NULL,0)); 726} 727 728int 729fdt_get_chosen_bootargs(char *bootargs, size_t max_size) 730{ 731 phandle_t chosen; 732 733 chosen = OF_finddevice("/chosen"); 734 if (chosen == -1) 735 return (ENXIO); 736 if (OF_getprop(chosen, "bootargs", bootargs, max_size) == -1) 737 return (ENXIO); 738 return (0); 739} 740