code starts up
This commit is contained in:
parent
bb81a685ed
commit
9cd262ed57
64 changed files with 12325 additions and 7154 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -3,3 +3,4 @@ bin/
|
|||
lib/
|
||||
lib64
|
||||
pyvenv.cfg
|
||||
log/
|
||||
|
|
|
|||
219
config.py
Normal file
219
config.py
Normal file
File diff suppressed because one or more lines are too long
|
|
@ -16,45 +16,45 @@ from .base import bflb_base_eflash_loader
|
|||
from .base import bflb_img_create
|
||||
from .base import bflb_serial
|
||||
from .base import bflb_img_loader
|
||||
from base.bl602 import flash_select_do
|
||||
from base.bl602 import bootheader_cfg_keys
|
||||
from base.bl602 import jlink_load_cfg
|
||||
from base.bl602 import cklink_load_cfg
|
||||
from base.bl602 import openocd_load_cfg
|
||||
from base.bl602 import img_create_do
|
||||
from base.bl702 import chiptype_patch
|
||||
from base.bl702 import flash_select_do
|
||||
from base.bl702 import bootheader_cfg_keys
|
||||
from base.bl702 import jlink_load_cfg
|
||||
from base.bl702 import cklink_load_cfg
|
||||
from base.bl702 import openocd_load_cfg
|
||||
from base.bl702 import img_create_do
|
||||
from base.bl808 import chiptype_patch
|
||||
from base.bl808 import flash_select_do
|
||||
from base.bl808 import bootheader_cfg_keys
|
||||
from base.bl808 import jlink_load_cfg
|
||||
from base.bl808 import cklink_load_cfg
|
||||
from base.bl808 import openocd_load_cfg
|
||||
from base.bl808 import img_create_do
|
||||
from base.bl616 import chiptype_patch
|
||||
from base.bl616 import flash_select_do
|
||||
from base.bl616 import bootheader_cfg_keys
|
||||
from base.bl616 import jlink_load_cfg
|
||||
from base.bl616 import cklink_load_cfg
|
||||
from base.bl616 import openocd_load_cfg
|
||||
from base.bl616 import img_create_do
|
||||
from base.wb03 import chiptype_patch
|
||||
from base.wb03 import flash_select_do
|
||||
from base.wb03 import bootheader_cfg_keys
|
||||
from base.wb03 import jlink_load_cfg
|
||||
from base.wb03 import cklink_load_cfg
|
||||
from base.wb03 import openocd_load_cfg
|
||||
from base.wb03 import img_create_do
|
||||
from base.bl702l import chiptype_patch
|
||||
from base.bl702l import flash_select_do
|
||||
from base.bl702l import bootheader_cfg_keys
|
||||
from base.bl702l import jlink_load_cfg
|
||||
from base.bl702l import cklink_load_cfg
|
||||
from base.bl702l import openocd_load_cfg
|
||||
from base.bl702l import img_create_do
|
||||
from .base.bl602 import flash_select_do
|
||||
from .base.bl602 import bootheader_cfg_keys
|
||||
from .base.bl602 import jlink_load_cfg
|
||||
from .base.bl602 import cklink_load_cfg
|
||||
from .base.bl602 import openocd_load_cfg
|
||||
from .base.bl602 import img_create_do
|
||||
from .base.bl702 import chiptype_patch
|
||||
from .base.bl702 import flash_select_do
|
||||
from .base.bl702 import bootheader_cfg_keys
|
||||
from .base.bl702 import jlink_load_cfg
|
||||
from .base.bl702 import cklink_load_cfg
|
||||
from .base.bl702 import openocd_load_cfg
|
||||
from .base.bl702 import img_create_do
|
||||
from .base.bl808 import chiptype_patch
|
||||
from .base.bl808 import flash_select_do
|
||||
from .base.bl808 import bootheader_cfg_keys
|
||||
from .base.bl808 import jlink_load_cfg
|
||||
from .base.bl808 import cklink_load_cfg
|
||||
from .base.bl808 import openocd_load_cfg
|
||||
from .base.bl808 import img_create_do
|
||||
from .base.bl616 import chiptype_patch
|
||||
from .base.bl616 import flash_select_do
|
||||
from .base.bl616 import bootheader_cfg_keys
|
||||
from .base.bl616 import jlink_load_cfg
|
||||
from .base.bl616 import cklink_load_cfg
|
||||
from .base.bl616 import openocd_load_cfg
|
||||
from .base.bl616 import img_create_do
|
||||
from .base.wb03 import chiptype_patch
|
||||
from .base.wb03 import flash_select_do
|
||||
from .base.wb03 import bootheader_cfg_keys
|
||||
from .base.wb03 import jlink_load_cfg
|
||||
from .base.wb03 import cklink_load_cfg
|
||||
from .base.wb03 import openocd_load_cfg
|
||||
from .base.wb03 import img_create_do
|
||||
from .base.bl702l import chiptype_patch
|
||||
from .base.bl702l import flash_select_do
|
||||
from .base.bl702l import bootheader_cfg_keys
|
||||
from .base.bl702l import jlink_load_cfg
|
||||
from .base.bl702l import cklink_load_cfg
|
||||
from .base.bl702l import openocd_load_cfg
|
||||
from .base.bl702l import img_create_do
|
||||
# okay decompiling ./libs/__init__.pyc
|
||||
|
|
|
|||
|
|
@ -1,7 +0,0 @@
|
|||
# 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: -
|
||||
pass
|
||||
# okay decompiling ./libs/base.pyc
|
||||
2205
libs/base/bflb_base_eflash_loader.py
Normal file
2205
libs/base/bflb_base_eflash_loader.py
Normal file
File diff suppressed because it is too large
Load diff
241
libs/base/bflb_efuse_boothd_create.py
Normal file
241
libs/base/bflb_efuse_boothd_create.py
Normal file
|
|
@ -0,0 +1,241 @@
|
|||
# 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_efuse_boothd_create.py
|
||||
import os, sys, shutil, traceback
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, chip_path, convert_path
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
|
||||
def bootheader_update_flash_pll_crc(bootheader_data, chiptype):
|
||||
flash_cfg_start = 8
|
||||
flash_cfg_len = 92
|
||||
if chiptype == 'wb03':
|
||||
flash_cfg_start += 208
|
||||
flash_cfg = bootheader_data[flash_cfg_start + 4:flash_cfg_start + flash_cfg_len - 4]
|
||||
crcarray = bflb_utils.get_crc32_bytearray(flash_cfg)
|
||||
bootheader_data[flash_cfg_start + flash_cfg_len - 4:flash_cfg_start + flash_cfg_len] = crcarray
|
||||
pll_cfg_start = flash_cfg_start + flash_cfg_len
|
||||
pll_cfg_len = 16
|
||||
if chiptype == 'bl808':
|
||||
pll_cfg_len = 28
|
||||
else:
|
||||
if chiptype == 'bl616' or chiptype == 'wb03':
|
||||
pll_cfg_len = 20
|
||||
pll_cfg = bootheader_data[pll_cfg_start + 4:pll_cfg_start + pll_cfg_len - 4]
|
||||
crcarray = bflb_utils.get_crc32_bytearray(pll_cfg)
|
||||
bootheader_data[pll_cfg_start + pll_cfg_len - 4:pll_cfg_start + pll_cfg_len] = crcarray
|
||||
return bootheader_data
|
||||
|
||||
|
||||
def get_int_mask(pos, length):
|
||||
ones = '11111111111111111111111111111111'
|
||||
zeros = '00000000000000000000000000000000'
|
||||
mask = ones[0:32 - pos - length] + zeros[0:length] + ones[0:pos]
|
||||
return int(mask, 2)
|
||||
|
||||
|
||||
def update_data_from_cfg(config_keys, config_file, section):
|
||||
bflb_utils.printf('Updating data according to <' + config_file + '[' + section + ']>')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
filelen = 0
|
||||
for key in config_keys:
|
||||
offset = int(config_keys.get(key)['offset'], 10)
|
||||
if offset > filelen:
|
||||
filelen = offset
|
||||
|
||||
filelen += 4
|
||||
bflb_utils.printf('Created file len:' + str(filelen))
|
||||
data = bytearray(filelen)
|
||||
data_mask = bytearray(filelen)
|
||||
for key in cfg.options(section):
|
||||
if config_keys.get(key) is None:
|
||||
bflb_utils.printf(key + ' not exist')
|
||||
continue
|
||||
else:
|
||||
val = cfg.get(section, key)
|
||||
if val.startswith('0x'):
|
||||
val = int(val, 16)
|
||||
else:
|
||||
val = int(val, 10)
|
||||
offset = int(config_keys.get(key)['offset'], 10)
|
||||
pos = int(config_keys.get(key)['pos'], 10)
|
||||
bitlen = int(config_keys.get(key)['bitlen'], 10)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
oldval_mask = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data_mask[offset:offset + 4]))
|
||||
newval = (oldval & get_int_mask(pos, bitlen)) + (val << pos)
|
||||
if val != 0:
|
||||
newval_mask = oldval_mask | ~get_int_mask(pos, bitlen)
|
||||
else:
|
||||
newval_mask = oldval_mask
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
data_mask[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval_mask)
|
||||
|
||||
return (data, data_mask)
|
||||
|
||||
|
||||
def bootheader_create_do(chipname, chiptype, config_file, section, output_file=None, if_img=False):
|
||||
efuse_bootheader_path = os.path.join(chip_path, chipname, 'efuse_bootheader')
|
||||
try:
|
||||
bflb_utils.printf('Create bootheader using ', config_file)
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
bh_data, tmp = update_data_from_cfg(sub_module.bootheader_cfg_keys.bootheader_cfg_keys, config_file, section)
|
||||
bh_data = bootheader_update_flash_pll_crc(bh_data, chiptype)
|
||||
if output_file is None:
|
||||
fp = open(efuse_bootheader_path + '/' + section.lower().replace('_cfg', '.bin'), 'wb+')
|
||||
else:
|
||||
fp = open(output_file, 'wb+')
|
||||
if section == 'BOOTHEADER_CFG':
|
||||
if chiptype == 'bl60x':
|
||||
final_data = bytearray(8192)
|
||||
bh_data[118] = bh_data[118] | 4
|
||||
final_data[0:176] = bh_data
|
||||
final_data[4096:4272] = bh_data
|
||||
final_data[4098] = 65
|
||||
final_data[117] = final_data[117] | 240
|
||||
final_data[4214] = final_data[4214] | 3
|
||||
bh_data = final_data
|
||||
if if_img is True:
|
||||
bh_data[8:12] = bytearray(4)
|
||||
bh_data[100:104] = bytearray(4)
|
||||
if chiptype == 'bl808':
|
||||
fp.write(bh_data[0:384])
|
||||
else:
|
||||
if chiptype == 'bl616':
|
||||
fp.write(bh_data[0:256])
|
||||
else:
|
||||
if chiptype == 'wb03':
|
||||
fp.write(bh_data[0:464])
|
||||
else:
|
||||
if chiptype == 'bl702l':
|
||||
fp.write(bh_data[0:240])
|
||||
else:
|
||||
fp.write(bh_data[0:176])
|
||||
else:
|
||||
fp.write(bh_data)
|
||||
fp.close()
|
||||
if chiptype == 'bl808':
|
||||
if section == 'BOOTHEADER_GROUP0_CFG':
|
||||
fp = open(efuse_bootheader_path + '/clock_para.bin', 'wb+')
|
||||
fp.write(bh_data[100:128])
|
||||
fp.close()
|
||||
fp = open(efuse_bootheader_path + '/flash_para.bin', 'wb+')
|
||||
fp.write(bh_data[12:96])
|
||||
fp.close()
|
||||
else:
|
||||
if chiptype == 'bl616':
|
||||
if section == 'BOOTHEADER_GROUP0_CFG':
|
||||
fp = open(efuse_bootheader_path + '/clock_para.bin', 'wb+')
|
||||
fp.write(bh_data[100:120])
|
||||
fp.close()
|
||||
fp = open(efuse_bootheader_path + '/flash_para.bin', 'wb+')
|
||||
fp.write(bh_data[12:96])
|
||||
fp.close()
|
||||
else:
|
||||
if chiptype == 'wb03':
|
||||
if section == 'BOOTHEADER_GROUP0_CFG':
|
||||
fp = open(efuse_bootheader_path + '/clock_para.bin', 'wb+')
|
||||
fp.write(bh_data[308:328])
|
||||
fp.close()
|
||||
fp = open(efuse_bootheader_path + '/flash_para.bin', 'wb+')
|
||||
fp.write(bh_data[220:304])
|
||||
fp.close()
|
||||
else:
|
||||
if chiptype == 'bl702l':
|
||||
if section == 'BOOTHEADER_CFG':
|
||||
fp = open(efuse_bootheader_path + '/clock_para.bin', 'wb+')
|
||||
fp.write(bh_data[100:116])
|
||||
fp.close()
|
||||
fp = open(efuse_bootheader_path + '/flash_para.bin', 'wb+')
|
||||
fp.write(bh_data[12:96])
|
||||
fp.close()
|
||||
else:
|
||||
fp = open(efuse_bootheader_path + '/flash_para.bin', 'wb+')
|
||||
fp.write(bh_data[12:96])
|
||||
fp.close()
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf('bootheader_create_do fail!!')
|
||||
bflb_utils.printf(e)
|
||||
traceback.print_exc(limit=5, file=(sys.stdout))
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
|
||||
def bootheader_create_process(chipname, chiptype, config_file, output_file1=None, output_file2=None, if_img=False):
|
||||
fp = open(config_file, 'r')
|
||||
data = fp.read()
|
||||
fp.close()
|
||||
if 'BOOTHEADER_CFG' in data:
|
||||
bootheader_create_do(chipname, chiptype, config_file, 'BOOTHEADER_CFG', output_file1, if_img)
|
||||
if 'BOOTHEADER_CPU0_CFG' in data:
|
||||
bootheader_create_do(chipname, chiptype, config_file, 'BOOTHEADER_CPU0_CFG', output_file1, if_img)
|
||||
if 'BOOTHEADER_CPU1_CFG' in data:
|
||||
bootheader_create_do(chipname, chiptype, config_file, 'BOOTHEADER_CPU1_CFG', output_file2, if_img)
|
||||
if 'BOOTHEADER_GROUP0_CFG' in data:
|
||||
bootheader_create_do(chipname, chiptype, config_file, 'BOOTHEADER_GROUP0_CFG', output_file1, if_img)
|
||||
if 'BOOTHEADER_GROUP1_CFG' in data:
|
||||
bootheader_create_do(chipname, chiptype, config_file, 'BOOTHEADER_GROUP1_CFG', output_file2, if_img)
|
||||
|
||||
|
||||
def efuse_create_process(chipname, chiptype, config_file, output_file=None):
|
||||
efuse_bootheader_path = os.path.join(chip_path, chipname, 'efuse_bootheader')
|
||||
eflash_loader_path = os.path.join(chip_path, chipname, 'eflash_loader')
|
||||
filedir = ''
|
||||
bflb_utils.printf('Create efuse using ', config_file)
|
||||
cfgfile = eflash_loader_path + '/eflash_loader_cfg.ini'
|
||||
if os.path.isfile(cfgfile) is False:
|
||||
shutil.copyfile(eflash_loader_path + '/eflash_loader_cfg.conf', cfgfile)
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(cfgfile)
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
efuse_data, mask = update_data_from_cfg(sub_module.efuse_cfg_keys.efuse_cfg_keys, config_file, 'EFUSE_CFG')
|
||||
if output_file is None:
|
||||
filedir = efuse_bootheader_path + '/efusedata.bin'
|
||||
else:
|
||||
filedir = output_file
|
||||
fp = open(filedir, 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
bflb_utils.update_cfg(cfg, 'EFUSE_CFG', 'file', convert_path(os.path.relpath(filedir, app_path)))
|
||||
if output_file is None:
|
||||
filedir = efuse_bootheader_path + '/efusedata_mask.bin'
|
||||
else:
|
||||
filedir = output_file.replace('.bin', '_mask.bin')
|
||||
fp = open(filedir, 'wb+')
|
||||
fp.write(mask)
|
||||
fp.close()
|
||||
bflb_utils.update_cfg(cfg, 'EFUSE_CFG', 'maskfile', convert_path(os.path.relpath(filedir, app_path)))
|
||||
cfg.write(cfgfile, 'w+')
|
||||
|
||||
|
||||
def efuse_boothd_create_process(chipname, chiptype, config_file):
|
||||
bootheader_create_process(chipname, chiptype, config_file)
|
||||
efuse_create_process(chipname, chiptype, config_file)
|
||||
|
||||
|
||||
def run():
|
||||
chip_dict = {
|
||||
'bl56x': 'bl60x',
|
||||
'bl60x': 'bl60x',
|
||||
'bl562': 'bl602',
|
||||
'bl602': 'bl602',
|
||||
'bl702': 'bl702',
|
||||
'bl702l': 'bl702l',
|
||||
'bl808': 'bl808',
|
||||
'bl616': 'bl616',
|
||||
'wb03': 'wb03'}
|
||||
chipname = sys.argv[1]
|
||||
chiptype = chip_dict[chipname]
|
||||
img_create_path = os.path.join(chip_path, chipname, 'img_create_mcu')
|
||||
bh_cfg_file = img_create_path + '/efuse_bootheader_cfg.ini'
|
||||
bh_file = img_create_path + '/bootheader.bin'
|
||||
bootheader_create_process(chipname, chiptype, bh_cfg_file, bh_file, img_create_path + '/bootheader_dummy.bin')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run()
|
||||
# okay decompiling ./libs/base/bflb_efuse_boothd_create.pyc
|
||||
170
libs/base/bflb_flash_select.py
Normal file
170
libs/base/bflb_flash_select.py
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
# 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_flash_select.py
|
||||
import os, re
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, chip_path, conf_sign
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
|
||||
def get_int_mask(pos, length):
|
||||
ones = '11111111111111111111111111111111'
|
||||
zeros = '00000000000000000000000000000000'
|
||||
mask = ones[0:32 - pos - length] + zeros[0:length] + ones[0:pos]
|
||||
return int(mask, 2)
|
||||
|
||||
|
||||
def update_flash_para_from_cfg(config_keys, config_file):
|
||||
section = 'FLASH_CFG'
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
filelen = 0
|
||||
offset = 0
|
||||
minOffset = 4294967295
|
||||
maxOffset = 0
|
||||
flashCrcOffset = 0
|
||||
crcOffset = 0
|
||||
if config_keys.get('crc32') != None:
|
||||
crcOffset = int(config_keys.get('crc32')['offset'], 10)
|
||||
if config_keys.get('flashcfg_crc32') != None:
|
||||
flashCrcOffset = int(config_keys.get('flashcfg_crc32')['offset'], 10)
|
||||
for key in cfg.options(section):
|
||||
if config_keys.get(key) == None:
|
||||
continue
|
||||
else:
|
||||
offset = int(config_keys.get(key)['offset'], 10)
|
||||
if offset < minOffset:
|
||||
minOffset = offset
|
||||
if offset > maxOffset:
|
||||
maxOffset = offset
|
||||
|
||||
filelen = maxOffset - minOffset + 4
|
||||
data = bytearray(filelen)
|
||||
for key in cfg.options(section):
|
||||
if config_keys.get(key) == None:
|
||||
bflb_utils.printf(key + ' not exist')
|
||||
continue
|
||||
else:
|
||||
val = cfg.get(section, key)
|
||||
if val.startswith('0x'):
|
||||
val = int(val, 16)
|
||||
else:
|
||||
val = int(val, 10)
|
||||
offset = int(config_keys.get(key)['offset'], 10) - minOffset
|
||||
pos = int(config_keys.get(key)['pos'], 10)
|
||||
bitlen = int(config_keys.get(key)['bitlen'], 10)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = (oldval & get_int_mask(pos, bitlen)) + (val << pos)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
|
||||
return (minOffset, filelen, data, flashCrcOffset, crcOffset)
|
||||
|
||||
|
||||
def update_flash_cfg_data_do(chiptype, flash_id):
|
||||
cfg_dir = app_path + '/utils/flash/' + chiptype + '/'
|
||||
sub_module = __import__(('libs.base.' + chiptype), fromlist=[chiptype])
|
||||
conf_name = sub_module.flash_select_do.get_suitable_file_name(cfg_dir, flash_id)
|
||||
if os.path.isfile(cfg_dir + conf_name) == False:
|
||||
return (None, None, None, None, None)
|
||||
return update_flash_para_from_cfg(sub_module.bootheader_cfg_keys.bootheader_cfg_keys, cfg_dir + conf_name)
|
||||
|
||||
|
||||
def flash_bootheader_config_check(chiptype, flashid, file, parafile):
|
||||
magic_code = 1347307074
|
||||
flash_magic_code = 1195787078
|
||||
offset, flashCfgLen, data, flashCrcOffset, crcOffset = update_flash_cfg_data_do(chiptype, flashid)
|
||||
if data is None:
|
||||
offset = 12
|
||||
flashCfgLen = 84
|
||||
if parafile != '':
|
||||
if data != None:
|
||||
fp = open(os.path.join(app_path, parafile), 'wb')
|
||||
fp.write(data)
|
||||
fp.close()
|
||||
fp = open(os.path.join(app_path, file), 'rb')
|
||||
rdata = bytearray(fp.read())
|
||||
fp.close()
|
||||
i = 0
|
||||
length = 128
|
||||
flashCfg = bytearray(256)
|
||||
while i < length:
|
||||
if rdata[i:i + 4] == bflb_utils.int_to_4bytearray_l(magic_code):
|
||||
if rdata[i + 8:i + 12] == bflb_utils.int_to_4bytearray_l(flash_magic_code):
|
||||
if data != None:
|
||||
data[2:4] = rdata[i + 14:i + 16]
|
||||
flashCfg = rdata[i + offset:i + offset + flashCfgLen]
|
||||
if data != None:
|
||||
if not data != flashCfg and flashCfg[13:14] != b'\xff' or flashCfg[13:14] != b'\x00':
|
||||
return False
|
||||
else:
|
||||
if flashCfg[13:14] != b'\xff':
|
||||
if flashCfg[13:14] != b'\x00':
|
||||
return False
|
||||
i += 4
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def update_flash_cfg_data(chiptype, flash_id, cfg, bh_cfg_file, cfg_key):
|
||||
cfg2 = BFConfigParser()
|
||||
cfg2.read(bh_cfg_file)
|
||||
magic_code = cfg2.get(cfg_key, 'magic_code')
|
||||
magic_code = int(magic_code, 16)
|
||||
flash_magic_code = cfg2.get(cfg_key, 'flashcfg_magic_code')
|
||||
flash_magic_code = int(flash_magic_code, 16)
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
offset, flashCfgLen, data, flashCrcOffset, crcOffset = update_flash_cfg_data_do(chiptype, flash_id)
|
||||
para_file = cfg.get('FLASH_CFG', 'flash_para')
|
||||
if para_file != '':
|
||||
fp = open(os.path.join(app_path, para_file), 'wb')
|
||||
fp.write(data)
|
||||
fp.close()
|
||||
flash_file = re.compile('\\s+').split(cfg.get('FLASH_CFG', 'file'))
|
||||
for f in flash_file:
|
||||
fp = open(os.path.join(app_path, f), 'rb')
|
||||
rdata = bytearray(fp.read())
|
||||
fp.close()
|
||||
i = 0
|
||||
length = len(rdata)
|
||||
while i < length:
|
||||
if rdata[i:i + 4] == bflb_utils.int_to_4bytearray_l(magic_code):
|
||||
if rdata[i + 8:i + 12] == bflb_utils.int_to_4bytearray_l(flash_magic_code):
|
||||
data[2:4] = rdata[i + 14:i + 16]
|
||||
flashCfg = rdata[i + offset:i + offset + flashCfgLen]
|
||||
if data != flashCfg:
|
||||
return False
|
||||
i += 4
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def check_basic_flash_cfg(cfg_file, section):
|
||||
if os.path.isfile(cfg_file) is False:
|
||||
return False
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(cfg_file)
|
||||
if cfg.has_option(section, 'mfg_id'):
|
||||
if cfg.get(section, 'mfg_id') == '0xff' or cfg.get(section, 'mfg_id') == '0xFF':
|
||||
cfg.set(section, 'io_mode', '0x10')
|
||||
cfg.set(section, 'cont_read_support', '0')
|
||||
cfg.write(cfg_file, 'w+')
|
||||
return True
|
||||
if cfg.get(section, 'mfg_id') == '0x00':
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def update_flash_cfg(chipname, chiptype, flash_id, file=None, create=False, section=None):
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
if check_basic_flash_cfg(file, section):
|
||||
return True
|
||||
if sub_module.flash_select_do.update_flash_cfg_do(chipname, chiptype, flash_id, file, create, section) == False:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def get_supported_flash(chiptype):
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
return sub_module.flash_select_do.get_supported_flash_do()
|
||||
# okay decompiling ./libs/base/bflb_flash_select.pyc
|
||||
179
libs/base/bflb_img_create.py
Normal file
179
libs/base/bflb_img_create.py
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
# 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_img_create.py
|
||||
import re, os, sys, time, shutil, zipfile
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, chip_path, set_error_code, convert_path
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base import bflb_efuse_boothd_create
|
||||
|
||||
def take_second(elem):
|
||||
return elem[1]
|
||||
|
||||
|
||||
def factory_mode_set(file, value):
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(file)
|
||||
if cfg.has_option('EFUSE_CFG', 'factory_mode'):
|
||||
cfg.set('EFUSE_CFG', 'factory_mode', value)
|
||||
cfg.write(file, 'w')
|
||||
|
||||
|
||||
def check_pt_file(file, addr):
|
||||
if len(file) > 0:
|
||||
i = 0
|
||||
L = []
|
||||
while i < len(file):
|
||||
L.append([convert_path(file[i]), int(addr[i], 16)])
|
||||
i += 1
|
||||
|
||||
L.sort(key=take_second)
|
||||
i = 0
|
||||
try:
|
||||
while i < len(L) - 1:
|
||||
address = L[i][1]
|
||||
address_next = L[i + 1][1]
|
||||
file_size = os.path.getsize(os.path.join(app_path, L[i][0]))
|
||||
if address_next < address + file_size:
|
||||
bflb_utils.printf('pt check fail, %s is overlayed with %s in flash layout, please check your partition table to fix this issue' % (
|
||||
L[i][0], L[i + 1][0]))
|
||||
return False
|
||||
else:
|
||||
i += 1
|
||||
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
return False
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def compress_dir(chipname, zippath, efuse_load=False, address=None, flash_file=None, efuse_file=None, efuse_mask_file=None):
|
||||
zip_file = os.path.join(chip_path, chipname, zippath, 'whole_img.pack')
|
||||
dir_path = os.path.join(chip_path, chipname, chipname)
|
||||
cfg_file = os.path.join(chip_path, chipname, 'eflash_loader/eflash_loader_cfg.ini')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(cfg_file)
|
||||
if not address:
|
||||
address = []
|
||||
if not flash_file:
|
||||
flash_file = []
|
||||
if check_pt_file(flash_file, address) is not True:
|
||||
bflb_utils.printf('PT Check Fail')
|
||||
set_error_code('0082')
|
||||
return False
|
||||
flash_file.append(os.path.join(chip_path, chipname, 'eflash_loader/eflash_loader_cfg.ini'))
|
||||
if efuse_load:
|
||||
if efuse_file:
|
||||
flash_file.append(efuse_file)
|
||||
if efuse_mask_file:
|
||||
flash_file.append(efuse_mask_file)
|
||||
if len(flash_file) > 0:
|
||||
i = 0
|
||||
try:
|
||||
while i < len(flash_file):
|
||||
if chip_path in flash_file[i]:
|
||||
relpath = os.path.relpath(os.path.join(app_path, convert_path(flash_file[i])), chip_path)
|
||||
dir = os.path.join(chip_path, chipname, relpath)
|
||||
if os.path.isdir(os.path.dirname(dir)) is False:
|
||||
os.makedirs(os.path.dirname(dir))
|
||||
shutil.copyfile(os.path.join(app_path, convert_path(flash_file[i])), dir)
|
||||
else:
|
||||
relpath = os.path.relpath(os.path.join(chipname, 'img_create', os.path.basename(flash_file[i])))
|
||||
dir = os.path.join(chip_path, chipname, relpath)
|
||||
if os.path.isdir(os.path.dirname(dir)) is False:
|
||||
os.makedirs(os.path.dirname(dir))
|
||||
shutil.copyfile(flash_file[i], dir)
|
||||
i += 1
|
||||
|
||||
verfile = os.path.join(chip_path, chipname, chipname, 'version.txt')
|
||||
with open(verfile, mode='w') as f:
|
||||
f.write(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
return False
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
try:
|
||||
z = zipfile.ZipFile(zip_file, 'w')
|
||||
for dirpath, dirnames, filenames in os.walk(dir_path):
|
||||
for file in filenames:
|
||||
z.write(os.path.join(dirpath, file), os.path.relpath(os.path.join(dirpath, file), os.path.join(chip_path, chipname)))
|
||||
|
||||
z.close()
|
||||
shutil.rmtree(dir_path)
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
return False
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def img_create(args, chipname='bl60x', chiptype='bl60x', img_dir=None, config_file=None):
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
img_dir_path = os.path.join(chip_path, chipname, 'img_create')
|
||||
if img_dir is None:
|
||||
sub_module.img_create_do.img_create_do(args, img_dir_path, config_file)
|
||||
else:
|
||||
sub_module.img_create_do.img_create_do(args, img_dir, config_file)
|
||||
|
||||
|
||||
def create_sp_media_image_file(config, chiptype='bl60x', cpu_type=None):
|
||||
sub_module = __import__(('libs.' + chiptype), fromlist=[chiptype])
|
||||
sub_module.img_create_do.create_sp_media_image(config, cpu_type)
|
||||
|
||||
|
||||
def encrypt_loader_bin(chiptype, file, sign, encrypt, encrypt_key, encrypt_iv, publickey_file, privatekey_file):
|
||||
sub_module = __import__(('libs.base.' + chiptype), fromlist=[chiptype])
|
||||
return sub_module.img_create_do.encrypt_loader_bin_do(file, sign, encrypt, encrypt_key, encrypt_iv, publickey_file, privatekey_file)
|
||||
|
||||
|
||||
def run():
|
||||
parser_image = bflb_utils.image_create_parser_init()
|
||||
args = parser_image.parse_args()
|
||||
bflb_utils.printf('Chipname: %s' % args.chipname)
|
||||
if args.chipname:
|
||||
chip_dict = { 'bl56x': 'bl60x',
|
||||
'bl60x': 'bl60x',
|
||||
'bl562': 'bl602',
|
||||
'bl602': 'bl602',
|
||||
'bl702': 'bl702',
|
||||
'bl702l': 'bl702l',
|
||||
'bl808': 'bl808',
|
||||
'bl606p': 'bl808',
|
||||
'bl616': 'bl616',
|
||||
'wb03': 'wb03'}
|
||||
chipname = args.chipname
|
||||
chiptype = chip_dict[chipname]
|
||||
img_create_path = os.path.join(chip_path, chipname, 'img_create_mcu')
|
||||
img_create_cfg = os.path.join(chip_path, chipname, 'img_create_mcu') + '/img_create_cfg.ini'
|
||||
bh_cfg_file = img_create_path + '/efuse_bootheader_cfg.ini'
|
||||
bh_file = img_create_path + '/bootheader.bin'
|
||||
if args.imgfile:
|
||||
imgbin = args.imgfile
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(img_create_cfg)
|
||||
cfg.set('Img_Cfg', 'segdata_file', imgbin)
|
||||
cfg.write(img_create_cfg, 'w')
|
||||
bflb_efuse_boothd_create.bootheader_create_process(chipname, chiptype, bh_cfg_file, bh_file, img_create_path + '/bootheader_dummy.bin')
|
||||
img_create(args, chipname, chiptype, img_create_path, img_create_cfg)
|
||||
else:
|
||||
bflb_utils.printf('Please set chipname config, exit')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run()
|
||||
# okay decompiling ./libs/base/bflb_img_create.pyc
|
||||
787
libs/base/bflb_img_loader.py
Normal file
787
libs/base/bflb_img_loader.py
Normal file
|
|
@ -0,0 +1,787 @@
|
|||
# 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_img_loader.py
|
||||
import os, sys, time, hashlib, binascii, traceback, threading
|
||||
from Crypto.Cipher import AES
|
||||
from libs import bflb_utils
|
||||
from libs.base import bflb_img_create
|
||||
from libs.base import bflb_serial
|
||||
import config as gol
|
||||
from libs.bflb_utils import app_path
|
||||
|
||||
class BflbImgLoader(object):
|
||||
|
||||
def __init__(self, device, speed, boot_speed, interface='uart', chip_type='bl602', chip_name='bl602', eflash_loader_file1='', eflash_loader_file2='', callback=None, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, shake_hand_retry=2, isp_mode_sign=False, isp_timeout=0, encrypt_key=None, encrypt_iv=None, public_key=None, private_key=None):
|
||||
self._device = device
|
||||
self._speed = speed
|
||||
self._interface = interface.lower()
|
||||
self._chip_type = chip_type
|
||||
self._chip_name = chip_name
|
||||
self._eflash_loader_file1 = eflash_loader_file1
|
||||
self._eflash_loader_file2 = eflash_loader_file2
|
||||
self._callback = callback
|
||||
self._do_reset = do_reset
|
||||
self._reset_hold_time = reset_hold_time
|
||||
self._shake_hand_delay = shake_hand_delay
|
||||
self._reset_revert = reset_revert
|
||||
self._cutoff_time = cutoff_time
|
||||
self._shake_hand_retry = shake_hand_retry
|
||||
self._isp_mode_sign = isp_mode_sign
|
||||
self._isp_timeout = isp_timeout
|
||||
self._boot_speed = boot_speed
|
||||
self.encrypt_key = encrypt_key
|
||||
self.encrypt_iv = encrypt_iv
|
||||
self.public_key = public_key
|
||||
self.private_key = private_key
|
||||
self._boot_load = True
|
||||
self._record_bootinfo = None
|
||||
self.bflb_serial_object = None
|
||||
self._imge_fp = None
|
||||
self._segcnt = 0
|
||||
self._602a0_dln_fix = False
|
||||
self.isp_baudrate = 2000000
|
||||
if interface == 'uart':
|
||||
self.bflb_serial_object = bflb_serial.BLSerialUart(rts_state=True, dtr_state=True)
|
||||
self._bootrom_cmds = {'get_chip_id':{'cmd_id':'05',
|
||||
'data_len':'0000',
|
||||
'callback':None},
|
||||
'get_boot_info':{'cmd_id':'10',
|
||||
'data_len':'0000',
|
||||
'callback':None},
|
||||
'load_boot_header':{'cmd_id':'11',
|
||||
'data_len':'00b0',
|
||||
'callback':None},
|
||||
'808_load_boot_header':{'cmd_id':'11',
|
||||
'data_len':'0160',
|
||||
'callback':None},
|
||||
'628_load_boot_header':{'cmd_id':'11',
|
||||
'data_len':'0100',
|
||||
'callback':None},
|
||||
'616_load_boot_header':{'cmd_id':'11',
|
||||
'data_len':'0100',
|
||||
'callback':None},
|
||||
'702l_load_boot_header':{'cmd_id':'11',
|
||||
'data_len':'00F0',
|
||||
'callback':None},
|
||||
'load_publick_key':{'cmd_id':'12',
|
||||
'data_len':'0044',
|
||||
'callback':None},
|
||||
'load_publick_key2':{'cmd_id':'13',
|
||||
'data_len':'0044',
|
||||
'callback':None},
|
||||
'load_signature':{'cmd_id':'14',
|
||||
'data_len':'0004',
|
||||
'callback':None},
|
||||
'load_signature2':{'cmd_id':'15',
|
||||
'data_len':'0004',
|
||||
'callback':None},
|
||||
'load_aes_iv':{'cmd_id':'16',
|
||||
'data_len':'0014',
|
||||
'callback':None},
|
||||
'load_seg_header':{'cmd_id':'17',
|
||||
'data_len':'0010',
|
||||
'callback':None},
|
||||
'load_seg_data':{'cmd_id':'18',
|
||||
'data_len':'0100',
|
||||
'callback':None},
|
||||
'check_image':{'cmd_id':'19',
|
||||
'data_len':'0000',
|
||||
'callback':None},
|
||||
'run_image':{'cmd_id':'1a',
|
||||
'data_len':'0000',
|
||||
'callback':None},
|
||||
'change_rate':{'cmd_id':'20',
|
||||
'data_len':'0008',
|
||||
'callback':None},
|
||||
'reset':{'cmd_id':'21',
|
||||
'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},
|
||||
'efuse_write':{'cmd_id':'40',
|
||||
'data_len':'0080',
|
||||
'callback':None},
|
||||
'efuse_read':{'cmd_id':'41',
|
||||
'data_len':'0000',
|
||||
'callback':None}}
|
||||
|
||||
def close_port(self):
|
||||
if self.bflb_serial_object is not None:
|
||||
self.bflb_serial_object.close()
|
||||
|
||||
def boot_process_load_cmd(self, section, read_len):
|
||||
read_data = bytearray(0)
|
||||
if read_len != 0:
|
||||
read_data = bytearray(self._imge_fp.read(read_len))
|
||||
if len(read_data) != read_len:
|
||||
bflb_utils.printf('read error,expected len=', read_len, 'read len=', len(read_data))
|
||||
return bytearray(0)
|
||||
if section == 'load_boot_header':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[120:124])
|
||||
self._segcnt = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segcnt is ', self._segcnt)
|
||||
else:
|
||||
if section == '808_load_boot_header':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[140:144])
|
||||
self._segcnt = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segcnt is ', self._segcnt)
|
||||
else:
|
||||
if section == '628_load_boot_header':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[136:140])
|
||||
self._segcnt = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segcnt is ', self._segcnt)
|
||||
else:
|
||||
if section == '616_load_boot_header':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[132:136])
|
||||
self._segcnt = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segcnt is ', self._segcnt)
|
||||
else:
|
||||
if section == '702l_load_boot_header':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[120:124])
|
||||
self._segcnt = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segcnt is ', self._segcnt)
|
||||
if section == 'load_signature' or section == 'load_signature2':
|
||||
tmp = bflb_utils.bytearray_reverse(read_data[0:4])
|
||||
sig_len = bflb_utils.bytearray_to_int(tmp)
|
||||
read_data = read_data + bytearray(self._imge_fp.read(sig_len + 4))
|
||||
if len(read_data) != sig_len + 8:
|
||||
bflb_utils.printf('read signature error,expected len=', sig_len + 4, 'read len=', len(read_data))
|
||||
return read_data
|
||||
|
||||
def boot_process_one_cmd(self, section, cmd_id, cmd_len):
|
||||
read_len = bflb_utils.bytearray_to_int(cmd_len)
|
||||
read_data = self._bootrom_cmds.get(section)['callback'](section, read_len)
|
||||
tmp = bytearray(2)
|
||||
tmp[0] = cmd_len[1]
|
||||
tmp[1] = cmd_len[0]
|
||||
data_read = bytearray(0)
|
||||
tmp = bflb_utils.int_to_2bytearray_l(len(read_data))
|
||||
data = cmd_id + bytearray(1) + tmp + read_data
|
||||
if self._chip_type == 'bl702':
|
||||
if section == 'run_image':
|
||||
sub_module = __import__(('libs.base.' + self._chip_type), fromlist=[self._chip_type])
|
||||
data = sub_module.chiptype_patch.img_load_create_predata_before_run_img()
|
||||
self.bflb_serial_object.write(data)
|
||||
if section == 'get_boot_info' or section == 'load_seg_header' or section == 'get_chip_id':
|
||||
res, data_read = self.bflb_serial_object.deal_response()
|
||||
else:
|
||||
res = self.bflb_serial_object.deal_ack()
|
||||
if res.startswith('OK') is True:
|
||||
pass
|
||||
else:
|
||||
try:
|
||||
bflb_utils.printf('result: ', res)
|
||||
except IOError:
|
||||
bflb_utils.printf('python IO error')
|
||||
|
||||
return (res, data_read)
|
||||
|
||||
def boot_process_one_section(self, section, data_len):
|
||||
cmd_id = bflb_utils.hexstr_to_bytearray(self._bootrom_cmds.get(section)['cmd_id'])
|
||||
if data_len == 0:
|
||||
length = bflb_utils.hexstr_to_bytearray(self._bootrom_cmds.get(section)['data_len'])
|
||||
else:
|
||||
length = bflb_utils.int_to_2bytearray_b(data_len)
|
||||
return self.boot_process_one_cmd(section, cmd_id, length)
|
||||
|
||||
def boot_inf_change_rate(self, comnum, section, newrate):
|
||||
cmd_id = bflb_utils.hexstr_to_bytearray(self._bootrom_cmds.get(section)['cmd_id'])
|
||||
cmd_len = bflb_utils.hexstr_to_bytearray(self._bootrom_cmds.get(section)['data_len'])
|
||||
bflb_utils.printf('process', section, ',cmd=', binascii.hexlify(cmd_id), ',data len=', binascii.hexlify(cmd_len))
|
||||
baudrate = self.bflb_serial_object.if_get_rate()
|
||||
oldv = bflb_utils.int_to_4bytearray_l(baudrate)
|
||||
newv = bflb_utils.int_to_4bytearray_l(newrate)
|
||||
tmp = bytearray(3)
|
||||
tmp[1] = cmd_len[1]
|
||||
tmp[2] = cmd_len[0]
|
||||
data = cmd_id + tmp + oldv + newv
|
||||
self.bflb_serial_object.if_write(data)
|
||||
bflb_utils.printf()
|
||||
stime = 110 / float(baudrate) * 2
|
||||
if stime < 0.003:
|
||||
stime = 0.003
|
||||
time.sleep(stime)
|
||||
self.bflb_serial_object.if_close()
|
||||
self.bflb_serial_object.if_init(comnum, newrate, self._chip_type, self._chip_name)
|
||||
return self.bflb_serial_object.if_deal_ack(dmy_data=False)
|
||||
|
||||
def boot_install_cmds_callback(self):
|
||||
self._bootrom_cmds.get('get_chip_id')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('get_boot_info')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_boot_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('808_load_boot_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('628_load_boot_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('616_load_boot_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('702l_load_boot_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_publick_key')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_publick_key2')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_signature')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_signature2')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_aes_iv')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_seg_header')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('load_seg_data')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('check_image')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('run_image')['callback'] = self.boot_process_load_cmd
|
||||
self._bootrom_cmds.get('reset')['callback'] = self.boot_process_load_cmd
|
||||
|
||||
def issue_log_print(self):
|
||||
bflb_utils.printf('########################################################################')
|
||||
bflb_utils.printf('请按照以下描述排查问题：')
|
||||
if self._chip_type == 'bl60x':
|
||||
bflb_utils.printf('GPIO24是否上拉到板子自身的3.3V，而不是外部的3.3V')
|
||||
bflb_utils.printf('GPIO7(RX)是否连接到USB转串口的TX引脚')
|
||||
bflb_utils.printf('GPIO14(TX)是否连接到USB转串口的RX引脚')
|
||||
bflb_utils.printf('在使用烧录软件进行烧录前，是否在GPIO24拉高的情况下，使用Reset/Chip_En复位了芯片')
|
||||
else:
|
||||
if self._chip_type == 'bl602':
|
||||
bflb_utils.printf('GPIO8是否上拉到板子自身的3.3V，而不是外部的3.3V')
|
||||
bflb_utils.printf('GPIO7(RX)是否连接到USB转串口的TX引脚')
|
||||
bflb_utils.printf('GPIO16(TX)是否连接到USB转串口的RX引脚')
|
||||
bflb_utils.printf('在使用烧录软件进行烧录前，是否在GPIO8拉高的情况下，使用Reset/Chip_En复位了芯片')
|
||||
else:
|
||||
if self._chip_type == 'bl702':
|
||||
bflb_utils.printf('GPIO28是否上拉到板子自身的3.3V，而不是外部的3.3V')
|
||||
bflb_utils.printf('GPIO15(RX)是否连接到USB转串口的TX引脚')
|
||||
bflb_utils.printf('GPIO14(TX)是否连接到USB转串口的RX引脚')
|
||||
bflb_utils.printf('在使用烧录软件进行烧录前，是否在GPIO28拉高的情况下，使用Reset/Chip_En复位了芯片')
|
||||
else:
|
||||
bflb_utils.printf('Boot pin是否上拉到板子自身的3.3V，而不是外部的3.3V')
|
||||
bflb_utils.printf('UART RX是否连接到USB转串口的TX引脚')
|
||||
bflb_utils.printf('UART TX是否连接到USB转串口的RX引脚')
|
||||
bflb_utils.printf('在使用烧录软件进行烧录前，是否在Boot pin拉高的情况下，使用Reset/Chip_En复位了芯片')
|
||||
bflb_utils.printf('烧录软件所选择的COM口，是否是连接芯片的串口')
|
||||
bflb_utils.printf('烧录软件上选择的波特率是否是USB转串口支持的波特率')
|
||||
bflb_utils.printf('3.3V供电是否正常')
|
||||
bflb_utils.printf('板子供电电流是否正常(烧录模式下，芯片耗电电流5-7mA)')
|
||||
bflb_utils.printf('########################################################################')
|
||||
|
||||
def send_55_command(self, speed):
|
||||
try:
|
||||
while True:
|
||||
if self._shakehand_flag is True:
|
||||
break
|
||||
if not self._chip_type == 'bl702' or self._chip_type == 'bl702l':
|
||||
self.bflb_serial_object.write(self.get_sync_bytes(int(0.003 * speed / 10)))
|
||||
else:
|
||||
self.bflb_serial_object.write(self.get_sync_bytes(int(0.006 * speed / 10)))
|
||||
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def get_sync_bytes(self, length):
|
||||
try:
|
||||
data = bytearray(length)
|
||||
i = 0
|
||||
while i < length:
|
||||
data[i] = 85
|
||||
i += 1
|
||||
|
||||
return data
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def set_isp_baudrate(self, isp_baudrate):
|
||||
bflb_utils.printf('isp mode speed: ', isp_baudrate)
|
||||
self.isp_baudrate = isp_baudrate
|
||||
|
||||
def toggle_boot_or_shake_hand(self, run_sign, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, isp_mode_sign=False, isp_timeout=0, boot_load=False, shake_hand_retry=2):
|
||||
"""
|
||||
When run_sign is 2, it run shakehand.
|
||||
"""
|
||||
device = self._device
|
||||
speed = self._speed
|
||||
if run_sign == 2:
|
||||
shake_hand_retry = shake_hand_retry
|
||||
else:
|
||||
if run_sign == 1:
|
||||
shake_hand_retry = 1
|
||||
if self.bflb_serial_object:
|
||||
try:
|
||||
timeout = self.bflb_serial_object.get_timeout()
|
||||
blusbserialwriteflag = False
|
||||
if isp_mode_sign:
|
||||
if isp_timeout > 0:
|
||||
wait_timeout = isp_timeout
|
||||
self.bflb_serial_object.set_timeout(0.1)
|
||||
self._shakehand_flag = False
|
||||
cutoff_time = 0
|
||||
do_reset = False
|
||||
self.bflb_serial_object.repeat_init(device, self.isp_baudrate, self._chip_type, self._chip_name)
|
||||
self.bflb_serial_object.write(b'\r\nispboot if\r\nreboot\r\n')
|
||||
fl_thrx = None
|
||||
fl_thrx = threading.Thread(target=(self.send_55_command), args=(speed,))
|
||||
fl_thrx.setDaemon(True)
|
||||
fl_thrx.start()
|
||||
bflb_utils.printf('Please Press Reset Key!')
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
time.sleep(0.2)
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
time_stamp = time.time()
|
||||
while time.time() - time_stamp < wait_timeout:
|
||||
if self._chip_type == 'bl602' or self._chip_type == 'bl702':
|
||||
self.bflb_serial_object.set_timeout(0.01)
|
||||
success, ack = self.bflb_serial_object.read(3000)
|
||||
if ack.find(b'Boot2 ISP Shakehand Suss') != -1:
|
||||
self._shakehand_flag = True
|
||||
if ack.find(b'Boot2 ISP Ready') != -1:
|
||||
bflb_utils.printf('isp ready')
|
||||
self.bflb_serial_object.write(bytearray.fromhex('a0000000'))
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
return 'OK'
|
||||
else:
|
||||
success, ack = self.bflb_serial_object.read(3000)
|
||||
if ack.find(b'Boot2 ISP Ready') != -1:
|
||||
bflb_utils.printf('isp ready')
|
||||
self._shakehand_flag = True
|
||||
if self._shakehand_flag is True:
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
tmp_timeout = self.bflb_serial_object.get_timeout()
|
||||
self.bflb_serial_object.set_timeout(0.1)
|
||||
if self._chip_type == 'bl602' or self._chip_type == 'bl702':
|
||||
self.bflb_serial_object.set_timeout(0.5)
|
||||
success, ack = self.bflb_serial_object.read(15)
|
||||
self.bflb_serial_object.set_timeout(0.005)
|
||||
ack += self.bflb_serial_object.read(15)[1]
|
||||
self.bflb_serial_object.set_timeout(tmp_timeout)
|
||||
bflb_utils.printf('read ready')
|
||||
if ack.find(b'Boot2 ISP Ready') == -1:
|
||||
bflb_utils.printf('Boot2 isp is not ready')
|
||||
return 'FL'
|
||||
self.bflb_serial_object.write(bytearray.fromhex('a0000000'))
|
||||
return 'OK'
|
||||
else:
|
||||
while 1:
|
||||
ack = self.bflb_serial_object.raw_read()
|
||||
if len(ack) == 0:
|
||||
break
|
||||
|
||||
time.sleep(0.1)
|
||||
while True:
|
||||
ack = self.bflb_serial_object.raw_read()
|
||||
if len(ack) == 0:
|
||||
break
|
||||
|
||||
self.bflb_serial_object.set_timeout(tmp_timeout)
|
||||
break
|
||||
|
||||
self._shakehand_flag = True
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
self.bflb_serial_object.repeat_init(device, speed, self._chip_type, self._chip_name)
|
||||
time.sleep(2.2)
|
||||
if self.bflb_serial_object._is_bouffalo_chip():
|
||||
if boot_load:
|
||||
blusbserialwriteflag = True
|
||||
while shake_hand_retry > 0:
|
||||
if cutoff_time != 0 and blusbserialwriteflag is not True:
|
||||
cutoff_revert = False
|
||||
if cutoff_time > 1000:
|
||||
cutoff_revert = True
|
||||
cutoff_time = cutoff_time - 1000
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
time.sleep(0.2)
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
time.sleep(0.05)
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
if cutoff_revert:
|
||||
self.bflb_serial_object.setDTR(0)
|
||||
else:
|
||||
self.bflb_serial_object.setDTR(1)
|
||||
bflb_utils.printf('tx rx and power off, press the machine!')
|
||||
bflb_utils.printf('cutoff time is ', cutoff_time / 1000.0)
|
||||
time.sleep(cutoff_time / 1000.0)
|
||||
if cutoff_revert:
|
||||
self.bflb_serial_object.setDTR(1)
|
||||
else:
|
||||
self.bflb_serial_object.setDTR(0)
|
||||
bflb_utils.printf('power on tx and rx ')
|
||||
time.sleep(0.1)
|
||||
else:
|
||||
if run_sign == 2:
|
||||
self.bflb_serial_object.setDTR(0)
|
||||
bflb_utils.printf('default set DTR high ')
|
||||
time.sleep(0.1)
|
||||
if do_reset is True:
|
||||
if blusbserialwriteflag is not True:
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
time.sleep(0.2)
|
||||
if reset_revert:
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
time.sleep(0.001)
|
||||
reset_cnt = 2
|
||||
if reset_hold_time > 1000:
|
||||
reset_cnt = int(reset_hold_time // 1000)
|
||||
reset_hold_time = reset_hold_time % 1000
|
||||
while reset_cnt > 0:
|
||||
if reset_revert:
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
else:
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
time.sleep(reset_hold_time / 1000.0)
|
||||
if reset_revert:
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
else:
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
if shake_hand_delay > 0:
|
||||
time.sleep(shake_hand_delay / 1000.0)
|
||||
else:
|
||||
time.sleep(0.005)
|
||||
if reset_revert:
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
else:
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
time.sleep(reset_hold_time / 1000.0)
|
||||
if reset_revert:
|
||||
self.bflb_serial_object.setRTS(1)
|
||||
else:
|
||||
self.bflb_serial_object.setRTS(0)
|
||||
if shake_hand_delay > 0:
|
||||
time.sleep(shake_hand_delay / 1000.0)
|
||||
else:
|
||||
time.sleep(0.005)
|
||||
reset_cnt -= 1
|
||||
|
||||
bflb_utils.printf('reset cnt: ' + str(reset_cnt) + ', reset hold: ' + str(reset_hold_time / 1000.0) + ', shake hand delay: ' + str(shake_hand_delay / 1000.0))
|
||||
if blusbserialwriteflag:
|
||||
self.bflb_serial_object.bl_usb_serial_write(cutoff_time, reset_revert)
|
||||
else:
|
||||
bflb_utils.printf('clean buf')
|
||||
self.bflb_serial_object.set_timeout(0.1)
|
||||
self.bflb_serial_object.clear_buf()
|
||||
if run_sign == 1:
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
return 'OK'
|
||||
if self._602a0_dln_fix:
|
||||
self.bflb_serial_object.set_timeout(0.5)
|
||||
else:
|
||||
self.bflb_serial_object.set_timeout(0.1)
|
||||
bflb_utils.printf('send sync')
|
||||
if self._chip_type == 'bl702' or self._chip_type == 'bl702l':
|
||||
self.bflb_serial_object.write(self.get_sync_bytes(int(0.003 * speed / 10)))
|
||||
else:
|
||||
self.bflb_serial_object.write(self.get_sync_bytes(int(0.006 * speed / 10)))
|
||||
if self._chip_type == 'bl808':
|
||||
time.sleep(0.3)
|
||||
self.bflb_serial_object.write(bflb_utils.hexstr_to_bytearray('5000080038F0002000000018'))
|
||||
if self._602a0_dln_fix:
|
||||
time.sleep(4)
|
||||
success, ack = self.bflb_serial_object.read(1000)
|
||||
bflb_utils.printf('ack is ', binascii.hexlify(ack))
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
if self._602a0_dln_fix:
|
||||
self.bflb_serial_object.write(bytearray(2))
|
||||
time.sleep(0.03)
|
||||
return 'OK'
|
||||
if len(ack) != 0:
|
||||
bflb_utils.printf('reshake')
|
||||
if do_reset is False:
|
||||
bflb_utils.printf('sleep')
|
||||
time.sleep(3)
|
||||
else:
|
||||
bflb_utils.printf('retry')
|
||||
shake_hand_retry -= 1
|
||||
|
||||
self.bflb_serial_object.set_timeout(timeout)
|
||||
return 'FL'
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
else:
|
||||
return 'FL'
|
||||
|
||||
def img_load_shake_hand(self, sh_baudrate, wk_baudrate, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, shake_hand_retry=2, isp_mode_sign=False, isp_timeout=0, boot_load=True):
|
||||
self.bflb_serial_object.repeat_init(self._device, sh_baudrate, self._chip_type, self._chip_name)
|
||||
self.boot_install_cmds_callback()
|
||||
if self._chip_type == 'wb03':
|
||||
self.toggle_boot_or_shake_hand(1, do_reset, reset_hold_time, shake_hand_delay, reset_revert, cutoff_time, isp_mode_sign, isp_timeout, boot_load)
|
||||
bflb_utils.printf('get_chip_id')
|
||||
ret, data_read = self.boot_process_one_section('get_chip_id', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
bflb_utils.printf('fail')
|
||||
return (
|
||||
ret, None)
|
||||
data_read = binascii.hexlify(data_read)
|
||||
bflb_utils.printf('data read is ', data_read)
|
||||
chip_id = data_read.decode('utf-8')
|
||||
if chip_id != '43484950574230334130305f424c0000':
|
||||
if chip_id != '43484950574230334130305F424C0000':
|
||||
return 'shake hand fail'
|
||||
else:
|
||||
if self._chip_type == 'bl602':
|
||||
self._602a0_dln_fix = False
|
||||
ret = self.toggle_boot_or_shake_hand(2, do_reset, reset_hold_time, shake_hand_delay, reset_revert, cutoff_time, isp_mode_sign, isp_timeout, boot_load, shake_hand_retry)
|
||||
if self._chip_type == 'bl602':
|
||||
self._602a0_dln_fix = False
|
||||
if ret != 'OK':
|
||||
bflb_utils.printf('shake hand fail')
|
||||
self.issue_log_print()
|
||||
bflb_utils.set_error_code('0050')
|
||||
return 'shake hand fail'
|
||||
if sh_baudrate != wk_baudrate:
|
||||
if self.boot_inf_change_rate(self._device, 'change_rate', wk_baudrate) != 'OK':
|
||||
bflb_utils.printf('change rate fail')
|
||||
return 'change rate fail'
|
||||
bflb_utils.printf('shake hand success')
|
||||
return ret
|
||||
|
||||
def img_load_main_process(self, file, group, record_bootinfo=None):
|
||||
encrypt_blk_size = 16
|
||||
bflb_utils.printf('get_boot_info')
|
||||
ret, data_read = self.boot_process_one_section('get_boot_info', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
bflb_utils.printf('fail')
|
||||
return (
|
||||
ret, None)
|
||||
data_read = binascii.hexlify(data_read)
|
||||
bflb_utils.printf('data read is ', data_read)
|
||||
bootinfo = data_read.decode('utf-8')
|
||||
chipid = ''
|
||||
if self._chip_type == 'bl702' or self._chip_type == 'bl702l':
|
||||
chipid = bootinfo[32:34] + bootinfo[34:36] + bootinfo[36:38] + bootinfo[38:40] + bootinfo[40:42] + bootinfo[42:44] + bootinfo[44:46] + bootinfo[46:48]
|
||||
else:
|
||||
chipid = bootinfo[34:36] + bootinfo[32:34] + bootinfo[30:32] + bootinfo[28:30] + bootinfo[26:28] + bootinfo[24:26]
|
||||
bflb_utils.printf('========= ChipID: ', chipid, ' =========')
|
||||
bflb_utils.printf('last boot info: ', record_bootinfo)
|
||||
if record_bootinfo != None:
|
||||
if bootinfo[8:] == record_bootinfo[8:]:
|
||||
bflb_utils.printf('repeated chip')
|
||||
return (
|
||||
'repeat_burn', bootinfo)
|
||||
if bootinfo[:8] == 'FFFFFFFF' or bootinfo[:8] == 'ffffffff':
|
||||
bflb_utils.printf('eflash loader present')
|
||||
return (
|
||||
'error_shakehand', bootinfo)
|
||||
sign = 0
|
||||
encrypt = 0
|
||||
if self._chip_type == 'bl60x':
|
||||
sign = int(data_read[8:10], 16) & 3
|
||||
encrypt = (int(data_read[8:10], 16) & 12) >> 2
|
||||
else:
|
||||
if self._chip_type == 'bl602' or self._chip_type == 'bl702' or self._chip_type == 'bl702l':
|
||||
sign = int(data_read[8:10], 16)
|
||||
encrypt = int(data_read[10:12], 16)
|
||||
else:
|
||||
if self._chip_type == 'bl808' or self._chip_type == 'bl628':
|
||||
if group == 0:
|
||||
sign = int(data_read[8:10], 16)
|
||||
encrypt = int(data_read[12:14], 16)
|
||||
else:
|
||||
sign = int(data_read[10:12], 16)
|
||||
encrypt = int(data_read[14:16], 16)
|
||||
else:
|
||||
sign = int(data_read[8:10], 16)
|
||||
encrypt = int(data_read[10:12], 16)
|
||||
bflb_utils.printf('sign is ', sign, ' encrypt is ', encrypt)
|
||||
if encrypt == 1 or sign == 1:
|
||||
if encrypt == 1 and self.encrypt_key != None and self.encrypt_iv != None and sign == 1 and self.encrypt_key != None and self.private_key != None:
|
||||
ret, encrypted_data = bflb_img_create.encrypt_loader_bin(self._chip_type, file, sign, encrypt, self.encrypt_key, self.encrypt_iv, self.public_key, self.private_key)
|
||||
else:
|
||||
if encrypt == 1and self.encrypt_key != None and self.encrypt_key != None and sign == 0:
|
||||
ret, encrypted_data = bflb_img_create.encrypt_loader_bin(self._chip_type, file, sign, encrypt, self.encrypt_key, self.encrypt_iv, self.public_key, self.private_key)
|
||||
else:
|
||||
if encrypt == 0and sign == 1 and sign == 1 and self.private_key != None:
|
||||
ret, encrypted_data = bflb_img_create.encrypt_loader_bin(self._chip_type, file, sign, encrypt, self.encrypt_key, self.encrypt_iv, self.public_key, self.private_key)
|
||||
else:
|
||||
if encrypt == 1 and sign == 1:
|
||||
bflb_utils.printf('Error: Aes-encrypt and ecc-signature is None!')
|
||||
else:
|
||||
if encrypt == 1 and sign == 0:
|
||||
bflb_utils.printf('Error: Aes-encrypt is None!')
|
||||
else:
|
||||
if encrypt == 0:
|
||||
if sign == 1:
|
||||
bflb_utils.printf('Error: Ecc-signature is None!')
|
||||
return (
|
||||
'', bootinfo)
|
||||
if ret == True:
|
||||
filename, ext = os.path.splitext(file)
|
||||
file_encrypt = filename + '_encrypt' + ext
|
||||
fp = open(file_encrypt, 'wb')
|
||||
fp.write(encrypted_data)
|
||||
fp.close()
|
||||
self._imge_fp = open(file_encrypt, 'rb')
|
||||
else:
|
||||
file = os.path.join(bflb_utils.app_path, file)
|
||||
self._imge_fp = open(file, 'rb')
|
||||
else:
|
||||
file = os.path.join(bflb_utils.app_path, file)
|
||||
self._imge_fp = open(file, 'rb')
|
||||
if self._chip_type == 'wb03':
|
||||
self._imge_fp.read(208)
|
||||
if self._chip_type == 'bl808':
|
||||
ret, dmy = self.boot_process_one_section('808_load_boot_header', 0)
|
||||
else:
|
||||
if self._chip_type == 'bl628':
|
||||
ret, dmy = self.boot_process_one_section('628_load_boot_header', 0)
|
||||
else:
|
||||
if self._chip_type == 'bl616' or self._chip_type == 'wb03':
|
||||
ret, dmy = self.boot_process_one_section('616_load_boot_header', 0)
|
||||
else:
|
||||
if self._chip_type == 'bl702l':
|
||||
ret, dmy = self.boot_process_one_section('702l_load_boot_header', 0)
|
||||
else:
|
||||
ret, dmy = self.boot_process_one_section('load_boot_header', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
if sign != 0:
|
||||
ret, dmy = self.boot_process_one_section('load_publick_key', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
if self._chip_type == 'bl60x' or self._chip_type == 'bl808' or self._chip_type == 'bl628':
|
||||
ret, dmy = self.boot_process_one_section('load_publick_key2', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
ret, dmy = self.boot_process_one_section('load_signature', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
if self._chip_type == 'bl60x' or self._chip_type == 'bl808' or self._chip_type == 'bl628':
|
||||
ret, dmy = self.boot_process_one_section('load_signature2', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
if encrypt != 0:
|
||||
ret, dmy = self.boot_process_one_section('load_aes_iv', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
segs = 0
|
||||
while segs < self._segcnt:
|
||||
send_len = 0
|
||||
segdata_len = 0
|
||||
ret, data_read = self.boot_process_one_section('load_seg_header', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
else:
|
||||
tmp = bflb_utils.bytearray_reverse(data_read[4:8])
|
||||
segdata_len = bflb_utils.bytearray_to_int(tmp)
|
||||
bflb_utils.printf('segdata_len is ', segdata_len)
|
||||
if encrypt == 1:
|
||||
if segdata_len % encrypt_blk_size != 0:
|
||||
segdata_len = segdata_len + encrypt_blk_size - segdata_len % encrypt_blk_size
|
||||
while send_len < segdata_len:
|
||||
left = segdata_len - send_len
|
||||
if left > 4080:
|
||||
left = 4080
|
||||
ret, dmy = self.boot_process_one_section('load_seg_data', left)
|
||||
if ret.startswith('OK') is False:
|
||||
return (ret, bootinfo)
|
||||
send_len = send_len + left
|
||||
bflb_utils.printf(send_len, '/', segdata_len)
|
||||
if self._callback is not None:
|
||||
self._callback(send_len, segdata_len, sys._getframe().f_code.co_name)
|
||||
|
||||
segs = segs + 1
|
||||
|
||||
ret, dmy = self.boot_process_one_section('check_image', 0)
|
||||
return (
|
||||
ret, bootinfo)
|
||||
|
||||
def img_get_bootinfo(self, sh_baudrate, wk_baudrate, callback=None, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, shake_hand_retry=2, isp_mode_sign=False, isp_timeout=0, boot_load=True):
|
||||
bflb_utils.printf('========= image get bootinfo =========')
|
||||
ret = self.img_load_shake_hand(sh_baudrate, wk_baudrate, do_reset, reset_hold_time, shake_hand_delay, reset_revert, cutoff_time, shake_hand_retry, isp_mode_sign, isp_timeout, boot_load)
|
||||
if ret == 'shake hand fail' or ret == 'change rate fail':
|
||||
bflb_utils.printf('shake hand fail')
|
||||
self.bflb_serial_object.close()
|
||||
return (False, b'')
|
||||
time.sleep(0.5)
|
||||
ret, data_read = self.boot_process_one_section('get_boot_info', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
bflb_utils.printf('get_boot_info no ok')
|
||||
return (
|
||||
ret, b'')
|
||||
data_read = binascii.hexlify(data_read)
|
||||
bflb_utils.printf('data read is ', data_read)
|
||||
return (
|
||||
True, data_read)
|
||||
|
||||
def img_loader_reset_cpu(self):
|
||||
bflb_utils.printf('========= reset cpu =========')
|
||||
ret, data_read = self.boot_process_one_section('reset', 0)
|
||||
if ret.startswith('OK') is False:
|
||||
bflb_utils.printf('reset cpu fail')
|
||||
return False
|
||||
return True
|
||||
|
||||
def img_load_process(self, sh_baudrate, wk_baudrate, callback=None, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, shake_hand_retry=2, isp_mode_sign=False, isp_timeout=0, boot_load=True, record_bootinfo=None):
|
||||
bflb_utils.printf('========= image load =========')
|
||||
success = True
|
||||
bootinfo = None
|
||||
try:
|
||||
ret = self.img_load_shake_hand(sh_baudrate, wk_baudrate, do_reset, reset_hold_time, shake_hand_delay, reset_revert, cutoff_time, shake_hand_retry, isp_mode_sign, isp_timeout, boot_load)
|
||||
if ret == 'shake hand fail' or ret == 'change rate fail':
|
||||
bflb_utils.printf('shake hand fail')
|
||||
self.bflb_serial_object.close()
|
||||
return (
|
||||
False, bootinfo, ret)
|
||||
time.sleep(0.01)
|
||||
if self._eflash_loader_file1 is not None:
|
||||
if self._eflash_loader_file1 != '':
|
||||
res, bootinfo = self.img_load_main_process(self._eflash_loader_file1, 0, record_bootinfo)
|
||||
if res.startswith('OK') is False:
|
||||
if res.startswith('repeat_burn') is True:
|
||||
return (False, bootinfo, res)
|
||||
bflb_utils.printf('Img load fail')
|
||||
if res.startswith('error_shakehand') is True:
|
||||
bflb_utils.printf('shakehand with eflash loader found')
|
||||
return (False, bootinfo, res)
|
||||
if self._eflash_loader_file2 is not None:
|
||||
if self._eflash_loader_file2 != '':
|
||||
res, bootinfo = self.img_load_main_process(self._eflash_loader_file2, 1, record_bootinfo)
|
||||
if res.startswith('OK') is False:
|
||||
if res.startswith('repeat_burn') is True:
|
||||
return (False, bootinfo, res)
|
||||
bflb_utils.printf('Img load fail')
|
||||
if res.startswith('error_shakehand') is True:
|
||||
bflb_utils.printf('shakehand with eflash loader found')
|
||||
return (False, bootinfo, res)
|
||||
bflb_utils.printf('Run img')
|
||||
self._imge_fp.close()
|
||||
res, dmy = self.boot_process_one_section('run_image', 0)
|
||||
if res.startswith('OK') is False:
|
||||
bflb_utils.printf('Img run fail')
|
||||
success = False
|
||||
time.sleep(0.1)
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
traceback.print_exc(limit=5, file=(sys.stdout))
|
||||
return (
|
||||
False, bootinfo, '')
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
return (
|
||||
success, bootinfo, '')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
img_load_t = BflbImgLoader()
|
||||
if len(sys.argv) == 3:
|
||||
img_load_t.img_load_process(sys.argv[1], 115200, 115200, sys.argv[2], '')
|
||||
else:
|
||||
if len(sys.argv) == 4:
|
||||
img_load_t.img_load_process(sys.argv[1], 115200, 115200, sys.argv[2], sys.argv[3])
|
||||
# okay decompiling ./libs/base/bflb_img_loader.pyc
|
||||
714
libs/base/bflb_serial.py
Normal file
714
libs/base/bflb_serial.py
Normal file
|
|
@ -0,0 +1,714 @@
|
|||
# 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_serial.py
|
||||
__doc__ = '\nCreated on 20220830\n\n@author: Dillon\n'
|
||||
import re, os, sys, time, serial, struct, pylink, cklink, subprocess
|
||||
from glob import glob
|
||||
from libs.bflb_utils import *
|
||||
from serial.tools.list_ports import comports
|
||||
import config as gol
|
||||
|
||||
class BLSerialUart(object):
|
||||
__doc__ = '\n Bouffalolab serial package\n '
|
||||
|
||||
def __init__(self, rts_state=False, dtr_state=False):
|
||||
self._device = 'COM1'
|
||||
self._baudrate = 115200
|
||||
self._isp_baudrate = 2000000
|
||||
self._ser = None
|
||||
self._shakehand_flag = False
|
||||
self._chiptype = 'bl602'
|
||||
self.rts_state = rts_state
|
||||
self.dtr_state = dtr_state
|
||||
|
||||
def repeat_init(self, device, rate=0, _chip_type='bl602', _chip_name='bl602'):
|
||||
try:
|
||||
if not rate:
|
||||
rate = self._isp_baudrate
|
||||
if self._ser is None:
|
||||
self._baudrate = rate
|
||||
if ' (' in device:
|
||||
dev = device[:device.find(' (')]
|
||||
else:
|
||||
dev = device
|
||||
self._device = dev.upper()
|
||||
for i in range(3):
|
||||
try:
|
||||
self._ser = serial.Serial(dev, rate, timeout=2.0, xonxoff=False, rtscts=False, write_timeout=None, dsrdtr=False)
|
||||
except Exception as error:
|
||||
try:
|
||||
printf(error)
|
||||
time.sleep(1)
|
||||
finally:
|
||||
error = None
|
||||
del error
|
||||
|
||||
else:
|
||||
break
|
||||
|
||||
else:
|
||||
self._ser.baudrate = rate
|
||||
self._baudrate = rate
|
||||
self._602a0_dln_fix = False
|
||||
self._chiptype = _chip_type
|
||||
self._chipname = _chip_name
|
||||
except Exception as e:
|
||||
try:
|
||||
printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def write(self, message):
|
||||
if self._ser:
|
||||
self._ser.write(message)
|
||||
|
||||
def read(self, length=1):
|
||||
try:
|
||||
data = bytearray(0)
|
||||
received = 0
|
||||
while received < length:
|
||||
tmp = self._ser.read(length - received)
|
||||
if len(tmp) == 0:
|
||||
break
|
||||
else:
|
||||
data += tmp
|
||||
received += len(tmp)
|
||||
|
||||
if len(data) != length:
|
||||
return (0, data)
|
||||
return (1, data)
|
||||
except Exception as e:
|
||||
try:
|
||||
printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def raw_read(self):
|
||||
return self._ser.read(self._ser.in_waiting or 1)
|
||||
|
||||
def clear_buf(self):
|
||||
if self._ser:
|
||||
self._ser.read_all()
|
||||
|
||||
def close(self):
|
||||
if self._ser:
|
||||
self._ser.close()
|
||||
|
||||
def _is_bouffalo_chip(self):
|
||||
bl_sign = False
|
||||
if sys.platform.startswith('win'):
|
||||
for port, data, info in comports():
|
||||
if not port:
|
||||
continue
|
||||
if self._device.upper() == port.upper():
|
||||
if not 'VID:PID=42BF:B210' in info.upper():
|
||||
if 'VID:PID=FFFF:FFFF' in info.upper():
|
||||
pass
|
||||
bl_sign = True
|
||||
break
|
||||
|
||||
else:
|
||||
if sys.platform.startswith('linux') or sys.platform.startswith('darwin'):
|
||||
ports = []
|
||||
for port, data, info in comports():
|
||||
if not port:
|
||||
continue
|
||||
if self._device.upper() == port.upper():
|
||||
if not 'PID=FFFF' in info.upper():
|
||||
if 'PID=42BF:B210' in info.upper():
|
||||
pass
|
||||
bl_sign = True
|
||||
break
|
||||
|
||||
return bl_sign
|
||||
|
||||
def bl_usb_serial_write(self, cutoff_time, reset_revert):
|
||||
try:
|
||||
boot_revert = 0
|
||||
printf('usb serial port')
|
||||
if cutoff_time != 0:
|
||||
boot_revert = 0
|
||||
if cutoff_time > 1000:
|
||||
boot_revert = 1
|
||||
data = bytearray()
|
||||
specialstr = string_to_bytearray('BOUFFALOLAB5555RESET')
|
||||
for b in specialstr:
|
||||
data.append(b)
|
||||
|
||||
data.append(boot_revert)
|
||||
data.append(reset_revert)
|
||||
self._ser.write(data)
|
||||
time.sleep(0.05)
|
||||
except Exception as e:
|
||||
try:
|
||||
printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def set_dtr(self, dtr):
|
||||
"""
|
||||
dtr: If dtr is 1, it shows high. If dtr is 0, it shows low.
|
||||
"""
|
||||
try:
|
||||
if sys.platform.startswith('darwin'):
|
||||
self._ser.write(b'BOUFFALOLAB5555DTR' + str(dtr).encode())
|
||||
self.clear_buf()
|
||||
if dtr == 1:
|
||||
self._ser.setDTR(0)
|
||||
else:
|
||||
if dtr == 0:
|
||||
self._ser.setDTR(1)
|
||||
else:
|
||||
bl_sign = self._is_bouffalo_chip()
|
||||
if bl_sign:
|
||||
self._ser.write(b'BOUFFALOLAB5555DTR' + str(dtr).encode())
|
||||
else:
|
||||
if dtr == 1:
|
||||
self._ser.setDTR(0)
|
||||
else:
|
||||
if dtr == 0:
|
||||
self._ser.setDTR(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
def setDTR(self, dtr):
|
||||
self._ser.setDTR(dtr)
|
||||
|
||||
def set_rts(self, rts):
|
||||
"""
|
||||
rts: If rts is 1, it shows high. If rts is 0, it shows low.
|
||||
"""
|
||||
try:
|
||||
if sys.platform.startswith('darwin'):
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS' + str(rts).encode())
|
||||
self.clear_buf()
|
||||
if rts == 1:
|
||||
self._ser.setRTS(0)
|
||||
else:
|
||||
if rts == 0:
|
||||
self._ser.setRTS(1)
|
||||
else:
|
||||
bl_sign = self._is_bouffalo_chip()
|
||||
if bl_sign:
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS' + str(rts).encode())
|
||||
else:
|
||||
if rts == 1:
|
||||
self._ser.setRTS(0)
|
||||
else:
|
||||
if rts == 0:
|
||||
self._ser.setRTS(1)
|
||||
except:
|
||||
pass
|
||||
|
||||
def setRTS(self, rts):
|
||||
self._ser.setRTS(rts)
|
||||
|
||||
def reset(self):
|
||||
if sys.platform.startswith('darwin'):
|
||||
self._ser.write(b'BOUFFALOLAB5555DTR0')
|
||||
time.sleep(0.05)
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS0')
|
||||
time.sleep(0.05)
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS1')
|
||||
self.clear_buf()
|
||||
self._ser.setDTR(1)
|
||||
time.sleep(0.05)
|
||||
self._ser.setRTS(1)
|
||||
time.sleep(0.05)
|
||||
self._ser.setRTS(0)
|
||||
else:
|
||||
bl_sign = self._is_bouffalo_chip()
|
||||
if bl_sign:
|
||||
self._ser.write(b'BOUFFALOLAB5555DTR0')
|
||||
time.sleep(0.05)
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS0')
|
||||
time.sleep(0.05)
|
||||
self._ser.write(b'BOUFFALOLAB5555RTS1')
|
||||
else:
|
||||
self._ser.setDTR(1)
|
||||
time.sleep(0.05)
|
||||
self._ser.setRTS(1)
|
||||
time.sleep(0.05)
|
||||
self._ser.setRTS(0)
|
||||
|
||||
def set_isp_baudrate(self, baudrate):
|
||||
printf('isp mode speed: ', baudrate)
|
||||
self._isp_baudrate = baudrate
|
||||
|
||||
def set_timeout(self, timeout):
|
||||
self._ser.timeout = timeout
|
||||
|
||||
def get_timeout(self):
|
||||
return self._ser.timeout
|
||||
|
||||
def deal_ack(self):
|
||||
try:
|
||||
success, ack = self.read(2)
|
||||
if success == 0:
|
||||
printf('ack is ', str(binascii.hexlify(ack)))
|
||||
return ack.decode('utf-8')
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
return 'OK'
|
||||
if ack.find(b'P') != -1 or ack.find(b'D') != -1:
|
||||
return 'PD'
|
||||
success, err_code = self.read(2)
|
||||
if success == 0:
|
||||
printf('err code is ', str(binascii.hexlify(err_code)))
|
||||
return 'FL'
|
||||
err_code_str = str(binascii.hexlify(err_code[1:2] + err_code[0:1]).decode('utf-8'))
|
||||
ack = 'FL'
|
||||
try:
|
||||
ret = ack + err_code_str + '(' + get_bflb_error_code(err_code_str) + ')'
|
||||
except Exception as e:
|
||||
try:
|
||||
printf(e)
|
||||
ret = ack + err_code_str + ' unknown'
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
printf(ret)
|
||||
return ret
|
||||
except Exception as e:
|
||||
try:
|
||||
printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
def deal_response(self):
|
||||
try:
|
||||
ack = self.deal_ack()
|
||||
if ack == 'OK':
|
||||
success, len_bytes = self.read(2)
|
||||
if success == 0:
|
||||
printf('Get length error')
|
||||
printf('len error is ', binascii.hexlify(len_bytes))
|
||||
return (
|
||||
'Get length error', len_bytes)
|
||||
tmp = bytearray_reverse(len_bytes)
|
||||
data_len = bytearray_to_int(tmp)
|
||||
success, data_bytes = self.read(data_len)
|
||||
if success == 0 or len(data_bytes) != data_len:
|
||||
printf('Read data error,maybe not get excepted length')
|
||||
return (
|
||||
'Read data error,maybe not get excepted length', data_bytes)
|
||||
return (
|
||||
ack, data_bytes)
|
||||
printf('Not ack OK')
|
||||
printf(ack)
|
||||
return (
|
||||
ack, None)
|
||||
except Exception as e:
|
||||
try:
|
||||
printf('Error: %s' % e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
|
||||
class BLSerialJLink(object):
|
||||
|
||||
def __init__(self, device, speed, jlink_shake_hand_addr, jlink_data_addr, jlink_set_tif, jlink_core_type, jlink_run_addr):
|
||||
self.device = device
|
||||
self.speed = speed
|
||||
self.jlink_shake_hand_addr = jlink_shake_hand_addr
|
||||
self.jlink_data_addr = jlink_data_addr
|
||||
self.jlink_run_addr = jlink_run_addr
|
||||
self._rx_timeout = 10000
|
||||
self._chiptype = 'bl602'
|
||||
if sys.platform == 'win32':
|
||||
obj_dll = pylink.Library(dllpath=path_dll)
|
||||
self._jlink = pylink.JLink(lib=obj_dll)
|
||||
self.jlink_path = os.path.join(app_path, 'utils/jlink', 'JLink.exe')
|
||||
else:
|
||||
self._jlink = pylink.JLink()
|
||||
self.jlink_path = 'JLinkExe'
|
||||
match = re.search('\\d{8,10}', device, re.I)
|
||||
if match is not None:
|
||||
self._jlink.open(serial_no=(int(self.device)))
|
||||
else:
|
||||
self._jlink.open()
|
||||
self._jlink.set_tif(jlink_set_tif)
|
||||
self._jlink.connect(jlink_core_type, self.speed)
|
||||
|
||||
def set_chip_type(self, chiptype):
|
||||
self._chiptype = chiptype
|
||||
|
||||
def write(self, message):
|
||||
self.raw_write(self.jlink_data_addr, message)
|
||||
data_list = []
|
||||
data_list.append(int('59445248', 16))
|
||||
self._jlink.memory_write((int(self.jlink_shake_hand_addr, 16)), data_list, nbits=32)
|
||||
|
||||
def raw_write(self, addr, data_send):
|
||||
addr_int = int(addr, 16)
|
||||
len2 = len(data_send) % 4
|
||||
len1 = len(data_send) - len2
|
||||
if len1 != 0:
|
||||
data_list = []
|
||||
for i in range(int(len1 / 4)):
|
||||
data_list.append(data_send[4 * i] + (data_send[4 * i + 1] << 8) + (data_send[4 * i + 2] << 16) + (data_send[4 * i + 3] << 24))
|
||||
|
||||
self._jlink.memory_write(addr_int, data_list, nbits=32)
|
||||
if len2 != 0:
|
||||
data_list = []
|
||||
for i in range(len2):
|
||||
data_list.append(data_send[len1 + i])
|
||||
|
||||
self._jlink.memory_write((addr_int + len1), data_list, nbits=8)
|
||||
|
||||
def raw_write_8(self, addr, data_send):
|
||||
data_list = []
|
||||
for data in data_send:
|
||||
data_list.append(data)
|
||||
|
||||
self._jlink.memory_write((int(addr, 16)), data_list, nbits=8)
|
||||
|
||||
def raw_write_16(self, addr, data_send):
|
||||
data_list = []
|
||||
for i in range(int(len(data_send) / 2)):
|
||||
data_list.append(data_send[2 * i] + (data_send[2 * i + 1] << 8))
|
||||
|
||||
self._jlink.memory_write((int(addr, 16)), data_list, nbits=16)
|
||||
|
||||
def raw_write_32(self, addr, data_send):
|
||||
data_list = []
|
||||
for i in range(int(len(data_send) / 4)):
|
||||
data_list.append(data_send[4 * i] + (data_send[4 * i + 1] << 8) + (data_send[4 * i + 2] << 16) + (data_send[4 * i + 3] << 24))
|
||||
|
||||
self._jlink.memory_write((int(addr, 16)), data_list, nbits=32)
|
||||
|
||||
def read(self, length):
|
||||
start_time = time.time() * 1000
|
||||
while True:
|
||||
ready = self._jlink.memory_read((int(self.jlink_shake_hand_addr, 16)), 1, nbits=32)
|
||||
if len(ready) >= 1:
|
||||
if ready[0] == int('4B434153', 16):
|
||||
break
|
||||
elapsed = time.time() * 1000 - start_time
|
||||
if elapsed >= self._rx_timeout:
|
||||
return 'waiting response time out'.encode('utf-8')
|
||||
else:
|
||||
time.sleep(0.001)
|
||||
|
||||
data = self._raw_read(self.jlink_data_addr, length)
|
||||
if len(data) != length:
|
||||
return (0, data)
|
||||
return (1, data)
|
||||
|
||||
def _raw_read(self, addr, data_len):
|
||||
addr_int = int(addr, 16)
|
||||
if addr_int % 4 == 0:
|
||||
len2 = data_len % 4
|
||||
len1 = data_len - len2
|
||||
data1 = bytearray(0)
|
||||
data2 = bytearray(0)
|
||||
if len1 != 0:
|
||||
data1 = self._jlink.memory_read(addr_int, (int(len1 / 4)), nbits=32)
|
||||
if len2 != 0:
|
||||
data2 = self._jlink.memory_read((addr_int + len1), len2, nbits=8)
|
||||
data = bytearray(0)
|
||||
for tmp in data1:
|
||||
data += int_to_4bytearray_l(tmp)
|
||||
|
||||
data += bytearray(data2)
|
||||
return data
|
||||
return self._raw_read8(addr, data_len)
|
||||
|
||||
def _raw_read8(self, addr, data_len):
|
||||
data = self._jlink.memory_read((int(addr, 16)), data_len, nbits=8)
|
||||
return bytearray(data)
|
||||
|
||||
def _raw_read16(self, addr, data_len):
|
||||
raw_data = self._jlink.memory_read((int(addr, 16)), (data_len / 2), nbits=16)
|
||||
data = bytearray(0)
|
||||
for tmp in raw_data:
|
||||
data += int_to_2bytearray_l(tmp)
|
||||
|
||||
return bytearray(data)
|
||||
|
||||
def _raw_read32(self, addr, data_len):
|
||||
raw_data = self._jlink.memory_read((int(addr, 16)), (data_len / 4), nbits=32)
|
||||
data = bytearray(0)
|
||||
for tmp in raw_data:
|
||||
data += int_to_4bytearray_l(tmp)
|
||||
|
||||
return bytearray(data)
|
||||
|
||||
def set_rx_timeout(self, val):
|
||||
self._rx_timeout = val * 1000
|
||||
|
||||
def halt_cpu(self):
|
||||
if self._jlink.halted() is False:
|
||||
self._jlink.halt()
|
||||
if self._jlink.halted():
|
||||
return True
|
||||
printf("couldn't halt cpu")
|
||||
return False
|
||||
|
||||
def reset_cpu(self, ms=0, halt=True):
|
||||
if self._chiptype != 'bl60x':
|
||||
self._jlink.set_reset_pin_low()
|
||||
self._jlink.set_reset_pin_high()
|
||||
return self._jlink.reset(ms, False)
|
||||
|
||||
def set_pc_msp(self, pc, msp):
|
||||
if self._jlink.halted() is False:
|
||||
self._jlink.halt()
|
||||
if self._jlink.halted():
|
||||
if self._chiptype == 'bl602' or self._chiptype == 'bl702' or self._chiptype == 'bl702l':
|
||||
jlink_script = 'jlink.cmd'
|
||||
fp = open(jlink_script, 'w+')
|
||||
cmd = 'h\r\nSetPC ' + str(self._jlink_run_addr) + '\r\nexit'
|
||||
printf(cmd)
|
||||
fp.write(cmd)
|
||||
fp.close()
|
||||
if self._device:
|
||||
jlink_cmd = self.jlink_path + ' -device RISC-V -Speed {0} -SelectEmuBySN {1} -IF JTAG -jtagconf -1,-1 -autoconnect 1 -CommanderScript jlink.cmd'.format(str(self._speed), str(self._device))
|
||||
else:
|
||||
jlink_cmd = self.jlink_path + ' -device RISC-V -Speed {0} -IF JTAG -jtagconf -1,-1 -autoconnect 1 -CommanderScript jlink.cmd'.format(str(self._speed))
|
||||
printf(jlink_cmd)
|
||||
p = subprocess.Popen(jlink_cmd, shell=True, stdin=(subprocess.PIPE), stdout=(subprocess.PIPE), stderr=(subprocess.PIPE))
|
||||
out, err = p.communicate()
|
||||
printf(out, err)
|
||||
os.remove(jlink_script)
|
||||
else:
|
||||
self._jlink.register_write(15, int(pc, 16))
|
||||
self._jlink.register_write(13, int(msp, 16))
|
||||
self._jlink.restart()
|
||||
else:
|
||||
printf("couldn't halt cpu")
|
||||
|
||||
def shakehand(self, do_reset=False, reset_hold_time=100, shake_hand_delay=100, reset_revert=True, cutoff_time=0, shake_hand_retry=2, isp_timeout=0, boot_load=False):
|
||||
self.write(bytearray(1))
|
||||
success, ack = self.if_read(2)
|
||||
printf(binascii.hexlify(ack))
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
time.sleep(0.03)
|
||||
return 'OK'
|
||||
return 'FL'
|
||||
|
||||
def deal_ack(self):
|
||||
success, ack = self.read(2)
|
||||
if success == 0:
|
||||
printf('ack:' + str(binascii.hexlify(ack)))
|
||||
return ack.decode('utf-8')
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
return 'OK'
|
||||
if ack.find(b'P') != -1 or ack.find(b'D') != -1:
|
||||
return 'PD'
|
||||
success, err_code = self.read(4)
|
||||
if success == 0:
|
||||
printf('err_code:' + str(binascii.hexlify(err_code)))
|
||||
return 'FL'
|
||||
err_code_str = str(binascii.hexlify(err_code[3:4] + err_code[2:3]).decode('utf-8'))
|
||||
ack = 'FL'
|
||||
try:
|
||||
ret = ack + err_code_str + '(' + get_bflb_error_code(err_code_str) + ')'
|
||||
except Exception:
|
||||
ret = ack + err_code_str + ' unknown'
|
||||
|
||||
printf(ret)
|
||||
return ret
|
||||
|
||||
def deal_response(self):
|
||||
ack = self.if_deal_ack()
|
||||
if ack == 'OK':
|
||||
success, len_bytes = self.read(4)
|
||||
if success == 0:
|
||||
printf('Get length error')
|
||||
printf(binascii.hexlify(len_bytes))
|
||||
return (
|
||||
'Get length error', len_bytes)
|
||||
tmp = bytearray_reverse(len_bytes[2:4])
|
||||
data_len = bytearray_to_int(tmp)
|
||||
success, data_bytes = self.read(data_len + 4)
|
||||
if success == 0:
|
||||
printf('Read data error')
|
||||
return (
|
||||
'Read data error', data_bytes)
|
||||
data_bytes = data_bytes[4:]
|
||||
if len(data_bytes) != data_len:
|
||||
printf('Not get excepted length')
|
||||
return (
|
||||
'Not get excepted length', data_bytes)
|
||||
return (ack, data_bytes)
|
||||
printf('Not ack OK')
|
||||
printf(ack)
|
||||
return (
|
||||
ack, None)
|
||||
|
||||
def close(self):
|
||||
self._jlink.close()
|
||||
|
||||
|
||||
class BLSerialCKLink(object):
|
||||
|
||||
def __init__(self, device, serial, speed, rx_timeout, cklink_shake_hand_addr='20000000', cklink_data_addr='20000004', cklink_run_addr='22010000'):
|
||||
self.device = device
|
||||
self.serial = serial
|
||||
self._speed = speed
|
||||
self._rx_timeout = rx_timeout
|
||||
self._inited = False
|
||||
self._cklink_reg_pc = 32
|
||||
self._cklink_shake_hand_addr = cklink_shake_hand_addr
|
||||
self._cklink_data_addr = cklink_data_addr
|
||||
self._cklink_run_addr = cklink_run_addr
|
||||
self._chiptype = 'bl602'
|
||||
self.link = gol.obj_cklink
|
||||
self.temp_init()
|
||||
|
||||
def temp_init(self):
|
||||
if self._inited is False:
|
||||
dev = self.device.split('|')
|
||||
vid = int(dev[0].replace('0x', ''), 16)
|
||||
pid = int(dev[1].replace('0x', ''), 16)
|
||||
printf('SN is ' + str(self.serial))
|
||||
self._cklink_vid = vid
|
||||
self._cklink_pid = pid
|
||||
self._inited = True
|
||||
if not self.link:
|
||||
self.link = cklink.CKLink(dlldir=cklink_dll, vid=(self._cklink_vid), pid=(self._cklink_pid), sn=serial, arch=2, cdi=0)
|
||||
gol.obj_cklink = self.link
|
||||
self.link.open()
|
||||
if self.link.connected():
|
||||
self.link.reset(1)
|
||||
return False
|
||||
|
||||
def set_chip_type(self, chiptype):
|
||||
self._chiptype = chiptype
|
||||
|
||||
def set_rx_timeout(self, val):
|
||||
self._rx_timeout = val * 1000
|
||||
|
||||
def halt_cpu(self):
|
||||
return self.link.halt()
|
||||
|
||||
def resume_cpu(self):
|
||||
return self.link.resume()
|
||||
|
||||
def reset_cpu(self):
|
||||
return self.link.reset(1)
|
||||
|
||||
def set_pc_msp(self):
|
||||
self.halt_cpu()
|
||||
if self._chiptype == 'bl602' or self._chiptype == 'bl702' or self._chiptype == 'bl702l':
|
||||
addr = int(self._cklink_run_addr, 16)
|
||||
self.link.write_cpu_reg(self._cklink_reg_pc, addr)
|
||||
|
||||
def write(self, message):
|
||||
self.if_raw_write(self._cklink_data_addr, message)
|
||||
self.if_raw_write(self._cklink_shake_hand_addr, binascii.unhexlify('48524459'))
|
||||
|
||||
def _raw_write(self, addr, data_send):
|
||||
self.halt_cpu()
|
||||
addr_int = int(addr, 16)
|
||||
data_send = bytes(data_send)
|
||||
self.link.write_memory(addr_int, data_send)
|
||||
self.resume_cpu()
|
||||
|
||||
def read(self, length):
|
||||
start_time = time.time() * 1000
|
||||
while True:
|
||||
self.halt_cpu()
|
||||
ready = self.link.read_memory(int(self._cklink_shake_hand_addr, 16), 4)
|
||||
if len(ready) >= 1:
|
||||
ready = binascii.hexlify(ready).decode()
|
||||
if ready == '5341434b':
|
||||
self.resume_cpu()
|
||||
break
|
||||
elapsed = time.time() * 1000 - start_time
|
||||
if elapsed >= self._rx_timeout:
|
||||
return (0, 'waiting response time out'.encode('utf-8'))
|
||||
else:
|
||||
self.resume_cpu()
|
||||
time.sleep(0.001)
|
||||
|
||||
data = self._raw_read(self._cklink_data_addr, length)
|
||||
if len(data) != length:
|
||||
return (0, data)
|
||||
return (1, data)
|
||||
|
||||
def _raw_read(self, addr, data_len):
|
||||
return self.if_raw_read8(addr, data_len)
|
||||
|
||||
def _raw_read8(self, addr, data_len):
|
||||
self.halt_cpu()
|
||||
data = self.link.read_memory(int(addr, 16), data_len)
|
||||
self.resume_cpu()
|
||||
return bytearray(data)
|
||||
|
||||
def if_shakehand(self):
|
||||
self.if_write(bytearray(1))
|
||||
success, ack = self.read(2)
|
||||
printf(binascii.hexlify(ack))
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
time.sleep(0.03)
|
||||
return 'OK'
|
||||
return 'FL'
|
||||
|
||||
def deal_ack(self):
|
||||
success, ack = self.read(2)
|
||||
if success == 0:
|
||||
printf('ack:' + str(binascii.hexlify(ack)))
|
||||
return ack.decode('utf-8')
|
||||
if ack.find(b'O') != -1 or ack.find(b'K') != -1:
|
||||
return 'OK'
|
||||
if ack.find(b'P') != -1 or ack.find(b'D') != -1:
|
||||
return 'PD'
|
||||
success, err_code = self.if_read(4)
|
||||
if success == 0:
|
||||
printf('err_code:' + str(binascii.hexlify(err_code)))
|
||||
return 'FL'
|
||||
err_code_str = str(binascii.hexlify(err_code[3:4] + err_code[2:3]).decode('utf-8'))
|
||||
ack = 'FL'
|
||||
try:
|
||||
ret = ack + err_code_str + '(' + get_bflb_error_code(err_code_str) + ')'
|
||||
except Exception:
|
||||
ret = ack + err_code_str + ' unknown'
|
||||
|
||||
printf(ret)
|
||||
return ret
|
||||
|
||||
def deal_response(self):
|
||||
ack = self.deal_ack()
|
||||
if ack == 'OK':
|
||||
success, len_bytes = self.read(16)
|
||||
if success == 0:
|
||||
printf('Get length error')
|
||||
printf(binascii.hexlify(len_bytes))
|
||||
return (
|
||||
'Get length error', len_bytes)
|
||||
tmp = bytearray_reverse(len_bytes[2:4])
|
||||
data_len = bytearray_to_int(tmp)
|
||||
success, data_bytes = self.if_read(data_len + 4)
|
||||
if success == 0:
|
||||
printf('Read data error')
|
||||
return (
|
||||
'Read data error', data_bytes)
|
||||
data_bytes = data_bytes[4:]
|
||||
if len(data_bytes) != data_len:
|
||||
printf('Not get excepted length')
|
||||
return (
|
||||
'Not get excepted length', data_bytes)
|
||||
return (ack, data_bytes)
|
||||
printf('Not ack OK')
|
||||
printf(ack)
|
||||
return (
|
||||
ack, None)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
print(pylink_enumerate())
|
||||
ls = BLSerialUart('COM28', 2000000, '4201BFF0', '4201C000', 0, 'RISC-V', '22010000')
|
||||
ls.set_dtr(0)
|
||||
time.sleep(10)
|
||||
ls.set_dtr(1)
|
||||
ls.close()
|
||||
# okay decompiling ./libs/base/bflb_serial.pyc
|
||||
331
libs/base/bl602/bootheader_cfg_keys.py
Normal file
331
libs/base/bl602/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,331 @@
|
|||
# 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/bl602/bootheader_cfg_keys.py
|
||||
bootheader_len = 176
|
||||
bootheader_cfg_keys = {'magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':'12',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':'12',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':'12',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':'16',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':'16',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':'16',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':'20',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_cmd':{'offset':'20',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_dmy_clk':{'offset':'20',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':'28',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':'28',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':'28',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':'32',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':'32',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':'32',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':'36',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_cmd':{'offset':'40',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_dmy_clk':{'offset':'40',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_cmd':{'offset':'40',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_dmy_clk':{'offset':'40',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_cmd':{'offset':'44',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_dmy_clk':{'offset':'44',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_cmd':{'offset':'44',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_dmy_clk':{'offset':'44',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_cmd':{'offset':'48',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_dmy_clk':{'offset':'48',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_page_prog_cmd':{'offset':'48',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'write_vreg_enable_cmd':{'offset':'48',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_index':{'offset':'52',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_index':{'offset':'52',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_index':{'offset':'52',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_bit_pos':{'offset':'52',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_bit_pos':{'offset':'56',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'busy_bit_pos':{'offset':'56',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_write_len':{'offset':'56',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_read_len':{'offset':'56',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_write_len':{'offset':'60',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_read_len':{'offset':'60',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'release_power_down':{'offset':'60',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_read_len':{'offset':'60',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd0':{'offset':'64',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd1':{'offset':'64',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd0':{'offset':'68',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd1':{'offset':'68',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_qpi_cmd':{'offset':'72',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'exit_qpi_cmd':{'offset':'72',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'cont_read_code':{'offset':'72',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'cont_read_exit_code':{'offset':'72',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_cmd':{'offset':'76',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_dmy_clk':{'offset':'76',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_data_mode':{'offset':'76',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_code':{'offset':'76',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd':{'offset':'80',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd_dmy_clk':{'offset':'80',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code_mode':{'offset':'80',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code':{'offset':'80',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_time':{'offset':'84',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'blk32k_erase_time':{'offset':'84',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'blk64k_erase_time':{'offset':'88',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'page_prog_time':{'offset':'88',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_time':{'offset':'92',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'power_down_delay':{'offset':'92',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qe_data':{'offset':'92',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flashcfg_crc32':{'offset':'96',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'clkcfg_magic_code':{'offset':'100',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'xtal_type':{'offset':'104',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'pll_clk':{'offset':'104',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'hclk_div':{'offset':'104',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'bclk_div':{'offset':'104',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_type':{'offset':'108',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_div':{'offset':'108',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'clkcfg_crc32':{'offset':'112',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'sign':{'offset':'116',
|
||||
'pos':'0',
|
||||
'bitlen':'2'},
|
||||
'encrypt_type':{'offset':'116',
|
||||
'pos':'2',
|
||||
'bitlen':'2'},
|
||||
'key_sel':{'offset':'116',
|
||||
'pos':'4',
|
||||
'bitlen':'2'},
|
||||
'no_segment':{'offset':'116',
|
||||
'pos':'8',
|
||||
'bitlen':'1'},
|
||||
'cache_enable':{'offset':'116',
|
||||
'pos':'9',
|
||||
'bitlen':'1'},
|
||||
'notload_in_bootrom':{'offset':'116',
|
||||
'pos':'10',
|
||||
'bitlen':'1'},
|
||||
'aes_region_lock':{'offset':'116',
|
||||
'pos':'11',
|
||||
'bitlen':'1'},
|
||||
'cache_way_disable':{'offset':'116',
|
||||
'pos':'12',
|
||||
'bitlen':'4'},
|
||||
'crc_ignore':{'offset':'116',
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'hash_ignore':{'offset':'116',
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'img_len':{'offset':'120',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'bootentry':{'offset':'124',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'img_start':{'offset':'128',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_0':{'offset':'132',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_1':{'offset':'136',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_2':{'offset':'140',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_3':{'offset':'144',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_4':{'offset':'148',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_5':{'offset':'152',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_6':{'offset':'156',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_7':{'offset':'160',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'crc32':{'offset':'172',
|
||||
'pos':'0',
|
||||
'bitlen':'32'}}
|
||||
# okay decompiling ./libs/base/bl602/bootheader_cfg_keys.pyc
|
||||
12
libs/base/bl602/cklink_load_cfg.py
Normal file
12
libs/base/bl602/cklink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl602/cklink_load_cfg.py
|
||||
cklink_shake_hand_addr = '4201BFF0'
|
||||
cklink_data_addr = '4201C000'
|
||||
cklink_load_addr = '22010000'
|
||||
cklink_core_type = 'RISC-V'
|
||||
cklink_set_tif = 0
|
||||
cklink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl602/cklink_load_cfg.pyc
|
||||
64
libs/base/bl602/flash_select_do.py
Normal file
64
libs/base/bl602/flash_select_do.py
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
# 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/bl602/flash_select_do.py
|
||||
import os, config as gol
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, conf_sign
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
|
||||
def get_suitable_file_name(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:
|
||||
bflb_utils.printf('Flash id duplicate and alternative is:')
|
||||
for i in range(len(conf_files)):
|
||||
tmp = conf_files[i].split('.')[0]
|
||||
bflb_utils.printf('%d:%s' % (i + 1, tmp))
|
||||
|
||||
return conf_files[i]
|
||||
if len(conf_files) == 1:
|
||||
return conf_files[0]
|
||||
return ''
|
||||
|
||||
|
||||
def update_flash_cfg_do(chipname, chiptype, flash_id, file=None, create=False, section=None):
|
||||
if conf_sign:
|
||||
cfg_dir = app_path + '/utils/flash/' + chipname + '/'
|
||||
else:
|
||||
cfg_dir = app_path + '/utils/flash/' + gol.flash_dict[chipname] + '/'
|
||||
conf_name = get_suitable_file_name(cfg_dir, flash_id)
|
||||
value_key = []
|
||||
if os.path.isfile(cfg_dir + conf_name) is False:
|
||||
return False
|
||||
fp = open(cfg_dir + conf_name, 'r')
|
||||
for line in fp.readlines():
|
||||
value = line.split('=')[0].strip()
|
||||
if value == '[FLASH_CFG]':
|
||||
continue
|
||||
else:
|
||||
value_key.append(value)
|
||||
|
||||
cfg1 = BFConfigParser()
|
||||
cfg1.read(cfg_dir + conf_name)
|
||||
cfg2 = BFConfigParser()
|
||||
cfg2.read(file)
|
||||
for i in range(len(value_key)):
|
||||
if cfg1.has_option('FLASH_CFG', value_key[i]):
|
||||
if cfg2.has_option(section, value_key[i]):
|
||||
tmp_value = cfg1.get('FLASH_CFG', value_key[i])
|
||||
bflb_utils.update_cfg(cfg2, section, value_key[i], tmp_value)
|
||||
|
||||
cfg2.write(file, 'w+')
|
||||
bflb_utils.printf('Update flash cfg finished')
|
||||
|
||||
|
||||
def get_supported_flash_do():
|
||||
flash_type = []
|
||||
return flash_type
|
||||
# okay decompiling ./libs/base/bl602/flash_select_do.pyc
|
||||
524
libs/base/bl602/img_create_do.py
Normal file
524
libs/base/bl602/img_create_do.py
Normal file
|
|
@ -0,0 +1,524 @@
|
|||
# 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/bl602/img_create_do.py
|
||||
import hashlib, binascii, ecdsa
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import open_file, img_create_sha256_data, img_create_encrypt_data
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl602.bootheader_cfg_keys import bootheader_len as header_len
|
||||
keyslot0 = 28
|
||||
keyslot1 = keyslot0 + 16
|
||||
keyslot2 = keyslot1 + 16
|
||||
keyslot3 = keyslot2 + 16
|
||||
keyslot4 = keyslot3 + 16
|
||||
keyslot5 = keyslot4 + 16
|
||||
keyslot6 = keyslot5 + 16
|
||||
wr_lock_key_slot_4_l = 13
|
||||
wr_lock_key_slot_5_l = 14
|
||||
wr_lock_boot_mode = 15
|
||||
wr_lock_dbg_pwd = 16
|
||||
wr_lock_sw_usage_0 = 17
|
||||
wr_lock_wifi_mac = 18
|
||||
wr_lock_key_slot_0 = 19
|
||||
wr_lock_key_slot_1 = 20
|
||||
wr_lock_key_slot_2 = 21
|
||||
wr_lock_key_slot_3 = 22
|
||||
wr_lock_key_slot_4_h = 23
|
||||
wr_lock_key_slot_5_h = 24
|
||||
rd_lock_dbg_pwd = 25
|
||||
rd_lock_key_slot_0 = 26
|
||||
rd_lock_key_slot_1 = 27
|
||||
rd_lock_key_slot_2 = 28
|
||||
rd_lock_key_slot_3 = 29
|
||||
rd_lock_key_slot_4 = 30
|
||||
rd_lock_key_slot_5 = 31
|
||||
|
||||
def img_update_efuse(cfg, sign, pk_hash, flash_encryp_type, flash_key, sec_eng_key_sel, sec_eng_key, security=False):
|
||||
efuse_data = bytearray(128)
|
||||
efuse_mask_data = bytearray(128)
|
||||
if cfg != None:
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'rb')
|
||||
efuse_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'rb')
|
||||
efuse_mask_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
mask_4bytes = bytearray.fromhex('FFFFFFFF')
|
||||
efuse_data[0] |= flash_encryp_type
|
||||
efuse_data[0] |= sign << 2
|
||||
if flash_encryp_type > 0:
|
||||
efuse_data[0] |= 128
|
||||
efuse_data[0] |= 48
|
||||
efuse_mask_data[0] |= 255
|
||||
rw_lock = 0
|
||||
if pk_hash is not None:
|
||||
efuse_data[keyslot0:keyslot2] = pk_hash
|
||||
efuse_mask_data[keyslot0:keyslot2] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_0
|
||||
rw_lock |= 1 << wr_lock_key_slot_1
|
||||
if flash_key is not None:
|
||||
if flash_encryp_type == 1:
|
||||
efuse_data[keyslot2:keyslot3] = flash_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
else:
|
||||
if flash_encryp_type == 2:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
else:
|
||||
if flash_encryp_type == 3:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if sec_eng_key is not None:
|
||||
if flash_encryp_type == 0:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot3:keyslot4] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot4] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if flash_encryp_type == 1:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_4
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_4
|
||||
efuse_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
efuse_mask_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
if cfg != None:
|
||||
if security is True:
|
||||
bflb_utils.printf('Encrypt efuse data')
|
||||
security_key, security_iv = bflb_utils.get_security_key()
|
||||
efuse_data = img_create_encrypt_data(efuse_data, security_key, security_iv, 0)
|
||||
efuse_data = bytearray(4096) + efuse_data
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'wb+')
|
||||
fp.write(efuse_mask_data)
|
||||
fp.close()
|
||||
return efuse_data
|
||||
|
||||
|
||||
def img_create_get_sign_encrypt_info(bootheader_data):
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
return (
|
||||
sign, encrypt, key_sel)
|
||||
|
||||
|
||||
def img_create_get_hash_ignore(bootheader_data):
|
||||
return bootheader_data[118] >> 1 & 1
|
||||
|
||||
|
||||
def img_create_get_crc_ignore(bootheader_data):
|
||||
return bootheader_data[118] & 1
|
||||
|
||||
|
||||
def img_create_update_bootheader_if(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
if bootheader_data[118] >> 1 & 1 == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if bootheader_data[118] & 1 == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data
|
||||
|
||||
|
||||
def img_create_update_bootheader(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
if img_create_get_hash_ignore(bootheader_data) == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if img_create_get_crc_ignore(bootheader_data) == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data[0:header_len]
|
||||
|
||||
|
||||
def img_create_update_segheader(segheader, segdatalen, segdatacrc):
|
||||
segheader[4:8] = segdatalen
|
||||
segheader[8:12] = segdatacrc
|
||||
return segheader
|
||||
|
||||
|
||||
def img_create_sign_data(data_bytearray, privatekey_file_uecc, publickey_file):
|
||||
sk = ecdsa.SigningKey.from_pem(open(privatekey_file_uecc).read())
|
||||
vk = ecdsa.VerifyingKey.from_pem(open(publickey_file).read())
|
||||
pk_data = vk.to_string()
|
||||
bflb_utils.printf('Private key: ', binascii.hexlify(sk.to_string()))
|
||||
bflb_utils.printf('Public key: ', binascii.hexlify(pk_data))
|
||||
pk_hash = img_create_sha256_data(pk_data)
|
||||
bflb_utils.printf('Public key hash=', binascii.hexlify(pk_hash))
|
||||
signature = sk.sign(data_bytearray, hashfunc=(hashlib.sha256), sigencode=(ecdsa.util.sigencode_string))
|
||||
bflb_utils.printf('Signature=', binascii.hexlify(signature))
|
||||
len_array = bflb_utils.int_to_4bytearray_l(len(signature))
|
||||
sig_field = len_array + signature
|
||||
crcarray = bflb_utils.get_crc32_bytearray(sig_field)
|
||||
return (
|
||||
pk_data, pk_hash, sig_field + crcarray)
|
||||
|
||||
|
||||
def img_create_read_file_append_crc(file, crc):
|
||||
fp = open(file, 'rb')
|
||||
read_data = bytearray(fp.read())
|
||||
crcarray = bytearray(0)
|
||||
if crc:
|
||||
crcarray = bflb_utils.get_crc32_bytearray(read_data)
|
||||
fp.close()
|
||||
return read_data + crcarray
|
||||
|
||||
|
||||
def encrypt_loader_bin_do(file, sign, encrypt, temp_encrypt_key, temp_encrypt_iv, publickey_file, privatekey_file):
|
||||
if encrypt != 0 or sign != 0:
|
||||
encrypt_key = bytearray(0)
|
||||
encrypt_iv = bytearray(0)
|
||||
load_helper_bin_header = bytearray(0)
|
||||
load_helper_bin_body = bytearray(0)
|
||||
offset = 116
|
||||
sign_pos = 0
|
||||
encrypt_type_pos = 2
|
||||
key_sel_pos = 4
|
||||
pk_data = bytearray(0)
|
||||
signature = bytearray(0)
|
||||
aesiv_data = bytearray(0)
|
||||
data_tohash = bytearray(0)
|
||||
with open(file, 'rb') as fp:
|
||||
load_helper_bin = fp.read()
|
||||
load_helper_bin_header = load_helper_bin[0:header_len]
|
||||
load_helper_bin_body = load_helper_bin[header_len:]
|
||||
if load_helper_bin_header != bytearray(0):
|
||||
if load_helper_bin_body != bytearray(0):
|
||||
load_helper_bin_body = bflb_utils.add_to_16(load_helper_bin_body)
|
||||
if encrypt != 0:
|
||||
encrypt_key = bflb_utils.hexstr_to_bytearray(temp_encrypt_key)
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(temp_encrypt_iv)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
load_helper_bin_body_encrypt = bflb_utils.img_create_encrypt_data(load_helper_bin_body, encrypt_key, encrypt_iv, 0)
|
||||
else:
|
||||
load_helper_bin_body_encrypt = load_helper_bin_body
|
||||
data = bytearray(load_helper_bin_header)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = oldval
|
||||
if encrypt != 0:
|
||||
newval = newval | 1 << encrypt_type_pos
|
||||
newval = newval | 0 << key_sel_pos
|
||||
if sign != 0:
|
||||
newval = newval | 1 << sign_pos
|
||||
data_tohash += load_helper_bin_body_encrypt
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
load_helper_bin_header = data
|
||||
load_helper_bin_encrypt = load_helper_bin_header + pk_data + signature + aesiv_data + load_helper_bin_body_encrypt
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
load_helper_bin_data = bytearray(load_helper_bin_encrypt)
|
||||
load_helper_bin_encrypt = img_create_update_bootheader_if(load_helper_bin_data, hash, 1)
|
||||
return (
|
||||
True, load_helper_bin_encrypt)
|
||||
return (False, None)
|
||||
|
||||
|
||||
def create_encryptandsign_flash_data(data, offset, key, iv, publickey, privatekey):
|
||||
encrypt = 0
|
||||
encrypt_type = 0
|
||||
sign = 0
|
||||
data_len = len(data)
|
||||
aesiv_data = bytearray(0)
|
||||
pk_data = bytearray(0)
|
||||
data_tohash = bytearray(0)
|
||||
efuse_data = bytearray(128)
|
||||
bootheader_data = data[0:176]
|
||||
img_len = bflb_utils.bytearray_to_int(data[120:121]) + (bflb_utils.bytearray_to_int(data[121:122]) << 8) + (bflb_utils.bytearray_to_int(data[122:123]) << 16) + (bflb_utils.bytearray_to_int(data[123:124]) << 24)
|
||||
img_data = data[offset:offset + img_len]
|
||||
if key:
|
||||
if iv:
|
||||
encrypt = 1
|
||||
if len(key) == 32:
|
||||
encrypt_type = 1
|
||||
else:
|
||||
if len(key) == 64:
|
||||
encrypt_type = 2
|
||||
else:
|
||||
if len(key) == 48:
|
||||
encrypt_type = 3
|
||||
bootheader_data[116] |= encrypt_type
|
||||
if publickey:
|
||||
if privatekey:
|
||||
sign = 1
|
||||
bootheader_data[116] |= 4
|
||||
if encrypt:
|
||||
encrypt_key = bflb_utils.hexstr_to_bytearray(key)
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(iv)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
mfgBin = False
|
||||
if img_data[img_len - 16:img_len - 12] == bytearray('0mfg'.encode('utf-8')):
|
||||
bflb_utils.printf('mfg bin')
|
||||
mfgBin = True
|
||||
data_toencrypt = bytearray(0)
|
||||
if mfgBin:
|
||||
data_toencrypt += img_data[:img_len - 16]
|
||||
else:
|
||||
data_toencrypt += img_data
|
||||
if encrypt:
|
||||
data_toencrypt = img_create_encrypt_data(data_toencrypt, encrypt_key, encrypt_iv, 1)
|
||||
if mfgBin:
|
||||
data_toencrypt += img_data[img_len - 16:img_len]
|
||||
fw_data = bytearray(0)
|
||||
data_tohash += data_toencrypt
|
||||
fw_data = data_toencrypt
|
||||
seg_cnt = len(data_toencrypt)
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
bootheader_data = img_create_update_bootheader(bootheader_data, hash, seg_cnt)
|
||||
signature = bytearray(0)
|
||||
pk_hash = None
|
||||
if sign:
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey, publickey)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
bflb_utils.printf('Write flash img')
|
||||
bootinfo = bootheader_data + pk_data + signature + aesiv_data
|
||||
output_data = bytearray(data_len)
|
||||
for i in range(data_len):
|
||||
output_data[i] = 255
|
||||
|
||||
output_data[0:len(bootinfo)] = bootinfo
|
||||
output_data[offset:offset + seg_cnt] = fw_data
|
||||
if encrypt != 0:
|
||||
if encrypt_type == 1:
|
||||
efuse_data = img_update_efuse(None, sign, pk_hash, 1, encrypt_key + bytearray(32 - len(encrypt_key)), 0, encrypt_key + bytearray(32 - len(encrypt_key)))
|
||||
if encrypt_type == 2:
|
||||
efuse_data = img_update_efuse(None, sign, pk_hash, 3, encrypt_key + bytearray(32 - len(encrypt_key)), 0, encrypt_key + bytearray(32 - len(encrypt_key)))
|
||||
if encrypt_type == 3:
|
||||
efuse_data = img_update_efuse(None, sign, pk_hash, 2, encrypt_key + bytearray(32 - len(encrypt_key)), 0, encrypt_key + bytearray(32 - len(encrypt_key)))
|
||||
return (
|
||||
output_data, efuse_data, seg_cnt)
|
||||
|
||||
|
||||
def img_creat_process(flash_img, cfg, security=False):
|
||||
encrypt_blk_size = 16
|
||||
padding = bytearray(encrypt_blk_size)
|
||||
data_tohash = bytearray(0)
|
||||
cfg_section = 'Img_Cfg'
|
||||
segheader_file = []
|
||||
if flash_img == 0:
|
||||
for files in cfg.get(cfg_section, 'segheader_file').split(' '):
|
||||
segheader_file.append(str(files))
|
||||
|
||||
segdata_file = []
|
||||
for files in cfg.get(cfg_section, 'segdata_file').split('|'):
|
||||
segdata_file.append(str(files))
|
||||
if flash_img == 1:
|
||||
break
|
||||
|
||||
boot_header_file = cfg.get(cfg_section, 'boot_header_file')
|
||||
bootheader_data = img_create_read_file_append_crc(boot_header_file, 0)
|
||||
encrypt = 0
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
aesiv_data = bytearray(0)
|
||||
pk_data = bytearray(0)
|
||||
if sign != 0:
|
||||
bflb_utils.printf('Image need sign')
|
||||
publickey_file = cfg.get(cfg_section, 'publickey_file')
|
||||
privatekey_file_uecc = cfg.get(cfg_section, 'privatekey_file_uecc')
|
||||
if encrypt != 0:
|
||||
bflb_utils.printf('Image need encrypt ', encrypt)
|
||||
encrypt_key_org = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_key_org'))
|
||||
if encrypt == 1:
|
||||
encrypt_key = encrypt_key_org[0:16]
|
||||
else:
|
||||
if encrypt == 2:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
if encrypt == 3:
|
||||
encrypt_key = encrypt_key_org[0:24]
|
||||
bflb_utils.printf('Key= ', binascii.hexlify(encrypt_key))
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_iv'))
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
seg_cnt = len(segheader_file)
|
||||
if flash_img == 0:
|
||||
if seg_cnt != len(segdata_file):
|
||||
bflb_utils.printf('Segheader count and segdata count not match')
|
||||
return (
|
||||
'FAIL', data_tohash)
|
||||
mfgBin = False
|
||||
data_toencrypt = bytearray(0)
|
||||
if flash_img == 0:
|
||||
i = 0
|
||||
seg_header_list = []
|
||||
seg_data_list = []
|
||||
while i < seg_cnt:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[i], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
else:
|
||||
segdata_crcarray = bflb_utils.get_crc32_bytearray(seg_data)
|
||||
seg_data_list.append(seg_data)
|
||||
seg_header = img_create_read_file_append_crc(segheader_file[i], 0)
|
||||
seg_header = img_create_update_segheader(seg_header, bflb_utils.int_to_4bytearray_l(len(seg_data)), segdata_crcarray)
|
||||
segheader_crcarray = bflb_utils.get_crc32_bytearray(seg_header)
|
||||
seg_header = seg_header + segheader_crcarray
|
||||
seg_header_list.append(seg_header)
|
||||
i = i + 1
|
||||
|
||||
i = 0
|
||||
while i < seg_cnt:
|
||||
data_toencrypt += seg_header_list[i]
|
||||
data_toencrypt += seg_data_list[i]
|
||||
i += 1
|
||||
|
||||
else:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[0], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
if seg_data[len(seg_data) - 16:len(seg_data) - 12] == bytearray('0mfg'.encode('utf-8')):
|
||||
mfgBin = True
|
||||
if mfgBin:
|
||||
data_toencrypt += seg_data[:len(seg_data) - 16]
|
||||
else:
|
||||
data_toencrypt += seg_data
|
||||
seg_cnt = len(data_toencrypt)
|
||||
if mfgBin:
|
||||
seg_cnt += 16
|
||||
if encrypt != 0:
|
||||
data_toencrypt = img_create_encrypt_data(data_toencrypt, encrypt_key, encrypt_iv, flash_img)
|
||||
if mfgBin:
|
||||
data_toencrypt += seg_data[len(seg_data) - 16:len(seg_data)]
|
||||
fw_data = bytearray(0)
|
||||
data_tohash += data_toencrypt
|
||||
fw_data = data_toencrypt
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
bootheader_data = img_create_update_bootheader(bootheader_data, hash, seg_cnt)
|
||||
signature = bytearray(0)
|
||||
pk_hash = None
|
||||
if sign == 1:
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file_uecc, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
if flash_img == 1:
|
||||
bflb_utils.printf('Write flash img')
|
||||
bootinfo_file_name = cfg.get(cfg_section, 'bootinfo_file')
|
||||
fp = open(bootinfo_file_name, 'wb+')
|
||||
bootinfo = bootheader_data + pk_data + signature + aesiv_data
|
||||
fp.write(bootinfo)
|
||||
fp.close()
|
||||
fw_file_name = cfg.get(cfg_section, 'img_file')
|
||||
fp = open(fw_file_name, 'wb+')
|
||||
fp.write(fw_data)
|
||||
fp.close()
|
||||
fw_data_hash = img_create_sha256_data(fw_data)
|
||||
fp = open(fw_file_name.replace('.bin', '_withhash.bin'), 'wb+')
|
||||
fp.write(fw_data + fw_data_hash)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, encrypt, None, key_sel, None, security)
|
||||
else:
|
||||
bflb_utils.printf('Write if img')
|
||||
whole_img_file_name = cfg.get(cfg_section, 'whole_img_file')
|
||||
fp = open(whole_img_file_name, 'wb+')
|
||||
img_data = bootheader_data + pk_data + signature + aesiv_data + fw_data
|
||||
fp.write(img_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, 0, None, key_sel, bytearray(32), security)
|
||||
return (
|
||||
'OK', data_tohash)
|
||||
|
||||
|
||||
def img_create_do(args, img_dir_path=None, config_file=None):
|
||||
bflb_utils.printf('Image create path: ', img_dir_path)
|
||||
if config_file is None:
|
||||
config_file = img_dir_path + '/img_create_cfg.ini'
|
||||
bflb_utils.printf('Config file: ', config_file)
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
img_type = 'media'
|
||||
signer = 'none'
|
||||
security = False
|
||||
data_tohash = bytearray(0)
|
||||
try:
|
||||
if args.image:
|
||||
img_type = args.image
|
||||
if args.signer:
|
||||
signer = args.signer
|
||||
if args.security:
|
||||
security = args.security == 'efuse'
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
if img_type == 'media':
|
||||
flash_img = 1
|
||||
else:
|
||||
flash_img = 0
|
||||
ret, data_tohash = img_creat_process(flash_img, cfg, security)
|
||||
if ret != 'OK':
|
||||
bflb_utils.printf('Fail to create images!')
|
||||
|
||||
|
||||
def create_sp_media_image(config, cpu_type=None, security=False):
|
||||
bflb_utils.printf('========= sp image create =========')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config)
|
||||
img_creat_process(1, cfg, security)
|
||||
# okay decompiling ./libs/base/bl602/img_create_do.pyc
|
||||
12
libs/base/bl602/jlink_load_cfg.py
Normal file
12
libs/base/bl602/jlink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl602/jlink_load_cfg.py
|
||||
jlink_shake_hand_addr = '4201BFF0'
|
||||
jlink_data_addr = '4201C000'
|
||||
jlink_load_addr = '22010000'
|
||||
jlink_core_type = 'RISC-V'
|
||||
jlink_set_tif = 0
|
||||
jlink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl602/jlink_load_cfg.pyc
|
||||
12
libs/base/bl602/openocd_load_cfg.py
Normal file
12
libs/base/bl602/openocd_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl602/openocd_load_cfg.py
|
||||
openocd_shake_hand_addr = '4201BFF0'
|
||||
openocd_data_addr = '4201C000'
|
||||
openocd_load_addr = '22010000'
|
||||
openocd_core_type = 'RISC-V'
|
||||
openocd_set_tif = 0
|
||||
openocd_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl602/openocd_load_cfg.pyc
|
||||
482
libs/base/bl616/bootheader_cfg_keys.py
Normal file
482
libs/base/bl616/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,482 @@
|
|||
# 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/bl616/bootheader_cfg_keys.py
|
||||
clock_start_pos = 100
|
||||
bootcfg_start_pos = 120
|
||||
bootcfg_len = 48
|
||||
bootcpucfg_start_pos = bootcfg_start_pos + bootcfg_len
|
||||
bootcpucfg_len = 16
|
||||
bootcpucfg_m0_index = 0
|
||||
bootcpucfg_d0_index = 1
|
||||
bootcpucfg_lp_index = 2
|
||||
boot2_start_pos = bootcpucfg_start_pos + bootcpucfg_len * (bootcpucfg_m0_index + 1)
|
||||
boot2_len = 8
|
||||
flashcfg_table_start_pos = boot2_start_pos + boot2_len
|
||||
flashcfg_table_len = 8
|
||||
patch_on_read_start_pos = flashcfg_table_start_pos + flashcfg_table_len
|
||||
patch_on_read_len = 24
|
||||
patch_on_jump_start_pos = patch_on_read_start_pos + patch_on_read_len
|
||||
patch_on_jump_len = 24
|
||||
rsvd_start_pos = patch_on_jump_start_pos + patch_on_jump_len
|
||||
rsvd_len = 4
|
||||
crc32_start_pos = rsvd_start_pos + rsvd_len
|
||||
bootheader_len = crc32_start_pos + 4
|
||||
bootheader_cfg_keys = {'magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':'12',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':'12',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':'12',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':'16',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':'16',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':'16',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':'20',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_32bits_addr_cmd':{'offset':'20',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_32bits_addr_clk':{'offset':'20',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':'28',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':'28',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':'28',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':'32',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':'32',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':'32',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':'36',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_cmd':{'offset':'40',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_dmy_clk':{'offset':'40',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_cmd':{'offset':'40',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_dmy_clk':{'offset':'40',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_cmd':{'offset':'44',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_dmy_clk':{'offset':'44',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_cmd':{'offset':'44',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_dmy_clk':{'offset':'44',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_cmd':{'offset':'48',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_dmy_clk':{'offset':'48',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_page_prog_cmd':{'offset':'48',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'write_vreg_enable_cmd':{'offset':'48',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_index':{'offset':'52',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_index':{'offset':'52',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_index':{'offset':'52',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_bit_pos':{'offset':'52',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_bit_pos':{'offset':'56',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'busy_bit_pos':{'offset':'56',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_write_len':{'offset':'56',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_read_len':{'offset':'56',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_write_len':{'offset':'60',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_read_len':{'offset':'60',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'release_power_down':{'offset':'60',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_read_len':{'offset':'60',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd0':{'offset':'64',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd1':{'offset':'64',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd0':{'offset':'68',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd1':{'offset':'68',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_qpi_cmd':{'offset':'72',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'exit_qpi_cmd':{'offset':'72',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'cont_read_code':{'offset':'72',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'cont_read_exit_code':{'offset':'72',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_cmd':{'offset':'76',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_dmy_clk':{'offset':'76',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_data_mode':{'offset':'76',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_code':{'offset':'76',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd':{'offset':'80',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd_dmy_clk':{'offset':'80',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code_mode':{'offset':'80',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code':{'offset':'80',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_time':{'offset':'84',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'blk32k_erase_time':{'offset':'84',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'blk64k_erase_time':{'offset':'88',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'page_prog_time':{'offset':'88',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_time':{'offset':'92',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'power_down_delay':{'offset':'92',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qe_data':{'offset':'92',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flashcfg_crc32':{'offset':'96',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'clkcfg_magic_code':{'offset':str(int(clock_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'xtal_type':{'offset':str(int(clock_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mcu_clk':{'offset':str(int(clock_start_pos) + 4),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'mcu_clk_div':{'offset':str(int(clock_start_pos) + 4),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'mcu_bclk_div':{'offset':str(int(clock_start_pos) + 4),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'mcu_pbclk_div':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'emi_clk':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'emi_clk_div':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_type':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_div':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'wifipll_pu':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'aupll_pu':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'rsvd0':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'clkcfg_crc32':{'offset':str(int(clock_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'sign':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'2'},
|
||||
'encrypt_type':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'2',
|
||||
'bitlen':'2'},
|
||||
'key_sel':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'4',
|
||||
'bitlen':'2'},
|
||||
'xts_mode':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'6',
|
||||
'bitlen':'1'},
|
||||
'aes_region_lock':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'7',
|
||||
'bitlen':'1'},
|
||||
'no_segment':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'8',
|
||||
'bitlen':'1'},
|
||||
'boot2_enable':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'9',
|
||||
'bitlen':'1'},
|
||||
'boot2_rollback':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'10',
|
||||
'bitlen':'1'},
|
||||
'cpu_master_id':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'11',
|
||||
'bitlen':'4'},
|
||||
'notload_in_bootrom':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'15',
|
||||
'bitlen':'1'},
|
||||
'crc_ignore':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'hash_ignore':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'power_on_mm':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'18',
|
||||
'bitlen':'1'},
|
||||
'em_sel':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'19',
|
||||
'bitlen':'3'},
|
||||
'cmds_en':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'22',
|
||||
'bitlen':'1'},
|
||||
'cmds_wrap_mode':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'23',
|
||||
'bitlen':'2'},
|
||||
'cmds_wrap_len':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'25',
|
||||
'bitlen':'4'},
|
||||
'icache_invalid':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'29',
|
||||
'bitlen':'1'},
|
||||
'dcache_invalid':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'30',
|
||||
'bitlen':'1'},
|
||||
'fpga_halt_release':{'offset':str(int(bootcfg_start_pos) + 0),
|
||||
'pos':'31',
|
||||
'bitlen':'1'},
|
||||
'group_image_offset':{'offset':str(int(bootcfg_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'aes_region_len':{'offset':str(int(bootcfg_start_pos) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'img_len_cnt':{'offset':str(int(bootcfg_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_0':{'offset':str(int(bootcfg_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_1':{'offset':str(int(bootcfg_start_pos) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_2':{'offset':str(int(bootcfg_start_pos) + 24),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_3':{'offset':str(int(bootcfg_start_pos) + 28),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_4':{'offset':str(int(bootcfg_start_pos) + 32),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_5':{'offset':str(int(bootcfg_start_pos) + 36),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_6':{'offset':str(int(bootcfg_start_pos) + 40),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_7':{'offset':str(int(bootcfg_start_pos) + 44),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_config_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'm0_halt_cpu':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'm0_cache_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'm0_cache_wa':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'm0_cache_wb':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'18',
|
||||
'bitlen':'1'},
|
||||
'm0_cache_wt':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'19',
|
||||
'bitlen':'1'},
|
||||
'm0_cache_way_dis':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'20',
|
||||
'bitlen':'4'},
|
||||
'm0_reserved':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 0),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'm0_image_address_offset':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_boot_entry':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_msp_val':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_0':{'offset':str(int(boot2_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_1':{'offset':str(int(boot2_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashCfgTableAddr':{'offset':str(int(flashcfg_table_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashCfgTableLen':{'offset':str(int(flashcfg_table_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr0':{'offset':str(int(patch_on_read_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value0':{'offset':str(int(patch_on_read_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr1':{'offset':str(int(patch_on_read_start_pos) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value1':{'offset':str(int(patch_on_read_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr2':{'offset':str(int(patch_on_read_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value2':{'offset':str(int(patch_on_read_start_pos) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr0':{'offset':str(int(patch_on_jump_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value0':{'offset':str(int(patch_on_jump_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr1':{'offset':str(int(patch_on_jump_start_pos) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value1':{'offset':str(int(patch_on_jump_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr2':{'offset':str(int(patch_on_jump_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value2':{'offset':str(int(patch_on_jump_start_pos) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved':{'offset':str(int(rsvd_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'crc32':{'offset':str(int(crc32_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'}}
|
||||
# okay decompiling ./libs/base/bl616/bootheader_cfg_keys.pyc
|
||||
10
libs/base/bl616/chiptype_patch.py
Normal file
10
libs/base/bl616/chiptype_patch.py
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
# 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/bl616/chiptype_patch.py
|
||||
|
||||
|
||||
def img_load_create_predata_before_run_img():
|
||||
return bytearray(0)
|
||||
# okay decompiling ./libs/base/bl616/chiptype_patch.pyc
|
||||
12
libs/base/bl616/cklink_load_cfg.py
Normal file
12
libs/base/bl616/cklink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl616/cklink_load_cfg.py
|
||||
cklink_shake_hand_addr = '2204BBEC'
|
||||
cklink_data_addr = '2204CC88'
|
||||
cklink_load_addr = '22010000'
|
||||
cklink_core_type = 'RISC-V'
|
||||
cklink_set_tif = 0
|
||||
cklink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl616/cklink_load_cfg.pyc
|
||||
147
libs/base/bl616/flash_select_do.py
Normal file
147
libs/base/bl616/flash_select_do.py
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
# 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/bl616/flash_select_do.py
|
||||
import os, csv
|
||||
from re import I
|
||||
import config as gol
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, conf_sign
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootheader_cfg_keys as flash_cfg_keys
|
||||
|
||||
def get_suitable_file_name(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:
|
||||
bflb_utils.printf('Flash id duplicate and alternative is:')
|
||||
for i in range(len(conf_files)):
|
||||
tmp = conf_files[i].split('.')[0]
|
||||
bflb_utils.printf('%d:%s' % (i + 1, tmp))
|
||||
|
||||
return conf_files[i]
|
||||
if len(conf_files) == 1:
|
||||
return conf_files[0]
|
||||
return ''
|
||||
|
||||
|
||||
def update_flash_cfg_do(chipname, chiptype, flash_id, file=None, create=False, section=None):
|
||||
if conf_sign:
|
||||
cfg_dir = app_path + '/utils/flash/' + chipname + '/'
|
||||
else:
|
||||
cfg_dir = app_path + '/utils/flash/' + gol.flash_dict[chipname] + '/'
|
||||
conf_name = get_suitable_file_name(cfg_dir, flash_id)
|
||||
value_key = []
|
||||
if os.path.isfile(cfg_dir + conf_name) is False:
|
||||
return False
|
||||
fp = open(cfg_dir + conf_name, 'r')
|
||||
for line in fp.readlines():
|
||||
value = line.split('=')[0].strip()
|
||||
if value == '[FLASH_CFG]':
|
||||
continue
|
||||
else:
|
||||
value_key.append(value)
|
||||
|
||||
cfg1 = BFConfigParser()
|
||||
cfg1.read(cfg_dir + conf_name)
|
||||
cfg2 = BFConfigParser()
|
||||
cfg2.read(file)
|
||||
for i in range(len(value_key)):
|
||||
if cfg1.has_option('FLASH_CFG', value_key[i]):
|
||||
if cfg2.has_option(section, value_key[i]):
|
||||
tmp_value = cfg1.get('FLASH_CFG', value_key[i])
|
||||
bflb_utils.update_cfg(cfg2, section, value_key[i], tmp_value)
|
||||
|
||||
cfg2.write(file, 'w+')
|
||||
bflb_utils.printf('Update flash cfg finished')
|
||||
|
||||
|
||||
def get_supported_flash_do():
|
||||
flash_type = []
|
||||
return flash_type
|
||||
|
||||
|
||||
def get_int_mask(pos, length):
|
||||
ones = '11111111111111111111111111111111'
|
||||
zeros = '00000000000000000000000000000000'
|
||||
mask = ones[0:32 - pos - length] + zeros[0:length] + ones[0:pos]
|
||||
return int(mask, 2)
|
||||
|
||||
|
||||
def create_flashcfg_data_from_cfg(cfg_len, cfgfile):
|
||||
section = 'FLASH_CFG'
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(cfgfile)
|
||||
data = bytearray(cfg_len)
|
||||
minOffset = int(flash_cfg_keys.get('io_mode')['offset'], 10)
|
||||
for key in cfg.options(section):
|
||||
if flash_cfg_keys.get(key) == None:
|
||||
bflb_utils.printf(key + ' not exist')
|
||||
continue
|
||||
else:
|
||||
val = cfg.get(section, key)
|
||||
if val.startswith('0x'):
|
||||
val = int(val, 16)
|
||||
else:
|
||||
val = int(val, 10)
|
||||
offset = int(flash_cfg_keys.get(key)['offset'], 10) - minOffset
|
||||
pos = int(flash_cfg_keys.get(key)['pos'], 10)
|
||||
bitlen = int(flash_cfg_keys.get(key)['bitlen'], 10)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = (oldval & get_int_mask(pos, bitlen)) + (val << pos)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
|
||||
crcarray = bflb_utils.get_crc32_bytearray(data)
|
||||
data = bflb_utils.int_to_4bytearray_l(1195787078) + data + crcarray
|
||||
return data
|
||||
|
||||
|
||||
def create_flashcfg_table(start_addr):
|
||||
single_flashcfg_len = 92
|
||||
flash_table_list = bytearray(0)
|
||||
flash_table_data = bytearray(0)
|
||||
table_file = os.path.join(app_path, 'utils', 'flash', 'bl616', 'flashcfg_list.csv')
|
||||
with open(table_file, 'r', encoding='utf-8-sig') as csvfile:
|
||||
table_list = []
|
||||
cfgfile_list = []
|
||||
reader = csv.DictReader(csvfile)
|
||||
cnt = 0
|
||||
for row in reader:
|
||||
row_dict = {}
|
||||
row_dict['jid'] = row.get('flashJedecID', '')
|
||||
row_dict['cfgfile'] = row.get('configFile', '')
|
||||
if row_dict['cfgfile'] not in cfgfile_list:
|
||||
cfgfile_list.append(row_dict['cfgfile'])
|
||||
else:
|
||||
table_list.append(row_dict)
|
||||
cnt += 1
|
||||
|
||||
table_list_len = 4 + cnt * 8 + 4
|
||||
for cfgfile in cfgfile_list:
|
||||
cfgfile = os.path.join(app_path, 'utils', 'flash', 'bl616', cfgfile)
|
||||
data = create_flashcfg_data_from_cfg(single_flashcfg_len - 8, cfgfile)
|
||||
flash_table_data += data
|
||||
|
||||
for dict in table_list:
|
||||
flash_table_list += bflb_utils.int_to_4bytearray_b(int(dict['jid'] + '00', 16))
|
||||
i = 0
|
||||
offset = 0
|
||||
for cfgfile in cfgfile_list:
|
||||
if cfgfile == dict['cfgfile']:
|
||||
offset = start_addr + table_list_len + single_flashcfg_len * i
|
||||
break
|
||||
else:
|
||||
i += 1
|
||||
|
||||
flash_table_list += bflb_utils.int_to_4bytearray_l(offset)
|
||||
|
||||
crcarray = bflb_utils.get_crc32_bytearray(flash_table_list)
|
||||
flash_table_list = bflb_utils.int_to_4bytearray_l(1196704582) + flash_table_list + crcarray
|
||||
return (
|
||||
flash_table_list, flash_table_data, len(flash_table_list))
|
||||
# okay decompiling ./libs/base/bl616/flash_select_do.pyc
|
||||
753
libs/base/bl616/img_create_do.py
Normal file
753
libs/base/bl616/img_create_do.py
Normal file
|
|
@ -0,0 +1,753 @@
|
|||
# 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/bl616/img_create_do.py
|
||||
import os, sys, hashlib, binascii, codecs, ecdsa
|
||||
from CryptoPlus.Cipher import AES as AES_XTS
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import img_create_sha256_data, img_create_encrypt_data
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl616.flash_select_do import create_flashcfg_table
|
||||
from libs.base.bl616.bootheader_cfg_keys import flashcfg_table_start_pos as flashcfg_table_start
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcpucfg_start_pos as bootcpucfg_start
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcpucfg_len as bootcpucfg_length
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcpucfg_m0_index as bootcpucfg_m0_index_number
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcpucfg_d0_index as bootcpucfg_d0_index_number
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcpucfg_lp_index as bootcpucfg_lp_index_number
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootcfg_start_pos as bootcfg_start
|
||||
from libs.base.bl616.bootheader_cfg_keys import bootheader_len as header_len
|
||||
keyslot0 = 28
|
||||
keyslot1 = keyslot0 + 16
|
||||
keyslot2 = keyslot1 + 16
|
||||
keyslot3 = keyslot2 + 16
|
||||
keyslot3_end = keyslot3 + 16
|
||||
keyslot4 = 128
|
||||
keyslot5 = keyslot4 + 16
|
||||
keyslot6 = keyslot5 + 16
|
||||
keyslot7 = keyslot6 + 16
|
||||
keyslot8 = keyslot7 + 16
|
||||
keyslot9 = keyslot8 + 16
|
||||
keyslot10 = keyslot9 + 16
|
||||
keyslot10_end = keyslot10 + 16
|
||||
keyslot11 = keyslot3_end + 16
|
||||
keyslot11_end = keyslot11 + 16
|
||||
wr_lock_boot_mode = 14
|
||||
wr_lock_dbg_pwd = 15
|
||||
wr_lock_wifi_mac = 16
|
||||
wr_lock_key_slot_0 = 17
|
||||
wr_lock_key_slot_1 = 18
|
||||
wr_lock_key_slot_2 = 19
|
||||
wr_lock_key_slot_3 = 20
|
||||
wr_lock_sw_usage_0 = 21
|
||||
wr_lock_sw_usage_1 = 22
|
||||
wr_lock_sw_usage_2 = 23
|
||||
wr_lock_sw_usage_3 = 24
|
||||
wr_lock_key_slot_11 = 25
|
||||
rd_lock_dbg_pwd = 26
|
||||
rd_lock_key_slot_0 = 27
|
||||
rd_lock_key_slot_1 = 28
|
||||
rd_lock_key_slot_2 = 29
|
||||
rd_lock_key_slot_3 = 30
|
||||
rd_lock_key_slot_11 = 31
|
||||
wr_lock_key_slot_4 = 15
|
||||
wr_lock_key_slot_5 = 16
|
||||
wr_lock_key_slot_6 = 17
|
||||
wr_lock_key_slot_7 = 18
|
||||
wr_lock_key_slot_8 = 19
|
||||
wr_lock_key_slot_9 = 20
|
||||
wr_lock_key_slot_10 = 21
|
||||
rd_lock_key_slot_4 = 25
|
||||
rd_lock_key_slot_5 = 26
|
||||
rd_lock_key_slot_6 = 27
|
||||
rd_lock_key_slot_7 = 28
|
||||
rd_lock_key_slot_8 = 29
|
||||
rd_lock_key_slot_9 = 30
|
||||
rd_lock_key_slot_10 = 31
|
||||
|
||||
def bytearray_data_merge(data1, data2, len):
|
||||
for i in range(len):
|
||||
data1[i] |= data2[i]
|
||||
|
||||
return data1
|
||||
|
||||
|
||||
def img_update_efuse_group0(cfg, sign, pk_hash, flash_encryp_type, flash_key, sec_eng_key_sel, sec_eng_key, security=False):
|
||||
fp = open(cfg.get('Img_Group0_Cfg', 'efuse_file'), 'rb')
|
||||
efuse_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Group0_Cfg', 'efuse_mask_file'), 'rb')
|
||||
efuse_mask_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
mask_4bytes = bytearray.fromhex('FFFFFFFF')
|
||||
if flash_encryp_type >= 3:
|
||||
efuse_data[0] |= 3
|
||||
else:
|
||||
efuse_data[0] |= flash_encryp_type
|
||||
if sign > 0:
|
||||
efuse_data[92] |= sign << 7
|
||||
efuse_mask_data[92] |= 255
|
||||
if flash_encryp_type > 0:
|
||||
efuse_data[0] |= 48
|
||||
efuse_mask_data[0] |= 255
|
||||
rw_lock0 = 0
|
||||
rw_lock1 = 0
|
||||
if pk_hash is not None:
|
||||
efuse_data[keyslot0:keyslot2] = pk_hash
|
||||
efuse_mask_data[keyslot0:keyslot2] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_0
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_1
|
||||
if flash_key is not None:
|
||||
if flash_encryp_type == 1:
|
||||
efuse_data[keyslot2:keyslot3] = flash_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
else:
|
||||
if flash_encryp_type == 2:
|
||||
efuse_data[keyslot2:keyslot3_end] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
else:
|
||||
if flash_encryp_type == 3:
|
||||
efuse_data[keyslot2:keyslot3_end] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
else:
|
||||
if flash_encryp_type == 4 or flash_encryp_type == 5 or flash_encryp_type == 6:
|
||||
efuse_data[keyslot2:keyslot3_end] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
if sec_eng_key is not None:
|
||||
if flash_encryp_type == 0:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot3:keyslot3_end] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot3:keyslot3_end] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot3_end] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
if sec_eng_key_sel == 2:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot5] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
if sec_eng_key_sel == 3:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot5] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
if flash_encryp_type == 1:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot5:keyslot6] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
if sec_eng_key_sel == 2:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot3:keyslot3_end] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot3_end] = mask_4bytes * 4
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 3:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
if flash_encryp_type == 2 or flash_encryp_type == 3 or flash_encryp_type == 4 or flash_encryp_type == 5 or flash_encryp_type == 6:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot6:keyslot7] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot10:keyslot10_end] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot6:keyslot7] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot10:keyslot10_end] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_6
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_10
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_6
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_10
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot10:keyslot10_end] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot6:keyslot7] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot6:keyslot7] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot10:keyslot10_end] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_6
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_10
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_6
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_10
|
||||
if sec_eng_key_sel == 2:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot3:keyslot3_end] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 3:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot2:keyslot3_end] = sec_eng_key
|
||||
efuse_mask_data[keyslot2:keyslot3_end] = mask_4bytes * 8
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_2
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_2
|
||||
rw_lock0 |= 1 << wr_lock_key_slot_3
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_3
|
||||
efuse_data[124:128] = bytearray_data_merge(efuse_data[124:128], bflb_utils.int_to_4bytearray_l(rw_lock0), 4)
|
||||
efuse_mask_data[124:128] = bytearray_data_merge(efuse_mask_data[124:128], bflb_utils.int_to_4bytearray_l(rw_lock0), 4)
|
||||
efuse_data[252:256] = bytearray_data_merge(efuse_data[252:256], bflb_utils.int_to_4bytearray_l(rw_lock1), 4)
|
||||
efuse_mask_data[252:256] = bytearray_data_merge(efuse_mask_data[252:256], bflb_utils.int_to_4bytearray_l(rw_lock1), 4)
|
||||
if security is True:
|
||||
bflb_utils.printf('Encrypt efuse data')
|
||||
security_key, security_iv = bflb_utils.get_security_key()
|
||||
efuse_data = img_create_encrypt_data(efuse_data, security_key, security_iv, 0)
|
||||
efuse_data = bytearray(4096) + efuse_data
|
||||
fp = open(cfg.get('Img_Group0_Cfg', 'efuse_file'), 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Group0_Cfg', 'efuse_mask_file'), 'wb+')
|
||||
fp.write(efuse_mask_data)
|
||||
fp.close()
|
||||
|
||||
|
||||
def img_create_get_sign_encrypt_info(bootheader_data):
|
||||
sign = bootheader_data[bootcfg_start] & 3
|
||||
encrypt = bootheader_data[bootcfg_start] >> 2 & 3
|
||||
key_sel = bootheader_data[bootcfg_start] >> 4 & 3
|
||||
xts_mode = bootheader_data[bootcfg_start] >> 6 & 1
|
||||
return (
|
||||
sign, encrypt, key_sel, xts_mode)
|
||||
|
||||
|
||||
def img_create_get_img_start_addr(bootheader_data):
|
||||
bootentry = []
|
||||
bootentry.append(bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(bootheader_data[bootcpucfg_start + bootcpucfg_length * bootcpucfg_m0_index_number + 16:bootcpucfg_start + bootcpucfg_length * bootcpucfg_m0_index_number + 16 + 4])))
|
||||
return bootentry
|
||||
|
||||
|
||||
def img_create_flash_default_data(length):
|
||||
datas = bytearray(length)
|
||||
for i in range(length):
|
||||
datas[i] = 255
|
||||
|
||||
return datas
|
||||
|
||||
|
||||
def img_get_file_data(files):
|
||||
datas = []
|
||||
for file in files:
|
||||
if file == 'UNUSED':
|
||||
datas.append(bytearray(0))
|
||||
continue
|
||||
else:
|
||||
with open(file, 'rb') as fp:
|
||||
data = fp.read()
|
||||
datas.append(data)
|
||||
|
||||
return datas
|
||||
|
||||
|
||||
def img_get_largest_addr(addrs, files):
|
||||
min = 67108863
|
||||
maxlen = 0
|
||||
datalen = 0
|
||||
for i in range(len(addrs)):
|
||||
if files[i] == 'UNUSED':
|
||||
continue
|
||||
else:
|
||||
addr = addrs[i] & 67108863
|
||||
if addr >= maxlen:
|
||||
maxlen = addr
|
||||
datalen = os.path.getsize(files[i])
|
||||
if addr <= min:
|
||||
min = addr
|
||||
|
||||
if maxlen == 0:
|
||||
if datalen == 0:
|
||||
return (0, 0)
|
||||
return (
|
||||
maxlen + datalen - min, min)
|
||||
|
||||
|
||||
def img_get_one_group_img(d_addrs, d_files):
|
||||
whole_img_len, min = img_get_largest_addr(d_addrs, d_files)
|
||||
whole_img_len &= 67108863
|
||||
whole_img_data = img_create_flash_default_data(whole_img_len)
|
||||
filedatas = img_get_file_data(d_files)
|
||||
for i in range(len(d_addrs)):
|
||||
if d_files[i] == 'UNUSED':
|
||||
continue
|
||||
else:
|
||||
start_addr = d_addrs[i]
|
||||
start_addr &= 67108863
|
||||
start_addr -= min
|
||||
whole_img_data[start_addr:start_addr + len(filedatas[i])] = filedatas[i]
|
||||
|
||||
return whole_img_data
|
||||
|
||||
|
||||
def img_create_get_hash_ignore(bootheader_data):
|
||||
return bootheader_data[bootcfg_start + 2] >> 1 & 1
|
||||
|
||||
|
||||
def img_create_get_crc_ignore(bootheader_data):
|
||||
return bootheader_data[bootcfg_start + 2] & 1
|
||||
|
||||
|
||||
def img_create_update_bootheader_if(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[bootcfg_start + 12:bootcfg_start + 12 + 4] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign = bootheader_data[bootcfg_start] & 3
|
||||
encrypt = bootheader_data[bootcfg_start] >> 2 & 3
|
||||
key_sel = bootheader_data[bootcfg_start] >> 4 & 3
|
||||
xts_mode = bootheader_data[bootcfg_start] >> 6 & 1
|
||||
if bootheader_data[bootcfg_start + 2] >> 1 & 1 == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[bootcfg_start + 16:bootcfg_start + 16 + 32] = hash
|
||||
if bootheader_data[bootcfg_start + 2] & 1 == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data
|
||||
|
||||
|
||||
def img_create_update_bootheader(bootheader_data, hash, seg_cnt, flashcfg_table_addr, flashcfg_table_len):
|
||||
bootheader_data[flashcfg_table_start:flashcfg_table_start + 4] = bflb_utils.int_to_4bytearray_l(flashcfg_table_addr)
|
||||
bootheader_data[flashcfg_table_start + 4:flashcfg_table_start + 8] = bflb_utils.int_to_4bytearray_l(flashcfg_table_len)
|
||||
bootheader_data[bootcfg_start + 12:bootcfg_start + 12 + 4] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign, encrypt, key_sel, xts_mode = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
if img_create_get_hash_ignore(bootheader_data) == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[bootcfg_start + 16:bootcfg_start + 16 + 32] = hash
|
||||
if img_create_get_crc_ignore(bootheader_data) == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data[0:header_len]
|
||||
|
||||
|
||||
def img_create_update_segheader(segheader, segdatalen, segdatacrc):
|
||||
segheader[4:8] = segdatalen
|
||||
segheader[8:12] = segdatacrc
|
||||
return segheader
|
||||
|
||||
|
||||
def reverse_str_data_unit_number(str_data_unit_number):
|
||||
"""
|
||||
high position low data
|
||||
data unit number:00000280
|
||||
storage format: 80020000
|
||||
"""
|
||||
reverse_str = ''
|
||||
if len(str_data_unit_number) == 8:
|
||||
str_part1 = str_data_unit_number[0:2]
|
||||
str_part2 = str_data_unit_number[2:4]
|
||||
str_part3 = str_data_unit_number[4:6]
|
||||
str_part4 = str_data_unit_number[6:8]
|
||||
reverse_str = str_part4 + str_part3 + str_part2 + str_part1
|
||||
return reverse_str
|
||||
|
||||
|
||||
def reverse_iv(need_reverse_iv_bytearray):
|
||||
temp_reverse_iv_bytearray = binascii.hexlify(need_reverse_iv_bytearray).decode()
|
||||
if temp_reverse_iv_bytearray[24:32] != '00000000':
|
||||
bflb_utils.printf('The lower 4 bytes of IV should be set 0, if set IV is less than 16 bytes, make up 0 for the low 4 bytes of IV ')
|
||||
sys.exit()
|
||||
reverse_iv_bytearray = '00000000' + temp_reverse_iv_bytearray[0:24]
|
||||
return reverse_iv_bytearray
|
||||
|
||||
|
||||
def img_create_encrypt_data_xts(data_bytearray, key_bytearray, iv_bytearray, encrypt):
|
||||
counter = binascii.hexlify(iv_bytearray[4:16]).decode()
|
||||
data_unit_number = 0
|
||||
key = (
|
||||
key_bytearray[0:16], key_bytearray[16:32])
|
||||
if encrypt == 2 or encrypt == 3:
|
||||
key = (
|
||||
key_bytearray, key_bytearray)
|
||||
cipher = AES_XTS.new(key, AES_XTS.MODE_XTS)
|
||||
total_len = len(data_bytearray)
|
||||
ciphertext = bytearray(0)
|
||||
deal_len = 0
|
||||
while deal_len < total_len:
|
||||
data_unit_number = str(hex(data_unit_number)).replace('0x', '')
|
||||
data_unit_number_to_str = str(data_unit_number)
|
||||
right_justify_str = data_unit_number_to_str.rjust(8, '0')
|
||||
reverse_data_unit_number_str = reverse_str_data_unit_number(right_justify_str)
|
||||
tweak = reverse_data_unit_number_str + counter
|
||||
tweak = bflb_utils.hexstr_to_bytearray('0' * (32 - len(tweak)) + tweak)
|
||||
if 32 + deal_len <= total_len:
|
||||
cur_block = data_bytearray[0 + deal_len:32 + deal_len]
|
||||
ciphertext += cipher.encrypt(cur_block, tweak)
|
||||
else:
|
||||
cur_block = data_bytearray[0 + deal_len:16 + deal_len] + bytearray(16)
|
||||
ciphertext += cipher.encrypt(cur_block, tweak)[0:16]
|
||||
deal_len += 32
|
||||
data_unit_number = int(data_unit_number, 16)
|
||||
data_unit_number += 1
|
||||
|
||||
return ciphertext
|
||||
|
||||
|
||||
def img_create_sign_data(data_bytearray, privatekey_file_uecc, publickey_file):
|
||||
sk = ecdsa.SigningKey.from_pem(open(privatekey_file_uecc).read())
|
||||
vk = ecdsa.VerifyingKey.from_pem(open(publickey_file).read())
|
||||
pk_data = vk.to_string()
|
||||
bflb_utils.printf('Private key: ', binascii.hexlify(sk.to_string()))
|
||||
bflb_utils.printf('Public key: ', binascii.hexlify(pk_data))
|
||||
pk_hash = img_create_sha256_data(pk_data)
|
||||
bflb_utils.printf('Public key hash=', binascii.hexlify(pk_hash))
|
||||
signature = sk.sign(data_bytearray, hashfunc=(hashlib.sha256), sigencode=(ecdsa.util.sigencode_string))
|
||||
bflb_utils.printf('Signature=', binascii.hexlify(signature))
|
||||
len_array = bflb_utils.int_to_4bytearray_l(len(signature))
|
||||
sig_field = len_array + signature
|
||||
crcarray = bflb_utils.get_crc32_bytearray(sig_field)
|
||||
return (
|
||||
pk_data, pk_hash, sig_field + crcarray)
|
||||
|
||||
|
||||
def img_create_read_file_append_crc(file, crc):
|
||||
fp = open(file, 'rb')
|
||||
read_data = bytearray(fp.read())
|
||||
crcarray = bytearray(0)
|
||||
if crc:
|
||||
crcarray = bflb_utils.get_crc32_bytearray(read_data)
|
||||
fp.close()
|
||||
return read_data + crcarray
|
||||
|
||||
|
||||
def encrypt_loader_bin_do(file, sign, encrypt, temp_encrypt_key, temp_encrypt_iv, publickey_file, privatekey_file):
|
||||
if encrypt != 0 or sign != 0:
|
||||
encrypt_key = bytearray(0)
|
||||
encrypt_iv = bytearray(0)
|
||||
load_helper_bin_header = bytearray(0)
|
||||
load_helper_bin_body = bytearray(0)
|
||||
offset = bootcfg_start
|
||||
sign_pos = 0
|
||||
encrypt_type_pos = 2
|
||||
pk_data = bytearray(0)
|
||||
signature = bytearray(0)
|
||||
aesiv_data = bytearray(0)
|
||||
data_tohash = bytearray(0)
|
||||
with open(file, 'rb') as fp:
|
||||
load_helper_bin = fp.read()
|
||||
load_helper_bin_header = load_helper_bin[0:header_len]
|
||||
load_helper_bin_body = load_helper_bin[header_len:]
|
||||
if load_helper_bin_header != bytearray(0):
|
||||
if load_helper_bin_body != bytearray(0):
|
||||
load_helper_bin_body = bflb_utils.add_to_16(load_helper_bin_body)
|
||||
if encrypt != 0:
|
||||
encrypt_key = bflb_utils.hexstr_to_bytearray(temp_encrypt_key)
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(temp_encrypt_iv)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
load_helper_bin_body_encrypt = bflb_utils.img_create_encrypt_data(load_helper_bin_body, encrypt_key, encrypt_iv, 0)
|
||||
else:
|
||||
load_helper_bin_body_encrypt = load_helper_bin_body
|
||||
data = bytearray(load_helper_bin_header)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = oldval
|
||||
if encrypt != 0:
|
||||
newval = newval | 1 << encrypt_type_pos
|
||||
if sign != 0:
|
||||
newval = newval | 1 << sign_pos
|
||||
data_tohash += load_helper_bin_body_encrypt
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
load_helper_bin_header = data
|
||||
load_helper_bin_encrypt = load_helper_bin_header + pk_data + signature + aesiv_data + load_helper_bin_body_encrypt
|
||||
hashfun = hashlib.sha256()
|
||||
hashfun.update(load_helper_bin_body_encrypt)
|
||||
hash = bflb_utils.hexstr_to_bytearray(hashfun.hexdigest())
|
||||
load_helper_bin_data = bytearray(load_helper_bin_encrypt)
|
||||
load_helper_bin_encrypt = img_create_update_bootheader_if(load_helper_bin_data, hash, 1)
|
||||
return (
|
||||
True, load_helper_bin_encrypt)
|
||||
return (False, None)
|
||||
|
||||
|
||||
def img_creat_process(group_type, flash_img, cfg, security=False):
|
||||
encrypt_blk_size = 16
|
||||
padding = bytearray(encrypt_blk_size)
|
||||
data_tohash = bytearray(0)
|
||||
cfg_section = ''
|
||||
img_update_efuse_fun = img_update_efuse_group0
|
||||
cfg_section = 'Img_Group0_Cfg'
|
||||
segheader_file = []
|
||||
if flash_img == 0:
|
||||
for files in cfg.get(cfg_section, 'segheader_file').split(' '):
|
||||
segheader_file.append(str(files))
|
||||
|
||||
segdata_file = []
|
||||
for files in cfg.get(cfg_section, 'segdata_file').split('|'):
|
||||
if files:
|
||||
segdata_file.append(str(files))
|
||||
|
||||
boot_header_file = cfg.get(cfg_section, 'boot_header_file')
|
||||
bootheader_data = img_create_read_file_append_crc(boot_header_file, 0)
|
||||
encrypt = 0
|
||||
sign, encrypt, key_sel, xts_mode = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
boot_entry = img_create_get_img_start_addr(bootheader_data)
|
||||
aesiv_data = bytearray(0)
|
||||
pk_data = bytearray(0)
|
||||
publickey_file = ''
|
||||
privatekey_file_uecc = ''
|
||||
if sign != 0:
|
||||
bflb_utils.printf('Image need sign')
|
||||
publickey_file = cfg.get(cfg_section, 'publickey_file')
|
||||
privatekey_file_uecc = cfg.get(cfg_section, 'privatekey_file_uecc')
|
||||
if encrypt != 0:
|
||||
bflb_utils.printf('Image need encrypt ', encrypt)
|
||||
if xts_mode == 1:
|
||||
bflb_utils.printf('Enable xts mode')
|
||||
encrypt_key_org = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_key_org'))
|
||||
if encrypt == 1:
|
||||
if xts_mode == 1:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
encrypt_key = encrypt_key_org[0:16]
|
||||
else:
|
||||
if encrypt == 2:
|
||||
if xts_mode == 1:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
if encrypt == 3:
|
||||
if xts_mode == 1:
|
||||
encrypt_key = encrypt_key_org[0:24]
|
||||
else:
|
||||
encrypt_key = encrypt_key_org[0:24]
|
||||
bflb_utils.printf('Key= ', binascii.hexlify(encrypt_key))
|
||||
iv_value = cfg.get(cfg_section, 'aes_iv')
|
||||
if xts_mode == 1:
|
||||
iv_value = iv_value[24:32] + iv_value[:24]
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(iv_value)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
seg_cnt = len(segheader_file)
|
||||
segdata_cnt = len(segdata_file)
|
||||
if flash_img == 0:
|
||||
if seg_cnt != segdata_cnt:
|
||||
bflb_utils.printf('Segheader count and segdata count not match')
|
||||
return (
|
||||
'FAIL', data_tohash)
|
||||
data_toencrypt = bytearray(0)
|
||||
if flash_img == 0:
|
||||
i = 0
|
||||
seg_header_list = []
|
||||
seg_data_list = []
|
||||
while i < seg_cnt:
|
||||
seg_data = bytearray(0)
|
||||
if segdata_file[i] != 'UNUSED':
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[i], 0)
|
||||
else:
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
segdata_crcarray = bflb_utils.get_crc32_bytearray(seg_data)
|
||||
seg_data_list.append(seg_data)
|
||||
seg_header = img_create_read_file_append_crc(segheader_file[i], 0)
|
||||
seg_header = img_create_update_segheader(seg_header, bflb_utils.int_to_4bytearray_l(len(seg_data)), segdata_crcarray)
|
||||
segheader_crcarray = bflb_utils.get_crc32_bytearray(seg_header)
|
||||
seg_header = seg_header + segheader_crcarray
|
||||
seg_header_list.append(seg_header)
|
||||
i = i + 1
|
||||
|
||||
i = 0
|
||||
cnt = 0
|
||||
while i < seg_cnt:
|
||||
if seg_header_list[i][4:8] != bytearray(4):
|
||||
data_toencrypt += seg_header_list[i]
|
||||
data_toencrypt += seg_data_list[i]
|
||||
cnt += 1
|
||||
else:
|
||||
i += 1
|
||||
|
||||
seg_cnt = cnt
|
||||
else:
|
||||
seg_data = img_get_one_group_img(boot_entry, segdata_file)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
data_toencrypt += seg_data
|
||||
seg_cnt = len(data_toencrypt)
|
||||
if encrypt != 0:
|
||||
unencrypt_mfg_data = bytearray(0)
|
||||
if seg_cnt >= 8192:
|
||||
if data_toencrypt[4096:4100] == bytearray('0mfg'.encode('utf-8')):
|
||||
unencrypt_mfg_data = data_toencrypt[4096:8192]
|
||||
if xts_mode != 0:
|
||||
data_toencrypt = img_create_encrypt_data_xts(data_toencrypt, encrypt_key, encrypt_iv, encrypt)
|
||||
else:
|
||||
data_toencrypt = img_create_encrypt_data(data_toencrypt, encrypt_key, encrypt_iv, flash_img)
|
||||
if unencrypt_mfg_data != bytearray(0):
|
||||
data_toencrypt = data_toencrypt[0:4096] + unencrypt_mfg_data + data_toencrypt[8192:]
|
||||
fw_data = bytearray(0)
|
||||
data_tohash += data_toencrypt
|
||||
fw_data = data_toencrypt
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
signature = bytearray(0)
|
||||
pk_hash = None
|
||||
if sign == 1:
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file_uecc, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
flashCfgAddr = len(bootheader_data + pk_data + signature + aesiv_data)
|
||||
flashCfgListLen = 0
|
||||
flashCfgList = bytearray(0)
|
||||
flashCfgTable = bytearray(0)
|
||||
if flash_img == 1:
|
||||
if bootheader_data[25:26] == b'\xff':
|
||||
flashCfgList, flashCfgTable, flashCfgListLen = create_flashcfg_table(flashCfgAddr)
|
||||
bootheader_data = img_create_update_bootheader(bootheader_data, hash, seg_cnt, flashCfgAddr, flashCfgListLen)
|
||||
if flash_img == 1:
|
||||
bflb_utils.printf('Write flash img')
|
||||
bootinfo_file_name = cfg.get(cfg_section, 'bootinfo_file')
|
||||
fp = open(bootinfo_file_name, 'wb+')
|
||||
bootinfo = bootheader_data + pk_data + signature + aesiv_data + flashCfgList + flashCfgTable
|
||||
fp.write(bootinfo)
|
||||
fp.close()
|
||||
fw_file_name = cfg.get(cfg_section, 'img_file')
|
||||
fp = open(fw_file_name, 'wb+')
|
||||
fp.write(fw_data)
|
||||
fp.close()
|
||||
fw_data_hash = img_create_sha256_data(fw_data)
|
||||
fp = open(fw_file_name.replace('.bin', '_withhash.bin'), 'wb+')
|
||||
fp.write(fw_data + fw_data_hash)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
flash_encrypt_type = 0
|
||||
if encrypt == 1:
|
||||
flash_encrypt_type = 1
|
||||
if encrypt == 2:
|
||||
flash_encrypt_type = 3
|
||||
if encrypt == 3:
|
||||
flash_encrypt_type = 2
|
||||
if xts_mode == 1:
|
||||
flash_encrypt_type += 3
|
||||
img_update_efuse_fun(cfg, sign, pk_hash, flash_encrypt_type, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, None, security)
|
||||
else:
|
||||
img_update_efuse_fun(cfg, sign, pk_hash, encrypt, None, key_sel, None, security)
|
||||
else:
|
||||
bflb_utils.printf('Write if img')
|
||||
whole_img_file_name = cfg.get(cfg_section, 'whole_img_file')
|
||||
fp = open(whole_img_file_name, 'wb+')
|
||||
img_data = bootheader_data + pk_data + signature + aesiv_data + fw_data
|
||||
fp.write(img_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if_encrypt_type = 0
|
||||
if encrypt == 1:
|
||||
if_encrypt_type = 1
|
||||
if encrypt == 2:
|
||||
if_encrypt_type = 3
|
||||
if encrypt == 3:
|
||||
if_encrypt_type = 2
|
||||
if xts_mode == 1:
|
||||
if_encrypt_type += 3
|
||||
img_update_efuse_fun(cfg, sign, pk_hash, if_encrypt_type, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse_fun(cfg, sign, pk_hash, 0, None, key_sel, bytearray(32), security)
|
||||
return (
|
||||
'OK', data_tohash)
|
||||
|
||||
|
||||
def img_create_do(args, img_dir_path=None, config_file=None):
|
||||
bflb_utils.printf('Image create path: ', img_dir_path)
|
||||
if config_file is None:
|
||||
config_file = img_dir_path + '/img_create_cfg.ini'
|
||||
bflb_utils.printf('Config file: ', config_file)
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
group_type = 'all'
|
||||
img_type = 'media'
|
||||
signer = 'none'
|
||||
security = False
|
||||
data_tohash = bytearray(0)
|
||||
try:
|
||||
if args.image:
|
||||
img_type = args.image
|
||||
if args.group:
|
||||
group_type = args.group
|
||||
if args.signer:
|
||||
signer = args.signer
|
||||
if args.security:
|
||||
security = args.security == 'efuse'
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
if img_type == 'media':
|
||||
flash_img = 1
|
||||
else:
|
||||
flash_img = 0
|
||||
ret0 = ret1 = 'OK'
|
||||
if group_type == 'group0' or group_type == 'all':
|
||||
ret0, data_tohash0 = img_creat_process('group0', flash_img, cfg, security)
|
||||
else:
|
||||
img_creat_process('', flash_img, cfg, security)
|
||||
if ret0 != 'OK':
|
||||
bflb_utils.printf('Fail to create group0 images!')
|
||||
return
|
||||
if ret1 != 'OK':
|
||||
bflb_utils.printf('Fail to create group1 images!')
|
||||
|
||||
|
||||
def create_sp_media_image(config, cpu_type=None, security=False):
|
||||
bflb_utils.printf('========= sp image create =========')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config)
|
||||
img_creat_process('group0', 1, cfg, security)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
data_bytearray = codecs.decode('42464E500100000046434647040101036699FF039F00B7E904EF0001C72052D8060232000B010B013B01BB006B01EB02EB02025000010001010002010101AB01053500000131000038FF20FF77030240770302F02C01B004B0040500FFFF030036C3DD9E5043464704040001010105000101050000010101A612AC86000144650020000000000000503100007A6345494BCABEC7307FD8F8396729EB67DDC8C63B7AD69B797B08564E982A8701000000000000000000000000000000000000D80000000000010000000000000000000000200100000001D80000000000010000000000000000000000200200000002580000000000010000000000000000000000200300000003580000000000010000D0C57503C09E750300200400000004580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000935F92BB', 'hex')
|
||||
key_bytearray = codecs.decode('fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0000102030405060708090a0b0c0d0e0f', 'hex')
|
||||
need_reverse_iv_bytearray = codecs.decode('01000000000000000000000000000000', 'hex')
|
||||
iv_bytearray = codecs.decode(reverse_iv(need_reverse_iv_bytearray), 'hex')
|
||||
img_create_encrypt_data_xts(data_bytearray, key_bytearray, iv_bytearray, 0)
|
||||
# okay decompiling ./libs/base/bl616/img_create_do.pyc
|
||||
12
libs/base/bl616/jlink_load_cfg.py
Normal file
12
libs/base/bl616/jlink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl616/jlink_load_cfg.py
|
||||
jlink_shake_hand_addr = '4201BFF0'
|
||||
jlink_data_addr = '4201C000'
|
||||
jlink_load_addr = '22010000'
|
||||
jlink_core_type = 'RISC-V'
|
||||
jlink_set_tif = 0
|
||||
jlink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl616/jlink_load_cfg.pyc
|
||||
12
libs/base/bl616/openocd_load_cfg.py
Normal file
12
libs/base/bl616/openocd_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl616/openocd_load_cfg.py
|
||||
openocd_shake_hand_addr = '4201BFF0'
|
||||
openocd_data_addr = '4201C000'
|
||||
openocd_load_addr = '22010000'
|
||||
openocd_core_type = 'RISC-V'
|
||||
openocd_set_tif = 0
|
||||
openocd_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl616/openocd_load_cfg.pyc
|
||||
343
libs/base/bl702/bootheader_cfg_keys.py
Normal file
343
libs/base/bl702/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,343 @@
|
|||
# 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/bl702/bootheader_cfg_keys.py
|
||||
bootheader_len = 176
|
||||
bootheader_cfg_keys = {'magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':'12',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':'12',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':'12',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':'16',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':'16',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':'16',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':'20',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_cmd':{'offset':'20',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_dmy_clk':{'offset':'20',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':'28',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':'28',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':'28',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':'32',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':'32',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':'32',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':'36',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_cmd':{'offset':'40',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_dmy_clk':{'offset':'40',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_cmd':{'offset':'40',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_dmy_clk':{'offset':'40',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_cmd':{'offset':'44',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_dmy_clk':{'offset':'44',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_cmd':{'offset':'44',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_dmy_clk':{'offset':'44',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_cmd':{'offset':'48',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_dmy_clk':{'offset':'48',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_page_prog_cmd':{'offset':'48',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'write_vreg_enable_cmd':{'offset':'48',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_index':{'offset':'52',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_index':{'offset':'52',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_index':{'offset':'52',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_bit_pos':{'offset':'52',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_bit_pos':{'offset':'56',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'busy_bit_pos':{'offset':'56',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_write_len':{'offset':'56',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_read_len':{'offset':'56',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_write_len':{'offset':'60',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_read_len':{'offset':'60',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'release_power_down':{'offset':'60',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_read_len':{'offset':'60',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd0':{'offset':'64',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd1':{'offset':'64',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd0':{'offset':'68',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd1':{'offset':'68',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_qpi_cmd':{'offset':'72',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'exit_qpi_cmd':{'offset':'72',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'cont_read_code':{'offset':'72',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'cont_read_exit_code':{'offset':'72',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_cmd':{'offset':'76',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_dmy_clk':{'offset':'76',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_data_mode':{'offset':'76',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_code':{'offset':'76',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd':{'offset':'80',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd_dmy_clk':{'offset':'80',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code_mode':{'offset':'80',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code':{'offset':'80',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_time':{'offset':'84',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'blk32k_erase_time':{'offset':'84',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'blk64k_erase_time':{'offset':'88',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'page_prog_time':{'offset':'88',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_time':{'offset':'92',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'power_down_delay':{'offset':'92',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qe_data':{'offset':'92',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flashcfg_crc32':{'offset':'96',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'clkcfg_magic_code':{'offset':'100',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'xtal_type':{'offset':'104',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'pll_clk':{'offset':'104',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'hclk_div':{'offset':'104',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'bclk_div':{'offset':'104',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_type':{'offset':'108',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_div':{'offset':'108',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'clkcfg_crc32':{'offset':'112',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'sign':{'offset':'116',
|
||||
'pos':'0',
|
||||
'bitlen':'2'},
|
||||
'encrypt_type':{'offset':'116',
|
||||
'pos':'2',
|
||||
'bitlen':'2'},
|
||||
'key_sel':{'offset':'116',
|
||||
'pos':'4',
|
||||
'bitlen':'2'},
|
||||
'no_segment':{'offset':'116',
|
||||
'pos':'8',
|
||||
'bitlen':'1'},
|
||||
'cache_enable':{'offset':'116',
|
||||
'pos':'9',
|
||||
'bitlen':'1'},
|
||||
'notload_in_bootrom':{'offset':'116',
|
||||
'pos':'10',
|
||||
'bitlen':'1'},
|
||||
'aes_region_lock':{'offset':'116',
|
||||
'pos':'11',
|
||||
'bitlen':'1'},
|
||||
'cache_way_disable':{'offset':'116',
|
||||
'pos':'12',
|
||||
'bitlen':'4'},
|
||||
'crc_ignore':{'offset':'116',
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'hash_ignore':{'offset':'116',
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'boot2_enable':{'offset':'116',
|
||||
'pos':'19',
|
||||
'bitlen':'1'},
|
||||
'boot2_rollback':{'offset':'116',
|
||||
'pos':'20',
|
||||
'bitlen':'1'},
|
||||
'img_len':{'offset':'120',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'bootentry':{'offset':'124',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'img_start':{'offset':'128',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_0':{'offset':'132',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_1':{'offset':'136',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_2':{'offset':'140',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_3':{'offset':'144',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_4':{'offset':'148',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_5':{'offset':'152',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_6':{'offset':'156',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_7':{'offset':'160',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_0':{'offset':'164',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_1':{'offset':'168',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'crc32':{'offset':'172',
|
||||
'pos':'0',
|
||||
'bitlen':'32'}}
|
||||
# okay decompiling ./libs/base/bl702/bootheader_cfg_keys.pyc
|
||||
62
libs/base/bl702/chiptype_patch.py
Normal file
62
libs/base/bl702/chiptype_patch.py
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# 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/bl702/chiptype_patch.py
|
||||
|
||||
|
||||
def img_load_create_predata_before_run_img():
|
||||
pre_data = bytearray(12)
|
||||
pre_data[0] = 80
|
||||
pre_data[1] = 0
|
||||
pre_data[2] = 8
|
||||
pre_data[3] = 0
|
||||
pre_data[4] = 0
|
||||
pre_data[5] = 241
|
||||
pre_data[6] = 0
|
||||
pre_data[7] = 64
|
||||
pre_data[8] = 69
|
||||
pre_data[9] = 72
|
||||
pre_data[10] = 66
|
||||
pre_data[11] = 78
|
||||
pre_data2 = bytearray(12)
|
||||
pre_data2[0] = 80
|
||||
pre_data2[1] = 0
|
||||
pre_data2[2] = 8
|
||||
pre_data2[3] = 0
|
||||
pre_data2[4] = 4
|
||||
pre_data2[5] = 241
|
||||
pre_data2[6] = 0
|
||||
pre_data2[7] = 64
|
||||
pre_data2[8] = 0
|
||||
pre_data2[9] = 0
|
||||
pre_data2[10] = 1
|
||||
pre_data2[11] = 34
|
||||
pre_data3 = bytearray(12)
|
||||
pre_data3[0] = 80
|
||||
pre_data3[1] = 0
|
||||
pre_data3[2] = 8
|
||||
pre_data3[3] = 0
|
||||
pre_data3[4] = 24
|
||||
pre_data3[5] = 0
|
||||
pre_data3[6] = 0
|
||||
pre_data3[7] = 64
|
||||
pre_data3[8] = 0
|
||||
pre_data3[9] = 0
|
||||
pre_data3[10] = 0
|
||||
pre_data3[11] = 0
|
||||
pre_data4 = bytearray(12)
|
||||
pre_data4[0] = 80
|
||||
pre_data4[1] = 0
|
||||
pre_data4[2] = 8
|
||||
pre_data4[3] = 0
|
||||
pre_data4[4] = 24
|
||||
pre_data4[5] = 0
|
||||
pre_data4[6] = 0
|
||||
pre_data4[7] = 64
|
||||
pre_data4[8] = 2
|
||||
pre_data4[9] = 0
|
||||
pre_data4[10] = 0
|
||||
pre_data4[11] = 0
|
||||
return pre_data + pre_data2 + pre_data3 + pre_data4
|
||||
# okay decompiling ./libs/base/bl702/chiptype_patch.pyc
|
||||
12
libs/base/bl702/cklink_load_cfg.py
Normal file
12
libs/base/bl702/cklink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702/cklink_load_cfg.py
|
||||
cklink_shake_hand_addr = '4202BFF0'
|
||||
cklink_data_addr = '4202C000'
|
||||
cklink_load_addr = '22010000'
|
||||
cklink_core_type = 'RISC-V'
|
||||
cklink_set_tif = 0
|
||||
cklink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702/cklink_load_cfg.pyc
|
||||
64
libs/base/bl702/flash_select_do.py
Normal file
64
libs/base/bl702/flash_select_do.py
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
# 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/bl702/flash_select_do.py
|
||||
import os, config as gol
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, conf_sign
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
|
||||
def get_suitable_file_name(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:
|
||||
bflb_utils.printf('Flash id duplicate and alternative is:')
|
||||
for i in range(len(conf_files)):
|
||||
tmp = conf_files[i].split('.')[0]
|
||||
bflb_utils.printf('%d:%s' % (i + 1, tmp))
|
||||
|
||||
return conf_files[i]
|
||||
if len(conf_files) == 1:
|
||||
return conf_files[0]
|
||||
return ''
|
||||
|
||||
|
||||
def update_flash_cfg_do(chipname, chiptype, flash_id, file=None, create=False, section=None):
|
||||
if conf_sign:
|
||||
cfg_dir = app_path + '/utils/flash/' + chipname + '/'
|
||||
else:
|
||||
cfg_dir = app_path + '/utils/flash/' + gol.flash_dict[chipname] + '/'
|
||||
conf_name = get_suitable_file_name(cfg_dir, flash_id)
|
||||
value_key = []
|
||||
if os.path.isfile(cfg_dir + conf_name) is False:
|
||||
return False
|
||||
fp = open(cfg_dir + conf_name, 'r')
|
||||
for line in fp.readlines():
|
||||
value = line.split('=')[0].strip()
|
||||
if value == '[FLASH_CFG]':
|
||||
continue
|
||||
else:
|
||||
value_key.append(value)
|
||||
|
||||
cfg1 = BFConfigParser()
|
||||
cfg1.read(cfg_dir + conf_name)
|
||||
cfg2 = BFConfigParser()
|
||||
cfg2.read(file)
|
||||
for i in range(len(value_key)):
|
||||
if cfg1.has_option('FLASH_CFG', value_key[i]):
|
||||
if cfg2.has_option(section, value_key[i]):
|
||||
tmp_value = cfg1.get('FLASH_CFG', value_key[i])
|
||||
bflb_utils.update_cfg(cfg2, section, value_key[i], tmp_value)
|
||||
|
||||
cfg2.write(file, 'w+')
|
||||
bflb_utils.printf('Update flash cfg finished')
|
||||
|
||||
|
||||
def get_supported_flash_do():
|
||||
flash_type = []
|
||||
return flash_type
|
||||
# okay decompiling ./libs/base/bl702/flash_select_do.pyc
|
||||
428
libs/base/bl702/img_create_do.py
Normal file
428
libs/base/bl702/img_create_do.py
Normal file
|
|
@ -0,0 +1,428 @@
|
|||
# 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/bl702/img_create_do.py
|
||||
import hashlib, binascii, ecdsa
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import img_create_sha256_data, img_create_encrypt_data
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl702.bootheader_cfg_keys import bootheader_len as header_len
|
||||
keyslot0 = 28
|
||||
keyslot1 = keyslot0 + 16
|
||||
keyslot2 = keyslot1 + 16
|
||||
keyslot3 = keyslot2 + 16
|
||||
keyslot4 = keyslot3 + 16
|
||||
keyslot5 = keyslot4 + 16
|
||||
keyslot6 = keyslot5 + 16
|
||||
wr_lock_key_slot_4_l = 13
|
||||
wr_lock_key_slot_5_l = 14
|
||||
wr_lock_boot_mode = 15
|
||||
wr_lock_dbg_pwd = 16
|
||||
wr_lock_sw_usage_0 = 17
|
||||
wr_lock_wifi_mac = 18
|
||||
wr_lock_key_slot_0 = 19
|
||||
wr_lock_key_slot_1 = 20
|
||||
wr_lock_key_slot_2 = 21
|
||||
wr_lock_key_slot_3 = 22
|
||||
wr_lock_key_slot_4_h = 23
|
||||
wr_lock_key_slot_5_h = 24
|
||||
rd_lock_dbg_pwd = 25
|
||||
rd_lock_key_slot_0 = 26
|
||||
rd_lock_key_slot_1 = 27
|
||||
rd_lock_key_slot_2 = 28
|
||||
rd_lock_key_slot_3 = 29
|
||||
rd_lock_key_slot_4 = 30
|
||||
rd_lock_key_slot_5 = 31
|
||||
|
||||
def img_update_efuse(cfg, sign, pk_hash, flash_encryp_type, flash_key, sec_eng_key_sel, sec_eng_key, security=False):
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'rb')
|
||||
efuse_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'rb')
|
||||
efuse_mask_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
mask_4bytes = bytearray.fromhex('FFFFFFFF')
|
||||
efuse_data[0] |= flash_encryp_type
|
||||
efuse_data[0] |= sign << 2
|
||||
if flash_encryp_type > 0:
|
||||
efuse_data[0] |= 128
|
||||
efuse_data[0] |= 48
|
||||
efuse_mask_data[0] |= 255
|
||||
rw_lock = 0
|
||||
if pk_hash is not None:
|
||||
efuse_data[keyslot0:keyslot2] = pk_hash
|
||||
efuse_mask_data[keyslot0:keyslot2] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_0
|
||||
rw_lock |= 1 << wr_lock_key_slot_1
|
||||
if flash_key is not None:
|
||||
if flash_encryp_type == 1:
|
||||
efuse_data[keyslot2:keyslot3] = flash_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
else:
|
||||
if flash_encryp_type == 2:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
else:
|
||||
if flash_encryp_type == 3:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if sec_eng_key is not None:
|
||||
if flash_encryp_type == 0:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot3:keyslot4] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot4] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if flash_encryp_type == 1:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot5:keyslot6] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_5_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_5_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_4
|
||||
efuse_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
efuse_mask_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
if security is True:
|
||||
bflb_utils.printf('Encrypt efuse data')
|
||||
security_key, security_iv = bflb_utils.get_security_key()
|
||||
efuse_data = img_create_encrypt_data(efuse_data, security_key, security_iv, 0)
|
||||
efuse_data = bytearray(4096) + efuse_data
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'wb+')
|
||||
fp.write(efuse_mask_data)
|
||||
fp.close()
|
||||
|
||||
|
||||
def img_create_get_sign_encrypt_info(bootheader_data):
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
return (
|
||||
sign, encrypt, key_sel)
|
||||
|
||||
|
||||
def img_create_get_hash_ignore(bootheader_data):
|
||||
return bootheader_data[118] >> 1 & 1
|
||||
|
||||
|
||||
def img_create_get_crc_ignore(bootheader_data):
|
||||
return bootheader_data[118] & 1
|
||||
|
||||
|
||||
def img_create_update_bootheader_if(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
if bootheader_data[118] >> 1 & 1 == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if bootheader_data[118] & 1 == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data
|
||||
|
||||
|
||||
def img_create_update_bootheader(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
if img_create_get_hash_ignore(bootheader_data) == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if img_create_get_crc_ignore(bootheader_data) == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data[0:header_len]
|
||||
|
||||
|
||||
def img_create_update_segheader(segheader, segdatalen, segdatacrc):
|
||||
segheader[4:8] = segdatalen
|
||||
segheader[8:12] = segdatacrc
|
||||
return segheader
|
||||
|
||||
|
||||
def img_create_sign_data(data_bytearray, privatekey_file_uecc, publickey_file):
|
||||
sk = ecdsa.SigningKey.from_pem(open(privatekey_file_uecc).read())
|
||||
vk = ecdsa.VerifyingKey.from_pem(open(publickey_file).read())
|
||||
pk_data = vk.to_string()
|
||||
bflb_utils.printf('Private key: ', binascii.hexlify(sk.to_string()))
|
||||
bflb_utils.printf('Public key: ', binascii.hexlify(pk_data))
|
||||
pk_hash = img_create_sha256_data(pk_data)
|
||||
bflb_utils.printf('Public key hash=', binascii.hexlify(pk_hash))
|
||||
signature = sk.sign(data_bytearray, hashfunc=(hashlib.sha256), sigencode=(ecdsa.util.sigencode_string))
|
||||
bflb_utils.printf('Signature=', binascii.hexlify(signature))
|
||||
len_array = bflb_utils.int_to_4bytearray_l(len(signature))
|
||||
sig_field = len_array + signature
|
||||
crcarray = bflb_utils.get_crc32_bytearray(sig_field)
|
||||
return (
|
||||
pk_data, pk_hash, sig_field + crcarray)
|
||||
|
||||
|
||||
def img_create_read_file_append_crc(file, crc):
|
||||
fp = open(file, 'rb')
|
||||
read_data = bytearray(fp.read())
|
||||
crcarray = bytearray(0)
|
||||
if crc:
|
||||
crcarray = bflb_utils.get_crc32_bytearray(read_data)
|
||||
fp.close()
|
||||
return read_data + crcarray
|
||||
|
||||
|
||||
def encrypt_loader_bin_do(file, sign, encrypt, temp_encrypt_key, temp_encrypt_iv, publickey_file, privatekey_file):
|
||||
if encrypt != 0 or sign != 0:
|
||||
encrypt_key = bytearray(0)
|
||||
encrypt_iv = bytearray(0)
|
||||
load_helper_bin_header = bytearray(0)
|
||||
load_helper_bin_body = bytearray(0)
|
||||
offset = 116
|
||||
sign_pos = 0
|
||||
encrypt_type_pos = 2
|
||||
key_sel_pos = 4
|
||||
pk_data = bytearray(0)
|
||||
signature = bytearray(0)
|
||||
aesiv_data = bytearray(0)
|
||||
data_tohash = bytearray(0)
|
||||
with open(file, 'rb') as fp:
|
||||
load_helper_bin = fp.read()
|
||||
load_helper_bin_header = load_helper_bin[0:header_len]
|
||||
load_helper_bin_body = load_helper_bin[header_len:]
|
||||
if load_helper_bin_header != bytearray(0):
|
||||
if load_helper_bin_body != bytearray(0):
|
||||
load_helper_bin_body = bflb_utils.add_to_16(load_helper_bin_body)
|
||||
if encrypt != 0:
|
||||
encrypt_key = bflb_utils.hexstr_to_bytearray(temp_encrypt_key)
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(temp_encrypt_iv)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
load_helper_bin_body_encrypt = bflb_utils.img_create_encrypt_data(load_helper_bin_body, encrypt_key, encrypt_iv, 0)
|
||||
else:
|
||||
load_helper_bin_body_encrypt = load_helper_bin_body
|
||||
data = bytearray(load_helper_bin_header)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = oldval
|
||||
if encrypt != 0:
|
||||
newval = newval | 1 << encrypt_type_pos
|
||||
newval = newval | 1 << key_sel_pos
|
||||
if sign != 0:
|
||||
newval = newval | 1 << sign_pos
|
||||
data_tohash += load_helper_bin_body_encrypt
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
load_helper_bin_header = data
|
||||
load_helper_bin_encrypt = load_helper_bin_header + pk_data + signature + aesiv_data + load_helper_bin_body_encrypt
|
||||
hashfun = hashlib.sha256()
|
||||
hashfun.update(data_tohash)
|
||||
hash = bflb_utils.hexstr_to_bytearray(hashfun.hexdigest())
|
||||
load_helper_bin_data = bytearray(load_helper_bin_encrypt)
|
||||
load_helper_bin_encrypt = img_create_update_bootheader_if(load_helper_bin_data, hash, 1)
|
||||
return (
|
||||
True, load_helper_bin_encrypt)
|
||||
return (False, None)
|
||||
|
||||
|
||||
def img_creat_process(flash_img, cfg, security=False):
|
||||
encrypt_blk_size = 16
|
||||
padding = bytearray(encrypt_blk_size)
|
||||
data_tohash = bytearray(0)
|
||||
cfg_section = 'Img_Cfg'
|
||||
segheader_file = []
|
||||
if flash_img == 0:
|
||||
for files in cfg.get(cfg_section, 'segheader_file').split(' '):
|
||||
segheader_file.append(str(files))
|
||||
|
||||
segdata_file = []
|
||||
for files in cfg.get(cfg_section, 'segdata_file').split('|'):
|
||||
segdata_file.append(str(files))
|
||||
if flash_img == 1:
|
||||
break
|
||||
|
||||
boot_header_file = cfg.get(cfg_section, 'boot_header_file')
|
||||
bootheader_data = img_create_read_file_append_crc(boot_header_file, 0)
|
||||
encrypt = 0
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
aesiv_data = bytearray(0)
|
||||
pk_data = bytearray(0)
|
||||
if sign != 0:
|
||||
bflb_utils.printf('Image need sign')
|
||||
publickey_file = cfg.get(cfg_section, 'publickey_file')
|
||||
privatekey_file_uecc = cfg.get(cfg_section, 'privatekey_file_uecc')
|
||||
if encrypt != 0:
|
||||
bflb_utils.printf('Image need encrypt ', encrypt)
|
||||
encrypt_key_org = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_key_org'))
|
||||
if encrypt == 1:
|
||||
encrypt_key = encrypt_key_org[0:16]
|
||||
else:
|
||||
if encrypt == 2:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
if encrypt == 3:
|
||||
encrypt_key = encrypt_key_org[0:24]
|
||||
bflb_utils.printf('Key= ', binascii.hexlify(encrypt_key))
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_iv'))
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
seg_cnt = len(segheader_file)
|
||||
if flash_img == 0:
|
||||
if seg_cnt != len(segdata_file):
|
||||
bflb_utils.printf('Segheader count and segdata count not match')
|
||||
return (
|
||||
'FAIL', data_tohash)
|
||||
data_toencrypt = bytearray(0)
|
||||
if flash_img == 0:
|
||||
i = 0
|
||||
seg_header_list = []
|
||||
seg_data_list = []
|
||||
while i < seg_cnt:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[i], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
else:
|
||||
segdata_crcarray = bflb_utils.get_crc32_bytearray(seg_data)
|
||||
seg_data_list.append(seg_data)
|
||||
seg_header = img_create_read_file_append_crc(segheader_file[i], 0)
|
||||
seg_header = img_create_update_segheader(seg_header, bflb_utils.int_to_4bytearray_l(len(seg_data)), segdata_crcarray)
|
||||
segheader_crcarray = bflb_utils.get_crc32_bytearray(seg_header)
|
||||
seg_header = seg_header + segheader_crcarray
|
||||
seg_header_list.append(seg_header)
|
||||
i = i + 1
|
||||
|
||||
i = 0
|
||||
while i < seg_cnt:
|
||||
data_toencrypt += seg_header_list[i]
|
||||
data_toencrypt += seg_data_list[i]
|
||||
i += 1
|
||||
|
||||
else:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[0], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
data_toencrypt += seg_data
|
||||
seg_cnt = len(data_toencrypt)
|
||||
if encrypt != 0:
|
||||
data_toencrypt = img_create_encrypt_data(data_toencrypt, encrypt_key, encrypt_iv, flash_img)
|
||||
fw_data = bytearray(0)
|
||||
data_tohash += data_toencrypt
|
||||
fw_data = data_toencrypt
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
bootheader_data = img_create_update_bootheader(bootheader_data, hash, seg_cnt)
|
||||
signature = bytearray(0)
|
||||
pk_hash = None
|
||||
if sign == 1:
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file_uecc, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
if flash_img == 1:
|
||||
bflb_utils.printf('Write flash img')
|
||||
bootinfo_file_name = cfg.get(cfg_section, 'bootinfo_file')
|
||||
fp = open(bootinfo_file_name, 'wb+')
|
||||
bootinfo = bootheader_data + pk_data + signature + aesiv_data
|
||||
fp.write(bootinfo)
|
||||
fp.close()
|
||||
fw_file_name = cfg.get(cfg_section, 'img_file')
|
||||
fp = open(fw_file_name, 'wb+')
|
||||
fp.write(fw_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, encrypt, None, key_sel, None, security)
|
||||
else:
|
||||
bflb_utils.printf('Write if img')
|
||||
whole_img_file_name = cfg.get(cfg_section, 'whole_img_file')
|
||||
fp = open(whole_img_file_name, 'wb+')
|
||||
img_data = bootheader_data + pk_data + signature + aesiv_data + fw_data
|
||||
fp.write(img_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, 0, None, key_sel, bytearray(32), security)
|
||||
return (
|
||||
'OK', data_tohash)
|
||||
|
||||
|
||||
def img_create_do(args, img_dir_path=None, config_file=None):
|
||||
bflb_utils.printf('Image create path: ', img_dir_path)
|
||||
if config_file is None:
|
||||
config_file = img_dir_path + '/img_create_cfg.ini'
|
||||
bflb_utils.printf('Config file: ', config_file)
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
img_type = 'media'
|
||||
signer = 'none'
|
||||
security = False
|
||||
data_tohash = bytearray(0)
|
||||
try:
|
||||
if args.image:
|
||||
img_type = args.image
|
||||
if args.signer:
|
||||
signer = args.signer
|
||||
if args.security:
|
||||
security = args.security == 'efuse'
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
if img_type == 'media':
|
||||
flash_img = 1
|
||||
else:
|
||||
flash_img = 0
|
||||
ret, data_tohash = img_creat_process(flash_img, cfg, security)
|
||||
if ret != 'OK':
|
||||
bflb_utils.printf('Fail to create images!')
|
||||
|
||||
|
||||
def create_sp_media_image(config, cpu_type=None, security=False):
|
||||
bflb_utils.printf('========= sp image create =========')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config)
|
||||
img_creat_process(1, cfg, security)
|
||||
# okay decompiling ./libs/base/bl702/img_create_do.pyc
|
||||
12
libs/base/bl702/jlink_load_cfg.py
Normal file
12
libs/base/bl702/jlink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702/jlink_load_cfg.py
|
||||
jlink_shake_hand_addr = '4202BFF0'
|
||||
jlink_data_addr = '4202C000'
|
||||
jlink_load_addr = '22010000'
|
||||
jlink_core_type = 'RISC-V'
|
||||
jlink_set_tif = 0
|
||||
jlink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702/jlink_load_cfg.pyc
|
||||
12
libs/base/bl702/openocd_load_cfg.py
Normal file
12
libs/base/bl702/openocd_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702/openocd_load_cfg.py
|
||||
openocd_shake_hand_addr = '4202BFF0'
|
||||
openocd_data_addr = '4202C000'
|
||||
openocd_load_addr = '22010000'
|
||||
openocd_core_type = 'RISC-V'
|
||||
openocd_set_tif = 0
|
||||
openocd_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702/openocd_load_cfg.pyc
|
||||
391
libs/base/bl702l/bootheader_cfg_keys.py
Normal file
391
libs/base/bl702l/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,391 @@
|
|||
# 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/bl702l/bootheader_cfg_keys.py
|
||||
bootheader_len = 240
|
||||
bootheader_cfg_keys = {'magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':'12',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':'12',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':'12',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':'16',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':'16',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':'16',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':'20',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_cmd':{'offset':'20',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_jedecid_dmy_clk':{'offset':'20',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':'28',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':'28',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':'28',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':'32',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':'32',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':'32',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':'36',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_cmd':{'offset':'40',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_dmy_clk':{'offset':'40',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_cmd':{'offset':'40',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_dmy_clk':{'offset':'40',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_cmd':{'offset':'44',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_dmy_clk':{'offset':'44',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_cmd':{'offset':'44',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_dmy_clk':{'offset':'44',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_cmd':{'offset':'48',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_dmy_clk':{'offset':'48',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_page_prog_cmd':{'offset':'48',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'write_vreg_enable_cmd':{'offset':'48',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_index':{'offset':'52',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_index':{'offset':'52',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_index':{'offset':'52',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_bit_pos':{'offset':'52',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_bit_pos':{'offset':'56',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'busy_bit_pos':{'offset':'56',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_write_len':{'offset':'56',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_read_len':{'offset':'56',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_write_len':{'offset':'60',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_read_len':{'offset':'60',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'release_power_down':{'offset':'60',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_read_len':{'offset':'60',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd0':{'offset':'64',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd1':{'offset':'64',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd0':{'offset':'68',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd1':{'offset':'68',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_qpi_cmd':{'offset':'72',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'exit_qpi_cmd':{'offset':'72',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'cont_read_code':{'offset':'72',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'cont_read_exit_code':{'offset':'72',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_cmd':{'offset':'76',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_dmy_clk':{'offset':'76',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_data_mode':{'offset':'76',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_code':{'offset':'76',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd':{'offset':'80',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd_dmy_clk':{'offset':'80',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code_mode':{'offset':'80',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code':{'offset':'80',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_time':{'offset':'84',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'blk32k_erase_time':{'offset':'84',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'blk64k_erase_time':{'offset':'88',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'page_prog_time':{'offset':'88',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_time':{'offset':'92',
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'power_down_delay':{'offset':'92',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qe_data':{'offset':'92',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flashcfg_crc32':{'offset':'96',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'clkcfg_magic_code':{'offset':'100',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'xtal_type':{'offset':'104',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'pll_clk':{'offset':'104',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'hclk_div':{'offset':'104',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'bclk_div':{'offset':'104',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_type':{'offset':'108',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_div':{'offset':'108',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'clkcfg_crc32':{'offset':'112',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'sign':{'offset':'116',
|
||||
'pos':'0',
|
||||
'bitlen':'2'},
|
||||
'encrypt_type':{'offset':'116',
|
||||
'pos':'2',
|
||||
'bitlen':'2'},
|
||||
'key_sel':{'offset':'116',
|
||||
'pos':'4',
|
||||
'bitlen':'2'},
|
||||
'no_segment':{'offset':'116',
|
||||
'pos':'8',
|
||||
'bitlen':'1'},
|
||||
'cache_enable':{'offset':'116',
|
||||
'pos':'9',
|
||||
'bitlen':'1'},
|
||||
'notload_in_bootrom':{'offset':'116',
|
||||
'pos':'10',
|
||||
'bitlen':'1'},
|
||||
'aes_region_lock':{'offset':'116',
|
||||
'pos':'11',
|
||||
'bitlen':'1'},
|
||||
'cache_way_disable':{'offset':'116',
|
||||
'pos':'12',
|
||||
'bitlen':'4'},
|
||||
'crc_ignore':{'offset':'116',
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'hash_ignore':{'offset':'116',
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'boot2_enable':{'offset':'116',
|
||||
'pos':'19',
|
||||
'bitlen':'1'},
|
||||
'boot2_rollback':{'offset':'116',
|
||||
'pos':'20',
|
||||
'bitlen':'1'},
|
||||
'img_len':{'offset':'120',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'bootentry':{'offset':'124',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'img_start':{'offset':'128',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_0':{'offset':'132',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_1':{'offset':'136',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_2':{'offset':'140',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_3':{'offset':'144',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_4':{'offset':'148',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_5':{'offset':'152',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_6':{'offset':'156',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'hash_7':{'offset':'160',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_0':{'offset':'164',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'boot2_pt_table_1':{'offset':'168',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashCfgTableAddr':{'offset':'172',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashCfgTableLen':{'offset':'176',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr0':{'offset':'180',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value0':{'offset':'184',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr1':{'offset':'188',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value1':{'offset':'192',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_addr2':{'offset':'196',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value2':{'offset':'200',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr0':{'offset':'204',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value0':{'offset':'208',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr1':{'offset':'212',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value1':{'offset':'216',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_addr2':{'offset':'220',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value2':{'offset':'224',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved1':{'offset':'228',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved2':{'offset':'232',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'crc32':{'offset':'236',
|
||||
'pos':'0',
|
||||
'bitlen':'32'}}
|
||||
# okay decompiling ./libs/base/bl702l/bootheader_cfg_keys.pyc
|
||||
62
libs/base/bl702l/chiptype_patch.py
Normal file
62
libs/base/bl702l/chiptype_patch.py
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# 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/bl702l/chiptype_patch.py
|
||||
|
||||
|
||||
def img_load_create_predata_before_run_img():
|
||||
pre_data = bytearray(12)
|
||||
pre_data[0] = 80
|
||||
pre_data[1] = 0
|
||||
pre_data[2] = 8
|
||||
pre_data[3] = 0
|
||||
pre_data[4] = 0
|
||||
pre_data[5] = 241
|
||||
pre_data[6] = 0
|
||||
pre_data[7] = 64
|
||||
pre_data[8] = 69
|
||||
pre_data[9] = 72
|
||||
pre_data[10] = 66
|
||||
pre_data[11] = 78
|
||||
pre_data2 = bytearray(12)
|
||||
pre_data2[0] = 80
|
||||
pre_data2[1] = 0
|
||||
pre_data2[2] = 8
|
||||
pre_data2[3] = 0
|
||||
pre_data2[4] = 4
|
||||
pre_data2[5] = 241
|
||||
pre_data2[6] = 0
|
||||
pre_data2[7] = 64
|
||||
pre_data2[8] = 0
|
||||
pre_data2[9] = 0
|
||||
pre_data2[10] = 1
|
||||
pre_data2[11] = 34
|
||||
pre_data3 = bytearray(12)
|
||||
pre_data3[0] = 80
|
||||
pre_data3[1] = 0
|
||||
pre_data3[2] = 8
|
||||
pre_data3[3] = 0
|
||||
pre_data3[4] = 24
|
||||
pre_data3[5] = 0
|
||||
pre_data3[6] = 0
|
||||
pre_data3[7] = 64
|
||||
pre_data3[8] = 0
|
||||
pre_data3[9] = 0
|
||||
pre_data3[10] = 0
|
||||
pre_data3[11] = 0
|
||||
pre_data4 = bytearray(12)
|
||||
pre_data4[0] = 80
|
||||
pre_data4[1] = 0
|
||||
pre_data4[2] = 8
|
||||
pre_data4[3] = 0
|
||||
pre_data4[4] = 24
|
||||
pre_data4[5] = 0
|
||||
pre_data4[6] = 0
|
||||
pre_data4[7] = 64
|
||||
pre_data4[8] = 2
|
||||
pre_data4[9] = 0
|
||||
pre_data4[10] = 0
|
||||
pre_data4[11] = 0
|
||||
return pre_data + pre_data2 + pre_data3 + pre_data4
|
||||
# okay decompiling ./libs/base/bl702l/chiptype_patch.pyc
|
||||
12
libs/base/bl702l/cklink_load_cfg.py
Normal file
12
libs/base/bl702l/cklink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702l/cklink_load_cfg.py
|
||||
cklink_shake_hand_addr = '4202BFF0'
|
||||
cklink_data_addr = '4202C000'
|
||||
cklink_load_addr = '22010000'
|
||||
cklink_core_type = 'RISC-V'
|
||||
cklink_set_tif = 0
|
||||
cklink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702l/cklink_load_cfg.pyc
|
||||
151
libs/base/bl702l/flash_select_do.py
Normal file
151
libs/base/bl702l/flash_select_do.py
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
# 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/bl702l/flash_select_do.py
|
||||
import os, csv, config as gol
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import app_path, conf_sign
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl702l.bootheader_cfg_keys import bootheader_cfg_keys as flash_cfg_keys
|
||||
|
||||
def get_suitable_file_name(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:
|
||||
bflb_utils.printf('Flash id duplicate and alternative is:')
|
||||
for i in range(len(conf_files)):
|
||||
tmp = conf_files[i].split('.')[0]
|
||||
bflb_utils.printf('%d:%s' % (i + 1, tmp))
|
||||
|
||||
return conf_files[i]
|
||||
if len(conf_files) == 1:
|
||||
return conf_files[0]
|
||||
return ''
|
||||
|
||||
|
||||
def update_flash_cfg_do(chipname, chiptype, flash_id, file=None, create=False, section=None):
|
||||
if conf_sign:
|
||||
cfg_dir = app_path + '/utils/flash/' + chipname + '/'
|
||||
else:
|
||||
cfg_dir = app_path + '/utils/flash/' + gol.flash_dict[chipname] + '/'
|
||||
conf_name = get_suitable_file_name(cfg_dir, flash_id)
|
||||
value_key = []
|
||||
if os.path.isfile(cfg_dir + conf_name) is False:
|
||||
return False
|
||||
fp = open(cfg_dir + conf_name, 'r')
|
||||
for line in fp.readlines():
|
||||
value = line.split('=')[0].strip()
|
||||
if value == '[FLASH_CFG]':
|
||||
continue
|
||||
else:
|
||||
value_key.append(value)
|
||||
|
||||
cfg1 = BFConfigParser()
|
||||
cfg1.read(cfg_dir + conf_name)
|
||||
cfg2 = BFConfigParser()
|
||||
cfg2.read(file)
|
||||
for i in range(len(value_key)):
|
||||
if cfg1.has_option('FLASH_CFG', value_key[i]):
|
||||
if cfg2.has_option(section, value_key[i]):
|
||||
tmp_value = cfg1.get('FLASH_CFG', value_key[i])
|
||||
bflb_utils.update_cfg(cfg2, section, value_key[i], tmp_value)
|
||||
|
||||
cfg2.write(file, 'w+')
|
||||
bflb_utils.printf('Update flash cfg finished')
|
||||
|
||||
|
||||
def get_supported_flash_do():
|
||||
flash_type = []
|
||||
return flash_type
|
||||
|
||||
|
||||
def get_int_mask(pos, length):
|
||||
ones = '11111111111111111111111111111111'
|
||||
zeros = '00000000000000000000000000000000'
|
||||
mask = ones[0:32 - pos - length] + zeros[0:length] + ones[0:pos]
|
||||
return int(mask, 2)
|
||||
|
||||
|
||||
def create_flashcfg_data_from_cfg(cfg_len, cfgfile):
|
||||
section = 'FLASH_CFG'
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(cfgfile)
|
||||
data = bytearray(cfg_len)
|
||||
minOffset = int(flash_cfg_keys.get('io_mode')['offset'], 10)
|
||||
for key in cfg.options(section):
|
||||
if flash_cfg_keys.get(key) == None:
|
||||
bflb_utils.printf(key + ' not exist')
|
||||
continue
|
||||
else:
|
||||
val = cfg.get(section, key)
|
||||
if val.startswith('0x'):
|
||||
val = int(val, 16)
|
||||
else:
|
||||
val = int(val, 10)
|
||||
offset = int(flash_cfg_keys.get(key)['offset'], 10) - minOffset
|
||||
pos = int(flash_cfg_keys.get(key)['pos'], 10)
|
||||
bitlen = int(flash_cfg_keys.get(key)['bitlen'], 10)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = (oldval & get_int_mask(pos, bitlen)) + (val << pos)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
|
||||
crcarray = bflb_utils.get_crc32_bytearray(data)
|
||||
data = bflb_utils.int_to_4bytearray_l(1195787078) + data + crcarray
|
||||
return data
|
||||
|
||||
|
||||
def create_flashcfg_table(start_addr):
|
||||
single_flashcfg_len = 92
|
||||
flash_table_list = bytearray(0)
|
||||
flash_table_data = bytearray(0)
|
||||
if conf_sign:
|
||||
table_file = os.path.join(app_path, 'utils', 'flash', 'bl702l', 'flashcfg_list.csv')
|
||||
else:
|
||||
table_file = os.path.join(app_path, 'utils', 'flash', 'bl702l', 'flashcfg_list.csv')
|
||||
with open(table_file, 'r', encoding='utf-8-sig') as csvfile:
|
||||
table_list = []
|
||||
cfgfile_list = []
|
||||
reader = csv.DictReader(csvfile)
|
||||
cnt = 0
|
||||
for row in reader:
|
||||
row_dict = {}
|
||||
row_dict['jid'] = row.get('flashJedecID', '')
|
||||
row_dict['cfgfile'] = row.get('configFile', '')
|
||||
if row_dict['cfgfile'] not in cfgfile_list:
|
||||
cfgfile_list.append(row_dict['cfgfile'])
|
||||
else:
|
||||
table_list.append(row_dict)
|
||||
cnt += 1
|
||||
|
||||
table_list_len = 4 + cnt * 8 + 4
|
||||
for cfgfile in cfgfile_list:
|
||||
if conf_sign:
|
||||
cfgfile = os.path.join(app_path, 'utils', 'flash', 'bl702l', cfgfile)
|
||||
else:
|
||||
cfgfile = os.path.join(app_path, 'utils', 'flash', 'bl702l', cfgfile)
|
||||
data = create_flashcfg_data_from_cfg(single_flashcfg_len - 8, cfgfile)
|
||||
flash_table_data += data
|
||||
|
||||
for dict in table_list:
|
||||
flash_table_list += bflb_utils.int_to_4bytearray_b(int(dict['jid'] + '00', 16))
|
||||
i = 0
|
||||
offset = 0
|
||||
for cfgfile in cfgfile_list:
|
||||
if cfgfile == dict['cfgfile']:
|
||||
offset = start_addr + table_list_len + single_flashcfg_len * i
|
||||
break
|
||||
else:
|
||||
i += 1
|
||||
|
||||
flash_table_list += bflb_utils.int_to_4bytearray_l(offset)
|
||||
|
||||
crcarray = bflb_utils.get_crc32_bytearray(flash_table_list)
|
||||
flash_table_list = bflb_utils.int_to_4bytearray_l(1196704582) + flash_table_list + crcarray
|
||||
return (
|
||||
flash_table_list, flash_table_data, len(flash_table_list))
|
||||
# okay decompiling ./libs/base/bl702l/flash_select_do.pyc
|
||||
438
libs/base/bl702l/img_create_do.py
Normal file
438
libs/base/bl702l/img_create_do.py
Normal file
|
|
@ -0,0 +1,438 @@
|
|||
# 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/bl702l/img_create_do.py
|
||||
import hashlib, binascii, ecdsa
|
||||
from libs import bflb_utils
|
||||
from libs.bflb_utils import img_create_sha256_data, img_create_encrypt_data
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl702l.flash_select_do import create_flashcfg_table
|
||||
from libs.base.bl702l.bootheader_cfg_keys import bootheader_len as header_len
|
||||
keyslot0 = 28
|
||||
keyslot1 = keyslot0 + 16
|
||||
keyslot2 = keyslot1 + 16
|
||||
keyslot3 = keyslot2 + 16
|
||||
keyslot4 = keyslot3 + 16
|
||||
keyslot5 = keyslot4 + 16
|
||||
keyslot6 = keyslot5 + 16
|
||||
wr_lock_key_slot_4_l = 13
|
||||
wr_lock_key_slot_5_l = 14
|
||||
wr_lock_boot_mode = 15
|
||||
wr_lock_dbg_pwd = 16
|
||||
wr_lock_sw_usage_0 = 17
|
||||
wr_lock_wifi_mac = 18
|
||||
wr_lock_key_slot_0 = 19
|
||||
wr_lock_key_slot_1 = 20
|
||||
wr_lock_key_slot_2 = 21
|
||||
wr_lock_key_slot_3 = 22
|
||||
wr_lock_key_slot_4_h = 23
|
||||
wr_lock_key_slot_5_h = 24
|
||||
rd_lock_dbg_pwd = 25
|
||||
rd_lock_key_slot_0 = 26
|
||||
rd_lock_key_slot_1 = 27
|
||||
rd_lock_key_slot_2 = 28
|
||||
rd_lock_key_slot_3 = 29
|
||||
rd_lock_key_slot_4 = 30
|
||||
rd_lock_key_slot_5 = 31
|
||||
|
||||
def img_update_efuse(cfg, sign, pk_hash, flash_encryp_type, flash_key, sec_eng_key_sel, sec_eng_key, security=False):
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'rb')
|
||||
efuse_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'rb')
|
||||
efuse_mask_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
mask_4bytes = bytearray.fromhex('FFFFFFFF')
|
||||
efuse_data[0] |= flash_encryp_type
|
||||
efuse_data[0] |= sign << 2
|
||||
if flash_encryp_type > 0:
|
||||
efuse_data[0] |= 128
|
||||
efuse_data[0] |= 48
|
||||
efuse_mask_data[0] |= 255
|
||||
rw_lock = 0
|
||||
if pk_hash is not None:
|
||||
efuse_data[keyslot0:keyslot2] = pk_hash
|
||||
efuse_mask_data[keyslot0:keyslot2] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_0
|
||||
rw_lock |= 1 << wr_lock_key_slot_1
|
||||
if flash_key is not None:
|
||||
if flash_encryp_type == 1:
|
||||
efuse_data[keyslot2:keyslot3] = flash_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
else:
|
||||
if flash_encryp_type == 2:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
else:
|
||||
if flash_encryp_type == 3:
|
||||
efuse_data[keyslot2:keyslot4] = flash_key
|
||||
efuse_mask_data[keyslot2:keyslot4] = mask_4bytes * 8
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if sec_eng_key is not None:
|
||||
if flash_encryp_type == 0:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot3:keyslot4] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot3:keyslot4] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_3
|
||||
rw_lock |= 1 << rd_lock_key_slot_3
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot2:keyslot3] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot2:keyslot3] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_2
|
||||
rw_lock |= 1 << rd_lock_key_slot_2
|
||||
if flash_encryp_type == 1:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot5:keyslot6] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_5_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_5_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot5] = mask_4bytes * 4
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_l
|
||||
rw_lock |= 1 << wr_lock_key_slot_4_h
|
||||
rw_lock |= 1 << rd_lock_key_slot_4
|
||||
efuse_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
efuse_mask_data[124:128] = bflb_utils.int_to_4bytearray_l(rw_lock)
|
||||
if security is True:
|
||||
bflb_utils.printf('Encrypt efuse data')
|
||||
security_key, security_iv = bflb_utils.get_security_key()
|
||||
efuse_data = img_create_encrypt_data(efuse_data, security_key, security_iv, 0)
|
||||
efuse_data = bytearray(4096) + efuse_data
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_file'), 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Cfg', 'efuse_mask_file'), 'wb+')
|
||||
fp.write(efuse_mask_data)
|
||||
fp.close()
|
||||
|
||||
|
||||
def img_create_get_sign_encrypt_info(bootheader_data):
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
return (
|
||||
sign, encrypt, key_sel)
|
||||
|
||||
|
||||
def img_create_get_hash_ignore(bootheader_data):
|
||||
return bootheader_data[118] >> 1 & 1
|
||||
|
||||
|
||||
def img_create_get_crc_ignore(bootheader_data):
|
||||
return bootheader_data[118] & 1
|
||||
|
||||
|
||||
def img_create_update_bootheader_if(bootheader_data, hash, seg_cnt):
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign = bootheader_data[116] & 3
|
||||
encrypt = bootheader_data[116] >> 2 & 3
|
||||
key_sel = bootheader_data[116] >> 4 & 3
|
||||
if bootheader_data[118] >> 1 & 1 == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if bootheader_data[118] & 1 == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data
|
||||
|
||||
|
||||
def img_create_update_bootheader(bootheader_data, hash, seg_cnt, flashcfg_table_addr, flashcfg_table_len):
|
||||
bootheader_data[172:176] = bflb_utils.int_to_4bytearray_l(flashcfg_table_addr)
|
||||
bootheader_data[176:180] = bflb_utils.int_to_4bytearray_l(flashcfg_table_len)
|
||||
bootheader_data[120:124] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
if img_create_get_hash_ignore(bootheader_data) == 1 and sign == 0:
|
||||
bflb_utils.printf('Hash ignored')
|
||||
else:
|
||||
bootheader_data[132:164] = hash
|
||||
if img_create_get_crc_ignore(bootheader_data) == 1:
|
||||
bflb_utils.printf('Header crc ignored')
|
||||
else:
|
||||
hd_crcarray = bflb_utils.get_crc32_bytearray(bootheader_data[0:header_len - 4])
|
||||
bootheader_data[header_len - 4:header_len] = hd_crcarray
|
||||
bflb_utils.printf('Header crc: ', binascii.hexlify(hd_crcarray))
|
||||
return bootheader_data[0:header_len]
|
||||
|
||||
|
||||
def img_create_update_segheader(segheader, segdatalen, segdatacrc):
|
||||
segheader[4:8] = segdatalen
|
||||
segheader[8:12] = segdatacrc
|
||||
return segheader
|
||||
|
||||
|
||||
def img_create_sign_data(data_bytearray, privatekey_file_uecc, publickey_file):
|
||||
sk = ecdsa.SigningKey.from_pem(open(privatekey_file_uecc).read())
|
||||
vk = ecdsa.VerifyingKey.from_pem(open(publickey_file).read())
|
||||
pk_data = vk.to_string()
|
||||
bflb_utils.printf('Private key: ', binascii.hexlify(sk.to_string()))
|
||||
bflb_utils.printf('Public key: ', binascii.hexlify(pk_data))
|
||||
pk_hash = img_create_sha256_data(pk_data)
|
||||
bflb_utils.printf('Public key hash=', binascii.hexlify(pk_hash))
|
||||
signature = sk.sign(data_bytearray, hashfunc=(hashlib.sha256), sigencode=(ecdsa.util.sigencode_string))
|
||||
bflb_utils.printf('Signature=', binascii.hexlify(signature))
|
||||
len_array = bflb_utils.int_to_4bytearray_l(len(signature))
|
||||
sig_field = len_array + signature
|
||||
crcarray = bflb_utils.get_crc32_bytearray(sig_field)
|
||||
return (
|
||||
pk_data, pk_hash, sig_field + crcarray)
|
||||
|
||||
|
||||
def img_create_read_file_append_crc(file, crc):
|
||||
fp = open(file, 'rb')
|
||||
read_data = bytearray(fp.read())
|
||||
crcarray = bytearray(0)
|
||||
if crc:
|
||||
crcarray = bflb_utils.get_crc32_bytearray(read_data)
|
||||
fp.close()
|
||||
return read_data + crcarray
|
||||
|
||||
|
||||
def encrypt_loader_bin_do(file, sign, encrypt, temp_encrypt_key, temp_encrypt_iv, publickey_file, privatekey_file):
|
||||
if encrypt != 0 or sign != 0:
|
||||
encrypt_key = bytearray(0)
|
||||
encrypt_iv = bytearray(0)
|
||||
load_helper_bin_header = bytearray(0)
|
||||
load_helper_bin_body = bytearray(0)
|
||||
offset = 116
|
||||
sign_pos = 0
|
||||
encrypt_type_pos = 2
|
||||
key_sel_pos = 4
|
||||
pk_data = bytearray(0)
|
||||
signature = bytearray(0)
|
||||
aesiv_data = bytearray(0)
|
||||
data_tohash = bytearray(0)
|
||||
with open(file, 'rb') as fp:
|
||||
load_helper_bin = fp.read()
|
||||
load_helper_bin_header = load_helper_bin[0:header_len]
|
||||
load_helper_bin_body = load_helper_bin[header_len:]
|
||||
if load_helper_bin_header != bytearray(0):
|
||||
if load_helper_bin_body != bytearray(0):
|
||||
load_helper_bin_body = bflb_utils.add_to_16(load_helper_bin_body)
|
||||
if encrypt != 0:
|
||||
encrypt_key = bflb_utils.hexstr_to_bytearray(temp_encrypt_key)
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(temp_encrypt_iv)
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
load_helper_bin_body_encrypt = bflb_utils.img_create_encrypt_data(load_helper_bin_body, encrypt_key, encrypt_iv, 0)
|
||||
else:
|
||||
load_helper_bin_body_encrypt = load_helper_bin_body
|
||||
data = bytearray(load_helper_bin_header)
|
||||
oldval = bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(data[offset:offset + 4]))
|
||||
newval = oldval
|
||||
if encrypt != 0:
|
||||
newval = newval | 1 << encrypt_type_pos
|
||||
newval = newval | 1 << key_sel_pos
|
||||
if sign != 0:
|
||||
newval = newval | 1 << sign_pos
|
||||
data_tohash += load_helper_bin_body_encrypt
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
data[offset:offset + 4] = bflb_utils.int_to_4bytearray_l(newval)
|
||||
load_helper_bin_header = data
|
||||
load_helper_bin_encrypt = load_helper_bin_header + pk_data + signature + aesiv_data + load_helper_bin_body_encrypt
|
||||
hashfun = hashlib.sha256()
|
||||
hashfun.update(data_tohash)
|
||||
hash = bflb_utils.hexstr_to_bytearray(hashfun.hexdigest())
|
||||
load_helper_bin_data = bytearray(load_helper_bin_encrypt)
|
||||
load_helper_bin_encrypt = img_create_update_bootheader_if(load_helper_bin_data, hash, 1)
|
||||
return (
|
||||
True, load_helper_bin_encrypt)
|
||||
return (False, None)
|
||||
|
||||
|
||||
def img_creat_process(flash_img, cfg, security=False):
|
||||
encrypt_blk_size = 16
|
||||
padding = bytearray(encrypt_blk_size)
|
||||
data_tohash = bytearray(0)
|
||||
cfg_section = 'Img_Cfg'
|
||||
segheader_file = []
|
||||
if flash_img == 0:
|
||||
for files in cfg.get(cfg_section, 'segheader_file').split(' '):
|
||||
segheader_file.append(str(files))
|
||||
|
||||
segdata_file = []
|
||||
for files in cfg.get(cfg_section, 'segdata_file').split('|'):
|
||||
segdata_file.append(str(files))
|
||||
if flash_img == 1:
|
||||
break
|
||||
|
||||
boot_header_file = cfg.get(cfg_section, 'boot_header_file')
|
||||
bootheader_data = img_create_read_file_append_crc(boot_header_file, 0)
|
||||
encrypt = 0
|
||||
sign, encrypt, key_sel = img_create_get_sign_encrypt_info(bootheader_data)
|
||||
aesiv_data = bytearray(0)
|
||||
pk_data = bytearray(0)
|
||||
if sign != 0:
|
||||
bflb_utils.printf('Image need sign')
|
||||
publickey_file = cfg.get(cfg_section, 'publickey_file')
|
||||
privatekey_file_uecc = cfg.get(cfg_section, 'privatekey_file_uecc')
|
||||
if encrypt != 0:
|
||||
bflb_utils.printf('Image need encrypt ', encrypt)
|
||||
encrypt_key_org = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_key_org'))
|
||||
if encrypt == 1:
|
||||
encrypt_key = encrypt_key_org[0:16]
|
||||
else:
|
||||
if encrypt == 2:
|
||||
encrypt_key = encrypt_key_org[0:32]
|
||||
else:
|
||||
if encrypt == 3:
|
||||
encrypt_key = encrypt_key_org[0:24]
|
||||
bflb_utils.printf('Key= ', binascii.hexlify(encrypt_key))
|
||||
encrypt_iv = bflb_utils.hexstr_to_bytearray(cfg.get(cfg_section, 'aes_iv'))
|
||||
iv_crcarray = bflb_utils.get_crc32_bytearray(encrypt_iv)
|
||||
aesiv_data = encrypt_iv + iv_crcarray
|
||||
data_tohash = data_tohash + aesiv_data
|
||||
seg_cnt = len(segheader_file)
|
||||
if flash_img == 0:
|
||||
if seg_cnt != len(segdata_file):
|
||||
bflb_utils.printf('Segheader count and segdata count not match')
|
||||
return (
|
||||
'FAIL', data_tohash)
|
||||
data_toencrypt = bytearray(0)
|
||||
if flash_img == 0:
|
||||
i = 0
|
||||
seg_header_list = []
|
||||
seg_data_list = []
|
||||
while i < seg_cnt:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[i], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
else:
|
||||
segdata_crcarray = bflb_utils.get_crc32_bytearray(seg_data)
|
||||
seg_data_list.append(seg_data)
|
||||
seg_header = img_create_read_file_append_crc(segheader_file[i], 0)
|
||||
seg_header = img_create_update_segheader(seg_header, bflb_utils.int_to_4bytearray_l(len(seg_data)), segdata_crcarray)
|
||||
segheader_crcarray = bflb_utils.get_crc32_bytearray(seg_header)
|
||||
seg_header = seg_header + segheader_crcarray
|
||||
seg_header_list.append(seg_header)
|
||||
i = i + 1
|
||||
|
||||
i = 0
|
||||
while i < seg_cnt:
|
||||
data_toencrypt += seg_header_list[i]
|
||||
data_toencrypt += seg_data_list[i]
|
||||
i += 1
|
||||
|
||||
else:
|
||||
seg_data = img_create_read_file_append_crc(segdata_file[0], 0)
|
||||
padding_size = 0
|
||||
if len(seg_data) % encrypt_blk_size != 0:
|
||||
padding_size = encrypt_blk_size - len(seg_data) % encrypt_blk_size
|
||||
seg_data += padding[0:padding_size]
|
||||
data_toencrypt += seg_data
|
||||
seg_cnt = len(data_toencrypt)
|
||||
if encrypt != 0:
|
||||
data_toencrypt = img_create_encrypt_data(data_toencrypt, encrypt_key, encrypt_iv, flash_img)
|
||||
fw_data = bytearray(0)
|
||||
data_tohash += data_toencrypt
|
||||
fw_data = data_toencrypt
|
||||
hash = img_create_sha256_data(data_tohash)
|
||||
bflb_utils.printf('Image hash is ', binascii.hexlify(hash))
|
||||
signature = bytearray(0)
|
||||
pk_hash = None
|
||||
if sign == 1:
|
||||
pk_data, pk_hash, signature = img_create_sign_data(data_tohash, privatekey_file_uecc, publickey_file)
|
||||
pk_data = pk_data + bflb_utils.get_crc32_bytearray(pk_data)
|
||||
flashCfgAddr = len(bootheader_data + pk_data + signature + aesiv_data)
|
||||
flashCfgListLen = 0
|
||||
flashCfgList = bytearray(0)
|
||||
flashCfgTable = bytearray(0)
|
||||
if flash_img == 1:
|
||||
if bootheader_data[25:26] == b'\xff':
|
||||
flashCfgList, flashCfgTable, flashCfgListLen = create_flashcfg_table(flashCfgAddr)
|
||||
bootheader_data = img_create_update_bootheader(bootheader_data, hash, seg_cnt, flashCfgAddr, flashCfgListLen)
|
||||
if flash_img == 1:
|
||||
bflb_utils.printf('Write flash img')
|
||||
bootinfo_file_name = cfg.get(cfg_section, 'bootinfo_file')
|
||||
fp = open(bootinfo_file_name, 'wb+')
|
||||
bootinfo = bootheader_data + pk_data + signature + aesiv_data + flashCfgList + flashCfgTable
|
||||
fp.write(bootinfo)
|
||||
fp.close()
|
||||
fw_file_name = cfg.get(cfg_section, 'img_file')
|
||||
fp = open(fw_file_name, 'wb+')
|
||||
fp.write(fw_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, encrypt_key + bytearray(32 - len(encrypt_key)), key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, encrypt, None, key_sel, None, security)
|
||||
else:
|
||||
bflb_utils.printf('Write if img')
|
||||
whole_img_file_name = cfg.get(cfg_section, 'whole_img_file')
|
||||
fp = open(whole_img_file_name, 'wb+')
|
||||
img_data = bootheader_data + pk_data + signature + aesiv_data + fw_data
|
||||
fp.write(img_data)
|
||||
fp.close()
|
||||
if encrypt != 0:
|
||||
if encrypt == 1:
|
||||
img_update_efuse(cfg, sign, pk_hash, 1, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 2:
|
||||
img_update_efuse(cfg, sign, pk_hash, 3, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
if encrypt == 3:
|
||||
img_update_efuse(cfg, sign, pk_hash, 2, None, key_sel, encrypt_key + bytearray(32 - len(encrypt_key)), security)
|
||||
else:
|
||||
img_update_efuse(cfg, sign, pk_hash, 0, None, key_sel, bytearray(32), security)
|
||||
return (
|
||||
'OK', data_tohash)
|
||||
|
||||
|
||||
def img_create_do(args, img_dir_path=None, config_file=None):
|
||||
bflb_utils.printf('Image create path: ', img_dir_path)
|
||||
if config_file is None:
|
||||
config_file = img_dir_path + '/img_create_cfg.ini'
|
||||
bflb_utils.printf('Config file: ', config_file)
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config_file)
|
||||
img_type = 'media'
|
||||
signer = 'none'
|
||||
security = False
|
||||
data_tohash = bytearray(0)
|
||||
try:
|
||||
if args.image:
|
||||
img_type = args.image
|
||||
if args.signer:
|
||||
signer = args.signer
|
||||
if args.security:
|
||||
security = args.security == 'efuse'
|
||||
except Exception as e:
|
||||
try:
|
||||
bflb_utils.printf(e)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
if img_type == 'media':
|
||||
flash_img = 1
|
||||
else:
|
||||
flash_img = 0
|
||||
ret, data_tohash = img_creat_process(flash_img, cfg, security)
|
||||
if ret != 'OK':
|
||||
bflb_utils.printf('Fail to create images!')
|
||||
|
||||
|
||||
def create_sp_media_image(config, cpu_type=None, security=False):
|
||||
bflb_utils.printf('========= sp image create =========')
|
||||
cfg = BFConfigParser()
|
||||
cfg.read(config)
|
||||
img_creat_process(1, cfg, security)
|
||||
# okay decompiling ./libs/base/bl702l/img_create_do.pyc
|
||||
12
libs/base/bl702l/jlink_load_cfg.py
Normal file
12
libs/base/bl702l/jlink_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702l/jlink_load_cfg.py
|
||||
jlink_shake_hand_addr = '4202BFF0'
|
||||
jlink_data_addr = '4202C000'
|
||||
jlink_load_addr = '22010000'
|
||||
jlink_core_type = 'RISC-V'
|
||||
jlink_set_tif = 0
|
||||
jlink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702l/jlink_load_cfg.pyc
|
||||
12
libs/base/bl702l/openocd_load_cfg.py
Normal file
12
libs/base/bl702l/openocd_load_cfg.py
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
# 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/bl702l/openocd_load_cfg.py
|
||||
openocd_shake_hand_addr = '4202BFF0'
|
||||
openocd_data_addr = '4202C000'
|
||||
openocd_load_addr = '22010000'
|
||||
openocd_core_type = 'RISC-V'
|
||||
openocd_set_tif = 0
|
||||
openocd_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl702l/openocd_load_cfg.pyc
|
||||
614
libs/base/bl808/bootheader_cfg_keys.py
Normal file
614
libs/base/bl808/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,614 @@
|
|||
# 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/bl808/bootheader_cfg_keys.py
|
||||
clock_start_pos = 100
|
||||
bootcfg_start_pos = 128
|
||||
bootcfg_len = 48
|
||||
bootcpucfg_start_pos = bootcfg_start_pos + bootcfg_len
|
||||
bootcpucfg_len = 24
|
||||
bootcpucfg_m0_index = 0
|
||||
bootcpucfg_d0_index = 1
|
||||
bootcpucfg_lp_index = 2
|
||||
boot2_start_pos = bootcpucfg_start_pos + bootcpucfg_len * (bootcpucfg_lp_index + 1)
|
||||
boot2_len = 8
|
||||
flashcfg_table_start_pos = boot2_start_pos + boot2_len
|
||||
flashcfg_table_len = 8
|
||||
patch_on_read_start_pos = flashcfg_table_start_pos + flashcfg_table_len
|
||||
patch_on_read_len = 32
|
||||
patch_on_jump_start_pos = patch_on_read_start_pos + patch_on_read_len
|
||||
patch_on_jump_len = 32
|
||||
rsvd_start_pos = patch_on_jump_start_pos + patch_on_jump_len
|
||||
rsvd_len = 20
|
||||
crc32_start_pos = rsvd_start_pos + rsvd_len
|
||||
bootheader_len = crc32_start_pos + 4
|
||||
bootheader_cfg_keys = {'magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':'12',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':'12',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':'12',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':'16',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':'16',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':'16',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':'20',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_32bits_addr_cmd':{'offset':'20',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_32bits_addr_clk':{'offset':'20',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':'28',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':'28',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':'28',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':'32',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':'32',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':'32',
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':'36',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':'36',
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||