Rockchip RK3399 - TPL/SPL方式加载uboot

root@zhengyang:/work/sambashare/rk3399/u-boot# cd ..
root@zhengyang:/work/sambashare/rk3399# cd u-boot/
root@zhengyang:/work/sambashare/rk3399/u-boot# ls -l
总用量 488
drwxr-xr-x   2 root root   4096 5月   7 20:00 api
drwxr-xr-x  14 root root   4096 5月   7 20:00 arch
drwxr-xr-x 181 root root   4096 5月   7 20:00 board
drwxr-xr-x   6 root root   4096 5月   7 20:00 cmd
drwxr-xr-x   5 root root   4096 5月   7 20:00 common
-rw-r--r--   1 root root   2260 5月   7 20:00 config.mk
drwxr-xr-x   2 root root  69632 5月   7 20:00 configs
drwxr-xr-x   2 root root   4096 5月   7 20:00 disk
drwxr-xr-x  10 root root  12288 5月   7 20:00 doc
drwxr-xr-x   3 root root   4096 5月   7 20:00 Documentation
drwxr-xr-x  56 root root   4096 5月   7 20:00 drivers
drwxr-xr-x   2 root root   4096 5月   7 20:00 dts
drwxr-xr-x   2 root root   4096 5月   7 20:00 env
drwxr-xr-x   4 root root   4096 5月   7 20:00 examples
drwxr-xr-x  12 root root   4096 5月   7 20:00 fs
drwxr-xr-x  32 root root  16384 5月   7 20:00 include
-rw-r--r--   1 root root   1863 5月   7 20:00 Kbuild
-rw-r--r--   1 root root  14162 5月   7 20:00 Kconfig
drwxr-xr-x  14 root root   4096 5月   7 20:00 lib
drwxr-xr-x   2 root root   4096 5月   7 20:00 Licenses
-rw-r--r--   1 root root  12587 5月   7 20:00 MAINTAINERS
-rw-r--r--   1 root root  56469 5月   7 20:00 Makefile
-rwxr-xr-x   1 root root  19845 5月   7 20:00 make.sh
drwxr-xr-x   2 root root   4096 5月   7 20:00 net
-rwxr-xr-x   1 root root   1640 5月   7 20:00 pack_resource.sh
drwxr-xr-x   5 root root   4096 5月   7 20:00 post
-rw-r--r--   1 root root     34 5月   7 20:00 PREUPLOAD.cfg
-rw-r--r--   1 root root 189024 5月   7 20:00 README
drwxr-xr-x   6 root root   4096 5月   7 20:00 scripts
-rw-r--r--   1 root root     17 5月   7 20:00 snapshot.commit
drwxr-xr-x  12 root root   4096 5月   7 20:00 test
drwxr-xr-x  16 root root   4096 5月   7 20:00 tools

CONFIG_ARM=y
CONFIG_ARCH_ROCKCHIP=y
CONFIG_SPL_LIBCOMMON_SUPPORT=y
CONFIG_SPL_LIBGENERIC_SUPPORT=y
CONFIG_SYS_MALLOC_F_LEN=0x4000
CONFIG_ROCKCHIP_RK3399=y
CONFIG_RKIMG_BOOTLOADER=y
# CONFIG_USING_KERNEL_DTB is not set
CONFIG_DEFAULT_DEVICE_TREE="rk3399-evb"
CONFIG_DEBUG_UART=y
CONFIG_FIT=y
CONFIG_SPL_LOAD_FIT=y
CONFIG_SPL_FIT_GENERATOR="arch/arm/mach-rockchip/make_fit_atf.py"
# CONFIG_DISPLAY_CPUINFO is not set
CONFIG_ANDROID_BOOTLOADER=y
CONFIG_SPL_STACK_R=y
CONFIG_SPL_STACK_R_MALLOC_SIMPLE_LEN=0x10000
CONFIG_SPL_ATF=y
CONFIG_SPL_ATF_NO_PLATFORM_PARAM=y
CONFIG_FASTBOOT_BUF_ADDR=0x00800800
CONFIG_FASTBOOT_BUF_SIZE=0x04000000
CONFIG_FASTBOOT_FLASH=y
CONFIG_FASTBOOT_FLASH_MMC_DEV=0
CONFIG_CMD_BOOTZ=y
# CONFIG_CMD_IMLS is not set
CONFIG_CMD_GPT=y
CONFIG_CMD_LOAD_ANDROID=y
CONFIG_CMD_BOOT_ANDROID=y
CONFIG_CMD_BOOT_ROCKCHIP=y
CONFIG_CMD_MMC=y
CONFIG_CMD_SF=y
CONFIG_CMD_USB=y
CONFIG_CMD_USB_MASS_STORAGE=y
# CONFIG_CMD_SETEXPR is not set
CONFIG_CMD_TIME=y
CONFIG_RKPARM_PARTITION=y
CONFIG_SPL_OF_CONTROL=y
CONFIG_OF_LIVE=y
CONFIG_OF_SPL_REMOVE_PROPS="pinctrl-0 pinctrl-names clock-names interrupt-parent assigned-clocks assigned-clock-rates assigned-clock-parents"
CONFIG_NET_RANDOM_ETHADDR=y
CONFIG_REGMAP=y
CONFIG_SPL_REGMAP=y
CONFIG_SYSCON=y
CONFIG_SPL_SYSCON=y
CONFIG_CLK=y
CONFIG_SPL_CLK=y
CONFIG_ROCKCHIP_GPIO=y
CONFIG_SYS_I2C_ROCKCHIP=y
CONFIG_MISC=y
CONFIG_ROCKCHIP_EFUSE=y
CONFIG_MMC_DW=y
CONFIG_MMC_DW_ROCKCHIP=y
CONFIG_MMC_SDHCI=y
CONFIG_MMC_SDHCI_ROCKCHIP=y
CONFIG_DM_ETH=y
CONFIG_ETH_DESIGNWARE=y
CONFIG_GMAC_ROCKCHIP=y
CONFIG_PINCTRL=y
CONFIG_SPL_PINCTRL=y
CONFIG_DM_PMIC=y
CONFIG_PMIC_RK8XX=y
CONFIG_REGULATOR_PWM=y
CONFIG_DM_REGULATOR_FIXED=y
CONFIG_REGULATOR_RK8XX=y
CONFIG_PWM_ROCKCHIP=y
CONFIG_RAM=y
CONFIG_SPL_RAM=y
CONFIG_ROCKCHIP_SDRAM_COMMON=y
CONFIG_DM_RESET=y
CONFIG_BAUDRATE=1500000
CONFIG_DEBUG_UART_BASE=0xFF1A0000
CONFIG_DEBUG_UART_CLOCK=24000000
CONFIG_DEBUG_UART_SHIFT=2
CONFIG_SYSRESET=y
CONFIG_USB=y
CONFIG_USB_XHCI_HCD=y
CONFIG_USB_XHCI_DWC3=y
CONFIG_USB_EHCI_HCD=y
CONFIG_USB_EHCI_GENERIC=y
CONFIG_USB_OHCI_HCD=y
CONFIG_USB_OHCI_GENERIC=y
CONFIG_USB_DWC3=y
CONFIG_USB_DWC3_GADGET=y
CONFIG_USB_STORAGE=y
CONFIG_USB_GADGET=y
CONFIG_USB_GADGET_DOWNLOAD=y
CONFIG_USB_GADGET_MANUFACTURER="Rockchip"
CONFIG_USB_GADGET_VENDOR_NUM=0x2207
CONFIG_USB_GADGET_PRODUCT_NUM=0x330a
CONFIG_USB_HOST_ETHER=y
CONFIG_USB_ETHER_ASIX=y
CONFIG_USB_ETHER_ASIX88179=y
CONFIG_USB_ETHER_MCS7830=y
CONFIG_USB_ETHER_RTL8152=y
CONFIG_USB_ETHER_SMSC95XX=y
CONFIG_DM_VIDEO=y
CONFIG_DISPLAY=y
CONFIG_DRM_ROCKCHIP=y
CONFIG_DRM_ROCKCHIP_DW_MIPI_DSI=y
CONFIG_DRM_ROCKCHIP_ANALOGIX_DP=y
CONFIG_LCD=y
CONFIG_USE_TINY_PRINTF=y
CONFIG_SPL_TINY_MEMSET=y
CONFIG_ERRNO_STR=y

