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

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