blflashcommand/libs/base/bflb_base_eflash_loader.py

# decompyle3 version 3.9.0
# Python bytecode version base 3.7.0 (3394)
# Decompiled from: Python 3.7.16 (default, Mar 30 2023, 01:25:49) 
# [GCC 12.2.1 20220924]
# Embedded file name: libs/base/bflb_base_eflash_loader.py
__doc__ = '\nCreated on 20220908\n\n@author: Dillon\n'
import os, lzma, ecdsa, config as gol
from libs.bflb_utils import *
from libs.bflb_configobj import BFConfigParser
from libs import bflb_ecdh
from libs import bflb_interface_jlink
from libs import bflb_interface_cklink
from libs import bflb_interface_openocd
from libs.base import bflb_img_loader
from libs.base import bflb_flash_select
from libs.base import bflb_efuse_boothd_create
from libs.base import bflb_img_create as img_create
from pickle import NONE
FLASH_LOAD_SHAKE_HAND = 'Flash load shake hand'
FLASH_ERASE_SHAKE_HAND = 'Flash erase shake hand'

class BaseEflashLoader(object):
    __doc__ = '\n    Load the flash base execution file.\n    '

    def __init__(self, chip_type, args, config, callback, macaddr_callback, create_simple_callback, create_img_callback, task_num):
        self.chip_type = chip_type
        self.chip_name = ''
        self.args = args
        self.config = config
        self.callback = callback
        self.macaddr_callback = macaddr_callback
        self.create_simple_callback = create_simple_callback
        self.create_img_callback = create_img_callback
        self.temp_task_num = task_num
        self.task_num = None
        self.device = ''
        self.speed = 0
        self.boot_speed = 0
        self.bflb_serial_object = None
        self.start = ''
        self.end = ''
        self.file = ''
        self.address = ''
        self.macaddr = ''
        self.bootinfo = None
        self.flash_set = 0
        self.read_flash_id = 0
        self.id_valid_flag = '80'
        self.read_flash2_id = 0
        self.id2_valid_flag = '80'
        self.do_reset = True
        self.reset_hold_time = 100
        self.shake_hand_delay = 100
        self.reset_revert = True
        self.cutoff_time = 0
        self.shake_hand_retry = 2
        self.flash_burn_retry = 1
        self.ram_load = False
        self.load_function = 1
        self.macaddr_check = False
        self.NUM_ERR = 5
        self.cfg = ''
        self.eflash_loader_file = ''
        self.cpu_reset = False
        self.retry_delay_after_cpu_reset = 0
        self.input_macaddr = ''
        self.isp_mode_sign = False
        self.create_cfg = None
        self._skip_addr = []
        self._skip_len = []
        self.address_list = []
        self.flash_file_list = []
        self.encrypt_key = None
        self.encrypt_iv = None
        self.public_key = None
        self.private_key = None
        self.load_file = ''
        self._mac_addr = bytearray(0)
        self._need_shake_hand = True
        self._isp_shakehand_timeout = 0
        self._macaddr_check = bytearray(0)
        self._default_time_out = 2.0
        self._flash2_en = False
        self._flash1_size = 0
        self._flash2_size = 0
        self._flash2_select = False
        self._efuse_bootheader_file = ''
        self._img_create_file = ''
        self._com_cmds = {'change_rate':{'cmd_id':'20', 
          'data_len':'0008', 
          'callback':None}, 
         'reset':{'cmd_id':'21', 
          'data_len':'0000', 
          'callback':None}, 
         'clk_set':{'cmd_id':'22', 
          'data_len':'0000', 
          'callback':None}, 
         'opt_finish':{'cmd_id':'23', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_erase':{'cmd_id':'30', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_write':{'cmd_id':'31', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_read':{'cmd_id':'32', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_boot':{'cmd_id':'33', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_xip_read':{'cmd_id':'34', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_switch_bank':{'cmd_id':'35', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_read_jid':{'cmd_id':'36', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_read_status_reg':{'cmd_id':'37', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_write_status_reg':{'cmd_id':'38', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_write_check':{'cmd_id':'3a', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_set_para':{'cmd_id':'3b', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_chiperase':{'cmd_id':'3c', 
          'data_len':'0000', 
          'callback':None}, 
         'flash_readSha':{'cmd_id':'3d', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_xip_readSha':{'cmd_id':'3e', 
          'data_len':'0100', 
          'callback':None}, 
         'flash_decompress_write':{'cmd_id':'3f', 
          'data_len':'0100', 
          'callback':None}, 
         'efuse_write':{'cmd_id':'40', 
          'data_len':'0080', 
          'callback':None}, 
         'efuse_read':{'cmd_id':'41', 
          'data_len':'0000', 
          'callback':None}, 
         'efuse_read_mac':{'cmd_id':'42', 
          'data_len':'0000', 
          'callback':None}, 
         'efuse_write_mac':{'cmd_id':'43', 
          'data_len':'0006', 
          'callback':None}, 
         'flash_xip_read_start':{'cmd_id':'60', 
          'data_len':'0080', 
          'callback':None}, 
         'flash_xip_read_finish':{'cmd_id':'61', 
          'data_len':'0000', 
          'callback':None}, 
         'log_read':{'cmd_id':'71', 
          'data_len':'0000', 
          'callback':None}, 
         'efuse_security_write':{'cmd_id':'80', 
          'data_len':'0080', 
          'callback':None}, 
         'efuse_security_read':{'cmd_id':'81', 
          'data_len':'0000', 
          'callback':None}, 
         'ecdh_get_pk':{'cmd_id':'90', 
          'data_len':'0000', 
          'callback':None}, 
         'ecdh_chanllenge':{'cmd_id':'91', 
          'data_len':'0000', 
          'callback':None}}
        self._resp_cmds = [
         'flash_read','flash_xip_read','efuse_read','efuse_read_mac','flash_readSha','flash_xip_readSha','flash_read_jid',
         'flash_read_status_reg','log_read','ecdh_get_pk','ecdh_chanllenge','efuse_security_read']

    def first_run_step_load_parameter(self):
        """
        First step: init.
        """
        if self.temp_task_num == None:
            local_log_enable(True)
        if self.temp_task_num != None:
            if self.temp_task_num > 256:
                self.task_num = self.temp_task_num - 256
            else:
                self.task_num = self.temp_task_num
        else:
            self.task_num = None
        printf('========= eflash loader cmd arguments =========')
        self.interface = self.config['param']['interface_type'].lower()
        self.chip_name = self.config['param']['chip_name']
        self.config_file = os.path.join(app_path, 'chips', self.chip_name.lower(), 'eflash_loader', 'eflash_loader_cfg.ini')
        if not os.path.exists(self.config_file):
            conf_file = self.config_file.replace('.ini', '.conf')
            if os.path.exists(conf_file):
                shutil.copy(conf_file, self.config_file)
        if os.path.exists(self.config_file):
            self.cfg = BFConfigParser()
            self.cfg.read(self.config_file)
        else:
            printf('Config file "' + self.config_file + '" not found')
            self.error_code_print('000B')
            return (False, 0)
        if self.interface == 'openocd':
            self.device = self.cfg.get('LOAD_CFG', 'openocd_config')
            self._bflb_sn_device = self.config['param']['comport_uart']
        else:
            if self.interface == 'cklink':
                self.device = self.cfg.get('LOAD_CFG', 'cklink_vidpid')
                self._bflb_sn_device = self.cfg.get('LOAD_CFG', 'cklink_type') + ' ' + self.config['param']['comport_uart']
            else:
                self.device = self.config['param']['comport_uart']
        if 'aes_key' in self.config['param']:
            if self.config['check_box']['encrypt']:
                self.encrypt_key = self.config['param']['aes_key']
        if 'aes_iv' in self.config['param']:
            if self.config['check_box']['sign']:
                self.encrypt_iv = self.config['param']['aes_iv']
        if 'input_path' in self.config:
            if 'publickey' in self.config['input_path']['publickey']:
                self.public_key = self.config['input_path']['publickey']
        if 'input_path' in self.config:
            if 'privatekey' in self.config['input_path']['privatekey']:
                self.private_key = self.config['input_path']['privatekey']
        xtal_type = self.config['param']['chip_xtal']
        if self.interface == 'uart':
            temp_speed = int(self.config['param']['speed_uart'])
        else:
            temp_speed = int(self.config['param']['speed_jlink'])
        printf('serial port is ', self.device)
        printf('chiptype: ', self.chip_type)
        try:
            if self.args.start:
                self.start = self.args.start
            if self.args.end:
                self.end = self.args.end
            if self.args.file:
                self.file = self.args.file
            if self.args.addr:
                self.address = self.args.addr
            if self.args.mac:
                self.macaddr = self.args.mac
            if self.args.createcfg:
                self.create_cfg = self.args.createcfg
            if self.args.loadfile:
                self.load_file = self.args.loadfile
            if self.args.usage:
                printf('-e --start=00000000 --end=0000FFFF -c config.ini')
                printf('-w --flash -c config.ini')
                printf('-w --flash --file=1.bin,2.bin --addr=00000000,00001000 -c config.ini')
                printf('-r --flash --start=00000000 --end=0000FFFF --file=flash.bin -c config.ini')
        except Exception as e:
            try:
                printf(e)
                self.error_code_print('0002')
                return (False, 0)
            finally:
                e = None
                del e

        if self.cfg.has_option('LOAD_CFG', 'verify'):
            if self.cfg.get('LOAD_CFG', 'verify') == '1':
                self.verify = 1
            else:
                self.verify = 0
        else:
            self.verify = 0
        try:
            self.erase = int(self.config['param']['erase'])
        except:
            self.erase = 1

        try:
            boot2_isp_mode = int(self.config['param']['boot2_isp_mode'])
            if int(boot2_isp_mode) == 1:
                self.isp_mode_sign = True
        except:
            pass

        if not 'skip_mode' in self.config['param'] or self.config['param']['skip_mode']:
            skip_para = self.config['param']['skip_mode'].replace(' ', '')
            if skip_para[-1] == ';':
                skip_para = skip_para[:-1]
            skip_para_list = skip_para.split(';')
            for temp_value in skip_para_list:
                temp_list = temp_value.split(',')
                if temp_list[0][0:2] == '0x':
                    self._skip_addr.append(int(temp_list[0][2:], 16))
                else:
                    self._skip_addr.append(int(temp_list[0], 10))
                if temp_list[1][0:2] == '0x':
                    self._skip_len.append(int(temp_list[1][2:], 16))
                else:
                    self._skip_len.append(int(temp_list[1], 10))

            if len(self._skip_len) > 1 or len(self._skip_len) == 1 and self._skip_len[0] > 0:
                if self.erase == 2:
                    printf('Error: skip mode can not set flash chiperase!')
                    self.error_code_print('0044')
                    return (False, 0)
            if self.cfg.has_option('LOAD_CFG', 'local_log'):
                if self.cfg.get('LOAD_CFG', 'local_log') == 'true':
                    printf('local log enable')
                    local_log_enable(True)
                    self.input_macaddr = self.macaddr
                else:
                    local_log_enable(False)
                    self.input_macaddr = ''
            if self.interface == 'cklink':
                self._bflb_com_tx_size = 14344
            else:
                self._bflb_com_tx_size = int(self.cfg.get('LOAD_CFG', 'tx_size'))
            if self.cfg.has_option('LOAD_CFG', 'erase_time_out'):
                self._erase_time_out = int(self.cfg.get('LOAD_CFG', 'erase_time_out'))
            if self.cfg.has_option('LOAD_CFG', 'shake_hand_retry'):
                self.shake_hand_retry = int(self.cfg.get('LOAD_CFG', 'shake_hand_retry'))
            if self.cfg.has_option('LOAD_CFG', 'flash_burn_retry'):
                self.flash_burn_retry = int(self.cfg.get('LOAD_CFG', 'flash_burn_retry'))
            if self.cfg.has_option('LOAD_CFG', 'checksum_err_retry'):
                self._checksum_err_retry_limit = int(self.cfg.get('LOAD_CFG', 'checksum_err_retry'))
            if self.cfg.has_option('LOAD_CFG', 'cpu_reset_after_load'):
                self.cpu_reset = self.cfg.get('LOAD_CFG', 'cpu_reset_after_load') == 'true'
            if self.cfg.has_option('LOAD_CFG', 'retry_delay_after_cpu_reset'):
                self.retry_delay_after_cpu_reset = int(self.cfg.get('LOAD_CFG', 'retry_delay_after_cpu_reset'))
                printf('retry delay: ', self.retry_delay_after_cpu_reset)
            if self.cfg.has_option('LOAD_CFG', 'eflash_loader_file'):
                if self.eflash_loader_file is None:
                    self.eflash_loader_file = self.cfg.get('LOAD_CFG', 'eflash_loader_file')
            printf('cpu_reset=', self.cpu_reset)
            if xtal_type != '':
                self.eflash_loader_file = 'chips/' + self.chip_name.lower() + '/eflash_loader/eflash_loader_' + xtal_type.replace('.', 'p').lower() + '.bin'
            if self.load_file and not self.eflash_loader_file:
                self.eflash_loader_file = self.load_file
            else:
                if self.eflash_loader_file is not None:
                    self.eflash_loader_file = os.path.join(app_path, self.eflash_loader_file)
            self.load_function = 1
            if self.cfg.has_option('LOAD_CFG', 'isp_shakehand_timeout'):
                self._isp_shakehand_timeout = int(self.cfg.get('LOAD_CFG', 'isp_shakehand_timeout'))
            result, address, flash_file = self.get_flash_file_and_address()
            if not result:
                return (False, self.flash_burn_retry)
            temp_file_list = []
            for one in flash_file:
                if os.path.join(chip_path, self.chip_name) in one:
                    temp_file_list.append(one.replace(app_path, '')[1:])
                else:
                    temp_file_list.append(os.path.join('chips', self.chip_name, 'img_create', os.path.basename(one)))

            if 'erase' in self.config['param']:
                if self.config['param']['erase']:
                    update_cfg(self.cfg, 'LOAD_CFG', 'erase', str(self.erase))
            if 'skip_mode' in self.config['param']:
                if self.config['param']['skip_mode']:
                    update_cfg(self.cfg, 'LOAD_CFG', 'skip_mode', self.config['param']['skip_mode'])
            if 'boot2_isp_mode' in self.config['param']:
                if self.config['param']['boot2_isp_mode']:
                    update_cfg(self.cfg, 'LOAD_CFG', 'boot2_isp_mode', self.config['param']['boot2_isp_mode'])
            update_cfg(self.cfg, 'FLASH_CFG', 'file', ' '.join(temp_file_list))
            update_cfg(self.cfg, 'FLASH_CFG', 'address', ' '.join(address))
            self.cfg.write(self.config_file, 'w+')
            with open((self.config_file), 'r', encoding='utf-8') as cf_file:
                cf_context = cf_file.read().replace('"', '')
            with open((self.config_file), 'w', encoding='utf-8') as cf_file:
                cf_file.write(cf_context)
            self.bl_write_flash_img(address, flash_file)
            self.address_list = address[:]
            self.flash_file_list = flash_file[:]
            if self.args.efuse:
                try:
                    if self.config['input_path']['efuse']:
                        if self.config['check_box']['efuse']:
                            efusefile = self.config['input_path']['efuse']
                except:
                    efusefile = ''

                if efusefile:
                    efuse_file = efusefile
                    mask_file = efuse_file.replace('.bin', '_mask.bin')
                    relpath_efuse_file = os.path.relpath(os.path.join('chips', self.chip_name, 'img_create', os.path.basename(efuse_file)))
                    relpath_mask_file = os.path.relpath(os.path.join('chips', self.chip_name, 'img_create', os.path.basename(mask_file)))
                    if self.cfg.has_option('EFUSE_CFG', 'file'):
                        update_cfg(self.cfg, 'EFUSE_CFG', 'file', relpath_efuse_file)
                        update_cfg(self.cfg, 'EFUSE_CFG', 'maskfile', relpath_mask_file)
                        self.cfg.write(self.config_file, 'w+')
                        with open((self.config_file), 'r', encoding='utf-8') as cf_file:
                            cf_context = cf_file.read().replace('"', '')
                        with open((self.config_file), 'w', encoding='utf-8') as cf_file:
                            cf_file.write(cf_context)
                else:
                    efuse_file = self.cfg.get('EFUSE_CFG', 'file')
                    mask_file = self.cfg.get('EFUSE_CFG', 'maskfile')
                if self.temp_task_num != None:
                    efuse_file = 'task' + str(self.temp_task_num) + '/' + efuse_file
                ret = img_create.compress_dir(self.chip_name, 'img_create', self.args.efuse, address, flash_file, efuse_file, mask_file)
                if ret is not True:
                    return errorcode_msg()
            else:
                ret = img_create.compress_dir(self.chip_name, 'img_create', False, address, flash_file)
                if ret is not True:
                    return errorcode_msg()
            if self.interface == 'uart' or self.interface == 'sdio':
                if temp_speed:
                    self.speed = temp_speed
                self.boot_speed = int(self.cfg.get('LOAD_CFG', 'speed_uart_boot'))
                self.set_boot_speed()
                if self.cfg.has_option('LOAD_CFG', 'reset_hold_time'):
                    self.reset_hold_time = int(self.cfg.get('LOAD_CFG', 'reset_hold_time'))
                if self.cfg.has_option('LOAD_CFG', 'shake_hand_delay'):
                    self.shake_hand_delay = int(self.cfg.get('LOAD_CFG', 'shake_hand_delay'))
                if self.cfg.has_option('LOAD_CFG', 'do_reset'):
                    self.do_reset = self.cfg.get('LOAD_CFG', 'do_reset') == 'true'
                if self.cfg.has_option('LOAD_CFG', 'reset_revert'):
                    self.reset_revert = self.cfg.get('LOAD_CFG', 'reset_revert') == 'true'
                if self.cfg.has_option('LOAD_CFG', 'cutoff_time'):
                    self.cutoff_time = int(self.cfg.get('LOAD_CFG', 'cutoff_time'))
                printf('========= Interface is %s =========' % self.interface)
                self._bflb_com_img_loader = bflb_img_loader.BflbImgLoader(self.device, self.speed, self.boot_speed, self.interface, self.chip_type, self.chip_name, self.eflash_loader_file, '', self.callback, self.do_reset, self.reset_hold_time, self.shake_hand_delay, self.reset_revert, self.cutoff_time, self.shake_hand_retry, self.isp_mode_sign, self._isp_shakehand_timeout, self.encrypt_key, self.encrypt_iv, self.public_key, self.private_key)
                self.bflb_serial_object = self._bflb_com_img_loader.bflb_serial_object
                if not self.cfg.has_option('LOAD_CFG', 'isp_mode_speed') or self.isp_mode_sign is True:
                    isp_mode_speed = int(self.cfg.get('LOAD_CFG', 'isp_mode_speed'))
                    self._bflb_com_img_loader.set_isp_baudrate(isp_mode_speed)
            else:
                if self.interface == 'jlink':
                    printf('========= Interface is JLink =========')
                    self.bflb_serial_object = bflb_interface_jlink.BflbJLinkPort()
                    if temp_speed:
                        self.speed = temp_speed
                        printf('com speed: %dk' % self.speed)
                    else:
                        self.speed = int(self.cfg.get('LOAD_CFG', 'speed_jlink'))
                    self.boot_speed = self.speed
                else:
                    if self.interface == 'openocd':
                        printf('========= Interface is Openocd =========')
                        self.bflb_serial_object = bflb_interface_openocd.BflbOpenocdPort()
                        if temp_speed:
                            self.speed = temp_speed
                            printf('com speed: %dk' % self.speed)
                        else:
                            self.speed = int(self.cfg.get('LOAD_CFG', 'speed_jlink'))
                        self.boot_speed = self.speed
                    else:
                        if self.interface == 'cklink':
                            printf('========= Interface is CKLink =========')
                            self.bflb_serial_object = bflb_interface_cklink.BflbCKLinkPort()
                            if temp_speed:
                                self.speed = temp_speed
                                printf('com speed: %dk' % self.speed)
                            else:
                                self.speed = int(self.cfg.get('LOAD_CFG', 'speed_jlink'))
                            self.boot_speed = self.speed
                        else:
                            printf(self.interface + ' is not supported ')
                            return (
                             False, self.flash_burn_retry)
            if self.args.chipid:
                ret, self.bootinfo, res = self.get_boot_info()
                if ret is False:
                    self.error_code_print('0003')
                    return (
                     False, self.flash_burn_retry)
                return (
                 True, self.flash_burn_retry)
            if self.cfg.has_option('LOAD_CFG', 'load_function'):
                self.load_function = int(self.cfg.get('LOAD_CFG', 'load_function'))
            if self.isp_mode_sign is True:
                if self._isp_shakehand_timeout == 0:
                    self._isp_shakehand_timeout = 5
                self.set_load_function()
            return (True, 'continue')

    def second_run_step_shake_hand(self):
        """
        Second step: shake hand and load eflash_loader.bin.
        """
        try:
            if self.load_function == 0:
                printf('No need load eflash_loader.bin')
            else:
                if self.load_function == 1:
                    load_bin_pass = False
                    printf('Eflash load bin file: ', self.eflash_loader_file)
                    ret, self.bootinfo, res = self.load_eflash_loader_bin()
                    if res == 'shake hand fail':
                        self.error_code_print('0050')
                    if res.startswith('repeat_burn') is True:
                        return ('repeat_burn', self.flash_burn_retry)
                    if res.startswith('error_shakehand') is True:
                        if self.cpu_reset is True:
                            self.error_code_print('0003')
                            return (
                             False, self.flash_burn_retry)
                        load_bin_pass = True
                        time.sleep(4.5)
                    if ret is False:
                        if load_bin_pass == False:
                            self.error_code_print('0003')
                            return (
                             False, self.flash_burn_retry)
                    if self.ram_load:
                        return (True, self.flash_burn_retry)
                else:
                    if self.load_function == 2:
                        load_bin_pass = False
                        printf('Bootrom load')
                        ret, self.bootinfo, res = self.get_boot_info()
                        if res == 'shake hand fail':
                            self.error_code_print('0050')
                        if res.startswith('repeat_burn') is True:
                            self.error_code_print('000A')
                            return (
                             'repeat_burn', self.flash_burn_retry)
                        if res.startswith('error_shakehand') is True:
                            if self.cpu_reset is True:
                                self.error_code_print('0003')
                                return (
                                 False, self.flash_burn_retry)
                            load_bin_pass = True
                            time.sleep(4.5)
                        if ret is False:
                            if load_bin_pass == False:
                                self.error_code_print('0050')
                                return (
                                 False, self.flash_burn_retry)
                        self._need_shake_hand = False
                        clock_para = bytearray(0)
                        if self.cfg.has_option('LOAD_CFG', 'clock_para'):
                            clock_para_str = self.cfg.get('LOAD_CFG', 'clock_para')
                            if clock_para_str != '':
                                clock_para_file = os.path.join(app_path, clock_para_str)
                                printf('clock para file: ', clock_para_file)
                                clock_para = self.clock_para_update(clock_para_file)
                        printf('change bdrate: ', self.speed)
                        ret = self.clock_pll_set(self._need_shake_hand, True, clock_para)
                        if ret is False:
                            printf('pll set fail!!')
                            return (
                             False, self.flash_burn_retry)
            return (True, 'continue')
        except Exception as e:
            try:
                printf(e)
                self.error_code_print('0003')
                return (
                 False, self.flash_burn_retry)
            finally:
                e = None
                del e

    def third_run_step_read_mac_address(self):
        """
        Third step: read mac address.
        """
        time.sleep(0.1)
        if self.isp_mode_sign is True:
            if self.cpu_reset is True:
                self.set_clear_boot_status(self._need_shake_hand)
        if self.cfg.has_option('LOAD_CFG', 'check_mac'):
            self.macaddr_check = self.cfg.get('LOAD_CFG', 'check_mac') == 'true'
        if self.macaddr_check:
            if self.isp_mode_sign is False:
                ret, self._mac_addr = self.efuse_read_mac_addr_process()
                if ret is False:
                    printf('read mac addr fail!!')
                    return (
                     False, self.flash_burn_retry)
                if self._mac_addr == self._macaddr_check:
                    self.error_code_print('000A')
                    return (
                     False, self.flash_burn_retry)
                self._need_shake_hand = False
                self._macaddr_check_status = True
        if self.macaddr_callback is not None:
            ret, self._efuse_data, self._efuse_mask_data, macaddr = self.macaddr_callback(binascii.hexlify(self._mac_addr).decode('utf-8'))
            if ret is False:
                return (False, self.flash_burn_retry)
            if self._efuse_data != bytearray(0) and self._efuse_mask_data != bytearray(0) or macaddr != '':
                self.args.efuse = True
        if self.callback:
            self.callback(0, 100, 'running', 'blue')
        return (True, 'continue')

    def fourth_run_step_interact_chip(self):
        """
        Fourth step: Interact with chip, read chip ID and update flash parameter.
        """
        if self.args.flash:
            flash_pin = 0
            flash_clock_cfg = 0
            flash_io_mode = 0
            flash_clk_delay = 0
            if self.cfg.has_option('FLASH_CFG', 'decompress_write'):
                self.decompress_write = self.cfg.get('FLASH_CFG', 'decompress_write') == 'true'
            self.set_decompress_write()
            printf('flash set para')
            if self.cfg.get('FLASH_CFG', 'flash_pin'):
                flash_pin_cfg = self.cfg.get('FLASH_CFG', 'flash_pin')
                if flash_pin_cfg.startswith('0x'):
                    flash_pin = int(flash_pin_cfg, 16)
                else:
                    flash_pin = int(flash_pin_cfg, 10)
                if flash_pin == 128:
                    flash_pin = self.get_flash_pin_from_bootinfo(self.chip_type, self.bootinfo)
                    printf('get flash pin cfg from bootinfo: 0x%02X' % flash_pin)
            else:
                flash_pin = self.get_flash_pin()
            if self.cfg.has_option('FLASH_CFG', 'flash_clock_cfg'):
                clock_div_cfg = self.cfg.get('FLASH_CFG', 'flash_clock_cfg')
                if clock_div_cfg.startswith('0x'):
                    flash_clock_cfg = int(clock_div_cfg, 16)
                else:
                    flash_clock_cfg = int(clock_div_cfg, 10)
            if self.cfg.has_option('FLASH_CFG', 'flash_io_mode'):
                io_mode_cfg = self.cfg.get('FLASH_CFG', 'flash_io_mode')
                if io_mode_cfg.startswith('0x'):
                    flash_io_mode = int(io_mode_cfg, 16)
                else:
                    flash_io_mode = int(io_mode_cfg, 10)
            if self.cfg.has_option('FLASH_CFG', 'flash_clock_delay'):
                clk_delay_cfg = self.cfg.get('FLASH_CFG', 'flash_clock_delay')
                if clk_delay_cfg.startswith('0x'):
                    flash_clk_delay = int(clk_delay_cfg, 16)
                else:
                    flash_clk_delay = int(clk_delay_cfg, 10)
            self.flash_set = (flash_pin << 0) + (flash_clock_cfg << 8) + (flash_io_mode << 16) + (flash_clk_delay << 24)
            if self.flash_set != 66047 or self.load_function == 2:
                printf('set flash cfg: %X' % self.flash_set)
                ret = self.flash_set_para_main_process(self.flash_set, bytearray(0))
                self._need_shake_hand = False
                if ret is False:
                    return (False, self.flash_burn_retry)
            ret, data = self.flash_read_jedec_id_process()
            if ret:
                self._need_shake_hand = False
                data = binascii.hexlify(data).decode('utf-8')
                self.id_valid_flag = data[6:]
                read_id = data[0:6]
                self.read_flash_id = read_id
                if self.cfg.has_option('FLASH_CFG', 'flash_para'):
                    flash_para_file = os.path.join(app_path, self.cfg.get('FLASH_CFG', 'flash_para'))
                    self.flash_para_update(flash_para_file, read_id)
                if self.id_valid_flag != '80':
                    if not self.show_identify_fail():
                        return (False, self.flash_burn_retry)
                if self.is_conf_exist(self.read_flash_id) is False:
                    self.error_code_print('003D')
                    return (
                     False, self.flash_burn_retry)
            else:
                self.error_code_print('0030')
                return (
                 False, self.flash_burn_retry)
            result, content = self.run_flash2()
            return (
             result, content)
        return (True, 'continue')

    def fifth_run_step_write_flash_and_check(self):
        """
        Fifth step: write flash and check.
        """
        if self.args.none:
            return (True, self.flash_burn_retry)
        if self.args.write:
            if not self.args.flash:
                if not self.args.efuse:
                    printf('No target select')
                    return (
                     False, self.flash_burn_retry)
            printf('Program operation')
            if self.args.flash:
                flash_para_file = ''
                flash2_para_file = ''
                if self.cfg.has_option('FLASH_CFG', 'flash_para'):
                    flash_para_file = os.path.join(app_path, self.cfg.get('FLASH_CFG', 'flash_para'))
                if self.cfg.has_option('FLASH2_CFG', 'flash2_para'):
                    flash2_para_file = os.path.join(app_path, self.cfg.get('FLASH2_CFG', 'flash2_para'))
                address = self.address_list
                flash_file = self.flash_file_list
                if self.erase == 2:
                    ret = self.flash_chiperase_main_process()
                    if ret is False:
                        return (False, self.flash_burn_retry)
                    self._need_shake_hand = False
                    self.erase = 0
                if len(flash_file) > 0:
                    size_before = 0
                    size_all = 0
                    i = 0
                    for item in flash_file:
                        if self.temp_task_num != None:
                            size_all += os.path.getsize(os.path.join(app_path, convert_path('task' + str(self.temp_task_num) + '/' + item)))
                        else:
                            size_all += os.path.getsize(os.path.join(app_path, convert_path(item)))

                    try:
                        ret = False
                        while i < len(flash_file):
                            if self.temp_task_num != None:
                                flash_file[i] = 'task' + str(self.temp_task_num) + '/' + flash_file[i]
                                size_current = os.path.getsize(os.path.join(app_path, convert_path(flash_file[i])))
                            else:
                                size_current = os.path.getsize(os.path.join(app_path, convert_path(flash_file[i])))
                            if self.callback:
                                self.callback(size_before, size_all, 'program1')
                            else:
                                if self.callback:
                                    self.callback(size_current, size_all, 'program2')
                                printf('Dealing Index ', i)
                                if self.isp_mode_sign is True:
                                    printf('========= programming ', convert_path(flash_file[i]))
                                else:
                                    printf('========= programming ', convert_path(flash_file[i]), ' to 0x', address[i])
                                flash1_bin = ''
                                flash1_bin_len = 0
                                flash2_bin = ''
                                flash2_bin_len = 0
                                flash1_bin, flash1_bin_len, flash2_bin, flash2_bin_len = self.get_flash1_and_flash2(flash_file, address, size_current, i)
                                if flash1_bin != '' and flash2_bin != '':
                                    ret = self.flash_cfg_option(self.read_flash_id, flash_para_file, self.flash_set, self.id_valid_flag, flash1_bin, self.config_file, self.cfg, self.create_img_callback, self.create_simple_callback)
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                    printf('========= programming ', convert_path(flash1_bin), ' to 0x', address[i])
                                    ret = self.flash_load_specified(convert_path(flash1_bin), int(address[i], 16), self.callback)
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                    ret = self.flash_switch_bank_process(1)
                                    self._need_shake_hand = False
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                    ret = self.flash_cfg_option(self.read_flash2_id, flash2_para_file, self.flash2_set, self.id2_valid_flag, flash_file[i], self.config_file, self.cfg, self.create_img_callback, self.create_simple_callback)
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                    printf('========= programming ', convert_path(flash2_bin), ' to 0x%08X' % (int(address[i], 16) + flash1_bin_len))
                                    ret = self.flash_load_specified(convert_path(flash2_bin), int(address[i], 16) + flash1_bin_len, self.callback)
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                else:
                                    if not (self._flash2_en is False or self._flash2_select) is False or int(address[i], 16) < self._flash1_size:
                                        ret = self.flash_cfg_option(self.read_flash_id, flash_para_file, self.flash_set, self.id_valid_flag, flash_file[i], self.config_file, self.cfg, self.create_img_callback, self.create_simple_callback)
                                        if ret is False:
                                            return (False, self.flash_burn_retry)
                                    else:
                                        if self._flash2_select is False:
                                            if int(address[i], 16) >= self._flash1_size:
                                                ret = self.flash_switch_bank_process(1)
                                                self._need_shake_hand = False
                                                if ret is False:
                                                    return (False, self.flash_burn_retry)
                                        ret = self.flash_cfg_option(self.read_flash2_id, flash2_para_file, self.flash2_set, self.id2_valid_flag, flash_file[i], self.config_file, self.cfg, self.create_img_callback, self.create_simple_callback)
                                        if ret is False:
                                            return (False, self.flash_burn_retry)
                                    if 'eflash_loader_cfg.ini' in flash_file[i]:
                                        print('11111')
                                    ret = self.flash_load_specified(convert_path(flash_file[i]), int(address[i], 16), self.callback)
                                    if ret is False:
                                        return (False, self.flash_burn_retry)
                                size_before += os.path.getsize(os.path.join(app_path, convert_path(flash_file[i])))
                                i += 1
                                if self.callback:
                                    self.callback(i, len(flash_file), 'program')
                                self._need_shake_hand = False

                        if self._flash2_select is True:
                            ret = self.flash_switch_bank_process(0)
                            self._need_shake_hand = False
                            if ret is False:
                                return (False, self.flash_burn_retry)
                        printf('Program Finished')
                    except Exception as e:
                        try:
                            printf(e)
                            traceback.print_exc(limit=(self.NUM_ERR), file=(sys.stdout))
                            return (
                             False, self.flash_burn_retry)
                        finally:
                            e = None
                            del e

                else:
                    printf('Warning: No input file to program to flash')
        return (True, 'continue')

    def sixth_run_step_write_efuse(self):
        """
        Sixth step: write efuse.
        """
        if self.args.efuse:
            try:
                if self.config['input_path']['efuse']:
                    efusefile = self.config['input_path']['efuse']
            except:
                efusefile = ''

            if efusefile:
                efuse_file = efusefile
                mask_file = efuse_file.replace('.bin', '_mask.bin')
            else:
                efuse_file = self.cfg.get('EFUSE_CFG', 'file')
                mask_file = self.cfg.get('EFUSE_CFG', 'maskfile')
            if self.temp_task_num != None:
                efuse_file = 'task' + str(self.temp_task_num) + '/' + efuse_file
            efuse_load = True
            efuse_verify = 0
            if self.cfg.has_option('EFUSE_CFG', 'burn_en'):
                efuse_load = self.cfg.get('EFUSE_CFG', 'burn_en') == 'true'
            if self.cfg.has_option('EFUSE_CFG', 'factory_mode'):
                if self.cfg.get('EFUSE_CFG', 'factory_mode') == 'true':
                    efuse_verify = 1
            security_write = self.cfg.get('EFUSE_CFG', 'security_write') == 'true'
            if efuse_load and self.isp_mode_sign is False:
                ret = self.efuse_load_specified(efuse_file, mask_file, bytearray(0), bytearray(0), efuse_verify, security_write)
                if self.callback:
                    self.callback(1, 1, 'APP_WR')
                if ret is False:
                    return (False, self.flash_burn_retry)
            else:
                printf('efuse load disalbe')
            self._need_shake_hand = False
        return (True, 'continue')

    def seventh_run_step_erase(self):
        """
        Seventh step: erase.
        """
        if self.args.erase:
            printf('Erase flash operation')
            if self.end == '0':
                ret = self.flash_chiperase_main_process()
                if ret is False:
                    return (False, self.flash_burn_retry)
            else:
                ret = self.flash_erase_main_process(int(self.start, 16), int(self.end, 16), self._need_shake_hand)
                if ret is False:
                    return (False, self.flash_burn_retry)
            printf('Erase flash OK')
        return (True, 'continue')

    def eighth_run_step_read(self):
        """
        Eighth step: read.
        """
        if self.args.read:
            printf('Read operation')
            if not self.args.flash:
                if not self.args.efuse:
                    printf('No target select')
                    return (
                     False, self.flash_burn_retry)
            if not (self.args.flash and self.start and self.end):
                self.flash_read_jedec_id_process(self.callback)
            else:
                start_addr = int(self.start, 16)
                end_addr = int(self.end, 16)
                ret, readdata = self.flash_read_main_process(start_addr, end_addr - start_addr + 1, self._need_shake_hand, self.file, self.callback)
                if ret is False:
                    return (False, self.flash_burn_retry)
            if self.args.efuse:
                start_addr = int(self.start, 16)
                end_addr = int(self.end, 16)
                if self.efuse_read_main_process(start_addr, end_addr - start_addr + 1, self._need_shake_hand, self.file) is False:
                    return (False, self.flash_burn_retry)
        return (True, 'continue')

    def ninth_run_step_end(self):
        """
        Ninth step: run end.
        """
        self.run_reset_cpu()
        if self.macaddr_check is True:
            self._bootinfo = self.bootinfo
        self._macaddr_check = self._mac_addr
        self._macaddr_check_status = False
        return (
         True, self.flash_burn_retry)

    def set_clear_boot_status(self, shakehand=0):
        pass

    def set_boot_speed(self):
        pass

    def set_load_function(self):
        self.load_function = 2

    def set_decompress_write(self):
        pass

    def get_flash_pin(self):
        return 0

    def show_identify_fail(self):
        return True

    def run_flash2(self):
        return (True, 'continue')

    def get_flash1_and_flash2(self, flash_file, address, size_current, i):
        return ('', 0, '', 0)

    def run_reset_cpu(self):
        pass

    def get_mac_len(self):
        return 6

    def get_isp_sh_time(self):
        return 0

    def write_flash_data(self, file, start_addr, callback):
        pass

    def clear_boot_status(self, shakehand=0):
        printf('Clear boot status at hbn rsvd register')
        if shakehand != 0:
            printf(FLASH_ERASE_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return False
        data = bytearray(12)
        data[0] = 80
        data[1] = 0
        data[2] = 8
        data[3] = 0
        data[4] = 8
        data[5] = 241
        data[6] = 0
        data[7] = 32
        data[8] = 0
        data[9] = 0
        data[10] = 0
        data[11] = 0
        self.bflb_serial_object.write(data)
        self.bflb_serial_object.deal_ack(dmy_data=False)
        return True

    def set_config_file(self, bootheaderFile, imgCreateFile):
        self._efuse_bootheader_file = bootheaderFile
        self._img_create_file = imgCreateFile

    def load_eflash_loader_bin(self):
        """
        This function is used to load eflash loader bin file.
        """
        printf('========= load eflash_loader.bin =========')
        bootinfo = None
        if self.interface == 'jlink':
            printf('Load eflash_loader.bin via jlink')
            self.bflb_serial_object.if_init(self.device, self.speed, self.chip_type, self.chip_name)
            self.bflb_serial_object.reset_cpu()
            imge_fp = open_file(self.eflash_loader_file, 'rb')
            fw_data = bytearray(imge_fp.read())[192:] + bytearray(0)
            imge_fp.close()
            sub_module = __import__(('libs.base.' + self.chip_type), fromlist=[self.chip_type])
            load_addr = sub_module.jlink_load_cfg.jlink_load_addr
            self.bflb_serial_object.if_raw_write(load_addr, fw_data)
            pc = fw_data[4:8]
            pc = bytes([pc[3], pc[2], pc[1], pc[0]])
            msp = fw_data[0:4]
            msp = bytes([msp[3], msp[2], msp[1], msp[0]])
            self.bflb_serial_object.set_pc_msp(binascii.hexlify(pc), binascii.hexlify(msp).decode('utf-8'))
            time.sleep(0.01)
            self.bflb_serial_object.if_close()
            return (
             True, bootinfo, '')
        if self.interface == 'openocd':
            printf('Load eflash_loader.bin via openocd')
            self.bflb_serial_object.if_init(self.device, self._bflb_sn_device, self.speed, self.chip_type, self.chip_name)
            self.bflb_serial_object.halt_cpu()
            imge_fp = open_file(self.eflash_loader_file, 'rb')
            fw_data = bytearray(imge_fp.read())[192:] + bytearray(0)
            imge_fp.close()
            sub_module = __import__(('libs.base.' + self.chip_type), fromlist=[self.chip_type])
            load_addr = sub_module.openocd_load_cfg.openocd_load_addr
            self.bflb_serial_object.if_raw_write(load_addr, fw_data)
            pc = fw_data[4:8]
            pc = bytes([pc[3], pc[2], pc[1], pc[0]])
            msp = fw_data[0:4]
            msp = bytes([msp[3], msp[2], msp[1], msp[0]])
            self.bflb_serial_object.set_pc_msp(binascii.hexlify(pc), binascii.hexlify(msp).decode('utf-8'))
            return (
             True, bootinfo, '')
        if self.interface == 'cklink':
            printf('Load eflash_loader.bin via cklink')
            self.bflb_serial_object.if_init(self.device, self._bflb_sn_device, self.speed, self.chip_type, self.chip_name)
            self.bflb_serial_object.halt_cpu()
            imge_fp = open_file(self.eflash_loader_file, 'rb')
            fw_data = bytearray(imge_fp.read())[192:] + bytearray(0)
            imge_fp.close()
            sub_module = __import__(('libs.base.' + self.chip_type), fromlist=[self.chip_type])
            load_addr = sub_module.openocd_load_cfg.openocd_load_addr
            self.bflb_serial_object.if_raw_write(load_addr, fw_data)
            pc = fw_data[4:8]
            pc = bytes([pc[3], pc[2], pc[1], pc[0]])
            msp = fw_data[0:4]
            msp = bytes([msp[3], msp[2], msp[1], msp[0]])
            self.bflb_serial_object.set_pc_msp(binascii.hexlify(pc), binascii.hexlify(msp).decode('utf-8'))
            self.bflb_serial_object.resume_cpu()
            return (
             True, bootinfo, '')
        if self.interface.lower() == 'uart' or self.interface == 'sdio':
            ret = True
            printf('Load eflash_loader.bin via %s' % self.interface)
            start_time = time.time() * 1000
            ret, bootinfo, res = self._bflb_com_img_loader.img_load_process(self.boot_speed, self.boot_speed, None, self.do_reset, self.reset_hold_time, self.shake_hand_delay, self.reset_revert, self.cutoff_time, self.shake_hand_retry, self.isp_mode_sign, self._isp_shakehand_timeout, True, bootinfo)
            printf('Load helper bin time cost(ms): ', time.time() * 1000 - start_time)
            return (
             ret, bootinfo, res)

    def set_temp_timeout(self):
        self.bflb_serial_object.set_timeout(self._erase_time_out / 1000)

    def get_new_bh_data(self, section, bh_data, fp):
        return b''

    def get_chip_id(self, bootinfo):
        chip_id = bootinfo[34:36] + bootinfo[32:34] + bootinfo[30:32] + bootinfo[28:30] + bootinfo[26:28] + bootinfo[24:26]
        return chip_id

    def get_flash_file_and_address(self):
        result = True
        temp_files = []
        temp_addrs = []
        temp_dict = {}
        temp_set_addrs = []
        for key, value_dict in self.config.items():
            if isinstance(value_dict, dict):
                if 'addr' in value_dict:
                    if value_dict['addr'] in temp_set_addrs:
                        printf('Error: %s has duplicate addresse %s!' % (key, value_dict['addr']))
                        return (
                         False, temp_addrs, temp_files)
                    else:
                        temp_dict[value_dict['addr']] = value_dict['path']
                        temp_set_addrs.append(value_dict['addr'])

        if temp_dict:
            temp_list = sorted((temp_dict.items()), key=(lambda x: int(x[0], 16)
), reverse=False)
            for i in range(len(temp_list)):
                temp_addrs.append(temp_list[i][0].replace('0x', ''))
                temp_files.append(temp_list[i][1])
                if i != 0:
                    temp_length = int(temp_list[i][0], 16) - int(temp_list[i - 1][0], 16)
                    file_length = os.path.getsize(temp_list[i - 1][1])
                    if temp_length < file_length:
                        result = False
                        printf('Error: path: %s  size: %s  range: %s' % (temp_list[i - 1][1], str(file_length), str(temp_length)))
                        printf('Error: The file size exceeds the address space size!')

        return (
         result, temp_addrs, temp_files)

    def get_boot_info(self):
        """
        This function is used to get boot information from chips. At the same time, it can get chip ID.
        """
        printf('========= get_boot_info =========')
        bootinfo = None
        if self.interface == 'uart':
            ret = True
            start_time = time.time() * 1000
            ret, bootinfo = self._bflb_com_img_loader.img_get_bootinfo(self.boot_speed, self.boot_speed, None, self.do_reset, self.reset_hold_time, self.shake_hand_delay, self.reset_revert, self.cutoff_time, self.shake_hand_retry, self.isp_mode_sign, self._isp_shakehand_timeout)
            bootinfo = bootinfo.decode('utf-8')
            chipid = ''
            chipid = self.get_chip_id(bootinfo)
            printf('========= ChipID: ', chipid, ' =========')
            printf('Get bootinfo time cost(ms): ', time.time() * 1000 - start_time)
            return (
             ret, bootinfo, 'OK')
        printf('interface not fit')
        return (
         False, bootinfo, '')

    def error_code_print(self, code):
        set_error_code(code, self.task_num)
        printf('{"ErrorCode": "' + code + '","ErrorMsg":"' + eflash_loader_error_code[code] + '"}')

    def clock_para_update(self, file):
        if os.path.isfile(file) is False:
            efuse_bootheader_path = os.path.join(chip_path, self.chip_name, 'efuse_bootheader')
            efuse_bh_cfg = efuse_bootheader_path + '/efuse_bootheader_cfg.conf'
            sub_module = __import__(('libs.base.' + self.chip_type), fromlist=[self.chip_type])
            section = 'BOOTHEADER_GROUP0_CFG'
            fp = open(efuse_bh_cfg, 'r')
            data = fp.read()
            fp.close()
            if 'BOOTHEADER_CFG' in data:
                section = 'BOOTHEADER_CFG'
            else:
                if 'BOOTHEADER_CPU0_CFG' in data:
                    section = 'BOOTHEADER_CPU0_CFG'
                else:
                    if 'BOOTHEADER_GROUP0_CFG' in data:
                        section = 'BOOTHEADER_GROUP0_CFG'
            bh_data, tmp = bflb_efuse_boothd_create.update_data_from_cfg(sub_module.bootheader_cfg_keys.bootheader_cfg_keys, efuse_bh_cfg, section)
            bh_data = bflb_efuse_boothd_create.bootheader_update_flash_pll_crc(bh_data, self.chip_type)
            fp = open(file, 'wb+')
            self.get_new_bh_data(section, bh_data, fp)
            fp.close()
        fp = open_file(file, 'rb')
        clock_para = bytearray(fp.read())
        fp.close()
        return clock_para

    def clock_pll_set(self, shakehand, irq_en, clk_para):
        printf('Clock PLL set')
        if shakehand != 0:
            printf('clock set shake hand')
            if self.img_load_shake_hand() is False:
                return False
        start_time = time.time() * 1000
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('clk_set')['cmd_id'])
        irq_enable = bytearray(4)
        load_speed = bytearray(4)
        if irq_en:
            irq_enable = b'\x01\x00\x00\x00'
        load_speed = int_to_4bytearray_l(int(self.speed))
        data_send = irq_enable + load_speed + clk_para
        try_cnt = 0
        while True:
            ret, dmy = self.com_process_one_cmd('clk_set', cmd_id, data_send)
            if ret.startswith('OK'):
                break
            if try_cnt < self._checksum_err_retry_limit:
                printf('Retry')
                try_cnt += 1
            else:
                self.error_code_print('000C')
                return False

        printf('Set clock time cost(ms): ', time.time() * 1000 - start_time)
        self.bflb_serial_object.repeat_init(self.device, self.speed, self.chip_type, self.chip_name)
        self.bflb_serial_object.clear_buf()
        time.sleep(0.01)
        return True

    def efuse_read_mac_addr_process(self, callback=None):
        readdata = bytearray(0)
        macLen = self.get_mac_len()
        if self._need_shake_hand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('efuse_read_mac')['cmd_id'])
        printf('Read mac addr ')
        ret, data_read = self.com_process_one_cmd('efuse_read_mac', cmd_id, bytearray(0))
        if ret.startswith('OK') is False:
            self.error_code_print('0023')
            return (False, None)
        readdata += data_read
        crcarray = get_crc32_bytearray(readdata[:macLen])
        if crcarray != readdata[macLen:macLen + 4]:
            printf(binascii.hexlify(crcarray))
            printf(binascii.hexlify(readdata[macLen:macLen + 4]))
            self.error_code_print('0025')
            return (False, None)
        return (True, readdata[:macLen])

    def flash_set_para_main_process(self, flash_pin, flash_para):
        printf('Set flash config ')
        if flash_para != bytearray(0):
            if flash_para[13:14] == b'\xff':
                printf('Skip set flash para due to flash id is 0xFF')
                return True
        if self._need_shake_hand != 0:
            printf('Flash set para shake hand')
            if self.img_load_shake_hand() is False:
                return False
        start_time = time.time() * 1000
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_set_para')['cmd_id'])
        data_send = int_to_4bytearray_l(flash_pin) + flash_para
        try_cnt = 0
        while True:
            ret, dmy = self.com_process_one_cmd('flash_set_para', cmd_id, data_send)
            if ret.startswith('OK'):
                break
            if try_cnt < self._checksum_err_retry_limit:
                printf('Retry')
                try_cnt += 1
            else:
                self.error_code_print('003B')
                return False

        printf('Set para time cost(ms): ', time.time() * 1000 - start_time)
        return True

    def flash_read_jedec_id_process(self, callback=None):
        printf('========= flash read jedec ID =========')
        readdata = bytearray(0)
        if self._need_shake_hand is not False:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_read_jid')['cmd_id'])
        ret, data_read = self.com_process_one_cmd('flash_read_jid', cmd_id, bytearray(0))
        printf('Read flash jedec ID ')
        if ret.startswith('OK') is False:
            self.error_code_print('0030')
            return (False, None)
        readdata += data_read
        printf('readdata: ')
        printf(binascii.hexlify(readdata))
        printf('Finished')
        return (
         True, readdata[:4])

    def flash_para_update(self, file, jedec_id):
        flash_para = bytearray(0)
        if self.is_conf_exist(jedec_id) is True:
            sub_module = __import__(('libs.base.' + self.chip_type), fromlist=[self.chip_type])
            cfg_dir = app_path + '/utils/flash/' + self.chip_type + '/'
            conf_name = sub_module.flash_select_do.get_suitable_file_name(cfg_dir, jedec_id)
            offset, flashCfgLen, flash_para, flashCrcOffset, crcOffset = bflb_flash_select.update_flash_para_from_cfg(sub_module.bootheader_cfg_keys.bootheader_cfg_keys, cfg_dir + conf_name)
            fp = open(os.path.join(app_path, file), 'wb+')
            fp.write(flash_para)
            fp.close()
        return flash_para

    def is_conf_exist(self, flash_id):
        cfg_dir = app_path + '/utils/flash/' + self.chip_type + '/'
        conf_name = self.get_suitable_conf_name(cfg_dir, flash_id)
        if os.path.isfile(cfg_dir + conf_name) is False:
            printf('ERROR: Could not find flash configuration for chip')
            printf('File must be at: %s' % cfg_dir + conf_name)
            return False
        return True

    def flash_chiperase_main_process(self):
        printf('Flash Chip Erase All')
        if self._need_shake_hand != 0:
            printf(FLASH_ERASE_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                printf('Shake hand fail')
                return False
        start_time = time.time() * 1000
        self.set_temp_timeout()
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_chiperase')['cmd_id'])
        try_cnt = 0
        while True:
            ret, dmy = self.com_process_one_cmd('flash_chiperase', cmd_id, bytearray(0))
            if ret.startswith('OK'):
                break
            else:
                if ret.startswith('PD'):
                    printf('erase pending')
                    while True:
                        ret = self.bflb_serial_object.deal_ack()
                        if ret.startswith('PD'):
                            printf('erase pending')
                        else:
                            self.bflb_serial_object.set_timeout(0.02)
                            self.bflb_serial_object.read(1000)
                            break
                        if time.time() * 1000 - start_time > self._erase_time_out:
                            printf('erase timeout')
                            break

                    if ret.startswith('OK'):
                        break
                    if try_cnt < self._checksum_err_retry_limit:
                        printf('Retry')
                        try_cnt += 1
                    else:
                        printf('Erase Fail')
                        self.bflb_serial_object.set_timeout(self._default_time_out)
                        self.error_code_print('0033')
                        return False

        printf('Chip erase time cost(ms): ', time.time() * 1000 - start_time)
        self.bflb_serial_object.set_timeout(self._default_time_out)
        return True

    def flash_cfg_option(self, read_flash_id, flash_para_file, flash_set, id_valid_flag, binfile, cfgfile, cfg, create_img_callback=None, create_simple_callback=None):
        ret = bflb_flash_select.flash_bootheader_config_check(self.chip_type, read_flash_id, convert_path(binfile), flash_para_file)
        if ret is False:
            printf('flashcfg not match first')
            if self.is_conf_exist(read_flash_id) is True:
                update_cfg(cfg, 'FLASH_CFG', 'flash_id', read_flash_id)
                if isinstance(cfgfile, BFConfigParser) == False:
                    cfg.write(cfgfile, 'w+')
                if create_img_callback is not None:
                    create_img_callback()
                else:
                    if create_simple_callback is not None:
                        create_simple_callback()
            else:
                self.error_code_print('003D')
                return False
            ret = bflb_flash_select.flash_bootheader_config_check(self.chip_name, read_flash_id, convert_path(binfile), flash_para_file)
            if ret is False:
                printf('flashcfg not match again')
                self.error_code_print('0040')
                return False
        if flash_para_file:
            if id_valid_flag != '80':
                printf('flash para file: ', flash_para_file)
                fp = open_file(flash_para_file, 'rb')
                flash_para = bytearray(fp.read())
                fp.close()
                ret = self.flash_set_para_main_process(flash_set, flash_para)
                self._need_shake_hand = False
                if ret is False:
                    return False

    def flash_switch_bank_process(self, bank):
        """When the chip has two flashes, switch the flashes according to bank."""
        printf('Flash Switch Bank')
        if self._need_shake_hand != 0:
            printf('Flash switch bank shake hand')
            if self.img_load_shake_hand() is False:
                printf('Shake hand fail')
                return False
        start_time = time.time() * 1000
        self.bflb_serial_object.set_timeout(self._erase_time_out / 1000)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_switch_bank')['cmd_id'])
        data_send = int_to_4bytearray_l(bank)
        ret, dmy = self.com_process_one_cmd('flash_switch_bank', cmd_id, data_send)
        if ret.startswith('OK') is False:
            printf('Switch Fail')
            self.bflb_serial_object.set_timeout(self._default_time_out)
            self.error_code_print('0042')
            return False
        printf('Switch bank time cost(ms): ', time.time() * 1000 - start_time)
        self.bflb_serial_object.set_timeout(self._default_time_out)
        if bank == 0:
            self._flash2_select = False
        else:
            self._flash2_select = True
        return True

    def flash_load_opt(self, file, start_addr, callback=None):
        printf('========= flash load =========')
        if self._need_shake_hand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return False
        if self._flash2_select is True:
            start_addr -= self._flash1_size
        self.write_flash_data(file, start_addr, callback)
        ret = self.flash_load_main_process(file, start_addr, callback)
        if ret is False:
            printf('Flash load fail')
            return ret
        fw_sha256 = ''
        fp = open_file(file, 'rb')
        flash_data = fp.read()
        fp.close()
        flash_data_len = len(flash_data)
        if flash_data_len > 2097152:
            self.bflb_serial_object.set_timeout(2.0 * (flash_data_len / 2097152 + 1))
        sh = hashlib.sha256()
        sh.update(flash_data)
        fw_sha256 = sh.hexdigest()
        fw_sha256 = hexstr_to_bytearray(fw_sha256)
        printf('Sha caled by host: ', binascii.hexlify(fw_sha256).decode('utf-8'))
        del sh
        printf('xip mode Verify')
        ret, read_data = self.flash_xip_read_sha_main_process(start_addr, flash_data_len, 0, None, callback)
        try:
            printf('Sha caled by dev: ', binascii.hexlify(read_data).decode('utf-8'))
        except:
            printf('Sha caled by dev: ', binascii.hexlify(read_data))

        if ret is True and read_data == fw_sha256:
            printf('Verify success')
        else:
            printf('Verify fail')
            self.flash_load_tips()
            self.error_code_print('003E')
            ret = False
        if self.verify > 0:
            fp = open_file(file, 'rb')
            flash_data = bytearray(fp.read())
            fp.close()
            flash_data_len = len(flash_data)
            ret, read_data = self.flash_read_main_process(start_addr, flash_data_len, 0, None, callback)
            if ret is True and read_data == flash_data:
                printf('Verify success')
            else:
                printf('Verify fail')
                self.flash_load_tips()
                self.error_code_print('003E')
                ret = False
            printf('sbus mode Verify')
            ret, read_data = self.flash_read_sha_main_process(start_addr, flash_data_len, 0, None, callback)
            printf('Sha caled by dev: ', binascii.hexlify(read_data).decode('utf-8'))
            if ret is True and read_data == fw_sha256:
                printf('Verify success')
            else:
                printf('Verify fail')
                self.flash_load_tips()
                self.error_code_print('003E')
                ret = False
        self.bflb_serial_object.set_timeout(self._default_time_out)
        return ret

    def flash_load_specified(self, file, start_addr, callback=None):
        ret = False
        run_state = 0
        temp_start_addr = start_addr
        if len(self._skip_len) > 0 and self._skip_len[0] > 0:
            fp = open_file(file, 'rb')
            flash_data = fp.read()
            fp.close()
            flash_data_len = len(flash_data)
            if self._skip_addr[0] > temp_start_addr + flash_data_len or self._skip_addr[-1] + self._skip_len[-1] < temp_start_addr:
                ret = self.flash_load_opt(file, start_addr, callback)
                return ret
            for i in range(len(self._skip_addr)):
                if self._skip_addr[i] <= start_addr:
                    if self._skip_addr[i] + self._skip_len[i] > start_addr and self._skip_addr[i] + self._skip_len[i] < temp_start_addr + flash_data_len:
                        addr = self._skip_addr[i] + self._skip_len[i]
                        start_addr = self._skip_addr[i] + self._skip_len[i]
                    else:
                        if self._skip_addr[i] > start_addr and self._skip_addr[i] + self._skip_len[i] < temp_start_addr + flash_data_len:
                            printf('skip flash file, skip addr 0x%08X, skip len 0x%08X' % (
                             self._skip_addr[i], self._skip_len[i]))
                            addr = start_addr
                            data = flash_data[start_addr - temp_start_addr:self._skip_addr[i] - temp_start_addr]
                            filename, ext = os.path.splitext(file)
                            file_temp = os.path.join(app_path, filename + '_skip' + str(i) + ext)
                            fp = open(file_temp, 'wb')
                            fp.write(data)
                            fp.close()
                            ret = self.flash_load_opt(file_temp, addr, callback)
                            start_addr = self._skip_addr[i] + self._skip_len[i]
                        else:
                            if self._skip_addr[i] > start_addr:
                                if self._skip_addr[i] < temp_start_addr + flash_data_len and self._skip_addr[i] + self._skip_len[i] >= temp_start_addr + flash_data_len:
                                    printf('skip flash file, skip addr 0x%08X, skip len 0x%08X' % (
                                     self._skip_addr[i], self._skip_len[i]))
                                    addr = start_addr
                                    data = flash_data[start_addr - temp_start_addr:self._skip_addr[i] - temp_start_addr]
                                    filename, ext = os.path.splitext(file)
                                    file_temp = os.path.join(app_path, filename + '_skip' + str(i) + ext)
                                    fp = open(file_temp, 'wb')
                                    fp.write(data)
                                    fp.close()
                                    ret = self.flash_load_opt(file_temp, addr, callback)
                                    start_addr = temp_start_addr + flash_data_len
                                else:
                                    if self._skip_addr[i] <= start_addr:
                                        if self._skip_addr[i] + self._skip_len[i] >= temp_start_addr + flash_data_len:
                                            printf('skip flash file, skip addr 0x%08X, skip len 0x%08X' % (
                                             self._skip_addr[i], self._skip_len[i]))
                                            start_addr = temp_start_addr + flash_data_len
                                            return True

            if start_addr < temp_start_addr + flash_data_len:
                addr = start_addr
                data = flash_data[start_addr - temp_start_addr:]
                filename, ext = os.path.splitext(file)
                file_temp = os.path.join(app_path, filename + '_skip' + str(i + 1) + ext)
                fp = open(file_temp, 'wb')
                fp.write(data)
                fp.close()
                ret = self.flash_load_opt(file_temp, addr, callback)
        else:
            ret = self.flash_load_opt(file, start_addr, callback)
        return ret

    def flash_load_main_process(self, file, start_addr, callback=None):
        fp = open_file(file, 'rb')
        flash_data = bytearray(fp.read())
        fp.close()
        flash_data_len = len(flash_data)
        i = 0
        cur_len = 0
        if self.erase == 1:
            ret = self.flash_erase_main_process(start_addr, start_addr + flash_data_len - 1)
            if ret is False:
                return False
        start_time = time.time() * 1000
        log = ''
        if self.decompress_write and flash_data_len > 4096:
            self.bflb_serial_object.set_timeout(30.0)
            start_addr |= 2147483648
            cmd_name = 'flash_decompress_write'
            ret, flash_data, flash_data_len = self.flash_load_xz_compress(file)
            if ret is False:
                printf('Flash write data xz fail')
                self.bflb_serial_object.set_timeout(self._default_time_out)
                return False
            if time.time() * 1000 - start_time > 2200:
                printf(FLASH_LOAD_SHAKE_HAND)
                if self.img_load_shake_hand() is False:
                    return False
            else:
                if time.time() * 1000 - start_time > 1800:
                    time.sleep(0.5)
                    printf(FLASH_LOAD_SHAKE_HAND)
                    if self.img_load_shake_hand() is False:
                        return False
            printf('decompress flash load ', flash_data_len)
        else:
            cmd_name = 'flash_write'
        while i < flash_data_len:
            cur_len = flash_data_len - i
            if cur_len > self._bflb_com_tx_size - 8:
                cur_len = self._bflb_com_tx_size - 8
            cmd_id = hexstr_to_bytearray(self._com_cmds.get(cmd_name)['cmd_id'])
            data_send = int_to_4bytearray_l(i + start_addr) + flash_data[i:i + cur_len]
            start_addr &= 2147483647
            try_cnt = 0
            while True:
                ret, dmy = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
                if ret.startswith('OK'):
                    break
                if try_cnt < self._checksum_err_retry_limit:
                    printf('Retry')
                    try_cnt += 1
                else:
                    self.error_code_print('0036')
                    self.bflb_serial_object.set_timeout(self._default_time_out)
                    return False

            i += cur_len
            log = 'Load ' + str(i) + '/' + str(flash_data_len) + ' {"progress":' + str(i * 100 // flash_data_len) + '}'
            printf(log)
            if callback is not None:
                if flash_data_len > 200:
                    callback(i, flash_data_len, 'APP_WR')

        printf(log)
        if self.flash_write_check_main_process() is False:
            printf('Flash write check fail')
            self.bflb_serial_object.set_timeout(self._default_time_out)
            return False
        self.bflb_serial_object.set_timeout(self._default_time_out)
        printf('Flash load time cost(ms): ', time.time() * 1000 - start_time)
        printf('Finished')
        return True

    def flash_xip_read_sha_main_process(self, start_addr, flash_data_len, shakehand=0, file=None, callback=None):
        readdata = bytearray(0)
        if shakehand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_xip_read_start')['cmd_id'])
        ret, dmy = self.com_process_one_cmd('flash_xip_read_start', cmd_id, bytearray(0))
        if ret.startswith('OK') is False:
            self.error_code_print('0039')
            return (False, None)
        start_time = time.time() * 1000
        log = ''
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_xip_readSha')['cmd_id'])
        data_send = int_to_4bytearray_l(start_addr) + int_to_4bytearray_l(flash_data_len)
        try_cnt = 0
        while True:
            ret, data_read = self.com_process_one_cmd('flash_xip_readSha', cmd_id, data_send)
            if ret.startswith('OK'):
                break
            if try_cnt < self._checksum_err_retry_limit:
                printf('Retry')
                try_cnt += 1
            else:
                printf('Read Fail')
                cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_xip_read_finish')['cmd_id'])
                ret, dmy = self.com_process_one_cmd('flash_xip_read_finish', cmd_id, bytearray(0))
                if ret.startswith('OK') is False:
                    self.error_code_print('0039')
                    return (False, None)
                return (False, None)

        log += 'Read Sha256/' + str(flash_data_len)
        if callback is not None:
            callback(flash_data_len, flash_data_len, 'APP_VR')
        readdata += data_read
        printf(log)
        printf('Flash xip readsha time cost(ms): ', time.time() * 1000 - start_time)
        printf('Finished')
        if file is not None:
            fp = open_file(file, 'wb+')
            fp.write(readdata)
            fp.close()
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_xip_read_finish')['cmd_id'])
        ret, dmy = self.com_process_one_cmd('flash_xip_read_finish', cmd_id, bytearray(0))
        if ret.startswith('OK') is False:
            self.error_code_print('0039')
            return (False, None)
        return (True, readdata)

    def flash_read_sha_main_process(self, start_addr, flash_data_len, shakehand=0, file=None, callback=None):
        readdata = bytearray(0)
        if shakehand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        start_time = time.time() * 1000
        log = ''
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_readSha')['cmd_id'])
        data_send = int_to_4bytearray_l(start_addr) + int_to_4bytearray_l(flash_data_len)
        try_cnt = 0
        while True:
            ret, data_read = self.com_process_one_cmd('flash_readSha', cmd_id, data_send)
            if ret.startswith('OK'):
                break
            if try_cnt < self._checksum_err_retry_limit:
                printf('Retry')
                try_cnt += 1
            else:
                self.error_code_print('0038')
                return (False, None)

        log += 'Read Sha256/' + str(flash_data_len)
        if callback is not None:
            callback(flash_data_len, flash_data_len, 'APP_VR')
        readdata += data_read
        printf(log)
        printf('Flash readsha time cost(ms): ', time.time() * 1000 - start_time)
        printf('Finished')
        if file is not None:
            fp = open_file(file, 'wb+')
            fp.write(readdata)
            fp.close()
        return (True, readdata)

    def flash_load_xz_compress(self, file):
        try:
            xz_filters = [
             {'id':lzma.FILTER_LZMA2, 
              'dict_size':32768}]
            fp = open_file(file, 'rb')
            data = bytearray(fp.read())
            fp.close()
            flash_data = lzma.compress(data, check=(lzma.CHECK_CRC32), filters=xz_filters)
            flash_data_len = len(flash_data)
        except Exception as e:
            try:
                printf(e)
                return (False, None, None)
            finally:
                e = None
                del e

        return (
         True, flash_data, flash_data_len)

    def flash_load_tips(self):
        printf('########################################################################')
        printf('请按照以下描述排查问题：')
        printf('是否降低烧录波特率到500K测试过')
        printf('烧写文件的大小是否超过Flash所能存储的最大空间')
        printf('Flash是否被写保护')
        printf('########################################################################')

    def flash_erase_main_process(self, start_addr, end_addr, shakehand=0):
        printf('========= flash erase =========')
        printf('Erase flash  from ', hex(start_addr), ' to ', hex(end_addr))
        if shakehand != 0:
            printf(FLASH_ERASE_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                printf('Shake hand fail')
                return False
        start_time = time.time() * 1000
        self.set_temp_timeout()
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_erase')['cmd_id'])
        data_send = int_to_4bytearray_l(start_addr) + int_to_4bytearray_l(end_addr)
        try_cnt = 0
        while True:
            ret, dmy = self.com_process_one_cmd('flash_erase', cmd_id, data_send)
            if ret.startswith('OK'):
                break
            else:
                if ret.startswith('PD'):
                    printf('erase pending')
                    while True:
                        ret = self.bflb_serial_object.deal_ack()
                        if ret.startswith('PD'):
                            printf('erase pending')
                        else:
                            self.bflb_serial_object.set_timeout(0.02)
                            self.bflb_serial_object.read(1000)
                            break
                        if time.time() * 1000 - start_time > self._erase_time_out:
                            printf('erase timeout')
                            break

                    if ret.startswith('OK'):
                        break
                    if try_cnt < self._checksum_err_retry_limit:
                        printf('Retry')
                        try_cnt += 1
                    else:
                        printf('Erase Fail')
                        self.bflb_serial_object.set_timeout(self._default_time_out)
                        self.error_code_print('0034')
                        return False

        printf('Erase time cost(ms): ', time.time() * 1000 - start_time)
        self.bflb_serial_object.set_timeout(self._default_time_out)
        return True

    def flash_read_main_process(self, start_addr, flash_data_len, shakehand=0, file=None, callback=None):
        printf('========= flash read =========')
        i = 0
        cur_len = 0
        readdata = bytearray(0)
        if shakehand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        start_time = time.time() * 1000
        log = ''
        while i < flash_data_len:
            cur_len = flash_data_len - i
            if cur_len > self._bflb_com_tx_size - 8:
                cur_len = self._bflb_com_tx_size - 8
            else:
                cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_read')['cmd_id'])
                data_send = int_to_4bytearray_l(i + start_addr) + int_to_4bytearray_l(cur_len)
                try_cnt = 0
                while True:
                    ret, data_read = self.com_process_one_cmd('flash_read', cmd_id, data_send)
                    if ret.startswith('OK'):
                        break
                    if try_cnt < self._checksum_err_retry_limit:
                        printf('Retry')
                        try_cnt += 1
                    else:
                        self.error_code_print('0035')
                        return (False, None)

                i += cur_len
                log += 'Read ' + str(i) + '/' + str(flash_data_len)
                if len(log) > 50:
                    printf(log)
                    log = ''
                else:
                    log += '\n'
                if callback is not None:
                    callback(i, flash_data_len, 'APP_VR')
                readdata += data_read

        printf(log)
        printf('Flash read time cost(ms): ', time.time() * 1000 - start_time)
        printf('Finished')
        if file is not None:
            fp = open_file(file, 'wb+')
            fp.write(readdata)
            fp.close()
        return (True, readdata)

    def flash_write_check_main_process(self, shakehand=0):
        printf('Write check')
        if shakehand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return False
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_write_check')['cmd_id'])
        try_cnt = 0
        while True:
            retry = 0
            if self.decompress_write:
                retry = 10
            ret, dmy = self.com_process_one_cmd('flash_write_check', cmd_id, bytearray(0))
            if ret.startswith('OK'):
                break
            if try_cnt < self._checksum_err_retry_limit + retry:
                printf('Retry')
                try_cnt += 1
            else:
                self.error_code_print('0037')
                return False

        return True

    def efuse_load_specified(self, file, maskfile, efusedata, efusedatamask, verify=0, security_write=False):
        printf('========= efuse load =========')
        if self._need_shake_hand != 0:
            printf('Efuse load shake hand')
            ret = self.img_load_shake_hand()
            if ret is False:
                return False
        ret = self.efuse_load_main_process(file, maskfile, efusedata, efusedatamask, verify, security_write)
        return ret

    def efuse_load_main_process(self, file, maskfile, efusedata, efusedatamask, verify=0, security_write=False):
        if efusedata != bytearray(0):
            printf('Load data')
            efuse_data = efusedata
            mask_data = efusedatamask
        else:
            if file is not None:
                printf('Load file: ', file)
                fp = open_file(file, 'rb')
                efuse_data = bytearray(fp.read()) + bytearray(0)
                fp.close()
                if verify:
                    fp = open_file(maskfile, 'rb')
                    mask_data = bytearray(fp.read()) + bytearray(0)
                    fp.close()
                else:
                    mask_data = bytearray(0)
                if len(efuse_data) > 4096:
                    printf('Decrypt efuse data')
                    efuse_data = efuse_data[4096:]
                    security_key, security_iv = get_security_key()
                    efuse_data = aes_decrypt_data(efuse_data, security_key, security_iv, 0)
            else:
                efuse_data = self._efuse_data
                if verify:
                    mask_data = self._efuse_mask_data
                else:
                    mask_data = bytearray(0)
        if security_write:
            if self.get_ecdh_shared_key() is not True:
                return False
        printf('Load efuse 0')
        if security_write:
            cmd_name = 'efuse_security_write'
        else:
            cmd_name = 'efuse_write'
        cmd_id = hexstr_to_bytearray(self._com_cmds.get(cmd_name)['cmd_id'])
        data_send = efuse_data[0:124] + bytearray(4)
        if security_write:
            data_send = self.ecdh_encrypt_data(data_send)
        data_send = int_to_4bytearray_l(0) + data_send
        ret, dmy = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
        if ret.startswith('OK') is False:
            printf('Write Fail')
            self.error_code_print('0021')
            return False
        if verify >= 1:
            ret, read_data = self.efuse_read_main_process(0, 128, shakehand=0, file=None, security_read=security_write)
            if ret is True and self.efuse_compare(read_data, mask_data[0:124] + bytearray(4), efuse_data[0:124] + bytearray(4)):
                printf('Verify success')
            else:
                printf('Read: ')
                printf(binascii.hexlify(read_data[0:124]).decode('utf-8'))
                printf('Expected: ')
                printf(binascii.hexlify(efuse_data[0:124]).decode('utf-8'))
                printf('Verify fail')
                self.error_code_print('0022')
                return False
        data_send = bytearray(12) + efuse_data[124:128]
        if security_write:
            data_send = self.ecdh_encrypt_data(data_send)
        data_send = int_to_4bytearray_l(112) + data_send
        ret, dmy = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
        if ret.startswith('OK') is False:
            printf('Write Fail')
            self.error_code_print('0021')
            return False
        if verify >= 1:
            ret, read_data = self.efuse_read_main_process(112, 16, shakehand=0, file=None, security_read=security_write)
            if ret is True and self.efuse_compare(read_data, bytearray(12) + mask_data[124:128], bytearray(12) + efuse_data[124:128]):
                printf('Verify success')
            else:
                printf('Read: ')
                printf(binascii.hexlify(read_data[12:16]))
                printf('Expected: ')
                printf(binascii.hexlify(efuse_data[124:128]))
                printf('Verify fail')
                self.error_code_print('0022')
                return False
        if len(efuse_data) > 128:
            printf('Load efuse 1')
            if security_write:
                cmd_name = 'efuse_security_write'
            else:
                cmd_name = 'efuse_write'
            cmd_id = hexstr_to_bytearray(self._com_cmds.get(cmd_name)['cmd_id'])
            data_send = efuse_data[128:252] + bytearray(4)
            if security_write:
                data_send = self.ecdh_encrypt_data(data_send)
            data_send = int_to_4bytearray_l(128) + data_send
            ret, dmy = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
            if ret.startswith('OK') is False:
                printf('Write Fail')
                self.error_code_print('0021')
                return False
            if verify >= 1:
                ret, read_data = self.efuse_read_main_process(128, 128, shakehand=0, file=None, security_read=security_write)
                if ret is True and self.efuse_compare(read_data, mask_data[128:252] + bytearray(4), efuse_data[128:252] + bytearray(4)):
                    printf('Verify success')
                else:
                    printf('Verify fail')
                    self.error_code_print('0022')
                    return False
            data_send = bytearray(12) + efuse_data[252:256]
            if security_write:
                data_send = self.ecdh_encrypt_data(data_send)
            data_send = int_to_4bytearray_l(240) + data_send
            ret, dmy = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
            if ret.startswith('OK') is False:
                printf('Write Fail')
                self.error_code_print('0021')
                return False
            if verify >= 1:
                ret, read_data = self.efuse_read_main_process(240, 16, shakehand=0, file=None, security_read=security_write)
                if ret is True and self.efuse_compare(read_data, bytearray(12) + mask_data[252:256], bytearray(12) + efuse_data[252:256]):
                    printf('Verify success')
                else:
                    printf('Verify fail')
                    self.error_code_print('0022')
        printf('Finished')
        return True

    def efuse_read_main_process(self, start_addr, data_len, shakehand=0, file=None, security_read=False):
        readdata = bytearray(0)
        if shakehand != 0:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        if security_read:
            cmd_name = 'efuse_security_read'
        else:
            cmd_name = 'efuse_read'
        cmd_id = hexstr_to_bytearray(self._com_cmds.get(cmd_name)['cmd_id'])
        data_send = int_to_4bytearray_l(start_addr) + int_to_4bytearray_l(data_len)
        ret, data_read = self.com_process_one_cmd(cmd_name, cmd_id, data_send)
        printf('Read efuse ')
        if ret.startswith('OK') is False:
            self.error_code_print('0020')
            return (False, None)
        readdata += data_read
        if security_read:
            readdata = self.ecdh_decrypt_data(readdata)
        printf('Finished')
        if file is not None:
            fp = open_file(file, 'wb+')
            fp.write(readdata)
            fp.close()
        return (True, readdata)

    def efuse_compare(self, read_data, maskdata, write_data):
        i = 0
        for i in range(len(read_data)):
            compare_data = read_data[i] & maskdata[i]
            if compare_data & write_data[i] != write_data[i]:
                printf('compare fail: ', i)
                printf(read_data[i], write_data[i])
                return False

        return True

    def img_load_shake_hand(self):
        isp_sh_time = self.get_isp_sh_time()
        if self.interface.lower() == 'uart':
            self.bflb_serial_object.repeat_init(self.device, self.speed, self.chip_type, self.chip_name)
            if self._bflb_com_img_loader.toggle_boot_or_shake_hand(2, do_reset=False,
              reset_hold_time=100,
              shake_hand_delay=100,
              reset_revert=True,
              cutoff_time=0,
              isp_mode_sign=(self.isp_mode_sign),
              isp_timeout=isp_sh_time,
              boot_load=False,
              shake_hand_retry=2) != 'OK':
                self.error_code_print('0001')
                return False
        else:
            self.bflb_serial_object.if_init(self.device, self.speed, self.chip_type, self.chip_name)
            if self.bflb_serial_object.if_shakehand(do_reset=False, reset_hold_time=100,
              shake_hand_delay=100,
              reset_revert=True,
              cutoff_time=0,
              shake_hand_retry=2,
              isp_timeout=isp_sh_time,
              boot_load=False) != 'OK':
                self.error_code_print('0001')
                return False
        self._need_shake_hand = False
        return True

    def com_process_one_cmd(self, section, cmd_id, data_send):
        data_read = bytearray(0)
        data_len = int_to_2bytearray_l(len(data_send))
        checksum = 0
        checksum += bytearray_to_int(data_len[0:1]) + bytearray_to_int(data_len[1:2])
        for char in data_send:
            checksum += char

        data = cmd_id + int_to_2bytearray_l(checksum & 255)[0:1] + data_len + data_send
        if self.interface.lower() == 'uart':
            self.bflb_serial_object.write(data)
            if section in self._resp_cmds:
                res, data_read = self.bflb_serial_object.deal_response()
            else:
                res = self.bflb_serial_object.deal_ack()
        else:
            self.bflb_serial_object.if_write(data)
            if section in self._resp_cmds:
                res, data_read = self.bflb_serial_object.if_deal_response()
            else:
                res = self.bflb_serial_object.if_deal_ack()
        return (
         res, data_read)

    def get_suitable_conf_name(self, cfg_dir, flash_id):
        conf_files = []
        for home, dirs, files in os.walk(cfg_dir):
            for filename in files:
                if filename.split('_')[-1] == flash_id + '.conf':
                    conf_files.append(filename)

        if len(conf_files) > 1:
            printf('Flash id duplicate and alternative is:')
            for i in range(len(conf_files)):
                tmp = conf_files[i].split('.')[0]
                printf('%d:%s' % (i + 1, tmp))

            return conf_files[i]
        if len(conf_files) == 1:
            return conf_files[0]
        return ''

    def get_ecdh_shared_key(self, shakehand=0):
        printf('========= get ecdh shared key =========')
        publickey_file = 'utils/pem/publickey_uecc.pem'
        if shakehand != 0:
            printf('Shake hand')
            ret = self.img_load_shake_hand()
            if ret is False:
                return
        tmp_ecdh = bflb_ecdh.BflbEcdh()
        self._ecdh_public_key = tmp_ecdh.create_public_key()
        self._ecdh_private_key = binascii.hexlify(tmp_ecdh.ecdh.private_key.to_string()).decode('utf-8')
        printf('ecdh public key')
        printf(self._ecdh_public_key)
        printf('ecdh private key')
        printf(self._ecdh_private_key)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('ecdh_get_pk')['cmd_id'])
        data_send = bytearray.fromhex(self._ecdh_public_key)
        ret, data_read = self.com_process_one_cmd('ecdh_get_pk', cmd_id, data_send)
        if ret.startswith('OK') is True:
            self._ecdh_peer_public_key = binascii.hexlify(data_read).decode('utf-8')
            printf('ecdh peer key')
            printf(self._ecdh_peer_public_key)
            self._ecdh_shared_key = tmp_ecdh.create_shared_key(self._ecdh_peer_public_key[0:128])
            printf('ecdh shared key')
            printf(self._ecdh_shared_key)
            cmd_id = hexstr_to_bytearray(self._com_cmds.get('ecdh_chanllenge')['cmd_id'])
            data_send = bytearray(0)
            ret, data_read = self.com_process_one_cmd('ecdh_chanllenge', cmd_id, data_send)
            if ret.startswith('OK') is True:
                printf('challenge data')
                printf(binascii.hexlify(data_read).decode('utf-8'))
                encrypted_data = data_read[0:32]
                signature = data_read[32:96]
                signature_r = data_read[32:64]
                signature_s = data_read[64:96]
                vk = ecdsa.VerifyingKey.from_pem(open_file('utils\\pem\\room_root_publickey_ecc.pem').read())
                try:
                    ret = vk.verify(signature, (self.ecdh_decrypt_data(encrypted_data)),
                      hashfunc=(hashlib.sha256),
                      sigdecode=(ecdsa.util.sigdecode_string))
                except Exception as err:
                    try:
                        printf(err)
                    finally:
                        err = None
                        del err

                if ret is True:
                    return True
                printf('Challenge verify fail')
                return False
            else:
                printf('Challenge ack fail')
                return False
        else:
            printf('Get shared key fail')
            return False

    def ecdh_encrypt_data(self, data):
        cryptor = AES.new(bytearray.fromhex(self._ecdh_shared_key[0:32]), AES.MODE_CBC, bytearray(16))
        ciphertext = cryptor.encrypt(data)
        return ciphertext

    def ecdh_decrypt_data(self, data):
        cryptor = AES.new(bytearray.fromhex(self._ecdh_shared_key[0:32]), AES.MODE_CBC, bytearray(16))
        plaintext = cryptor.decrypt(data)
        return plaintext

    def close_serial(self):
        if self.bflb_serial_object:
            try:
                self.bflb_serial_object.close()
            except Exception as e:
                try:
                    printf(e)
                finally:
                    e = None
                    del e

    def clear_all_data(self):
        if self.bflb_serial_object:
            try:
                self.bflb_serial_object.clear_buf()
            except Exception as e:
                try:
                    printf(e)
                finally:
                    e = None
                    del e

    def base_reset_cpu(self):
        if self.bflb_serial_object:
            self.bflb_serial_object.reset_cpu()

    def object_status_clear(self):
        self.bootinfo = None
        self._macaddr_check = bytearray(0)
        self._macaddr_check_status = False

    def flash_read_status_reg_process(self, cmd, len, callback=None):
        printf('========= flash read status register =========')
        readdata = bytearray(0)
        if self._need_shake_hand is not False:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, None)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_read_status_reg')['cmd_id'])
        data_send = int_to_4bytearray_l(int(cmd, 16)) + int_to_4bytearray_l(len)
        ret, data_read = self.com_process_one_cmd('flash_read_status_reg', cmd_id, data_send)
        printf('Read flash status register ')
        if ret.startswith('OK') is False:
            self.error_code_print('0031')
            return (False, None)
        readdata += data_read
        printf('readdata: ')
        printf(binascii.hexlify(readdata))
        printf('Finished')
        return (
         True, readdata)

    def flash_write_status_reg_process(self, cmd, len, write_data, callback=None):
        printf('========= flash write status register =========')
        if self._need_shake_hand is not False:
            printf(FLASH_LOAD_SHAKE_HAND)
            if self.img_load_shake_hand() is False:
                return (False, 'Flash load shake hand fail')
        printf('write_data ', write_data)
        cmd_id = hexstr_to_bytearray(self._com_cmds.get('flash_write_status_reg')['cmd_id'])
        data_send = int_to_4bytearray_l(int(cmd, 16)) + int_to_4bytearray_l(len) + int_to_4bytearray_l(int(write_data, 16))
        ret, data_read = self.com_process_one_cmd('flash_write_status_reg', cmd_id, data_send)
        printf('Write flash status register ')
        if ret.startswith('OK') is False:
            self.error_code_print('0032')
            return (False, 'Write fail')
        printf('Finished')
        return (True, None)

    def bl_get_largest_addr(self, addrs, files):
        maxlen = 0
        datalen = 0
        for i in range(len(addrs)):
            if int(addrs[i], 16) > maxlen:
                maxlen = int(addrs[i], 16)
                if os.path.exists(files[i]):
                    datalen = os.path.getsize(files[i])
                else:
                    datalen = os.path.getsize(os.path.join(app_path, files[i]))

        return maxlen + datalen

    def bl_get_file_data(self, files):
        datas = []
        for file in files:
            if os.path.exists(file):
                temp_path = file
            else:
                temp_path = os.path.join(app_path, file)
            with open(temp_path, 'rb') as fp:
                data = fp.read()
            datas.append(data)

        return datas

    def bl_create_flash_default_data(self, length):
        datas = bytearray(length)
        for i in range(length):
            datas[i] = 255

        return datas

    def bl_write_flash_img(self, d_addrs, d_files, flash_size='1M'):
        whole_img_len = self.bl_get_largest_addr(d_addrs, d_files)
        whole_img_data = self.bl_create_flash_default_data(whole_img_len)
        whole_img_file = os.path.join(chip_path, self.chip_name, 'img_create', 'whole_flash_data.bin')
        if os.path.exists(whole_img_file):
            os.remove(whole_img_file)
        filedatas = self.bl_get_file_data(d_files)
        for i in range(len(d_addrs)):
            start_addr = int(d_addrs[i], 16)
            whole_img_data[start_addr:start_addr + len(filedatas[i])] = filedatas[i]

        if not os.path.exists(os.path.dirname(whole_img_file)):
            os.makedirs(os.path.dirname(whole_img_file))
        fp = open(whole_img_file, 'wb+')
        fp.write(whole_img_data)
        fp.close()

    def get_flash_pin_from_bootinfo(self, chiptype, bootinfo):
        return 128
# okay decompiling ./libs/base/bflb_base_eflash_loader.pyc