board/synopsys/axs10x/headerize-axs.py

   1 #!/usr/bin/env python3
   2
   3 #we can use binascii instead of zlib
   4 import os, getopt, sys, zlib
   5 from elftools.elf.elffile import ELFFile
   6
   7
   8 def usage(exit_code):
   9     print("typical usage:")
  10     print("AXS101:")
  11     print(sys.argv[0] + \
  12         " --header-type v1 --arc-id 0x434 --spi-flash-offset 0x0 --image u-boot.bin --elf u-boot")
  13     print("AXS103:")
  14     print(sys.argv[0] + \
  15         " --header-type v2 --arc-id 0x53 --spi-flash-offset 0x200000 --image u-boot.bin --elf u-boot")
  16     sys.exit(exit_code)
  17
  18
  19 def elf_get_entry(filename):
  20     with open(filename, 'rb') as f:
  21         elffile = ELFFile(f)
  22         return elffile.header['e_entry']
  23
  24
  25 def calc_check_sum(filename):
  26     # Calculate u-boot image check_sum: it is sum of all u-boot binary bytes
  27     with open(filename, "rb") as file:
  28         ba = bytearray(file.read())
  29     return sum(ba) & 0xFF
  30
  31
  32 def arg_verify(uboot_bin_filename, uboot_elf_filename, header_type):
  33     if not os.path.isfile(uboot_bin_filename):
  34         print("uboot bin file not exists: " + uboot_bin_filename)
  35         sys.exit(2)
  36
  37     if not os.path.isfile(uboot_elf_filename):
  38         print("uboot elf file not exists: " + uboot_elf_filename)
  39         sys.exit(2)
  40
  41     if header_type not in ("v1", "v2"):
  42         print("unknown header type: " + header_type)
  43         print("choose between 'v1' (most likely AXS101) and 'v2' (most likely AXS103)")
  44         sys.exit(2)
  45
  46
  47 def main():
  48     try:
  49         opts, args = getopt.getopt(sys.argv[1:],
  50             "ht:a:s:i:l:e:",
  51             ["help", "header-type=", "arc-id=", "spi-flash-offset=", "image=", "elf="])
  52     except getopt.GetoptError as err:
  53         print(err)
  54         usage(2)
  55
  56     # default filenames
  57     uboot_elf_filename  = "u-boot"
  58     uboot_bin_filename  = "u-boot.bin"
  59     headerised_filename = "u-boot.head"
  60     uboot_scrypt_file   = "u-boot-update.txt"
  61
  62     # default values
  63     spi_flash_offset    = 0x200000
  64     header_type         = "v2"
  65     arc_id              = 0x53
  66
  67     # initial header values: place where preloader will store u-boot binary,
  68     # should be equal to CONFIG_SYS_TEXT_BASE
  69     image_copy_adr  = 0x81000000
  70
  71     # initial constant header values, do not change these values
  72     magic1          = 0xdeadbeafaf # big endian byte order
  73     magic2          = [            # big endian byte order
  74     0x20202a2020202020202020202a20202020207c5c2e20202020202e2f7c20202020207c2d,
  75     0x2e5c2020202f2e2d7c20202020205c2020602d2d2d6020202f20202020202f205f202020,
  76     0x205f20205c20202020207c205f60712070205f207c2020202020272e5f3d2f205c3d5f2e,
  77     0x272020202020202020605c202f60202020202020202020202020206f2020202020202020]
  78
  79     for opt, arg in opts:
  80         if opt in ('-h', "--help"):        usage(0)
  81         if opt in ('-t', "--header-type"): header_type           = arg
  82         if opt in ('-a', "--arc-id"):      arc_id                = int(arg, 16)
  83         if opt in ('-s', "--spi-flash-offset"): spi_flash_offset = int(arg, 16)
  84         if opt in ('-i', "--image"):       uboot_bin_filename    = arg
  85         if opt in ('-e', "--elf"):         uboot_elf_filename    = arg
  86
  87     arg_verify(uboot_bin_filename, uboot_elf_filename, header_type)
  88
  89     uboot_img_size = os.path.getsize(uboot_bin_filename)
  90     jump_address = elf_get_entry(uboot_elf_filename)
  91     check_sum = calc_check_sum(uboot_bin_filename)
  92
  93     # Calculate header adresses depend on header type
  94     if header_type == "v2":
  95         image_copy_adr -= 0x4
  96         uboot_img_size += 0x4
  97         # we append image so we need to append checksum
  98         jmpchk_sum = sum(jump_address.to_bytes(4, byteorder='big'))
  99         check_sum = (check_sum + jmpchk_sum) & 0xFF
 100         imade_jump_append = True
 101     else:
 102         imade_jump_append = False
 103
 104     # write header to file
 105     with open(headerised_filename, "wb") as file:
 106         file.write(arc_id.to_bytes(2, byteorder='little'))
 107         file.write(uboot_img_size.to_bytes(4, byteorder='little'))
 108         file.write(check_sum.to_bytes(1, byteorder='little'))
 109         file.write(image_copy_adr.to_bytes(4, byteorder='little'))
 110         file.write(magic1.to_bytes(5, byteorder='big'))
 111         for i in range(16): file.write(0x00.to_bytes(1, byteorder='little'))
 112         for byte in magic2: file.write(byte.to_bytes(36, byteorder='big'))
 113         for i in range(224 - len(magic2) * 36):
 114             file.write(0x00.to_bytes(1, byteorder='little'))
 115         if imade_jump_append:
 116             file.write(jump_address.to_bytes(4, byteorder='little'))
 117
 118     # append u-boot image to header
 119     with open(headerised_filename, "ab") as fo:
 120         with open(uboot_bin_filename,'rb') as fi:
 121             fo.write(fi.read())
 122
 123     # calc u-boot headerised image CRC32 (will be used by uboot update
 124     # command for check)
 125     headerised_image_crc = ""
 126     with open(headerised_filename, "rb") as fi:
 127         headerised_image_crc = hex(zlib.crc32(fi.read()) & 0xffffffff)
 128
 129     load_addr = 0x81000000
 130     crc_store_adr = load_addr - 0x8
 131     crc_calc_adr = crc_store_adr - 0x4
 132     load_size = os.path.getsize(headerised_filename)
 133     crc_calc_cmd = \
 134         "crc32 " + hex(load_addr) + " " + hex(load_size) + " " + hex(crc_calc_adr)
 135     crc_check_cmd = \
 136         "mw.l " + hex(crc_store_adr) + " " + headerised_image_crc + " && " + \
 137         crc_calc_cmd + " && " + \
 138         "cmp.l " + hex(crc_store_adr) + " " + hex(crc_calc_adr) + " 1"
 139
 140     # make errase size to be allighned by 64K
 141     if load_size & 0xFFFF == 0:
 142         errase_size = load_size
 143     else:
 144         errase_size = load_size - (load_size & 0xFFFF) + 0x10000
 145
 146     # Hack to handle n25*** flash protect ops weirdness:
 147     # protect unlock return fail status is region is already unlock (entire or
 148     # partially). Same for lock ops.
 149     # As there is no possibility to check current flash status pretend
 150     # unlock & lock always success.
 151     sf_unlock_cmd = \
 152         "if sf protect unlock 0x0 0x4000000 ; then true ; else true ; fi"
 153     sf_lock_cmd = \
 154         "if sf protect lock 0x0 0x4000000 ; then true ; else true ; fi"
 155
 156     # u-bood CMD to load u-bood with header to SPI flash
 157     sf_load_image_cmd = \
 158         "fatload mmc 0:1 " + hex(load_addr) + " " + headerised_filename + " && " + \
 159         "sf probe 0:0 && " + \
 160         sf_unlock_cmd + " && " + \
 161         "sf erase " + hex(spi_flash_offset) + " " + hex(errase_size) + " && " + \
 162         "sf write " + hex(load_addr) + " " + hex(spi_flash_offset) + " " + hex(load_size) + " && " + \
 163         sf_lock_cmd
 164
 165     update_uboot_cmd = sf_load_image_cmd + " && echo \"u-boot update: OK\""
 166
 167     with open(uboot_scrypt_file, "wb") as fo:
 168         fo.write(update_uboot_cmd.encode('ascii'))
 169
 170
 171 if __name__ == "__main__":
 172     try:
 173         main()
 174     except Exception as err:
 175         print(err)
 176         sys.exit(2)