scripts/tizen/sd_fusing_rpi4.sh

   1 #!/bin/bash
   2
   3 declare FORMAT=""
   4 declare DEVICE=""
   5 declare -i OLD_DD=0
   6
   7 # Binaires array for fusing
   8 declare -a FUSING_BINARY_ARRAY
   9 declare -i FUSING_BINARY_NUM=0
  10
  11 declare CONV_ASCII=""
  12 declare -i FUS_ENTRY_NUM=0
  13 declare -i ab_option=0
  14
  15 # binary name | part number | bs | label | fs type
  16 declare -a PART_TABLE=(
  17         "boot.img"                      1       4M      boot_a                  vfat
  18         "rootfs.img"                    2       4M      rootfs_a                ext4
  19         "system-data.img"               3       4M      system-data             ext4
  20         "user.img"                      5       4M      user                    ext4
  21         "modules.img"                   6       4M      module_a                ext4
  22         "ramdisk.img"                   7       4M      ramdisk_a               ext4
  23         "ramdisk-recovery.img"          8       4M      ramdisk-recovery_a      ext4
  24         "hal.img"                       10      4M      hal_a                   ext4
  25         "boot.img"                      11      4M      boot_b                  vfat
  26         "rootfs.img"                    12      4M      rootfs_b                ext4
  27         "modules.img"                   13      4M      module_b                ext4
  28         "ramdisk.img"                   14      4M      ramdisk_b               ext4
  29         "ramdisk-recovery.img"          15      4M      ramdisk-recovery_b      ext4
  30         "hal.img"                       16      4M      hal_b                   ext4
  31         )
  32 declare -a PART_TABLE_B=(
  33         "boot.img"                      11      4M      boot_b                  vfat
  34         "rootfs.img"                    12      4M      rootfs_b                ext4
  35         "modules.img"                   13      4M      module_b                ext4
  36         "ramdisk.img"                   14      4M      ramdisk_b               ext4
  37         "ramdisk-recovery.img"          15      4M      ramdisk-recovery_b      ext4
  38         "hal.img"                       16      4M      hal_b                   ext4
  39         )
  40
  41 declare -r -i PART_TABLE_COL=5
  42 declare -r -i PART_TABLE_ROW=${#PART_TABLE[*]}/${PART_TABLE_COL}
  43 declare -r -i PART_TABLE_ROW_B=${#PART_TABLE_B[*]}/${PART_TABLE_COL}
  44
  45 # partition table support
  46 function get_index_use_name () {
  47         local -r binary_name=$1
  48
  49         for ((idx=0;idx<$PART_TABLE_ROW;idx++)); do
  50                 if [ ${PART_TABLE[idx * ${PART_TABLE_COL} + 0]} == "$binary_name" ]; then
  51                         return $idx
  52                 fi
  53         done
  54
  55         # return out of bound index
  56         return $idx
  57 }
  58
  59 # partition table support
  60 function get_index_use_name_to_b () {
  61         local -r binary_name=$1
  62
  63         for ((idx=0;idx<$PART_TABLE_ROW_B;idx++)); do
  64                 if [ ${PART_TABLE_B[idx * ${PART_TABLE_COL} + 0]} == "$binary_name" ]; then
  65                         return $idx
  66                 fi
  67         done
  68
  69         # return out of bound index
  70         return $idx
  71 }
  72
  73 function print_message () {
  74         local color=$1
  75         local message=$2
  76
  77         tput setaf $color
  78         tput bold
  79         echo ""
  80         echo $message
  81         tput sgr 0
  82 }
  83
  84 function check_ddversion () {
  85         # NOTE
  86         # before coreutils dd 8.24, dd doesn't support "status=progress"
  87         # and the option causes fusing failure. For backward compatibility,
  88         # do not use the option for old dd
  89         local version=(`dd --version | head -1 | grep -o '[0-9]\+'`)
  90         local major=${version[0]}
  91         local minor=${version[1]}
  92
  93         if [ $major -lt 8 ];  then
  94                 OLD_DD=1
  95         elif [ $major -eq 8 -a $minor -lt 24 ];  then
  96                 OLD_DD=1
  97         fi
  98 }
  99
 100 function fusing_image () {
 101         if [ $ab_option == 2 ] ; then
 102                 echo "Skip to update Partitoin A"
 103                 return
 104         fi
 105         local -r fusing_img=$1
 106
 107         # get binary info using basename
 108         get_index_use_name $(basename "$fusing_img")
 109         local -r -i part_idx=$?
 110
 111         if [ $part_idx -ne $PART_TABLE_ROW ];then
 112                 local -r num=${PART_TABLE[${part_idx} * ${PART_TABLE_COL} + 1]}
 113                 if [ "${num}" == "" ]; then
 114                         local -r blktype=disk
 115                 else
 116                         local -r blktype=part
 117                 fi
 118                 local -r device=/dev/`lsblk ${DEVICE} -o TYPE,KNAME | awk "/^${blktype}.*[a-z]${num}\$/ { print \\\$2 }"`
 119                 local -r bs=${PART_TABLE[${part_idx} * ${PART_TABLE_COL} + 2]}
 120         else
 121                 echo "Not supported binary: $fusing_img"
 122                 return
 123         fi
 124
 125         local -r input_size=`du -b $fusing_img | awk '{print $1}'`
 126         local -r input_size_mb=`expr $input_size / 1024 / 1024`
 127
 128         print_message 2 "[Fusing $1 ($input_size_mb MiB)]"
 129         if [ "$blktype" == "part" ]; then
 130                 local MOUNT_PART=`mount | grep $device`
 131                 if [ "$MOUNT_PART" != "" ]; then
 132                         umount $device
 133                 fi
 134         fi
 135         if [ $OLD_DD == 1 ]; then
 136                 dd if=$fusing_img | pv -s $input_size | dd of=$device bs=$bs
 137         else
 138                 dd if=$fusing_img of=$device bs=$bs status=progress oflag=direct
 139         fi
 140 }
 141
 142 function fusing_image_to_b () {
 143         if [ $ab_option == 0 ]  ; then
 144                 echo "Skip to update Partitoin B"
 145                 return
 146         fi
 147         local -r fusing_img=$1
 148
 149         # get binary info using basename
 150         get_index_use_name_to_b $(basename "$fusing_img")
 151
 152         local -r -i part_idx=$?
 153
 154         if [ $part_idx -ne $PART_TABLE_ROW_B ];then
 155                 local -r num=${PART_TABLE_B[${part_idx} * ${PART_TABLE_COL} + 1]}
 156                 if [ "${num}" == "" ]; then
 157                         local -r blktype=disk
 158                 else
 159                         local -r blktype=part
 160                 fi
 161                 local -r device=/dev/`lsblk ${DEVICE} -o TYPE,KNAME | awk "/^${blktype}.*[a-z]${num}\$/ { print \\\$2 }"`
 162                 local -r bs=${PART_TABLE_B[${part_idx} * ${PART_TABLE_COL} + 2]}
 163         else
 164                 echo "Not supported binary: $fusing_img"
 165                 return
 166         fi
 167
 168         local -r input_size=`du -b $fusing_img | awk '{print $1}'`
 169         local -r input_size_mb=`expr $input_size / 1024 / 1024`
 170
 171         print_message 2 "[Fusing $1 ($input_size_mb MiB)]"
 172         if [ "$blktype" == "part" ]; then
 173                 local MOUNT_PART=`mount | grep $device`
 174                 if [ "$MOUNT_PART" != "" ]; then
 175                         umount $device
 176                 fi
 177         fi
 178         if [ $OLD_DD == 1 ]; then
 179                 dd if=$fusing_img | pv -s $input_size | dd of=$device bs=$bs
 180         else
 181                 dd if=$fusing_img of=$device bs=$bs status=progress oflag=direct
 182         fi
 183 }
 184
 185 function fuse_image_tarball () {
 186         local -r filepath=$1
 187         local -r temp_dir="tar_tmp"
 188
 189         mkdir -p $temp_dir
 190         tar xvf $filepath -C $temp_dir
 191         cd $temp_dir
 192
 193         for file in *
 194         do
 195                 fusing_image $file
 196                 fusing_image_to_b $file
 197         done
 198
 199         cd ..
 200         rm -rf $temp_dir
 201         eval sync
 202 }
 203
 204 function initialize_parameter () {
 205         # create "reboot-param.bin" file in inform partition for passing reboot parameter
 206         # It should be done only once upon partition format.
 207         local -r DISK=$DEVICE
 208         local -r PART9=/dev/`lsblk ${DISK} -o TYPE,KNAME | grep part | awk '{ print $2 }' | grep -G "[a-z]9\$"`
 209
 210         if [ -d mnt_tmp ]; then
 211                 echo "Remove the existing mnt_tmp directory!!"
 212                 rm -rf mnt_tmp
 213         fi
 214         mkdir mnt_tmp
 215         mount -t ext4 ${PART9} ./mnt_tmp
 216         echo "norm" > ./mnt_tmp/reboot-param.bin
 217         echo "norm" > ./mnt_tmp/reboot-param.info
 218         echo "a" > ./mnt_tmp/partition-ab.info
 219         echo "1" > ./mnt_tmp/partition-ab-cloned.info
 220         echo "0" > ./mnt_tmp/upgrade-status.info
 221
 222         # To check the status of partition. (default "ok")
 223         echo "ok" > ./mnt_tmp/partition-a-status.info
 224         echo "ok" > ./mnt_tmp/partition-b-status.info
 225
 226         sync
 227         umount ./mnt_tmp
 228         rmdir mnt_tmp
 229 }
 230
 231 function fuse_image () {
 232
 233         if [ "$FUSING_BINARY_NUM" == 0 ]; then
 234                 return
 235         fi
 236
 237         # Clear preivous values before flashing image
 238         initialize_parameter
 239
 240         for ((fuse_idx = 0 ; fuse_idx < $FUSING_BINARY_NUM ; fuse_idx++))
 241         do
 242                 local filename=${FUSING_BINARY_ARRAY[fuse_idx]}
 243
 244                 case "$filename" in
 245                     *.tar | *.tar.gz)
 246                         fuse_image_tarball $filename
 247                         ;;
 248                     *)
 249                         fusing_image $filename
 250                         fusing_image_to_b $filename
 251                         ;;
 252                 esac
 253         done
 254         echo ""
 255 }
 256
 257 # partition format
 258 function mkpart_3 () {
 259         # NOTE: if your sfdisk version is less than 2.26.0, then you should use following sfdisk command:
 260         # sfdisk --in-order --Linux --unit M $DISK <<-__EOF__
 261
 262         # NOTE: sfdisk 2.26 doesn't support units other than sectors and marks --unit option as deprecated.
 263         # The input data needs to contain multipliers (MiB) instead.
 264         local version=(`sfdisk -v | grep -o '[0-9]\+'`)
 265         local major=${version[0]}
 266         local minor=${version[1]}
 267         local sfdisk_new=0
 268         local support_delete=0
 269
 270         if [ $major -gt 2 ];  then
 271                 sfdisk_new=1
 272                 if [ $major -eq 2 -a $minor -ge 28 ]; then
 273                         support_delete=1
 274                 fi
 275         else
 276                 if [ $major -eq 2 -a $minor -ge 26 ];  then
 277                         sfdisk_new=1
 278                 fi
 279         fi
 280
 281         if [ $sfdisk_new == 0 ]; then
 282                 echo "$(tput setaf 3)$(tput bold)NOTICE: Your sfdisk ${version[0]}.${version[1]}  version is too old. Update Latest sfdisk!"
 283                 tput sgr 0
 284                 exit -1
 285         fi
 286
 287         local -r DISK=$DEVICE
 288         local -r SIZE=`sfdisk -s $DISK`
 289         local -r SIZE_MB=$((SIZE >> 10))
 290
 291         local -r BOOT_SZ=64
 292         local -r ROOTFS_SZ=3072
 293         local -r DATA_SZ=1344
 294         local -r MODULE_SZ=32
 295         local -r RAMDISK_SZ=32
 296         local -r RAMDISK_RECOVERY_SZ=32
 297         local -r INFORM_SZ=8
 298         local -r HAL_SZ=256
 299         local -r PARAM_SZ=4
 300         local -r RESERVED1_SZ=64
 301         local -r RESERVED2_SZ=125
 302         local -r EXTEND_SZ=36
 303
 304         let "USER_SZ = $SIZE_MB - $BOOT_SZ * 2 - $ROOTFS_SZ * 2 - $DATA_SZ - $MODULE_SZ * 2 - $RAMDISK_SZ * 2 - $RAMDISK_RECOVERY_SZ * 2 - $INFORM_SZ - $EXTEND_SZ - $HAL_SZ * 2 - $RESERVED1_SZ - $RESERVED2_SZ - $PARAM_SZ"
 305
 306         local -r BOOT_A=${PART_TABLE[0 * ${PART_TABLE_COL} + 3]}
 307         local -r ROOTFS_A=${PART_TABLE[1 * ${PART_TABLE_COL} + 3]}
 308         local -r SYSTEMDATA=${PART_TABLE[2 * ${PART_TABLE_COL} + 3]}
 309         local -r USER=${PART_TABLE[3 * ${PART_TABLE_COL} + 3]}
 310         local -r MODULE_A=${PART_TABLE[4 * ${PART_TABLE_COL} + 3]}
 311         local -r RAMDISK_A=${PART_TABLE[5 * ${PART_TABLE_COL} + 3]}
 312         local -r RAMDISK_RECOVERY_A=${PART_TABLE[6 * ${PART_TABLE_COL} + 3]}
 313         local -r INFORM=inform
 314         local -r HAL_A=${PART_TABLE[7 * ${PART_TABLE_COL} + 3]}
 315         local -r BOOT_B=${PART_TABLE[8 * ${PART_TABLE_COL} + 3]}
 316         local -r ROOTFS_B=${PART_TABLE[9 * ${PART_TABLE_COL} + 3]}
 317         local -r MODULE_B=${PART_TABLE[10 * ${PART_TABLE_COL} + 3]}
 318         local -r RAMDISK_B=${PART_TABLE[11 * ${PART_TABLE_COL} + 3]}
 319         local -r RAMDISK_RECOVERY_B=${PART_TABLE[12 * ${PART_TABLE_COL} + 3]}
 320         local -r HAL_B=${PART_TABLE[13 * ${PART_TABLE_COL} + 3]}
 321         local -r RESERVED0=reserved0
 322         local -r RESERVED1=reserved1
 323         local -r RESERVED2=reserved2
 324
 325         if [[ $USER_SZ -le 100 ]]
 326         then
 327                 echo "We recommend to use more than 8GB disk"
 328                 exit 0
 329         fi
 330
 331         echo "================================================"
 332         echo "Label                     dev             size"
 333         echo "================================================"
 334         echo $BOOT_A"                   " $DISK"1       " $BOOT_SZ "MB"
 335         echo $ROOTFS_A"                 " $DISK"2       " $ROOTFS_SZ "MB"
 336         echo $SYSTEMDATA"               " $DISK"3       " $DATA_SZ "MB"
 337         echo "[Extend]""                " $DISK"4"
 338         echo " "$USER"                  " $DISK"5       " $USER_SZ "MB"
 339         echo " "$MODULE_A"              " $DISK"6       " $MODULE_SZ "MB"
 340         echo " "$RAMDISK_A"             " $DISK"7       " $RAMDISK_SZ "MB"
 341         echo " "$RAMDISK_RECOVERY_A"    " $DISK"8       " $RAMDISK_RECOVERY_SZ "MB"
 342         echo " "$INFORM"                " $DISK"9       " $INFORM_SZ "MB"
 343         echo " "$HAL_A"                 " $DISK"10      " $HAL_SZ "MB"
 344         echo " "$BOOT_B"                " $DISK"11      " $BOOT_SZ "MB"
 345         echo " "$ROOTFS_B"              " $DISK"12      " $ROOTFS_SZ "MB"
 346         echo " "$MODULE_B"              " $DISK"13      " $MODULE_SZ "MB"
 347         echo " "$RAMDISK_B"             " $DISK"14      " $RAMDISK_SZ "MB"
 348         echo " "$RAMDISK_RECOVERY_B"    " $DISK"15      " $RAMDISK_RECOVERY_SZ "MB"
 349         echo " "$HAL_B"                 " $DISK"16      " $HAL_SZ "MB"
 350         echo " "$RESERVED0"             " $DISK"17      " $PARAM_SZ "MB"
 351         echo " "$RESERVED1"             " $DISK"18      " $RESERVED1_SZ "MB"
 352         echo " "$RESERVED2"             " $DISK"19      " $RESERVED2_SZ "MB"
 353
 354         local MOUNT_LIST=`mount | grep $DISK | awk '{print $1}'`
 355         for mnt in $MOUNT_LIST
 356         do
 357                 umount $mnt
 358         done
 359
 360         echo "Remove partition table..."
 361         dd if=/dev/zero of=$DISK bs=512 count=32 conv=notrunc
 362
 363         if [ $support_delete == 1 ]; then
 364                 sfdisk --delete $DISK
 365         fi
 366
 367         SCRIPT=""
 368         for ((idx=0; idx < $PART_TABLE_ROW; idx++)); do
 369                 NR=${PART_TABLE[idx * ${PART_TABLE_COL} + 1]}
 370                 eval "PART_LABEL_NR_${NR}=${PART_TABLE[idx * ${PART_TABLE_COL} + 3]}"
 371         done
 372
 373         sfdisk $DISK <<-__EOF__
 374         label: gpt
 375         ${DEVICE}1 : start=4MiB, size=${BOOT_SZ}MiB, type= C12A7328-F81F-11D2-BA4B-00A0C93EC93B, name=${PART_LABEL_NR_1}
 376         ${DEVICE}2 : size=${ROOTFS_SZ}MiB, name=${PART_LABEL_NR_2}
 377         ${DEVICE}3 : size=${DATA_SZ}MiB, name=${PART_LABEL_NR_3}
 378         ${DEVICE}4 : size=${EXTEND_SZ}MiB, name=none
 379         ${DEVICE}5 : size=${USER_SZ}MiB, name=${PART_LABEL_NR_5}
 380         ${DEVICE}6 : size=${MODULE_SZ}MiB, name=${PART_LABEL_NR_6}
 381         ${DEVICE}7 : size=${RAMDISK_SZ}MiB, name=${PART_LABEL_NR_7}
 382         ${DEVICE}8 : size=${RAMDISK_RECOVERY_SZ}MiB, name=${PART_LABEL_NR_8}
 383         ${DEVICE}9 : size=${INFORM_SZ}MiB, name=inform
 384         ${DEVICE}10: size=${HAL_SZ}MiB, name=${PART_LABEL_NR_10}
 385         ${DEVICE}11: size=${BOOT_SZ}MiB, type= C12A7328-F81F-11D2-BA4B-00A0C93EC93B, name=${PART_LABEL_NR_11}
 386         ${DEVICE}12: size=${ROOTFS_SZ}MiB, name=${PART_LABEL_NR_12}
 387         ${DEVICE}13: size=${MODULE_SZ}MiB, name=${PART_LABEL_NR_13}
 388         ${DEVICE}14: size=${RAMDISK_SZ}MiB, name=${PART_LABEL_NR_14}
 389         ${DEVICE}15: size=${RAMDISK_RECOVERY_SZ}MiB, name=${PART_LABEL_NR_15}
 390         ${DEVICE}16: size=${HAL_SZ}MiB, name=${PART_LABEL_NR_16}
 391         ${DEVICE}17: size=${PARAM_SZ}MiB, name=reserved0
 392         ${DEVICE}18: size=${RESERVED1_SZ}MiB, name=reserved1
 393         ${DEVICE}19: size=${RESERVED2_SZ}MiB, name=reserved2
 394         __EOF__
 395
 396
 397         for ((idx=0;idx<$PART_TABLE_ROW;idx++)); do
 398                 local PART=/dev/`lsblk ${DISK} -o TYPE,KNAME | awk "/^part.*[a-z]${PART_TABLE[$idx * ${PART_TABLE_COL} + 1]}\$/ { print \\\$2 }"`
 399                 if [ "${PART_TABLE[$idx * ${PART_TABLE_COL} + 4]}" == "vfat" ]; then
 400                         mkfs.vfat -F 16 ${PART} -n ${PART_TABLE[$idx * ${PART_TABLE_COL} + 3]}
 401                         if [ $? -eq 1 ]; then
 402                                 echo "Failed to format as FAT filesystem"
 403                                 exit -1
 404                         fi
 405                 elif [ "${PART_TABLE[$idx * ${PART_TABLE_COL} + 4]}" == "ext4" ]; then
 406                         mkfs.ext4 -q ${PART} -L ${PART_TABLE[$idx * ${PART_TABLE_COL} + 3]} -F
 407                 else
 408                         echo "Skip to format for unknown filesystem type ${PART_TABLE[$idx * ${PART_TABLE_COL} + 4]} for part$idx, ${PART_TABLE[$idx * ${PART_TABLE_COL} + 3]}"
 409                 fi
 410         done
 411
 412         local -r PART9=/dev/`lsblk ${DISK} -o TYPE,KNAME | grep part | awk '{ print $2 }' | grep -G "[a-z]9\$"`
 413         mkfs.ext4 -q ${PART9} -L $INFORM -F -O ^metadata_csum
 414
 415         # initialize value of parameters
 416         initialize_parameter
 417
 418         local -r PART17=/dev/`lsblk ${DISK} -o TYPE,KNAME | grep part | awk '{ print $2 }' | grep -G "[a-z]17\$"`
 419         mkfs.ext4 -q ${PART17} -L $RESERVED0 -F
 420
 421         local -r PART18=/dev/`lsblk ${DISK} -o TYPE,KNAME | grep part | awk '{ print $2 }' | grep -G "[a-z]18\$"`
 422         mkfs.ext4 -q ${PART18} -L $RESERVED1 -F
 423
 424         local -r PART19=/dev/`lsblk ${DISK} -o TYPE,KNAME | grep part | awk '{ print $2 }' | grep -G "[a-z]19\$"`
 425         mkfs.ext4 -q ${PART19} -L $RESERVED2 -F
 426 }
 427
 428 function show_usage () {
 429         echo "- Usage:"
 430         echo "  sudo ./sd_fusing*.sh -d <device> [-b <path> <path> ..] [--format] [--update [b] ]"
 431         echo "  -d  : device ndoe "
 432         echo "  -b  : binary "
 433         echo "  --update : If want to update Image about B Partition, use --update option with b"
 434         echo "             Otherwise, it will be updated to both partition"
 435 }
 436
 437 function check_partition_format () {
 438         if [ "$FORMAT" != "2" ]; then
 439                 echo "-----------------------"
 440                 echo "Skip $DEVICE format"
 441                 echo "-----------------------"
 442                 return 0
 443         fi
 444
 445         echo "-------------------------------"
 446         echo "Start $DEVICE format"
 447         echo ""
 448         mkpart_3
 449         echo "End $DEVICE format"
 450         echo "-------------------------------"
 451         echo ""
 452 }
 453
 454 function check_args () {
 455         if [ "$DEVICE" == "" ]; then
 456                 echo "$(tput setaf 1)$(tput bold)- Device node is empty!"
 457                 show_usage
 458                 tput sgr 0
 459                 exit 0
 460         fi
 461
 462         if [ "$DEVICE" != "" ]; then
 463                 echo "Device: $DEVICE"
 464         fi
 465
 466         if [ "$FUSING_BINARY_NUM" != 0 ]; then
 467                 echo "Fusing binary: "
 468                 for ((bid = 0 ; bid < $FUSING_BINARY_NUM ; bid++))
 469                 do
 470                         echo "  ${FUSING_BINARY_ARRAY[bid]}"
 471                 done
 472                 echo ""
 473         fi
 474
 475         if [ "$FORMAT" == "1" ]; then
 476                 echo ""
 477                 echo "$(tput setaf 3)$(tput bold)$DEVICE will be formatted, Is it OK? [y/<n>]"
 478                 tput sgr 0
 479                 read input
 480                 if [ "$input" == "y" ] || [ "$input" == "Y" ]; then
 481                         FORMAT=2
 482                 else
 483                         FORMAT=0
 484                 fi
 485         fi
 486 }
 487
 488 function check_device () {
 489         if [ ! -b "$DEVICE" ]; then
 490                 echo "No such device: $DEVICE"
 491                 exit 0
 492         fi
 493
 494         DEVICE=/dev/`lsblk $DEVICE -o TYPE,KNAME | awk "/^disk/ { print \\\$2 }"`
 495
 496         local REMOVABLE=`lsblk $DEVICE -nd -o RM | grep 1 | wc -l`
 497         if [ "$REMOVABLE" == "0" ]; then
 498                 echo ""
 499                 echo "$(tput setaf 3)$(tput bold)$DEVICE is not a removable disk, Is it OK? [y/<n>]"
 500                 tput sgr 0
 501                 read input
 502                 if [ "$input" != "y" ] && [ "$input" != "Y" ]; then
 503                         exit 0
 504                 fi
 505         fi
 506
 507         if [ ! -w "$DEVICE" ]; then
 508                 echo "Write not permitted: $DEVICE"
 509                 exit 0
 510         fi
 511 }
 512
 513 function print_logo () {
 514         echo ""
 515         echo "Raspberry Pi4 downloader, version 1.0.9"
 516         echo ""
 517 }
 518
 519 print_logo
 520
 521 function add_fusing_binary() {
 522         local declare binary_name=$1
 523
 524         if [ "$binary_name" != "" ]; then
 525                 if [ -f "$binary_name" ]; then
 526                         FUSING_BINARY_ARRAY[$FUSING_BINARY_NUM]=$binary_name
 527
 528                         FUSING_BINARY_NUM=$((FUSING_BINARY_NUM + 1))
 529                 else
 530                         echo "No such file: $binary_name"
 531                 fi
 532         fi
 533 }
 534
 535
 536 declare -i binary_option=0
 537
 538 while test $# -ne 0; do
 539         option=$1
 540         shift
 541
 542         case $option in
 543         --f | --format)
 544                 FORMAT="1"
 545                 binary_option=0
 546                 ;;
 547         -d)
 548                 DEVICE=$1
 549                 binary_option=0
 550                 shift
 551                 ;;
 552         -b)
 553                 add_fusing_binary $1
 554                 binary_option=1
 555                 shift
 556                 ;;
 557         --update)
 558                 if [ "$1" == "b" ] ; then
 559                         ab_option=2
 560                 else
 561                         ab_option=1
 562                 fi
 563                 shift
 564                 ;;
 565         *)
 566                 if [ $binary_option == 1 ];then
 567                         add_fusing_binary $option
 568                 else
 569                         echo "Unkown command: $option"
 570                         exit
 571                 fi
 572                 ;;
 573         esac
 574 done
 575
 576 check_args
 577 check_device
 578 check_partition_format
 579 check_ddversion
 580 fuse_image