[rp2040] elf2uf2 review

Author: andryblack

tools/build_script_generator/scons/site_tools/elf2uf2.py

@@ -17,8 +17,17 @@
 from modm_tools import elf2uf2
 
 def elf2uf2_action(target, source, env):
+    memranges = []
+    for conf in env['CONFIG_DEVICE_MEMORY']:
+        memranges.append({
+            "start": conf['start'],
+            "end": conf['start'] + conf['size'],
+            "type": conf['name'] == 'flash' and 'CONTENTS' or 'NO_CONTENTS'
+            })
     elf2uf2.convert(str(source[0]),
-                    str(target[0]),env['CONFIG_DEVICE_NAME'])
+                    str(target[0]),
+                    env['CONFIG_DEVICE_NAME'],
+                    memranges)
 
 def generate(env, **kw):
 

tools/modm_tools/elf2uf2.py

@@ -10,32 +10,28 @@
 # Authors:
 # - 2022, Andrey Kunitsyn
 
+"""
+### elf2uf2 - Elf to UF2 Converter
+
+UF2 file format info : https://github.com/microsoft/uf2
+
+```sh
+python3 modm/modm_tools/elf2uf2.py firmware.elf -o firmware.uf2 --target rp2040 \
+    --range 0x10000000:0x15000000:CONTENTS \
+    --range 0x20000000:0x20042000:NO_CONTENTS
+
+# converts `firmware.elf` to `firmware.uf2` in the CWD
+```
+"""
+
 import os
 import struct
 
 from pathlib import Path
 
 verbose = False
 
-# we require 256 (as this is the page size supported by the device)
-LOG2_PAGE_SIZE = 8 # @todo configurable
-PAGE_SIZE = (1 << LOG2_PAGE_SIZE)
 
-# @todo read from modm-device
-memory_map = {
-    "rp2040": {
-        "flash": [
-            {"start":0x10000000,"end":0x15000000,"type":"CONTENTS"},
-            {"start":0x20000000,"end":0x20042000,"type":"NO_CONTENTS"},
-            {"start":0x21000000,"end":0x21040000,"type":"NO_CONTENTS"},
-        ],
-        "ram": [
-            {"start":0x20000000,"end":0x20042000,"type":"CONTENTS"},
-            {"start":0x15000000,"end":0x15004000,"type":"CONTENTS"},
-            {"start":0x00000000,"end":0x00004000,"type":"IGNORE"}, #// for now we ignore the bootrom if present
-        ]
-    }
-}
 
 UF2_FLAG_NOT_MAIN_FLASH     = 0x00000001
 UF2_FLAG_FILE_CONTAINER     = 0x00001000
@@ -49,6 +45,7 @@
         "MAGIC_START1": 0x9E5D5157,
         "MAGIC_END": 0x0AB16F30,
         "FAMILY_ID": 0xe48bff56,
+        "PAGE_SIZE": (1 << 8),
     }
 }
 
@@ -151,7 +148,7 @@ def check_address_range(valid_ranges, addr, vaddr, size, uninitialized):
             return range
     raise Exception("Memory segment {:08x}->{:08x} is outside of valid address range for device".format(addr, addr+size))
 
-def read_and_check_elf32_ph_entries(buffer, eh, valid_ranges, pages):
+def read_and_check_elf32_ph_entries(buffer, eh, valid_ranges, pages, page_size):
     for i in range(eh[6]):
         entry = struct.unpack_from(elf32_ph_entry,buffer,eh[1]+i*elf32_ph_entry_size)
         if entry[0] == PT_LOAD and entry[5] !=0:
@@ -167,8 +164,8 @@ def read_and_check_elf32_ph_entries(buffer, eh, valid_ranges, pages):
                 remaining = mapped_size;
                 file_offset = entry[1];
                 while remaining > 0:
-                    off = addr & (PAGE_SIZE - 1)
-                    chlen = min(remaining, PAGE_SIZE - off)
+                    off = addr & (page_size - 1)
+                    chlen = min(remaining, page_size - off)
                     key = addr - off
                     fragments = []
                     if key in pages:
@@ -201,32 +198,17 @@ def realize_page(buffer, fragments):
             raise Exception("failed concat")
     return result
 
-def is_address_initialized(valid_ranges, addr):
-    for range in valid_ranges:
-        if range["start"] <= addr and range["end"] > addr:
-            return range["type"] == "CONTENTS"
-    return False
 
-def convert_data(source_bytes,target):
+def convert_data(source_bytes,target,ranges):
     eh = read_header(source_bytes)
-    ranges = None
-    ranges_name = None
-    memory_variants = memory_map[target]
-    for name,memranges in memory_variants.items():
-        if is_address_initialized(memranges,eh[0]):
-            ranges = memranges
-            ranges_name = name
-            break
-    if not ranges:
-        raise Exception("Not found memory range")
+    config = uf2_config[target]
     if verbose:
-        print('Build for chip:{} mem:{}'.format(target,ranges_name))
+        print('Build for chip:{}'.format(target))
     pages = {}
-    read_and_check_elf32_ph_entries(source_bytes,eh,ranges,pages)
+    read_and_check_elf32_ph_entries(source_bytes,eh,ranges,pages,config["PAGE_SIZE"])
     if len(pages) == 0:
         raise Exception("The input file has no memory pages")
 
-    config = uf2_config[target]
     num_blocks = len(pages)
     page_num = 0
     file_content = bytes(0)
@@ -240,7 +222,7 @@ def convert_data(source_bytes,target):
                             config["MAGIC_START1"],
                             UF2_FLAG_FAMILY_ID_PRESENT,
                             target_addr,
-                            PAGE_SIZE,
+                            config["PAGE_SIZE"],
                             page_num,
                             num_blocks,
                             config["FAMILY_ID"]) + data + struct.pack('<I',config["MAGIC_END"])
@@ -250,11 +232,16 @@ def convert_data(source_bytes,target):
         file_content += block
     return file_content
 
-def convert(source, output, target):
+def convert(source, output, target, ranges):
     source_bytes = Path(source).read_bytes()
-    uf2 = convert_data(source_bytes,target)
+    uf2 = convert_data(source_bytes,target, ranges)
     Path(output).write_bytes(uf2)
 
+def parse_range(strval):
+    if strval.startswith('0x'):
+        return int(strval[2:],16)
+    return int(strval)
+
 if __name__ == "__main__":
     import argparse
 
@@ -266,6 +253,7 @@ def convert(source, output, target):
     parser.add_argument(
             "-o", "--output",
             dest="output",
+            required=True,
             help="Destination UF2 image")
     parser.add_argument(
             "--verbose",
@@ -277,8 +265,21 @@ def convert(source, output, target):
             dest="target",
             default="rp2040",
             help="Target chip")
+    parser.add_argument(
+            "--range",
+            nargs='+',
+            dest="ranges",
+            help="Memory range in format start:end:type, where type NO_CONTENTS|CONTENTS|IGNORE")
 
     args = parser.parse_args()
     verbose = args.verbose
+    ranges = []
+    for r in args.ranges:
+        start,end,t = r.split(':')
+        ranges.append({
+            "start": parse_range(start),
+            "end": parse_range(end),
+            "type": t
+            })
 
     convert(args.source,args.output,args.target)