openwrt/target/linux/bcm53xx/base-files/lib/upgrade/platform.sh
Matthew Hagan 7ad9988287 bcm53xx: add support for Cisco Meraki MX64/MX65
This commit adds support for the Cisco Meraki MX64 and MX65 devices which
use the Broadcom NSP SoC, which is compatible with the bcm53xx platform.

MX64 Hardware info:
  - CPU: Broadcom BCM58625 Cortex A9 @ 1200Mhz
  - RAM: 2 GB (4 x 4Gb SK Hynix H5TC4G83CFR)
  - Storage: 1 GB (Micron MT29F8G08ABACA)
  - Networking: BCM58625 internal switch (5x 1GbE ports)
  - USB: 1x USB2.0
  - Serial: Internal header

MX65 Hardware info:
  - CPU: Broadcom BCM58625 Cortex A9 @ 1200Mhz
  - RAM: 2 GB (4 x 4Gb SK Hynix H5TC4G83CFR)
  - Storage: 1 GB (Micron MT29F8G08ABACA)
  - Networking: BCM58625 switch (2x 1GbE ports, used for WAN ports 1 & 2)
    2x Qualcomm QCA8337 switches (10x 1GbE ports, used for LAN ports 3-12)
  - PSE: Broadcom BCM59111KMLG connected to LAN ports 11 & 12
  - USB: 1x USB2.0
  - Serial: Internal header

Notes:
  - The Meraki provided GPL source are available at [2].
  - Wireless capability on the MX64W and MX65W exists in the form of 2x
    Broadcom BCM43520KMLG, which is not supported. These devices will work
    otherwise as standard MX64 or MX65 devices.
  - Early MX64 units use an A0 variant of the BCM958625 SoC which lacks
    cache coherency and uses a different "secondary-boot-reg". As a
    consequence a different device tree is needed.
  - Installation of OpenWrt requires changing u-boot to a custom version.
    This is due to the stock u-boot "nand read" command being limited to
    load only 2MB, in spite of the bootkernel1 and bootkernel2 partitions
    both being 3MB in the stock layout. It is also required to allow
    booting via USB, enabling cache coherency and setting up the QCA
    switches and Serdes link on the MX65. The modified sources for U-boot
    are available for the MX64[3] and MX65[4].
  - Initial work on this device used a small bootloader within the OEM
    partition scheme. To allow booting of larger kernels, UBI and bootm
    support has been added, along with ability to store env variables to
    the NAND. The Shmoo and newly created env partitions have been moved
    to the extra space available after the nvram data.
  - Users who installed the previous non-UBI supporting bootloader will
    need to convert to the new one before flashing a compatible image.
    These steps are detailed below.

References:

[1] https://www.broadcom.com/products/embedded-and-networking-processors/c
ommunications/bcm5862x
[2] https://dl.meraki.net/wired-14-39-mx64-20190426.tar.bz2
[3] https://github.com/clayface/U-boot-MX64-20190430_MX64
[4] https://github.com/clayface/U-boot-MX64-20190430_MX65

Installation guide:

Initial installation steps:
  1. Compile or obtain OpenWrt files for the MX64 or MX65, including
     u-boot[3][4], initramfs and sysupgrade images.
  2. A USB disk with DOS partition scheme and primary FAT partition is
     required.
  3. If installing onto an MX64, set up a local web server.
  4. On the device, boot into diagnostic mode by holding reset when
     powering on the device. Continue to hold reset until the orange LED
     begins to flash white. On used units the white flash may be difficult
     to see.
  5. Plug an Ethernet cable into the first LAN port, set the host to
     192.168.1.2 and confirm telnet connectivity to 192.168.1.1.