root@zhengyang:/work/sambashare/rk3399/u-boot# cat u-boot.its
/*
 * Copyright (C) 2017 Fuzhou Rockchip Electronics Co., Ltd
 *
 * Minimal dts for a SPL FIT image payload.
 *
 * SPDX-License-Identifier: GPL-2.0+  X11
 */
/dts-v1/;

/ {
        description = "Configuration to load ATF before U-Boot";
        #address-cells = <1>;

        images {
                uboot {
                        description = "U-Boot (64-bit)";
                        data = /incbin/("u-boot-nodtb.bin");
                        type = "standalone";
                        os = "U-Boot";
                        arch = "arm64";
                        compression = "none";
                        load = <0x00200000>;
                        hash {
                                algo = "sha256";
                        };
                };

                atf@1 {
                        description = "ARM Trusted Firmware";
                        data = /incbin/("bl31_0x00040000.bin");
                        type = "firmware";
                        arch = "arm64";
                        os = "arm-trusted-firmware";
                        compression = "none";
                        load = <0x00040000>;
                        entry = <0x00040000>;
                        hash {
                                algo = "sha256";
                        };
                };

                atf@2 {
                        description = "ARM Trusted Firmware";
                        data = /incbin/("bl31_0xff3b0000.bin");
                        type = "firmware";
                        arch = "arm64";
                        os = "arm-trusted-firmware";
                        compression = "none";
                        load = <0xff3b0000>;
                        hash {
                                algo = "sha256";
                        };
                };

                atf@3 {
                        description = "ARM Trusted Firmware";
                        data = /incbin/("bl31_0xff8c0000.bin");
                        type = "firmware";
                        arch = "arm64";
                        os = "arm-trusted-firmware";
                        compression = "none";
                        load = <0xff8c0000>;
                        hash {
                                algo = "sha256";
                        };
                };

                atf@4 {
                        description = "ARM Trusted Firmware";
                        data = /incbin/("bl31_0xff8c1000.bin");
                        type = "firmware";
                        arch = "arm64";
                        os = "arm-trusted-firmware";
                        compression = "none";
                        load = <0xff8c1000>;
                        hash {
                                algo = "sha256";
                        };
                };

                atf@5 {
                        description = "ARM Trusted Firmware";
                        data = /incbin/("bl31_0xff8c2000.bin");
                        type = "firmware";
                        arch = "arm64";
                        os = "arm-trusted-firmware";
                        compression = "none";
                        load = <0xff8c2000>;
                        hash {
                                algo = "sha256";
                        };
                };

                fdt {
                        description = "U-Boot device tree blob";
                        data = /incbin/("u-boot.dtb");
                        type = "flat_dt";
                        arch = "arm64";
                        compression = "none";
                        hash {
                                algo = "sha256";
                        };
                };


        };

        configurations {
                default = "config";
                config {
                        description = "Rockchip armv8 with ATF";
                        rollback-index = <0x0>;
                        firmware = "atf@1";
                        loadables = "uboot", "atf@2" , "atf@3" , "atf@4" , "atf@5" , "atf@6" ;
                        fdt = "fdt";
                        signature {
                                algo = "sha256,rsa2048";
                                padding = "pss";
                                key-name-hint = "dev";
                                sign-images = "fdt", "firmware", "loadables";
                        };
                };

        };


};

DDR Version 1.27 20211018
In
Channel 0: LPDDR3, 800MHz
CS = 0
MR0=0x58
MR1=0x58
MR2=0x58
MR3=0x58
MR4=0x2
MR5=0x1
MR6=0x5
MR7=0x0
MR8=0x1F
MR9=0x1F
MR10=0x1F
MR11=0x1F
MR12=0x1F
MR13=0x1F
MR14=0x1F
MR15=0x1F
MR16=0x1F
CS = 1
MR0=0x58
MR1=0x58
MR2=0x58
MR3=0x58
MR4=0x2
MR5=0x1
MR6=0x5
MR7=0x0
MR8=0x1F
MR9=0x1F
MR10=0x1F
MR11=0x1F
MR12=0x1F
MR13=0x1F
MR14=0x1F
MR15=0x1F
MR16=0x1F
Bus Width=32 Col=10 Bank=8 Row=15/15 CS=2 Die Bus-Width=32 Size=2048MB
Channel 1: LPDDR3, 800MHz
CS = 0
MR0=0x58
MR1=0x58
MR2=0x58
MR3=0x58
MR4=0x2
MR5=0x1
MR6=0x5
MR7=0x0
MR8=0x1F
MR9=0x1F
MR10=0x1F
MR11=0x1F
MR12=0x1F
MR13=0x1F
MR14=0x1F
MR15=0x1F
MR16=0x1F
CS = 1
MR0=0x58
MR1=0x58
MR2=0x58
MR3=0x58
MR4=0x2
MR5=0x1
MR6=0x5
MR7=0x0
MR8=0x1F
MR9=0x1F
MR10=0x1F
MR11=0x1F
MR12=0x1F
MR13=0x1F
MR14=0x1F
MR15=0x1F
MR16=0x1F
Bus Width=32 Col=10 Bank=8 Row=15/15 CS=2 Die Bus-Width=32 Size=2048MB
256B stride
ch 0 ddrconfig = 0x101, ddrsize = 0x2020
ch 1 ddrconfig = 0x101, ddrsize = 0x2020
pmugrf_os_reg[2] = 0x3AA0DAA0, stride = 0xD
OUT
Boot1 Release Time: Jun  2 2020 15:02:17, version: 1.26
CPUId = 0x0
SdmmcInit=2 0
BootCapSize=100000
UserCapSize=14910MB
FwPartOffset=2000 , 100000
UsbBoot ...73858
powerOn 86071

