#!/bin/bash
set -e

localpath=$(cd $(dirname $0) && pwd)
build_system=lichee
[ -d $localpath/../../../device/config/chips ] && build_system=longan
[ -d $localpath/../../tools/pack/chips ] && build_system=lichee

echo "build_system: $build_system"

#Setup common variables
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabi-
if [ -n "`echo ${LICHEE_CHIP} | grep "sun5[0-9]i"`" ] && \
        [ "x${LICHEE_ARCH}" = "xarm64" ]; then
    export ARCH=arm64
    export CROSS_COMPILE=aarch64-linux-gnu-
fi

if [ -n "${LICHEE_TOOLCHAIN_PATH}" \
        -a -d "${LICHEE_TOOLCHAIN_PATH}" ]; then
    GCC=$(find ${LICHEE_TOOLCHAIN_PATH} -perm /a+x -a -regex '.*-gcc');
    export CROSS_COMPILE="${GCC%-*}-";
elif [ -n "${LICHEE_CROSS_COMPILER}" ]; then
    export CROSS_COMPILE="${LICHEE_CROSS_COMPILER}-"
fi

export AS=${CROSS_COMPILE}as
export LD=${CROSS_COMPILE}ld
export CC=${CROSS_COMPILE}gcc
export AR=${CROSS_COMPILE}ar
export NM=${CROSS_COMPILE}nm
export STRIP=${CROSS_COMPILE}strip
export OBJCOPY=${CROSS_COMPILE}objcopy
export OBJDUMP=${CROSS_COMPILE}objdump
export LOCALVERSION=""
export MKBOOTIMG=${LICHEE_TOOLS_DIR}/pack/pctools/linux/android/mkbootimg
if [ "x$CCACHE_DIR" != "x" ];then
    CCACHE_Y="ccache "
fi
MAKE="make CROSS_COMPILE="${CCACHE_Y}${CROSS_COMPILE}""

if [ -n "$ANDROID_CLANG_PATH" ]; then
    export PATH=$ANDROID_CLANG_PATH:$PATH
    MAKE="make CC=clang HOSTCC=clang NM=llvm-nm OBJCOPY=llvm-objcopy"
    ARCH_PREFIX=arm
    [ "x$ARCH" == "xarm64" ] && ARCH_PREFIX=aarch64
    if [ -n "$ANDROID_TOOLCHAIN_PATH" ]; then
        export CROSS_COMPILE=$ANDROID_TOOLCHAIN_PATH/$ARCH_PREFIX-linux-androidkernel-
        export CLANG_TRIPLE=$ARCH_PREFIX-linux-gnu-
    fi
fi

KERNEL_VERSION=`${MAKE} -s kernelversion -C ./`
LICHEE_KDIR=`pwd`
LICHEE_MOD_DIR=${LICHEE_KDIR}/output/lib/modules/${KERNEL_VERSION}
export LICHEE_KDIR

update_kern_ver()
{
    if [ -r include/generated/utsrelease.h ]; then
        KERNEL_VERSION=`cat include/generated/utsrelease.h |awk -F\" '{print $2}'`
    fi
    LICHEE_MOD_DIR=${LICHEE_KDIR}/output/lib/modules/${KERNEL_VERSION}
}

