1 /* 2 * (C) Copyright 2017 Rockchip Electronics Co., Ltd. 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <common.h> 8 #include <version.h> 9 #include <abuf.h> 10 #include <amp.h> 11 #include <android_ab.h> 12 #include <android_bootloader.h> 13 #include <android_image.h> 14 #include <bidram.h> 15 #include <boot_rkimg.h> 16 #include <cli.h> 17 #include <clk.h> 18 #include <console.h> 19 #include <debug_uart.h> 20 #include <dm.h> 21 #include <dvfs.h> 22 #include <fdt_support.h> 23 #include <io-domain.h> 24 #include <image.h> 25 #include <key.h> 26 #include <memblk.h> 27 #include <misc.h> 28 #include <of_live.h> 29 #include <mtd_blk.h> 30 #include <ram.h> 31 #include <rng.h> 32 #include <rockchip_debugger.h> 33 #include <syscon.h> 34 #include <sysmem.h> 35 #include <video_rockchip.h> 36 #include <xbc.h> 37 #include <asm/io.h> 38 #include <asm/gpio.h> 39 #include <android_avb/rk_avb_ops_user.h> 40 #include <dm/uclass-internal.h> 41 #include <dm/root.h> 42 #include <power/charge_display.h> 43 #include <power/regulator.h> 44 #include <optee_include/OpteeClientInterface.h> 45 #include <optee_include/OpteeClientApiLib.h> 46 #include <optee_include/tee_api_defines.h> 47 #include <asm/arch/boot_mode.h> 48 #include <asm/arch/clock.h> 49 #include <asm/arch/cpu.h> 50 #include <asm/arch/hotkey.h> 51 #include <asm/arch/param.h> 52 #include <asm/arch/periph.h> 53 #include <asm/arch/resource_img.h> 54 #include <asm/arch/rk_atags.h> 55 #include <asm/arch/vendor.h> 56 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 57 #include <rk_eink.h> 58 #endif 59 60 DECLARE_GLOBAL_DATA_PTR; 61 62 #ifdef CONFIG_ARM64 63 static ulong orig_images_ep; 64 #endif 65 66 __weak int rk_board_late_init(void) 67 { 68 return 0; 69 } 70 71 __weak int rk_board_fdt_fixup(void *blob) 72 { 73 return 0; 74 } 75 76 __weak int rk_board_dm_fdt_fixup(void *blob) 77 { 78 return 0; 79 } 80 81 __weak int soc_clk_dump(void) 82 { 83 return 0; 84 } 85 86 __weak int set_armclk_rate(void) 87 { 88 return 0; 89 } 90 91 __weak int rk_board_init(void) 92 { 93 return 0; 94 } 95 96 #ifdef CONFIG_ROCKCHIP_SET_ETHADDR 97 /* 98 * define serialno max length, the max length is 512 Bytes 99 * The remaining bytes are used to ensure that the first 512 bytes 100 * are valid when executing 'env_set("serial#", value)'. 101 */ 102 #define VENDOR_SN_MAX 513 103 #define CPUID_LEN 0x10 104 #define CPUID_OFF 0x07 105 106 #define MAX_ETHERNET 0x2 107 108 static int rockchip_set_ethaddr(void) 109 { 110 __maybe_unused bool need_write = false; 111 bool randomed = false; 112 char buf[ARP_HLEN_ASCII + 1], mac[16]; 113 u8 ethaddr[ARP_HLEN * MAX_ETHERNET] = {0}; 114 int i, ret = -EINVAL; 115 116 #ifdef CONFIG_ROCKCHIP_VENDOR_PARTITION 117 ret = vendor_storage_read(LAN_MAC_ID, ethaddr, sizeof(ethaddr)); 118 #endif 119 for (i = 0; i < MAX_ETHERNET; i++) { 120 if (ret <= 0 || !is_valid_ethaddr(ðaddr[i * ARP_HLEN])) { 121 if (!randomed) { 122 net_random_ethaddr(ðaddr[i * ARP_HLEN]); 123 randomed = true; 124 } else { 125 if (i > 0) { 126 memcpy(ðaddr[i * ARP_HLEN], 127 ðaddr[(i - 1) * ARP_HLEN], 128 ARP_HLEN); 129 ethaddr[i * ARP_HLEN] |= 0x02; 130 ethaddr[i * ARP_HLEN] += (i << 2); 131 } 132 } 133 134 need_write = true; 135 } 136 137 if (is_valid_ethaddr(ðaddr[i * ARP_HLEN])) { 138 snprintf(buf, ARP_HLEN_ASCII + 1, "%pM", ðaddr[i * ARP_HLEN]); 139 if (i == 0) 140 memcpy(mac, "ethaddr", sizeof("ethaddr")); 141 else 142 sprintf(mac, "eth%daddr", i); 143 env_set(mac, buf); 144 } 145 } 146 147 #ifdef CONFIG_ROCKCHIP_VENDOR_PARTITION 148 if (need_write) { 149 ret = vendor_storage_write(LAN_MAC_ID, 150 ethaddr, sizeof(ethaddr)); 151 if (ret < 0) 152 printf("%s: vendor_storage_write failed %d\n", 153 __func__, ret); 154 } 155 #endif 156 return 0; 157 } 158 #endif 159 160 #ifdef CONFIG_ROCKCHIP_SET_SN 161 static int rockchip_set_serialno(void) 162 { 163 u8 low[CPUID_LEN / 2], high[CPUID_LEN / 2]; 164 u8 cpuid[CPUID_LEN] = {0}; 165 char serialno_str[VENDOR_SN_MAX]; 166 int ret = 0, i; 167 u64 serialno; 168 169 /* Read serial number from vendor storage part */ 170 memset(serialno_str, 0, VENDOR_SN_MAX); 171 172 #ifdef CONFIG_ROCKCHIP_VENDOR_PARTITION 173 int j; 174 175 ret = vendor_storage_read(SN_ID, serialno_str, (VENDOR_SN_MAX-1)); 176 if (ret > 0) { 177 j = strlen(serialno_str); 178 for (i = 0; i < j; i++) { 179 if ((serialno_str[i] >= 'a' && serialno_str[i] <= 'z') || 180 (serialno_str[i] >= 'A' && serialno_str[i] <= 'Z') || 181 (serialno_str[i] >= '0' && serialno_str[i] <= '9')) 182 continue; 183 else 184 break; 185 } 186 187 /* valid character count > 0 */ 188 if (i > 0) { 189 serialno_str[i + 1] = 0x0; 190 env_set("serial#", serialno_str); 191 } 192 } 193 #endif 194 if (!env_get("serial#")) { 195 #if defined(CONFIG_ROCKCHIP_EFUSE) || defined(CONFIG_ROCKCHIP_OTP) 196 struct udevice *dev; 197 198 /* retrieve the device */ 199 if (IS_ENABLED(CONFIG_ROCKCHIP_EFUSE)) 200 ret = uclass_get_device_by_driver(UCLASS_MISC, 201 DM_GET_DRIVER(rockchip_efuse), 202 &dev); 203 else 204 ret = uclass_get_device_by_driver(UCLASS_MISC, 205 DM_GET_DRIVER(rockchip_otp), 206 &dev); 207 208 if (ret) { 209 printf("%s: could not find efuse/otp device\n", __func__); 210 return ret; 211 } 212 213 /* read the cpu_id range from the efuses */ 214 ret = misc_read(dev, CPUID_OFF, &cpuid, sizeof(cpuid)); 215 if (ret) { 216 printf("%s: read cpuid from efuse/otp failed, ret=%d\n", 217 __func__, ret); 218 return ret; 219 } 220 #else 221 /* generate random cpuid */ 222 for (i = 0; i < CPUID_LEN; i++) 223 cpuid[i] = (u8)(rand()); 224 #endif 225 /* Generate the serial number based on CPU ID */ 226 for (i = 0; i < 8; i++) { 227 low[i] = cpuid[1 + (i << 1)]; 228 high[i] = cpuid[i << 1]; 229 } 230 231 serialno = crc32_no_comp(0, low, 8); 232 serialno |= (u64)crc32_no_comp(serialno, high, 8) << 32; 233 snprintf(serialno_str, sizeof(serialno_str), "%llx", serialno); 234 235 env_set("serial#", serialno_str); 236 } 237 238 return ret; 239 } 240 #endif 241 242 #if defined(CONFIG_USB_FUNCTION_FASTBOOT) 243 int fb_set_reboot_flag(void) 244 { 245 printf("Setting reboot to fastboot flag ...\n"); 246 writel(BOOT_FASTBOOT, CONFIG_ROCKCHIP_BOOT_MODE_REG); 247 248 return 0; 249 } 250 #endif 251 252 #ifdef CONFIG_ROCKCHIP_USB_BOOT 253 static int boot_from_udisk(void) 254 { 255 struct blk_desc *desc; 256 struct udevice *dev; 257 int devnum = -1; 258 char buf[32]; 259 260 /* Booting priority: mmc1 > udisk */ 261 if (!strcmp(env_get("devtype"), "mmc") && !strcmp(env_get("devnum"), "1")) 262 return 0; 263 264 if (!run_command("usb start", -1)) { 265 for (blk_first_device(IF_TYPE_USB, &dev); 266 dev; 267 blk_next_device(&dev)) { 268 desc = dev_get_uclass_platdata(dev); 269 printf("Scanning usb %d ...\n", desc->devnum); 270 if (desc->type == DEV_TYPE_UNKNOWN) 271 continue; 272 273 if (desc->lba > 0L && desc->blksz > 0L) { 274 devnum = desc->devnum; 275 break; 276 } 277 } 278 if (devnum < 0) { 279 printf("No usb mass storage found\n"); 280 return -ENODEV; 281 } 282 283 desc = blk_get_devnum_by_type(IF_TYPE_USB, devnum); 284 if (!desc) { 285 printf("No usb %d found\n", devnum); 286 return -ENODEV; 287 } 288 289 snprintf(buf, 32, "rkimgtest usb %d", devnum); 290 if (!run_command(buf, -1)) { 291 snprintf(buf, 32, "%d", devnum); 292 rockchip_set_bootdev(desc); 293 env_set("devtype", "usb"); 294 env_set("devnum", buf); 295 printf("=== Booting from usb %d ===\n", devnum); 296 } else { 297 printf("No available udisk image on usb %d\n", devnum); 298 return -ENODEV; 299 } 300 } 301 302 return 0; 303 } 304 #endif 305 306 static void env_fixup(void) 307 { 308 struct memblock mem; 309 ulong u_addr_r; 310 phys_size_t end; 311 char *addr_r; 312 313 #ifdef ENV_MEM_LAYOUT_SETTINGS1 314 const char *env_addr0[] = { 315 "scriptaddr", "pxefile_addr_r", 316 "fdt_addr_r", "kernel_addr_r", "ramdisk_addr_r", 317 }; 318 const char *env_addr1[] = { 319 "scriptaddr1", "pxefile_addr1_r", 320 "fdt_addr1_r", "kernel_addr1_r", "ramdisk_addr1_r", 321 }; 322 int i; 323 324 /* 128M is a typical ram size for most platform, so as default here */ 325 if (gd->ram_size <= SZ_128M) { 326 /* Replace orignal xxx_addr_r */ 327 for (i = 0; i < ARRAY_SIZE(env_addr1); i++) { 328 addr_r = env_get(env_addr1[i]); 329 if (addr_r) 330 env_set(env_addr0[i], addr_r); 331 } 332 } 333 #endif 334 /* No BL32 ? */ 335 if (!(gd->flags & GD_FLG_BL32_ENABLED)) { 336 /* 337 * [1] Move kernel to lower address if possible. 338 */ 339 addr_r = env_get("kernel_addr_no_low_bl32_r"); 340 if (addr_r) 341 env_set("kernel_addr_r", addr_r); 342 343 /* 344 * [2] Move ramdisk at BL32 position if need. 345 * 346 * 0x0a200000 and 0x08400000 are rockchip traditional address 347 * of BL32 and ramdisk: 348 * 349 * |------------|------------| 350 * | BL32 | ramdisk | 351 * |------------|------------| 352 * 353 * Move ramdisk to BL32 address to fix sysmem alloc failed 354 * issue on the board with critical memory(ie. 256MB). 355 */ 356 if (gd->ram_size > SZ_128M && gd->ram_size <= SZ_256M) { 357 u_addr_r = env_get_ulong("ramdisk_addr_r", 16, 0); 358 if (u_addr_r == 0x0a200000) 359 env_set("ramdisk_addr_r", "0x08400000"); 360 } 361 } else { 362 mem = param_parse_optee_mem(); 363 364 /* 365 * [1] Move kernel forward if possible. 366 */ 367 if (mem.base > SZ_128M) { 368 addr_r = env_get("kernel_addr_no_low_bl32_r"); 369 if (addr_r) 370 env_set("kernel_addr_r", addr_r); 371 } 372 373 /* 374 * [2] Move ramdisk backward if optee enlarge. 375 */ 376 end = mem.base + mem.size; 377 u_addr_r = env_get_ulong("ramdisk_addr_r", 16, 0); 378 if (u_addr_r >= mem.base && u_addr_r < end) 379 env_set_hex("ramdisk_addr_r", end); 380 } 381 } 382 383 static void cmdline_handle(void) 384 { 385 struct blk_desc *dev_desc; 386 int if_type; 387 int devnum; 388 389 param_parse_pubkey_fuse_programmed(); 390 391 dev_desc = rockchip_get_bootdev(); 392 if (!dev_desc) 393 return; 394 395 /* 396 * 1. From rk356x, the sd/udisk recovery update flag was moved from 397 * IDB to Android BCB. 398 * 399 * 2. Udisk is init at the late boot_from_udisk(), but 400 * rockchip_get_boot_mode() actually only read once, 401 * we need to update boot mode according to udisk BCB. 402 */ 403 if_type = dev_desc->if_type; 404 devnum = dev_desc->devnum; 405 if ((if_type == IF_TYPE_MMC && devnum == 1) || (if_type == IF_TYPE_USB)) { 406 if (get_bcb_recovery_msg() == BCB_MSG_RECOVERY_RK_FWUPDATE) { 407 if (if_type == IF_TYPE_MMC && devnum == 1) { 408 env_update("bootargs", "sdfwupdate"); 409 } else if (if_type == IF_TYPE_USB) { 410 env_update("bootargs", "usbfwupdate"); 411 env_set("reboot_mode", "recovery-usb"); 412 } 413 } else { 414 if (if_type == IF_TYPE_USB) 415 env_set("reboot_mode", "normal"); 416 } 417 } 418 419 if (rockchip_get_boot_mode() == BOOT_MODE_QUIESCENT) 420 env_update("bootargs", "androidboot.quiescent=1 pwm_bl.quiescent=1"); 421 } 422 423 static void scan_run_cmd(void) 424 { 425 char *config = CONFIG_ROCKCHIP_CMD; 426 char *cmd, *key; 427 428 key = strchr(config, ' '); 429 if (!key) 430 return; 431 432 cmd = strdup(config); 433 cmd[key - config] = 0; 434 key++; 435 436 if (!strcmp(key, "-")) { 437 run_command(cmd, 0); 438 } else { 439 #ifdef CONFIG_DM_KEY 440 ulong map; 441 442 map = simple_strtoul(key, NULL, 10); 443 if (key_is_pressed(key_read(map))) { 444 printf("## Key<%ld> pressed... run cmd '%s'\n", map, cmd); 445 run_command(cmd, 0); 446 } 447 #endif 448 } 449 } 450 451 int board_late_init(void) 452 { 453 #ifdef CONFIG_ROCKCHIP_SET_ETHADDR 454 rockchip_set_ethaddr(); 455 #endif 456 #ifdef CONFIG_ROCKCHIP_SET_SN 457 rockchip_set_serialno(); 458 #endif 459 setup_download_mode(); 460 scan_run_cmd(); 461 #ifdef CONFIG_ROCKCHIP_USB_BOOT 462 boot_from_udisk(); 463 #endif 464 #ifdef CONFIG_DM_CHARGE_DISPLAY 465 charge_display(); 466 #endif 467 #ifdef CONFIG_DRM_ROCKCHIP 468 if (rockchip_get_boot_mode() != BOOT_MODE_QUIESCENT) 469 rockchip_show_logo(); 470 #endif 471 #ifdef CONFIG_ROCKCHIP_EINK_DISPLAY 472 rockchip_eink_show_uboot_logo(); 473 #endif 474 #if (CONFIG_ROCKCHIP_BOOT_MODE_REG > 0) 475 setup_boot_mode(); 476 #endif 477 env_fixup(); 478 soc_clk_dump(); 479 cmdline_handle(); 480 #ifdef CONFIG_AMP 481 amp_cpus_on(); 482 #endif 483 return rk_board_late_init(); 484 } 485 486 static void early_download(void) 487 { 488 #if defined(CONFIG_PWRKEY_DNL_TRIGGER_NUM) && \ 489 (CONFIG_PWRKEY_DNL_TRIGGER_NUM > 0) 490 if (pwrkey_download_init()) 491 printf("Pwrkey download init failed\n"); 492 #endif 493 494 #if (CONFIG_ROCKCHIP_BOOT_MODE_REG > 0) 495 if (is_hotkey(HK_BROM_DNL)) { 496 printf("Enter bootrom download..."); 497 flushc(); 498 writel(BOOT_BROM_DOWNLOAD, CONFIG_ROCKCHIP_BOOT_MODE_REG); 499 do_reset(NULL, 0, 0, NULL); 500 printf("failed!\n"); 501 } 502 #endif 503 } 504 505 static void board_debug_init(void) 506 { 507 if (!gd->serial.using_pre_serial && 508 !(gd->flags & GD_FLG_DISABLE_CONSOLE)) 509 debug_uart_init(); 510 511 if (tstc()) { 512 gd->console_evt = getc(); 513 if (gd->console_evt <= 0x1a) /* 'z' */ 514 printf("Hotkey: ctrl+%c\n", gd->console_evt + 'a' - 1); 515 } 516 517 if (IS_ENABLED(CONFIG_CONSOLE_DISABLE_CLI)) 518 printf("Cmd interface: disabled\n"); 519 } 520 521 int board_init(void) 522 { 523 board_debug_init(); 524 #ifdef DEBUG 525 soc_clk_dump(); 526 #endif 527 #ifdef CONFIG_OPTEE_CLIENT 528 optee_client_init(); 529 #endif 530 #ifdef CONFIG_USING_KERNEL_DTB 531 init_kernel_dtb(); 532 #endif 533 early_download(); 534 535 clks_probe(); 536 #ifdef CONFIG_DM_REGULATOR 537 regulators_enable_boot_on(is_hotkey(HK_REGULATOR)); 538 #endif 539 #ifdef CONFIG_ROCKCHIP_IO_DOMAIN 540 io_domain_init(); 541 #endif 542 set_armclk_rate(); 543 #ifdef CONFIG_DM_DVFS 544 dvfs_init(true); 545 #endif 546 #ifdef CONFIG_ANDROID_AB 547 if (ab_decrease_tries()) 548 printf("Decrease ab tries count fail!\n"); 549 #endif 550 551 return rk_board_init(); 552 } 553 554 int interrupt_debugger_init(void) 555 { 556 #ifdef CONFIG_ROCKCHIP_DEBUGGER 557 return rockchip_debugger_init(); 558 #else 559 return 0; 560 #endif 561 } 562 563 int board_fdt_fixup(void *blob) 564 { 565 /* 566 * Device's platdata points to orignal fdt blob property, 567 * access DM device before any fdt fixup. 568 */ 569 rk_board_dm_fdt_fixup(blob); 570 571 /* Common fixup for DRM */ 572 #ifdef CONFIG_DRM_ROCKCHIP 573 rockchip_display_fixup(blob); 574 #endif 575 576 #ifdef CONFIG_ROCKCHIP_VENDOR_PARTITION 577 vendor_storage_fixup(blob); 578 #endif 579 580 return rk_board_fdt_fixup(blob); 581 } 582 583 #if defined(CONFIG_ARM64_BOOT_AARCH32) || !defined(CONFIG_ARM64) 584 /* 585 * Common for OP-TEE: 586 * 64-bit & 32-bit mode: share memory dcache is always enabled; 587 * 588 * Common for U-Boot: 589 * 64-bit mode: MMU table is static defined in rkxxx.c file, all memory 590 * regions are mapped. That's good to match OP-TEE MMU policy. 591 * 592 * 32-bit mode: MMU table is setup according to gd->bd->bi_dram[..] where 593 * the OP-TEE region has been reserved, so it can not be 594 * mapped(i.e. dcache is disabled). That's *NOT* good to match 595 * OP-TEE MMU policy. 596 * 597 * For the data coherence when communication between U-Boot and OP-TEE, U-Boot 598 * should follow OP-TEE MMU policy. 599 * 600 * So 32-bit mode U-Boot should map OP-TEE share memory as dcache enabled. 601 */ 602 int board_initr_caches_fixup(void) 603 { 604 #ifdef CONFIG_OPTEE_CLIENT 605 struct memblock mem; 606 607 mem.base = 0; 608 mem.size = 0; 609 610 optee_get_shm_config(&mem.base, &mem.size); 611 if (mem.size) 612 mmu_set_region_dcache_behaviour(mem.base, mem.size, 613 DCACHE_WRITEBACK); 614 #endif 615 return 0; 616 } 617 #endif 618 619 void arch_preboot_os(uint32_t bootm_state, bootm_headers_t *images) 620 { 621 if (!(bootm_state & BOOTM_STATE_OS_PREP)) 622 return; 623 624 #ifdef CONFIG_ARM64 625 u8 *data = (void *)images->ep; 626 627 /* 628 * Fix kernel 5.10 arm64 boot warning: 629 * "[Firmware Bug]: Kernel image misaligned at boot, please fix your bootloader!" 630 * 631 * kernel: 5.10 commit 120dc60d0bdb ("arm64: get rid of TEXT_OFFSET") 632 * arm64 kernel version: 633 * data[10] == 0x00 if kernel version >= 5.10: N*2MB align 634 * data[10] == 0x08 if kernel version < 5.10: N*2MB + 0x80000(TEXT_OFFSET) 635 * 636 * Why fix here? 637 * 1. this is the common and final path for any boot command. 638 * 2. don't influence original boot flow, just fix it exactly before 639 * jumping kernel. 640 * 641 * But relocation is in board_quiesce_devices() until all decompress 642 * done, mainly for saving boot time. 643 */ 644 645 orig_images_ep = images->ep; 646 647 if (data[10] == 0x00) { 648 if (round_down(images->ep, SZ_2M) != images->ep) 649 images->ep = round_down(images->ep, SZ_2M); 650 } else { 651 if (IS_ALIGNED(images->ep, SZ_2M)) 652 images->ep += 0x80000; 653 } 654 #endif 655 hotkey_run(HK_CLI_OS_PRE); 656 } 657 658 void enable_caches(void) 659 { 660 icache_enable(); 661 dcache_enable(); 662 } 663 664 #ifdef CONFIG_LMB 665 /* 666 * Using last bi_dram[...] to initialize "bootm_low" and "bootm_mapsize". 667 * This makes lmb_alloc_base() always alloc from tail of sdram. 668 * If we don't assign it, bi_dram[0] is used by default and it may cause 669 * lmb_alloc_base() fail when bi_dram[0] range is small. 670 */ 671 void board_lmb_reserve(struct lmb *lmb) 672 { 673 char bootm_mapsize[32]; 674 char bootm_low[32]; 675 u64 start, size; 676 int i; 677 678 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { 679 if (!gd->bd->bi_dram[i].size) 680 break; 681 } 682 683 start = gd->bd->bi_dram[i - 1].start; 684 size = gd->bd->bi_dram[i - 1].size; 685 686 /* 687 * 32-bit kernel: ramdisk/fdt shouldn't be loaded to highmem area(768MB+), 688 * otherwise "Unable to handle kernel paging request at virtual address ...". 689 * 690 * So that we hope limit highest address at 768M, but there comes the the 691 * problem: ramdisk is a compressed image and it expands after descompress, 692 * so it accesses 768MB+ and brings the above "Unable to handle kernel ...". 693 * 694 * We make a appointment that the highest memory address is 512MB, it 695 * makes lmb alloc safer. 696 */ 697 #ifndef CONFIG_ARM64 698 if (start >= ((u64)CONFIG_SYS_SDRAM_BASE + SZ_512M)) { 699 start = gd->bd->bi_dram[i - 2].start; 700 size = gd->bd->bi_dram[i - 2].size; 701 } 702 703 if ((start + size) > ((u64)CONFIG_SYS_SDRAM_BASE + SZ_512M)) 704 size = (u64)CONFIG_SYS_SDRAM_BASE + SZ_512M - start; 705 #endif 706 sprintf(bootm_low, "0x%llx", start); 707 sprintf(bootm_mapsize, "0x%llx", size); 708 env_set("bootm_low", bootm_low); 709 env_set("bootm_mapsize", bootm_mapsize); 710 } 711 #endif 712 713 #ifdef CONFIG_BIDRAM 714 int board_bidram_reserve(struct bidram *bidram) 715 { 716 struct memblock mem; 717 int ret; 718 719 /* ATF */ 720 mem = param_parse_atf_mem(); 721 ret = bidram_reserve(MEM_ATF, mem.base, mem.size); 722 if (ret) 723 return ret; 724 725 /* PSTORE/ATAGS/SHM */ 726 mem = param_parse_common_resv_mem(); 727 ret = bidram_reserve(MEM_SHM, mem.base, mem.size); 728 if (ret) 729 return ret; 730 731 /* OP-TEE */ 732 mem = param_parse_optee_mem(); 733 ret = bidram_reserve(MEM_OPTEE, mem.base, mem.size); 734 if (ret) 735 return ret; 736 737 return 0; 738 } 739 740 #ifdef CONFIG_SYSMEM 741 int board_sysmem_reserve(struct sysmem *sysmem) 742 { 743 #ifdef CONFIG_SKIP_RELOCATE_UBOOT 744 if (!sysmem_alloc_base_by_name("NO-RELOC-CODE", 745 CONFIG_SYS_TEXT_BASE, SZ_2M)) { 746 printf("Failed to reserve sysmem for U-Boot code\n"); 747 return -ENOMEM; 748 } 749 #endif 750 return 0; 751 } 752 #endif 753 754 parse_fn_t board_bidram_parse_fn(void) 755 { 756 return param_parse_ddr_mem; 757 } 758 #endif 759 760 int board_init_f_boot_flags(void) 761 { 762 int boot_flags = 0; 763 764 #ifdef CONFIG_FPGA_ROCKCHIP 765 arch_fpga_init(); 766 #endif 767 #ifdef CONFIG_PSTORE 768 param_parse_pstore(); 769 #endif 770 param_parse_pre_serial(&boot_flags); 771 772 /* The highest priority to turn off (override) console */ 773 #if defined(CONFIG_DISABLE_CONSOLE) 774 boot_flags |= GD_FLG_DISABLE_CONSOLE; 775 #endif 776 777 return boot_flags; 778 } 779 780 #if defined(CONFIG_USB_GADGET) 781 #include <usb.h> 782 #if defined(CONFIG_USB_GADGET_DWC2_OTG) 783 #include <fdt_support.h> 784 #include <usb/dwc2_udc.h> 785 786 static struct dwc2_plat_otg_data otg_data = { 787 .rx_fifo_sz = 512, 788 .np_tx_fifo_sz = 16, 789 .tx_fifo_sz = 128, 790 }; 791 792 int board_usb_init(int index, enum usb_init_type init) 793 { 794 const void *blob = gd->fdt_blob; 795 const fdt32_t *reg; 796 fdt_addr_t addr; 797 int node; 798 799 /* find the usb_otg node */ 800 node = fdt_node_offset_by_compatible(blob, -1, "snps,dwc2"); 801 802 retry: 803 if (node > 0) { 804 reg = fdt_getprop(blob, node, "reg", NULL); 805 if (!reg) 806 return -EINVAL; 807 808 addr = fdt_translate_address(blob, node, reg); 809 if (addr == OF_BAD_ADDR) { 810 pr_err("Not found usb_otg address\n"); 811 return -EINVAL; 812 } 813 814 #if defined(CONFIG_ROCKCHIP_RK3288) 815 if (addr != 0xff580000) { 816 node = fdt_node_offset_by_compatible(blob, node, 817 "snps,dwc2"); 818 goto retry; 819 } 820 #endif 821 } else { 822 /* 823 * With kernel dtb support, rk3288 dwc2 otg node 824 * use the rockchip legacy dwc2 driver "dwc_otg_310" 825 * with the compatible "rockchip,rk3288_usb20_otg", 826 * and rk3368 also use the "dwc_otg_310" driver with 827 * the compatible "rockchip,rk3368-usb". 828 */ 829 #if defined(CONFIG_ROCKCHIP_RK3288) 830 node = fdt_node_offset_by_compatible(blob, -1, 831 "rockchip,rk3288_usb20_otg"); 832 #elif defined(CONFIG_ROCKCHIP_RK3368) 833 node = fdt_node_offset_by_compatible(blob, -1, 834 "rockchip,rk3368-usb"); 835 #endif 836 if (node > 0) { 837 goto retry; 838 } else { 839 pr_err("Not found usb_otg device\n"); 840 return -ENODEV; 841 } 842 } 843 844 otg_data.regs_otg = (uintptr_t)addr; 845 846 return dwc2_udc_probe(&otg_data); 847 } 848 849 int board_usb_cleanup(int index, enum usb_init_type init) 850 { 851 return 0; 852 } 853 #elif defined(CONFIG_USB_DWC3_GADGET) /* CONFIG_USB_GADGET_DWC2_OTG */ 854 #include <dwc3-uboot.h> 855 856 int board_usb_cleanup(int index, enum usb_init_type init) 857 { 858 dwc3_uboot_exit(index); 859 return 0; 860 } 861 862 #endif /* CONFIG_USB_DWC3_GADGET */ 863 #endif /* CONFIG_USB_GADGET */ 864 865 static void bootm_no_reloc(void) 866 { 867 char *ramdisk_high; 868 char *fdt_high; 869 870 if (!env_get_yesno("bootm-no-reloc")) 871 return; 872 873 ramdisk_high = env_get("initrd_high"); 874 fdt_high = env_get("fdt_high"); 875 876 if (!fdt_high) { 877 env_set_hex("fdt_high", -1UL); 878 printf("Fdt "); 879 } 880 881 if (!ramdisk_high) { 882 env_set_hex("initrd_high", -1UL); 883 printf("Ramdisk "); 884 } 885 886 if (!fdt_high || !ramdisk_high) 887 printf("skip relocation\n"); 888 } 889 890 int bootm_board_start(void) 891 { 892 /* 893 * print console record data 894 * 895 * On some rockchip platforms, uart debug and sdmmc pin are multiplex. 896 * If boot from sdmmc mode, the console data would be record in buffer, 897 * we switch to uart debug function in order to print it after loading 898 * images. 899 */ 900 #if 0 901 if (!strcmp("mmc", env_get("devtype")) && 902 !strcmp("1", env_get("devnum"))) { 903 printf("IOMUX: sdmmc => uart debug"); 904 pinctrl_select_state(gd->cur_serial_dev, "default"); 905 console_record_print_purge(); 906 } 907 #endif 908 /* disable bootm relcation to save boot time */ 909 bootm_no_reloc(); 910 911 /* PCBA test needs more permission */ 912 if (get_bcb_recovery_msg() == BCB_MSG_RECOVERY_PCBA) 913 env_update("bootargs", "androidboot.selinux=permissive"); 914 915 /* sysmem */ 916 hotkey_run(HK_SYSMEM); 917 sysmem_overflow_check(); 918 919 return 0; 920 } 921 922 int bootm_image_populate_dtb(void *img) 923 { 924 if ((gd->flags & GD_FLG_KDTB_READY) && !gd->fdt_blob_kern) 925 sysmem_free((phys_addr_t)gd->fdt_blob); 926 else 927 gd->fdt_blob = (void *)env_get_ulong("fdt_addr_r", 16, 0); 928 929 return rockchip_ram_read_dtb_file(img, (void *)gd->fdt_blob); 930 } 931 932 /* 933 * Implement it to support CLI command: 934 * - Android: bootm [aosp addr] 935 * - FIT: bootm [fit addr] 936 * - uImage: bootm [uimage addr] 937 * 938 * Purpose: 939 * - The original bootm command args require fdt addr on AOSP, 940 * which is not flexible on rockchip boot/recovery.img. 941 * - Take Android/FIT/uImage image into sysmem management to avoid image 942 * memory overlap. 943 */ 944 #if defined(CONFIG_ANDROID_BOOTLOADER) || \ 945 defined(CONFIG_ROCKCHIP_FIT_IMAGE) || \ 946 defined(CONFIG_ROCKCHIP_UIMAGE) 947 int board_do_bootm(int argc, char * const argv[]) 948 { 949 int format; 950 void *img; 951 952 /* only 'bootm' full image goes further */ 953 if (argc != 2) 954 return 0; 955 956 img = (void *)simple_strtoul(argv[1], NULL, 16); 957 format = (genimg_get_format(img)); 958 959 /* Android */ 960 #ifdef CONFIG_ANDROID_BOOT_IMAGE 961 if (format == IMAGE_FORMAT_ANDROID) { 962 struct andr_img_hdr *hdr; 963 ulong load_addr; 964 ulong size; 965 int ret; 966 967 hdr = (struct andr_img_hdr *)img; 968 printf("BOOTM: transferring to board Android\n"); 969 970 load_addr = env_get_ulong("kernel_addr_r", 16, 0); 971 load_addr -= hdr->page_size; 972 size = android_image_get_end(hdr) - (ulong)hdr; 973 974 if (!sysmem_alloc_base(MEM_ANDROID, (ulong)hdr, size)) 975 return -ENOMEM; 976 977 ret = bootm_image_populate_dtb(img); 978 if (ret) { 979 printf("bootm can't read dtb, ret=%d\n", ret); 980 return ret; 981 } 982 983 ret = android_image_memcpy_separate(hdr, &load_addr); 984 if (ret) { 985 printf("board do bootm failed, ret=%d\n", ret); 986 return ret; 987 } 988 989 return android_bootloader_boot_kernel(load_addr); 990 } 991 #endif 992 993 /* FIT */ 994 #if IMAGE_ENABLE_FIT 995 if (format == IMAGE_FORMAT_FIT) { 996 char boot_cmd[64]; 997 int ret; 998 999 printf("BOOTM: transferring to board FIT\n"); 1000 1001 ret = bootm_image_populate_dtb(img); 1002 if (ret) { 1003 printf("bootm can't read dtb, ret=%d\n", ret); 1004 return ret; 1005 } 1006 snprintf(boot_cmd, sizeof(boot_cmd), "boot_fit %s", argv[1]); 1007 return run_command(boot_cmd, 0); 1008 } 1009 #endif 1010 1011 /* uImage */ 1012 #if 0 1013 #if defined(CONFIG_IMAGE_FORMAT_LEGACY) 1014 if (format == IMAGE_FORMAT_LEGACY && 1015 image_get_type(img) == IH_TYPE_MULTI) { 1016 char boot_cmd[64]; 1017 1018 printf("BOOTM: transferring to board uImage\n"); 1019 snprintf(boot_cmd, sizeof(boot_cmd), "boot_uimage %s", argv[1]); 1020 return run_command(boot_cmd, 0); 1021 } 1022 #endif 1023 #endif 1024 return 0; 1025 } 1026 #endif 1027 1028 void autoboot_command_fail_handle(void) 1029 { 1030 #ifdef CONFIG_ANDROID_AB 1031 if (rk_avb_ab_have_bootable_slot() == true) 1032 run_command("reset;", 0); 1033 else 1034 run_command("fastboot usb 0;", 0); 1035 #endif 1036 1037 #ifdef CONFIG_AVB_VBMETA_PUBLIC_KEY_VALIDATE 1038 run_command("download", 0); 1039 run_command("fastboot usb 0;", 0); 1040 #endif 1041 1042 } 1043 1044 #ifdef CONFIG_FIT_ROLLBACK_PROTECT 1045 1046 #define FIT_ROLLBACK_INDEX_LOCATION 0x66697472 /* "fitr" */ 1047 1048 int fit_read_otp_rollback_index(uint32_t fit_index, uint32_t *otp_index) 1049 { 1050 #ifdef CONFIG_OPTEE_CLIENT 1051 u64 index; 1052 int ret; 1053 1054 ret = trusty_read_rollback_index(FIT_ROLLBACK_INDEX_LOCATION, &index); 1055 if (ret) { 1056 if (ret != TEE_ERROR_ITEM_NOT_FOUND) 1057 return ret; 1058 1059 index = 0; 1060 printf("Initial otp index as %d\n", fit_index); 1061 } 1062 1063 *otp_index = (uint32_t)index; 1064 #else 1065 *otp_index = 0; 1066 #endif 1067 1068 return 0; 1069 } 1070 1071 int fit_write_trusty_rollback_index(u32 trusty_index) 1072 { 1073 if (!trusty_index) 1074 return 0; 1075 #ifdef CONFIG_OPTEE_CLIENT 1076 return trusty_write_rollback_index(FIT_ROLLBACK_INDEX_LOCATION, 1077 (u64)trusty_index); 1078 #else 1079 return 0; 1080 #endif 1081 } 1082 #endif 1083 1084 void board_quiesce_devices(void *images) 1085 { 1086 #ifdef CONFIG_ROCKCHIP_PRELOADER_ATAGS 1087 /* Destroy atags makes next warm boot safer */ 1088 atags_destroy(); 1089 #endif 1090 #ifdef CONFIG_FIT_ROLLBACK_PROTECT 1091 int ret; 1092 1093 ret = fit_write_trusty_rollback_index(gd->rollback_index); 1094 if (ret) { 1095 panic("Failed to write fit rollback index %d, ret=%d", 1096 gd->rollback_index, ret); 1097 } 1098 #endif 1099 #ifdef CONFIG_ROCKCHIP_HW_DECOMPRESS 1100 misc_decompress_cleanup(); 1101 #endif 1102 #ifdef CONFIG_ARM64 1103 bootm_headers_t *bootm_images = (bootm_headers_t *)images; 1104 1105 /* relocate kernel after decompress cleanup */ 1106 if (orig_images_ep && orig_images_ep != bootm_images->ep) { 1107 memmove((char *)bootm_images->ep, (const char *)orig_images_ep, 1108 bootm_images->os.image_len); 1109 printf("== DO RELOCATE == Kernel from 0x%08lx to 0x%08lx\n", 1110 orig_images_ep, bootm_images->ep); 1111 } 1112 #endif 1113 1114 hotkey_run(HK_CMDLINE); 1115 hotkey_run(HK_CLI_OS_GO); 1116 #ifdef CONFIG_ROCKCHIP_REBOOT_TEST 1117 do_reset(NULL, 0, 0, NULL); 1118 #endif 1119 } 1120 1121 /* 1122 * Use hardware rng to seed Linux random 1123 * 1124 * 'Android_14 + GKI' requires this information. 1125 */ 1126 int board_rng_seed(struct abuf *buf) 1127 { 1128 struct udevice *dev; 1129 size_t len = 32; 1130 u64 *data; 1131 1132 data = malloc(len); 1133 if (!data) { 1134 printf("Out of memory\n"); 1135 return -ENOMEM; 1136 } 1137 1138 if (uclass_get_device(UCLASS_RNG, 0, &dev) || !dev) { 1139 printf("No RNG device\n"); 1140 return -ENODEV; 1141 } 1142 1143 if (dm_rng_read(dev, data, len)) { 1144 printf("Reading RNG failed\n"); 1145 return -EIO; 1146 } 1147 1148 abuf_init_set(buf, data, len); 1149 1150 return 0; 1151 } 1152 1153 /* 1154 * Pass fwver when any available. 1155 */ 1156 static void bootargs_add_fwver(bool verbose) 1157 { 1158 #ifdef CONFIG_ROCKCHIP_PRELOADER_ATAGS 1159 struct tag *t; 1160 char *list1 = NULL; 1161 char *list2 = NULL; 1162 char *fwver = NULL; 1163 char *p = PLAIN_VERSION; 1164 int i, end; 1165 1166 t = atags_get_tag(ATAG_FWVER); 1167 if (t) { 1168 list1 = calloc(1, sizeof(struct tag_fwver)); 1169 if (!list1) 1170 return; 1171 for (i = 0; i < FW_MAX; i++) { 1172 if (t->u.fwver.ver[i][0] != '\0') { 1173 strcat(list1, t->u.fwver.ver[i]); 1174 strcat(list1, ","); 1175 } 1176 } 1177 } 1178 1179 list2 = calloc(1, FWVER_LEN); 1180 if (!list2) 1181 goto out; 1182 strcat(list2, "uboot-"); 1183 /* optional */ 1184 #ifdef BUILD_TAG 1185 strcat(list2, BUILD_TAG); 1186 strcat(list2, "-"); 1187 #endif 1188 /* optional */ 1189 if (strcmp(PLAIN_VERSION, "2017.09")) { 1190 strncat(list2, p + strlen("2017.09-g"), 10); 1191 strcat(list2, "-"); 1192 } 1193 strcat(list2, U_BOOT_DMI_DATE); 1194 1195 /* merge ! */ 1196 if (list1 || list2) { 1197 fwver = calloc(1, sizeof(struct tag_fwver)); 1198 if (!fwver) 1199 goto out; 1200 1201 strcat(fwver, "androidboot.fwver="); 1202 if (list1) 1203 strcat(fwver, list1); 1204 if (list2) { 1205 strcat(fwver, list2); 1206 } else { 1207 end = strlen(fwver) - 1; 1208 fwver[end] = '\0'; /* omit last ',' */ 1209 } 1210 if (verbose) 1211 printf("## fwver: %s\n\n", fwver); 1212 env_update("bootargs", fwver); 1213 env_set("fwver", fwver + strlen("androidboot.")); 1214 } 1215 out: 1216 if (list1) 1217 free(list1); 1218 if (list2) 1219 free(list2); 1220 if (fwver) 1221 free(fwver); 1222 #endif 1223 } 1224 1225 static void bootargs_add_android(bool verbose) 1226 { 1227 #ifdef CONFIG_ANDROID_AB 1228 ab_update_root_partition(); 1229 #endif 1230 1231 /* Android header v4+ need this handle */ 1232 #ifdef CONFIG_ANDROID_BOOT_IMAGE 1233 struct andr_img_hdr *hdr; 1234 char *fwver; 1235 1236 hdr = (void *)env_get_ulong("android_addr_r", 16, 0); 1237 if (hdr && !android_image_check_header(hdr) && hdr->header_version >= 4) { 1238 if (env_update_extract_subset("bootargs", "andr_bootargs", "androidboot.")) 1239 printf("extract androidboot.xxx error\n"); 1240 if (verbose) 1241 printf("## bootargs(android): %s\n\n", env_get("andr_bootargs")); 1242 1243 /* for kernel cmdline can be read */ 1244 fwver = env_get("fwver"); 1245 if (fwver) { 1246 env_update("bootargs", fwver); 1247 env_set("fwver", NULL); 1248 } 1249 } 1250 #endif 1251 } 1252 1253 static void bootargs_add_partition(bool verbose) 1254 { 1255 #if defined(CONFIG_ENVF) || defined(CONFIG_ENV_PARTITION) 1256 char *part_type[] = { "mtdparts", "blkdevparts" }; 1257 char *part_list; 1258 char *env; 1259 int id = 0; 1260 1261 env = env_get(part_type[id]); 1262 if (!env) 1263 env = env_get(part_type[++id]); 1264 if (env) { 1265 if (!strstr(env, part_type[id])) { 1266 part_list = calloc(1, strlen(env) + strlen(part_type[id]) + 2); 1267 if (part_list) { 1268 strcat(part_list, part_type[id]); 1269 strcat(part_list, "="); 1270 strcat(part_list, env); 1271 } 1272 } else { 1273 part_list = env; 1274 } 1275 env_update("bootargs", part_list); 1276 if (verbose) 1277 printf("## parts: %s\n\n", part_list); 1278 } 1279 1280 env = env_get("sys_bootargs"); 1281 if (env) { 1282 env_update("bootargs", env); 1283 if (verbose) 1284 printf("## sys_bootargs: %s\n\n", env); 1285 } 1286 #endif 1287 1288 #ifdef CONFIG_MTD_BLK 1289 if (!env_get("mtdparts")) { 1290 char *mtd_par_info = mtd_part_parse(NULL); 1291 1292 if (mtd_par_info) { 1293 if (memcmp(env_get("devtype"), "mtd", 3) == 0) 1294 env_update("bootargs", mtd_par_info); 1295 } 1296 } 1297 #endif 1298 } 1299 1300 static void bootargs_add_dtb_dtbo(void *fdt, bool verbose) 1301 { 1302 /* bootargs_ext is used when dtbo is applied. */ 1303 const char *arr_bootargs[] = { "bootargs", "bootargs_ext" }; 1304 const char *bootargs; 1305 char *msg = "kernel"; 1306 int i, noffset; 1307 1308 /* find or create "/chosen" node. */ 1309 noffset = fdt_find_or_add_subnode(fdt, 0, "chosen"); 1310 if (noffset < 0) 1311 return; 1312 1313 for (i = 0; i < ARRAY_SIZE(arr_bootargs); i++) { 1314 bootargs = fdt_getprop(fdt, noffset, arr_bootargs[i], NULL); 1315 if (!bootargs) 1316 continue; 1317 if (verbose) 1318 printf("## bootargs(%s-%s): %s\n\n", 1319 msg, arr_bootargs[i], bootargs); 1320 /* 1321 * Append kernel bootargs 1322 * If use AB system, delete default "root=" which route 1323 * to rootfs. Then the ab bootctl will choose the 1324 * high priority system to boot and add its UUID 1325 * to cmdline. The format is "roo=PARTUUID=xxxx...". 1326 */ 1327 #ifdef CONFIG_ANDROID_AB 1328 env_update_filter("bootargs", bootargs, "root="); 1329 #else 1330 env_update("bootargs", bootargs); 1331 #endif 1332 } 1333 } 1334 1335 char *board_fdt_chosen_bootargs(void *fdt) 1336 { 1337 int verbose = is_hotkey(HK_CMDLINE); 1338 const char *bootargs; 1339 1340 /* debug */ 1341 hotkey_run(HK_INITCALL); 1342 if (verbose) 1343 printf("## bootargs(u-boot): %s\n\n", env_get("bootargs")); 1344 1345 bootargs_add_dtb_dtbo(fdt, verbose); 1346 bootargs_add_partition(verbose); 1347 bootargs_add_android(verbose); 1348 bootargs_add_fwver(verbose); 1349 1350 /* 1351 * Initrd fixup: remove unused "initrd=0x...,0x...", 1352 * this for compatible with legacy parameter.txt 1353 */ 1354 env_delete("bootargs", "initrd=", 0); 1355 1356 /* 1357 * If uart is required to be disabled during 1358 * power on, it would be not initialized by 1359 * any pre-loader and U-Boot. 1360 * 1361 * If we don't remove earlycon from commandline, 1362 * kernel hangs while using earlycon to putc/getc 1363 * which may dead loop for waiting uart status. 1364 * (It seems the root cause is baundrate is not 1365 * initilalized) 1366 * 1367 * So let's remove earlycon from commandline. 1368 */ 1369 if (gd->flags & GD_FLG_DISABLE_CONSOLE) 1370 env_delete("bootargs", "earlycon=", 0); 1371 1372 bootargs = env_get("bootargs"); 1373 if (verbose) 1374 printf("## bootargs(merged): %s\n\n", bootargs); 1375 1376 return (char *)bootargs; 1377 } 1378 1379 int ft_verify_fdt(void *fdt) 1380 { 1381 /* for android header v4+, we load bootparams and fixup initrd */ 1382 #if defined(CONFIG_ANDROID_BOOT_IMAGE) && defined(CONFIG_XBC) 1383 struct andr_img_hdr *hdr; 1384 uint64_t initrd_start, initrd_end; 1385 char *bootargs, *p; 1386 int nodeoffset; 1387 int is_u64, err; 1388 u32 len; 1389 1390 hdr = (void *)env_get_ulong("android_addr_r", 16, 0); 1391 if (!hdr || android_image_check_header(hdr) || 1392 hdr->header_version < 4) 1393 return 1; 1394 1395 bootargs = env_get("andr_bootargs"); 1396 if (!bootargs) 1397 return 1; 1398 1399 /* trans character: space to new line */ 1400 p = bootargs; 1401 while (*p++) { 1402 if (*p == ' ') 1403 *p = '\n'; 1404 } 1405 1406 debug("## andr_bootargs: %s\n", bootargs); 1407 1408 /* 1409 * add boot params right after bootconfig 1410 * 1411 * because we can get final full bootargs in board_fdt_chosen_bootargs(), 1412 * android_image_get_ramdisk() is early than that. 1413 * 1414 * we have to add boot params by now. 1415 */ 1416 len = addBootConfigParameters((char *)bootargs, strlen(bootargs), 1417 (u64)hdr->ramdisk_addr + hdr->ramdisk_size + 1418 hdr->vendor_ramdisk_size, hdr->vendor_bootconfig_size); 1419 if (len < 0) { 1420 printf("error: addBootConfigParameters\n"); 1421 return 0; 1422 } 1423 1424 nodeoffset = fdt_subnode_offset(fdt, 0, "chosen"); 1425 if (nodeoffset < 0) { 1426 printf("error: No /chosen node\n"); 1427 return 0; 1428 } 1429 1430 /* fixup initrd with real value */ 1431 fdt_delprop(fdt, nodeoffset, "linux,initrd-start"); 1432 fdt_delprop(fdt, nodeoffset, "linux,initrd-end"); 1433 1434 is_u64 = (fdt_address_cells(fdt, 0) == 2); 1435 initrd_start = hdr->ramdisk_addr; 1436 initrd_end = initrd_start + hdr->ramdisk_size + 1437 hdr->vendor_ramdisk_size + 1438 hdr->vendor_bootconfig_size + len; 1439 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start", 1440 initrd_start, is_u64); 1441 if (err < 0) { 1442 printf("WARNING: could not set linux,initrd-start %s.\n", 1443 fdt_strerror(err)); 1444 return 0; 1445 } 1446 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end", 1447 initrd_end, is_u64); 1448 if (err < 0) { 1449 printf("WARNING: could not set linux,initrd-end %s.\n", 1450 fdt_strerror(err)); 1451 return 0; 1452 } 1453 #endif 1454 return 1; 1455 } 1456 1457