FlashAlgo 算法python实现

离线编程器：

1、首先，既然是SWD编程器，那首先当然是要实现SWD时序协议了
由于单片机都没有SWD外设，所以只能用GPIO模拟实现SWD时序，，这部分功能已经由ARM公司的CMSIS-DAP代码实现

2、然后就是基于CMSIS-DAP，实现通过DAP读写目标芯片的内存、内核寄存器，，这部分功能已经由DAPLink里面的swd_host.c文件实现

同时，swd_host.c还实现了另一个对实现编程器至关重要的函数：

1. uint8_t swd_flash_syscall_exec(const program_syscall_t *sysCallParam, uint32_t entry, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4)

复制代码

它的作用是通过DAP在目标芯片上执行

那么，我们只要把编程算法（一段在目标芯片上执行的代码，里面有Flash_Erase、Flash_Write两个函数）通过SWD写入目标芯片的SRAM，然后再通过SWD调用目标芯片SRAM里面的Flash_Erase、Flash_Write两个函数，不就能实现通过SWD给目标芯片编程了吗？？

所以，程序的主体结构就是：

其中target_flash_init()的主要作用就是把芯片的编程算法下载到目标芯片的SRAM中去

好了，SWD编程器已经实现

不过还有一个问题：要下载到目标芯片SRAM中去的编程算法从哪里来？？

我们知道，Keil针对每一颗芯片都有一个Flash编程算法，这个算法存在一个后缀为.FLM的文件里面，，要是我们能把.FLM文件里面的算法内容抽取出来给我们用，，那不就完美了吗

3、其实这个功能也已经有国外大神给实现了，GitHub上的FlashAlgo项目里面有个flash_algo.py文件，它就是用来实现这个功能的
 

flash_algo.py

#! python3
"""
 mbed
 Copyright (c) 2017-2017 ARM Limited
"""
import os
import io
import struct
import binascii
from collections import namedtuple

import jinja2
from elftools.elf.elffile import ELFFile