do_init_to_dts()
{
	local DTC_SRC_PATH=${LICHEE_KERN_DIR}/arch/${ARCH}/boot/dts
	if [ "x${ARCH}" == "xarm64" ]; then
		DTC_SRC_PATH=${DTC_SRC_PATH}/sunxi
	fi
	local DTC_DEP_BOARD1=${DTC_SRC_PATH}/.board.dtb.d.dtc.tmp
	local DTC_SRC_BOARD1=${DTC_SRC_PATH}/.board.dtb.dts.tmp
	local DTC_DEP_BOARD=${DTC_SRC_PATH}/.${LICHEE_CHIP}-${LICHEE_BOARD}.dtb.d.dtc.tmp
	local DTC_SRC_BOARD=${DTC_SRC_PATH}/.${LICHEE_CHIP}-${LICHEE_BOARD}.dtb.dts.tmp
	local DTC_DEP_BUSSINESS=${DTC_SRC_PATH}/.${LICHEE_CHIP}-${LICHEE_BUSSINESS}.dtb.d.dtc.tmp
	local DTC_SRC_BUSSINESS=${DTC_SRC_PATH}/.${LICHEE_CHIP}-${LICHEE_BUSSINESS}.dtb.dts.tmp
	local DTC_DEP_COMMON=${DTC_SRC_PATH}/.${LICHEE_CHIP}-soc.dtb.d.dtc.tmp
	local DTC_SRC_COMMON=${DTC_SRC_PATH}/.${LICHEE_CHIP}-soc.dtb.dts.tmp

	local DTC_COMPILER=${LICHEE_KERN_DIR}/scripts/dtc/dtc

	local DTC_INI_FILE_BASE=${LICHEE_BOARD_CONFIG_DIR}/sys_config.fex
	local DTC_INI_FILE=output/sys_config_fix.fex

	cp $DTC_INI_FILE_BASE $DTC_INI_FILE
	sed -i "s/\(\[dram\)_para\(\]\)/\1\2/g" $DTC_INI_FILE
	sed -i "s/\(\[nand[0-9]\)_para\(\]\)/\1\2/g" $DTC_INI_FILE

	if [ ! -f $DTC_COMPILER ]; then
		echo "Script_to_dts: Can not find dtc compiler.\n"
		exit 1
	fi

	if [ -f $DTC_DEP_BOARD1 ]; then
		printf "Script_to_dts: use board special dts file board.dts\n"
		DTC_DEP_FILE=${DTC_DEP_BOARD1}
		DTC_SRC_FILE=${DTC_SRC_BOARD1}
	elif [ -f $DTC_DEP_BOARD ]; then
		printf "Script_to_dts: use board special dts file ${LICHEE_CHIP}-${LICHEE_BOARD}.dts\n"
		DTC_DEP_FILE=${DTC_DEP_BOARD}
		DTC_SRC_FILE=${DTC_SRC_BOARD}
	elif [ -f $DTC_DEP_BUSSINESS ]; then
		printf "Script_to_dts: use bussiness special dts file ${LICHEE_CHIP}-${LICHEE_BUSSINESS}.dts\n"
		DTC_DEP_FILE=${DTC_DEP_BUSSINESS}
		DTC_SRC_FILE=${DTC_SRC_BUSSINESS}
	else
		printf "Script_to_dts: use common dts file ${LICHEE_CHIP}-soc.dts\n"
		DTC_DEP_FILE=${DTC_DEP_COMMON}
		DTC_SRC_FILE=${DTC_SRC_COMMON}
	fi

	local DTC_FLAGS="-W no-unit_address_vs_reg"

	if [ -d ${LICHEE_CHIP_CONFIG_DIR}/dtbo ];  then
		echo "sunxi_dtb create"
		$DTC_COMPILER ${DTC_FLAGS} -@ -O dtb -o ${LICHEE_KERN_DIR}/output/sunxi.dtb	\
			-b 0			\
			-i $DTC_SRC_PATH	\
			-F $DTC_INI_FILE	\
			-d $DTC_DEP_FILE $DTC_SRC_FILE
	else
		echo "sunxi_dtb create"
		$DTC_COMPILER -p 2048 ${DTC_FLAGS} -O dtb -o ${LICHEE_KERN_DIR}/output/sunxi.dtb	\
			-b 0			\
			-i $DTC_SRC_PATH	\
			-F $DTC_INI_FILE	\
			-d $DTC_DEP_FILE $DTC_SRC_FILE
	fi

	if [ $? -ne 0 ]; then
		echo "Conver script to dts failed"
		exit 1
	fi

	#restore the orignal dtsi
	if [ "x${LICHEE_LINUX_DEV}" = "xdragonboard" \
		-o "x${LICHEE_LINUX_DEV}" = "xdragonmat" ]; then
		local DTS_PATH=${LICHEE_KERN_DIR}/arch/${ARCH}/boot/dts
		[ "x${ARCH}" = "xarm64" ] && DTS_PATH=${LICHEE_KERN_DIR}/arch/${ARCH}/boot/dts/sunxi
		if [ -f ${DTS_PATH}/${LICHEE_CHIP}_bak.dtsi ];then
			rm -f ${DTS_PATH}/${LICHEE_CHIP}.dtsi
			mv  ${DTS_PATH}/${LICHEE_CHIP}_bak.dtsi  ${DTS_PATH}/${LICHEE_CHIP}.dtsi
		fi
	fi

	printf "Conver script to dts ok.\n"

	# It'is used for debug dtb
	$DTC_COMPILER ${DTC_FLAGS} -I dtb -O dts -o ${LICHEE_KERN_DIR}/output/.sunxi.dts ${LICHEE_KERN_DIR}/output/sunxi.dtb

	return
}

