prepare_sd_image_rescue_vim2_uboots.2

#!/bin/sh

## hyphop ##

#= prerape rescue image for sd/usb/mmc disk - vfat - uboots 

## usage ./prapare_sd_image_rescue [-r] [ /dev/FLASHDISK ] | [ @remote_host ]

set -e

DEV="$1"

sudo=sudo

mkimage=$(dirname $0)/mkimage2

REBUILD_RESCUE=

DEV2=/dev/mmcblk1

UBOOT_VER=

for a in "$@"; do
case $a in
    -r)
    REBUILD_RESCUE=1
    ;;
    -1)
UBOOT_VER=1
DEVNAME="VIM$UBOOT_VER"
    ;;
    -2)
UBOOT_VER=2
DEVNAME="VIM$UBOOT_VER"
    ;;
    -3)
UBOOT_VER=3
DEVNAME="VIM$UBOOT_VER"
    ;;
    -3l|-3L)
UBOOT_VER=3l
DEVNAME="VIM$UBOOT_VER"
    ;;
    -e)
UBOOT_VER=e
DEVNAME="Edge"
    ;;
    *@*)
    DEV="$a"
    ;;
#    /dev/mmc*)
#    DEV2=$a
#    ;;
    *)
    [ -b "$a" ] && {
	DEV="$a"
    }
    ;;
esac
done

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


[ "" ] && {
case "$UBOOT_VER" in

    echo "[i] change uboot version to $UBOOT_VER">&2
#
    1|2|3|3l)

    UBOOT_BIN="$TU/VIM$UBOOT_VER.u-boot.spi.bin"

    CMD ln -sf $TU/VIM$UBOOT_VER.u-boot.sd.bin $UBOOT_SD
    CMD ln -sf $TU/VIM$UBOOT_VER.u-boot.spi.bin $UBOOT_SPI
    ;;

    e)

    UBOOT_BIN="$TU/Edge.u-boot.spi.bin"

    CMD ln -sf $TU/Edge.u-boot.sd.bin $UBOOT_SD
    CMD ln -sf $TU/Edge.u-boot.spi.bin $UBOOT_SPI
    ;;

esac
}

## rebuild rescue image
export UBOOT_BIN=$UBOOT_BIN
export DEVNAME=$DEVNAME
export UBOOT_VER=$UBOOT_VER

[ "$REBUILD_RESCUE" ] && {
    #NOCACHE=1 
    $(dirname $0)/pack_image -r 
}

CMD(){
    echo "[#] $@">&2
    "$@"
}

D=/tmp/krescue.sd
D2=/tmp/krescue.sd.tmp

#grep $D /proc/mounts && CMD $sudo umount $D
#CMD $sudo losetup -D

[ -d "$D" ] && rm -rf "$D"
[ -d "$D" ] || mkdir -p "$D"

UBOOT_SD=../share/u-boot.sd.bin
UBOOT_SPI=../share/u-boot.spi.bin

#u-boot.sd.bin
#u-boot.vim1.sd.bin

TU="/tmp/u-boot-mainline"


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

P=$PWD

DD=$D.img
DDRN="$(dirname $D)/$DEVNAME.$(basename $D)"

OF=3276 ## 1.6M before
OF=3200 ## 1638400 bytes UBOOT AREA before $((512*32*100))

S=$((36*1024*1024))
#S=$((52*1024*1024))
S=$((64*1024*1024))	# total 64M
BS=512

RESCUE=/rescue
[ -d $D$RESCUE ] || CMD mkdir -p  $D$RESCUE
CMD mkdir -p  $D.tmp

echo "$(TZ= date)" > $D.tmp/generated.date
echo "$(TZ= date +%s )" > $D.tmp/generated.time
DATE=$(cat $D.tmp/generated.date)
TIME=$(cat $D.tmp/generated.time)

#grep  --binary-files=text KRESCUE_INFO -A3 krescue.sd.img

#grep  --binary-files=text KRESCUE_INFO -A20 krescue.sd.img | grep --binary-files=text -B20 KRESCUE-INFO


## copy files 

[ -d $D$RESCUE/docs ] || CMD mkdir -p  $D$RESCUE/docs

CMD cp -L ../docs/README-rescue.md $D
CMD cp -L ../docs/README-rescue* $D$RESCUE/docs
#CMD cp -L ../share/Image $D$RESCUE
CMD cp -L ../share/uInitrd* $D$RESCUE
CMD cp -L ../share/uImage $D$RESCUE
#CMD cp -L ../share/uImage* $D$RESCUE
#CMD cp -L ../share/kvim3_linux.dtb $D$RESCUE/uboot.dtb
#CMD cp -L ../share/kvim3_linux.dtb $D$RESCUE/uboot.dtb
#CMD cp -L ../share/*_linux.dtb $D$RESCUE
#CMD cp -L ../share/linux.dtb $D$RESCUE/linux.dtb

