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