1#!/bin/bash
2set -eo pipefail
3
4# Get the root mtd device number (mtdX) from "/dev/ubiblockX_Y on /"
5function findrootmtd() {
6    rootmatch=" on / "
7    m="$(mount | grep "${rootmatch}" | grep "ubiblock")"
8    m="${m##*ubiblock}"
9    m="${m%_*}"
10    if [ -z "${m}" ]; then
11        # default to bmc mtd (0)
12        m=0
13    fi
14    echo "mtd${m}"
15}
16
17function findrootubi() {
18    rootmatch=" on / "
19    m="$(mount | grep "${rootmatch}")"
20    m="${m##*ubiblock}"
21    m="${m% on*}"
22    echo "ubi${m}"
23}
24
25# Get the mtd device number (mtdX)
26function findmtd() {
27    m="$(grep -xl "$1" /sys/class/mtd/*/name)"
28    m="${m%/name}"
29    m="${m##*/}"
30    echo "${m}"
31}
32
33# Get the mtd device number only (return X of mtdX)
34function findmtdnum() {
35    m="$(findmtd "$1")"
36    m="${m##mtd}"
37    echo "${m}"
38}
39
40# Get the ubi device number (ubiX_Y)
41function findubi() {
42    u="$(grep -xl "$1" /sys/class/ubi/ubi?/subsystem/ubi*/name)"
43    u="${u%/name}"
44    u="${u##*/}"
45    echo "${u}"
46}
47
48# Get the ubi device number (ubiX_Y) on a specific mtd
49function findubi_onmtd() {
50    u="$(grep -xl "$1" /sys/class/ubi/ubi"$2"/subsystem/ubi"$2"*/name)"
51    u="${u%/name}"
52    u="${u##*/}"
53    echo "${u}"
54}
55
56# Get all ubi device names on a specific mtd that match requested string
57function findubiname_onmtd() {
58    u="$(grep -h "$1" /sys/class/ubi/ubi"$2"/subsystem/ubi"$2"*/name)"
59    u="${u%/name}"
60    u="${u##*/}"
61    echo "${u}"
62}
63
64# Get the name from the requested ubiX_Y volume
65function findname() {
66    n="$(cat /sys/class/ubi/"$1"/name)"
67    echo "${n}"
68}
69
70# Set the version path property to the flash location where the image was
71# successfully flashed
72function set_flashid() {
73    busctl set-property xyz.openbmc_project.Software.BMC.Updater \
74        "/xyz/openbmc_project/software/${version}" \
75        xyz.openbmc_project.Common.FilePath \
76        Path s "$1"
77}
78
79# Set the u-boot envs that perform a side switch on failure to boot
80function set_wdt2bite() {
81    if ! fw_printenv wdt2bite 2>/dev/null; then
82        fw_setenv wdt2bite "mw.l 0x1e785024 0xa 1; mw.b 0x1e78502c 0xb3 1"
83        fw_setenv bootalt "run wdt2bite"
84        fw_setenv obmc_bootcmd "ubi part obmc-ubi; run do_rwreset; ubi read \
85\${loadaddr} \${kernelname}; bootm \${loadaddr} || run bootalt"
86    fi
87}
88
89# Make space on flash before creating new volumes. This can be enhanced
90# determine current flash usage. For now only keep a "keepmax" number of them
91function ubi_remove_volumes()
92{
93    rootubi="$(findrootubi)"
94    rootname="$(findname "${rootubi}")"
95    rootversion="${rootname##*-}"
96    rootkernel="kernel-${rootversion}"
97
98    # Just keep max number of volumes before updating, don't delete the version
99    # the BMC is booted from, and when a version is identified to be deleted,
100    # delete both the rofs and kernel volumes for that version.
101    rmnames="$(findubiname_onmtd "${name%-*}-" "${ro}")"
102    mapfile -t array <<< "${rmnames}"
103    ubicount="${#array[@]}"
104    while [ "${ubicount}" -ge "${keepmax}" ]; do
105        # Loop through existing volumes and skip currently active ones
106        for (( index=0; index<${#array[@]}; index++ )); do
107            rmname="${array[${index}]}"
108            rmversion="${rmname##*-}"
109            [ "${rmversion}" == "${version}" ] && continue
110            rmubi="$(findubi_onmtd "rofs-${rmversion}" "${ro}")"
111            if [[ "${rmubi}" != "${rootubi}" ]] && \
112                [[ "${rmname}" != "${rootkernel}" ]]; then
113                ubi_remove "rofs-${rmversion}" "${ro}"
114                ubi_remove "kernel-${rmversion}" "${ro}"
115                # Remove priority value
116                fw_setenv "${rmversion}"
117                break
118            fi
119        done
120        # Decrease count regardless to avoid an infinite loop
121        (( ubicount-- ))
122    done
123}
124
125function ubi_rw() {
126    rwmtd="$(findmtd "${reqmtd}")"
127    rw="${rwmtd#mtd}"
128    ubidev="/dev/ubi${rw}"
129
130    # Update rwfs_size, check imgsize was specified, otherwise it'd clear the var
131    if [ -n "$imgsize" ]; then
132        rwsize="$(fw_printenv -n rwfs_size 2>/dev/null)" || true
133        if [[ "${imgsize}" != "${rwsize}" ]]; then
134            fw_setenv rwfs_size "${imgsize}"
135        fi
136    fi
137
138    vol="$(findubi "${name}")"
139    if [ -z "${vol}" ]; then
140        ubimkvol "${ubidev}" -N "${name}" -s "${imgsize}"
141    fi
142}
143
144function ubi_ro() {
145    keepmax=2 # Default 2 volumes per mtd
146    romtd="$(findmtd "${reqmtd}")"
147    romtd2="$(findmtd "${reqmtd2}")"
148
149    if [ ! "${romtd}" == "${romtd2}" ]; then
150        # Request to use alternate mtd device, choose the non-root one
151        keepmax=1 # 1 volume on each of the requested mtds
152        rootmtd="$(findrootmtd)"
153        if [ "${rootmtd}" == "${romtd}" ]; then
154            romtd="${romtd2}"
155        fi
156    fi
157    ro="${romtd#mtd}"
158    ubidev="/dev/ubi${ro}"
159
160    ubi_remove_volumes
161
162    if [ -z "${imgfile}" ]; then
163        echo "Unable to create read-only volume. Image file not specified."
164        return 1
165    fi
166
167    # Create a ubi volume, dynamically sized to fit BMC image if size unspecified
168    img="/tmp/images/${version}/${imgfile}"
169    imgsize="$(stat -c '%s' "${img}")"
170
171    vol="$(findubi "${name}")"
172    if [ -n "${vol}" ]; then
173        # Allow a duplicate kernel volume on the alt mtd
174        if [[ "${name}" =~ "kernel" ]]; then
175            vol="$(findubi_onmtd "${name}" "${ro}")"
176        fi
177    fi
178    if [ -z "${vol}" ]; then
179        ubimkvol "${ubidev}" -N "${name}" -s "${imgsize}" --type=static
180        vol="$(findubi "${name}")"
181    fi
182
183    set_flashid "${version}"
184}
185
186# Squashfs images need a ubi block
187function ubi_block() {
188    vol="$(findubi "${name}")"
189    ubidevid="${vol#ubi}"
190    block="/dev/ubiblock${ubidevid}"
191    if [ ! -e "$block" ]; then
192        ubiblock --create "/dev/ubi${ubidevid}"
193    fi
194}
195
196function ubi_updatevol() {
197    vol="$(findubi "${name}")"
198    ubidevid="${vol#ubi}"
199    img="/tmp/images/${version}/${imgfile}"
200    ubiupdatevol "/dev/ubi${ubidevid}" "${img}"
201}
202
203function ubi_remove() {
204    rmname="$1"
205    rmmtd="$2"
206    if [ -n "${rmmtd}" ]; then
207        vol="$(findubi_onmtd "${rmname}" "${rmmtd}")"
208    else
209        vol="$(findubi "${rmname}")"
210    fi
211
212    if [ -n "$vol" ]; then
213        vol="${vol%_*}"
214
215        if grep -q "$rmname" /proc/mounts; then
216            mountdir=$(grep "$rmname" /proc/mounts | cut -d " " -f 2)
217            umount "$mountdir"
218            rm -r "$mountdir"
219        fi
220
221        ubirmvol "/dev/${vol}" -N "$rmname"
222    fi
223}
224
225function ubi_cleanup() {
226    # When ubi_cleanup is run, it expects one or no active version.
227    activeVersion=$(busctl --list --no-pager tree \
228            xyz.openbmc_project.Software.BMC.Updater | \
229        grep /xyz/openbmc_project/software/ | tail -c 9)
230
231    if [[ -z "$activeVersion" ]]; then
232        vols=$(ubinfo -a | grep "rofs-" | cut -c 14-)
233    else
234        flashid=$(busctl get-property xyz.openbmc_project.Software.BMC.Updater \
235                "/xyz/openbmc_project/software/${activeVersion}" \
236            xyz.openbmc_project.Common.FilePath Path |  awk '{print $NF;}' | tr -d '"')
237        vols=$(ubinfo -a | grep "rofs-" | \
238            grep -v "$flashid" | cut -c 14-) || true
239    fi
240
241    mapfile -t array <<< "${vols}"
242    for (( index=0; index<${#array[@]}; index++ )); do
243        ubi_remove "${array[index]}"
244    done
245}
246
247function mount_ubi_alt_rwfs() {
248    altNum="$(findmtdnum "alt-bmc")"
249    if [ -n "${altNum}" ]; then
250        altRwfs=$(ubinfo -a -d "${altNum}" | grep -w "rwfs") || true
251        if [ -n "${altRwfs}" ]; then
252            altVarMount="/media/alt/var"
253            mkdir -p "${altVarMount}"
254            if mount ubi"${altNum}":rwfs "${altVarMount}" -t ubifs -o defaults; then
255                mkdir -p "${altVarMount}"/persist/etc
256            fi
257        fi
258    fi
259}
260
261function remount_ubi() {
262    bmcmtd="$(findmtd "bmc")"
263    altbmcmtd="$(findmtd "alt-bmc")"
264    mtds="${bmcmtd: -1}","${altbmcmtd: -1}"
265
266    rootubi="$(findrootubi)"
267    rootname="$(findname "${rootubi}")"
268
269    IFS=',' read -r -a arrayMtds <<< "$mtds"
270    for mtd in "${arrayMtds[@]}"; do
271        # Get information on all ubi volumes
272        ubinfo=$(ubinfo -d "${mtd}")
273        presentVolumes=${ubinfo##*:}
274        IFS=', ' read -r -a array <<< "$presentVolumes"
275        for element in "${array[@]}"; do
276            elementProperties=$(ubinfo -d "$mtd" -n "$element")
277            # Get ubi volume name by getting rid of additional properties
278            name=${elementProperties#*Name:}
279            name="${name%Character*}"
280            name="$(echo -e "${name}" | tr -d '[:space:]')"
281
282            if [[ ${name} == rofs-* ]]; then
283                if [[ "${name}" == "${rootname}" ]]; then
284                    mountdir="/media/${name}-functional"
285                else
286                    mountdir="/media/${name}"
287                fi
288
289                if [ ! -d "${mountdir}" ]; then
290                    mkdir -p "${mountdir}"
291                    # U-Boot will create the ubiblock for the running version, but not
292                    # for the version on the other chip
293                    if [ ! -e "/dev/ubiblock${mtd}_${element}" ]; then
294                        ubiblock --create "/dev/ubi${mtd}_${element}"
295                    fi
296                    mount -t squashfs -o ro "/dev/ubiblock${mtd}_${element}" "${mountdir}"
297                fi
298            fi
299        done
300    done
301
302    set_wdt2bite
303}
304
305function mount_static_alt() {
306    typ=$1
307    altFs=$2
308    mountName=$3
309    altNum="$(findmtdnum "${altFs}")"
310    if [ -n "${altNum}" ]; then
311        altFsMount="/run/media/${mountName}"
312        mkdir -p "${altFsMount}"
313        altFsBlock="/dev/mtdblock${altNum}"
314        mount -t "${typ}" "${altFsBlock}" "${altFsMount}"
315    fi
316}
317
318function umount_static_alt() {
319    altFs=$1
320    altFsMount="/run/media/${altFs}"
321    umount "${altFsMount}"
322}
323
324# Read the current env variable and set it on the alternate boot env
325function copy_env_var_to_alt() {
326    varName=$1
327    value="$(fw_printenv -n "${varName}")"
328    fw_setenv -c /etc/alt_fw_env.config "${varName}" "${value}"
329}
330
331# When the alternate bmc chip boots, u-boot thinks its the primary mtdX.
332# Therefore need to swap the chip numbers when copying the ubiblock and root to
333# alternate bmc u-boot environment.
334function copy_ubiblock_to_alt() {
335    value="$(fw_printenv -n ubiblock)"
336    bmcNum="$(findmtdnum "bmc")"
337    altNum="$(findmtdnum "alt-bmc")"
338    replaceAlt="${value/${altNum},/${bmcNum},}"
339
340    if [[ "${value}" == "${replaceAlt}" ]]; then
341        replaceBmc="${value/${bmcNum},/${altNum},}"
342        value=${replaceBmc}
343    else
344        value=${replaceAlt}
345    fi
346
347    fw_setenv -c /etc/alt_fw_env.config ubiblock "${value}"
348}
349
350function copy_root_to_alt() {
351    value="$(fw_printenv -n root)"
352    bmcNum="$(findmtdnum "bmc")"
353    altNum="$(findmtdnum "alt-bmc")"
354    replaceAlt="${value/${altNum}_/${bmcNum}_}"
355
356    if [[ "${value}" == "${replaceAlt}" ]]; then
357        replaceBmc="${value/${bmcNum}_/${altNum}_}"
358        value=${replaceBmc}
359    else
360        value=${replaceAlt}
361    fi
362
363    fw_setenv -c /etc/alt_fw_env.config root "${value}"
364}
365
366function ubi_setenv() {
367    # The U-Boot environment maintains two banks of environment variables.
368    # The banks need to be consistent with each other to ensure that these
369    # variables can reliably be read from file. In order to guarantee that the
370    # banks are both correct, we need to run fw_setenv twice.
371    variable=$1
372    if [[ "$variable" == *"="* ]]; then
373        varName="${variable%=*}"
374        value="${variable##*=}"
375        # Write only if var is not set already to the requested value
376        currentValue="$(fw_printenv -n "${varName}" 2>/dev/null)" || true
377        if [[ "${currentValue}" != "${value}" ]]; then
378            fw_setenv "$varName" "$value"
379            fw_setenv "$varName" "$value"
380        fi
381    else
382        fw_setenv "$variable"
383        fw_setenv "$variable"
384    fi
385}
386
387function mtd_write() {
388    flashmtd="$(findmtd "${reqmtd}")"
389    img="/tmp/images/${version}/${imgfile}"
390    flashcp -v "${img}" /dev/"${flashmtd}"
391}
392
393function backup_env_vars() {
394    copy_env_var_to_alt kernelname
395    copy_ubiblock_to_alt
396    copy_root_to_alt
397}
398
399function update_env_vars() {
400    vol="$(findubi rofs-"${flashid}")"
401    if [ -z "${vol}" ]; then
402        return 1
403    fi
404    ubidevid="${vol#ubi}"
405    block="/dev/ubiblock${ubidevid}"
406    if [ ! -e "${block}" ]; then
407        return 1
408    fi
409    ubi_setenv "kernelname=kernel-${flashid}"
410    ubi_setenv "ubiblock=${ubidevid//_/,}"
411    ubi_setenv "root=${block}"
412}
413
414#TODO: Replace the implementation with systemd-inhibitors lock
415#      once systemd/systemd#949 is resolved
416function rebootguardenable() {
417    dir="/run/systemd/system/"
418    file="reboot-guard.conf"
419    units=("reboot" "poweroff" "halt")
420
421    for unit in "${units[@]}"; do
422        mkdir -p ${dir}"${unit}".target.d
423        echo -e "[Unit]\nRefuseManualStart=yes" >> ${dir}"${unit}".target.d/${file}
424    done
425}
426
427#TODO: Replace the implementation with systemd-inhibitors lock
428#      once systemd/systemd#949 is resolved
429function rebootguarddisable() {
430    dir="/run/systemd/system/"
431    file="reboot-guard.conf"
432    units=("reboot" "poweroff" "halt")
433
434    for unit in "${units[@]}"; do
435        rm -rf ${dir}"${unit}".target.d/${file}
436    done
437}
438
439# Create a copy in the alt mtd
440function create_vol_in_alt() {
441    alt="alt-bmc"
442    altmtd="$(findmtd "${alt}")"
443    if [ -n "${altmtd}" ]; then
444        reqmtd="${alt}"
445        reqmtd2="${alt}"
446        ubi_ro
447        ubi_updatevol
448    fi
449}
450
451# Copy contents of one MTD device to another
452function mtd_copy() {
453    in=$1
454    out=$2
455
456    # Must erase MTD first to prevent corruption
457    flash_eraseall "${out}"
458    dd if="${in}" of="${out}"
459}
460
461function mirroruboot() {
462    bmc="$(findmtd "u-boot")"
463    bmcdev="/dev/${bmc}"
464    alt="$(findmtd "alt-u-boot")"
465    altdev="/dev/${alt}"
466
467    checksum_bmc="$(md5sum "${bmcdev}")"
468    checksum_bmc="${checksum_bmc% *}"
469    checksum_alt="$(md5sum "${altdev}")"
470    checksum_alt="${checksum_alt% *}"
471
472    if [[ "${checksum_bmc}" != "${checksum_alt}" ]]; then
473        bmcenv="$(findmtd "u-boot-env")"
474        bmcenvdev="/dev/${bmcenv}"
475        altenv="$(findmtd "alt-u-boot-env")"
476        altenvdev="/dev/${altenv}"
477
478        echo "Mirroring U-boot to alt chip"
479        mtd_copy "${bmcdev}" "${altdev}"
480        mtd_copy "${bmcenvdev}" "${altenvdev}"
481
482        copy_ubiblock_to_alt
483        copy_root_to_alt
484    fi
485}
486
487# Compare the device where u-boot resides with an image file. Specify the full
488# path to the device and image file to use for the compare. Print a value of
489# "0" if identical, "1" otherwise.
490function cmp_uboot() {
491    device="$1"
492    image="$2"
493
494    # Since the image file can be smaller than the device, copy the device to a
495    # tmp file and write the image file on top, then compare the sum of each.
496    # Use cat / redirection since busybox does not have the conv=notrunc option.
497    tmpFile="$(mktemp /tmp/ubootdev.XXXXXX)"
498    dd if="${device}" of="${tmpFile}"
499    devSum="$(sha256sum "${tmpFile}")"
500    cat < "${image}" 1<> "${tmpFile}"
501    imgSum="$(sha256sum "${tmpFile}")"
502    rm -f "${tmpFile}"
503
504    if [ "${imgSum}" == "${devSum}" ]; then
505        echo "0";
506    else
507        echo "1";
508    fi
509}
510
511# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b.
512# Return the label (a or b) for the running partition.
513function mmc_get_primary_label() {
514    # Get root device /dev/mmcblkpX
515    rootmatch=" on / "
516    root="$(mount | grep "${rootmatch}")"
517    # shellcheck disable=SC2295
518    root="${root%${rootmatch}*}"
519
520    # Find the device label
521    if [[ $(readlink -f /dev/disk/by-partlabel/rofs-a) == "${root}" ]]; then
522        echo "a"
523    elif [[ $(readlink -f /dev/disk/by-partlabel/rofs-b) == "${root}" ]]; then
524        echo "b"
525    else
526        echo ""
527    fi
528}
529
530# The eMMC partition labels for the kernel and rootfs are boot-a/b and rofs-a/b.
531# Return the label (a or b) for the non-running partition.
532function mmc_get_secondary_label() {
533    root="$(mmc_get_primary_label)"
534    if [[ "${root}" == "a" ]]; then
535        echo "b"
536    elif [[ "${root}" == "b" ]]; then
537        echo "a"
538    else
539        echo ""
540    fi
541}
542
543function mmc_mount() {
544    primaryId="$(mmc_get_primary_label)"
545    secondaryId="$(mmc_get_secondary_label)"
546
547    primaryDir="${mediaDir}/rofs-${primaryId}-functional"
548    secondaryDir="${mediaDir}/rofs-${secondaryId}"
549
550    mkdir -p "${primaryDir}"
551    mkdir -p "${secondaryDir}"
552
553    mount PARTLABEL=rofs-"${primaryId}" "${primaryDir}" -t ext4 -o ro || rmdir "${primaryDir}"
554    mount PARTLABEL=rofs-"${secondaryId}" "${secondaryDir}" -t ext4 -o ro || rmdir "${secondaryDir}"
555}
556
557function mmc_update() {
558    # Update u-boot if needed
559    bootPartition="mmcblk0boot0"
560    devUBoot="/dev/${bootPartition}"
561    imgUBoot="${imgpath}/${version}/image-u-boot"
562    if [ "$(cmp_uboot "${devUBoot}" "${imgUBoot}")" != "0" ]; then
563        echo 0 > "/sys/block/${bootPartition}/force_ro"
564        dd if="${imgUBoot}" of="${devUBoot}"
565        echo 1 > "/sys/block/${bootPartition}/force_ro"
566    fi
567
568    # Update the secondary (non-running) boot and rofs partitions.
569    label="$(mmc_get_secondary_label)"
570
571    # Update the boot and rootfs partitions, restore their labels after the update
572    # by getting the partition number mmcblk0pX from their label.
573    zstd -d -c "${imgpath}"/"${version}"/image-kernel | dd of="/dev/disk/by-partlabel/boot-${label}"
574    number="$(readlink -f /dev/disk/by-partlabel/boot-"${label}")"
575    number="${number##*mmcblk0p}"
576    sgdisk --change-name="${number}":boot-"${label}" /dev/mmcblk0 1>/dev/null
577
578    zstd -d -c "${imgpath}"/"${version}"/image-rofs | dd of="/dev/disk/by-partlabel/rofs-${label}"
579    number="$(readlink -f /dev/disk/by-partlabel/rofs-"${label}")"
580    number="${number##*mmcblk0p}"
581    sgdisk --change-name="${number}":rofs-"${label}" /dev/mmcblk0 1>/dev/null
582
583    # Run this after sgdisk for labels to take effect.
584    partprobe
585
586    # Update hostfw
587    if [ -f "${imgpath}"/"${version}"/image-hostfw ]; then
588        # Remove patches
589        patchdir="/usr/local/share/hostfw/alternate"
590        if [ -d "${patchdir}" ]; then
591            rm -rf "${patchdir:?}"/*
592        fi
593        hostfwdir=$(grep "hostfw " /proc/mounts | cut -d " " -f 2)
594        cp "${imgpath}"/"${version}"/image-hostfw "${hostfwdir}"/hostfw-"${label}"
595        mkdir -p "${hostfwdir}"/alternate
596        mount "${hostfwdir}"/hostfw-"${label}" "${hostfwdir}"/alternate -o ro
597    fi
598
599    set_flashid "${label}"
600}
601
602function mmc_remove() {
603    # Render the filesystem unbootable by wiping out the first 1MB, this
604    # invalidates the filesystem header.
605    # Check if the requested id is the one the BMC is running from since dd
606    # can still write and corrupt the running partition.
607    primaryid="$(mmc_get_primary_label)"
608    if [[ "${flashid}" == "${primaryid}" ]]; then
609        return 1
610    fi
611    dd if=/dev/zero of=/dev/disk/by-partlabel/boot-"${flashid}" count=2048
612    dd if=/dev/zero of=/dev/disk/by-partlabel/rofs-"${flashid}" count=2048
613
614    hostfw_alt="hostfw/alternate"
615    if grep -q "${hostfw_alt}" /proc/mounts; then
616        hostfw_alt=$(grep "${hostfw_alt}" /proc/mounts | cut -d " " -f 2)
617        umount "${hostfw_alt}"
618    fi
619    hostfw_base="hostfw "
620    if grep -q "${hostfw_base}" /proc/mounts; then
621        hostfw_base=$(grep "${hostfw_base}" /proc/mounts | cut -d " " -f 2)
622        rm -f "${hostfw_base}/hostfw-${flashid}"
623    fi
624}
625
626# Set the requested version as primary for the BMC to boot from upon reboot.
627function mmc_setprimary() {
628    # Point root to the flashid of the requested BMC rootfs.
629    fw_setenv bootside "${flashid}"
630}
631
632function mmc_mirroruboot() {
633    # Get current boot device; 0-primary_bootdev device; 1 - alt_bootdev
634    bootdev=$(cat /sys/kernel/debug/aspeed/sbc/abr_image)
635    if [[ "${bootdev}" == "0" ]]; then
636        bootPartition="mmcblk0boot0"
637        alt_bootPartition="mmcblk0boot1"
638    else
639        bootPartition="mmcblk0boot1"
640        alt_bootPartition="mmcblk0boot0"
641    fi
642
643    devUBoot="/dev/${bootPartition}"
644    alt_devUBoot="/dev/${alt_bootPartition}"
645
646    checksum_UBoot="$(md5sum "${devUBoot}")"
647    checksum_UBoot="${checksum_UBoot% *}"
648    checksum_alt_UBoot="$(md5sum "${alt_devUBoot}")"
649    checksum_alt_UBoot="${checksum_alt% *}"
650
651    if [[ "${checksum_UBoot}" != "${checksum_alt_UBoot}" ]]; then
652        echo "Mirroring U-boot to alt chip"
653        echo 0 > "/sys/block/${alt_bootPartition}/force_ro"
654        dd if="${devUBoot}" of="${alt_devUBoot}"
655        echo 1 > "/sys/block/${alt_bootPartition}/force_ro"
656    fi
657}
658
659case "$1" in
660    mtduboot)
661        reqmtd="$2"
662        version="$3"
663        imgfile="image-u-boot"
664        mtd_write
665        ;;
666    ubirw)
667        reqmtd="$2"
668        name="$3"
669        imgsize="$4"
670        ubi_rw
671        ;;
672    ubiro)
673        reqmtd="$(echo "$2" | cut -d "+" -f 1)"
674        reqmtd2="$(echo "$2" | cut -d "+" -f 2)"
675        name="$3"
676        version="$4"
677        imgfile="image-rofs"
678        ubi_ro
679        ubi_updatevol
680        ubi_block
681        ;;
682    ubikernel)
683        reqmtd="$(echo "$2" | cut -d "+" -f 1)"
684        reqmtd2="$(echo "$2" | cut -d "+" -f 2)"
685        name="$3"
686        version="$4"
687        imgfile="image-kernel"
688        ubi_ro
689        ubi_updatevol
690        create_vol_in_alt
691        ;;
692    ubiremove)
693        name="$2"
694        ubi_remove "${name}"
695        ;;
696    ubicleanup)
697        ubi_cleanup
698        ;;
699    ubisetenv)
700        ubi_setenv "$2"
701        ;;
702    ubiremount)
703        remount_ubi
704        mount_ubi_alt_rwfs
705        ;;
706    createenvbackup)
707        backup_env_vars
708        ;;
709    updateubootvars)
710        flashid="$2"
711        update_env_vars
712        ;;
713    rebootguardenable)
714        rebootguardenable
715        ;;
716    rebootguarddisable)
717        rebootguarddisable
718        ;;
719    mirroruboot)
720        mirroruboot
721        ;;
722    mmc)
723        version="$2"
724        imgpath="$3"
725        mmc_update
726        ;;
727    mmc-mount)
728        mediaDir="$2"
729        mmc_mount
730        ;;
731    mmc-remove)
732        flashid="$2"
733        mmc_remove
734        ;;
735    mmc-setprimary)
736        flashid="$2"
737        mmc_setprimary
738        ;;
739    mmc-mirroruboot)
740        mmc_mirroruboot
741        ;;
742    static-altfs)
743        mount_static_alt "$2" "$3" "$4"
744        ;;
745    umount-static-altfs)
746        umount_static_alt "$2"
747        ;;
748    *)
749        echo "Invalid argument"
750        exit 1
751        ;;
752esac
753