show_help()
{
    printf "
    Build script for Lichee platform

    Invalid Options:

    help         - show this help
    kernel       - build kernel
    modules      - build kernel module in modules dir
    clean        - clean kernel and modules

    "
}

build_nand()
{
    NAND_ROOT=${LICHEE_KDIR}/modules/nand

    ${MAKE} -C modules/nand LICHEE_MOD_DIR=${LICHEE_MOD_DIR} \
        LICHEE_KDIR=${LICHEE_KDIR} \
        CONFIG_CHIP_ID=${CONFIG_CHIP_ID} install

}

gpu_message()
{
    echo -ne "\033[34;1m"
    echo "[GPU]: $1"
    echo -ne "\033[0m"
}

build_gpu()
{
    GPU_TYPE=`fgrep CONFIG_SUNXI_GPU_TYPE ${LICHEE_KDIR}/.config 2>/dev/null | cut -d \" -f 2`
    if [ "X$GPU_TYPE" = "XNone" -o "X$GPU_TYPE" = "X" ]; then
        gpu_message "No GPU type is configured in ${LICHEE_KDIR}/.config."
        return
    fi

    gpu_message "Building $GPU_TYPE device driver..."

    if [ "X${LICHEE_PLATFORM}" = "Xandroid" -o "X${LICHEE_PLATFORM}" = "Xsecureandroid" ] ; then
        TMP_OUT=$OUT
        TMP_TOP=$TOP
        unset OUT
        unset TOP
    fi

    ${MAKE} -C modules/gpu LICHEE_MOD_DIR=${LICHEE_MOD_DIR} LICHEE_KDIR=${LICHEE_KDIR}

    if [ "X${LICHEE_PLATFORM}" = "Xandroid" -o "X${LICHEE_PLATFORM}" = "Xsecureandroid" ] ; then
        export OUT=$TMP_OUT
        export TOP=$TMP_TOP
    fi

    gpu_message "$GPU_TYPE device driver has been built."
}

clean_gpu()
{
    GPU_TYPE=`fgrep CONFIG_SUNXI_GPU_TYPE ${LICHEE_KDIR}/.config 2>/dev/null | cut -d \" -f 2`
    if [ "X$GPU_TYPE" = "XNone" -o "X$GPU_TYPE" = "X" ]; then
        gpu_message "No GPU type is configured in .config."
        return
    fi

    gpu_message "Cleaning $GPU_TYPE device driver..."
    ${MAKE} -C modules/gpu LICHEE_MOD_DIR=${LICHEE_MOD_DIR} LICHEE_KDIR=${LICHEE_KDIR} clean
    gpu_message "$GPU_TYPE device driver has been cleaned."
}

build_check()
{
    if [ "x$SUNXI_CHECK" = "x1" ];then
        SUNXI_SPARSE_CHECK=1
        SUNXI_SMATCH_CHECK=1
        SUNXI_STACK_CHECK=1
    fi

    if [ "x$SUNXI_SPARSE_CHECK" = "x1" ] && [ -f ../tools/codecheck/sparse/sparse ];then
        echo "\n\033[0;31;1mBuilding Round for sparse check...\033[0m\n\n"
        CHECK="../tools/codecheck/sparse/sparse"
        ${MAKE} CHECK=${CHECK} ARCH=${ARCH} -j${LICHEE_JLEVEL} \
                C=2 all modules 2>&1|tee output/build_sparse.txt
        cat output/build_sparse.txt|egrep -w '(warn|error|warning)' >output/warn_sparse.txt
    fi

    if [ "x$SUNXI_SMATCH_CHECK" = "x1" ]&& [ -f ../tools/codecheck/smatch/smatch ];then
        echo "\n\033[0;31;1mBuilding Round for smatch check...\033[0m\n\n"
        CHECK="../tools/codecheck/smatch/smatch --full-path --no-data -p=kkernel"
        ${MAKE} CHECK=${CHECK} ARCH=${ARCH} -j${LICHEE_JLEVEL} \
                C=2 all modules 2>&1|tee output/build_smatch.txt
        cat output/build_smatch.txt|egrep -w '(warn|error|warning)' >output/warn_smatch.txt
    fi

    if [ "x$SUNXI_STACK_CHECK" = "x1" ];then
        ${MAKE} ARCH=${ARCH} -j${LICHEE_JLEVEL} checkstack 2>&1 \
                |tee output/warn_stack.txt
    fi
}

