robinkrens.nl - git repository - renesas-ra-flasher/blob - src/RAFlasher.py

   1 import os
   2 import math
   3 import time
   4 import argparse
   5 import tempfile
   6 from tqdm import tqdm
   7 from RAConnect import *
   8 from RAPacker import *
   9
  10 SECTOR_SIZE = 2048
  11 VENDOR_ID = 0x045B
  12 PRODUCT_ID = 0x0261
  13
  14 def int_to_hex_list(num):
  15     hex_string = hex(num)[2:].upper()  # convert to hex string
  16     hex_string = hex_string.zfill(8) # pad for 8 char's long
  17     hex_list = [f'0x{hex_string[c:c+2]}' for c in range(0, 8, 2)]
  18     return hex_list
  19
  20 def hex_type(string):
  21     try:
  22         value = int(string, 16)
  23         return value
  24     except ValueError:
  25         raise argparse.ArgumentTypeError(f"'{string}' is not a valid hexadecimal value.")
  26
  27 def set_size_boundaries(start_addr, size):
  28     if start_addr % SECTOR_SIZE:
  29         raise ValueError(f"start addr not aligned on sector size {SECTOR_SIZE}")
  30
  31     if size < SECTOR_SIZE:
  32         print("Warning: you are trying to write something that is less than one sector size: padding with zeroes")
  33
  34     blocks = (size + SECTOR_SIZE - 1) // SECTOR_SIZE
  35     end_addr = blocks * SECTOR_SIZE + start_addr - 1
  36
  37     if (end_addr <= start_addr):
  38         raise ValueError(f"End address smaller or equal than start_address")
  39
  40     if (end_addr > 0x3FFFF):
  41         raise ValueError(f"Binary file is bigger than available ROM space")
  42
  43     return (start_addr, end_addr)
  44
  45 def get_area_info(dev):
  46     for i in [0,1,2]:
  47         packed = pack_pkt(ARE_CMD, [str(i)])
  48         dev.send_data(packed)
  49         info = dev.recv_data(23)
  50         msg = unpack_pkt(info)
  51         fmt = '>BIIII'
  52         KOA, SAD, EAD, EAU, WAU = struct.unpack(fmt, bytes(int(x, 16) for x in msg))
  53         print(f'Area {KOA}: {hex(SAD)}:{hex(EAD)} (erase {hex(EAU)} - write {hex(WAU)})')
  54
  55 def get_dev_info(dev):
  56     packed = pack_pkt(SIG_CMD, "")
  57     dev.send_data(packed)
  58     info = dev.recv_data(18)
  59     fmt = '>IIIBBHH'
  60     _HEADER, SCI, RMB, NOA, TYP, BFV, _FOOTER = struct.unpack(fmt, info)
  61     print('====================')
  62     if TYP == 0x02:
  63         print('Chip: RA MCU + RA2/RA4 Series')
  64     elif TYP == 0x03:
  65         print('Chip: RA MCU + RA6 Series')
  66     else:
  67         rint('Unknown MCU type')
  68     print(f'Serial interface speed: {SCI} Hz')
  69     print(f'Recommend max UART baud rate: {RMB} bps')
  70     print(f'User area in Code flash [{NOA & 0x1}|{NOA & 0x02 >> 1}]')
  71     print(f'User area in Data flash [{NOA & 0x03 >> 2}]')
  72     print(f'Config area [{NOA & 0x04 >> 3}]')
  73     print(f'Boot firmware: version {BFV >> 8}.{BFV & 0xFF}')
  74
  75 def erase_chip(dev, start_addr, size):
  76
  77     if size == None:
  78         size = 0x3FFFF - start_addr # erase all
  79
  80     (start_addr, end_addr) = set_size_boundaries(start_addr, size)
  81     print(f'Erasing {hex(start_addr)}:{hex(end_addr)}')
  82
  83     # setup initial communication
  84     SAD = int_to_hex_list(start_addr)
  85     EAD = int_to_hex_list(end_addr)
  86     packed = pack_pkt(ERA_CMD, SAD + EAD)
  87     dev.send_data(packed)
  88
  89     ret = dev.recv_data(7, timeout=1000) # erase takes usually a bit longer
  90     unpack_pkt(ret)
  91     print("Erase complete")
  92
  93 def read_img(dev, img, start_addr, size):
  94
  95     if size == None:
  96         size = 0x3FFFF - start_addr # read maximum possible
  97
  98     (start_addr, end_addr) = set_size_boundaries(start_addr, size)
  99
 100     # setup initial communication
 101     SAD = int_to_hex_list(start_addr)
 102     EAD = int_to_hex_list(end_addr)
 103     packed = pack_pkt(REA_CMD, SAD + EAD)
 104     dev.send_data(packed)
 105
 106     # calculate how many packets are have to be received
 107     nr_packet = (end_addr - start_addr) // 1024 # TODO: set other than just 1024
 108
 109     with open(img, 'wb') as f:
 110         for i in tqdm(range(0, nr_packet+1), desc="Reading progress"):
 111             ret = dev.recv_data(1024 + 6)
 112             chunk = unpack_pkt(ret)
 113             chunky = bytes(int(x, 16) for x in chunk)
 114             f.write(chunky)
 115             packed = pack_pkt(REA_CMD, ['0x00'], ack=True)
 116             dev.send_data(packed)
 117
 118
 119 def write_img(dev, img, start_addr, size, verify=False):
 120
 121     if os.path.exists(img):
 122         file_size = os.path.getsize(img)
 123     else:
 124         raise Exception(f'file {img} does not exist')
 125
 126     if size == None:
 127         size = file_size
 128
 129     if size > file_size:
 130         raise ValueError("Write size > file size")
 131
 132     (start_addr, end_addr) = set_size_boundaries(start_addr, size)
 133
 134     chunk_size = 1024 # max is 1024 according to protocol
 135
 136     # setup initial communication
 137     SAD = int_to_hex_list(start_addr)
 138     EAD = int_to_hex_list(end_addr)
 139     packed = pack_pkt(WRI_CMD, SAD + EAD)
 140     dev.send_data(packed)
 141     ret = dev.recv_data(7)
 142     unpack_pkt(ret)
 143
 144     totalread = 0
 145     with open(img, 'rb') as f:
 146         with tqdm(total=size, desc="Writing progress") as pbar:
 147             chunk = f.read(chunk_size)
 148             pbar.update(len(chunk))
 149             while chunk and totalread < size:
 150                 if len(chunk) != chunk_size:
 151                     padding_length = chunk_size - len(chunk)
 152                     chunk += b'\0' * padding_length
 153                 packed = pack_pkt(WRI_CMD, chunk, ack=True)
 154                 dev.send_data(packed)
 155                 reply_len = 7
 156                 reply = dev.recv_data(reply_len)
 157                 msg = unpack_pkt(reply)
 158                 chunk = f.read(chunk_size)
 159                 totalread += chunk_size
 160                 pbar.update(len(chunk))
 161
 162
 163     if verify:
 164         with tempfile.NamedTemporaryFile(prefix='.hidden_', delete=False) as tmp_file, open(img, 'rb') as cmp_file:
 165             read_img(dev, tmp_file.name, start_addr, size)
 166             c1 = tmp_file.read(file_size) # due to byte alignment read file is longer
 167             c2 = cmp_file.read()
 168             if c1 == c2:
 169                 print("Verify complete")
 170             else:
 171                 print("Verify failed")
 172
 173 def main():
 174     parser = argparse.ArgumentParser(description="RA Flasher Tool")
 175
 176     subparsers = parser.add_subparsers(dest="command", title="Commands")
 177
 178     # Subparser for the write command
 179     write_parser = subparsers.add_parser("write", help="Write data to flash")
 180     write_parser.add_argument("--start_address", type=hex_type, default='0x0000', help="Start address")
 181     write_parser.add_argument("--size", type=hex_type, default=None, help="Size in bytes")
 182     write_parser.add_argument("--verify", action="store_true", help="Verify after writing")
 183     write_parser.add_argument("file_name", type=str, help="File name")
 184
 185     # Subparser for the read command
 186     read_parser = subparsers.add_parser("read", help="Read data from flash")
 187     read_parser.add_argument("--start_address", type=hex_type, default='0x0000', help="Start address")
 188     read_parser.add_argument("--size", type=hex_type, default=None, help="Size in bytes")
 189     read_parser.add_argument("file_name", type=str, help="File name")
 190
 191     erase_parser = subparsers.add_parser("erase", help="Erase sectors")
 192     erase_parser.add_argument("--start_address", default='0x0000', type=hex_type, help="Start address")
 193     erase_parser.add_argument("--size", type=hex_type, help="Size")
 194
 195     # Subparser for the info command
 196     subparsers.add_parser("info", help="Show flasher information")
 197
 198     args = parser.parse_args()
 199
 200     if args.command == "write":
 201         dev = RAConnect(VENDOR_ID, PRODUCT_ID)
 202         write_img(dev, args.file_name, args.start_address, args.size, args.verify)
 203     elif args.command == "read":
 204         dev = RAConnect(VENDOR_ID, PRODUCT_ID)
 205         read_img(dev, args.file_name, args.start_address, args.size)
 206     elif args.command == "erase":
 207         dev = RAConnect(VENDOR_ID, PRODUCT_ID)
 208         erase_chip(dev, args.start_address, args.size)
 209     elif args.command == "info":
 210         dev = RAConnect(VENDOR_ID, PRODUCT_ID)
 211         get_dev_info(dev)
 212         get_area_info(dev)
 213     else:
 214         parser.print_help()
 215
 216 if __name__ == "__main__":
 217     main()
 218