#CMD cp -L ../share/kvim_linux.dtb $D$RESCUE/vim1.dtb
#CMD cp -L ../share/kvim2_linux.dtb $D$RESCUE/vim2.dtb
#CMD cp -L ../share/kvim3_linux.dtb $D$RESCUE/vim3.dtb
#CMD cp -L ../share/kvim3_linux.dtb $D$RESCUE/vim3-a311d.dtb
#CMD cp -L ../share/kvim3_linux.dtb $D$RESCUE/vim3-s922x.dtb
#CMD cp -L ../share/kvim3l_linux.dtb $D$RESCUE/vim3-s905d3.dtb

[ "" ] && {
for f in ../share/krescue-*.dtb; do
    [ -f "$f" ] && {
	CMD cp -L $f $D$RESCUE
    }
done
}

[ "1" ] && {
for f in /tmp/modules/*.dtb; do
    [ -f "$f" ] && {
	CMD cp -L $f $D$RESCUE
    }
done
}

CMD cp -L ../files/splash.bmp.gz $D$RESCUE
CMD cp -L ../files/splash.bmp.2.gz $D$RESCUE
CMD cp -L ../files/splash2.bmp $D/splash.bmp
#CMD cp ../files/*_env.txt $D$RESCUE
CMD cp -L ../share/*_env.txt $D$RESCUE

CMD cp -L ../files/rescue.cmd $D$RESCUE
CMD cp -Lr ../files/extra $D$RESCUE

#../files/extra/cmd2scr.sh $D$RESCUE/rescue.cmd
CMD $mkimage -C none -A arm -T script -d $D$RESCUE/rescue.cmd $D$RESCUE/rescue.scr

cat ../files/boot.ini ../files/rescue.cmd >> $D/boot.ini
CMD mkdir $D/boot
cat ../files/boot.ini ../files/rescue.cmd >> $D/boot/boot.ini

CMD cp $D$RESCUE/rescue.cmd $D$RESCUE/hook.cmd
CMD cp $D$RESCUE/rescue.scr $D$RESCUE/hook.scr
CMD cp $D$RESCUE/rescue.scr $D/boot.scr.uimg
CMD cp $D$RESCUE/rescue.scr $D/boot.scr.uimg
CMD cp $D$RESCUE/rescue.scr $D/s905_autoscript
CMD cp $D$RESCUE/rescue.scr $D/aml_autoscript
CMD cp $D$RESCUE/rescue.scr $D/cfgload		# coreelec

#CMD cp ../share/openwrt_khadas_fw_vims.tar.xz $D$RESCUE

[ "" ] && {
for v in vim3 vim3l vim2 vim1; do
for t in sd spi; do
for s in /tmp ../bin; do
U="$s/uboot_$v/u-boot.$t.bin"
[ -f "$U" ] && {
    CMD cp "$U" "$D$RESCUE/u-boot.$v.$t.bin"
    break
}

done
done
done

}

[ "1" ] && {
for v in VIM3 VIM3L VIM2 VIM1 Edge; do
for t in sd.bin spi.bin bin.gz; do
#for s in /tmp ../bin; do
#U="$s/uboot_vims/u-boot.$v.$t"
#U="$s/uboot-mainline/u-boot.$v.$t"
U="$TU/$v.u-boot.$t"
[ -f "$U" ] && {
    case $U in
#	*gz)
#	gzip -dc "$U" > "$D$RESCUE/u-boot.$v.bin"
#	;;
	*)
	CMD cp "$U" "$D$RESCUE"
	;;
    esac
    break
}

done
done
done
}

SPI_IMG=

[ "$SPI_IMG" ] && {
[ -f /tmp/krescue.spi.bin ] && {
CMD cp /tmp/krescue.spi.bin $D$RESCUE/
}
}

SS=$D$RESCUE/scripts
[ -d $SS ] || CMD mkdir -p $SS
CMD cp ../scripts/sd/* $SS

### OFFSET SIZE TOTAL
PART_="${OF} $((S/$BS - $OF)) $((S/$BS))"
echo "$PART_" > $D$RESCUE/generated.part

PPP=$PWD
cd $D
rsync -ra . > $D.tmp/files.list
#rsync -ra . | tail -n+2 $D.tmp/files.list
find  -type f -exec md5sum {} \; > $D.tmp/files.md5sum
cd $PPP
cp $D.tmp/files.* $D$RESCUE
echo "# grep ./ /tmp/files.md5sum | sort -d | md5sum | head -c32">&2
#grep ./ /boot/rescue/files.md5sum | sort -d | md5sum
HASH=$(grep ./ /tmp/files.md5sum | sort -d | md5sum | head -c32 | tee $D.tmp/generated.hash)
#sed -i "s/$HASH/hash: $(cat $D.tmp/generated.hash)/" $DD.vfat

mv $D.tmp/generated.* $D$RESCUE

#HASH="hash: --------------------------------"

(
printf "\n##KRESCUE_INFO\n"
echo "hash: $HASH"
echo "date: $DATE"
echo "time: $TIME"
echo "size: $S"
echo "part: $PART_"
echo "builder: hyphop"
printf "\n##KRESCUE-INFO\n"
) > $DD.msg

CMD dd if=/dev/zero bs=$BS count=$((S/$BS - $OF)) of=$DD.vfat
CMD mkfs.vfat -n rescue -i DEADBEEF -m $DD.msg $DD.vfat
CMD mdir -i $DD.vfat ::

PPPP=$PWD
cd $D
CMD mcopy -sp -i $DD.vfat $(ls --group-directories-first .) ::
CMD mdir -i $DD.vfat -/ ::
cd $PPPP

CMD sync

#[ "$TAR" ] && {
#    CMD tar -czf $D.tar.gz -C$D .

META="$HASH-$TIME-$S-"

T="${D%.sd}-$META.sd.tar"

echo "[T] $T"

case $TAR in
    1|gz)
#    tar -cf- -C$D . | gzip -c -9 > $D.tar.gz
    CMD tar -cf "$T" -C$D .
    CMD gzip -9 "$T"
    [ -f "$T" ] && rm "$T"
    CMD mv "$T.gz" "$D.tar.gz"
    ;;
    xz)
    CMD tar -cf "$T" -C$D .
    CMD xz -9 "$T"
    [ -f "$T" ] && rm "$T"
    CMD mv "$T.xz" "$D.tar.xz"
    ;;
    zstd)
    ./zstd_header2 "$(basename $T)
$(cat $DD.msg)
" > $D.UPDATE
    tar -cf- -C$D . | zstd --ultra -22 -T0 >> $D.UPDATE
#   tar -cf- -C$D . | zstd -18 -T0 >> $D.UPDATE

./zstd_header2 "
##KRESCUE##END
" >> $D.UPDATE

    ;;
    sfs)
    [ -f $D.sfs ] && rm $D.sfs
    mksquashfs $D $D.sfs -comp gzip -b 1M
    ;;
    sfs2)
    [ -f $D.sfs ] && rm $D.sfs
    mksquashfs $D $D.sfs -comp zstd -b 1M -Xcompression-level 22
    ;;
    "")
    ;;
    *)
    echo "[e] undef tar compress">&2
    exit 1
    ;;
esac
#}

CMD fsck.fat $DD.vfat

CMD dd if=/dev/zero count=$OF bs=$BS of=$DD
CMD dd if=$UBOOT_SD bs=$BS conv=notrunc of=$DD
cat $DD.vfat >> $DD
sync
echo "label:dos" | sfdisk -q $DD
echo "$OF, " | sfdisk -q $DD -a
sfdisk --part-type $DD 1 e
sync

#CMD dd if=$UBOOT_SD  bs=444 count=1 conv=notrunc of=$DD

md5sum $DD | tee $DD.md5sum

echo "[i] rescue sd image: $DD is ready">&2

ls -Ll1 $DD

[ "$GZ" ] && {
#    gzip -c $DD > $DD.gz
#    ls -Ll1 $DD.gz
    echo "[i] make rel $DDRN">&2
    gzip -c $DD > $DDRN.gz

}


echo "[i] maybe write to $DEV">&2

[ -b "$DEV" ] && {

#    echo "[i] type Y for allow write to $DEV">&2
#    [ "$(read YES)" = "Y" ] || {
#	echo "[w] owe wait only Y not $YES">&2
#	exit 1
#    }

    echo "[i] write image $DD -> $DEV flash disk! plz wait...">&2
    CMD $sudo dd if=$DD of=$DEV conv=notrunc bs=8192
    CMD sync
    echo "[i] DONE">&2

    exit
}

### !!!! rebuild

case $DEV in
    *@*)
    TO="root@${DEV#*@}"
    echo "[i] remote ssh write image $DD to sd: $DEV2">&2
    CMD rsync -av --inplace $DD $TO:$DD && {
	echo "
	/opt/sd_boot $DD
	exit 
        " | CMD ssh $TO

    }
#
#    CMD ssh $TO dd of=$DEV2 conv=sync < $DD
    echo "[i] DONE">&2
    exit
    ;;
esac

echo "[i] maybe next command for write it">&2
echo "./image2flash /tmp/krescue.upgrade.disk.img /dev/#your_drive " >&2
echo "# or remote write to sd">&2
echo "ssh root@vimu dd of=/dev/mmcblk1 bs=4096 < /tmp/krescue.spi.bin">&2

echo "[i] DONE">&2