=> print
arch=arm
autoload=no
baudrate=150000
board=evb_rk3399
board_name=evb_rk3399
boot_a_script=load ${devtype} ${devnum}:${distro_bootpart} ${scriptaddr} ${prefix}${script}; source ${scriptaddr}
boot_efi_binary=load ${devtype} ${devnum}:${distro_bootpart} ${kernel_addr_r} efi/boot/bootaa64.efi; if fdt addr ${fdt_addr_r}; then bootefi ${kernel_addr_r} ${fdt_addr_r};else bootefi ${kernel_addr_r} ${fdtcontroladdr};fi
boot_extlinux=sysboot ${devtype} ${devnum}:${distro_bootpart} any ${scriptaddr} ${prefix}extlinux/extlinux.conf
boot_net_usb_start=usb start
boot_prefixes=/ /boot/
boot_script_dhcp=boot.scr.uimg
boot_scripts=boot.scr.uimg boot.scr
boot_targets=mmc1 mmc0 usb0 pxe dhcp
bootargs= root=/dev/mmcblk1p7 rw rootfstype=ext4 data=/dev/mmcblk1p8 consoleblank=0 cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory swapaccount=1 mtdparts=rk29xxnand:0x00002000@0x00002000(uboot),0x00002000@0x00004000(trust),0x00002000@0x00006000(misc),0x00006000@0x00008000(resource),0x00010000@0x0000e000(kernel),0x00010000@0x0001e000(boot),0x00c80000@0x00030000(rootfs),-@0x00cb0000(userdata) storagemedia=emmc androidboot.storagemedia=emmc androidboot.mode=normal
bootcmd=boot_android ${devtype} ${devnum};boot_fit;bootrkp;run distro_bootcmd;
bootcmd_dhcp=run boot_net_usb_start; if dhcp ${scriptaddr} ${boot_script_dhcp}; then source ${scriptaddr}; fi;setenv efi_fdtfile ${fdtfile}; setenv efi_old_vci ${bootp_vci};setenv efi_old_arch ${bootp_arch};setenv bootp_vci PXEClient:Arch:00011:UNDI:003000;setenv bootp_arch 0xb;if dhcp ${kernel_addr_r}; then tftpboot ${fdt_addr_r} dtb/${efi_fdtfile};if fdt addr ${fdt_addr_r}; then bootefi ${kernel_addr_r} ${fdt_addr_r}; else bootefi ${kernel_addr_r} ${fdtcontroladdr};fi;fi;setenv bootp_vci ${efi_old_vci};setenv bootp_arch ${efi_old_arch};setenv efi_fdtfile;setenv efi_old_arch;setenv efi_old_vci;
bootcmd_mmc0=setenv devnum 0; run mmc_boot
bootcmd_mmc1=setenv devnum 1; run mmc_boot
bootcmd_pxe=run boot_net_usb_start; dhcp; if pxe get; then pxe boot; fi
bootcmd_usb0=setenv devnum 0; run usb_boot
bootdelay=5
cpu=armv8
cpuid#=544d533632342e303000000000050607
devnum=0
devtype=mmc
distro_bootcmd=for target in ${boot_targets}; do run bootcmd_${target}; done
efi_dtb_prefixes=/ /dtb/ /dtb/current/
eth1addr=ce:ff:bf:e6:3b:7d
ethaddr=ca:ff:bf:e6:3b:7d
fdt_addr_r=0x08300000
fdtcontroladdr=0xf3d87a20
kernel_addr_r=0x00280000
load_efi_dtb=load ${devtype} ${devnum}:${distro_bootpart} ${fdt_addr_r} ${prefix}${efi_fdtfile}
mmc_boot=if mmc dev ${devnum}; then setenv devtype mmc; run scan_dev_for_boot_part; fi
partitions=uuid_disk=${uuid_gpt_disk};name=loader1,start=32K,size=4000K,uuid=${uuid_gpt_loader1};name=loader2,start=8MB,size=4MB,uuid=${uuid_gpt_loader2};name=trust,size=4M,uuid=${uuid_gpt_atf};name=boot,size=112M,bootable,uuid=${uuid_gpt_boot};name=rootfs,size=-,uuid=B921B045-1DF0-41C3-AF44-4C6F280D3FAE;
pxefile_addr_r=0x00600000
ramdisk_addr_r=0x0a200000
rkimg_bootdev=if mmc dev 1 && rkimgtest mmc 1; then setenv devtype mmc; setenv devnum 1; echo Boot from SDcard;elif mmc dev 0; then setenv devtype mmc; setenv devnum 0;elif mtd_blk dev 0; then setenv devtype mtd; setenv devnum 0;elif mtd_blk dev 1; then setenv devtype mtd; setenv devnum 1;elif mtd_blk dev 2; then setenv devtype mtd; setenv devnum 2;elif rknand dev 0; then setenv devtype rknand; setenv devnum 0;elif rksfc dev 0; then setenv devtype spinand; setenv devnum 0;elif rksfc dev 1; then setenv devtype spinor; setenv devnum 1;elsesetenv devtype ramdisk; setenv devnum 0;fi;
scan_dev_for_boot=echo Scanning ${devtype} ${devnum}:${distro_bootpart}...; for prefix in ${boot_prefixes}; do run scan_dev_for_extlinux; run scan_dev_for_scripts; done;run scan_dev_for_efi;
scan_dev_for_boot_part=part list ${devtype} ${devnum} -bootable devplist; env exists devplist || setenv devplist 1; for distro_bootpart in ${devplist}; do if fstype ${devtype} ${devnum}:${distro_bootpart} bootfstype; then run scan_dev_for_boot; fi; done
scan_dev_for_efi=setenv efi_fdtfile ${fdtfile}; for prefix in ${efi_dtb_prefixes}; do if test -e ${devtype} ${devnum}:${distro_bootpart} ${prefix}${efi_fdtfile}; then run load_efi_dtb; fi;done;if test -e ${devtype} ${devnum}:${distro_bootpart} efi/boot/bootaa64.efi; then echo Found EFI removable media binary efi/boot/bootaa64.efi; run boot_efi_binary; echo EFI LOAD FAILED: continuing...; fi; setenv efi_fdtfile
scan_dev_for_extlinux=if test -e ${devtype} ${devnum}:${distro_bootpart} ${prefix}extlinux/extlinux.conf; then echo Found ${prefix}extlinux/extlinux.conf; run boot_extlinux; echo SCRIPT FAILED: continuing...; fi
scan_dev_for_scripts=for script in ${boot_scripts}; do if test -e ${devtype} ${devnum}:${distro_bootpart} ${prefix}${script}; then echo Found U-Boot script ${prefix}${script}; run boot_a_script; echo SCRIPT FAILED: continuing...; fi; done
scriptaddr=0x00500000
serial#=137825cca4f2db8f
soc=rockchip
stderr=serial,vidconsole
stdout=serial,vidconsole
usb_boot=usb start; if usb dev ${devnum}; then setenv devtype usb; run scan_dev_for_boot_part; fi
vendor=rockchip

