armbian-install

#!/bin/bash
#============================================================================
#
# This file is licensed under the terms of the GNU General Public
# License version 2. This program is licensed "as is" without any
# warranty of any kind, whether express or implied.
#
# This file is a part of the Armbian for Amlogic TV Boxes
# https://github.com/ophub/amlogic-s9xxx-armbian
#
# Function: Install armbian to eMMC
# Copyright (C) 2021- https://github.com/unifreq/openwrt_packit
# Copyright (C) 2021- https://github.com/ophub/amlogic-s9xxx-armbian
#
# Command: armbian-install
# Command optional parameters: armbian-install <mainline_u-boot>
# The mainline u-boot is installed by default: armbian-install
# Don't write mainline u-boot command: armbian-install no
#
#============================== Functions list ==============================
#
# error_msg          : Output error message
# init_var           : Initialize all variables
# show_aml_model     : Display the model list
# set_rootfs_type    : Set the type of file system
# create_partition   : Create emmc partition
# copy_bootfs        : Copy bootfs partition files
# copy_rootfs        : Copy rootfs partition files
#
#========================== Set default parameters ==========================
#
# Set default installation mainline u-boot
auto_mainline_uboot="yes"
# Set install list profile
model_conf="/etc/amlogic_model_database.conf"
# Add custom armbian firmware information
ophub_release_file="/etc/ophub-release"
# Set the installation file preprocessing directory
tmp_path="/ddbr"
#
# Set font color
STEPS="[\033[95m STEPS \033[0m]"
INFO="[\033[94m INFO \033[0m]"
SUCCESS="[\033[92m SUCCESS \033[0m]"
OPTIONS="[\033[93m OPTIONS \033[0m]"
ERROR="[\033[91m ERROR \033[0m]"
#
#============================================================================

# Encountered a serious error, abort the script execution
error_msg() {
    echo -e "${ERROR} ${1}"
    exit 1
}

# Initialize all variables
init_var() {
    echo -e "${STEPS} Start initializing the environment..."

    # Specify whether to brush into the mainline u-boot, such as: yes
    [[ "${1}" == "no" ]] && auto_mainline_uboot="no"

    # Check if the ${model_conf} file exists
    [[ -s "${model_conf}" ]] || error_msg "[ ${model_conf} ] file is missing!"
    model_database="$(cat ${model_conf} | grep -E "^[0-9]{1,9}.*:")"
    [[ -n "${model_database}" ]] || error_msg "[ ${model_conf} ] file is empty!"

    # Check the current system running disk
    root_devname="$(df / | tail -n1 | awk '{print $1}' | awk -F '/' '{print substr($3, 1, length($3)-2)}')"
    if lsblk -l | grep -E "^${root_devname}boot0" >/dev/null; then
        error_msg "you are running in emmc mode, please boot system with usb or tf card!"
    fi

    # Find emmc disk
    install_emmc="$(lsblk -l -o NAME | grep -oE '(mmcblk[0-9]?boot0)' | sed "s/boot0//g")"
    [[ -z "${install_emmc}" ]] && error_msg "No emmc can be found to install the armbian system!"
    DEV_EMMC="/dev/${install_emmc}"
    echo -e "${INFO} DEV_EMMC: [ ${DEV_EMMC} ]"

    # Create a file preprocessing directory
    [[ -d "${tmp_path}" ]] && rm -rf ${tmp_path}/* 2>/dev/null && sync
    DIR_INSTALL="${tmp_path}/install"
    mkdir -p ${DIR_INSTALL} && chmod 777 ${tmp_path}

    # Generate New ROOTFS UUID
    ROOTFS_UUID="$(cat /proc/sys/kernel/random/uuid)"
    [[ -z "${ROOTFS_UUID}" ]] && ROOTFS_UUID="$(uuidgen)"
    [[ -z "${ROOTFS_UUID}" ]] && error_msg "The new UUID is invalid, cannot continue."

    # Get kernel TEXT_OFFSET, For u-boot.ext and u-boot.emmc
    # With TEXT_OFFSET patch is [ 0108 ], without TEXT_OFFSET patch is [ 0000 ]
    K510="1"
    [[ "$(hexdump -n 15 -x "/boot/zImage" 2>/dev/null | head -n 1 | awk '{print $7}')" == "0108" ]] && K510="0"
}

# Search the model list
search_aml_model() {
    local search_soc_id="${1}"
    local ret_count="$(echo "${model_database}" | grep -E "^${search_soc_id}:" | wc -l)"
    if [[ "${ret_count}" -eq "1" ]]; then
        echo "${model_database}" | grep -E "^${search_soc_id}:" | sed -e 's/NA//g' -e 's/NULL//g' -e 's/[ ][ ]*//g'
    fi
}

