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