X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-util.git;a=blobdiff_plain;f=firmware%2Fkingst-la%2Fsigrok-fwextract-kingst-la2016;h=3575b04928a7989523ac69da288aa8e543cae7a2;hp=4357994207762fadb837fbcf5d9d92ff8dc5f9cb;hb=HEAD;hpb=03a034f47b9db6bd24035a9ccc0bc01c13217871

diff --git a/firmware/kingst-la/sigrok-fwextract-kingst-la2016 b/firmware/kingst-la/sigrok-fwextract-kingst-la2016
index 4357994..d690719 100755
--- a/firmware/kingst-la/sigrok-fwextract-kingst-la2016
+++ b/firmware/kingst-la/sigrok-fwextract-kingst-la2016
@@ -18,6 +18,11 @@
 ## along with this program; if not, see <http://www.gnu.org/licenses/>.
 ##
 
+# This utility extracts FX2 MCU firmware and FPGA bitstream images from
+# the "KingstVIS" vendor software. The blobs are kept in Qt resources
+# sections. The script was tested with several v3.5 software versions.
+
+import argparse
 import os
 import sys
 import re
@@ -26,7 +31,7 @@ import codecs
 import importlib.util
 import zlib
 
-# reuse parseelf.py module from saleae-logic16:
+# Reuse the parseelf.py module from saleae-logic16.
 fwdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 parseelf_py = os.path.join(fwdir, "saleae-logic16", "parseelf.py")
 spec = importlib.util.spec_from_file_location("parseelf", parseelf_py)
@@ -34,6 +39,9 @@ parseelf = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(parseelf)
 
 class qt_resources(object):
+    RCCFileInfo_Compressed = 0x01
+    RCCFileInfo_Directory = 0x02
+
     def __init__(self, program):
         self._elf = parseelf.elf(program)
         self._elf_sections = {} # idx -> data
@@ -57,7 +65,7 @@ class qt_resources(object):
                 sname, sym["st_size"], len(value)))
         return value
 
-    # qt resource stuff:
+    # Qt resource stuff.
     def _get_resource_name(self, offset):
         length, i = struct.unpack(">HI", self._res_names[offset:offset + 2 + 4])
         offset += 2 + 4
@@ -70,7 +78,6 @@ class qt_resources(object):
         return self._res_datas[offset:offset + length]
 
     def _read_resources(self):
-        RCCFileInfo_Directory = 0x02
         def read_table():
             table = []
             offset = 0
@@ -78,7 +85,7 @@ class qt_resources(object):
                 name_offset, flags = struct.unpack(">IH", self._res_struct[offset:offset+4+2])
                 offset += 6
                 name = self._get_resource_name(name_offset)
-                if flags & RCCFileInfo_Directory:
+                if flags & self.RCCFileInfo_Directory:
                     child_count, first_child_offset = struct.unpack(">II", self._res_struct[offset:offset + 4 + 4])
                     offset += 4 + 4
                     table.append((name, flags, child_count, first_child_offset))
@@ -89,29 +96,35 @@ class qt_resources(object):
             return table
         def read_dir_entries(table, which, parents=[]):
             name, flags = which[:2]
-            if not flags & RCCFileInfo_Directory:
+            if not flags & self.RCCFileInfo_Directory:
                 raise Exception("not a directory!")
             child_count, first_child = which[2:]
             for i in range(child_count):
                 child = table[first_child + i]
-                if child[1] & RCCFileInfo_Directory:
+                flags = child[1]
+                if flags & self.RCCFileInfo_Directory:
                     read_dir_entries(table, child, parents + [child[0]])
                 else:
                     country, language, data_offset = child[2:]
                     full_name = "/".join(parents + [child[0]])
                     self._resources[full_name] = data_offset
+                    self._resource_flags[full_name] = flags
 
         self._res_datas = self._get_elf_sym_value("_ZL16qt_resource_data")
         self._res_names = self._get_elf_sym_value("_ZL16qt_resource_name")
         self._res_struct = self._get_elf_sym_value("_ZL18qt_resource_struct")
 
         self._resources = {} # res_fn -> res_offset
+        self._resource_flags = {} # res_fn -> RCC_flags
         table = read_table()
         read_dir_entries(table, table[0])
 
     def get_resource(self, res_fn):
         offset = self._resources[res_fn]
+        flags = self._resource_flags[res_fn]
         data = self._get_resource_data(offset)
+        if flags & self.RCCFileInfo_Compressed:
+            data = zlib.decompress(data[4:])
         return data
 
     def find_resource_names(self, res_fn_re):
@@ -124,31 +137,34 @@ class res_writer(object):
     def __init__(self, res):
         self.res = res
 
-    def _write_file(self, fn, data, decoder=None, zero_pad_to=None):
+    def _decode_crc(self, data, decoder=None):
         if decoder is not None:
             data = decoder(data)