# Functions: Displays a list of supported amlogic devices
# Configure: View ${model_database}
# Explain:   1.ID  2.MODEL  3.SOC  4.FDTFILE  5.UBOOT_OVERLOAD  6.MAINLINE_UBOOT  7.ANDROID_UBOOT
# Example:   402:Beelink GT-King Pro:s922x:meson-g12b-gtking-pro.dtb:u-boot-gtkingpro.bin:/usr/lib/u-boot/gtkingpro-u-boot.bin.sd.bin:NA
show_aml_model() {
    echo -e "${STEPS} Start selecting device..."

    printf "%-s\n" "--------------------------------------------------------------------------------------"
    printf "%-5s %-10s %-30s %-50s\n" ID SOC MODEL DTB
    printf "%-s\n" "--------------------------------------------------------------------------------------"
    printf "%-5s %-10s %-30s %-50s\n" $(echo "${model_database}" | grep -E "^[0-9]{1,9}.*:" | sed -e 's/[ ][ ]*/-/g' | awk -F ':' '{print $1,$3,$2,$4}')
    printf "%-s\n" "--------------------------------------------------------------------------------------"

    echo -ne "${OPTIONS} Please Input ID: "
    read boxid
    if [[ "${boxid}" -eq "0" ]]; then
        read -p "Please Input SoC Name: " AMLOGIC_SOC
        AMLOGIC_SOC="${AMLOGIC_SOC}"
        #
        read -p "Please Input DTB Name: " FDTFILE
        FDTFILE="${FDTFILE}"
        #
        read -p "Please Input UBOOT_OVERLOAD Name: " UBOOT_OVERLOAD
        UBOOT_OVERLOAD="${UBOOT_OVERLOAD}"
        #
        read -p "Please Input MAINLINE_UBOOT Name: " MAINLINE_UBOOT
        MAINLINE_UBOOT="${MAINLINE_UBOOT}"
        #
        read -p "Please Input ANDROID_UBOOT Name: " ANDROID_UBOOT
        ANDROID_UBOOT="${ANDROID_UBOOT}"
    else
        ret="$(search_aml_model "${boxid}")"
        [[ -z "${ret}" ]] && error_msg "Input error, exit!"

        AMLOGIC_SOC="$(echo "${ret}" | awk -F ':' '{print $3}')"
        FDTFILE="$(echo "${ret}" | awk -F ':' '{print $4}')"
        UBOOT_OVERLOAD="$(echo "${ret}" | awk -F ':' '{print $5}')"
        MAINLINE_UBOOT="$(echo "${ret}" | awk -F ':' '{print $6}')"
        ANDROID_UBOOT="$(echo "${ret}" | awk -F ':' '{print $7}')"
    fi

    echo -e "${INFO} Input Box ID: [ ${boxid} ]"
    echo -e "${INFO} FDTFILE: [ ${FDTFILE} ]"
    echo -e "${INFO} UBOOT_OVERLOAD: [ ${UBOOT_OVERLOAD} ]"
    echo -e "${INFO} K510: [ ${K510} ]"

    # Check dtb file
    [[ -n "${FDTFILE}" && -f "/boot/dtb/amlogic/${FDTFILE}" ]] || error_msg "The DTB is missing, stop the install."

    # Check UBOOT_OVERLOAD
    if [[ "${K510}" -eq "1" ]]; then
        [[ -n "${UBOOT_OVERLOAD}" && -f "/boot/${UBOOT_OVERLOAD}" ]] || error_msg "The UBOOT_OVERLOAD is missing, stop the install."
    fi
}

