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 <stand.h> 34 #include <fdt.h> 35 #include <libfdt.h> 36 #include <sys/param.h> 37 #include <sys/linker.h> 38 #include <machine/elf.h> 39 40 #include "bootstrap.h" 41 #include "fdt_platform.h" 42 #include "fdt_overlay.h" 43 44 #ifdef DEBUG 45 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \ 46 printf(fmt,##args); } while (0) 47 #else 48 #define debugf(fmt, args...) 49 #endif 50 51 #define FDT_CWD_LEN 256 52 #define FDT_MAX_DEPTH 12 53 54 #define FDT_PROP_SEP " = " 55 56 #define COPYOUT(s,d,l) archsw.arch_copyout(s, d, l) 57 #define COPYIN(s,d,l) archsw.arch_copyin(s, d, l) 58 59 #define FDT_STATIC_DTB_SYMBOL "fdt_static_dtb" 60 61 #define CMD_REQUIRES_BLOB 0x01 62 63 /* Location of FDT yet to be loaded. */ 64 /* This may be in read-only memory, so can't be manipulated directly. */ 65 static struct fdt_header *fdt_to_load = NULL; 66 /* Location of FDT on heap. */ 67 /* This is the copy we actually manipulate. */ 68 static struct fdt_header *fdtp = NULL; 69 /* Size of FDT blob */ 70 static size_t fdtp_size = 0; 71 /* Location of FDT in kernel or module. */ 72 /* This won't be set if FDT is loaded from disk or memory. */ 73 /* If it is set, we'll update it when fdt_copy() gets called. */ 74 static vm_offset_t fdtp_va = 0; 75 76 static int fdt_load_dtb(vm_offset_t va); 77 78 static int fdt_cmd_nyi(int argc, char *argv[]); 79 80 static int fdt_cmd_addr(int argc, char *argv[]); 81 static int fdt_cmd_mkprop(int argc, char *argv[]); 82 static int fdt_cmd_cd(int argc, char *argv[]); 83 static int fdt_cmd_hdr(int argc, char *argv[]); 84 static int fdt_cmd_ls(int argc, char *argv[]); 85 static int fdt_cmd_prop(int argc, char *argv[]); 86 static int fdt_cmd_pwd(int argc, char *argv[]); 87 static int fdt_cmd_rm(int argc, char *argv[]); 88 static int fdt_cmd_mknode(int argc, char *argv[]); 89 static int fdt_cmd_mres(int argc, char *argv[]); 90 91 typedef int cmdf_t(int, char *[]); 92 93 struct cmdtab { 94 const char *name; 95 cmdf_t *handler; 96 int flags; 97 }; 98 99 static const struct cmdtab commands[] = { 100 { "addr", &fdt_cmd_addr, 0 }, 101 { "alias", &fdt_cmd_nyi, 0 }, 102 { "cd", &fdt_cmd_cd, CMD_REQUIRES_BLOB }, 103 { "header", &fdt_cmd_hdr, CMD_REQUIRES_BLOB }, 104 { "ls", &fdt_cmd_ls, CMD_REQUIRES_BLOB }, 105 { "mknode", &fdt_cmd_mknode, CMD_REQUIRES_BLOB }, 106 { "mkprop", &fdt_cmd_mkprop, CMD_REQUIRES_BLOB }, 107 { "mres", &fdt_cmd_mres, CMD_REQUIRES_BLOB }, 108 { "prop", &fdt_cmd_prop, CMD_REQUIRES_BLOB }, 109 { "pwd", &fdt_cmd_pwd, CMD_REQUIRES_BLOB }, 110 { "rm", &fdt_cmd_rm, CMD_REQUIRES_BLOB }, 111 { NULL, NULL } 112 }; 113 114 static char cwd[FDT_CWD_LEN] = "/"; 115 116 static vm_offset_t 117 fdt_find_static_dtb() 118 { 119 Elf_Ehdr *ehdr; 120 Elf_Shdr *shdr; 121 Elf_Sym sym; 122 vm_offset_t strtab, symtab, fdt_start; 123 uint64_t offs; 124 struct preloaded_file *kfp; 125 struct file_metadata *md; 126 char *strp; 127 int i, sym_count; 128 129 debugf("fdt_find_static_dtb()\n"); 130 131 sym_count = symtab = strtab = 0; 132 strp = NULL; 133 134 offs = __elfN(relocation_offset); 135 136 kfp = file_findfile(NULL, NULL); 137 if (kfp == NULL) 138 return (0); 139 140 /* Locate the dynamic symbols and strtab. */ 141 md = file_findmetadata(kfp, MODINFOMD_ELFHDR); 142 if (md == NULL) 143 return (0); 144 ehdr = (Elf_Ehdr *)md->md_data; 145 146 md = file_findmetadata(kfp, MODINFOMD_SHDR); 147 if (md == NULL) 148 return (0); 149 shdr = (Elf_Shdr *)md->md_data; 150 151 for (i = 0; i < ehdr->e_shnum; ++i) { 152 if (shdr[i].sh_type == SHT_DYNSYM && symtab == 0) { 153 symtab = shdr[i].sh_addr + offs; 154 sym_count = shdr[i].sh_size / sizeof(Elf_Sym); 155 } else if (shdr[i].sh_type == SHT_STRTAB && strtab == 0) { 156 strtab = shdr[i].sh_addr + offs; 157 } 158 } 159 160 /* 161 * The most efficient way to find a symbol would be to calculate a 162 * hash, find proper bucket and chain, and thus find a symbol. 163 * However, that would involve code duplication (e.g. for hash 164 * function). So we're using simpler and a bit slower way: we're 165 * iterating through symbols, searching for the one which name is 166 * 'equal' to 'fdt_static_dtb'. To speed up the process a little bit, 167 * we are eliminating symbols type of which is not STT_NOTYPE, or(and) 168 * those which binding attribute is not STB_GLOBAL. 169 */ 170 fdt_start = 0; 171 while (sym_count > 0 && fdt_start == 0) { 172 COPYOUT(symtab, &sym, sizeof(sym)); 173 symtab += sizeof(sym); 174 --sym_count; 175 if (ELF_ST_BIND(sym.st_info) != STB_GLOBAL || 176 ELF_ST_TYPE(sym.st_info) != STT_NOTYPE) 177 continue; 178 strp = strdupout(strtab + sym.st_name); 179 if (strcmp(strp, FDT_STATIC_DTB_SYMBOL) == 0) 180 fdt_start = (vm_offset_t)sym.st_value + offs; 181 free(strp); 182 } 183 return (fdt_start); 184 } 185 186 static int 187 fdt_load_dtb(vm_offset_t va) 188 { 189 struct fdt_header header; 190 int err; 191 192 debugf("fdt_load_dtb(0x%08jx)\n", (uintmax_t)va); 193 194 COPYOUT(va, &header, sizeof(header)); 195 err = fdt_check_header(&header); 196 if (err < 0) { 197 if (err == -FDT_ERR_BADVERSION) { 198 snprintf(command_errbuf, sizeof(command_errbuf), 199 "incompatible blob version: %d, should be: %d", 200 fdt_version(fdtp), FDT_LAST_SUPPORTED_VERSION); 201 } else { 202 snprintf(command_errbuf, sizeof(command_errbuf), 203 "error validating blob: %s", fdt_strerror(err)); 204 } 205 return (1); 206 } 207 208 /* 209 * Release previous blob 210 */ 211 if (fdtp) 212 free(fdtp); 213 214 fdtp_size = fdt_totalsize(&header); 215 fdtp = malloc(fdtp_size); 216 217 if (fdtp == NULL) { 218 command_errmsg = "can't allocate memory for device tree copy"; 219 return (1); 220 } 221 222 fdtp_va = va; 223 COPYOUT(va, fdtp, fdtp_size); 224 debugf("DTB blob found at 0x%jx, size: 0x%jx\n", (uintmax_t)va, (uintmax_t)fdtp_size); 225 226 return (0); 227 } 228 229 int 230 fdt_load_dtb_addr(struct fdt_header *header) 231 { 232 int err; 233 234 debugf("fdt_load_dtb_addr(%p)\n", header); 235 236 fdtp_size = fdt_totalsize(header); 237 err = fdt_check_header(header); 238 if (err < 0) { 239 snprintf(command_errbuf, sizeof(command_errbuf), 240 "error validating blob: %s", fdt_strerror(err)); 241 return (err); 242 } 243 free(fdtp); 244 if ((fdtp = malloc(fdtp_size)) == NULL) { 245 command_errmsg = "can't allocate memory for device tree copy"; 246 return (1); 247 } 248 249 fdtp_va = 0; // Don't write this back into module or kernel. 250 bcopy(header, fdtp, fdtp_size); 251 return (0); 252 } 253 254 int 255 fdt_load_dtb_file(const char * filename) 256 { 257 struct preloaded_file *bfp, *oldbfp; 258 int err; 259 260 debugf("fdt_load_dtb_file(%s)\n", filename); 261 262 oldbfp = file_findfile(NULL, "dtb"); 263 264 /* Attempt to load and validate a new dtb from a file. */ 265 if ((bfp = file_loadraw(filename, "dtb", 1)) == NULL) { 266 snprintf(command_errbuf, sizeof(command_errbuf), 267 "failed to load file '%s'", filename); 268 return (1); 269 } 270 if ((err = fdt_load_dtb(bfp->f_addr)) != 0) { 271 file_discard(bfp); 272 return (err); 273 } 274 275 /* A new dtb was validated, discard any previous file. */ 276 if (oldbfp) 277 file_discard(oldbfp); 278 return (0); 279 } 280 281 static int 282 fdt_load_dtb_overlay(const char * filename) 283 { 284 struct preloaded_file *bfp, *oldbfp; 285 struct fdt_header header; 286 int err; 287 288 debugf("fdt_load_dtb_overlay(%s)\n", filename); 289 290 oldbfp = file_findfile(filename, "dtbo"); 291 292 /* Attempt to load and validate a new dtb from a file. */ 293 if ((bfp = file_loadraw(filename, "dtbo", 1)) == NULL) { 294 printf("failed to load file '%s'\n", filename); 295 return (1); 296 } 297 298 COPYOUT(bfp->f_addr, &header, sizeof(header)); 299 err = fdt_check_header(&header); 300 301 if (err < 0) { 302 file_discard(bfp); 303 if (err == -FDT_ERR_BADVERSION) 304 printf("incompatible blob version: %d, should be: %d\n", 305 fdt_version(fdtp), FDT_LAST_SUPPORTED_VERSION); 306 307 else 308 printf("error validating blob: %s\n", 309 fdt_strerror(err)); 310 return (1); 311 } 312 313 /* A new dtb was validated, discard any previous file. */ 314 if (oldbfp) 315 file_discard(oldbfp); 316 317 return (0); 318 } 319 320 int 321 fdt_load_dtb_overlays(const char * filenames) 322 { 323 char *names; 324 char *name; 325 char *comaptr; 326 327 debugf("fdt_load_dtb_overlay(%s)\n", filenames); 328 329 names = strdup(filenames); 330 if (names == NULL) 331 return (1); 332 name = names; 333 do { 334 comaptr = strchr(name, ','); 335 if (comaptr) 336 *comaptr = '\0'; 337 fdt_load_dtb_overlay(name); 338 name = comaptr + 1; 339 } while(comaptr); 340 341 free(names); 342 return (0); 343 } 344 345 void 346 fdt_apply_overlays() 347 { 348 struct preloaded_file *fp; 349 size_t overlays_size, max_overlay_size, new_fdtp_size; 350 void *new_fdtp; 351 void *overlay; 352 int rv; 353 354 if ((fdtp == NULL) || (fdtp_size == 0)) 355 return; 356 357 overlays_size = 0; 358 max_overlay_size = 0; 359 for (fp = file_findfile(NULL, "dtbo"); fp != NULL; fp = fp->f_next) { 360 if (max_overlay_size < fp->f_size) 361 max_overlay_size = fp->f_size; 362 overlays_size += fp->f_size; 363 } 364 365 /* Nothing to apply */ 366 if (overlays_size == 0) 367 return; 368 369 /* It's actually more than enough */ 370 new_fdtp_size = fdtp_size + overlays_size; 371 new_fdtp = malloc(new_fdtp_size); 372 if (new_fdtp == NULL) { 373 printf("failed to allocate memory for DTB blob with overlays\n"); 374 return; 375 } 376 377 overlay = malloc(max_overlay_size); 378 if (overlay == NULL) { 379 printf("failed to allocate memory for DTB blob with overlays\n"); 380 free(new_fdtp); 381 return; 382 } 383 384 rv = fdt_open_into(fdtp, new_fdtp, new_fdtp_size); 385 if (rv != 0) { 386 printf("failed to open DTB blob for applying overlays\n"); 387 free(new_fdtp); 388 free(overlay); 389 return; 390 } 391 392 for (fp = file_findfile(NULL, "dtbo"); fp != NULL; fp = fp->f_next) { 393 printf("applying DTB overlay '%s'\n", fp->f_name); 394 COPYOUT(fp->f_addr, overlay, fp->f_size); 395 fdt_overlay_apply(new_fdtp, overlay, fp->f_size); 396 } 397 398 free(fdtp); 399 fdtp = new_fdtp; 400 fdtp_size = new_fdtp_size; 401 402 free(overlay); 403 } 404 405 int 406 fdt_setup_fdtp() 407 { 408 struct preloaded_file *bfp; 409 vm_offset_t va; 410 411 debugf("fdt_setup_fdtp()\n"); 412 413 /* If we already loaded a file, use it. */ 414 if ((bfp = file_findfile(NULL, "dtb")) != NULL) { 415 if (fdt_load_dtb(bfp->f_addr) == 0) { 416 printf("Using DTB from loaded file '%s'.\n", 417 bfp->f_name); 418 return (0); 419 } 420 } 421 422 /* If we were given the address of a valid blob in memory, use it. */ 423 if (fdt_to_load != NULL) { 424 if (fdt_load_dtb_addr(fdt_to_load) == 0) { 425 printf("Using DTB from memory address %p.\n", 426 fdt_to_load); 427 return (0); 428 } 429 } 430 431 if (fdt_platform_load_dtb() == 0) 432 return (0); 433 434 /* If there is a dtb compiled into the kernel, use it. */ 435 if ((va = fdt_find_static_dtb()) != 0) { 436 if (fdt_load_dtb(va) == 0) { 437 printf("Using DTB compiled into kernel.\n"); 438 return (0); 439 } 440 } 441 442 command_errmsg = "No device tree blob found!\n"; 443 return (1); 444 } 445 446 #define fdt_strtovect(str, cellbuf, lim, cellsize) _fdt_strtovect((str), \ 447 (cellbuf), (lim), (cellsize), 0); 448 449 /* Force using base 16 */ 450 #define fdt_strtovectx(str, cellbuf, lim, cellsize) _fdt_strtovect((str), \ 451 (cellbuf), (lim), (cellsize), 16); 452 453 static int 454 _fdt_strtovect(const char *str, void *cellbuf, int lim, unsigned char cellsize, 455 uint8_t base) 456 { 457 const char *buf = str; 458 const char *end = str + strlen(str) - 2; 459 uint32_t *u32buf = NULL; 460 uint8_t *u8buf = NULL; 461 int cnt = 0; 462 463 if (cellsize == sizeof(uint32_t)) 464 u32buf = (uint32_t *)cellbuf; 465 else 466 u8buf = (uint8_t *)cellbuf; 467 468 if (lim == 0) 469 return (0); 470 471 while (buf < end) { 472 473 /* Skip white whitespace(s)/separators */ 474 while (!isxdigit(*buf) && buf < end) 475 buf++; 476 477 if (u32buf != NULL) 478 u32buf[cnt] = 479 cpu_to_fdt32((uint32_t)strtol(buf, NULL, base)); 480 481 else 482 u8buf[cnt] = (uint8_t)strtol(buf, NULL, base); 483 484 if (cnt + 1 <= lim - 1) 485 cnt++; 486 else 487 break; 488 buf++; 489 /* Find another number */ 490 while ((isxdigit(*buf) || *buf == 'x') && buf < end) 491 buf++; 492 } 493 return (cnt); 494 } 495 496 void 497 fdt_fixup_ethernet(const char *str, char *ethstr, int len) 498 { 499 uint8_t tmp_addr[6]; 500 501 /* Convert macaddr string into a vector of uints */ 502 fdt_strtovectx(str, &tmp_addr, 6, sizeof(uint8_t)); 503 /* Set actual property to a value from vect */ 504 fdt_setprop(fdtp, fdt_path_offset(fdtp, ethstr), 505 "local-mac-address", &tmp_addr, 6 * sizeof(uint8_t)); 506 } 507 508 void 509 fdt_fixup_cpubusfreqs(unsigned long cpufreq, unsigned long busfreq) 510 { 511 int lo, o = 0, o2, maxo = 0, depth; 512 const uint32_t zero = 0; 513 514 /* We want to modify every subnode of /cpus */ 515 o = fdt_path_offset(fdtp, "/cpus"); 516 if (o < 0) 517 return; 518 519 /* maxo should contain offset of node next to /cpus */ 520 depth = 0; 521 maxo = o; 522 while (depth != -1) 523 maxo = fdt_next_node(fdtp, maxo, &depth); 524 525 /* Find CPU frequency properties */ 526 o = fdt_node_offset_by_prop_value(fdtp, o, "clock-frequency", 527 &zero, sizeof(uint32_t)); 528 529 o2 = fdt_node_offset_by_prop_value(fdtp, o, "bus-frequency", &zero, 530 sizeof(uint32_t)); 531 532 lo = MIN(o, o2); 533 534 while (o != -FDT_ERR_NOTFOUND && o2 != -FDT_ERR_NOTFOUND) { 535 536 o = fdt_node_offset_by_prop_value(fdtp, lo, 537 "clock-frequency", &zero, sizeof(uint32_t)); 538 539 o2 = fdt_node_offset_by_prop_value(fdtp, lo, "bus-frequency", 540 &zero, sizeof(uint32_t)); 541 542 /* We're only interested in /cpus subnode(s) */ 543 if (lo > maxo) 544 break; 545 546 fdt_setprop_inplace_cell(fdtp, lo, "clock-frequency", 547 (uint32_t)cpufreq); 548 549 fdt_setprop_inplace_cell(fdtp, lo, "bus-frequency", 550 (uint32_t)busfreq); 551 552 lo = MIN(o, o2); 553 } 554 } 555 556 #ifdef notyet 557 static int 558 fdt_reg_valid(uint32_t *reg, int len, int addr_cells, int size_cells) 559 { 560 int cells_in_tuple, i, tuples, tuple_size; 561 uint32_t cur_start, cur_size; 562 563 cells_in_tuple = (addr_cells + size_cells); 564 tuple_size = cells_in_tuple * sizeof(uint32_t); 565 tuples = len / tuple_size; 566 if (tuples == 0) 567 return (EINVAL); 568 569 for (i = 0; i < tuples; i++) { 570 if (addr_cells == 2) 571 cur_start = fdt64_to_cpu(reg[i * cells_in_tuple]); 572 else 573 cur_start = fdt32_to_cpu(reg[i * cells_in_tuple]); 574 575 if (size_cells == 2) 576 cur_size = fdt64_to_cpu(reg[i * cells_in_tuple + 2]); 577 else 578 cur_size = fdt32_to_cpu(reg[i * cells_in_tuple + 1]); 579 580 if (cur_size == 0) 581 return (EINVAL); 582 583 debugf(" reg#%d (start: 0x%0x size: 0x%0x) valid!\n", 584 i, cur_start, cur_size); 585 } 586 return (0); 587 } 588 #endif 589 590 void 591 fdt_fixup_memory(struct fdt_mem_region *region, size_t num) 592 { 593 struct fdt_mem_region *curmr; 594 uint32_t addr_cells, size_cells; 595 uint32_t *addr_cellsp, *size_cellsp; 596 int err, i, len, memory, root; 597 size_t realmrno; 598 uint8_t *buf, *sb; 599 uint64_t rstart, rsize; 600 int reserved; 601 602 root = fdt_path_offset(fdtp, "/"); 603 if (root < 0) { 604 sprintf(command_errbuf, "Could not find root node !"); 605 return; 606 } 607 608 memory = fdt_path_offset(fdtp, "/memory"); 609 if (memory <= 0) { 610 /* Create proper '/memory' node. */ 611 memory = fdt_add_subnode(fdtp, root, "memory"); 612 if (memory <= 0) { 613 snprintf(command_errbuf, sizeof(command_errbuf), 614 "Could not fixup '/memory' " 615 "node, error code : %d!\n", memory); 616 return; 617 } 618 619 err = fdt_setprop(fdtp, memory, "device_type", "memory", 620 sizeof("memory")); 621 622 if (err < 0) 623 return; 624 } 625 626 addr_cellsp = (uint32_t *)fdt_getprop(fdtp, root, "#address-cells", 627 NULL); 628 size_cellsp = (uint32_t *)fdt_getprop(fdtp, root, "#size-cells", NULL); 629 630 if (addr_cellsp == NULL || size_cellsp == NULL) { 631 snprintf(command_errbuf, sizeof(command_errbuf), 632 "Could not fixup '/memory' node : " 633 "%s %s property not found in root node!\n", 634 (!addr_cellsp) ? "#address-cells" : "", 635 (!size_cellsp) ? "#size-cells" : ""); 636 return; 637 } 638 639 addr_cells = fdt32_to_cpu(*addr_cellsp); 640 size_cells = fdt32_to_cpu(*size_cellsp); 641 642 /* 643 * Convert memreserve data to memreserve property 644 * Check if property already exists 645 */ 646 reserved = fdt_num_mem_rsv(fdtp); 647 if (reserved && 648 (fdt_getprop(fdtp, root, "memreserve", NULL) == NULL)) { 649 len = (addr_cells + size_cells) * reserved * sizeof(uint32_t); 650 sb = buf = (uint8_t *)malloc(len); 651 if (!buf) 652 return; 653 654 bzero(buf, len); 655 656 for (i = 0; i < reserved; i++) { 657 if (fdt_get_mem_rsv(fdtp, i, &rstart, &rsize)) 658 break; 659 if (rsize) { 660 /* Ensure endianness, and put cells into a buffer */ 661 if (addr_cells == 2) 662 *(uint64_t *)buf = 663 cpu_to_fdt64(rstart); 664 else 665 *(uint32_t *)buf = 666 cpu_to_fdt32(rstart); 667 668 buf += sizeof(uint32_t) * addr_cells; 669 if (size_cells == 2) 670 *(uint64_t *)buf = 671 cpu_to_fdt64(rsize); 672 else 673 *(uint32_t *)buf = 674 cpu_to_fdt32(rsize); 675 676 buf += sizeof(uint32_t) * size_cells; 677 } 678 } 679 680 /* Set property */ 681 if ((err = fdt_setprop(fdtp, root, "memreserve", sb, len)) < 0) 682 printf("Could not fixup 'memreserve' property.\n"); 683 684 free(sb); 685 } 686 687 /* Count valid memory regions entries in sysinfo. */ 688 realmrno = num; 689 for (i = 0; i < num; i++) 690 if (region[i].start == 0 && region[i].size == 0) 691 realmrno--; 692 693 if (realmrno == 0) { 694 sprintf(command_errbuf, "Could not fixup '/memory' node : " 695 "sysinfo doesn't contain valid memory regions info!\n"); 696 return; 697 } 698 699 len = (addr_cells + size_cells) * realmrno * sizeof(uint32_t); 700 sb = buf = (uint8_t *)malloc(len); 701 if (!buf) 702 return; 703 704 bzero(buf, len); 705 706 for (i = 0; i < num; i++) { 707 curmr = ®ion[i]; 708 if (curmr->size != 0) { 709 /* Ensure endianness, and put cells into a buffer */ 710 if (addr_cells == 2) 711 *(uint64_t *)buf = 712 cpu_to_fdt64(curmr->start); 713 else 714 *(uint32_t *)buf = 715 cpu_to_fdt32(curmr->start); 716 717 buf += sizeof(uint32_t) * addr_cells; 718 if (size_cells == 2) 719 *(uint64_t *)buf = 720 cpu_to_fdt64(curmr->size); 721 else 722 *(uint32_t *)buf = 723 cpu_to_fdt32(curmr->size); 724 725 buf += sizeof(uint32_t) * size_cells; 726 } 727 } 728 729 /* Set property */ 730 if ((err = fdt_setprop(fdtp, memory, "reg", sb, len)) < 0) 731 sprintf(command_errbuf, "Could not fixup '/memory' node.\n"); 732 733 free(sb); 734 } 735 736 void 737 fdt_fixup_stdout(const char *str) 738 { 739 char *ptr; 740 int serialno; 741 int len, no, sero; 742 const struct fdt_property *prop; 743 char *tmp[10]; 744 745 ptr = (char *)str + strlen(str) - 1; 746 while (ptr > str && isdigit(*(str - 1))) 747 str--; 748 749 if (ptr == str) 750 return; 751 752 serialno = (int)strtol(ptr, NULL, 0); 753 no = fdt_path_offset(fdtp, "/chosen"); 754 if (no < 0) 755 return; 756 757 prop = fdt_get_property(fdtp, no, "stdout", &len); 758 759 /* If /chosen/stdout does not extist, create it */ 760 if (prop == NULL || (prop != NULL && len == 0)) { 761 762 bzero(tmp, 10 * sizeof(char)); 763 strcpy((char *)&tmp, "serial"); 764 if (strlen(ptr) > 3) 765 /* Serial number too long */ 766 return; 767 768 strncpy((char *)tmp + 6, ptr, 3); 769 sero = fdt_path_offset(fdtp, (const char *)tmp); 770 if (sero < 0) 771 /* 772 * If serial device we're trying to assign 773 * stdout to doesn't exist in DT -- return. 774 */ 775 return; 776 777 fdt_setprop(fdtp, no, "stdout", &tmp, 778 strlen((char *)&tmp) + 1); 779 fdt_setprop(fdtp, no, "stdin", &tmp, 780 strlen((char *)&tmp) + 1); 781 } 782 } 783 784 /* 785 * Locate the blob, fix it up and return its location. 786 */ 787 static int 788 fdt_fixup(void) 789 { 790 int chosen, len; 791 792 len = 0; 793 794 debugf("fdt_fixup()\n"); 795 796 if (fdtp == NULL && fdt_setup_fdtp() != 0) 797 return (0); 798 799 /* Create /chosen node (if not exists) */ 800 if ((chosen = fdt_subnode_offset(fdtp, 0, "chosen")) == 801 -FDT_ERR_NOTFOUND) 802 chosen = fdt_add_subnode(fdtp, 0, "chosen"); 803 804 /* Value assigned to fixup-applied does not matter. */ 805 if (fdt_getprop(fdtp, chosen, "fixup-applied", NULL)) 806 return (1); 807 808 fdt_platform_fixups(); 809 810 fdt_setprop(fdtp, chosen, "fixup-applied", NULL, 0); 811 return (1); 812 } 813 814 /* 815 * Copy DTB blob to specified location and return size 816 */ 817 int 818 fdt_copy(vm_offset_t va) 819 { 820 int err; 821 debugf("fdt_copy va 0x%08x\n", va); 822 if (fdtp == NULL) { 823 err = fdt_setup_fdtp(); 824 if (err) { 825 printf("No valid device tree blob found!\n"); 826 return (0); 827 } 828 } 829 830 if (fdt_fixup() == 0) 831 return (0); 832 833 if (fdtp_va != 0) { 834 /* Overwrite the FDT with the fixed version. */ 835 /* XXX Is this really appropriate? */ 836 COPYIN(fdtp, fdtp_va, fdtp_size); 837 } 838 COPYIN(fdtp, va, fdtp_size); 839 return (fdtp_size); 840 } 841 842 843 844 int 845 command_fdt_internal(int argc, char *argv[]) 846 { 847 cmdf_t *cmdh; 848 int flags; 849 char *cmd; 850 int i, err; 851 852 if (argc < 2) { 853 command_errmsg = "usage is 'fdt <command> [<args>]"; 854 return (CMD_ERROR); 855 } 856 857 /* 858 * Validate fdt <command>. 859 */ 860 cmd = strdup(argv[1]); 861 i = 0; 862 cmdh = NULL; 863 while (!(commands[i].name == NULL)) { 864 if (strcmp(cmd, commands[i].name) == 0) { 865 /* found it */ 866 cmdh = commands[i].handler; 867 flags = commands[i].flags; 868 break; 869 } 870 i++; 871 } 872 if (cmdh == NULL) { 873 command_errmsg = "unknown command"; 874 return (CMD_ERROR); 875 } 876 877 if (flags & CMD_REQUIRES_BLOB) { 878 /* 879 * Check if uboot env vars were parsed already. If not, do it now. 880 */ 881 if (fdt_fixup() == 0) 882 return (CMD_ERROR); 883 } 884 885 /* 886 * Call command handler. 887 */ 888 err = (*cmdh)(argc, argv); 889 890 return (err); 891 } 892 893 static int 894 fdt_cmd_addr(int argc, char *argv[]) 895 { 896 struct preloaded_file *fp; 897 struct fdt_header *hdr; 898 const char *addr; 899 char *cp; 900 901 fdt_to_load = NULL; 902 903 if (argc > 2) 904 addr = argv[2]; 905 else { 906 sprintf(command_errbuf, "no address specified"); 907 return (CMD_ERROR); 908 } 909 910 hdr = (struct fdt_header *)strtoul(addr, &cp, 16); 911 if (cp == addr) { 912 snprintf(command_errbuf, sizeof(command_errbuf), 913 "Invalid address: %s", addr); 914 return (CMD_ERROR); 915 } 916 917 while ((fp = file_findfile(NULL, "dtb")) != NULL) { 918 file_discard(fp); 919 } 920 921 fdt_to_load = hdr; 922 return (CMD_OK); 923 } 924 925 static int 926 fdt_cmd_cd(int argc, char *argv[]) 927 { 928 char *path; 929 char tmp[FDT_CWD_LEN]; 930 int len, o; 931 932 path = (argc > 2) ? argv[2] : "/"; 933 934 if (path[0] == '/') { 935 len = strlen(path); 936 if (len >= FDT_CWD_LEN) 937 goto fail; 938 } else { 939 /* Handle path specification relative to cwd */ 940 len = strlen(cwd) + strlen(path) + 1; 941 if (len >= FDT_CWD_LEN) 942 goto fail; 943 944 strcpy(tmp, cwd); 945 strcat(tmp, "/"); 946 strcat(tmp, path); 947 path = tmp; 948 } 949 950 o = fdt_path_offset(fdtp, path); 951 if (o < 0) { 952 snprintf(command_errbuf, sizeof(command_errbuf), 953 "could not find node: '%s'", path); 954 return (CMD_ERROR); 955 } 956 957 strcpy(cwd, path); 958 return (CMD_OK); 959 960 fail: 961 snprintf(command_errbuf, sizeof(command_errbuf), 962 "path too long: %d, max allowed: %d", len, FDT_CWD_LEN - 1); 963 return (CMD_ERROR); 964 } 965 966 static int 967 fdt_cmd_hdr(int argc __unused, char *argv[] __unused) 968 { 969 char line[80]; 970 int ver; 971 972 if (fdtp == NULL) { 973 command_errmsg = "no device tree blob pointer?!"; 974 return (CMD_ERROR); 975 } 976 977 ver = fdt_version(fdtp); 978 pager_open(); 979 sprintf(line, "\nFlattened device tree header (%p):\n", fdtp); 980 if (pager_output(line)) 981 goto out; 982 sprintf(line, " magic = 0x%08x\n", fdt_magic(fdtp)); 983 if (pager_output(line)) 984 goto out; 985 sprintf(line, " size = %d\n", fdt_totalsize(fdtp)); 986 if (pager_output(line)) 987 goto out; 988 sprintf(line, " off_dt_struct = 0x%08x\n", 989 fdt_off_dt_struct(fdtp)); 990 if (pager_output(line)) 991 goto out; 992 sprintf(line, " off_dt_strings = 0x%08x\n", 993 fdt_off_dt_strings(fdtp)); 994 if (pager_output(line)) 995 goto out; 996 sprintf(line, " off_mem_rsvmap = 0x%08x\n", 997 fdt_off_mem_rsvmap(fdtp)); 998 if (pager_output(line)) 999 goto out; 1000 sprintf(line, " version = %d\n", ver); 1001 if (pager_output(line)) 1002 goto out; 1003 sprintf(line, " last compatible version = %d\n", 1004 fdt_last_comp_version(fdtp)); 1005 if (pager_output(line)) 1006 goto out; 1007 if (ver >= 2) { 1008 sprintf(line, " boot_cpuid = %d\n", 1009 fdt_boot_cpuid_phys(fdtp)); 1010 if (pager_output(line)) 1011 goto out; 1012 } 1013 if (ver >= 3) { 1014 sprintf(line, " size_dt_strings = %d\n", 1015 fdt_size_dt_strings(fdtp)); 1016 if (pager_output(line)) 1017 goto out; 1018 } 1019 if (ver >= 17) { 1020 sprintf(line, " size_dt_struct = %d\n", 1021 fdt_size_dt_struct(fdtp)); 1022 if (pager_output(line)) 1023 goto out; 1024 } 1025 out: 1026 pager_close(); 1027 1028 return (CMD_OK); 1029 } 1030 1031 static int 1032 fdt_cmd_ls(int argc, char *argv[]) 1033 { 1034 const char *prevname[FDT_MAX_DEPTH] = { NULL }; 1035 const char *name; 1036 char *path; 1037 int i, o, depth; 1038 1039 path = (argc > 2) ? argv[2] : NULL; 1040 if (path == NULL) 1041 path = cwd; 1042 1043 o = fdt_path_offset(fdtp, path); 1044 if (o < 0) { 1045 snprintf(command_errbuf, sizeof(command_errbuf), 1046 "could not find node: '%s'", path); 1047 return (CMD_ERROR); 1048 } 1049 1050 for (depth = 0; 1051 (o >= 0) && (depth >= 0); 1052 o = fdt_next_node(fdtp, o, &depth)) { 1053 1054 name = fdt_get_name(fdtp, o, NULL); 1055 1056 if (depth > FDT_MAX_DEPTH) { 1057 printf("max depth exceeded: %d\n", depth); 1058 continue; 1059 } 1060 1061 prevname[depth] = name; 1062 1063 /* Skip root (i = 1) when printing devices */ 1064 for (i = 1; i <= depth; i++) { 1065 if (prevname[i] == NULL) 1066 break; 1067 1068 if (strcmp(cwd, "/") == 0) 1069 printf("/"); 1070 printf("%s", prevname[i]); 1071 } 1072 printf("\n"); 1073 } 1074 1075 return (CMD_OK); 1076 } 1077 1078 static __inline int 1079 isprint(int c) 1080 { 1081 1082 return (c >= ' ' && c <= 0x7e); 1083 } 1084 1085 static int 1086 fdt_isprint(const void *data, int len, int *count) 1087 { 1088 const char *d; 1089 char ch; 1090 int yesno, i; 1091 1092 if (len == 0) 1093 return (0); 1094 1095 d = (const char *)data; 1096 if (d[len - 1] != '\0') 1097 return (0); 1098 1099 *count = 0; 1100 yesno = 1; 1101 for (i = 0; i < len; i++) { 1102 ch = *(d + i); 1103 if (isprint(ch) || (ch == '\0' && i > 0)) { 1104 /* Count strings */ 1105 if (ch == '\0') 1106 (*count)++; 1107 continue; 1108 } 1109 1110 yesno = 0; 1111 break; 1112 } 1113 1114 return (yesno); 1115 } 1116 1117 static int 1118 fdt_data_str(const void *data, int len, int count, char **buf) 1119 { 1120 char *b, *tmp; 1121 const char *d; 1122 int buf_len, i, l; 1123 1124 /* 1125 * Calculate the length for the string and allocate memory. 1126 * 1127 * Note that 'len' already includes at least one terminator. 1128 */ 1129 buf_len = len; 1130 if (count > 1) { 1131 /* 1132 * Each token had already a terminator buried in 'len', but we 1133 * only need one eventually, don't count space for these. 1134 */ 1135 buf_len -= count - 1; 1136 1137 /* Each consecutive token requires a ", " separator. */ 1138 buf_len += count * 2; 1139 } 1140 1141 /* Add some space for surrounding double quotes. */ 1142 buf_len += count * 2; 1143 1144 /* Note that string being put in 'tmp' may be as big as 'buf_len'. */ 1145 b = (char *)malloc(buf_len); 1146 tmp = (char *)malloc(buf_len); 1147 if (b == NULL) 1148 goto error; 1149 1150 if (tmp == NULL) { 1151 free(b); 1152 goto error; 1153 } 1154 1155 b[0] = '\0'; 1156 1157 /* 1158 * Now that we have space, format the string. 1159 */ 1160 i = 0; 1161 do { 1162 d = (const char *)data + i; 1163 l = strlen(d) + 1; 1164 1165 sprintf(tmp, "\"%s\"%s", d, 1166 (i + l) < len ? ", " : ""); 1167 strcat(b, tmp); 1168 1169 i += l; 1170 1171 } while (i < len); 1172 *buf = b; 1173 1174 free(tmp); 1175 1176 return (0); 1177 error: 1178 return (1); 1179 } 1180 1181 static int 1182 fdt_data_cell(const void *data, int len, char **buf) 1183 { 1184 char *b, *tmp; 1185 const uint32_t *c; 1186 int count, i, l; 1187 1188 /* Number of cells */ 1189 count = len / 4; 1190 1191 /* 1192 * Calculate the length for the string and allocate memory. 1193 */ 1194 1195 /* Each byte translates to 2 output characters */ 1196 l = len * 2; 1197 if (count > 1) { 1198 /* Each consecutive cell requires a " " separator. */ 1199 l += (count - 1) * 1; 1200 } 1201 /* Each cell will have a "0x" prefix */ 1202 l += count * 2; 1203 /* Space for surrounding <> and terminator */ 1204 l += 3; 1205 1206 b = (char *)malloc(l); 1207 tmp = (char *)malloc(l); 1208 if (b == NULL) 1209 goto error; 1210 1211 if (tmp == NULL) { 1212 free(b); 1213 goto error; 1214 } 1215 1216 b[0] = '\0'; 1217 strcat(b, "<"); 1218 1219 for (i = 0; i < len; i += 4) { 1220 c = (const uint32_t *)((const uint8_t *)data + i); 1221 sprintf(tmp, "0x%08x%s", fdt32_to_cpu(*c), 1222 i < (len - 4) ? " " : ""); 1223 strcat(b, tmp); 1224 } 1225 strcat(b, ">"); 1226 *buf = b; 1227 1228 free(tmp); 1229 1230 return (0); 1231 error: 1232 return (1); 1233 } 1234 1235 static int 1236 fdt_data_bytes(const void *data, int len, char **buf) 1237 { 1238 char *b, *tmp; 1239 const char *d; 1240 int i, l; 1241 1242 /* 1243 * Calculate the length for the string and allocate memory. 1244 */ 1245 1246 /* Each byte translates to 2 output characters */ 1247 l = len * 2; 1248 if (len > 1) 1249 /* Each consecutive byte requires a " " separator. */ 1250 l += (len - 1) * 1; 1251 /* Each byte will have a "0x" prefix */ 1252 l += len * 2; 1253 /* Space for surrounding [] and terminator. */ 1254 l += 3; 1255 1256 b = (char *)malloc(l); 1257 tmp = (char *)malloc(l); 1258 if (b == NULL) 1259 goto error; 1260 1261 if (tmp == NULL) { 1262 free(b); 1263 goto error; 1264 } 1265 1266 b[0] = '\0'; 1267 strcat(b, "["); 1268 1269 for (i = 0, d = data; i < len; i++) { 1270 sprintf(tmp, "0x%02x%s", d[i], i < len - 1 ? " " : ""); 1271 strcat(b, tmp); 1272 } 1273 strcat(b, "]"); 1274 *buf = b; 1275 1276 free(tmp); 1277 1278 return (0); 1279 error: 1280 return (1); 1281 } 1282 1283 static int 1284 fdt_data_fmt(const void *data, int len, char **buf) 1285 { 1286 int count; 1287 1288 if (len == 0) { 1289 *buf = NULL; 1290 return (1); 1291 } 1292 1293 if (fdt_isprint(data, len, &count)) 1294 return (fdt_data_str(data, len, count, buf)); 1295 1296 else if ((len % 4) == 0) 1297 return (fdt_data_cell(data, len, buf)); 1298 1299 else 1300 return (fdt_data_bytes(data, len, buf)); 1301 } 1302 1303 static int 1304 fdt_prop(int offset) 1305 { 1306 char *line, *buf; 1307 const struct fdt_property *prop; 1308 const char *name; 1309 const void *data; 1310 int len, rv; 1311 1312 line = NULL; 1313 prop = fdt_offset_ptr(fdtp, offset, sizeof(*prop)); 1314 if (prop == NULL) 1315 return (1); 1316 1317 name = fdt_string(fdtp, fdt32_to_cpu(prop->nameoff)); 1318 len = fdt32_to_cpu(prop->len); 1319 1320 rv = 0; 1321 buf = NULL; 1322 if (len == 0) { 1323 /* Property without value */ 1324 line = (char *)malloc(strlen(name) + 2); 1325 if (line == NULL) { 1326 rv = 2; 1327 goto out2; 1328 } 1329 sprintf(line, "%s\n", name); 1330 goto out1; 1331 } 1332 1333 /* 1334 * Process property with value 1335 */ 1336 data = prop->data; 1337 1338 if (fdt_data_fmt(data, len, &buf) != 0) { 1339 rv = 3; 1340 goto out2; 1341 } 1342 1343 line = (char *)malloc(strlen(name) + strlen(FDT_PROP_SEP) + 1344 strlen(buf) + 2); 1345 if (line == NULL) { 1346 sprintf(command_errbuf, "could not allocate space for string"); 1347 rv = 4; 1348 goto out2; 1349 } 1350 1351 sprintf(line, "%s" FDT_PROP_SEP "%s\n", name, buf); 1352 1353 out1: 1354 pager_open(); 1355 pager_output(line); 1356 pager_close(); 1357 1358 out2: 1359 if (buf) 1360 free(buf); 1361 1362 if (line) 1363 free(line); 1364 1365 return (rv); 1366 } 1367 1368 static int 1369 fdt_modprop(int nodeoff, char *propname, void *value, char mode) 1370 { 1371 uint32_t cells[100]; 1372 const char *buf; 1373 int len, rv; 1374 const struct fdt_property *p; 1375 1376 p = fdt_get_property(fdtp, nodeoff, propname, NULL); 1377 1378 if (p != NULL) { 1379 if (mode == 1) { 1380 /* Adding inexistant value in mode 1 is forbidden */ 1381 sprintf(command_errbuf, "property already exists!"); 1382 return (CMD_ERROR); 1383 } 1384 } else if (mode == 0) { 1385 sprintf(command_errbuf, "property does not exist!"); 1386 return (CMD_ERROR); 1387 } 1388 len = strlen(value); 1389 rv = 0; 1390 buf = value; 1391 1392 switch (*buf) { 1393 case '&': 1394 /* phandles */ 1395 break; 1396 case '<': 1397 /* Data cells */ 1398 len = fdt_strtovect(buf, (void *)&cells, 100, 1399 sizeof(uint32_t)); 1400 1401 rv = fdt_setprop(fdtp, nodeoff, propname, &cells, 1402 len * sizeof(uint32_t)); 1403 break; 1404 case '[': 1405 /* Data bytes */ 1406 len = fdt_strtovect(buf, (void *)&cells, 100, 1407 sizeof(uint8_t)); 1408 1409 rv = fdt_setprop(fdtp, nodeoff, propname, &cells, 1410 len * sizeof(uint8_t)); 1411 break; 1412 case '"': 1413 default: 1414 /* Default -- string */ 1415 rv = fdt_setprop_string(fdtp, nodeoff, propname, value); 1416 break; 1417 } 1418 1419 if (rv != 0) { 1420 if (rv == -FDT_ERR_NOSPACE) 1421 sprintf(command_errbuf, 1422 "Device tree blob is too small!\n"); 1423 else 1424 sprintf(command_errbuf, 1425 "Could not add/modify property!\n"); 1426 } 1427 return (rv); 1428 } 1429 1430 /* Merge strings from argv into a single string */ 1431 static int 1432 fdt_merge_strings(int argc, char *argv[], int start, char **buffer) 1433 { 1434 char *buf; 1435 int i, idx, sz; 1436 1437 *buffer = NULL; 1438 sz = 0; 1439 1440 for (i = start; i < argc; i++) 1441 sz += strlen(argv[i]); 1442 1443 /* Additional bytes for whitespaces between args */ 1444 sz += argc - start; 1445 1446 buf = (char *)malloc(sizeof(char) * sz); 1447 if (buf == NULL) { 1448 sprintf(command_errbuf, "could not allocate space " 1449 "for string"); 1450 return (1); 1451 } 1452 bzero(buf, sizeof(char) * sz); 1453 1454 idx = 0; 1455 for (i = start, idx = 0; i < argc; i++) { 1456 strcpy(buf + idx, argv[i]); 1457 idx += strlen(argv[i]); 1458 buf[idx] = ' '; 1459 idx++; 1460 } 1461 buf[sz - 1] = '\0'; 1462 *buffer = buf; 1463 return (0); 1464 } 1465 1466 /* Extract offset and name of node/property from a given path */ 1467 static int 1468 fdt_extract_nameloc(char **pathp, char **namep, int *nodeoff) 1469 { 1470 int o; 1471 char *path = *pathp, *name = NULL, *subpath = NULL; 1472 1473 subpath = strrchr(path, '/'); 1474 if (subpath == NULL) { 1475 o = fdt_path_offset(fdtp, cwd); 1476 name = path; 1477 path = (char *)&cwd; 1478 } else { 1479 *subpath = '\0'; 1480 if (strlen(path) == 0) 1481 path = cwd; 1482 1483 name = subpath + 1; 1484 o = fdt_path_offset(fdtp, path); 1485 } 1486 1487 if (strlen(name) == 0) { 1488 sprintf(command_errbuf, "name not specified"); 1489 return (1); 1490 } 1491 if (o < 0) { 1492 snprintf(command_errbuf, sizeof(command_errbuf), 1493 "could not find node: '%s'", path); 1494 return (1); 1495 } 1496 *namep = name; 1497 *nodeoff = o; 1498 *pathp = path; 1499 return (0); 1500 } 1501 1502 static int 1503 fdt_cmd_prop(int argc, char *argv[]) 1504 { 1505 char *path, *propname, *value; 1506 int o, next, depth, rv; 1507 uint32_t tag; 1508 1509 path = (argc > 2) ? argv[2] : NULL; 1510 1511 value = NULL; 1512 1513 if (argc > 3) { 1514 /* Merge property value strings into one */ 1515 if (fdt_merge_strings(argc, argv, 3, &value) != 0) 1516 return (CMD_ERROR); 1517 } else 1518 value = NULL; 1519 1520 if (path == NULL) 1521 path = cwd; 1522 1523 rv = CMD_OK; 1524 1525 if (value) { 1526 /* If value is specified -- try to modify prop. */ 1527 if (fdt_extract_nameloc(&path, &propname, &o) != 0) 1528 return (CMD_ERROR); 1529 1530 rv = fdt_modprop(o, propname, value, 0); 1531 if (rv) 1532 return (CMD_ERROR); 1533 return (CMD_OK); 1534 1535 } 1536 /* User wants to display properties */ 1537 o = fdt_path_offset(fdtp, path); 1538 1539 if (o < 0) { 1540 snprintf(command_errbuf, sizeof(command_errbuf), 1541 "could not find node: '%s'", path); 1542 rv = CMD_ERROR; 1543 goto out; 1544 } 1545 1546 depth = 0; 1547 while (depth >= 0) { 1548 tag = fdt_next_tag(fdtp, o, &next); 1549 switch (tag) { 1550 case FDT_NOP: 1551 break; 1552 case FDT_PROP: 1553 if (depth > 1) 1554 /* Don't process properties of nested nodes */ 1555 break; 1556 1557 if (fdt_prop(o) != 0) { 1558 sprintf(command_errbuf, "could not process " 1559 "property"); 1560 rv = CMD_ERROR; 1561 goto out; 1562 } 1563 break; 1564 case FDT_BEGIN_NODE: 1565 depth++; 1566 if (depth > FDT_MAX_DEPTH) { 1567 printf("warning: nesting too deep: %d\n", 1568 depth); 1569 goto out; 1570 } 1571 break; 1572 case FDT_END_NODE: 1573 depth--; 1574 if (depth == 0) 1575 /* 1576 * This is the end of our starting node, force 1577 * the loop finish. 1578 */ 1579 depth--; 1580 break; 1581 } 1582 o = next; 1583 } 1584 out: 1585 return (rv); 1586 } 1587 1588 static int 1589 fdt_cmd_mkprop(int argc, char *argv[]) 1590 { 1591 int o; 1592 char *path, *propname, *value; 1593 1594 path = (argc > 2) ? argv[2] : NULL; 1595 1596 value = NULL; 1597 1598 if (argc > 3) { 1599 /* Merge property value strings into one */ 1600 if (fdt_merge_strings(argc, argv, 3, &value) != 0) 1601 return (CMD_ERROR); 1602 } else 1603 value = NULL; 1604 1605 if (fdt_extract_nameloc(&path, &propname, &o) != 0) 1606 return (CMD_ERROR); 1607 1608 if (fdt_modprop(o, propname, value, 1)) 1609 return (CMD_ERROR); 1610 1611 return (CMD_OK); 1612 } 1613 1614 static int 1615 fdt_cmd_rm(int argc, char *argv[]) 1616 { 1617 int o, rv; 1618 char *path = NULL, *propname; 1619 1620 if (argc > 2) 1621 path = argv[2]; 1622 else { 1623 sprintf(command_errbuf, "no node/property name specified"); 1624 return (CMD_ERROR); 1625 } 1626 1627 o = fdt_path_offset(fdtp, path); 1628 if (o < 0) { 1629 /* If node not found -- try to find & delete property */ 1630 if (fdt_extract_nameloc(&path, &propname, &o) != 0) 1631 return (CMD_ERROR); 1632 1633 if ((rv = fdt_delprop(fdtp, o, propname)) != 0) { 1634 snprintf(command_errbuf, sizeof(command_errbuf), 1635 "could not delete %s\n", 1636 (rv == -FDT_ERR_NOTFOUND) ? 1637 "(property/node does not exist)" : ""); 1638 return (CMD_ERROR); 1639 1640 } else 1641 return (CMD_OK); 1642 } 1643 /* If node exists -- remove node */ 1644 rv = fdt_del_node(fdtp, o); 1645 if (rv) { 1646 sprintf(command_errbuf, "could not delete node"); 1647 return (CMD_ERROR); 1648 } 1649 return (CMD_OK); 1650 } 1651 1652 static int 1653 fdt_cmd_mknode(int argc, char *argv[]) 1654 { 1655 int o, rv; 1656 char *path = NULL, *nodename = NULL; 1657 1658 if (argc > 2) 1659 path = argv[2]; 1660 else { 1661 sprintf(command_errbuf, "no node name specified"); 1662 return (CMD_ERROR); 1663 } 1664 1665 if (fdt_extract_nameloc(&path, &nodename, &o) != 0) 1666 return (CMD_ERROR); 1667 1668 rv = fdt_add_subnode(fdtp, o, nodename); 1669 1670 if (rv < 0) { 1671 if (rv == -FDT_ERR_NOSPACE) 1672 sprintf(command_errbuf, 1673 "Device tree blob is too small!\n"); 1674 else 1675 sprintf(command_errbuf, 1676 "Could not add node!\n"); 1677 return (CMD_ERROR); 1678 } 1679 return (CMD_OK); 1680 } 1681 1682 static int 1683 fdt_cmd_pwd(int argc, char *argv[]) 1684 { 1685 char line[FDT_CWD_LEN]; 1686 1687 pager_open(); 1688 sprintf(line, "%s\n", cwd); 1689 pager_output(line); 1690 pager_close(); 1691 return (CMD_OK); 1692 } 1693 1694 static int 1695 fdt_cmd_mres(int argc, char *argv[]) 1696 { 1697 uint64_t start, size; 1698 int i, total; 1699 char line[80]; 1700 1701 pager_open(); 1702 total = fdt_num_mem_rsv(fdtp); 1703 if (total > 0) { 1704 if (pager_output("Reserved memory regions:\n")) 1705 goto out; 1706 for (i = 0; i < total; i++) { 1707 fdt_get_mem_rsv(fdtp, i, &start, &size); 1708 sprintf(line, "reg#%d: (start: 0x%jx, size: 0x%jx)\n", 1709 i, start, size); 1710 if (pager_output(line)) 1711 goto out; 1712 } 1713 } else 1714 pager_output("No reserved memory regions\n"); 1715 out: 1716 pager_close(); 1717 1718 return (CMD_OK); 1719 } 1720 1721 static int 1722 fdt_cmd_nyi(int argc, char *argv[]) 1723 { 1724 1725 printf("command not yet implemented\n"); 1726 return (CMD_ERROR); 1727 } 1728