Environment size: 5132/32764 bytes

#!/bin/bash
#
# Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd
#
# SPDX-License-Identifier: GPL-2.0
#

set -e
JOB=`sed -n "N;/processor/p" /proc/cpuinfo|wc -l`
SUPPORT_LIST=`ls configs/*[r,p][x,v,k][0-9][0-9]*_defconfig`
CMD_ARGS=$1

########################################### User can modify #############################################
RKBIN_TOOLS=../rkbin/tools
CROSS_COMPILE_ARM32=../prebuilts/gcc/linux-x86/arm/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-
CROSS_COMPILE_ARM64=../prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-
########################################### User not touch #############################################
# Declare global INI file searching index name for every chip, update in select_chip_info()
RKCHIP=
RKCHIP_LABEL=
RKCHIP_LOADER=
RKCHIP_TRUST=
INI_TRUST=
INI_LOADER=

# Declare rkbin repository path, updated in prepare()
RKBIN=

# Declare global toolchain path for CROSS_COMPILE, updated in select_toolchain()
TOOLCHAIN=
TOOLCHAIN_NM=
TOOLCHAIN_OBJDUMP=
TOOLCHAIN_ADDR2LINE=

# Declare global plaform configure, updated in fixup_platform_configure()
PLAT_RSA=
PLAT_SHA=
PLAT_UBOOT_SIZE=
PLAT_TRUST_SIZE=
PLAT_TYPE="RKFW" # default

SRCTREE=`pwd`
SCRIPT_FIT="${SRCTREE}/scripts/fit.sh"

SCRIPT_ATF="${SRCTREE}/scripts/atf.sh"
SCRIPT_TOS="${SRCTREE}/scripts/tos.sh"
SCRIPT_SPL="${SRCTREE}/scripts/spl.sh"
SCRIPT_UBOOT="${SRCTREE}/scripts/uboot.sh"
SCRIPT_LOADER="${SRCTREE}/scripts/loader.sh"
SCRIPT_DECOMP="${SRCTREE}/scripts/decomp.sh"
CC_FILE=".cc"
REP_DIR="./rep"
#########################################################################################################
function help()
{
        echo
        echo "Usage:"
        echo "  ./make.sh [board|sub-command]"
        echo
        echo "   - board:        board name of defconfig"
        echo "   - sub-command:  elf*|loader|trust|uboot|--spl|--tpl|itb|map|sym|<addr>"
        echo "   - ini:          ini file to pack trust/loader"
        echo
        echo "Output:"
        echo "   When board built okay, there are uboot/trust/loader images in current directory"
        echo
        echo "Example:"
        echo
        echo "1. Build:"
        echo "  ./make.sh evb-rk3399               --- build for evb-rk3399_defconfig"
        echo "  ./make.sh firefly-rk3288           --- build for firefly-rk3288_defconfig"
        echo "  ./make.sh EXT_DTB=rk-kernel.dtb    --- build with exist .config and external dtb"
        echo "  ./make.sh                          --- build with exist .config"
        echo "  ./make.sh env                      --- build envtools"
        echo
        echo "2. Pack:"
        echo "  ./make.sh uboot                    --- pack uboot.img"
        echo "  ./make.sh trust                    --- pack trust.img"
        echo "  ./make.sh trust <ini>              --- pack trust img with assigned ini file"
        echo "  ./make.sh loader                   --- pack loader bin"
        echo "  ./make.sh loader <ini>             --- pack loader img with assigned ini file"
        echo "  ./make.sh --spl                    --- pack loader with u-boot-spl.bin"
        echo "  ./make.sh --tpl                    --- pack loader with u-boot-tpl.bin"
        echo "  ./make.sh --tpl --spl              --- pack loader with u-boot-tpl.bin and u-boot-spl.bin"
        echo
        echo "3. Debug:"
        echo "  ./make.sh elf                      --- dump elf file with -D(default)"
        echo "  ./make.sh elf-S                    --- dump elf file with -S"
        echo "  ./make.sh elf-d                    --- dump elf file with -d"
        echo "  ./make.sh elf-*                    --- dump elf file with -*"
        echo "  ./make.sh <no reloc_addr>          --- unwind address(no relocated)"
        echo "  ./make.sh <reloc_addr-reloc_off>   --- unwind address(relocated)"
        echo "  ./make.sh map                      --- cat u-boot.map"
        echo "  ./make.sh sym                      --- cat u-boot.sym"
}

function filt_val()
{
        sed -n "/${1}=/s/${1}=//p" $2 | tr -d 'r' | tr -d '"'
}

function prepare()
{
        if [ -d ${RKBIN_TOOLS} ]; then
                absolute_path=$(cd `dirname ${RKBIN_TOOLS}`; pwd)
                RKBIN=${absolute_path}
        else
                echo "ERROR: No ../rkbin repository"
                exit 1
        fi

        if grep -Eq ''^CONFIG_ARM64=y'|'^CONFIG_ARM64_BOOT_AARCH32=y'' .config ; then
                ARM64_TRUSTZONE="y"
        fi

        if grep  -q '^CONFIG_ROCKCHIP_FIT_IMAGE_PACK=y' .config ; then
                PLAT_TYPE="FIT"
        elif grep  -q '^CONFIG_SPL_DECOMP_HEADER=y' .config ; then
                PLAT_TYPE="DECOMP"
        fi
}

