1#!/usr/bin/env python3
2
3#we can use binascii instead of zlib
4import os, getopt, sys, zlib
5from elftools.elf.elffile import ELFFile
6
7
8def 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
19def elf_get_entry(filename):
20    with open(filename, 'rb') as f:
21        elffile = ELFFile(f)
22        return elffile.header['e_entry']
23
24
25def 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
32def 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
47def 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
171if __name__ == "__main__":
172    try:
173        main()
174    except Exception as err:
175        print(err)
176        sys.exit(2)
177