-        if zero_pad_to is not None:
-            if len(data) > zero_pad_to:
-                raise Exception("can not zero_pad_to %d bytes -- data is already %d bytes" % (zero_pad_to, len(data)))
-            data += b"\0" * (zero_pad_to - len(data))
+        data = bytearray(data)
+        crc = zlib.crc32(data) & 0xffffffff
+        return data, crc
+
+    def _write_file(self, fn, data):
         with open(fn, "wb") as fp:
             fp.write(data)
-        data_crc32 = zlib.crc32(data) & 0xffffffff
-        print("saved %d bytes to %s (crc32=%08x)" % (len(data), fn, data_crc32))
 
-    def extract(self, res_fn, out_fn, decoder=None, zero_pad_to=None):
-        self._write_file(out_fn, self.res.get_resource(res_fn), decoder=decoder, zero_pad_to=zero_pad_to)
-
-    def extract_re(self, res_fn_re, out_fn, decoder=None):
-        for res_fn in res.find_resource_names(res_fn_re):
-            fn = re.sub(res_fn_re, out_fn, res_fn).lower()
-            self._write_file(fn, self.res.get_resource(res_fn), decoder=decoder)
+    def extract_re(self, resource_pattern, fname_pattern, decoder=None):
+        resources = sorted(res.find_resource_names(resource_pattern))
+        for resource in resources:
+            fname = re.sub(resource_pattern, fname_pattern, resource)
+            fname = fname.lower()
+            data = self.res.get_resource(resource)
+            data, crc = self._decode_crc(data, decoder=decoder)
+            self._write_file(fname, data)
+            print("resource {rsc}, file {fname}, size {size}, checksum {crc:08x}".format(
+                rsc = resource, fname = fname, size = len(data), crc = crc,
+            ))
 
 def decode_intel_hex(hexdata):
     """ return list of (address, data)
     """
     datas = []
-    # assume \n or \r\n*
+    # Assume LF-only or CR-LF style end-of-line.
     for line in hexdata.split(b"\n"):
         line = line.strip()
         if chr(line[0]) != ":": raise Exception("invalid line: %r" % line)
@@ -184,41 +200,23 @@ def intel_hex_as_blob(hexdata):
 def maybe_intel_hex_as_blob(data):
     if data[0] == ord(":") and max(data) < 127:
           return intel_hex_as_blob(data)
-    return data # keep binary data
+    return data # Keep binary data.
 
 if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("sigrok-fwextract-kingst-la2016 <programfile>")
-        sys.exit()
-
-    res = qt_resources(sys.argv[1])
+    parser = argparse.ArgumentParser(description = "KingstVIS firmware extraction")
+    parser.add_argument('executable', help = "KingstVIS executable file")
+    options = parser.parse_args()
+    exe_fn = options.executable
 
+    res = qt_resources(exe_fn)
     writer = res_writer(res)
 
-    '''
-    05-APR-2021
-    This extraction script has been tested with the
-    vendor software versions v3.5.0 and v3.5.1
-    These files were extracted and tested successfully:
-    saved 5430 bytes to kingst-la-01a2.fw (crc32=720551a9)
-    saved 178362 bytes to kingst-la2016a1-fpga.bitstream (crc32=7cc894fa)
-    saved 178542 bytes to kingst-la2016-fpga.bitstream (crc32=20694ff1)
-    saved 178379 bytes to kingst-la1016a1-fpga.bitstream (crc32=166866be)
-    saved 178151 bytes to kingst-la1016-fpga.bitstream (crc32=7db70001)
-    '''
-
-    # extract all firmware and fpga bitstreams
-    # writer.extract_re(r"fwfpga/(.*)", r"kingst-\1-fpga.bitstream")
-    # writer.extract_re(r"fwusb/fw(.*)", r"kingst-la-\1.fw", decoder=maybe_intel_hex_as_blob)
-
-    # extract fx2 mcu firmware for both the la2016 and la1016
-    # note that 0x01a2 is the usb pid for both of these devices
-    writer.extract_re("fwusb/fw01A2", "kingst-la-01a2.fw", decoder=maybe_intel_hex_as_blob)
-
-    # extract fpga bitstreams for la2016
-    # there are two bitstreams, newer hardware uses the 'a1' bitstream
-    writer.extract_re("fwfpga/LA2016(.*)", r"kingst-la2016\1-fpga.bitstream")
-
-    # extract fpga bitstreams for la1016
-    # there are two bitstreams, newer hardware uses the 'a1' bitstream
-    writer.extract_re("fwfpga/LA1016(.*)", r"kingst-la1016\1-fpga.bitstream")
+    # Extract all MCU firmware and FPGA bitstream images. The sigrok
+    # project may not cover all KingstVIS supported devices. Users can
+    # either just copy those files which are strictly required for their
+    # specific device (diagnostics will identify those). Or just copy a
+    # few more files while some of them remain unused later (their size
+    # is small). Seeing which files would be contained is considered
+    # valuable, to identify device variants or candidate models.
+    writer.extract_re(r"fwusb/fw(.*)", r"kingst-la-\1.fw", decoder=maybe_intel_hex_as_blob)
+    writer.extract_re(r"fwfpga/(.*)", r"kingst-\1-fpga.bitstream")