U-boot installation - MX64 Only:
  1. Newer fw versions require extra steps to support OpenWrt. To check,
     please connect via telnet and run:
        `cat /sys/block/mtdblock0/ro`
     If the result is 1, your mtd0 is locked will need to perform extra
     steps 4 and 5 in this section. If the result is 0 then skip these.

  2. Check which SoC is in use by running the following command:
        `devmem 0x18000000`
     If devmem is not found then try:
        `devmem2 0x18000000`
     If the output begins with anything between "0x3F00-0x3F03" you will
     need to use the A0 release. For any other output, eg "0x3F04" or
     higher, use the regular MX64 image.

  3  Confirm the size of the device's boot(mtd0) partition. In most
     cases it should be 0x100000 or larger. If this is the case, please
     proceed to use the uboot_mx64 image. If the reported size is
     0x80000, please use the uboot_mx64_small image, then follow the
     later guide to change to the larger image.
        `cat /proc/mtd`
     Example output:
        `# cat /proc/mtd
        cat /proc/mtd
        dev:    size   erasesize  name
        mtd0: 00100000 00040000 "boot"
        mtd1: 00080000 00040000 "shmoo"
        mtd2: 00300000 00040000 "bootkernel1"
        mtd3: 00100000 00040000 "nvram"
        mtd4: 00300000 00040000 "bootkernel2"
        mtd5: 3f700000 00040000 "ubi"
        mtd6: 40000000 00040000 "all"`

  4. Set up a webserver to serve the appropriate uboot_mx64 from the
     following location and verify the SHA512:
     https://github.com/clayface/U-boot-MX64-20190430_MX64

  5. (Only if mtd0 is locked) You will also need the mtd-rw.ko kernel
     module to unlock the partition from the same repo. An mtd executable
     is also needed to write the mtd block. Place these on the web server
     as well.

  6. (Only if mtd0 is locked) Use wget to retrieve the files on the MX64:
        `wget http://192.168.1.2/mtd-rw.ko`
        `insmod mtd-rw.ko i_want_a_brick=1`
     and confirm the unlock is set with dmesg
        `mtd-rw: mtd0: setting writeable flag`

  7. Download the appropriate u-boot image according to step 3. If you
     did not need to unlock the mtd0 partition then use dd to write the
     file, with caution:
        `wget http://192.168.1.2/uboot_mx64`
        `dd if=uboot_mx64 of=/dev/mtdblock0`
     If you needed to unlock the mtd0 partition using the mtd-rw module,
     run these commands instead to install u-boot instead:
        `wget http://192.168.1.2/mtd`
        `chmod +x mtd`
        `wget http://192.168.1.2/uboot_mx64`
        `./mtd write uboot_mx64 /dev/mtd0`

  8. Once this has successfully completed, power off the device. If you
     did not need to install the small u-boot image, proceed to
     "OpenWrt Installation". Otherwise proceed to "UBI supporting
     bootloader installation".

U-boot installation - MX65 Only:
  1. Obtain telnet access to the MX65.

  2. Confirm the size of the device's boot(mtd0) partition. In most
     cases it should be 0x100000 or larger. If this is the case, please
     proceed to use the uboot_mx65 image. If the reported size is
     0x80000, please use the uboot_mx65_small image, then follow the
     later guide to change to the larger image.
	`cat /proc/mtd`

  3. Prepare a USB drive formatted to FAT. Download the appropriate
     uboot_mx65 to the USB drive from the following location and verify
     the SHA512:
        https://github.com/clayface/U-boot-MX64-20190430_MX65

  3. Once you have telnet access to the MX65, plug in the USB disk and
     run the following commands, with caution. The USB disk should
     automount but if it does not, you will need to power off and on
     again with reset held. Depending on step 2, use the uboot_mx65 or
     uboot_mx65_small image accordingly:
        `cd /tmp/media/sda1`
        `dd if=uboot_mx65 of=/dev/mtdblock0`

  4. Once this has successfully completed, power off the device. If you
     did not need to install the small u-boot image, proceed to
     "OpenWrt Installation". Otherwise proceed to "UBI supporting
     bootloader installation".

UBI supporting bootloader installation:
  These steps need to be followed if the older u-boot image was
  installed, either because the Meraki diagnostic partition scheme used
  0x80000 as the mtd0 size, or because you installed the u-boot provided
  while OpenWrt support was still under development. If using OpenWrt,
  please make a backup before proceeding.

  1. Obtain the relevant image from the MX64(A0) or MX65 u-boot repo:
        `openwrt-bcm5862x-generic-meraki_XXXX-initramfs-kernel.bin`

  2. With the USB drive already inserted, power on the device while
     holding the reset button. A white/orange flashing pattern will
     occur shortly after power on. Let go of the reset button. The
     device is now booting into OpenWrt initramfs stored on the USB
     disk.

  3. Connect by SSH to 192.168.1.1 and flash the embedded u-boot image,
     changing X as appropriate:
        `mtd write /root/uboot_mx6X /dev/mtd0`
     You do not need to reboot as this image can handle "Kernel-in-UBI"
     OpenWrt installation.

  4. You can proceed to obtain and flash the appropriate OpenWrt image
     at "OpenWrt Installation" Step 3.

  5. Reboot will take significantly longer due to Shmoo calibration. In
     case the device does not come online after several minute, power-
     cycle the device and see if it boots. If you see an orange/white
     flashing pattern, this indicates UBI booting was not successful and
     you will need to copy a new bcm53xx image to a USB disk before
     booting it and attempting to install OpenWrt again - refer to
     "OpenWrt Installation" step 1. Do not attempt to reflash u-boot in
     this scenario.