function process_args()
{
        while [ $# -gt 0 ]; do
                case $1 in
                        *help|--h|-h)
                                help
                                exit 0
                                ;;
                        CROSS_COMPILE=*)  # set CROSS_COMPILE
                                ARG_COMPILE="y"
                                CROSS_COMPILE_ARM32=${1#*=}
                                CROSS_COMPILE_ARM64=${1#*=}
                                if [ ${CMD_ARGS} == $1 ]; then
                                        shift 1
                                        CMD_ARGS=$1
                                else
                                        shift 1
                                fi
                                ;;
                        # '': build with exist .config
                        # loader|trust|uboot: pack image
                        # debug*|map|sym|elf*|nm: debug command
                        # env: build env tool
                        # itb: pack itb image
                        # fit: pack non-secure uboot.img && boot.img
                        ''|loader|trust|uboot|debug*|itb|env|fit|map|sym|elf*|nm)
                                if [ "$2" == "spl" -o "$2" == "tpl" ]; then
                                        ARG_TSPL=$2
                                        shift 1
                                fi
                                shift 1
                                ;;
                        # trust/loader ini files for packing trust.img/loader.img
                        *.ini|*.INI)
                                if [ ! -f $1 ]; then
                                        echo "ERROR: No $1"
                                fi
                                if grep -q 'CODE471_OPTION' $1 ; then
                                        ARG_INI_LOADER=$1
                                elif grep -Eq ''BL31_OPTION'|'TOS'' $1 ; then
                                        ARG_INI_TRUST=$1
                                fi
                                shift 1
                                ;;
                        --sz-trust) # set trust size
                                ARG_TRUST_SIZE="--size $2 $3"
                                shift 3
                                ;;
                        --sz-uboot) # set uboot size
                                ARG_UBOOT_SIZE="--size $2 $3"
                                shift 3
                                ;;
                        --raw-compile)  # FIT: build but not pack image
                                ARG_RAW_COMPILE="y"
                                shift 1
                                ;;
                        --no-uboot) # FIT: pack uboot.img without u-boot
                                ARG_NO_UBOOT="y"
                                shift 1
                                ;;
                        --idblock)  # pack idblock.bin
                                shift 1
                                ;;
                        --tpl|tpl)  # use tpl file
                                ARG_TPL_BIN="tpl/u-boot-tpl.bin"
                                shift 1
                                ;;
                        --spl|spl*) # use spl file
                                ARG_SPL_BIN="spl/u-boot-spl.bin"
                                shift 1
                                ;;
                        --uboot|--fdt|--optee|--mcu|--bl31) # uboot.img components
                                mkdir -p ${REP_DIR}
                                if [ ! -f $2 ]; then
                                        echo "ERROR: No $2"
                                        exit 1
                                fi
                                if [ "$1" == "--uboot" ]; then
                                        cp $2 ${REP_DIR}/u-boot-nodtb.bin
                                elif [ "$1" == "--fdt" ]; then
                                        cp $2 ${REP_DIR}/u-boot.dtb
                                elif [ "$1" == "--optee" ]; then
                                        cp $2 ${REP_DIR}/tee.bin
                                elif [ "$1" == "--mcu" ]; then
                                        cp $2 ${REP_DIR}/mcu.bin
                                elif [ "$1" == "--bl31" ]; then
                                        if ! file $2 | grep 'ELF ' >/dev/null 2>&1 ; then
                                                echo "ERROR: $2 is not a bl31.elf file"
                                                exit 1
                                        fi
                                        cp $2 ${REP_DIR}/bl31.elf
                                fi
                                shift 2
                                ;;
                        *)
                                #1. FIT scripts args
                                NUM=$(${SCRIPT_FIT} --args $1)
                                if  [ ${NUM} -ne 0 ]; then
                                        [ ${NUM} -eq 1 ] && ARG_LIST_FIT="${ARG_LIST_FIT} $1"
                                        [ ${NUM} -eq 2 ] && ARG_LIST_FIT="${ARG_LIST_FIT} $1 $2"
                                        shift ${NUM}
                                        continue
                                #2. unwind function address
                                elif [ -z $(echo $1 | sed 's/[0-9,a-f,A-F,x,X,-]//g') ]; then
                                        ARG_FUNCADDR=$1
                                #3. make defconfig
                                else
                                        ARG_BOARD=$1
                                        if [ ! -f configs/${ARG_BOARD}_defconfig -a ! -f configs/${ARG_BOARD}.config ]; then
                                                echo -e "n${SUPPORT_LIST}n"
                                                echo "ERROR: No configs/${ARG_BOARD}_defconfig"
                                                exit 1
                                        elif [ -f configs/${ARG_BOARD}.config ]; then
                                                BASE1_DEFCONFIG=`filt_val "CONFIG_BASE_DEFCONFIG" configs/${ARG_BOARD}.config`
                                                BASE0_DEFCONFIG=`filt_val "CONFIG_BASE_DEFCONFIG" configs/${BASE1_DEFCONFIG}`
                                                MAKE_CMD="make ${BASE0_DEFCONFIG} ${BASE1_DEFCONFIG} ${ARG_BOARD}.config -j${JOB}"
                                                echo "## ${MAKE_CMD}"
                                                make ${BASE0_DEFCONFIG} ${BASE1_DEFCONFIG} ${ARG_BOARD}.config ${OPTION}
                                                rm -f ${CC_FILE}
                                        else
                                                MAKE_CMD="make ${ARG_BOARD}_defconfig -j${JOB}"
                                                echo "## ${MAKE_CMD}"
                                                make ${ARG_BOARD}_defconfig ${OPTION}
                                                rm -f ${CC_FILE}
                                        fi
                                fi
                                shift 1
                                ;;
                esac
        done

        if [ ! -f .config ]; then
                echo
                echo "ERROR: No .config"
                help
                exit 1
        fi
}

function select_toolchain()
{
        # If no outer CROSS_COMPILE, look for it from CC_FILE.
        if [ "${ARG_COMPILE}" != "y" ]; then
                if [ -f ${CC_FILE} ]; then
                        CROSS_COMPILE_ARM32=`cat ${CC_FILE}`
                        CROSS_COMPILE_ARM64=`cat ${CC_FILE}`
                else
                        if grep -q '^CONFIG_ARM64=y' .config ; then
                                CROSS_COMPILE_ARM64=$(cd `dirname ${CROSS_COMPILE_ARM64}`; pwd)"/aarch64-linux-gnu-"
                        else
                                CROSS_COMPILE_ARM32=$(cd `dirname ${CROSS_COMPILE_ARM32}`; pwd)"/arm-linux-gnueabihf-"
                        fi
                fi
        fi

        if grep -q '^CONFIG_ARM64=y' .config ; then
                TOOLCHAIN=${CROSS_COMPILE_ARM64}
                TOOLCHAIN_NM=${CROSS_COMPILE_ARM64}nm
                TOOLCHAIN_OBJDUMP=${CROSS_COMPILE_ARM64}objdump
                TOOLCHAIN_ADDR2LINE=${CROSS_COMPILE_ARM64}addr2line
        else
                TOOLCHAIN=${CROSS_COMPILE_ARM32}
                TOOLCHAIN_NM=${CROSS_COMPILE_ARM32}nm
                TOOLCHAIN_OBJDUMP=${CROSS_COMPILE_ARM32}objdump
                TOOLCHAIN_ADDR2LINE=${CROSS_COMPILE_ARM32}addr2line
        fi

        if [ ! `which ${TOOLCHAIN}gcc` ]; then
                echo "ERROR: No find ${TOOLCHAIN}gcc"
                exit 1
        fi

        # save to CC_FILE
        if [ "${ARG_COMPILE}" == "y" ]; then
                echo "${TOOLCHAIN}" > ${CC_FILE}
        fi
}

