flash: import modified flash algo conversion script

Author: mbrossard

tools/generate_flash_algo.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+#
+# DAPLink Interface Firmware
+# Copyright (c) 2011-2021 Arm Limited
+# Copyright (c) 2021 Chris Reed
+# Copyright (c) 2021 Mathias Brossard
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import binascii
+import colorama
+import hashlib
+import jinja2
+import os
+import struct
+from datetime import datetime
+from pyocd.target.pack.flash_algo import PackFlashAlgo
+
+BLOB_HEADER = '0xe00abe00,'
+HEADER_SIZE = 4
+STACK_SIZE = 0x400
+
+DAPLINK_TEMPLATE = \
+"""/* Flash OS Routines (Automagically Generated)
+ *
+ * DAPLink Interface Firmware
+ * Copyright (c) {{year}} {{copyright_owner}}
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Generated from '{{ filename }}'{%- if algo.flash_info.name %}{{ " (%s)" % algo.flash_info.name.decode('utf-8') }}{% endif %}
+{%- if pack_file %}
+// Originating from '{{ pack_file }}'
+{%- endif %}
+// digest = {{ digest }}, file size = {{ file_size}}
+// {{ 'algo version = 0x%x, algo size = %d (0x%x)' % (algo.flash_info.version, algo_size + header_size, algo_size + header_size) }}
+static const uint32_t {{name}}_flash_prog_blob[] = {
+    {{prog_header}}
+    {{algo.format_algo_data(4, 8, "c")}}
+};
+
+// Start address of flash
+static const uint32_t flash_start = {{"0x%08x" % algo.flash_start}};
+// Size of flash
+static const uint32_t flash_size = {{"0x%08x" % algo.flash_size}};
+
+/**
+* List of start and size for each size of flash sector - even indexes are start, odd are size
+* The size will apply to all sectors between the listed address and the next address
+* in the list.
+* The last pair in the list will have sectors starting at that address and ending
+* at address flash_start + flash_size.
+*/
+static const sector_info_t sectors_info[] = {
+{%- for start, size  in algo.sector_sizes %}
+    {{ "{0x%08x, 0x%08x}" % (start + algo.flash_start, size) }},
+{%- endfor %}
+};
+
+static const program_target_t flash = {
+    {{'0x%08x' % (algo.symbols['Init'] + header_size + entry)}}, // Init
+    {{'0x%08x' % (algo.symbols['UnInit'] + header_size + entry)}}, // UnInit
+    {{'0x%08x' % (algo.symbols['EraseChip'] + header_size + entry)}}, // EraseChip
+    {{'0x%08x' % (algo.symbols['EraseSector'] + header_size + entry)}}, // EraseSector
+    {{'0x%08x' % (algo.symbols['ProgramPage'] + header_size + entry)}}, // ProgramPage
+{%- if 'Verify' in algo.symbols and algo.symbols['Verify'] < 0xFFFFFFFF %}
+    {{'0x%08x' % (algo.symbols['Verify'] + header_size + entry)}}, // Verify
+{%- else %}
+    0x00000000, // Verify
+{%- endif %}
+
+    // BKPT : start of blob + 1
+    // RSB  : blob start + header + rw data offset
+    // RSP  : stack pointer
+    {
+        {{'0x%08x' % (entry + 1)}},
+        {{'0x%08x' % (entry + header_size + algo.rw_start)}},
+        {{'0x%08x' % stack_pointer}}
+    },
+
+    // mem buffer location
+    {{'0x%08x' % stack_pointer}},
+    // location to write prog_blob in target RAM
+    {{'0x%08x' % entry}},
+    // prog_blob size
+    sizeof({{name}}_flash_prog_blob),
+    // address of prog_blob
+    {{name}}_flash_prog_blob,
+    // ram_to_flash_bytes_to_be_written
+    {{'0x%08x' % algo.page_size}}
+};
+
+"""
+
+colorama.init()
+
+def str_to_num(val):
+    return int(val, 0)  #convert string to number and automatically handle hex conversion
+
+class PackFlashAlgoGenerator(PackFlashAlgo):
+    """
+    Class to wrap a flash algo
+
+    This class is intended to provide easy access to the information
+    provided by a flash algorithm, such as symbols and the flash
+    algorithm itself.
+    """
+
+    def format_algo_data(self, spaces, group_size, fmt):
+        """"
+        Return a string representing algo_data suitable for use in a template
+
+        The string is intended for use in a template.
+
+        :param spaces: The number of leading spaces for each line
+        :param group_size: number of elements per line (element type
+            depends of format)
+        :param fmt: - format to create - can be either "hex" or "c"
+        """
+        padding = " " * spaces
+        if fmt == "hex":
+            blob = binascii.b2a_hex(self.algo_data)
+            line_list = []
+            for i in range(0, len(blob), group_size):
+                line_list.append('"' + blob[i:i + group_size] + '"')
+            return ("\n" + padding).join(line_list)
+        elif fmt == "c":
+            blob = self.algo_data[:]
+            pad_size = 0 if len(blob) % 4 == 0 else 4 - len(blob) % 4
+            blob = blob + b"\x00" * pad_size
+            integer_list = struct.unpack("<" + "L" * (len(blob) // 4), blob)
+            line_list = []
+            for pos in range(0, len(integer_list), group_size):
+                group = ["0x%08x" % value for value in
+                         integer_list[pos:pos + group_size]]
+                line_list.append(", ".join(group))
+            return (",\n" + padding).join(line_list)
+        else:
+            raise Exception("Unsupported format %s" % fmt)
+
+    def process_template(self, template_text, data_dict=None):
+        """
+        Generate output from the supplied template
+
+        All the public methods and fields of this class can be accessed from
+        the template via "algo".
+
+        :param template_path: Relative or absolute file path to the template
+        :param data_dict: Additional data to use when generating
+        """
+        if data_dict is None:
+            data_dict = {}
+        else:
+            assert isinstance(data_dict, dict)
+            data_dict = dict(data_dict)
+        assert "algo" not in data_dict, "algo already set by user data"
+        data_dict["algo"] = self
+        data_dict["algo_size"] = len(self.algo_data)
+
+        template = jinja2.Template(template_text)
+        return template.render(data_dict)
+
+def main():
+    parser = argparse.ArgumentParser(description="Blob generator")
+    parser.add_argument("elf_path", help="Elf, axf, or flm to extract flash algo from")
+    parser.add_argument("--blob-start", default=0x20000000, type=str_to_num, help="Starting "
+                        "address of the flash blob in target RAM.")
+    parser.add_argument("--stack-size", default=STACK_SIZE, type=str_to_num, help="Stack size for the algo "
+                        f"(default {STACK_SIZE}).")
+    parser.add_argument("--pack-path", default=None, help="Path to pack file from which flash algo is from")
+    parser.add_argument("-i", "--info-only", action="store_true", help="Only print information about the flash "
+                        "algo, do not generate a blob.")
+    parser.add_argument("-o", "--output", default="target_blob.c", help="Path of output file "
+                        "(default 'target_blob.c').")
+    parser.add_argument("-t", "--template", help="Path to Jinja template file (default is an internal "
+                        "template for DAPLink).")
+    parser.add_argument('-c', '--copyright', help="Set copyright owner.")
+    args = parser.parse_args()
+
+    if not args.copyright:
+        print(f"{colorama.Fore.YELLOW}Warning! No copyright owner was specified. Defaulting to \"Arm Limited\". "
+            f"Please set via --copyright, or edit output.{colorama.Style.RESET_ALL}")
+
+    if args.template:
+        with open(args.template, "r") as tmpl_file:
+            tmpl = tmpl_file.read()
+    else:
+        tmpl = DAPLINK_TEMPLATE
+
+    with open(args.elf_path, "rb") as file_handle:
+        algo = PackFlashAlgoGenerator(file_handle)
+
+        print(algo.flash_info)
+
+        if args.info_only:
+            return
+
+        pack_file = None
+        if args.pack_path and os.path.exists(args.pack_path) and 'cmsis-pack-manager' in args.pack_path:
+            (rest, version) = (os.path.split(args.pack_path))
+            (rest, pack) = (os.path.split(rest))
+            (_, vendor) = (os.path.split(rest))
+            pack_file = '%s.%s.%s' % (vendor, pack, version)
+        elif args.pack_path:
+            pack_file = os.path.split(args.pack_path)[-1]
+        else:
+            print(f"{colorama.Fore.YELLOW}Warning! No CMSIS Pack was set."
+                f"Please set the path or file name of the CMSIS pack via --pack-path.{colorama.Style.RESET_ALL}")
+
+        file_handle.seek(0)
+        flm_content = file_handle.read()
+        hash = hashlib.sha256()
+        hash.update(flm_content)
+
+        # Allocate stack after algo and its rw data, with top and bottom rounded to 256 bytes.
+        stack_base = args.blob_start + HEADER_SIZE + algo.rw_start + algo.rw_size
+        stack_base = (stack_base + 7) // 8 * 8
+        sp = stack_base + args.stack_size
+        sp = (sp + 255) // 256 * 256
+
+        data_dict = {
+            'filename': os.path.split(args.elf_path)[-1],
+            'digest': hash.hexdigest(),
+            'file_size': len(flm_content),
+            'pack_file': pack_file,
+            'name': os.path.splitext(os.path.split(args.elf_path)[-1])[0],
+            'prog_header': BLOB_HEADER,
+            'header_size': HEADER_SIZE,
+            'entry': args.blob_start,
+            'stack_pointer': sp,
+            'year': datetime.now().year,
+            'copyright_owner': args.copyright or "Arm Limited",
+        }
+
+        text = algo.process_template(tmpl, data_dict)
+
+        with open(args.output, "w") as file_handle:
+            file_handle.write(text)
+
+        print(f"Wrote flash algo dict to {args.output}")
+
+if __name__ == '__main__':
+    main()