build_dts()
{
    if [ ! -f .config ] ; then
        printf "\n\033[0;31;1mUsing default config ${LICHEE_KERN_DEFCONF_ABSOLUTE} ...\033[0m\n\n"
        ${MAKE} ARCH=${ARCH} defconfig KBUILD_DEFCONFIG=${LICHEE_KERN_DEFCONF_RELATIVE}
    fi

    echo "---build dts for ${LICHEE_CHIP} ${LICHEE_BOARD}-----"
    if [ "x${ARCH}" = "xarm" ];then
        dts_path="arch/arm/boot/dts"
    else
        dts_path="arch/arm64/boot/dts/sunxi"
        prefix="sunxi/"
    fi
    dtb_file=board.dtb
    dts_file=board.dts
    if [ ! -f $dts_path/$dts_file ];then
        dtb_file="${LICHEE_CHIP}-${LICHEE_BOARD}.dtb"
        dts_file="${LICHEE_CHIP}-${LICHEE_BOARD}.dts"
    fi
    if [ ! -f $dts_path/$dts_file ];then
        dts_file="${LICHEE_CHIP}-soc.dts"
        dtb_file="${LICHEE_CHIP}-soc.dtb"
    fi
    ${MAKE} ARCH=${ARCH} ${prefix}${dtb_file}
}

build_kernel()
{
    echo "Building kernel"

    cd ${LICHEE_KDIR}
    rm -rf output/
    echo "${LICHEE_MOD_DIR}"
    mkdir -p ${LICHEE_MOD_DIR}

    # uImage is arm architecture specific target
    local arch_target=""
    if [ "${ARCH}" = "arm" ]; then
        arch_target="uImage dtbs"
    else
        arch_target="all"
    fi

    #exchange sdc0 and sdc2 for dragonBoard card boot
    local check_cardboot=false
    local SYS_CONFIG_FILE=""
    if [ "x$build_system" == "xlichee" ]; then
        [ "x${LICHEE_PLATFORM}" == "xdragonboard" -o "x${LICHEE_PLATFORM}" == "xdragonmat" ] && check_cardboot=true
        SYS_CONFIG_FILE=$localpath/../../tools/pack/chips/${LICHEE_CHIP}/configs/${LICHEE_BOARD}/sys_config.fex
    else
        [ "x${LICHEE_PLATFORM}" == "xlinux" ] && [ "x${LICHEE_LINUX_DEV}" == "xdragonboard" -o "x${LICHEE_LINUX_DEV}" == "xdragonmat" ] && check_cardboot=true
        SYS_CONFIG_FILE=${LICHEE_BOARD_CONFIG_DIR}/sys_config.fex
    fi

    if [ "x$check_cardboot" == "xtrue" ]; then
        local DTS_PATH=./arch/${ARCH}/boot/dts
        [ "x$ARCH" == "xarm64" ] && DTS_PATH=$DTS_PATH/sunxi

        if [ -f ${DTS_PATH}/${LICHEE_CHIP}_bak.dtsi ];then
            mv ${DTS_PATH}/${LICHEE_CHIP}_bak.dtsi ${DTS_PATH}/${LICHEE_CHIP}.dtsi
        fi

        # if find dragonboard_test=1 in sys_config.fex ,then will exchange sdc0 and sdc2
        local card_boot=$(awk -F= '/^dragonboard_test[[:space:]]*=/{gsub(/[[:blank:]]*/,"",$2);print $2}' $SYS_CONFIG_FILE)
        if [ "x$card_boot" == "x1" ]; then
            echo "exchange sdc0 and sdc2 for dragonboard card boot"
            ./scripts/exchange-sdc0-sdc2-for-dragonboard.sh ${DTS_PATH}/${LICHEE_CHIP}.dtsi
        fi
    fi

    if [ ! -f .config ] ; then
        printf "\n\033[0;31;1mUsing default config ${LICHEE_KERN_DEFCONF_ABSOLUTE} ...\033[0m\n\n"
        ${MAKE} ARCH=${ARCH} defconfig KBUILD_DEFCONFIG=${LICHEE_KERN_DEFCONF_RELATIVE}
    fi

    if [ "x$PACK_TINY_ANDROID" = "xtrue" ]; then
        ARCH=${ARCH} scripts/kconfig/merge_config.sh .config \
            linaro/configs/sunxi-tinyandroid.conf
    fi

    if [ "x$PACK_BSPTEST" != "x" -o "x$BUILD_SATA" != "x" -o "x$LICHEE_LINUX_DEV" = "xsata" ]; then
        if [ -f linaro/configs/sunxi-common.conf ];then
            ARCH=${ARCH} scripts/kconfig/merge_config.sh .config \
                linaro/configs/sunxi-common.conf
        fi
        if [ -f linaro/configs/sunxi-sata.conf ];then
            ARCH=${ARCH} scripts/kconfig/merge_config.sh .config \
                linaro/configs/sunxi-sata.conf
        fi
        if [ -f linaro/configs/sunxi-sata-${LICHEE_CHIP}.conf ];then
            ARCH=${ARCH} scripts/kconfig/merge_config.sh .config \
                linaro/configs/sunxi-sata-${LICHEE_CHIP}.conf
        fi
        if [ -f linaro/configs/sunxi-sata-${ARCH}.conf ];then
            ARCH=${ARCH} scripts/kconfig/merge_config.sh .config \
                linaro/configs/sunxi-sata-${ARCH}.conf
        fi
    fi

    ${MAKE} ARCH=${ARCH} -j${LICHEE_JLEVEL} ${arch_target} modules
    build_check
    update_kern_ver
    do_init_to_dts
    #The Image is origin binary from vmlinux.
    if [ -f arch/${ARCH}/boot/Image ]; then
        cp -vf arch/${ARCH}/boot/Image output/bImage
    fi

    if [ -f arch/${ARCH}/boot/zImage ] || [ -f arch/${ARCH}/boot/uImage ]; then
        cp -vf arch/${ARCH}/boot/[zu]Image output/
    fi

    if [ -f arch/${ARCH}/boot/Image.gz ]; then
        cp -vf arch/${ARCH}/boot/Image.gz output/
    fi

    echo "Copy rootfs.cpio.gz for ${ARCH}"
    if [ "${ARCH}" = "arm" ]; then
        cp -f rootfs_32bit.cpio.gz output/rootfs.cpio.gz
    else
        cp -f rootfs.cpio.gz output/rootfs.cpio.gz
    fi

    cp .config output/

    tar -jcf output/vmlinux.tar.bz2 vmlinux
    for file in $(find drivers sound crypto block fs security net -name "*.ko"); do
        cp $file ${LICHEE_MOD_DIR}
    done
    cp -f Module.symvers ${LICHEE_MOD_DIR}

}