#
# We select chip info to do:
#       1. RKCHIP:        fixup platform configure
#       2. RKCHIP_LOADER: search ini file to pack loader
#       3. RKCHIP_TRUST:  search ini file to pack trust
#       4. RKCHIP_LABEL:  show build message
#
function select_chip_info()
{
        # Read RKCHIP firstly from .config
        # The regular expression that matching:
        #  - PX30, PX3SE
        #  - RK????, RK????X
        #  - RV????
        CHIP_PATTERN='^CONFIG_ROCKCHIP_[R,P][X,V,K][0-9ESX]{1,5}'
        RKCHIP=`egrep -o ${CHIP_PATTERN} .config`

        # default
        RKCHIP=${RKCHIP##*_}
        RKCHIP_LOADER=${RKCHIP}
        RKCHIP_TRUST=${RKCHIP}
        RKCHIP_LABEL=`filt_val "CONFIG_CHIP_NAME" .config`
        if [ -z "${RKCHIP_LABEL}" ]; then
                RKCHIP_LABEL=${RKCHIP}
        fi
}

# Priority: default < CHIP_CFG_FIXUP_TABLE() < make.sh args
function fixup_platform_configure()
{
        U_KB=`filt_val "CONFIG_UBOOT_SIZE_KB" .config`
        U_NUM=`filt_val "CONFIG_UBOOT_NUM" .config`
        T_KB=`filt_val "CONFIG_TRUST_SIZE_KB" .config`
        T_NUM=`filt_val "CONFIG_TRUST_NUM" .config`
        SHA=`filt_val "CONFIG_TRUST_SHA_MODE" .config`
        RSA=`filt_val "CONFIG_TRUST_RSA_MODE" .config`

        # .config
        PLAT_UBOOT_SIZE="--size ${U_KB} ${U_NUM}"
        PLAT_TRUST_SIZE="--size ${T_KB} ${T_NUM}"
        PLAT_SHA="--sha ${SHA}"
        PLAT_RSA="--rsa ${RSA}"

        # ./make.sh args
        if [ ! -z "${ARG_UBOOT_SIZE}" ]; then
                PLAT_UBOOT_SIZE=${ARG_UBOOT_SIZE}
        fi
        if [ ! -z "${ARG_TRUST_SIZE}" ]; then
                PLAT_TRUST_SIZE=${ARG_TRUST_SIZE}
        fi
}

function select_ini_file()
{
        # default
        INI_LOADER=${RKBIN}/RKBOOT/${RKCHIP_LOADER}MINIALL.ini
        if [ "${ARM64_TRUSTZONE}" == "y" ]; then
                INI_TRUST=${RKBIN}/RKTRUST/${RKCHIP_TRUST}TRUST.ini
        else
                INI_TRUST=${RKBIN}/RKTRUST/${RKCHIP_TRUST}TOS.ini
        fi

        # defconfig
        NAME=`filt_val "CONFIG_LOADER_INI" .config`
        if [ ! -z "${NAME}" ]; then
                INI_LOADER=${RKBIN}/RKBOOT/${NAME}
        fi
        NAME=`filt_val "CONFIG_TRUST_INI" .config`
        if [ ! -z "${NAME}" ]; then
                INI_TRUST=${RKBIN}/RKTRUST/${NAME}
        fi

        # args
        if [ ! -z "${ARG_INI_TRUST}" ]; then
                INI_TRUST=${ARG_INI_TRUST}
        fi
        if [ ! -z "${ARG_INI_LOADER}" ]; then
                INI_LOADER=${ARG_INI_LOADER}
        fi
}

function sub_commands()
{
        # skip "--" parameter, such as "--rollback-index-..."
        if [[ ${CMD_ARGS} != --* ]]; then
                CMD=${CMD_ARGS%-*}
                ARG=${CMD_ARGS#*-}
        else
                CMD=${CMD_ARGS}
        fi

        if [ "${ARG_TSPL}" == "tpl" -o "${ARG_TSPL}" == "spl" ]; then
                ELF=`find -name u-boot-${ARG_TSPL}`
                MAP=`find -name u-boot-${ARG_TSPL}.map`
                SYM=`find -name u-boot-${ARG_TSPL}.sym`
        else
                ELF=u-boot
                MAP=u-boot.map
                SYM=u-boot.sym
        fi

        case ${CMD} in
                elf|nm)
                        if [ "${CMD}" == "nm" ]; then
                                echo -e "n${ELF}:     file format elfn"
                                ${TOOLCHAIN_NM} -r --size ${ELF} | grep -iv 'b' | less
                        else
                                if [ "${CMD}" == "elf" -a "${ARG}" == "elf" ]; then
                                        ARG=D # default
                                fi
                                ${TOOLCHAIN_OBJDUMP} -${ARG} ${ELF} | less
                        fi
                        exit 0
                        ;;
                map|sym)
                        if [ ${CMD} == "map" ]; then
                                cat ${MAP} | less
                        else
                                cat ${SYM} | less
                        fi
                        exit 0
                        ;;
                debug)
                        ./scripts/rkpatch.sh ${ARG}
                        exit 0
                        ;;
                fit)
                        # Non-secure
                        ${SCRIPT_FIT} --boot_img_dir images/ ${ARG_LIST_FIT}
                        exit 0
                        ;;
                uboot)
                        pack_uboot_image
                        exit 0
                        ;;
                trust)
                        pack_trust_image
                        exit 0
                        ;;
                loader)
                        pack_loader_image
                        exit 0
                        ;;
                itb)
                        pack_uboot_itb_image
                        exit 0
                        ;;
                env)
                        make CROSS_COMPILE=${TOOLCHAIN} envtools
                        exit 0
                        ;;
                --idblock)
                        pack_idblock
                        exit 0
                        ;;
                --tpl|--spl|tpl|spl)
                        pack_spl_loader_image
                        exit 0
                        ;;
                *)
                        unwind_addr_or_continue
                        ;;
        esac
}