class PackFlashAlgo(object):
    REQUIRED_SYMBOLS = (
        "Init",
        "UnInit",
        "EraseSector",
        "ProgramPage",
    )

    EXTRA_SYMBOLS = (
        "BlankCheck",
        "EraseChip",
        "Verify",
        "Read",
    )

    def __init__(self, data):
        ''' 从ELF文件中依次解析出Flash信息和所需的symbols、sections，
            然后根据section的信息创建可在RAM中执行的算法程序的二进制blob '''
        self.elf = ElfFileSimple(data)

        self.flash_info = PackFlashInfo(self.elf)
        self.flash_start     = self.flash_info.start
        self.flash_size      = self.flash_info.size
        self.flash_page_size = self.flash_info.page_size

        self.symbols = {}
        for symbol in self.REQUIRED_SYMBOLS:
            if symbol not in self.elf.symbols: raise Exception("Missing symbol %s" % symbol)
            self.symbols[symbol] = self.elf.symbols[symbol].value
        for symbol in self.EXTRA_SYMBOLS:
            if symbol not in self.elf.symbols: self.symbols[symbol] = 0xFFFFFFFF
            else:                              self.symbols[symbol] = self.elf.symbols[symbol].value

        ''' 算法程序工程的link脚本：
        PRG 0 PI
        {
            PrgCode +0           ; Code
            {
                * (+RO)
            }
            
            PrgData +0           ; Data
            {
                * (+RW,+ZI)
            }
        }
        '''
        ro_rw_zi = [None, None, None]
        for section in self.elf.iter_sections():
            for i, name_and_type in enumerate((("PrgCode", "SHT_PROGBITS"),
                                               ("PrgData", "SHT_PROGBITS"),
                                               ("PrgData", "SHT_NOBITS"),)):
                if name_and_type != (section.name, section["sh_type"]): continue
                if ro_rw_zi[i] is not None: raise Exception("Duplicated section")

                ro_rw_zi[i] = section

        ''' 若zi段丢失，创建一个空的 '''
        s_ro, s_rw, s_zi = ro_rw_zi
        if s_rw is not None and s_zi is None:
            s_zi = {
                "sh_addr": s_rw["sh_addr"] + s_rw["sh_size"],
                "sh_size": 0
            }
        
        if s_ro is None: raise Exception("RO section is missing")
        if s_rw is None: raise Exception("RW section is missing")
        if s_zi is None: raise Exception("ZI section is missing")
        if s_ro["sh_addr"] != 0:
            raise Exception("RO section does not start at address 0")
        if s_ro["sh_addr"] + s_ro["sh_size"] != s_rw["sh_addr"]:
            raise Exception("RW section does not follow RO section")
        if s_rw["sh_addr"] + s_rw["sh_size"] != s_zi["sh_addr"]:
            raise Exception("ZI section does not follow RW section")

        self.ro_start = s_ro["sh_addr"]
        self.ro_size  = s_ro["sh_size"]
        self.rw_start = s_rw["sh_addr"]
        self.rw_size  = s_rw["sh_size"]
        self.zi_start = s_zi["sh_addr"]
        self.zi_size  = s_zi["sh_size"]

        
        algo_size = s_ro["sh_size"] + s_rw["sh_size"] + s_zi["sh_size"]
        self.algo_data = bytearray(algo_size)
        for section in (s_ro, s_rw):
            start = section["sh_addr"]
            size  = section["sh_size"]
            assert len(section.data()) == size
            self.algo_data[start : start+size] = section.data()

    def format_algo_data(self, spaces, group_size, fmt):
        ''' 返回一个能表示algo_data的字符串 suitable for use in a template
            spaces: 每行的前导空格个数    group_size: 每行的元素个数    fmt: hex、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_path, output_path, data_dict=None):
        ''' 用模板文件生成输出文件， 此类的所有数据都可以在模板中通过 'algo' 访问
            data_dict: 生成输出时模板需要的其他数据                        '''
        if data_dict is None: data_dict = {}
        
        assert "algo" not in data_dict, "algo already set by user data"
        data_dict["algo"] = self

        with open(template_path) as f:
            template = jinja2.Template(f.read())

            with open(output_path, "wb") as f:
                f.write(template.render(data_dict).encode('latin'))

class PackFlashInfo(object):
    """从ELF文件中解析出FlashDev.c文件中定义的FlashDevice结构体变量的值"""

    FLASH_DEVICE_STRUCT = "<H128sHLLLLBxxxLL"   # FlashDevice结构体的成员
    FLASH_SECTOR_STRUCT = "<LL"                 # FlashSector结构体的成员
    FLASH_DEVICE_STRUCT_SIZE = struct.calcsize(FLASH_DEVICE_STRUCT)
    FLASH_SECTOR_STRUCT_SIZE = struct.calcsize(FLASH_SECTOR_STRUCT)
    SECTOR_END = (0xFFFFFFFF, 0xFFFFFFFF)

    def __init__(self, elf):
        info = elf.symbols["FlashDevice"]
        info_start = info.value
        info_size  = self.FLASH_DEVICE_STRUCT_SIZE
        info_data  = elf.read(info_start, info_size)

        values = struct.unpack(self.FLASH_DEVICE_STRUCT, info_data)

        self.version          = values[0]
        self.name             = values[1].strip(b"\x00")
        self.type             = values[2]
        self.start            = values[3]
        self.size             = values[4]
        self.page_size        = values[5]
        self.value_empty      = values[7]
        self.prog_timeout_ms  = values[8]
        self.erase_timeout_ms = values[9]

        self.sector_info_list = []
        for i in range(512):    # 最多512个sector
            data = elf.read(info_start + info_size + self.FLASH_SECTOR_STRUCT_SIZE * i, self.FLASH_SECTOR_STRUCT_SIZE)
            size, addr = struct.unpack(self.FLASH_SECTOR_STRUCT, data)

            if (size, addr) == self.SECTOR_END: break

            self.sector_info_list.append((addr, size))

    def __str__(self):
        desc = ""
        desc += "Flash Device:" + os.linesep
        desc += "  name=%s"             % self.name             + os.linesep
        desc += "  version=0x%x"        % self.version          + os.linesep
        desc += "  type=%i"             % self.type             + os.linesep
        desc += "  start=0x%x"          % self.start            + os.linesep
        desc += "  size=0x%x"           % self.size             + os.linesep
        desc += "  page_size=0x%x"      % self.page_size        + os.linesep
        desc += "  value_empty=0x%x"    % self.value_empty      + os.linesep
        desc += "  prog_timeout_ms=%i"  % self.prog_timeout_ms  + os.linesep
        desc += "  erase_timeout_ms=%i" % self.erase_timeout_ms + os.linesep
        desc += "  sectors:" + os.linesep
        for sector_addr, sector_size in self.sector_info_list:
            desc += ("    addr=0x%x, size=0x%x" %(sector_addr, sector_size) + os.linesep)

        return desc

SymbolSimple = namedtuple("SymbolSimple", "name, value, size")

class ElfFileSimple(ELFFile):
    ''' ELF对象包装，以更方便访问 symbols 和 rom '''

    def __init__(self, data):
        super(ElfFileSimple, self).__init__(io.BytesIO(data))

        self.symbols = {}   # 将 symbol table 中信息读出存入此中，方便访问
        for symbol in self.get_section_by_name(".symtab").iter_symbols():
            self.symbols[symbol.name] = SymbolSimple(symbol.name, symbol["st_value"], symbol["st_size"])

    def read(self, addr, size):     # 从ELF文件中读取程序数据        
        for segment in self.iter_segments():
            seg_addr = segment["p_paddr"]
            seg_size = min(segment["p_memsz"], segment["p_filesz"])
            
            if addr >= seg_addr and addr + size <= seg_addr + seg_size:
                start = addr - seg_addr
                return segment.data()[start : start+size]
            else:
                continue

if __name__ == '__main__':
    # 中断halt程序，让函数执行完后返回到这里来执行从而让CPU自动halt住
    BLOB_HEADER = '0xE00ABE00, 0x062D780D, 0x24084068, 0xD3000040, 0x1E644058, 0x1C49D1FA, 0x2A001E52, 0x4770D1F2,'
    HEADER_SIZE = 0x20

    data_dict = {
        'prog_header': BLOB_HEADER,
        'header_size': HEADER_SIZE,
        'entry': 0x20000000,
        'stack_pointer': 0x20000000 + 4096,
    }

    for name in os.listdir(os.getcwd()):
        if os.path.isfile(name) and name.endswith('.FLM'):
            with open(name, 'rb') as f:
                algo = PackFlashAlgo(f.read())
                print(algo.flash_info)
                if 'algo' in data_dict: del data_dict['algo']
                algo.process_template('c_blob.tmpl', name.replace('.FLM', '.c'), data_dict)
 

c_blob.tmpl

/* Flash OS Routines (Automagically Generated)
 * Copyright (c) 2009-2015 ARM Limited
 */
#include "flash_blob.h"

static const uint32_t flash_code[] = {
    {{prog_header}}
    {{algo.format_algo_data(4, 8, "c")}}
};

const program_target_t flash_algo = {
    {{'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

    // BKPT : start of blob + 1
    // RSB  : address to access global/static data
    // RSP  : stack pointer
    {
        {{'0x%08X' % (entry + 1)}},
        {{'0x%08X' % (entry + algo.rw_start + header_size)}},
        {{'0x%08X' % (entry + algo.rw_start + header_size + algo.rw_size + algo.flash_page_size + 1024)}}
    },

    {{'0x%08X' % (entry + algo.rw_start + header_size + algo.rw_size)}},  // mem buffer location
    {{'0x%08X' % entry}},  // location to write prog_blob in target RAM
    sizeof(flash_code),  // prog_blob size
    flash_code,  // address of prog_blob
    {{'0x%08X' % algo.flash_page_size}},  // ram_to_flash_bytes_to_be_written
};

工程示例代码：

GitHub - XIVN1987/DAPProg: Offline SWD Programmer for Cortex-M Core MCU