build_modules()
{

    echo "Building modules"

    if [ ! -f include/generated/utsrelease.h ]; then
        printf "Please build kernel first!\n"
        exit 1
    fi

    update_kern_ver
    build_nand
    build_gpu
}

regen_rootfs_cpio()
{
    echo "regenerate rootfs cpio"

    cd ${LICHEE_KDIR}/output
    if [ -x "../scripts/build_rootfs.sh" ]; then
        ../scripts/build_rootfs.sh e ./rootfs.cpio.gz > /dev/null
    else
        echo "No such file: scripts/build_rootfs.sh"
        exit 1
    fi

    mkdir -p ./skel/lib/modules/${KERNEL_VERSION}

    if [ -d ${LICHEE_KERN_DIR}/tools/efuse_api ];then
        ${MAKE} -C ${LICHEE_KERN_DIR}/tools/efuse_api INSTALL_PATH=$LICHEE_PLAT_OUT/rootfs_def/bin install
    fi

    if [ -e ${LICHEE_MOD_DIR}/nand.ko ]; then
        cp ${LICHEE_MOD_DIR}/nand.ko ./skel/lib/modules/${KERNEL_VERSION}
        if [ $? -ne 0 ]; then
            echo "copy nand module error: $?"
            exit 1
        fi
    fi

    ko_file=`find ./skel/lib/modules/$KERNEL_VERSION/ -name *.ko`
    if [ ! -z "$ko_file" ]; then
            ${STRIP} -d ./skel/lib/modules/$KERNEL_VERSION/*.ko
    fi

    rm -f rootfs.cpio.gz
    ../scripts/build_rootfs.sh c rootfs.cpio.gz > /dev/null
    rm -rf skel
    cd - > /dev/null
}

build_ramfs()
{
    local bss_sz=0;
    local bss_offset=0;
    local bss_size=0;
    local CHIP="";

    local BIMAGE="output/bImage";
    local RAMDISK="output/rootfs.cpio.gz";
    local DTB="output/sunxi.dtb";
    local BASE="";
    local RAMDISK_OFFSET="";
    local KERNEL_OFFSET="";

    # update rootfs.cpio.gz with new module files
    regen_rootfs_cpio

    CHIP=`echo ${LICHEE_CHIP} | sed -e 's/.*\(sun[0-9x]*i\).*/\1/g'`;

    if [ "${CHIP}" = "sun9i" ]; then
        BASE="0x20000000";
    else
        BASE="0x40000000";
    fi

    if [ "${ARCH}" = "arm" ]; then
        KERNEL_OFFSET="0x8000";
    elif [ "${ARCH}" = "arm64" ]; then
        KERNEL_OFFSET="0x80000";
    fi

    if [ -f vmlinux ]; then
        bss_offset=`${CROSS_COMPILE}readelf -S vmlinux | \
            awk  '/\.bss/ {print $5}'`;
        bss_size=`${CROSS_COMPILE}readelf -S vmlinux | \
            awk  '/\.bss/ {print $6}'`;

        # If linux-4.9 the bss_size will be in next line
        if [ -z "$bss_size" ]; then
            bss_size=`${CROSS_COMPILE}readelf -S vmlinux | \
                 awk  '/\.bss/ {getline var; print var}' | awk '{print $1}'`;
        fi

        bss_sz=$[ $((16#$bss_offset))+$((16#$bss_size))]
    fi

    # If the size of bImage larger than 16M, will offset 0x02000000
    if [ ${bss_sz} -gt $((16#1000000)) ]; then
        RAMDISK_OFFSET="0x02000000";
    else
        RAMDISK_OFFSET="0x01000000";
    fi
    DTB_OFFSET="0x04000000";

    ${MKBOOTIMG} --kernel ${BIMAGE} \
        --ramdisk ${RAMDISK} \
        --dtb ${DTB} \
        --board ${CHIP}_${ARCH} \
        --base ${BASE} \
        --kernel_offset ${KERNEL_OFFSET} \
        --ramdisk_offset ${RAMDISK_OFFSET} \
        --dtb_offset ${DTB_OFFSET} \
        --header_version 0x2 \
        -o output/boot.img

    # If uboot use *bootm* to boot kernel, we should use uImage.
    echo build_ramfs
    echo "Copy boot.img to output directory ..."
    cp output/boot.img ${LICHEE_PLAT_OUT}
    cp output/vmlinux.tar.bz2 ${LICHEE_PLAT_OUT}

    if [ -f output/zImage ] || [ -f output/uImage ]; then
        cp output/[zu]Image ${LICHEE_PLAT_OUT}
    fi

    if [ ! -f output/arisc ]; then
        echo "arisc" > output/arisc
    fi
    cp output/arisc ${LICHEE_PLAT_OUT}

    cp output/.sunxi.dts ${LICHEE_PLAT_OUT}
    cp output/sunxi.dtb ${LICHEE_PLAT_OUT}
}

gen_output()
{
    if [ "x${LICHEE_PLATFORM}" = "xandroid" ] ; then
        echo "Copy modules to target ..."
        rm -rf ${LICHEE_PLAT_OUT}/lib
        cp -rf ${LICHEE_KDIR}/output/* ${LICHEE_PLAT_OUT}
        return
    fi

    if [ -d ${LICHEE_BR_OUT}/target ] ; then
        echo "Copy modules to target ..."
        local module_dir="${LICHEE_BR_OUT}/target/lib/modules"
        rm -rf ${module_dir}
        mkdir -p ${module_dir}
        cp -rf ${LICHEE_MOD_DIR} ${module_dir}
    fi

    echo "$0"
}

clean_kernel()
{
    clarg="clean"
    if [ "x$1" == "xdistclean" ]; then
        clarg="distclean"
    fi
    echo "Cleaning kernel, arg: $clarg ..."
    ${MAKE} ARCH=${ARCH} "$clarg"
    rm -rf output/*
    echo
}

clean_modules()
{
    echo "Cleaning modules ..."
    clean_gpu
    echo
}

#####################################################################
#
#                      Main Runtine
#
#####################################################################

case "$1" in
    kernel)
        build_kernel
        ;;
    modules)
        build_modules
        ;;
    clean|distclean)
        clean_modules
        clean_kernel "$1"
        ;;
    dts)
        build_dts
        ;;
    *)
        build_kernel
        build_modules
        build_ramfs
        gen_output
        echo -e "\n\033[0;31;1m${LICHEE_CHIP} compile Kernel successful\033[0m\n\n"
        ;;
esac