# Set the type of file system
set_rootfs_type() {
    echo -e "${STEPS} Start selecting file system type..."
    cat <<EOF
-----------------------------------------------
ID  TYPE
-----------------------------------------------
1   ext4
2   btrfs
-----------------------------------------------
EOF
    echo -ne "${OPTIONS} Please Input ID: "
    read filetype
    if [[ "${filetype}" -eq "2" || "${filetype}" == "btrfs" ]]; then
        file_system_type="btrfs"
        uenv_mount_string="UUID=${ROOTFS_UUID} rootflags=compress=zstd:6 rootfstype=btrfs"
        fstab_mount_string="defaults,noatime,compress=zstd:6"
    else
        file_system_type="ext4"
        uenv_mount_string="UUID=${ROOTFS_UUID} rootflags=data=writeback rw rootfstype=ext4"
        fstab_mount_string="defaults,noatime,errors=remount-ro"
    fi
    echo -e "${INFO} Input Type ID: [ ${filetype} ]"
    echo -e "${INFO} The type of file system: [ ${file_system_type} ]"
}

# Create emmc partition
create_partition() {
    cd /
    echo -e "${STEPS} Start creating eMMC partition..."

    # Disable the system's partition adjustment service
    systemctl stop armbian-resize-filesystem.service
    systemctl disable armbian-resize-filesystem.service

    # Backup the bootloader, if necessary for system recovery
    [[ -d "/usr/lib/u-boot" ]] || mkdir -p /usr/lib/u-boot
    MYBOX_UBOOT="/usr/lib/u-boot/mybox-bootloader.img"
    if [[ ! -f "${MYBOX_UBOOT}" ]]; then
        echo -e "${INFO} Start backup default bootloader."
        dd if="${DEV_EMMC}" of=${MYBOX_UBOOT} bs=1M count=4 conv=fsync
    fi
    sync

    # Clear emmc disk data
    exists_pts="$(parted ${DEV_EMMC} print 2>/dev/null | grep 'primary' | wc -l)"
    if [[ "${exists_pts}" -gt "0" ]]; then
        i=1
        while [[ "${i}" -le "${exists_pts}" ]]; do
            parted -s ${DEV_EMMC} rm ${i} 2>/dev/null
            let i++
        done
    fi
    dd if=/dev/zero of=${DEV_EMMC} bs=512 count=1 conv=fsync
    sync

    # Set partition size (Unit: MiB)
    if [[ "${AMLOGIC_SOC}" == "s912" || "${AMLOGIC_SOC}" == "s905d" ]]; then
        BLANK1="68"
        BOOT="512"
        BLANK2="220"
    elif [[ "${AMLOGIC_SOC}" == "s905x" ]]; then
        BLANK1="700"
        BOOT="160"
        BLANK2="0"
    elif [[ "${AMLOGIC_SOC}" == "s905l3a" ]]; then
        BLANK1="570"
        BOOT="256"
        BLANK2="0"
    else
        BLANK1="68"
        BOOT="256"    # A total of [ 1120MiB ] can be used in this block, and the remaining [ 864MiB ] can be used.
        BLANK2="1026" # Can set the rootfs partition after [ 1350MiB ] of the total disk.
    fi

    # Format emmc disk
    echo -e "${INFO} Start create MBR and partittion."
    parted -s "${DEV_EMMC}" mklabel msdos 2>/dev/null
    parted -s "${DEV_EMMC}" mkpart primary fat32 $((BLANK1))MiB $((BLANK1 + BOOT - 1))MiB 2>/dev/null
    parted -s "${DEV_EMMC}" mkpart primary ${file_system_type} $((BLANK1 + BOOT + BLANK2))MiB 100% 2>/dev/null
    sync

    # Write bootloader
    if [[ -n "${MAINLINE_UBOOT}" && -f "${MAINLINE_UBOOT}" && "${auto_mainline_uboot}" == "yes" ]]; then
        echo -e "${INFO} Write Mainline bootloader: [ ${MAINLINE_UBOOT} ]"
        dd if="${MAINLINE_UBOOT}" of="${DEV_EMMC}" conv=fsync bs=1 count=444
        dd if="${MAINLINE_UBOOT}" of="${DEV_EMMC}" conv=fsync bs=512 skip=1 seek=1
    elif [[ -n "${ANDROID_UBOOT}" && -f "${ANDROID_UBOOT}" ]]; then
        echo -e "${INFO} Write Android bootloader: [ ${ANDROID_UBOOT} ]"
        dd if="${ANDROID_UBOOT}" of="${DEV_EMMC}" conv=fsync bs=1 count=444
        dd if="${ANDROID_UBOOT}" of="${DEV_EMMC}" conv=fsync bs=512 skip=1 seek=1
    elif [[ -n "${MYBOX_UBOOT}" && -f "${MYBOX_UBOOT}" ]]; then
        echo -e "${INFO} Restore the mybox bootloader: [ ${MYBOX_UBOOT} ]"
        dd if=${MYBOX_UBOOT} of="${DEV_EMMC}" conv=fsync bs=1 count=444
        dd if=${MYBOX_UBOOT} of="${DEV_EMMC}" conv=fsync bs=512 skip=1 seek=1
    fi
}