function unwind_addr_or_continue()
{
        FUNCADDR=${ARG_FUNCADDR}
        RELOCOFF=${FUNCADDR#*-}
        FUNCADDR=${FUNCADDR%-*}

        if [ -z $(echo ${FUNCADDR} | sed 's/[0-9,a-f,A-F,x,X,-]//g') ] && [ ${FUNCADDR} ]; then
                # With prefix: '0x' or '0X'
                if [ `echo ${FUNCADDR} | sed -n "/0[x,X]/p" | wc -l` -ne 0 ]; then
                        FUNCADDR=`echo ${FUNCADDR} | awk '{ print strtonum($0) }'`
                        FUNCADDR=`echo "obase=16;${FUNCADDR}"|bc | tr '[A-Z]' '[a-z]'`
                fi
                if [ `echo ${RELOCOFF} | sed -n "/0[x,X]/p" | wc -l` -ne 0 ] && [ ${RELOCOFF} ]; then
                        RELOCOFF=`echo ${RELOCOFF} | awk '{ print strtonum($0) }'`
                        RELOCOFF=`echo "obase=16;${RELOCOFF}"|bc | tr '[A-Z]' '[a-z]'`
                fi

                # If reloc address is assigned, do sub
                if [ "${FUNCADDR}" != "${RELOCOFF}" ]; then
                        # Hex -> Dec -> SUB -> Hex
                        FUNCADDR=`echo $((16#${FUNCADDR}))`
                        RELOCOFF=`echo $((16#${RELOCOFF}))`
                        FUNCADDR=$((FUNCADDR-RELOCOFF))
                        FUNCADDR=$(echo "obase=16;${FUNCADDR}"|bc | tr '[A-Z]' '[a-z]')
                fi

                echo
                sed -n "/${FUNCADDR}/p" ${SYM}
                ${TOOLCHAIN_ADDR2LINE} -e ${ELF} ${FUNCADDR}
                exit 0
        fi
}

function pack_idblock()
{
        INI=${INI_LOADER}
        if [ ! -f ${INI} ]; then
                echo "ERROR: No ${INI}"
                exit 1
        fi

        # chip
        COMMON_H=`grep "_common.h:" include/autoconf.mk.dep | awk -F "/" '{ printf $3 }'`
        PLAT=${COMMON_H%_*}

        # file
        SPL_BIN=${RKBIN}/`filt_val "FlashBoot" ${INI}`
        TPL_BIN=${RKBIN}/`filt_val "FlashData" ${INI}`
        if [ ! -z "${ARG_SPL_BIN}" ]; then
                SPL_BIN=${ARG_SPL_BIN}
        fi
        if [ ! -z "${ARG_TPL_BIN}" ]; then
                TPL_BIN=${ARG_TPL_BIN}
        fi

        # pack
        rm idblock.bin -f
        ./tools/mkimage -n ${PLAT} -T rksd -d ${TPL_BIN}:${SPL_BIN} idblock.bin
        echo "Input:"
        echo "    ${INI}"
        echo "    ${TPL_BIN}"
        echo "    ${SPL_BIN}"
        echo
        echo "Pack ${PLAT} idblock.bin okay!"
        echo
}

function pack_uboot_itb_image()
{
        INI=${INI_TRUST}
        if [ ! -f ${INI} ]; then
                echo "ERROR: No ${INI}"
                exit 1
        fi

        if [ "${ARM64_TRUSTZONE}" == "y" ]; then
                BL31_ELF=`sed -n '/_bl31_/s/PATH=//p' ${INI} | tr -d 'r'`
                BL32_BIN=`sed -n '/_bl32_/s/PATH=//p' ${INI} | tr -d 'r'`
                rm bl31.elf tee.bin -rf
                cp ${RKBIN}/${BL31_ELF} bl31.elf
                if grep BL32_OPTION -A 1 ${INI} | grep SEC=1 ; then
                        cp ${RKBIN}/${BL32_BIN} tee.bin
                        TEE_OFFSET=`grep BL32_OPTION -A 3 ${INI} | grep ADDR= | awk -F "=" '{ printf $2 }' | tr -d 'r'`
                        TEE_ARG="-t ${TEE_OFFSET}"
                fi
        else
                # TOS
                TOS=`filt_val "TOS" ${INI}`
                TOSTA=`filt_val "TOSTA" ${INI}`
                if [ ! -z "${TOSTA}" ]; then
                        cp ${RKBIN}/${TOSTA} tee.bin
                elif [ ! -z "${TOS}" ]; then
                        cp ${RKBIN}/${TOS}   tee.bin
                else
                        echo "WARN: No tee bin"
                fi
                if [ ! -z "${TOSTA}" -o ! -z "${TOS}" ]; then
                        TEE_OFFSET=`filt_val "ADDR" ${INI}`
                        if [ "${TEE_OFFSET}" == "" ]; then
                                TEE_OFFSET=0x8400000
                        fi
                        TEE_ARG="-t ${TEE_OFFSET}"
                fi
        fi

        # MCUs
        for ((i=0; i<5; i++))
        do
                MCU_BIN="mcu${i}.bin"
                MCU_IDX="MCU${i}"

                # compatible: use "MCU" to replace "MCU0" if "MCU" is present.
                ENABLED=`awk -F"," '/MCU=/  { printf $3 }' ${INI} | tr -d ' '`
                if [ ${i} -eq 0 ]; then
                        ENABLED=`awk -F"," '/MCU=/  { printf $3 }' ${INI} | tr -d ' '`
                        if [ ! -z ${ENABLED} ]; then
                                MCU_IDX="MCU"
                        fi
                fi

                ENABLED=`awk -F "," '/'${MCU_IDX}'=/  { printf $3 }' ${INI} | tr -d ' '`
                if [ "${ENABLED}" == "enabled" -o "${ENABLED}" == "okay" ]; then
                        NAME=`awk -F "," '/'${MCU_IDX}'=/ { printf $1 }' ${INI} | tr -d ' ' | awk -F "=" '{ print $2 }'`
                        OFFS=`awk -F "," '/'${MCU_IDX}'=/ { printf $2 }' ${INI} | tr -d ' '`
                        cp ${RKBIN}/${NAME} ${MCU_BIN}
                        if [ -z ${OFFS} ]; then
                                echo "ERROR: No ${MCU_BIN} address in ${INI}"
                                exit 1
                        fi
                        MCU_ARG=${MCU_ARG}" -m${i} ${OFFS}"
                fi
        done

        # Loadables
        for ((i=0; i<5; i++))
        do
                LOAD_BIN="load${i}.bin"
                LOAD_IDX="LOAD${i}"
                ENABLED=`awk -F "," '/'${LOAD_IDX}'=/  { printf $3 }' ${INI} | tr -d ' '`
                if [ "${ENABLED}" == "enabled" -o "${ENABLED}" == "okay" ]; then
                        NAME=`awk -F "," '/'${LOAD_IDX}'=/ { printf $1 }' ${INI} | tr -d ' ' | awk -F "=" '{ print $2 }'`
                        OFFS=`awk -F "," '/'${LOAD_IDX}'=/ { printf $2 }' ${INI} | tr -d ' '`
                        cp ${RKBIN}/${NAME} ${LOAD_BIN}
                        if [ -z ${OFFS} ]; then
                                echo "ERROR: No ${LOAD_BIN} address in ${INI}"
                                exit 1
                        fi
                        LOAD_ARG=${LOAD_ARG}" -l${i} ${OFFS}"
                fi
        done

        # COMPRESSION
        COMPRESSION=`awk -F"," '/COMPRESSION=/  { printf $1 }' ${INI} | tr -d ' ' | cut -c 13-`
        if [ ! -z "${COMPRESSION}" -a "${COMPRESSION}" != "none" ]; then
                COMPRESSION_ARG="-c ${COMPRESSION}"
        fi

        if [ -d ${REP_DIR} ]; then
                mv ${REP_DIR}/* ./
        fi

        SPL_FIT_SOURCE=`filt_val "CONFIG_SPL_FIT_SOURCE" .config`
        if [ ! -z ${SPL_FIT_SOURCE} ]; then
                cp ${SPL_FIT_SOURCE} u-boot.its
        else
                SPL_FIT_GENERATOR=`filt_val "CONFIG_SPL_FIT_GENERATOR" .config`
                # *.py is the legacy one.
                if [[ ${SPL_FIT_GENERATOR} == *.py ]]; then
                        ${SPL_FIT_GENERATOR} u-boot.dtb > u-boot.its
                else
                        ${SPL_FIT_GENERATOR} ${TEE_ARG} ${COMPRESSION_ARG} ${MCU_ARG} ${LOAD_ARG} > u-boot.its
                fi
        fi

        ./tools/mkimage -f u-boot.its -E u-boot.itb >/dev/null 2>&1
        echo "pack u-boot.itb okay! Input: ${INI}"
        echo
}

function pack_spl_loader_image()
{
        rm -f *loader*.bin *download*.bin *idblock*.img
        cd ${RKBIN}
        DEF_PATH=${RKBIN}/`filt_val "^PATH" ${INI_LOADER}`
        IDB_PATH=${RKBIN}/`filt_val "IDB_PATH" ${INI_LOADER}`
        if [ ! -z "${ARG_SPL_BIN}" -a ! -z "${ARG_TPL_BIN}" ]; then
                ${SCRIPT_SPL} --ini ${INI_LOADER} --tpl ${SRCTREE}/${ARG_TPL_BIN} --spl ${SRCTREE}/${ARG_SPL_BIN}
        elif [ ! -z "${ARG_TPL_BIN}" ]; then
                ${SCRIPT_SPL} --ini ${INI_LOADER} --tpl ${SRCTREE}/${ARG_TPL_BIN}
        else
                ${SCRIPT_SPL} --ini ${INI_LOADER} --spl ${SRCTREE}/${ARG_SPL_BIN}
        fi
        cd -
        if [ -f ${DEF_PATH} ]; then
                mv ${DEF_PATH} ./
        fi
        if [ -f ${IDB_PATH} ]; then
                mv ${IDB_PATH} ./
        fi
}

function pack_uboot_image()
{
        rm u-boot.img u-boot-dtb.img -f
        LOAD_ADDR=`sed -n "/CONFIG_SYS_TEXT_BASE=/s/CONFIG_SYS_TEXT_BASE=//p" include/autoconf.mk|tr -d 'r'`
        if [ -z "${LOAD_ADDR}" ]; then
                # upstream U-Boot
                LOAD_ADDR=`grep CONFIG_SYS_TEXT_BASE include/generated/autoconf.h | awk '{ print $3 }' | tr -d 'r'`
        fi

        if [ -z "${LOAD_ADDR}" ]; then
                echo "ERROR: No CONFIG_SYS_TEXT_BASE for u-boot";
                exit 1
        fi

        ${SCRIPT_UBOOT} --load ${LOAD_ADDR} ${PLAT_UBOOT_SIZE}
}

function pack_loader_image()
{
        rm -f *loader*.bin *download*.bin *idblock*.img
        cd ${RKBIN}
        DEF_PATH=${RKBIN}/`filt_val "^PATH" ${INI_LOADER}`
        IDB_PATH=${RKBIN}/`filt_val "IDB_PATH" ${INI_LOADER}`
        ${SCRIPT_LOADER} --ini ${INI_LOADER}
        cd -
        if [ -f ${DEF_PATH} ]; then
                mv ${DEF_PATH} ./
        fi
        if [ -f ${IDB_PATH} ]; then
                mv ${IDB_PATH} ./
        fi
}

function pack_trust_image()
{
        DRAM_BASE=`filt_val "CONFIG_SYS_SDRAM_BASE" include/autoconf.mk`

        rm trust*.img -f
        cd ${RKBIN}
        if [ "${ARM64_TRUSTZONE}" == "y" ]; then
                ${SCRIPT_ATF} --ini ${INI_TRUST} ${PLAT_SHA} ${PLAT_RSA} ${PLAT_TRUST_SIZE}
        else
                ${SCRIPT_TOS} --ini ${INI_TRUST} --base ${DRAM_BASE} ${PLAT_TRUST_SIZE}
        fi
        cd -
        if [ -f ${RKBIN}/trust*.img ]; then
                mv ${RKBIN}/trust*.img ./
        fi
}

function pack_fit_image()
{
        # check host tools
        if ! which dtc >/dev/null 2>&1 ; then
                echo "ERROR: No 'dtc', please: apt-get install device-tree-compiler"
                exit 1
        elif [ "${ARM64_TRUSTZONE}" == "y" ]; then
                if ! which python2 >/dev/null 2>&1 ; then
                        echo "ERROR: No python2"
                        exit 1
                fi
        fi

        # If we don't plan to have uboot in uboot.img in case of: SPL => Trust => Kernel, creating empty files.
        if [ "${ARG_NO_UBOOT}" == "y" ]; then
                rm u-boot-nodtb.bin u-boot.dtb -f
                touch u-boot-nodtb.bin u-boot.dtb
        fi

        rm uboot.img trust*.img -rf
        ${SCRIPT_FIT} ${ARG_LIST_FIT} --chip ${RKCHIP_LABEL}

        rm ${REP_DIR} -rf
        echo "pack uboot.img okay! Input: ${INI_TRUST}"
}

function handle_args_late()
{
        ARG_LIST_FIT="${ARG_LIST_FIT} --ini-trust ${INI_TRUST} --ini-loader ${INI_LOADER}"
}

function clean_files()
{
        rm spl/u-boot-spl.dtb tpl/u-boot-tpl.dtb u-boot.dtb -f
        rm spl/u-boot-spl tpl/u-boot-tpl u-boot -f
}

function pack_images()
{
        if [ "${ARG_RAW_COMPILE}" != "y" ]; then
                if [ "${PLAT_TYPE}" == "FIT" ]; then
                        pack_fit_image ${ARG_LIST_FIT}
                elif [ "${PLAT_TYPE}" == "DECOMP" ]; then
                        ${SCRIPT_DECOMP} ${ARG_LIST_FIT} --chip ${RKCHIP_LABEL}
                else
                        pack_uboot_image
                        pack_trust_image
                        pack_loader_image
                fi
        fi
}

function finish()
{
        echo
        if [ "${ARG_BOARD}" == "" ]; then
                echo "Platform ${RKCHIP_LABEL} is build OK, with exist .config"
        else
                echo "Platform ${RKCHIP_LABEL} is build OK, with new .config(${MAKE_CMD})"
        fi
}

process_args $*
prepare
select_toolchain
select_chip_info
fixup_platform_configure
select_ini_file
handle_args_late
sub_commands
clean_files
make PYTHON=python2 CROSS_COMPILE=${TOOLCHAIN} all --jobs=${JOB}
pack_images
finish
echo ${TOOLCHAIN}
date