target/linux/bcm53xx/base-files/lib/upgrade/platform.sh

   1 PART_NAME=firmware
   2
   3 # $(1): file to read magic from
   4 # $(2): offset in bytes
   5 get_magic_long_at() {
   6         dd if="$1" skip=$2 bs=1 count=4 2>/dev/null | hexdump -v -e '1/1 "%02x"'
   7 }
   8
   9 platform_machine() {
  10         cat /proc/device-tree/compatible | tr '\0' '\t' | cut -f 1
  11 }
  12
  13 platform_flash_type() {
  14         # On NAND devices "rootfs" is UBI volume, so won't be find in /proc/mtd
  15         grep -q "\"rootfs\"" /proc/mtd && {
  16                 echo "serial"
  17                 return
  18         }
  19
  20         echo "nand"
  21 }
  22
  23 platform_expected_image() {
  24         local machine=$(platform_machine)
  25
  26         case "$machine" in
  27                 "netgear,r6250v1")      echo "chk U12H245T00_NETGEAR"; return;;
  28                 "netgear,r6300v2")      echo "chk U12H240T00_NETGEAR"; return;;
  29                 "netgear,r7000")        echo "chk U12H270T00_NETGEAR"; return;;
  30                 "netgear,r8000")        echo "chk U12H315T00_NETGEAR"; return;;
  31         esac
  32 }
  33
  34 platform_identify() {
  35         local magic
  36
  37         magic=$(get_magic_long "$1")
  38         case "$magic" in
  39                 "48445230")
  40                         echo "trx"
  41                         return
  42                         ;;
  43                 "2a23245e")
  44                         echo "chk"
  45                         return
  46                         ;;
  47                 "5ea3a417")
  48                         echo "seama"
  49                         return
  50                         ;;
  51         esac
  52
  53         magic=$(get_magic_long_at "$1" 14)
  54         [ "$magic" = "55324e44" ] && {
  55                 echo "cybertan"
  56                 return
  57         }
  58
  59         echo "unknown"
  60 }
  61
  62 platform_check_image() {
  63         [ "$#" -gt 1 ] && return 1
  64
  65         local file_type=$(platform_identify "$1")
  66         local magic
  67         local error=0
  68
  69         case "$file_type" in
  70                 "chk")
  71                         local header_len=$((0x$(get_magic_long_at "$1" 4)))
  72                         local board_id_len=$(($header_len - 40))
  73                         local board_id=$(dd if="$1" skip=40 bs=1 count=$board_id_len 2>/dev/null | hexdump -v -e '1/1 "%c"')
  74                         local dev_board_id=$(platform_expected_image)
  75                         echo "Found CHK image with device board_id $board_id"
  76
  77                         [ -n "$dev_board_id" -a "chk $board_id" != "$dev_board_id" ] && {
  78                                 echo "Firmware board_id doesn't match device board_id ($dev_board_id)"
  79                                 error=1
  80                         }
  81
  82                         if ! otrx check "$1" -o "$header_len"; then
  83                                 echo "No valid TRX firmware in the CHK image"
  84                                 error=1
  85                         fi
  86                 ;;
  87                 "cybertan")
  88                         local pattern=$(dd if="$1" bs=1 count=4 2>/dev/null | hexdump -v -e '1/1 "%c"')
  89                         local dev_pattern=$(platform_expected_image)
  90                         echo "Found CyberTAN image with device pattern: $pattern"
  91
  92                         [ -n "$dev_pattern" -a "cybertan $pattern" != "$dev_pattern" ] && {
  93                                 echo "Firmware pattern doesn't match device pattern ($dev_pattern)"
  94                                 error=1
  95                         }
  96
  97                         if ! otrx check "$1" -o 32; then
  98                                 echo "No valid TRX firmware in the CyberTAN image"
  99                                 error=1
 100                         fi
 101                 ;;
 102                 "seama")
 103                         local img_signature=$(oseama info "$1" | grep "Meta entry:.*signature=" | sed "s/.*=//")
 104                         local dev_signature=$(platform_expected_image)
 105                         echo "Found Seama image with device signature: $img_signature"
 106
 107                         [ -n "$dev_signature" -a "seama $img_signature" != "$dev_signature" ] && {
 108                                 echo "Firmware signature doesn't match device signature ($dev_signature)"
 109                                 error=1
 110                         }
 111
 112                         $(oseama info "$1" -e 0 | grep -q "Meta entry:.*type=firmware") || {
 113                                 echo "Seama container doesn't have firmware entity"
 114                                 error=1
 115                         }
 116                 ;;
 117                 "trx")
 118                         if ! otrx check "$1"; then
 119                                 echo "Invalid (corrupted?) TRX firmware"
 120                                 error=1
 121                         fi
 122                 ;;
 123                 *)
 124                         echo "Invalid image type. Please use only .trx files"
 125                         error=1
 126                 ;;
 127         esac
 128
 129         return $error
 130 }
 131
 132 platform_pre_upgrade() {
 133         export RAMFS_COPY_BIN="${RAMFS_COPY_BIN} /usr/bin/oseama /bin/sed"
 134
 135         local file_type=$(platform_identify "$1")
 136         local dir="/tmp/sysupgrade-bcm53xx"
 137         local trx="$1"
 138         local offset
 139
 140         [ "$(platform_flash_type)" != "nand" ] && return
 141
 142         # Find trx offset
 143         case "$file_type" in
 144                 "chk")          offset=$((0x$(get_magic_long_at "$1" 4)));;
 145                 "cybertan")     offset=32;;
 146                 "seama")        return;;
 147         esac
 148
 149         # Extract partitions from trx
 150         rm -fR $dir
 151         mkdir -p $dir
 152         otrx extract "$trx" \
 153                 ${offset:+-o $offset} \
 154                 -1 $dir/kernel \
 155                 -2 $dir/root
 156         [ $? -ne 0 ] && {
 157                 echo "Failed to extract TRX partitions."
 158                 return
 159         }
 160
 161         # Firmwares without UBI image should be flashed "normally"
 162         local root_type=$(identify $dir/root)
 163         [ "$root_type" != "ubi" ] && {
 164                 echo "Provided firmware doesn't use UBI for rootfs."
 165                 return
 166         }
 167
 168         # Prepare TRX file with just a kernel that will replace current one
 169         local linux_length=$(grep "\"linux\"" /proc/mtd | sed "s/mtd[0-9]*:[ \t]*\([^ \t]*\).*/\1/")
 170         [ -z "$linux_length" ] && {
 171                 echo "Unable to find \"linux\" partition size"
 172                 exit 1
 173         }
 174         linux_length=$((0x$linux_length))
 175         local kernel_length=$(wc -c $dir/kernel | cut -d ' ' -f 1)
 176         [ $kernel_length -gt $linux_length ] && {
 177                 echo "New kernel doesn't fit \"linux\" partition."
 178                 return
 179         }
 180         rm -f /tmp/null.bin
 181         rm -f /tmp/kernel.trx
 182         touch /tmp/null.bin
 183         otrx create /tmp/kernel.trx \
 184                 -f $dir/kernel -b $(($linux_length + 28)) \
 185                 -f /tmp/null.bin
 186         [ $? -ne 0 ] && {
 187                 echo "Failed to create simple TRX with new kernel."
 188                 return
 189         }
 190
 191         # Prepare UBI image (drop unwanted extra blocks)
 192         local ubi_length=0
 193         while [ "$(dd if=$dir/root skip=$ubi_length bs=1 count=4 2>/dev/null)" = "UBI#" ]; do
 194                 ubi_length=$(($ubi_length + 131072))
 195         done
 196         dd if=$dir/root of=/tmp/root.ubi bs=131072 count=$((ubi_length / 131072)) 2>/dev/null
 197         [ $? -ne 0 ] && {
 198                 echo "Failed to prepare new UBI image."
 199                 return
 200         }
 201
 202         # Flash
 203         mtd write /tmp/kernel.trx firmware
 204         nand_do_upgrade /tmp/root.ubi
 205 }
 206
 207 platform_trx_from_chk_cmd() {
 208         local header_len=$((0x$(get_magic_long_at "$1" 4)))
 209
 210         echo -n dd bs=$header_len skip=1
 211 }
 212
 213 platform_trx_from_cybertan_cmd() {
 214         echo -n dd bs=32 skip=1
 215 }
 216
 217 platform_img_from_seama() {
 218         local dir="/tmp/sysupgrade-bcm53xx"
 219         local offset=$(oseama info "$1" -e 0 | grep "Entity offset:" | sed "s/.*:\s*//")
 220         local size=$(oseama info "$1" -e 0 | grep "Entity size:" | sed "s/.*:\s*//")
 221
 222         # Busybox doesn't support required iflag-s
 223         # echo -n dd iflag=skip_bytes,count_bytes skip=$offset count=$size
 224
 225         rm -fR $dir
 226         mkdir -p $dir
 227         dd if="$1" of=$dir/image-noheader.bin bs=$offset skip=1
 228         dd if=$dir/image-noheader.bin of=$dir/image-entity.bin bs=$size count=1
 229
 230         echo -n $dir/image-entity.bin
 231 }
 232
 233 platform_do_upgrade() {
 234         local file_type=$(platform_identify "$1")
 235         local trx="$1"
 236         local cmd=
 237
 238         [ "$(platform_flash_type)" == "nand" ] && {
 239                 echo "Writing whole image to NAND flash. All erase counters will be lost."
 240         }
 241
 242         case "$file_type" in
 243                 "chk")          cmd=$(platform_trx_from_chk_cmd "$trx");;
 244                 "cybertan")     cmd=$(platform_trx_from_cybertan_cmd "$trx");;
 245                 "seama")        trx=$(platform_img_from_seama "$trx");;
 246         esac
 247
 248         default_do_upgrade "$trx" "$cmd"
 249 }