pack_image

#!/bin/sh

## hyphop ##

#= krescue image builder ... SPI + ....

USAGE(){ echo "
USAGE pack_spi_image [-r|-h]

";}

P=$(dirname $0)

mkimage=$P/mkimage2

DIR=$PWD

REBUILD_RESCUE=

case "$@" in
    -r)
    REBUILD_RESCUE=1
    ;;
    -1)
    DEVNAME=VIM1
    ;;
    -2)
    DEVNAME=VIM2
    ;;
    -3)
    DEVNAME=VIM3
    ;;
    -3l|-l)
    DEVNAME=VIM3L
    ;;
    -e)
    DEVNAME=Edge
    ;;
esac

HEX(){
    printf "0x%06X" "$1"
}

## rebuild rescue image

[ "$REBUILD_RESCUE" ] && {
echo "[i] rebuild rescue">&2
cd $P/../../openwrt/ 1>/dev/null 2>/dev/null && {
[ -x ./create_squashfs ] && {
    ./create_squashfs initramfs-rescue
}
}
cd $DIR
}

FLASH_SIZE=$((1024*1024*16))
FLASH_SIZE_HEX=$(HEX $FLASH_SIZE)

ENV_SIZE=$((64*1024))
ENV_SIZE_HEX=$(HEX $ENV_SIZE)

ENV_OFFSET=$((FLASH_SIZE-$ENV_SIZE))
ENV_OFFSET_HEX=$(HEX $ENV_OFFSET)

echo "
SPI FLASH
=========
0 $FLASH_SIZE_HEX

$ENV_OFFSET_HEX $ENV_SIZE_HEX

" >&2

UNI=/tmp/krescue

S="$P/../share"

NOCACHE=

OUT=$UNI.spi.bin
OUT_SPI="$S/image.spi.bin"
SPI_PARTS_DTS="$S/spi_parts.dts"
SPI_PARTS_CMD="$S/spi_parts.cmdline"
SPI_PARTS_CMDLINE="mtdparts="

# kernel run from there

INITRD_ADDR=0x3000000
 LINUX_ADDR=0x1080000

# rk3399 + vim
LINUX_ADDR=0x0f080000

KERNEL_CMP_SPI=lzma
KERNEL_CMP_SPI_OPTS="-9e"
KERNEL_CMP=gzip
KERNEL_CMP_OPTS="-9"

BLOCK_SIZE=$((1024*64))
BLOCK_SIZH=$((1024*32))

SYS_ENV=$S/00_system_env.txt

[ "$UBOOT_BIN" ] || {
    [ "$DEVNAME" ] || {
        echo "[e] DEVNAME not defined">&2
	exit 1
    }
    UBOOT_BIN="/tmp/u-boot-mainline/$DEVNAME.u-boot.spi.bin"
}

[ -e "$UBOOT_BIN" ] && {
    A=$(basename "$UBOOT_BIN")
    DEVNAME=${A%%.*}
}

[ -e "$UBOOT_BIN" ] || {
    echo "[e] $UBOOT_BIN = not found">&2
    exit 1
}

echo "[i] uboot ver $DEVNAME">&2