OpenWrt Installation:
  1. Having obtained an OpenWrt image, please copy the file
        `openwrt-bcm53xx-generic-meraki_XXXX-initramfs.bin`
     to the base directory of a FAT formatted USB drive using DOS
     partition scheme ,where XXXX is mx64, mx64_a0 or mx65 depending on
     which device you have.

  2. With the USB drive already inserted, power on the device. Boot time
     will be longer than usual while Shmoo calibration takes place. A
     different white/orange flashing pattern will eventually occur to
     indicate device is now booting into OpenWrt initramfs stored on the
     USB disk.

  3. Ensuring Ethernet is plugged into a LAN port with IP set in the
     192.168.1.0/24 subnet excluding 192.168.1.1, use SCP to copy the
     sysupgrade file to 192.168.1.1:/tmp, eg:
        `scp openwrt-bcm53xx-generic-meraki_XXXX-squashfs.sysupgrade.bin\
        192.168.1.1:/tmp`

  4. Connect by SSH to 192.168.1.1 and run sysupgrade:
        `sysupgrade \
        /tmp/openwrt-bcm53xx-generic-meraki_XXXX-squashfs.sysupgrade.bin`

  5. OpenWrt should now be installed on the device.

Signed-off-by: Matthew Hagan <mnhagan88@gmail.com>

[ Rebase kernel configuration for 6.6,
  fix failsafe by making kmod-eeprom-at24 and kmod-dsa-qca8k built-in,
  resolve conflicts,
  add LED aliases,
  fix eth0 MAC address at probe ]

TODO:
- fix multiple LED colors not applied despite aliases - due to custom
  /etc/diag.sh
- fix race condition between preinit and probing of the DSA tree,
  causing no network interface available in failsafe mode (in general
  case - to allow moving drivers back to modules)

Signed-off-by: Lech Perczak <lech.perczak@gmail.com>
Link: https://github.com/openwrt/openwrt/pull/16634
Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
2024-10-22 00:39:32 +02:00

420 lines
11 KiB
Bash

