#!/usr/bin/python3 ## ## This file is part of the sigrok-util project. ## ## Copyright (C) 2020 Florian Schmidt ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## import os import sys import re import struct import codecs import importlib.util import zlib # reuse 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) parseelf = importlib.util.module_from_spec(spec) spec.loader.exec_module(parseelf) class qt_resources(object): def __init__(self, program): self._elf = parseelf.elf(program) self._elf_sections = {} # idx -> data self._read_resources() def _get_elf_section(self, idx): s = self._elf_sections.get(idx) if s is None: shdr = self._elf.shdrs[idx] s = self._elf.read_section(shdr), shdr self._elf_sections[idx] = s return s def _get_elf_sym_value(self, sname): sym = self._elf.symtab[sname] section, shdr = self._get_elf_section(sym["st_shndx"]) addr = sym["st_value"] - shdr["sh_addr"] value = section[addr:addr + sym["st_size"]] if len(value) != sym["st_size"]: print("warning: symbol %s should be %d bytes, but in section is only %d bytes" % ( sname, sym["st_size"], len(value))) return value # qt resource stuff: def _get_resource_name(self, offset): length, i = struct.unpack(">HI", self._res_names[offset:offset + 2 + 4]) offset += 2 + 4 name = self._res_names[offset:offset + 2 * length].decode("utf-16be") return name def _get_resource_data(self, offset): length = struct.unpack(">I", self._res_datas[offset:offset + 4])[0] offset += 4 return self._res_datas[offset:offset + length] def _read_resources(self): RCCFileInfo_Directory = 0x02 def read_table(): table = [] offset = 0 while offset < len(self._res_struct): 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: 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)) else: country, language, data_offset = struct.unpack(">HHI", self._res_struct[offset:offset + 2 + 2 + 4]) offset += 2 + 2 + 4 table.append((name, flags, country, language, data_offset)) return table def read_dir_entries(table, which, parents=[]): name, flags = which[:2] if not flags & 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: 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._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 table = read_table() read_dir_entries(table, table[0]) def get_resource(self, res_fn): offset = self._resources[res_fn] data = self._get_resource_data(offset) return data def find_resource_names(self, res_fn_re): for key in self._resources.keys(): m = re.match(res_fn_re, key) if m is not None: yield key class res_writer(object): def __init__(self, res): self.res = res def _write_file(self, fn, data, decoder=None, zero_pad_to=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)) 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 decode_intel_hex(hexdata): """ return list of (address, data) """ datas = [] # assume \n or \r\n* for line in hexdata.split(b"\n"): line = line.strip() if chr(line[0]) != ":": raise Exception("invalid line: %r" % line) offset = 1 record = codecs.decode(line[offset:], "hex") byte_count, address, record_type = struct.unpack(">BHB", record[:1 + 2 + 1]) offset = 1 + 2 + 1 if byte_count > 0: data = record[offset:offset + byte_count] offset += byte_count checksum = record[offset] ex_checksum = (~sum(record[:offset]) + 1) & 0xff if ex_checksum != checksum: raise Exception("invalid checksum %#x in %r" % (checksum, line)) if record_type == 0: datas.append((address, data)) elif record_type == 1: break return datas def intel_hex_as_blob(hexdata): """ return continuous bytes sequence including all data (loosing start address here) """ data = decode_intel_hex(hexdata) data.sort() last = data[-1] length = last[0] + len(last[1]) img = bytearray(length) for off, part in data: img[off:off + len(part)] = part return img 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 if __name__ == "__main__": if len(sys.argv) != 2: print("sigrok-fwextract-kingst-la2016 ") sys.exit() res = qt_resources(sys.argv[1]) 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")