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