# Copy bootfs partition files
copy_bootfs() {
    cd /
    echo -e "${STEPS} Start processing the bootfs partition..."

    PART_BOOT="${DEV_EMMC}p1"

    if grep -q ${PART_BOOT} /proc/mounts; then
        echo -e "${INFO} Unmounting BOOT partiton."
        umount -f ${PART_BOOT}
    fi
    echo -e "${INFO} Formatting BOOTFS partition."
    mkfs.vfat -n "BOOT_EMMC" ${PART_BOOT}

    mount -o rw ${PART_BOOT} ${DIR_INSTALL}
    [[ "$?" -ne "0" ]] && error_msg "Failed to mount BOOTFS partition"

    echo -e "${INFO} Start copy BOOTFS partition data."
    cp -rf /boot/* ${DIR_INSTALL} && sync
    rm -rf ${DIR_INSTALL}/'System Volume Information' 2>/dev/null

    echo -e "${INFO} Generate the new uEnv.txt file."
    rm -f ${DIR_INSTALL}/uEnv.txt && sync
    cat >${DIR_INSTALL}/uEnv.txt <<EOF
LINUX=/zImage
INITRD=/uInitrd
FDT=/dtb/amlogic/${FDTFILE}
APPEND=root=${uenv_mount_string} console=ttyAML0,115200n8 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0 cgroup_enable=cpuset cgroup_memory=1 cgroup_enable=memory swapaccount=1
EOF

    # If the [ /boot/extlinux/extlinux.conf ] file exists, create a new one.
    if [[ -f "${DIR_INSTALL}/extlinux/extlinux.conf" ]]; then
        echo -e "${INFO} Generate the new extlinux.conf file."
        rm -rf ${DIR_INSTALL}/extlinux && sync
        mkdir -p ${DIR_INSTALL}/extlinux
        cat >${DIR_INSTALL}/extlinux/extlinux.conf <<EOF
label Armbian
    kernel /zImage
    initrd /uInitrd
    fdt /dtb/amlogic/${FDTFILE}
    append root=${uenv_mount_string} console=ttyAML0,115200n8 console=tty0 no_console_suspend consoleblank=0 fsck.fix=yes fsck.repair=yes net.ifnames=0 loglevel=1 voutmode=hdmi disablehpd=false overscan=100 sdrmode=auto
EOF
    else
        rm -rf ${DIR_INSTALL}/extlinux 2>/dev/null
    fi

    rm ${DIR_INSTALL}/s9*
    rm ${DIR_INSTALL}/aml*
    mv -f ${DIR_INSTALL}/boot-emmc.ini ${DIR_INSTALL}/boot.ini
    sed -i "s|u-boot.ext|u-boot.emmc|g" ${DIR_INSTALL}/boot.ini
    mv -f ${DIR_INSTALL}/boot-emmc.scr ${DIR_INSTALL}/boot.scr
    mv -f ${DIR_INSTALL}/boot-emmc.cmd ${DIR_INSTALL}/boot.cmd

    # Copy u-boot.ext and u-boot.emmc
    if [[ "${K510}" -eq "1" && -n "${UBOOT_OVERLOAD}" && -f "${DIR_INSTALL}/${UBOOT_OVERLOAD}" ]]; then
        echo -e "${INFO} Copy [ ${UBOOT_OVERLOAD} ] to u-boot.emmc"
        if [ -f "${DIR_INSTALL}/u-boot.ext" ]; then
            cp -f ${DIR_INSTALL}/u-boot.ext ${DIR_INSTALL}/u-boot.emmc
        else
            cp -f ${DIR_INSTALL}/${UBOOT_OVERLOAD} ${DIR_INSTALL}/u-boot.ext
            cp -f ${DIR_INSTALL}/${UBOOT_OVERLOAD} ${DIR_INSTALL}/u-boot.emmc
        fi
        chmod +x ${DIR_INSTALL}/u-boot.ext
        chmod +x ${DIR_INSTALL}/u-boot.emmc
    fi

    sync && sleep 3
    umount ${DIR_INSTALL}
}

# Copy rootfs partition files
copy_rootfs() {
    cd /
    echo -e "${STEPS} Start processing the rootfs partition..."

    PART_ROOT="${DEV_EMMC}p2"

    if grep -q ${PART_ROOT} /proc/mounts; then
        echo -e "${INFO} Unmounting ROOT partiton."
        umount -f ${PART_ROOT}
    fi

    echo -e "${INFO} Formatting ROOTFS partition."
    if [[ "${file_system_type}" == "btrfs" ]]; then
        mkfs.btrfs -f -U ${ROOTFS_UUID} -L "ROOTFS_EMMC" -m single ${PART_ROOT}
        sleep 3
        mount -t btrfs -o compress=zstd:6 ${PART_ROOT} ${DIR_INSTALL}
    else
        mkfs.ext4 -F -q -U ${ROOTFS_UUID} -L "ROOTFS_EMMC" -b 4k -m 0 ${PART_ROOT}
        sleep 3
        mount -t ext4 ${PART_ROOT} ${DIR_INSTALL}
    fi
    [[ "$?" -ne "0" ]] && error_msg "Failed to mount ROOTFS partition"

    echo -e "${INFO} Start copy ROOTFS partition data."
    # Create relevant directories
    mkdir -p ${DIR_INSTALL}/{boot/,dev/,media/,mnt/,proc/,run/,sys/} && sync
    # Copy the relevant directory
    COPY_SRC="etc home lib64 opt root selinux srv usr var"
    for src in ${COPY_SRC}; do
        echo -e "${INFO} Copy the [ ${src} ] directory."
        tar -cf - ${src} | (
            cd ${DIR_INSTALL}
            tar -xf -
        )
        sync
    done
    # Create relevant symbolic link
    ln -sf /usr/bin ${DIR_INSTALL}/bin
    ln -sf /usr/lib ${DIR_INSTALL}/lib
    ln -sf /usr/sbin ${DIR_INSTALL}/sbin
    ln -sf /var/tmp ${DIR_INSTALL}/tmp
    sync

    echo -e "${INFO} Generate the new fstab file."
    rm -f ${DIR_INSTALL}/etc/fstab 2>/dev/null && sync
    cat >${DIR_INSTALL}/etc/fstab <<EOF
UUID=${ROOTFS_UUID}  /        ${file_system_type}     ${fstab_mount_string}     0 1
LABEL=BOOT_EMMC      /boot    vfat                    defaults                  0 2
tmpfs                /tmp     tmpfs                   defaults,nosuid           0 0

EOF

    echo -e "${INFO} Update the relevant parameters."
    ophub_release_file="${DIR_INSTALL}${ophub_release_file}"
    sed -i "s|^FDTFILE=.*|FDTFILE='${FDTFILE}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^UBOOT_OVERLOAD=.*|UBOOT_OVERLOAD='${UBOOT_OVERLOAD}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^MAINLINE_UBOOT=.*|MAINLINE_UBOOT='${MAINLINE_UBOOT}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^ANDROID_UBOOT=.*|ANDROID_UBOOT='${ANDROID_UBOOT}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^MYBOX_UBOOT=.*|MYBOX_UBOOT='${MYBOX_UBOOT}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^SOC=.*|SOC='${AMLOGIC_SOC}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^K510=.*|K510='${K510}'|g" ${ophub_release_file} 2>/dev/null
    sed -i "s|^DISK_TYPE=.*|DISK_TYPE='emmc'|g" ${ophub_release_file} 2>/dev/null

    rm -f ${DIR_INSTALL}/usr/sbin/armbian-tf 2>/dev/null

    sync && sleep 3
    umount ${DIR_INSTALL}
}

echo -e "${STEPS} Start install armbian to emmc..."
#
# Check script permission
[[ "$(id -u)" == "0" ]] || error_msg "please run this script as root: [ sudo $0 ]"
# Initialize all variables
init_var "${@}"
# Display the model list
show_aml_model
# Set the type of file system
set_rootfs_type
# Create emmc partition
create_partition
# Copy bootfs partition files
copy_bootfs
# Copy rootfs partition files
copy_rootfs
#
echo -e "${SUCCESS} Successful installed, please unplug the USB, re-insert the power supply to start the armbian."
exit 0