RAMFS_COPY_BIN='osafeloader oseama otrx truncate'
PART_NAME=firmware
REQUIRE_IMAGE_METADATA=0
BCM53XX_FW_FORMAT=
BCM53XX_FW_BOARD_ID=
BCM53XX_FW_INT_IMG_FORMAT=
BCM53XX_FW_INT_IMG_TRX_OFFSET=
BCM53XX_FW_INT_IMG_EXTRACT_CMD=
LXL_FLAGS_VENDOR_LUXUL=0x00000001
# $(1): file to read magic from
# $(2): offset in bytes
get_magic_long_at() {
dd if="$1" skip=$2 bs=1 count=4 2>/dev/null | hexdump -v -e '1/1 "%02x"'
}
# $(1): file to read LE long number from
# $(2): offset in bytes
get_le_long_at() {
echo $((0x$(dd if="$1" skip=$2 bs=1 count=4 2>/dev/null | hexdump -v -e '1/4 "%02x"')))
}
platform_flash_type() {
# On NAND devices "rootfs" is UBI volume, so won't be find in /proc/mtd
grep -q "\"rootfs\"" /proc/mtd && {
echo "serial"
return
}
echo "nand"
}
platform_expected_image() {
local machine=$(board_name)
case "$machine" in
"dlink,dir-885l") echo "seamaseal wrgac42_dlink.2015_dir885l"; return;;
"dlink,dir-890l") echo "seamaseal wrgac36_dlink.2013gui_dir890"; return;;
"luxul,abr-4500-v1") echo "lxl ABR-4500"; return;;
"luxul,xap-810-v1") echo "lxl XAP-810"; return;;
"luxul,xap-1410-v1") echo "lxl XAP-1410"; return;;
"luxul,xap-1440-v1") echo "lxl XAP-1440"; return;;
"luxul,xap-1510-v1") echo "lxl XAP-1510"; return;;
"luxul,xap-1610-v1") echo "lxl XAP-1610"; return;;
"luxul,xbr-4500-v1") echo "lxl XBR-4500"; return;;
"luxul,xwc-1000") echo "lxl XWC-1000"; return;;
"luxul,xwc-2000-v1") echo "lxl XWC-2000"; return;;
"luxul,xwr-1200-v1") echo "lxl XWR-1200"; return;;
"luxul,xwr-3100-v1") echo "lxl XWR-3100"; return;;
"luxul,xwr-3150-v1") echo "lxl XWR-3150"; return;;
"netgear,r6250-v1") echo "chk U12H245T00_NETGEAR"; return;;
"netgear,r6300-v2") echo "chk U12H240T00_NETGEAR"; return;;
"netgear,r7000") echo "chk U12H270T00_NETGEAR"; return;;
"netgear,r7900") echo "chk U12H315T30_NETGEAR"; return;;
"netgear,r8000") echo "chk U12H315T00_NETGEAR"; return;;
"netgear,r8500") echo "chk U12H334T00_NETGEAR"; return;;
"tplink,archer-c9-v1") echo "safeloader"; return;;
esac
}
platform_identify() {
local magic
magic=$(get_magic_long "$1")
case "$magic" in
"48445230")
BCM53XX_FW_FORMAT="trx"
return
;;
"2a23245e")
local header_len=$((0x$(get_magic_long_at "$1" 4)))
local board_id_len=$(($header_len - 40))
BCM53XX_FW_FORMAT="chk"
BCM53XX_FW_BOARD_ID=$(dd if="$1" skip=40 bs=1 count=$board_id_len 2>/dev/null | hexdump -v -e '1/1 "%c"')
BCM53XX_FW_INT_IMG_FORMAT="trx"
BCM53XX_FW_INT_IMG_TRX_OFFSET="$header_len"
BCM53XX_FW_INT_IMG_EXTRACT_CMD="dd skip=$header_len iflag=skip_bytes"
return
;;
"4c584c23")
local hdr_len=$(get_le_long_at "$1" 8)
local flags=$(get_le_long_at "$1" 12)
[ $((flags & LXL_FLAGS_VENDOR_LUXUL)) -gt 0 ] && notify_firmware_no_backup
BCM53XX_FW_FORMAT="lxl"
BCM53XX_FW_BOARD_ID=$(dd if="$1" skip=16 bs=1 count=16 2>/dev/null | hexdump -v -e '1/1 "%c"')
BCM53XX_FW_INT_IMG_FORMAT="trx"
BCM53XX_FW_INT_IMG_TRX_OFFSET="$hdr_len"
BCM53XX_FW_INT_IMG_EXTRACT_CMD="dd skip=$hdr_len iflag=skip_bytes"
return
;;
"5ea3a417")
BCM53XX_FW_FORMAT="seamaseal"
BCM53XX_FW_BOARD_ID=$(oseama info "$1" | grep "Meta entry:.*signature=" | sed "s/.*=//")
BCM53XX_FW_INT_IMG_EXTRACT_CMD="oseama extract - -e 0"
return
;;
esac
magic=$(get_magic_long_at "$1" 14)
[ "$magic" = "55324e44" ] && {
BCM53XX_FW_FORMAT="cybertan"
BCM53XX_FW_BOARD_ID=$(dd if="$1" bs=1 count=4 2>/dev/null | hexdump -v -e '1/1 "%c"')
BCM53XX_FW_INT_IMG_FORMAT="trx"
BCM53XX_FW_INT_IMG_TRX_OFFSET="32"
BCM53XX_FW_INT_IMG_EXTRACT_CMD="dd skip=32 iflag=skip_bytes"
return
}
magic=$(get_magic_long_at "$1" 60)
[ "$magic" = "4c584c23" ] && {
notify_firmware_no_backup
BCM53XX_FW_FORMAT="lxlold"
BCM53XX_FW_BOARD_ID=$(dd if="$1" skip=48 bs=1 count=12 2>/dev/null | hexdump -v -e '1/1 "%c"')
BCM53XX_FW_INT_IMG_FORMAT="trx"
BCM53XX_FW_INT_IMG_TRX_OFFSET="64"
BCM53XX_FW_INT_IMG_EXTRACT_CMD="dd skip=64 iflag=skip_bytes"
return
}
if osafeloader info "$1" > /dev/null 2>&1; then
BCM53XX_FW_FORMAT="safeloader"
return
fi
}
platform_other_check_image() {
[ "$#" -gt 1 ] && return 1
local error=0
platform_identify "$1"
[ -z "$BCM53XX_FW_FORMAT" ] && {
echo "Invalid image type. Please use firmware specific for this device."
notify_firmware_broken
return 1
}
echo "Found $BCM53XX_FW_FORMAT firmware for device $BCM53XX_FW_BOARD_ID"
local expected_image="$(platform_expected_image)"
local tmp_format=$BCM53XX_FW_FORMAT
[ "$tmp_format" = "lxlold" ] && tmp_format="lxl"
[ -n "$expected_image" -a -n "$BCM53XX_FW_BOARD_ID" -a "$expected_image" != "$tmp_format $BCM53XX_FW_BOARD_ID" ] && {
echo "Firmware doesn't match device ($expected_image)"
error=1
}
case "$BCM53XX_FW_FORMAT" in
"seamaseal")
$(oseama info "$1" -e 0 | grep -q "Meta entry:.*type=firmware") || {
echo "Seama seal doesn't contain firmware entity"
error=1
}
;;
"trx")
if ! otrx check "$1"; then
echo "Failed to find a valid TRX in firmware"
notify_firmware_test_result "trx_valid" 0
error=1
else
notify_firmware_test_result "trx_valid" 1
fi
[ "$expected_image" == "safeloader" ] && {
echo "This device expects SafeLoader format and may not work with TRX"
error=1
}
;;
*)
case "$BCM53XX_FW_INT_IMG_FORMAT" in
"trx")
# Make sure that both ways of extracting TRX work.
# platform_do_upgrade() may use any of them.
if ! otrx check "$1" -o "$BCM53XX_FW_INT_IMG_TRX_OFFSET" || \
! $BCM53XX_FW_INT_IMG_EXTRACT_CMD < $1 | otrx check -; then
echo "Invalid (corrupted?) TRX firmware"
notify_firmware_test_result "trx_valid" 0
error=1
else
notify_firmware_test_result "trx_valid" 1
fi
;;
esac
;;
esac
return $error
}
platform_check_image() {
local board
board="$(board_name)"
case "$board" in
meraki,mr26 | \
meraki,mr32 | \
meraki,mx64 | \
meraki,mx64-a0 | \
meraki,mx65)
# NAND sysupgrade
return 0
;;
*)
platform_other_check_image "$1"
return $?
;;
esac
return 1
}
# $(1): TRX image or firmware containing TRX
# $(2): offset of TRX in firmware (optional)
platform_do_upgrade_nand_trx() {
local dir="/tmp/sysupgrade-bcm53xx"
local trx="$1"
local offset="$2"
# Extract partitions from trx
rm -fR $dir
mkdir -p $dir
otrx extract "$trx" \
${offset:+-o $offset} \
-1 $dir/kernel \
-2 $dir/root
[ $? -ne 0 ] && {
echo "Failed to extract TRX partitions."
return
}
# Firmwares without UBI image should be flashed "normally"
local root_type=$(identify $dir/root)
[ "$root_type" != "ubi" ] && {
echo "Provided firmware doesn't use UBI for rootfs."
return
}
# Prepare TRX file with just a kernel that will replace current one
local linux_length=$(grep "\"linux\"" /proc/mtd | sed "s/mtd[0-9]*:[ \t]*\([^ \t]*\).*/\1/")
[ -z "$linux_length" ] && {
echo "Unable to find \"linux\" partition size"
exit 1
}
linux_length=$((0x$linux_length))
local kernel_length=$(wc -c $dir/kernel | cut -d ' ' -f 1)
[ $kernel_length -gt $linux_length ] && {
echo "New kernel doesn't fit \"linux\" partition."
return
}
rm -f /tmp/null.bin
rm -f /tmp/kernel.trx
touch /tmp/null.bin
otrx create /tmp/kernel.trx \
-f $dir/kernel -b $(($linux_length + 28)) \
-f /tmp/null.bin
[ $? -ne 0 ] && {
echo "Failed to create simple TRX with new kernel."
return
}
# Prepare UBI image (drop unwanted extra blocks)
local ubi_length=0
while [ "$(dd if=$dir/root skip=$ubi_length bs=1 count=4 2>/dev/null)" = "UBI#" ]; do
ubi_length=$(($ubi_length + 131072))
done
truncate -s $ubi_length $dir/root
[ $? -ne 0 ] && {
echo "Failed to prepare new UBI image."
return
}
# Flash
mtd write /tmp/kernel.trx firmware || exit 1
nand_do_upgrade $dir/root
}
platform_do_upgrade_nand_seamaseal() {
local dir="/tmp/sysupgrade-bcm53xx"
local seamaseal="$1"
local tmp
# Extract Seama entity from Seama seal
rm -fR $dir
mkdir -p $dir
oseama extract "$seamaseal" \
-e 0 \
-o $dir/seama.entity
[ $? -ne 0 ] && {
echo "Failed to extract Seama entity."
return
}
local entity_size=$(wc -c $dir/seama.entity | cut -d ' ' -f 1)
local ubi_offset=0
tmp=0
while [ 1 ]; do
[ $tmp -ge $entity_size ] && break
[ "$(dd if=$dir/seama.entity skip=$tmp bs=1 count=4 2>/dev/null)" = "UBI#" ] && {
ubi_offset=$tmp
break
}
tmp=$(($tmp + 131072))
done
[ $ubi_offset -eq 0 ] && {
echo "Failed to find UBI in Seama entity."
return
}
local ubi_length=0
while [ "$(dd if=$dir/seama.entity skip=$(($ubi_offset + $ubi_length)) bs=1 count=4 2>/dev/null)" = "UBI#" ]; do
ubi_length=$(($ubi_length + 131072))
done
dd if=$dir/seama.entity of=$dir/kernel.seama bs=131072 count=$(($ubi_offset / 131072)) 2>/dev/null
dd if=$dir/seama.entity of=$dir/root.ubi bs=131072 skip=$(($ubi_offset / 131072)) count=$(($ubi_length / 131072)) 2>/dev/null
# Flash
local kernel_size=$(sed -n 's/mtd[0-9]*: \([0-9a-f]*\).*"\(kernel\|linux\)".*/\1/p' /proc/mtd)
mtd write $dir/kernel.seama firmware || exit 1
mtd ${kernel_size:+-c 0x$kernel_size} fixseama firmware
nand_do_upgrade $dir/root.ubi
}
platform_img_from_safeloader() {
local dir="/tmp/sysupgrade-bcm53xx"
# Extract partitions from SafeLoader
rm -fR $dir
mkdir -p $dir
osafeloader extract "$1" \
-p "os-image" \
-o $dir/os-image
osafeloader extract "$1" \
-p "file-system" \
-o $dir/file-system
mtd write $dir/file-system rootfs
echo -n $dir/os-image
}
platform_other_do_upgrade() {
platform_identify "$1"
[ "$(platform_flash_type)" == "nand" ] && {
# Try NAND-aware upgrade
case "$BCM53XX_FW_FORMAT" in
"seamaseal")
platform_do_upgrade_nand_seamaseal "$1"
;;
"trx")
platform_do_upgrade_nand_trx "$1"
;;
*)
case "$BCM53XX_FW_INT_IMG_FORMAT" in
"trx")
platform_do_upgrade_nand_trx "$1" "$BCM53XX_FW_INT_IMG_TRX_OFFSET"
;;
*)
echo "NAND aware sysupgrade is unsupported for $BCM53XX_FW_FORMAT format"
;;
esac
;;
esac
# Above calls exit on success.
# If we got here something went wrong.
echo "Writing whole image to NAND flash. All erase counters will be lost."
}
case "$BCM53XX_FW_FORMAT" in
"safeloader")
PART_NAME=os-image
img=$(platform_img_from_safeloader "$1")
default_do_upgrade "$img"
;;
"seamaseal")
default_do_upgrade "$1" "$BCM53XX_FW_INT_IMG_EXTRACT_CMD"
;;
"trx")
default_do_upgrade "$1"
;;
*)
case "$BCM53XX_FW_INT_IMG_FORMAT" in
"trx")
default_do_upgrade "$1" "$BCM53XX_FW_INT_IMG_EXTRACT_CMD"
;;
esac
;;
esac
}
platform_do_upgrade() {
case "$(board_name)" in
meraki,mr26 | \
meraki,mr32)
REQUIRE_IMAGE_METADATA=1
CI_KERNPART="part.safe"
nand_do_upgrade "$1"
;;
meraki,mx64 | \
meraki,mx64-a0 | \
meraki,mx65)
REQUIRE_IMAGE_METADATA=1
nand_do_upgrade "$1"
;;
*)
platform_other_do_upgrade "$1"
;;
esac
}