#UBOOT_SCRIPT=$S/*.cmd
UBOOT_SCRIPT=$P/../files/rescue.cmd
UBOOT_SCRIPT_ENV=$S/*env.txt
#UBOOT_LOGOS=$S/*.bmp.gz
UBOOT_LOGOS=$S/splash.bmp
#UBOOT_DTB=$S/*.dtb

DTB_DIR=/tmp/modules


[ "$UBOOT_DTB" ] || {

#   UBOOT_DTB=$S/krescue-$DEVNAME.dtb

    case "$DEVNAME" in
    VIM3)
#    meson-g12b-s922x-khadas-vim3-kresq.dtb
    DTB_NAME=meson-g12b-a311d-khadas-vim3-kresq.dtb
    ;;
    VIM1)
    DTB_NAME=meson-gxl-s905x-khadas-vim-kresq.dtb
    ;;
    VIM2)
    DTB_NAME=meson-gxm-khadas-vim2-kresq.dtb
    ;;
    VIM3L)
    DTB_NAME=meson-sm1-khadas-vim3l-kresq.dtb
    ;;
    Edge)
    DTB_NAME=rk3399-khadas-edge-v-kresq.dtb
    ;;
    esac

    UBOOT_DTB="$DTB_DIR/$DTB_NAME"

}

LINUX_U_IMAGE=$S/uImage
LINUX_U_IMAGE_SPI=$S/uImage.spi
LINUX_U_INITRD=$S/uInitrd

LINUX_IMAGE=$S/Image
LINUX_INITRD=$S/Initrd
UBOOT_ENV=$S/ENV.txt

CMD2(){
    [ -s "$1" ] && {
	echo "[i] run cmd $@">&2
	"$@"
    }
}

CMD(){
	echo "[i] run cmd $@">&2
	"$@"
}


# data location
#
# UBOOT | SCRIPT | SCRIPT_ENV | LOGOS | DTB | U_IMAGE | U_INITRD | ENV
#
#

echo "[i] mask
$UBOOT_BIN
$UBOOT_SCRIPT
$UBOOT_SCRIPT_ENV
$UBOOT_LOGOS
$UBOOT_DTB
$LINUX_U_IMAGE
$LINUX_U_INITRD
$LINUX_IMAGE
$LINUX_INITRD
$UBOOT_ENV
"

filesize(){
    stat -L -c%s "$1" || {
	echo "[e] file not found $1">&2
	exit 1
    }
}

## find UBOOT sd

UBOOT_BIN_SIZE=
echo "uboot $UBOOT_BIN">&2

for UBOOT_BIN in $UBOOT_BIN ""; do
    [ -L "$UBOOT_BIN" ] && {
	UBOOT_BIN_R=$(realpath $UBOOT_BIN)
	echo "[i] UBOOT: $UBOOT_BIN_R">&2
    }
    [ -f "$UBOOT_BIN" ] && {
	break
    }
done

[ "$UBOOT_BIN" ] || {
    echo "[e] undefined UBOOT_BIN">&2
    exit 1
}

UBOOT_BIN_SIZE=$(filesize $UBOOT_BIN) || exit 1

[ $UBOOT_BIN_SIZE -lt 500000 ] && {
    echo "[e] wrong file $UBOOT_BIN">&2
    exit 1
}


## prepare SCRIPT
[ "" ] && {
UBOOT_SCRIPT_TMP=$UNI.script.tmp
UBOOT_SCRIPT_SCR=$UNI.script.scr
UBOOT_SCRIPTS=0

echo "#!script" > $UBOOT_SCRIPT_TMP

for u in $UBOOT_SCRIPT; do
    [ -f $u ] && {
	echo "# generated from $u $(date)" >> $UBOOT_SCRIPT_TMP
	cat $u >> $UBOOT_SCRIPT_TMP
	UBOOT_SCRIPTS=$((UBOOT_SCRIPTS+1))
    }
done

#CMD mkimage -C none -A arm -T script -d $UBOOT_SCRIPT_TMP $UBOOT_SCRIPT_SCR

ln -sf $UBOOT_SCRIPT_TMP $UBOOT_SCRIPT_SCR
}

UBOOT_SCRIPT_SCR=$UBOOT_SCRIPT
UBOOT_SCRIPT_SIZE=$(filesize $UBOOT_SCRIPT_SCR) || exit 1

[ "" ] && {
[ $UBOOT_SCRIPTS -lt 1 ] && {
    echo "[e] not found script in $UBOOT_SCRIPT">&2
    exit 1
}
}

## LOGOS

UBOOT_LOGO=

for UBOOT_LOGO in $UBOOT_LOGOS "" ; do

    [ -f $UBOOT_LOGO ] && {
	break
    }

    CMD2 $UBOOT_LOGO.make || {
	echo "[e] $UBOOT_LOGO.make error">&2
	exit 1
    }

    [ -f $UBOOT_LOGO ] && {
	break
    }

done

UBOOT_LOGO_SIZE=$(filesize $UBOOT_LOGO) #|| exit 1

[ "$UBOOT_LOGO_SIZE" ] || {
    echo "[i] zero size UBOOT_LOGOS: $UBOOT_LOGOS">&2
    exit 1
}

## DTB

echo "[i] UBOOT DTB : $UBOOT_DTB">&2

for UBOOT_DTB in $UBOOT_DTB "" ; do
    [ -f "$UBOOT_DTB" ] && {
	break
    }
done

echo "[i] UBOOT DTB : $UBOOT_DTB">&2

[ "$UBOOT_DTB" ] || {
    echo "[e] undefined UBOOT_DTB">&2
    exit 1
}

UBOOT_DTB_SIZE=$(filesize $UBOOT_DTB) || exit 1

[ "$UBOOT_DTB_SIZE" ] || {
    echo "[e] wrong file $UBOOT_DTB">&2
    exit 1
}

## Image linux kernel

for LINUX_IMAGE in $LINUX_IMAGE "" ; do
    [ -f "$LINUX_IMAGE" ] && {
	break
    }
done

[ "$LINUX_IMAGE" ] || {
    echo "[e] undefined LINUX_IMAGE">&2
    exit 1
}

LINUX_IMAGE_SIZE=$(filesize $LINUX_IMAGE) || exit 1

[ "$LINUX_IMAGE_SIZE" -lt 1000000 ] && {
    echo "[e] wrong file $LINUX_IMAGE">&2
    exit 1
}


CKERNEL=$UNI.Image.$KERNEL_CMP
CKERNEL_SPI=$UNI.Image.$KERNEL_CMP_SPI

[ $NOCACHE ] && {
    rm $CKERNEL
}

KNAME_SPI=$(basename $CKERNEL_SPI)
KNAME=$(basename $CKERNEL)

CMPDATE(){
    a="$(stat -Lc%Y $1 2>/dev/null)"
    b="$(stat -Lc%Y $2 2>/dev/null)"
    echo "[i] cmp date $1:$a $2:$b - $((b-a))s">&2
    [ -f $2 ] || return 0
    [ "$a" -gt "$b" ]
}


#rm $CKERNEL

#[ -f $CKERNEL ] || {

#lzma -dc $CKERNEL >/dev/null || {

#[ -f $CKERNEL ] && \
#    rm $CKERNEL

#}

    CMPDATE $LINUX_IMAGE $CKERNEL && {
	echo "[i] compress kernel $LINUX_IMAGE">&2
	CMD $KERNEL_CMP -c $LINUX_IMAGE > $CKERNEL
    }

    CMPDATE $LINUX_IMAGE $CKERNEL_SPI && {
	echo "[i] compress kernel $LINUX_IMAGE">&2
	CMD $KERNEL_CMP_SPI $KERNEL_CMP_SPI_OPTS -c $LINUX_IMAGE > $CKERNEL_SPI
    }

#}

CMPDATE $CKERNEL $LINUX_U_IMAGE && {
CMD $mkimage -A arm64 -O linux -C $KERNEL_CMP \
	-T kernel -a $LINUX_ADDR -e $LINUX_ADDR \
	-n "$KNAME" -d $CKERNEL $LINUX_U_IMAGE || {
	    echo "[e] error mkimage ">&2
	    exit 1
	}
}

CMPDATE $CKERNEL_SPI $LINUX_U_IMAGE_SPI && {
CMD $mkimage -A arm64 -O linux -C $KERNEL_CMP_SPI \
	-T kernel -a $LINUX_ADDR -e $LINUX_ADDR \
	-n "$KNAME_SPI" -d $CKERNEL_SPI $LINUX_U_IMAGE_SPI || {
	    echo "[e] error mkimage ">&2
	    exit 1
	}
}

LINUX_U_IMAGE_SIZE=$(filesize $LINUX_U_IMAGE) || exit 1
LINUX_U_IMAGE_SPI_SIZE=$(filesize $LINUX_U_IMAGE_SPI) || exit 1

[ "$LINUX_U_IMAGE_SIZE" -lt 1000000 ] && {
    echo "[e] wrong LINUX_U_IMAGE_SIZE">&2
    exit 1
}

[ "$LINUX_U_IMAGE_SPI_SIZE" -lt 1000000 ] && {
    echo "[e] wrong LINUX_U_IMAGE_SPI_SIZE">&2
    exit 1
}

LINUX_INITRD_SIZE=$(filesize $LINUX_INITRD) || exit 1

[ "$LINUX_INITRD_SIZE" -lt 1000000 ] && {
    echo "[e] wrong LINUX_INITRD_SIZE for $LINUX_INITRD">&2
    exit 1
}


CMPDATE $LINUX_INITRD $LINUX_U_INITRD && {
CMD $mkimage -A arm64 \
    -O linux \
    -T ramdisk \
    -C none \
    -a $INITRD_ADDR \
    -e $INITRD_ADDR \
    -n uInitrd \
    -d $LINUX_INITRD $LINUX_U_INITRD
}

LINUX_U_INITRD_SIZE=$(filesize $LINUX_U_INITRD)

[ "$LINUX_U_INITRD_SIZE" -lt 1000000 ] && {
    echo "[e] wrong LINUX_U_INITRD_SIZE for $LINUX_U_INITRD">&2
    exit 1
}

PAD(){
    a=$1
    [ "$a" ] || a=0
    b=$2
    [ "$b" ] || b=$BLOCK_SIZE
    s=$(( ($a/$b) * $b ))
    [ "$a" -gt $s ] && { 
	s=$((s+$b))
    }
    [ "$3" ] && {
	s=$((s+$3))
    }

    echo $s
}


TABLE_ROWS="|%08s|%08s|%08s|%08s|%08s|%04s|%-30s|\n"

HR(){
    echo "------------------------------\
--------------------------------------\
--------------">&2
}

item=1

FLINE(){

    n="$1"
    shift
    f="$1"
    shift

    printf $TABLE_ROWS "$n" "$@" $(($2/$BLOCK_SIZH)) "$f"

    size_h="$(HEX $2)"

echo "#$n
${n}_SIZE=$1
${n}_SIZHEX=$size_h
${n}_SPAD=$2
${n}_OFFSET=$3
${n}_OFFHEX=$4
" >> $SYS_ENV

    [ "$f" = "-" ] && {
	return
    }

#    [ "" ] && { 
    echo "
    $n@$item {
        label = \"$n\";
        reg = <$4 $size_h>;
    };
    " >> $SPI_PARTS_DTS

    SPI_PARTS_CMDLINE="$SPI_PARTS_CMDLINE,$(($2/1024))k($n)"

    item=$((item+1))

#    }

    [ -f "$f" ] || {
	echo "[e] not found $f">&2
	return 1
    }

    CMPDATE $f "$S/$n.PAD" 2>/dev/null && {
    HR
    dd if=/dev/zero bs=$BLOCK_SIZH \
	count=$(($2/$BLOCK_SIZH)) \
	of="$S/$n.PAD" 1>/dev/null 2>/dev/null
    dd if=$f bs=$BLOCK_SIZH \
	count=$(($2/$BLOCK_SIZH)) \
	conv=notrunc of="$S/$n.PAD" 1>/dev/null 2>/dev/null

    }
}

[ "1" ] && {
    rm $S/*.PAD
}

o=0

## FIXED
UBOOT_SCRIPT_ENV_SIZE=$BLOCK_SIZH

## 
UBOOT_SIZE=$UBOOT_BIN_SIZE
SCRIPT_SIZE=$UBOOT_SCRIPT_SIZE
ENV_SIZE=$UBOOT_SCRIPT_ENV_SIZE
LOGO_SIZE=$UBOOT_LOGO_SIZE
DTB_SIZE=$UBOOT_DTB_SIZE
UIMAGE_SIZE=$LINUX_U_IMAGE_SPI_SIZE
UINITRD_SIZE=$LINUX_U_INITRD_SIZE


# $(date)
echo "# SYSTEM_ENV auto generated
" > $SYS_ENV

echo "

//SPI FLASH PARTS

&spiflash {

    partitions {
    compatible = \"fixed-partitions\";
    #address-cells = <1>;
    #size-cells = <1>;

    full@0 {
        label = \"full\";
        reg = <0x000000 $FLASH_SIZE_HEX>;
    };

    ubootenv@0 {
        label = \"ubootenv\";
        reg = <$ENV_OFFSET_HEX $ENV_SIZE_HEX>;
    };

" > $SPI_PARTS_DTS

SPI_PARTS_CMDLINE="$SPI_PARTS_CMDLINE:-0(full)"
## fix size

UBOOT_BIN_SIZE=$((20*$BLOCK_SIZE)) ## 0x140000 size

# uboot
#s=$(PAD $UBOOT_BIN_SIZE $BLOCK_SIZE $BLOCK_SIZE)
s=$(PAD $UBOOT_BIN_SIZE)
UBOOT_BIN_SIZE_PAD=$s
o=$((o+$s))

printf "$TABLE_ROWS" section size pad_size offset off_hex 32k source
HR

FLINE "UBOOT" $UBOOT_BIN \
    $UBOOT_BIN_SIZE $UBOOT_BIN_SIZE_PAD 0 0

## dtb
UBOOT_DTB_OFFSET=$o
UBOOT_DTB_OFFSET_HEX=$(HEX $o)

## fix size
UBOOT_DTB_SIZE=$((2*$BLOCK_SIZE)) ## 0x140000 offset 

s=$(PAD $UBOOT_DTB_SIZE)
UBOOT_DTB_SIZE_PAD=$s
o=$((o+$s))


FLINE "DTB" $UBOOT_DTB $UBOOT_DTB_SIZE $UBOOT_DTB_SIZE_PAD \
    $UBOOT_DTB_OFFSET $UBOOT_DTB_OFFSET_HEX

# script
UBOOT_SCRIPT_SCR_OFFSET=$o
UBOOT_SCRIPT_SCR_OFFSET_HEX=$(HEX $o)

s=$(PAD $UBOOT_SCRIPT_SIZE $BLOCK_SIZH)
UBOOT_SCRIPT_SIZE_PAD=$s
o=$((o+$s))

FLINE "SCRIPT" $UBOOT_SCRIPT_SCR \
    $UBOOT_SCRIPT_SIZE $UBOOT_SCRIPT_SIZE_PAD \
    $UBOOT_SCRIPT_SCR_OFFSET $UBOOT_SCRIPT_SCR_OFFSET_HEX

## fixed env
UBOOT_SCRIPT_ENV_OFFSET=$o
UBOOT_SCRIPT_ENV_OFFSET_HEX=$(HEX $o)

s=$(PAD $UBOOT_SCRIPT_ENV_SIZE $BLOCK_SIZH)
o=$((o+$s))
UBOOT_SCRIPT_ENV_SIZE_PAD=$s

UBOOT_SCRIPT_ENV_TMP=$UNI.uboot.env

echo "" > $UBOOT_SCRIPT_ENV_TMP

FLINE "UENV" "$UBOOT_SCRIPT_ENV_TMP" \
    $UBOOT_SCRIPT_ENV_SIZE $UBOOT_SCRIPT_ENV_SIZE_PAD \
    $UBOOT_SCRIPT_ENV_OFFSET $UBOOT_SCRIPT_ENV_OFFSET_HEX

## logo
UBOOT_LOGO_OFFSET=$o
UBOOT_LOGO_OFFSET_HEX=$(HEX $o)

s=$(PAD $UBOOT_LOGO_SIZE)
UBOOT_LOGO_SIZE_PAD=$s
o=$((o+$s))

FLINE "LOGO" $UBOOT_LOGO $UBOOT_LOGO_SIZE $UBOOT_LOGO_SIZE_PAD \
    $UBOOT_LOGO_OFFSET $UBOOT_LOGO_OFFSET_HEX


## uimage
UIMAGE_OFFSET=$o
UIMAGE_OFFSET_HEX=$(HEX $o)

s=$(PAD $UIMAGE_SIZE $BLOCK_SIZE $BLOCK_SIZE)
UIMAGE_SIZE_PAD=$s
o=$((o+$s))

#FLINE "IMAGE"	$LINUX_IMAGE			$LINUX_IMAGE_SIZE	- - -
FLINE "UIMAGE" $LINUX_U_IMAGE_SPI $LINUX_U_IMAGE_SPI_SIZE $UIMAGE_SIZE_PAD \
    $UIMAGE_OFFSET $UIMAGE_OFFSET_HEX


## uinitrd
UINITRD_OFFSET=$o
UINITRD_OFFSET_HEX=$(HEX $o)

s=$(PAD $UINITRD_SIZE)
UINITRD_SIZE_PAD=$((s))
o=$((o+$s))

## 
ENV_OFFSET_HEX=$(HEX $ENV_OFFSET)

#FLINE "INITRD"	$LINUX_INITRD			$LINUX_INITRD_SIZE	- - - 
FLINE "UINITRD"	$LINUX_U_INITRD $LINUX_U_INITRD_SIZE $UINITRD_SIZE_PAD \
    $UINITRD_OFFSET $UINITRD_OFFSET_HEX
FLINE "ENV" - $BLOCK_SIZE $BLOCK_SIZE \
    $ENV_OFFSET $ENV_OFFSET_HEX

user_data_size=$((ENV_OFFSET-$o))


echo "total bytes: $o free user_data ($user_data_size)">&2

[ "$o" -gt "$ENV_OFFSET" ] && {
    echo "[i] oversize !!! $o > $ENV_OFFSET">&2
    [ "$NO_CHK_OVERSIZE" ] || exit 1 
}

USER_DATA_OFFSET_HEX=$(HEX $o)
user_data_size_hex=$(HEX $user_data_size)

## 
echo "
    USER@0 {
        label = \"USER\";
        reg = <$USER_DATA_OFFSET_HEX $user_data_size_hex>;
    };

    };
};
" >> $SPI_PARTS_DTS

echo "$SPI_PARTS_CMDLINE" | tee  $SPI_PARTS_CMD
##


UBOOT_SCRIPT_ENV_TMP=$UNI.script.env.tmp

echo "[i] rebuild script env $UBOOT_SCRIPT_ENV">&2
printf "" > $UBOOT_SCRIPT_ENV_TMP
for u in $UBOOT_SCRIPT_ENV; do
    [ -f $u ] && {
	echo "[i] add $u">&2
	cat $u >> $UBOOT_SCRIPT_ENV_TMP
    }
done

CMD dd if=$UBOOT_SCRIPT_ENV_TMP \
    bs=$BLOCK_SIZH \
    conv=notrunc \
    of="$S/UENV.PAD" 1>/dev/null 2>/dev/null

[ -s $OUT ] && rm $OUT

for s in \
UBOOT.PAD \
DTB.PAD \
SCRIPT.PAD \
UENV.PAD \
LOGO.PAD \
UIMAGE.PAD \
UINITRD.PAD; do

    echo "[i] concat $s">&2
    cat $S/$s >> $OUT

done


ln -sf $OUT $OUT_SPI

ls -l1L $OUT

gzip -c $OUT > $OUT.gz

ls -l1L $OUT.gz

echo "[i] image $OUT.gz - is ready">&2

echo "[i] image $OUT_SPI -> $OUT - is ready">&2

SPI_BOOT_CMD="
sf probe 0 104000000; sf read \$loadaddr $UBOOT_SCRIPT_SCR_OFFSET_HEX 8192 && script \$loadaddr 8192
"


echo "SPI_BOOT_CMD: $SPI_BOOT_CMD"