code starts up
This commit is contained in:
parent
bb81a685ed
commit
9cd262ed57
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -3,3 +3,4 @@ bin/
|
|||
lib/
|
||||
lib64
|
||||
pyvenv.cfg
|
||||
log/
|
||||
|
|
|
|||
|
|
@ -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'},
|
||||
'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'},
|
||||
'lp_div':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'dsp_clk':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'dsp_clk_div':{'offset':str(int(clock_start_pos) + 8),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'dsp_bclk_div':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'dsp_pbclk':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'dsp_pbclk_div':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'emi_clk':{'offset':str(int(clock_start_pos) + 12),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'emi_clk_div':{'offset':str(int(clock_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_type':{'offset':str(int(clock_start_pos) + 16),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'flash_clk_div':{'offset':str(int(clock_start_pos) + 16),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wifipll_pu':{'offset':str(int(clock_start_pos) + 16),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'aupll_pu':{'offset':str(int(clock_start_pos) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cpupll_pu':{'offset':str(int(clock_start_pos) + 20),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'mipipll_pu':{'offset':str(int(clock_start_pos) + 20),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'uhspll_pu':{'offset':str(int(clock_start_pos) + 20),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'clkcfg_crc32':{'offset':str(int(clock_start_pos) + 24),
|
||||
'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_cache_range_h':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_cache_range_l':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_image_address_offset':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_boot_entry':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'm0_msp_val':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_m0_index) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'd0_config_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'd0_halt_cpu':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'd0_cache_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'd0_cache_wa':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'd0_cache_wb':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'18',
|
||||
'bitlen':'1'},
|
||||
'd0_cache_wt':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'19',
|
||||
'bitlen':'1'},
|
||||
'd0_cache_way_dis':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'20',
|
||||
'bitlen':'4'},
|
||||
'd0_reserved':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 0),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'd0_cache_range_h':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'd0_cache_range_l':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'd0_image_address_offset':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'd0_boot_entry':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'd0_msp_val':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_d0_index) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'lp_config_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'lp_halt_cpu':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'lp_cache_enable':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'16',
|
||||
'bitlen':'1'},
|
||||
'lp_cache_wa':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'17',
|
||||
'bitlen':'1'},
|
||||
'lp_cache_wb':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'18',
|
||||
'bitlen':'1'},
|
||||
'lp_cache_wt':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'19',
|
||||
'bitlen':'1'},
|
||||
'lp_cache_way_dis':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'20',
|
||||
'bitlen':'4'},
|
||||
'lp_reserved':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 0),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'lp_cache_range_h':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'lp_cache_range_l':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'lp_image_address_offset':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'lp_boot_entry':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'lp_msp_val':{'offset':str(int(bootcpucfg_start_pos + bootcpucfg_len * bootcpucfg_lp_index) + 20),
|
||||
'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_read_addr3':{'offset':str(int(patch_on_read_start_pos) + 24),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_read_value3':{'offset':str(int(patch_on_read_start_pos) + 28),
|
||||
'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'},
|
||||
'patch_jump_addr3':{'offset':str(int(patch_on_jump_start_pos) + 24),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'patch_jump_value3':{'offset':str(int(patch_on_jump_start_pos) + 28),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved1':{'offset':str(int(rsvd_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved2':{'offset':str(int(rsvd_start_pos) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved3':{'offset':str(int(rsvd_start_pos) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved4':{'offset':str(int(rsvd_start_pos) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'reserved5':{'offset':str(int(rsvd_start_pos) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'crc32':{'offset':str(int(crc32_start_pos) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'}}
|
||||
# okay decompiling ./libs/base/bl808/bootheader_cfg_keys.pyc
|
||||
10
libs/base/bl808/chiptype_patch.py
Normal file
10
libs/base/bl808/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/bl808/chiptype_patch.py
|
||||
|
||||
|
||||
def img_load_create_predata_before_run_img():
|
||||
return bytearray(0)
|
||||
# okay decompiling ./libs/base/bl808/chiptype_patch.pyc
|
||||
12
libs/base/bl808/cklink_load_cfg.py
Normal file
12
libs/base/bl808/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/bl808/cklink_load_cfg.py
|
||||
cklink_shake_hand_addr = '2204BBE8'
|
||||
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/bl808/cklink_load_cfg.pyc
|
||||
153
libs/base/bl808/flash_select_do.py
Normal file
153
libs/base/bl808/flash_select_do.py
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
# 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/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, cgc
|
||||
from libs.bflb_configobj import BFConfigParser
|
||||
from libs.base.bl808.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', 'tg6210a', 'flashcfg_list.csv')
|
||||
else:
|
||||
table_file = os.path.join(app_path, 'utils', 'flash', 'bl808', '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', 'tg6210a', cfgfile)
|
||||
else:
|
||||
cfgfile = os.path.join(app_path, 'utils', 'flash', 'bl808', 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/bl808/flash_select_do.pyc
|
||||
950
libs/base/bl808/img_create_do.py
Normal file
950
libs/base/bl808/img_create_do.py
Normal file
|
|
@ -0,0 +1,950 @@
|
|||
# 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/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.bl808.flash_select_do import create_flashcfg_table
|
||||
from libs.base.bl808.bootheader_cfg_keys import flashcfg_table_start_pos as flashcfg_table_start
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcpucfg_start_pos as bootcpucfg_start
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcpucfg_len as bootcpucfg_length
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcpucfg_m0_index as bootcpucfg_m0_index_number
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcpucfg_d0_index as bootcpucfg_d0_index_number
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcpucfg_lp_index as bootcpucfg_lp_index_number
|
||||
from libs.base.bl808.bootheader_cfg_keys import bootcfg_start_pos as bootcfg_start
|
||||
from libs.base.bl808.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[93] |= sign
|
||||
efuse_mask_data[93] |= 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_update_efuse_group1(cfg, sign, pk_hash, flash_encryp_type, flash_key, sec_eng_key_sel, sec_eng_key, security=False):
|
||||
fp = open(cfg.get('Img_Group1_Cfg', 'efuse_file'), 'rb')
|
||||
efuse_data = bytearray(fp.read()) + bytearray(0)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Group1_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[93] |= sign
|
||||
efuse_mask_data[93] |= 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[keyslot8:keyslot10] = pk_hash
|
||||
efuse_mask_data[keyslot8:keyslot10] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_9
|
||||
if flash_key is not None:
|
||||
if flash_encryp_type == 1:
|
||||
efuse_data[keyslot3:keyslot3_end] = flash_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
|
||||
else:
|
||||
pass
|
||||
if flash_encryp_type == 2:
|
||||
efuse_data[keyslot4:keyslot6] = flash_key
|
||||
efuse_mask_data[keyslot4:keyslot6] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
else:
|
||||
if flash_encryp_type == 3:
|
||||
efuse_data[keyslot4:keyslot6] = flash_key
|
||||
efuse_mask_data[keyslot4:keyslot6] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
else:
|
||||
if flash_encryp_type == 4 or flash_encryp_type == 5 or flash_encryp_type == 6:
|
||||
efuse_data[keyslot4:keyslot6] = flash_key
|
||||
efuse_mask_data[keyslot4:keyslot6] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key is not None:
|
||||
if flash_encryp_type == 0:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot6:keyslot7] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot5:keyslot7] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_6
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_6
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot6:keyslot7] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot7:keyslot8] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot6:keyslot8] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_6
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_6
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_7
|
||||
if sec_eng_key_sel == 2:
|
||||
efuse_data[keyslot7:keyslot8] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot7:keyslot8] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot5:keyslot6] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_7
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key_sel == 3:
|
||||
efuse_data[keyslot7:keyslot8] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot7:keyslot8] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot5:keyslot6] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_7
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
if flash_encryp_type == 1:
|
||||
if sec_eng_key_sel == 0:
|
||||
efuse_data[keyslot7:keyslot8] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot7:keyslot8] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_7
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot6:keyslot7] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot6:keyslot7] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_6
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_6
|
||||
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[keyslot7:keyslot8] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot11:keyslot11_end] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot7:keyslot8] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot11:keyslot11_end] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_11
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_11
|
||||
if sec_eng_key_sel == 1:
|
||||
efuse_data[keyslot11:keyslot11_end] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot7:keyslot8] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot7:keyslot8] = mask_4bytes * 4
|
||||
efuse_mask_data[keyslot11:keyslot11_end] = mask_4bytes * 4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_11
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_7
|
||||
rw_lock0 |= 1 << rd_lock_key_slot_11
|
||||
if sec_eng_key_sel == 2:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot4:keyslot5] = sec_eng_key[16:32]
|
||||
efuse_data[keyslot5:keyslot6] = sec_eng_key[0:16]
|
||||
efuse_mask_data[keyslot4:keyslot6] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
if sec_eng_key_sel == 3:
|
||||
if flash_key is not None:
|
||||
pass
|
||||
else:
|
||||
efuse_data[keyslot4:keyslot6] = sec_eng_key
|
||||
efuse_mask_data[keyslot4:keyslot6] = mask_4bytes * 8
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_4
|
||||
rw_lock1 |= 1 << wr_lock_key_slot_5
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_4
|
||||
rw_lock1 |= 1 << rd_lock_key_slot_5
|
||||
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_Group1_Cfg', 'efuse_file'), 'wb+')
|
||||
fp.write(efuse_data)
|
||||
fp.close()
|
||||
fp = open(cfg.get('Img_Group1_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])))
|
||||
bootentry.append(bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(bootheader_data[bootcpucfg_start + bootcpucfg_length * bootcpucfg_d0_index_number + 16:bootcpucfg_start + bootcpucfg_length * bootcpucfg_d0_index_number + 16 + 4])))
|
||||
bootentry.append(bflb_utils.bytearray_to_int(bflb_utils.bytearray_reverse(bootheader_data[bootcpucfg_start + bootcpucfg_length * bootcpucfg_lp_index_number + 16:bootcpucfg_start + bootcpucfg_length * bootcpucfg_lp_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 = ''
|
||||
if group_type == 'group0':
|
||||
img_update_efuse_fun = img_update_efuse_group0
|
||||
cfg_section = 'Img_Group0_Cfg'
|
||||
else:
|
||||
if group_type == 'group1':
|
||||
img_update_efuse_fun = img_update_efuse_group1
|
||||
cfg_section = 'Img_Group1_Cfg'
|
||||
else:
|
||||
bflb_utils.printf('group type wrong')
|
||||
return (
|
||||
'FAIL', data_tohash)
|
||||
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 + pk_data + signature + 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 + pk_data + signature + 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 + pk_data + signature + 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':
|
||||
ret0, data_tohash0 = img_creat_process('group0', flash_img, cfg, security)
|
||||
else:
|
||||
if group_type == 'group1':
|
||||
ret1, data_tohash1 = img_creat_process('group1', flash_img, cfg, security)
|
||||
else:
|
||||
if group_type == 'all':
|
||||
ret0, data_tohash0 = img_creat_process('group0', flash_img, cfg, False)
|
||||
ret1, data_tohash1 = img_creat_process('group1', 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)
|
||||
if cpu_type == 'Group1':
|
||||
img_creat_process('group1', 1, cfg, security)
|
||||
else:
|
||||
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/bl808/img_create_do.pyc
|
||||
12
libs/base/bl808/jlink_load_cfg.py
Normal file
12
libs/base/bl808/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/bl808/jlink_load_cfg.py
|
||||
jlink_shake_hand_addr = '2204BBE8'
|
||||
jlink_data_addr = '2204CC88'
|
||||
jlink_load_addr = '22010000'
|
||||
jlink_core_type = 'RISC-V'
|
||||
jlink_set_tif = 0
|
||||
jlink_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl808/jlink_load_cfg.pyc
|
||||
12
libs/base/bl808/openocd_load_cfg.py
Normal file
12
libs/base/bl808/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/bl808/openocd_load_cfg.py
|
||||
openocd_shake_hand_addr = '2204BBE8'
|
||||
openocd_data_addr = '2204CC88'
|
||||
openocd_load_addr = '22010000'
|
||||
openocd_core_type = 'RISC-V'
|
||||
openocd_set_tif = 0
|
||||
openocd_run_addr = '22010000'
|
||||
# okay decompiling ./libs/base/bl808/openocd_load_cfg.pyc
|
||||
645
libs/base/wb03/bootheader_cfg_keys.py
Normal file
645
libs/base/wb03/bootheader_cfg_keys.py
Normal file
|
|
@ -0,0 +1,645 @@
|
|||
# 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/wb03/bootheader_cfg_keys.py
|
||||
custom_config_len = 208
|
||||
clock_start_pos = 100 + custom_config_len
|
||||
bootcfg_start_pos = 120 + custom_config_len
|
||||
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 = {'custom_magic_code':{'offset':'0',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_crc32':{'offset':'4',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_vendor_id':{'offset':'8',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_version':{'offset':'12',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_vendor_boot_offset':{'offset':'16',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_vendor_boot_len':{'offset':'20',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_ecc_type':{'offset':'24',
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'custom_aes_type':{'offset':'24',
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'custom_rsvd2':{'offset':'24',
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'custom_hash_0':{'offset':'28',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_1':{'offset':'32',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_2':{'offset':'36',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_3':{'offset':'40',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_4':{'offset':'44',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_5':{'offset':'48',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_6':{'offset':'52',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_hash_7':{'offset':'56',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_0':{'offset':'60',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_1':{'offset':'64',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_2':{'offset':'68',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_3':{'offset':'72',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_4':{'offset':'76',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_5':{'offset':'80',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_6':{'offset':'84',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_7':{'offset':'88',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_8':{'offset':'92',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_9':{'offset':'96',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_10':{'offset':'100',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_11':{'offset':'104',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_12':{'offset':'108',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_13':{'offset':'112',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_14':{'offset':'116',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_signature_15':{'offset':'120',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_0':{'offset':'124',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_1':{'offset':'128',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_2':{'offset':'132',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_3':{'offset':'136',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_4':{'offset':'140',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_5':{'offset':'144',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_6':{'offset':'148',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_7':{'offset':'152',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_8':{'offset':'156',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_9':{'offset':'160',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_10':{'offset':'164',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_11':{'offset':'168',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_12':{'offset':'172',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_13':{'offset':'176',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_14':{'offset':'180',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_pk_15':{'offset':'184',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_aes_iv_0':{'offset':'188',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_aes_iv_1':{'offset':'192',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_aes_iv_2':{'offset':'196',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_aes_iv_3':{'offset':'200',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'custom_rsvd4':{'offset':'204',
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'magic_code':{'offset':str(int(custom_config_len) + 0),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'revision':{'offset':str(int(custom_config_len) + 4),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'flashcfg_magic_code':{'offset':str(int(custom_config_len) + 8),
|
||||
'pos':'0',
|
||||
'bitlen':'32'},
|
||||
'io_mode':{'offset':str(int(custom_config_len) + 12),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'cont_read_support':{'offset':str(int(custom_config_len) + 12),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_delay':{'offset':str(int(custom_config_len) + 12),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'sfctrl_clk_invert':{'offset':str(int(custom_config_len) + 12),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reset_en_cmd':{'offset':str(int(custom_config_len) + 16),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reset_cmd':{'offset':str(int(custom_config_len) + 16),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd':{'offset':str(int(custom_config_len) + 16),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_contread_cmd_size':{'offset':str(int(custom_config_len) + 16),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd':{'offset':str(int(custom_config_len) + 20),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'jedecid_cmd_dmy_clk':{'offset':str(int(custom_config_len) + 20),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_32bits_addr_cmd':{'offset':str(int(custom_config_len) + 20),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'exit_32bits_addr_clk':{'offset':str(int(custom_config_len) + 20),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_size':{'offset':str(int(custom_config_len) + 24),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'mfg_id':{'offset':str(int(custom_config_len) + 24),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'page_size':{'offset':str(int(custom_config_len) + 24),
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_cmd':{'offset':str(int(custom_config_len) + 28),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_cmd':{'offset':str(int(custom_config_len) + 28),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'blk32k_erase_cmd':{'offset':str(int(custom_config_len) + 28),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'blk64k_erase_cmd':{'offset':str(int(custom_config_len) + 28),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'write_enable_cmd':{'offset':str(int(custom_config_len) + 32),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'page_prog_cmd':{'offset':str(int(custom_config_len) + 32),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpage_prog_cmd':{'offset':str(int(custom_config_len) + 32),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qual_page_prog_addr_mode':{'offset':str(int(custom_config_len) + 32),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_cmd':{'offset':str(int(custom_config_len) + 36),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dmy_clk':{'offset':str(int(custom_config_len) + 36),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_cmd':{'offset':str(int(custom_config_len) + 36),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_dmy_clk':{'offset':str(int(custom_config_len) + 36),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_cmd':{'offset':str(int(custom_config_len) + 40),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_do_dmy_clk':{'offset':str(int(custom_config_len) + 40),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_cmd':{'offset':str(int(custom_config_len) + 40),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_dio_dmy_clk':{'offset':str(int(custom_config_len) + 40),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_cmd':{'offset':str(int(custom_config_len) + 44),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qo_dmy_clk':{'offset':str(int(custom_config_len) + 44),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_cmd':{'offset':str(int(custom_config_len) + 44),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'fast_read_qio_dmy_clk':{'offset':str(int(custom_config_len) + 44),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_cmd':{'offset':str(int(custom_config_len) + 48),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qpi_fast_read_qio_dmy_clk':{'offset':str(int(custom_config_len) + 48),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'qpi_page_prog_cmd':{'offset':str(int(custom_config_len) + 48),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'write_vreg_enable_cmd':{'offset':str(int(custom_config_len) + 48),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_index':{'offset':str(int(custom_config_len) + 52),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_index':{'offset':str(int(custom_config_len) + 52),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_index':{'offset':str(int(custom_config_len) + 52),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_bit_pos':{'offset':str(int(custom_config_len) + 52),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_bit_pos':{'offset':str(int(custom_config_len) + 56),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'busy_bit_pos':{'offset':str(int(custom_config_len) + 56),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_write_len':{'offset':str(int(custom_config_len) + 56),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'wel_reg_read_len':{'offset':str(int(custom_config_len) + 56),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_write_len':{'offset':str(int(custom_config_len) + 60),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'qe_reg_read_len':{'offset':str(int(custom_config_len) + 60),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'release_power_down':{'offset':str(int(custom_config_len) + 60),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'busy_reg_read_len':{'offset':str(int(custom_config_len) + 60),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd0':{'offset':str(int(custom_config_len) + 64),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_read_cmd1':{'offset':str(int(custom_config_len) + 64),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd0':{'offset':str(int(custom_config_len) + 68),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'reg_write_cmd1':{'offset':str(int(custom_config_len) + 68),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'enter_qpi_cmd':{'offset':str(int(custom_config_len) + 72),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'exit_qpi_cmd':{'offset':str(int(custom_config_len) + 72),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'cont_read_code':{'offset':str(int(custom_config_len) + 72),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'cont_read_exit_code':{'offset':str(int(custom_config_len) + 72),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_cmd':{'offset':str(int(custom_config_len) + 76),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_dmy_clk':{'offset':str(int(custom_config_len) + 76),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_data_mode':{'offset':str(int(custom_config_len) + 76),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'burst_wrap_code':{'offset':str(int(custom_config_len) + 76),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd':{'offset':str(int(custom_config_len) + 80),
|
||||
'pos':'0',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_cmd_dmy_clk':{'offset':str(int(custom_config_len) + 80),
|
||||
'pos':'8',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code_mode':{'offset':str(int(custom_config_len) + 80),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'de_burst_wrap_code':{'offset':str(int(custom_config_len) + 80),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'sector_erase_time':{'offset':str(int(custom_config_len) + 84),
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'blk32k_erase_time':{'offset':str(int(custom_config_len) + 84),
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'blk64k_erase_time':{'offset':str(int(custom_config_len) + 88),
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'page_prog_time':{'offset':str(int(custom_config_len) + 88),
|
||||
'pos':'16',
|
||||
'bitlen':'16'},
|
||||
'chip_erase_time':{'offset':str(int(custom_config_len) + 92),
|
||||
'pos':'0',
|
||||
'bitlen':'16'},
|
||||
'power_down_delay':{'offset':str(int(custom_config_len) + 92),
|
||||
'pos':'16',
|
||||
'bitlen':'8'},
|
||||
'qe_data':{'offset':str(int(custom_config_len) + 92),
|
||||
'pos':'24',
|
||||
'bitlen':'8'},
|
||||
'flashcfg_crc32':{'offset':str(int(custom_config_len) + 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/wb03/bootheader_cfg_keys.pyc
|
||||
10
libs/base/wb03/chiptype_patch.py
Normal file
10
libs/base/wb03/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/wb03/chiptype_patch.py
|
||||
|
||||
|
||||
def img_load_create_predata_before_run_img():
|
||||
return bytearray(0)
|
||||
# okay decompiling ./libs/base/wb03/chiptype_patch.pyc
|
||||
12
libs/base/wb03/cklink_load_cfg.py
Normal file
12
libs/base/wb03/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/wb03/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/wb03/cklink_load_cfg.pyc
|
||||
147
libs/base/wb03/flash_select_do.py
Normal file
147
libs/base/wb03/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/wb03/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.wb03.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', 'wb03', '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', 'wb03', 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/wb03/flash_select_do.pyc
|
||||
766
libs/base/wb03/img_create_do.py
Normal file
766
libs/base/wb03/img_create_do.py
Normal file
|
|
@ -0,0 +1,766 @@
|
|||
# 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/wb03/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.wb03.flash_select_do import create_flashcfg_table
|
||||
from libs.base.wb03.bootheader_cfg_keys import custom_config_len as custom_cfg_len
|
||||
from libs.base.wb03.bootheader_cfg_keys import flashcfg_table_start_pos as flashcfg_table_start
|
||||
from libs.base.wb03.bootheader_cfg_keys import bootcpucfg_start_pos as bootcpucfg_start
|
||||
from libs.base.wb03.bootheader_cfg_keys import bootcpucfg_len as bootcpucfg_length
|
||||
from libs.base.wb03.bootheader_cfg_keys import bootcpucfg_m0_index as bootcpucfg_m0_index_number
|
||||
from libs.base.wb03.bootheader_cfg_keys import bootcfg_start_pos as bootcfg_start
|
||||
from libs.base.wb03.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[custom_cfg_len: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_custom_bootheader(bootheader_data, seg_cnt, hash, signature, pk_data, aesiv_data):
|
||||
bootheader_data[20:24] = bflb_utils.int_to_4bytearray_l(seg_cnt)
|
||||
if hash != bytearray(0):
|
||||
bootheader_data[28:60] = hash
|
||||
if signature != bytearray(0):
|
||||
bootheader_data[60:124] = signature[4:68]
|
||||
if pk_data != bytearray(0):
|
||||
bootheader_data[124:188] = pk_data[0:64]
|
||||
if aesiv_data != bytearray(0):
|
||||
bootheader_data[188:204] = aesiv_data[0:16]
|
||||
bootheader_data[4:8] = bflb_utils.get_crc32_bytearray(bootheader_data[8:custom_cfg_len - 4])
|
||||
return bootheader_data[0:header_len]
|
||||
|
||||
|
||||
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[custom_cfg_len: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
|
||||
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[233:234] == b'\xff':
|
||||
flashCfgList, flashCfgTable, flashCfgListLen = create_flashcfg_table(flashCfgAddr)
|
||||
bootheader_data = img_create_update_custom_bootheader(bootheader_data, seg_cnt, hash, signature, pk_data, aesiv_data)
|
||||
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/wb03/img_create_do.pyc
|
||||
12
libs/base/wb03/jlink_load_cfg.py
Normal file
12
libs/base/wb03/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/wb03/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/wb03/jlink_load_cfg.pyc
|
||||
12
libs/base/wb03/openocd_load_cfg.py
Normal file
12
libs/base/wb03/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/wb03/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/wb03/openocd_load_cfg.pyc
|
||||
|
|
@ -1,21 +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: pylink/__init__.py
|
||||
__version__ = '0.5.0'
|
||||
__title__ = 'pylink'
|
||||
__author__ = 'Square Embedded Software Team'
|
||||
__author_email__ = 'esw-team@squareup.com'
|
||||
__copyright__ = 'Copyright 2017 Square, Inc.'
|
||||
__license__ = 'Apache 2.0'
|
||||
__url__ = 'http://www.github.com/Square/pylink'
|
||||
__description__ = 'Python interface for SEGGER J-Link.'
|
||||
__long_description__ = "This module provides a Python implementation of the\nJ-Link SDK by leveraging the SDK's DLL.\n"
|
||||
from .enums import *
|
||||
from .errors import *
|
||||
from .jlink import *
|
||||
from .library import *
|
||||
from .structs import *
|
||||
from .unlockers import *
|
||||
# okay decompiling ./pylink/__init__.pyc
|
||||
|
|
@ -1,57 +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: pylink/binpacker.py
|
||||
import ctypes, math
|
||||
BITS_PER_BYTE = 8
|
||||
|
||||
def pack_size(value):
|
||||
"""Returns the number of bytes required to represent a given value.
|
||||
|
||||
Args:
|
||||
value (int): the natural number whose size to get
|
||||
|
||||
Returns:
|
||||
The minimal number of bytes required to represent the given integer.
|
||||
|
||||
Raises:
|
||||
ValueError: if ``value < 0``.
|
||||
TypeError: if ``value`` is not a number.
|
||||
"""
|
||||
if value == 0:
|
||||
return 1
|
||||
if value < 0:
|
||||
raise ValueError('Expected non-negative integer.')
|
||||
return int(math.log(value, 256)) + 1
|
||||
|
||||
|
||||
def pack(value, nbits=None):
|
||||
"""Packs a given value into an array of 8-bit unsigned integers.
|
||||
|
||||
If ``nbits`` is not present, calculates the minimal number of bits required
|
||||
to represent the given ``value``. The result is little endian.
|
||||
|
||||
Args:
|
||||
value (int): the integer value to pack
|
||||
nbits (int): optional number of bits to use to represent the value
|
||||
|
||||
Returns:
|
||||
An array of ``ctypes.c_uint8`` representing the packed ``value``.
|
||||
|
||||
Raises:
|
||||
ValueError: if ``value < 0`` and ``nbits`` is ``None`` or ``nbits <= 0``.
|
||||
TypeError: if ``nbits`` or ``value`` are not numbers.
|
||||
"""
|
||||
if nbits is None:
|
||||
nbits = pack_size(value) * BITS_PER_BYTE
|
||||
else:
|
||||
if nbits <= 0:
|
||||
raise ValueError('Given number of bits must be greater than 0.')
|
||||
buf_size = int(math.ceil(nbits / float(BITS_PER_BYTE)))
|
||||
buf = (ctypes.c_uint8 * buf_size)()
|
||||
for idx, _ in enumerate(buf):
|
||||
buf[idx] = value >> idx * BITS_PER_BYTE & 255
|
||||
|
||||
return buf
|
||||
# okay decompiling ./pylink/binpacker.pyc
|
||||
|
|
@ -1,52 +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: pylink/decorators.py
|
||||
from . import threads
|
||||
import functools
|
||||
|
||||
def async_decorator(func):
|
||||
"""Asynchronous function decorator. Interprets the function as being
|
||||
asynchronous, so returns a function that will handle calling the
|
||||
Function asynchronously.
|
||||
|
||||
Args:
|
||||
func (function): function to be called asynchronously
|
||||
|
||||
Returns:
|
||||
The wrapped function.
|
||||
|
||||
Raises:
|
||||
AttributeError: if ``func`` is not callable
|
||||
"""
|
||||
|
||||
@functools.wraps(func)
|
||||
def async_wrapper(*args, **kwargs):
|
||||
if not ('callback' not in kwargs or kwargs['callback']):
|
||||
return func(*args, **kwargs)
|
||||
callback = kwargs.pop('callback')
|
||||
if not callable(callback):
|
||||
raise TypeError("Expected 'callback' is not callable.")
|
||||
|
||||
def thread_func(*args, **kwargs):
|
||||
exception, res = (None, None)
|
||||
try:
|
||||
res = func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
try:
|
||||
exception = e
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
return callback(exception, res)
|
||||
|
||||
thread = threads.ThreadReturn(target=thread_func, args=args,
|
||||
kwargs=kwargs)
|
||||
thread.daemon = True
|
||||
thread.start()
|
||||
return thread
|
||||
|
||||
return async_wrapper
|
||||
# okay decompiling ./pylink/decorators.pyc
|
||||
528
pylink/enums.py
528
pylink/enums.py
|
|
@ -1,528 +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: pylink/enums.py
|
||||
import ctypes
|
||||
|
||||
class JLinkGlobalErrors(object):
|
||||
__doc__ = 'Enumeration for the error codes which any J-Link SDK DLL API-function\n can have as a return value.'
|
||||
UNSPECIFIED_ERROR = -1
|
||||
EMU_NO_CONNECTION = -256
|
||||
EMU_COMM_ERROR = -257
|
||||
DLL_NOT_OPEN = -258
|
||||
VCC_FAILURE = -259
|
||||
INVALID_HANDLE = -260
|
||||
NO_CPU_FOUND = -261
|
||||
EMU_FEATURE_UNSUPPORTED = -262
|
||||
EMU_NO_MEMORY = -263
|
||||
TIF_STATUS_ERROR = -264
|
||||
FLASH_PROG_COMPARE_FAILED = -265
|
||||
FLASH_PROG_PROGRAM_FAILED = -266
|
||||
FLASH_PROG_VERIFY_FAILED = -267
|
||||
OPEN_FILE_FAILED = -268
|
||||
UNKNOWN_FILE_FORMAT = -269
|
||||
WRITE_TARGET_MEMORY_FAILED = -270
|
||||
DEVICE_FEATURE_NOT_SUPPORTED = -271
|
||||
WRONG_USER_CONFIG = -272
|
||||
NO_TARGET_DEVICE_SELECTED = -273
|
||||
CPU_IN_LOW_POWER_MODE = -274
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
"""Returns the string message for the given ``error_code``.
|
||||
|
||||
Args:
|
||||
cls (JlinkGlobalErrors): the ``JLinkGlobalErrors`` class
|
||||
error_code (int): error code to convert
|
||||
|
||||
Returns:
|
||||
An error string corresponding to the error code.
|
||||
|
||||
Raises:
|
||||
ValueError: if the error code is invalid.
|
||||
"""
|
||||
if error_code == cls.EMU_NO_CONNECTION:
|
||||
return 'No connection to emulator.'
|
||||
if error_code == cls.EMU_COMM_ERROR:
|
||||
return 'Emulator connection error.'
|
||||
if error_code == cls.DLL_NOT_OPEN:
|
||||
return "DLL has not been opened. Did you call '.connect()'?"
|
||||
if error_code == cls.VCC_FAILURE:
|
||||
return 'Target system has no power.'
|
||||
if error_code == cls.INVALID_HANDLE:
|
||||
return 'Given file / memory handle is invalid.'
|
||||
if error_code == cls.NO_CPU_FOUND:
|
||||
return 'Could not find supported CPU.'
|
||||
if error_code == cls.EMU_FEATURE_UNSUPPORTED:
|
||||
return 'Emulator does not support the selected feature.'
|
||||
if error_code == cls.EMU_NO_MEMORY:
|
||||
return 'Emulator out of memory.'
|
||||
if error_code == cls.TIF_STATUS_ERROR:
|
||||
return 'Target interface error.'
|
||||
if error_code == cls.FLASH_PROG_COMPARE_FAILED:
|
||||
return 'Programmed data differs from source data.'
|
||||
if error_code == cls.FLASH_PROG_PROGRAM_FAILED:
|
||||
return 'Programming error occured.'
|
||||
if error_code == cls.FLASH_PROG_VERIFY_FAILED:
|
||||
return 'Error while verifying programmed data.'
|
||||
if error_code == cls.OPEN_FILE_FAILED:
|
||||
return 'Specified file could not be opened.'
|
||||
if error_code == cls.UNKNOWN_FILE_FORMAT:
|
||||
return 'File format of selected file is not supported.'
|
||||
if error_code == cls.WRITE_TARGET_MEMORY_FAILED:
|
||||
return 'Could not write target memory.'
|
||||
if error_code == cls.DEVICE_FEATURE_NOT_SUPPORTED:
|
||||
return 'Feature not supported by connected device.'
|
||||
if error_code == cls.WRONG_USER_CONFIG:
|
||||
return 'User configured DLL parameters incorrectly.'
|
||||
if error_code == cls.NO_TARGET_DEVICE_SELECTED:
|
||||
return 'User did not specify core to connect to.'
|
||||
if error_code == cls.CPU_IN_LOW_POWER_MODE:
|
||||
return 'Target CPU is in low power mode.'
|
||||
if error_code == cls.UNSPECIFIED_ERROR:
|
||||
return 'Unspecified error.'
|
||||
raise ValueError('Invalid error code: %d' % error_code)
|
||||
|
||||
|
||||
class JLinkEraseErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for the error codes generated during an erase operation.'
|
||||
ILLEGAL_COMMAND = -5
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.ILLEGAL_COMMAND:
|
||||
return 'Failed to erase sector.'
|
||||
return super(JLinkEraseErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkFlashErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for the error codes generated during a flash operation.'
|
||||
COMPARE_ERROR = -2
|
||||
PROGRAM_ERASE_ERROR = -3
|
||||
VERIFICATION_ERROR = -4
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.COMPARE_ERROR:
|
||||
return 'Error comparing flash content to programming data.'
|
||||
if error_code == cls.PROGRAM_ERASE_ERROR:
|
||||
return 'Error during program/erase phase.'
|
||||
if error_code == cls.VERIFICATION_ERROR:
|
||||
return 'Error verifying programmed data.'
|
||||
return super(JLinkFlashErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkWriteErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for the error codes generated during a write.'
|
||||
ZONE_NOT_FOUND_ERROR = -5
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.ZONE_NOT_FOUND_ERROR:
|
||||
return 'Zone not found'
|
||||
return super(JLinkWriteErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkReadErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for the error codes generated during a read.'
|
||||
ZONE_NOT_FOUND_ERROR = -5
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.ZONE_NOT_FOUND_ERROR:
|
||||
return 'Zone not found'
|
||||
return super(JLinkReadErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkDataErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for the error codes generated when setting a data event.'
|
||||
ERROR_UNKNOWN = 2147483648
|
||||
ERROR_NO_MORE_EVENTS = 2147483649
|
||||
ERROR_NO_MORE_ADDR_COMP = 2147483650
|
||||
ERROR_NO_MORE_DATA_COMP = 2147483652
|
||||
ERROR_INVALID_ADDR_MASK = 2147483680
|
||||
ERROR_INVALID_DATA_MASK = 2147483712
|
||||
ERROR_INVALID_ACCESS_MASK = 2147483776
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.ERROR_UNKNOWN:
|
||||
return 'Unknown error.'
|
||||
if error_code == cls.ERROR_NO_MORE_EVENTS:
|
||||
return 'There are no more available watchpoint units.'
|
||||
if error_code == cls.ERROR_NO_MORE_ADDR_COMP:
|
||||
return 'No more address comparisons can be set.'
|
||||
if error_code == cls.ERROR_NO_MORE_DATA_COMP:
|
||||
return 'No more data comparisons can be set.'
|
||||
if error_code == cls.ERROR_INVALID_ADDR_MASK:
|
||||
return 'Invalid flags passed for the address mask.'
|
||||
if error_code == cls.ERROR_INVALID_DATA_MASK:
|
||||
return 'Invalid flags passed for the data mask.'
|
||||
if error_code == cls.ERROR_INVALID_ACCESS_MASK:
|
||||
return 'Invalid flags passed for the access mask.'
|
||||
return super(JLinkDataErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkRTTErrors(JLinkGlobalErrors):
|
||||
__doc__ = 'Enumeration for error codes from RTT.'
|
||||
RTT_ERROR_CONTROL_BLOCK_NOT_FOUND = -2
|
||||
|
||||
@classmethod
|
||||
def to_string(cls, error_code):
|
||||
if error_code == cls.RTT_ERROR_CONTROL_BLOCK_NOT_FOUND:
|
||||
return 'The RTT Control Block has not yet been found (wait?)'
|
||||
return super(JLinkRTTErrors, cls).to_string(error_code)
|
||||
|
||||
|
||||
class JLinkHost(object):
|
||||
__doc__ = 'Enumeration for the different JLink hosts: currently only IP and USB.'
|
||||
USB = 1
|
||||
IP = 2
|
||||
USB_OR_IP = USB | IP
|
||||
|
||||
|
||||
class JLinkInterfaces(object):
|
||||
__doc__ = 'Target interfaces for the J-Link.'
|
||||
JTAG = 0
|
||||
SWD = 1
|
||||
FINE = 3
|
||||
ICSP = 4
|
||||
SPI = 5
|
||||
C2 = 6
|
||||
|
||||
|
||||
class JLinkResetStrategyCortexM3(object):
|
||||
__doc__ = 'Target reset strategies for the J-Link.\n\n Attributes:\n NORMAL: default reset strategy, does whatever is best to reset.\n CORE: only the core is reset via the ``VECTRESET`` bit.\n RESETPIN: pulls the reset pin low to reset the core and peripherals.\n CONNECT_UNDER_RESET: J-Link connects to target while keeping reset\n active. This is recommented for STM32 devices.\n HALT_AFTER_BTL: halt the core after the bootloader is executed.\n HALT_BEFORE_BTL: halt the core before the bootloader is executed.\n KINETIS: performs a normal reset, but also disables the watchdog.\n ADI_HALT_AFTER_KERNEL: sets the ``SYSRESETREQ`` bit in the ``AIRCR`` in\n order to reset the device.\n CORE_AND_PERIPHERALS: sets the ``SYSRESETREQ`` bit in the ``AIRCR``, and\n the ``VC_CORERESET`` bit in the ``DEMCR`` to make sure that the CPU is\n halted immediately after reset.\n LPC1200: reset for LPC1200 devices.\n S3FN60D: reset for Samsung S3FN60D devices.\n\n Note:\n Please see the J-Link SEGGER Documentation, UM8001, for full information\n about the different reset strategies.\n '
|
||||
NORMAL = 0
|
||||
CORE = 1
|
||||
RESETPIN = 2
|
||||
CONNECT_UNDER_RESET = 3
|
||||
HALT_AFTER_BTL = 4
|
||||
HALT_BEFORE_BTL = 5
|
||||
KINETIS = 6
|
||||
ADI_HALT_AFTER_KERNEL = 7
|
||||
CORE_AND_PERIPHERALS = 8
|
||||
LPC1200 = 9
|
||||
S3FN60D = 10
|
||||
|
||||
|
||||
class JLinkFunctions(object):
|
||||
__doc__ = 'Collection of function prototype and type builders for the J-Link SDK\n API calls.'
|
||||
LOG_PROTOTYPE = ctypes.CFUNCTYPE(None, ctypes.c_char_p)
|
||||
UNSECURE_HOOK_PROTOTYPE = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint32)
|
||||
FLASH_PROGRESS_PROTOTYPE = ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int)
|
||||
|
||||
|
||||
class JLinkCore(object):
|
||||
__doc__ = 'Enumeration for the different CPU core identifiers.\n\n These are the possible cores for targets the J-Link is connected to.\n Note that these are bitfields.'
|
||||
NONE = 0
|
||||
ANY = 4294967295
|
||||
CORTEX_M1 = 16777471
|
||||
COLDFIRE = 50331647
|
||||
CORTEX_M3 = 50331903
|
||||
CORTEX_M3_R1P0 = 50331664
|
||||
CORTEX_M3_R1P1 = 50331665
|
||||
CORTEX_M3_R2P0 = 50331680
|
||||
SIM = 83886079
|
||||
XSCALE = 100663295
|
||||
CORTEX_M0 = 100663551
|
||||
CORTEX_M_V8BASEL = 100729087
|
||||
ARM7 = 134217727
|
||||
ARM7TDMI = 117440767
|
||||
ARM7TDMI_R3 = 117440575
|
||||
ARM7TDMI_R4 = 117440591
|
||||
ARM7TDMI_S = 117441023
|
||||
ARM7TDMI_S_R3 = 117440831
|
||||
ARM7TDMI_S_R4 = 117440847
|
||||
CORTEX_A8 = 134217983
|
||||
CORTEX_A7 = 134742271
|
||||
CORTEX_A9 = 134807807
|
||||
CORTEX_A12 = 134873343
|
||||
CORTEX_A15 = 134938879
|
||||
CORTEX_A17 = 135004415
|
||||
ARM9 = 167772159
|
||||
ARM9TDMI_S = 150995455
|
||||
ARM920T = 153092351
|
||||
ARM922T = 153223423
|
||||
ARM926EJ_S = 153485823
|
||||
ARM946E_S = 155582975
|
||||
ARM966E_S = 157680127
|
||||
ARM968E_S = 157811199
|
||||
ARM11 = 201326591
|
||||
ARM1136 = 188153855
|
||||
ARM1136J = 188089087
|
||||
ARM1136J_S = 188089343
|
||||
ARM1136JF = 188090111
|
||||
ARM1136JF_S = 188090367
|
||||
ARM1156 = 190251007
|
||||
ARM1176 = 192348159
|
||||
ARM1176J = 192283391
|
||||
ARM1176J_S = 192283647
|
||||
ARM1176JF = 192284415
|
||||
ARM1176JF_S = 192284671
|
||||
CORTEX_R4 = 201326847
|
||||
CORTEX_R5 = 201392383
|
||||
RX = 234881023
|
||||
RX610 = 218169343
|
||||
RX62N = 218234879
|
||||
RX62T = 218300415
|
||||
RX63N = 218365951
|
||||
RX630 = 218431487
|
||||
RX63T = 218497023
|
||||
RX621 = 218562559
|
||||
RX62G = 218628095
|
||||
RX631 = 218693631
|
||||
RX210 = 219217919
|
||||
RX21A = 219283455
|
||||
RX220 = 219348991
|
||||
RX230 = 219414527
|
||||
RX231 = 219480063
|
||||
RX23T = 219545599
|
||||
RX111 = 220266495
|
||||
RX110 = 220332031
|
||||
RX113 = 220397567
|
||||
RX64M = 221315071
|
||||
RX71M = 221380607
|
||||
CORTEX_M4 = 234881279
|
||||
CORTEX_M7 = 234946815
|
||||
CORTEX_M_V8MAINL = 235012351
|
||||
CORTEX_A5 = 251658495
|
||||
POWER_PC = 285212671
|
||||
POWER_PC_N1 = 285147391
|
||||
POWER_PC_N2 = 285147647
|
||||
MIPS = 301989887
|
||||
MIPS_M4K = 285278207
|
||||
MIPS_MICROAPTIV = 285343743
|
||||
EFM8_UNSPEC = 318767103
|
||||
CIP51 = 302055423
|
||||
|
||||
|
||||
class JLinkDeviceFamily(object):
|
||||
__doc__ = 'Enumeration for the difference device families.\n\n These are the possible device families for targets that the J-Link is\n connected to.'
|
||||
AUTO = 0
|
||||
CORTEX_M1 = 1
|
||||
COLDFIRE = 2
|
||||
CORTEX_M3 = 3
|
||||
SIMULATOR = 4
|
||||
XSCALE = 5
|
||||
CORTEX_M0 = 6
|
||||
ARM7 = 7
|
||||
CORTEX_A8 = 8
|
||||
CORTEX_A9 = 8
|
||||
ARM9 = 9
|
||||
ARM10 = 10
|
||||
ARM11 = 11
|
||||
CORTEX_R4 = 12
|
||||
RX = 13
|
||||
CORTEX_M4 = 14
|
||||
CORTEX_A5 = 15
|
||||
POWERPC = 16
|
||||
MIPS = 17
|
||||
EFM8 = 18
|
||||
ANY = 255
|
||||
|
||||
|
||||
class JLinkFlags(object):
|
||||
__doc__ = 'Enumeration for the different flags that are passed to the J-Link C SDK\n API methods.'
|
||||
GO_OVERSTEP_BP = 1
|
||||
DLG_BUTTON_YES = 1
|
||||
DLG_BUTTON_NO = 2
|
||||
DLG_BUTTON_OK = 4
|
||||
DLG_BUTTON_CANCEL = 8
|
||||
HW_PIN_STATUS_LOW = 0
|
||||
HW_PIN_STATUS_HIGH = 1
|
||||
HW_PIN_STATUS_UNKNOWN = 255
|
||||
|
||||
|
||||
class JLinkSWOInterfaces(object):
|
||||
__doc__ = 'Serial Wire Output (SWO) interfaces.'
|
||||
UART = 0
|
||||
MANCHESTER = 1
|
||||
|
||||
|
||||
class JLinkSWOCommands(object):
|
||||
__doc__ = 'Serial Wire Output (SWO) commands.'
|
||||
START = 0
|
||||
STOP = 1
|
||||
FLUSH = 2
|
||||
GET_SPEED_INFO = 3
|
||||
GET_NUM_BYTES = 10
|
||||
SET_BUFFERSIZE_HOST = 20
|
||||
SET_BUFFERSIZE_EMU = 21
|
||||
|
||||
|
||||
class JLinkCPUCapabilities(object):
|
||||
__doc__ = 'Target CPU Cabilities.'
|
||||
READ_MEMORY = 2
|
||||
WRITE_MEMORY = 4
|
||||
READ_REGISTERS = 8
|
||||
WRITE_REGISTERS = 16
|
||||
GO = 32
|
||||
STEP = 64
|
||||
HALT = 128
|
||||
IS_HALTED = 256
|
||||
RESET = 512
|
||||
RUN_STOP = 1024
|
||||
TERMINAL = 2048
|
||||
DCC = 16384
|
||||
HSS = 32768
|
||||
|
||||
|
||||
class JLinkHaltReasons(object):
|
||||
__doc__ = 'Halt reasons for the CPU.\n\n Attributes:\n DBGRQ: CPU has been halted because DBGRQ signal asserted.\n CODE_BREAKPOINT: CPU has been halted because of code breakpoint match.\n DATA_BREAKPOINT: CPU has been halted because of data breakpoint match.\n VECTOR_CATCH: CPU has been halted because of vector catch.\n '
|
||||
DBGRQ = 0
|
||||
CODE_BREAKPOINT = 1
|
||||
DATA_BREAKPOINT = 2
|
||||
VECTOR_CATCH = 3
|
||||
|
||||
|
||||
class JLinkVectorCatchCortexM3(object):
|
||||
__doc__ = 'Vector catch types for the ARM Cortex M3.\n\n Attributes:\n CORE_RESET: The CPU core reset.\n MEM_ERROR: A memory management error occurred.\n COPROCESSOR_ERROR: Usage fault error accessing the Coprocessor.\n CHECK_ERROR: Usage fault error on enabled check.\n STATE_ERROR: Usage fault state error.\n BUS_ERROR: Normal bus error.\n INT_ERROR: Interrupt or exception service error.\n HARD_ERROR: Hard fault error.\n '
|
||||
CORE_RESET = 1
|
||||
MEM_ERROR = 16
|
||||
COPROCESSOR_ERROR = 32
|
||||
CHECK_ERROR = 64
|
||||
STATE_ERROR = 128
|
||||
BUS_ERROR = 256
|
||||
INT_ERROR = 512
|
||||
HARD_ERROR = 1024
|
||||
|
||||
|
||||
class JLinkBreakpoint(object):
|
||||
__doc__ = 'J-Link breakpoint types.\n\n Attributes:\n SW_RAM: Software breakpont located in RAM.\n SW_FLASH: Software breakpoint located in flash.\n SW: Software breakpoint located in RAM or flash.\n HW: Hardware breakpoint.\n ANY: Allows specifying any time of breakpoint.\n ARM: Breakpoint in ARM mode (only available on ARM 7/9 cores).\n THUMB: Breakpoint in THUMB mode (only available on ARM 7/9 cores).\n '
|
||||
SW_RAM = 16
|
||||
SW_FLASH = 32
|
||||
SW = 240
|
||||
HW = 4294967040
|
||||
ANY = 4294967280
|
||||
ARM = 1
|
||||
THUMB = 2
|
||||
|
||||
|
||||
class JLinkBreakpointImplementation(object):
|
||||
__doc__ = 'J-Link breakpoint implementation types.\n\n Attributes:\n HARD: Hardware breakpoint using a breakpoint unit.\n SOFT: Software breakpoint using a breakpoint instruction.\n PENDING: Breakpoint has not been set yet.\n FLASH: Breakpoint set in flash.\n '
|
||||
HARD = 1
|
||||
SOFT = 2
|
||||
PENDING = 4
|
||||
FLASH = 16
|
||||
|
||||
|
||||
class JLinkEventTypes(object):
|
||||
__doc__ = 'J-Link data event types.\n\n Attributes:\n BREAKPOINT: breakpoint data event.\n '
|
||||
BREAKPOINT = 1
|
||||
|
||||
|
||||
class JLinkAccessFlags(object):
|
||||
__doc__ = 'J-Link access types for data events.\n\n These access types allow specifying the different types of access events\n that should be monitored.\n\n Attributes:\n READ: specifies to monitor read accesses.\n WRITE: specifies to monitor write accesses.\n PRIVILEGED: specifies to monitor privileged accesses.\n SIZE_8BIT: specifies to monitor an 8-bit access width.\n SIZE_16BIT: specifies to monitor an 16-bit access width.\n SIZE_32BIT: specifies to monitor an 32-bit access width.\n '
|
||||
READ = 0
|
||||
WRITE = 1
|
||||
PRIV = 16
|
||||
SIZE_8BIT = 0
|
||||
SIZE_16BIT = 2
|
||||
SIZE_32BIT = 4
|
||||
|
||||
|
||||
class JLinkAccessMaskFlags(object):
|
||||
__doc__ = 'J-Link access mask flags.\n\n Attributes:\n SIZE: specifies to not care about the access size of the event.\n DIR: specifies to not care about the access direction of the event.\n PRIV: specifies to not care about the access privilege of the event.\n '
|
||||
SIZE = 6
|
||||
DIR = 1
|
||||
PRIV = 16
|
||||
|
||||
|
||||
class JLinkStraceCommand(object):
|
||||
__doc__ = 'STRACE commmands.'
|
||||
TRACE_EVENT_SET = 0
|
||||
TRACE_EVENT_CLR = 1
|
||||
TRACE_EVENT_CLR_ALL = 2
|
||||
SET_BUFFER_SIZE = 3
|
||||
|
||||
|
||||
class JLinkStraceEvent(object):
|
||||
__doc__ = 'STRACE events.'
|
||||
CODE_FETCH = 0
|
||||
DATA_ACCESS = 1
|
||||
DATA_LOAD = 2
|
||||
DATA_STORE = 3
|
||||
|
||||
|
||||
class JLinkStraceOperation(object):
|
||||
__doc__ = 'STRACE operation specifiers.'
|
||||
TRACE_START = 0
|
||||
TRACE_STOP = 1
|
||||
TRACE_INCLUDE_RANGE = 2
|
||||
TRACE_EXCLUDE_RANGE = 3
|
||||
|
||||
|
||||
class JLinkTraceSource(object):
|
||||
__doc__ = 'Sources for tracing.'
|
||||
ETB = 0
|
||||
ETM = 1
|
||||
MTB = 2
|
||||
|
||||
|
||||
class JLinkTraceCommand(object):
|
||||
__doc__ = 'J-Link trace commands.'
|
||||
START = 0
|
||||
STOP = 1
|
||||
FLUSH = 2
|
||||
GET_NUM_SAMPLES = 16
|
||||
GET_CONF_CAPACITY = 17
|
||||
SET_CAPACITY = 18
|
||||
GET_MIN_CAPACITY = 19
|
||||
GET_MAX_CAPACITY = 20
|
||||
SET_FORMAT = 32
|
||||
GET_FORMAT = 33
|
||||
GET_NUM_REGIONS = 48
|
||||
GET_REGION_PROPS = 49
|
||||
GET_REGION_PROPS_EX = 50
|
||||
|
||||
|
||||
class JLinkTraceFormat(object):
|
||||
__doc__ = 'J-Link trace formats.\n\n Attributes:\n FORMAT_4BIT: 4-bit data.\n FORMAT_8BIT: 8-bit data.\n FORMAT_16BIT: 16-bit data.\n FORMAT_MULTIPLEXED: multiplexing on ETM / buffer link.\n FORMAT_DEMULTIPLEXED: de-multiplexing on ETM / buffer link.\n FORMAT_DOUBLE_EDGE: clock data on both ETM / buffer link edges.\n FORMAT_ETM7_9: ETM7/ETM9 protocol.\n FORMAT_ETM10: ETM10 protocol.\n FORMAT_1BIT: 1-bit data.\n FORMAT_2BIT: 2-bit data.\n '
|
||||
FORMAT_4BIT = 1
|
||||
FORMAT_8BIT = 2
|
||||
FORMAT_16BIT = 4
|
||||
FORMAT_MULTIPLEXED = 8
|
||||
FORMAT_DEMULTIPLEXED = 16
|
||||
FORMAT_DOUBLE_EDGE = 32
|
||||
FORMAT_ETM7_9 = 64
|
||||
FORMAT_ETM10 = 128
|
||||
FORMAT_1BIT = 256
|
||||
FORMAT_2BIT = 512
|
||||
|
||||
|
||||
class JLinkROMTable(object):
|
||||
__doc__ = 'The J-Link ROM tables.'
|
||||
NONE = 256
|
||||
ETM = 257
|
||||
MTB = 258
|
||||
TPIU = 259
|
||||
ITM = 260
|
||||
DWT = 261
|
||||
FPB = 262
|
||||
NVIC = 263
|
||||
TMC = 264
|
||||
TF = 265
|
||||
PTM = 266
|
||||
ETB = 267
|
||||
DBG = 268
|
||||
APBAP = 269
|
||||
AHBAP = 270
|
||||
SECURE = 271
|
||||
|
||||
|
||||
class JLinkRTTCommand(object):
|
||||
__doc__ = 'RTT commands.'
|
||||
START = 0
|
||||
STOP = 1
|
||||
GETDESC = 2
|
||||
GETNUMBUF = 3
|
||||
GETSTAT = 4
|
||||
|
||||
|
||||
class JLinkRTTDirection(object):
|
||||
__doc__ = 'RTT Direction.'
|
||||
UP = 0
|
||||
DOWN = 1
|
||||
# okay decompiling ./pylink/enums.pyc
|
||||
|
|
@ -1,44 +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: pylink/errors.py
|
||||
from . import enums
|
||||
from . import util
|
||||
|
||||
class JLinkException(enums.JLinkGlobalErrors, Exception):
|
||||
__doc__ = 'Generic J-Link exception.'
|
||||
|
||||
def __init__(self, code):
|
||||
message = code
|
||||
self.code = None
|
||||
if util.is_integer(code):
|
||||
message = self.to_string(code)
|
||||
self.code = code
|
||||
super(JLinkException, self).__init__(message)
|
||||
self.message = message
|
||||
|
||||
|
||||
class JLinkEraseException(enums.JLinkEraseErrors, JLinkException):
|
||||
__doc__ = 'J-Link erase exception.'
|
||||
|
||||
|
||||
class JLinkFlashException(enums.JLinkFlashErrors, JLinkException):
|
||||
__doc__ = 'J-Link flash exception.'
|
||||
|
||||
|
||||
class JLinkWriteException(enums.JLinkWriteErrors, JLinkException):
|
||||
__doc__ = 'J-Link write exception.'
|
||||
|
||||
|
||||
class JLinkReadException(enums.JLinkReadErrors, JLinkException):
|
||||
__doc__ = 'J-Link read exception.'
|
||||
|
||||
|
||||
class JLinkDataException(enums.JLinkDataErrors, JLinkException):
|
||||
__doc__ = 'J-Link data event exception.'
|
||||
|
||||
|
||||
class JLinkRTTException(enums.JLinkRTTErrors, JLinkException):
|
||||
__doc__ = 'J-Link RTT exception.'
|
||||
# okay decompiling ./pylink/errors.pyc
|
||||
4629
pylink/jlink.py
4629
pylink/jlink.py
File diff suppressed because it is too large
Load Diff
114
pylink/jlock.py
114
pylink/jlock.py
|
|
@ -1,114 +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: pylink/jlock.py
|
||||
import psutil, errno, tempfile, os
|
||||
|
||||
class JLock(object):
|
||||
__doc__ = 'Lockfile for accessing a particular J-Link.\n\n The J-Link SDK does not prevent accessing the same J-Link multiple times\n from the same process or multiple processes. As a result, a user can\n have the same J-Link being accessed by multiple processes. This class\n provides an interface to a lock-file like structure for the physical\n J-Links to ensure that any instance of a ``JLink`` with an open emulator\n connection will be the only one accessing that emulator.\n\n This class uses a PID-style lockfile to allow acquiring of the lockfile in\n the instances where the lockfile exists, but the process which created it\n is no longer running.\n\n To share the same emulator connection between multiple threads, processes,\n or functions, a single instance of a ``JLink`` should be created and passed\n between the threads and processes.\n\n Attributes:\n name: the name of the lockfile.\n path: full path to the lockfile.\n fd: file description of the lockfile.\n acquired: boolean indicating if the lockfile lock has been acquired.\n '
|
||||
SERIAL_NAME_FMT = '.pylink-usb-{}.lck'
|
||||
IPADDR_NAME_FMT = '.pylink-ip-{}.lck'
|
||||
|
||||
def __init__(self, serial_no):
|
||||
"""Creates an instance of a ``JLock`` and populates the name.
|
||||
|
||||
Note:
|
||||
This method may fail if there is no temporary directory in which to
|
||||
have the lockfile placed.
|
||||
|
||||
Args:
|
||||
self (JLock): the ``JLock`` instance
|
||||
serial_no (int): the serial number of the J-Link
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
self.name = self.SERIAL_NAME_FMT.format(serial_no)
|
||||
self.acquired = False
|
||||
self.fd = None
|
||||
self.path = None
|
||||
self.path = os.path.join(tempfile.tempdir, self.name)
|
||||
|
||||
def __del__(self):
|
||||
"""Cleans up the lockfile instance if it was acquired.
|
||||
|
||||
Args:
|
||||
self (JLock): the ``JLock`` instance
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
self.release()
|
||||
|
||||
def acquire(self):
|
||||
"""Attempts to acquire a lock for the J-Link lockfile.
|
||||
|
||||
If the lockfile exists but does not correspond to an active process,
|
||||
the lockfile is first removed, before an attempt is made to acquire it.
|
||||
|
||||
Args:
|
||||
self (Jlock): the ``JLock`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the lock was acquired, otherwise ``False``.
|
||||
|
||||
Raises:
|
||||
OSError: on file errors.
|
||||
"""
|
||||
if os.path.exists(self.path):
|
||||
try:
|
||||
pid = None
|
||||
with open(self.path, 'r') as f:
|
||||
line = f.readline().strip()
|
||||
pid = int(line)
|
||||
if not psutil.pid_exists(pid):
|
||||
os.remove(self.path)
|
||||
except ValueError as e:
|
||||
try:
|
||||
os.remove(self.path)
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
except IOError as e:
|
||||
try:
|
||||
pass
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
try:
|
||||
self.fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_RDWR)
|
||||
to_write = '%s%s' % (os.getpid(), os.linesep)
|
||||
os.write(self.fd, to_write.encode())
|
||||
except OSError as e:
|
||||
try:
|
||||
if not os.path.exists(self.path):
|
||||
raise
|
||||
return False
|
||||
finally:
|
||||
e = None
|
||||
del e
|
||||
|
||||
self.acquired = True
|
||||
return True
|
||||
|
||||
def release(self):
|
||||
"""Cleans up the lockfile if it was acquired.
|
||||
|
||||
Args:
|
||||
self (JLock): the ``JLock`` instance
|
||||
|
||||
Returns:
|
||||
``False`` if the lock was not released or the lock is not acquired,
|
||||
otherwise ``True``.
|
||||
"""
|
||||
if not self.acquired:
|
||||
return False
|
||||
os.close(self.fd)
|
||||
if os.path.exists(self.path):
|
||||
os.remove(self.path)
|
||||
self.acquired = False
|
||||
return True
|
||||
# okay decompiling ./pylink/jlock.pyc
|
||||
|
|
@ -1,346 +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: pylink/library.py
|
||||
from . import util
|
||||
import ctypes
|
||||
import ctypes.util as ctypes_util
|
||||
import os, sys, tempfile
|
||||
|
||||
class Library(object):
|
||||
__doc__ = 'Wrapper to provide easy access to loading the J-Link SDK DLL.\n\n This class provides a convenience for finding and loading the J-Link DLL\n across multiple platforms, and accounting for the inconsistencies between\n Windows and nix-based platforms.\n\n Attributes:\n _standard_calls_: list of names of the methods for the API calls that\n must be converted to standard calling convention on the Windows\n platform.\n JLINK_SDK_NAME: name of the J-Link DLL on nix-based platforms.\n WINDOWS_JLINK_SDK_NAME: name of the J-Link DLL on Windows platforms.\n '
|
||||
_standard_calls_ = [
|
||||
'JLINK_Configure',
|
||||
'JLINK_DownloadFile',
|
||||
'JLINK_GetAvailableLicense',
|
||||
'JLINK_GetPCode',
|
||||
'JLINK_PrintConfig',
|
||||
'JLINK_EraseChip',
|
||||
'JLINK_SPI_Transfer',
|
||||
'JLINK_GetpFunc',
|
||||
'JLINK_GetMemZones',
|
||||
'JLINK_ReadMemZonedEx',
|
||||
'JLINK_SetHookUnsecureDialog',
|
||||
'JLINK_WriteMemZonedEx',
|
||||
'JLINK_DIALOG_Configure',
|
||||
'JLINK_DIALOG_ConfigureEx',
|
||||
'JLINK_EMU_GPIO_GetProps',
|
||||
'JLINK_EMU_GPIO_GetState',
|
||||
'JLINK_EMU_GPIO_SetState',
|
||||
'JLINK_EMU_AddLicense',
|
||||
'JLINK_EMU_EraseLicenses',
|
||||
'JLINK_EMU_GetLicenses',
|
||||
'JLINK_HSS_GetCaps',
|
||||
'JLINK_HSS_Start',
|
||||
'JLINK_HSS_Stop',
|
||||
'JLINK_HSS_Read',
|
||||
'JLINK_POWERTRACE_Control',
|
||||
'JLINK_POWERTRACE_Read',
|
||||
'JLINK_RTTERMINAL_Control',
|
||||
'JLINK_RTTERMINAL_Read',
|
||||
'JLINK_RTTERMINAL_Write',
|
||||
'JLINK_STRACE_Config',
|
||||
'JLINK_STRACE_Control',
|
||||
'JLINK_STRACE_Read',
|
||||
'JLINK_STRACE_Start',
|
||||
'JLINK_STRACE_Stop',
|
||||
'JLINK_SWD_GetData',
|
||||
'JLINK_SWD_GetU8',
|
||||
'JLINK_SWD_GetU16',
|
||||
'JLINK_SWD_GetU32',
|
||||
'JLINK_SWD_StoreGetRaw',
|
||||
'JLINK_SWD_StoreRaw',
|
||||
'JLINK_SWD_SyncBits',
|
||||
'JLINK_SWD_SyncBytes',
|
||||
'JLINK_SetFlashProgProgressCallback']
|
||||
JLINK_SDK_NAME = 'libjlinkarm'
|
||||
WINDOWS_32_JLINK_SDK_NAME = 'JLinkARM'
|
||||
WINDOWS_64_JLINK_SDK_NAME = 'JLink_x64'
|
||||
|
||||
@classmethod
|
||||
def get_appropriate_windows_sdk_name(cls):
|
||||
"""Returns the appropriate JLink SDK library name on Windows depending
|
||||
on 32bit or 64bit Python variant.
|
||||
|
||||
SEGGER delivers two variants of their dynamic library on Windows:
|
||||
- ``JLinkARM.dll`` for 32-bit platform
|
||||
- ``JLink_x64.dll`` for 64-bit platform
|
||||
|
||||
Args:
|
||||
cls (Library): the ``Library`` class
|
||||
|
||||
Returns:
|
||||
The name of the library depending on the platform this module is run on.
|
||||
|
||||
"""
|
||||
if sys.maxsize == 9223372036854775807:
|
||||
return Library.WINDOWS_64_JLINK_SDK_NAME
|
||||
return Library.WINDOWS_32_JLINK_SDK_NAME
|
||||
|
||||
@classmethod
|
||||
def find_library_windows(cls):
|
||||
r"""Loads the SEGGER DLL from the windows installation directory.
|
||||
|
||||
On Windows, these are found either under:
|
||||
- ``C:\Program Files\SEGGER\JLink``
|
||||
- ``C:\Program Files (x86)\SEGGER\JLink``.
|
||||
|
||||
Args:
|
||||
cls (Library): the ``Library`` class
|
||||
|
||||
Returns:
|
||||
The paths to the J-Link library files in the order that they are
|
||||
found.
|
||||
"""
|
||||
dll = cls.get_appropriate_windows_sdk_name() + '.dll'
|
||||
root = 'C:\\'
|
||||
for d in os.listdir(root):
|
||||
dir_path = os.path.join(root, d)
|
||||
if d.startswith('Program Files'):
|
||||
if os.path.isdir(dir_path):
|
||||
dir_path = os.path.join(dir_path, 'SEGGER')
|
||||
if not os.path.isdir(dir_path):
|
||||
continue
|
||||
else:
|
||||
ds = filter(lambda x: x.startswith('JLink')
|
||||
, os.listdir(dir_path))
|
||||
for jlink_dir in ds:
|
||||
lib_path = os.path.join(dir_path, jlink_dir, dll)
|
||||
if os.path.isfile(lib_path):
|
||||
yield lib_path
|
||||
|
||||
@classmethod
|
||||
def find_library_linux(cls):
|
||||
"""Loads the SEGGER DLL from the root directory.
|
||||
|
||||
On Linux, the SEGGER tools are installed under the ``/opt/SEGGER``
|
||||
directory with versioned directories having the suffix ``_VERSION``.
|
||||
|
||||
Args:
|
||||
cls (Library): the ``Library`` class
|
||||
|
||||
Returns:
|
||||
The paths to the J-Link library files in the order that they are
|
||||
found.
|
||||
"""
|
||||
dll = Library.JLINK_SDK_NAME
|
||||
root = os.path.join('/', 'opt', 'SEGGER')
|
||||
for directory_name, subdirs, files in os.walk(root):
|
||||
fnames = []
|
||||
x86_found = False
|
||||
for f in files:
|
||||
path = os.path.join(directory_name, f)
|
||||
if os.path.isfile(path):
|
||||
if f.startswith(dll):
|
||||
fnames.append(f)
|
||||
if '_x86' in path:
|
||||
x86_found = True
|
||||
|
||||
for fname in fnames:
|
||||
fpath = os.path.join(directory_name, fname)
|
||||
if util.is_os_64bit():
|
||||
if '_x86' not in fname:
|
||||
yield fpath
|
||||
else:
|
||||
if x86_found:
|
||||
if '_x86' in fname:
|
||||
yield fpath
|
||||
else:
|
||||
yield fpath
|
||||
|
||||
@classmethod
|
||||
def find_library_darwin(cls):
|
||||
r"""Loads the SEGGER DLL from the installed applications.
|
||||
|
||||
This method accounts for the all the different ways in which the DLL
|
||||
may be installed depending on the version of the DLL. Always uses
|
||||
the first directory found.
|
||||
|
||||
SEGGER's DLL is installed in one of three ways dependent on which
|
||||
which version of the SEGGER tools are installed:
|
||||
|
||||
======== ============================================================
|
||||
Versions Directory
|
||||
======== ============================================================
|
||||
< 5.0.0 ``/Applications/SEGGER/JLink\ NUMBER``
|
||||
< 6.0.0 ``/Applications/SEGGER/JLink/libjlinkarm.major.minor.dylib``
|
||||
>= 6.0.0 ``/Applications/SEGGER/JLink/libjlinkarm``
|
||||
======== ============================================================
|
||||
|
||||
Args:
|
||||
cls (Library): the ``Library`` class
|
||||
|
||||
Returns:
|
||||
The path to the J-Link library files in the order they are found.
|
||||
"""
|
||||
dll = Library.JLINK_SDK_NAME
|
||||
root = os.path.join('/', 'Applications', 'SEGGER')
|
||||
if not os.path.isdir(root):
|
||||
return
|
||||
for d in os.listdir(root):
|
||||
dir_path = os.path.join(root, d)
|
||||
if os.path.isdir(dir_path):
|
||||
if d.startswith('JLink'):
|
||||
files = list((f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))))
|
||||
if dll + '.dylib' in files:
|
||||
yield os.path.join(dir_path, dll + '.dylib')
|
||||
else:
|
||||
for f in files:
|
||||
if f.startswith(dll):
|
||||
yield os.path.join(dir_path, f)
|
||||
|
||||
def __init__(self, dllpath=None):
|
||||
"""Initializes an instance of a ``Library``.
|
||||
|
||||
Loads the default J-Link DLL if ``dllpath`` is ``None``, otherwise
|
||||
loads the DLL specified by the given ``dllpath``.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
dllpath (str): the DLL to load into the library
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
self._lib = None
|
||||
self._winlib = None
|
||||
self._path = None
|
||||
self._windows = sys.platform.startswith('win')
|
||||
self._cygwin = sys.platform.startswith('cygwin')
|
||||
self._temp = None
|
||||
if self._windows or self._cygwin:
|
||||
self._sdk = self.get_appropriate_windows_sdk_name()
|
||||
else:
|
||||
self._sdk = self.JLINK_SDK_NAME
|
||||
if dllpath is not None:
|
||||
self.load(dllpath)
|
||||
else:
|
||||
self.load_default()
|
||||
|
||||
def __del__(self):
|
||||
"""Cleans up the temporary DLL file created when the lib was loaded.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
self.unload()
|
||||
|
||||
def load_default(self):
|
||||
"""Loads the default J-Link SDK DLL.
|
||||
|
||||
The default J-Link SDK is determined by first checking if ``ctypes``
|
||||
can find the DLL, then by searching the platform-specific paths.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the DLL was loaded, otherwise ``False``.
|
||||
"""
|
||||
path = ctypes_util.find_library(self._sdk)
|
||||
if not path is None or self._windows or self._cygwin:
|
||||
path = next(self.find_library_windows(), None)
|
||||
else:
|
||||
if sys.platform.startswith('linux'):
|
||||
path = next(self.find_library_linux(), None)
|
||||
else:
|
||||
if sys.platform.startswith('darwin'):
|
||||
path = next(self.find_library_darwin(), None)
|
||||
if path is not None:
|
||||
return self.load(path)
|
||||
return False
|
||||
|
||||
def load(self, path=None):
|
||||
"""Loads the specified DLL, if any, otherwise re-loads the current DLL.
|
||||
|
||||
If ``path`` is specified, loads the DLL at the given ``path``,
|
||||
otherwise re-loads the DLL currently specified by this library.
|
||||
|
||||
Note:
|
||||
This creates a temporary DLL file to use for the instance. This is
|
||||
necessary to work around a limitation of the J-Link DLL in which
|
||||
multiple J-Links cannot be accessed from the same process.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
path (path): path to the DLL to load
|
||||
|
||||
Returns:
|
||||
``True`` if library was loaded successfully.
|
||||
|
||||
Raises:
|
||||
OSError: if there is no J-LINK SDK DLL present at the path.
|
||||
|
||||
See Also:
|
||||
`J-Link Multi-session <http://forum.segger.com/index.php?page=Thread&threadID=669>`_.
|
||||
"""
|
||||
self.unload()
|
||||
self._path = path or self._path
|
||||
if self._windows or self._cygwin:
|
||||
suffix = '.dll'
|
||||
else:
|
||||
if sys.platform.startswith('darwin'):
|
||||
suffix = '.dylib'
|
||||
else:
|
||||
suffix = '.so'
|
||||
tf = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
|
||||
with open(tf.name, 'wb') as outputfile:
|
||||
with open(self._path, 'rb') as inputfile:
|
||||
outputfile.write(inputfile.read())
|
||||
tf.close()
|
||||
self._temp = tf
|
||||
self._lib = ctypes.cdll.LoadLibrary(tf.name)
|
||||
if self._windows:
|
||||
self._winlib = ctypes.windll.LoadLibrary(tf.name)
|
||||
for stdcall in self._standard_calls_:
|
||||
if hasattr(self._winlib, stdcall):
|
||||
setattr(self._lib, stdcall, getattr(self._winlib, stdcall))
|
||||
|
||||
return True
|
||||
|
||||
def unload(self):
|
||||
"""Unloads the library's DLL if it has been loaded.
|
||||
|
||||
This additionally cleans up the temporary DLL file that was created
|
||||
when the library was loaded.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the DLL was unloaded, otherwise ``False``.
|
||||
"""
|
||||
unloaded = False
|
||||
if self._lib is not None:
|
||||
if self._winlib is not None:
|
||||
ctypes.windll.kernel32.FreeLibrary.argtypes = (
|
||||
ctypes.c_void_p,)
|
||||
ctypes.windll.kernel32.FreeLibrary(self._lib._handle)
|
||||
ctypes.windll.kernel32.FreeLibrary(self._winlib._handle)
|
||||
self._lib = None
|
||||
self._winlib = None
|
||||
unloaded = True
|
||||
else:
|
||||
del self._lib
|
||||
self._lib = None
|
||||
unloaded = True
|
||||
if self._temp is not None:
|
||||
os.remove(self._temp.name)
|
||||
self._temp = None
|
||||
return unloaded
|
||||
|
||||
def dll(self):
|
||||
"""Returns the DLL for the underlying shared library.
|
||||
|
||||
Args:
|
||||
self (Library): the ``Library`` instance
|
||||
|
||||
Returns:
|
||||
A ``ctypes`` DLL instance if one was loaded, otherwise ``None``.
|
||||
"""
|
||||
return self._lib
|
||||
# okay decompiling ./pylink/library.pyc
|
||||
|
|
@ -1,206 +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: pylink/registers.py
|
||||
import ctypes
|
||||
|
||||
class IDCodeRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'This class holds the different bit masks for the IDCode register.\n\n Attributes:\n valid: validity bit, should always be ``0``.\n manufactuer: the JEDEC Manufacturer ID.\n part_no: the part number defined by the manufacturer.\n version_code: the version code.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'valid', ctypes.c_uint32, 1),
|
||||
(
|
||||
'manufacturer', ctypes.c_uint32, 11),
|
||||
(
|
||||
'part_no', ctypes.c_uint32, 16),
|
||||
(
|
||||
'version_code', ctypes.c_uint32, 4)]
|
||||
|
||||
|
||||
class IDCodeRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the IDCode register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', IDCodeRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint32)]
|
||||
|
||||
|
||||
class AbortRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'This class holds the different bit mask for the Abort Register.\n\n Attributes:\n DAPABORT: write ``1`` to trigger a DAP abort.\n STKCMPCLR: write ``1`` to clear the ``STICKYCMP`` sticky compare flag\n (only supported on SW-DP).\n STKERRCLR: write ``1`` to clear the ``STICKYERR`` sticky error flag\n (only supported on SW-DP).\n WDERRCLR: write ``1`` to clear the ``WDATAERR`` write data error flag\n (only supported on SW-DP).\n ORUNERRCLR: write ``1`` to clear the ``STICKYORUN`` overrun error flag\n (only supported on SW-DP).\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'DAPABORT', ctypes.c_uint32, 1),
|
||||
(
|
||||
'STKCMPCLR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'STKERRCLR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'WDERRCLR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'ORUNERRCLR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'RESERVED', ctypes.c_uint32, 27)]
|
||||
|
||||
|
||||
class AbortRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the abort register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', AbortRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint32)]
|
||||
|
||||
|
||||
class ControlStatusRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'This class holds the different bit masks for the DP Control / Status\n Register bit assignments.\n\n Attributes:\n ORUNDETECT: if set, enables overrun detection.\n STICKYORUN: if overrun is enabled, is set when overrun occurs.\n TRNMODE: transfer mode for acess port operations.\n STICKYCMP: is set when a match occurs on a pushed compare or verify\n operation.\n STICKYERR: is set when an error is returned by an access port\n transaction.\n READOK: is set when the response to a previous access port or ``RDBUFF``\n was ``OK``.\n WDATAERR: set to ``1`` if a Write Data Error occurs.\n MASKLANE: bytes to be masked in pushed compare and verify operations.\n TRNCNT: transaction counter.\n RESERVED: reserved.\n CDBGRSTREQ: debug reset request.\n CDBGRSTACK: debug reset acknowledge.\n CDBGPWRUPREQ: debug power-up request.\n CDBGPWRUPACK: debug power-up acknowledge.\n CSYSPWRUPREQ: system power-up request\n CSYSPWRUPACK: system power-up acknowledge.\n\n See also:\n See the ARM documentation on the significance of these masks\n `here <http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ihi0031c/index.html>`_.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'ORUNDETECT', ctypes.c_uint32, 1),
|
||||
(
|
||||
'STICKYORUN', ctypes.c_uint32, 1),
|
||||
(
|
||||
'TRNMODE', ctypes.c_uint32, 2),
|
||||
(
|
||||
'STICKYCMP', ctypes.c_uint32, 1),
|
||||
(
|
||||
'STICKYERR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'READOK', ctypes.c_uint32, 1),
|
||||
(
|
||||
'WDATAERR', ctypes.c_uint32, 1),
|
||||
(
|
||||
'MASKLANE', ctypes.c_uint32, 4),
|
||||
(
|
||||
'TRNCNT', ctypes.c_uint32, 12),
|
||||
(
|
||||
'RESERVED', ctypes.c_uint32, 2),
|
||||
(
|
||||
'CDBGRSTREQ', ctypes.c_uint32, 1),
|
||||
(
|
||||
'CDBGRSTACK', ctypes.c_uint32, 1),
|
||||
(
|
||||
'CDBGPWRUPREQ', ctypes.c_uint32, 1),
|
||||
(
|
||||
'CDBGPWRUPACK', ctypes.c_uint32, 1),
|
||||
(
|
||||
'CSYSPWRUPREQ', ctypes.c_uint32, 1),
|
||||
(
|
||||
'CSYSPWRUPACK', ctypes.c_uint32, 1)]
|
||||
|
||||
|
||||
class ControlStatusRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the control/status register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', ControlStatusRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint32)]
|
||||
|
||||
|
||||
class SelectRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'This class holds the different bit masks for the AP Select Register.\n\n Attributes:\n CTRLSEL: SW-DP debug port address bank select.\n RESERVED_A: reserved.\n APBANKSEL: selects the active four-word register window on the current\n access port.\n RESERVED_B: reserved.\n APSEL: selects the current access port.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'CTRLSEL', ctypes.c_uint32, 1),
|
||||
(
|
||||
'RESERVED_A', ctypes.c_uint32, 3),
|
||||
(
|
||||
'APBANKSEL', ctypes.c_uint32, 4),
|
||||
(
|
||||
'RESERVED_B', ctypes.c_uint32, 16),
|
||||
(
|
||||
'APSEL', ctypes.c_uint32, 8)]
|
||||
|
||||
|
||||
class SelectRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the select register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', SelectRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint32)]
|
||||
|
||||
|
||||
class MDMAPControlRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'This class holds the different bit masks for the MDM-AP Control\n Register.\n\n Attributes:\n flash_mass_erase: set to cause a mass erase, this is cleared\n automatically when a mass erase finishes.\n debug_disable: set to disable debug, clear to allow debug.\n debug_request: set to force the core to halt.\n sys_reset_request: set to force a system reset.\n core_hold_reset: set to suspend the core in reset at the end of reset\n sequencing.\n VLLDBGREQ: set to hold the system in reset after the next recovery from\n VLLSx (Very Low Leakage Stop).\n VLLDBGACK: set to release a system held in reset following a VLLSx\n (Very Low Leakage Stop) recovery.\n VLLSTATACK: set to acknowledge that the DAP LLS (Low Leakage Stop) and\n VLLS (Very Low Leakage Stop) status bits have read.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'flash_mass_erase', ctypes.c_uint8, 1),
|
||||
(
|
||||
'debug_disable', ctypes.c_uint8, 1),
|
||||
(
|
||||
'debug_request', ctypes.c_uint8, 1),
|
||||
(
|
||||
'sys_reset_request', ctypes.c_uint8, 1),
|
||||
(
|
||||
'core_hold_reset', ctypes.c_uint8, 1),
|
||||
(
|
||||
'VLLDBGREQ', ctypes.c_uint8, 1),
|
||||
(
|
||||
'VLLDBGACK', ctypes.c_uint8, 1),
|
||||
(
|
||||
'VLLSTATACK', ctypes.c_uint8, 1)]
|
||||
|
||||
|
||||
class MDMAPControlRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the MDM-AP control register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', MDMAPControlRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint8)]
|
||||
|
||||
|
||||
class MDMAPStatusRegisterBits(ctypes.LittleEndianStructure):
|
||||
__doc__ = 'Holds the bit masks for the MDM-AP Status Register.\n\n Attributes:\n flash_mass_erase_ack: cleared after a system reset, indicates that a\n flash mass erase was acknowledged.\n flash_ready: indicates that flash has been initialized and can be\n configured.\n system_security: if set, system is secure and debugger cannot access the\n memory or system bus.\n system_reset: ``1`` if system is in reset, otherwise ``0``.\n mass_erase_enabled: ``1`` if MCU can be mass erased, otherwise ``0``.\n low_power_enabled: ``1`` if low power stop mode is enabled, otherwise ``0``.\n very_low_power_mode: ``1`` if device is in very low power mode.\n LLSMODEEXIT: indicates an exit from LLS mode has occurred.\n VLLSxMODEEXIT: indicates an exit from VLLSx mode has occured.\n core_halted; indicates core has entered debug halt mode.\n core_deep_sleep: indicates core has entered a low power mode.\n core_sleeping: indicates the core has entered a low power mode.\n\n Note:\n if ``core_sleeping & !core_deep_sleep``, then the core is in VLPW (very\n low power wait) mode, otherwise if ``core_sleeping & core_deep_sleep``,\n then it is in VLPS (very low power stop) mode.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'flash_mass_erase_ack', ctypes.c_uint32, 1),
|
||||
(
|
||||
'flash_ready', ctypes.c_uint32, 1),
|
||||
(
|
||||
'system_security', ctypes.c_uint32, 1),
|
||||
(
|
||||
'system_reset', ctypes.c_uint32, 1),
|
||||
(
|
||||
'RESERVED_A', ctypes.c_uint32, 1),
|
||||
(
|
||||
'mass_erase_enabled', ctypes.c_uint32, 1),
|
||||
(
|
||||
'backdoor_access_enabled', ctypes.c_uint32, 1),
|
||||
(
|
||||
'low_power_enabled', ctypes.c_uint32, 1),
|
||||
(
|
||||
'very_low_power_mode', ctypes.c_uint32, 1),
|
||||
(
|
||||
'LLSMODEEXIT', ctypes.c_uint32, 1),
|
||||
(
|
||||
'VLLSxMODEEXIT', ctypes.c_uint32, 1),
|
||||
(
|
||||
'RESERVED_B', ctypes.c_uint32, 5),
|
||||
(
|
||||
'core_halted', ctypes.c_uint32, 1),
|
||||
(
|
||||
'core_deep_sleep', ctypes.c_uint32, 1),
|
||||
(
|
||||
'core_sleeping', ctypes.c_uint32, 1),
|
||||
(
|
||||
'RESERVED_C', ctypes.c_uint32, 13)]
|
||||
|
||||
|
||||
class MDMAPStatusRegisterFlags(ctypes.Union):
|
||||
__doc__ = 'Mask for the MDM-AP status register bits.\n\n Attributes:\n value: the value stored in the mask.\n '
|
||||
_anonymous_ = ('bit', )
|
||||
_fields_ = [
|
||||
(
|
||||
'bit', MDMAPStatusRegisterBits),
|
||||
(
|
||||
'value', ctypes.c_uint32)]
|
||||
# okay decompiling ./pylink/registers.pyc
|
||||
|
|
@ -1,907 +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: pylink/structs.py
|
||||
from . import enums
|
||||
import ctypes
|
||||
|
||||
class JLinkConnectInfo(ctypes.Structure):
|
||||
__doc__ = 'J-Link connection info structure.\n\n Attributes:\n SerialNumber: J-Link serial number.\n Connection: type of connection (e.g. ``enums.JLinkHost.USB``)\n USBAddr: USB address if connected via USB.\n aIPAddr: IP address if connected via IP.\n Time: Time period (ms) after which UDP discover answer was received.\n Time_us: Time period (uS) after which UDP discover answer was received.\n HWVersion: Hardware version of J-Link, if connected via IP.\n abMACAddr: MAC Address, if connected via IP.\n acProduct: Product name, if connected via IP.\n acNickname: Nickname, if connected via IP.\n acFWString: Firmware string, if connected via IP.\n IsDHCPAssignedIP: Is IP address reception via DHCP.\n IsDHCPAssignedIPIsValid: True if connected via IP.\n NumIPConnections: Number of IP connections currently established.\n NumIPConnectionsIsValid: True if connected via IP.\n aPadding: Bytes reserved for future use.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SerialNumber', ctypes.c_uint32),
|
||||
(
|
||||
'Connection', ctypes.c_ubyte),
|
||||
(
|
||||
'USBAddr', ctypes.c_uint32),
|
||||
(
|
||||
'aIPAddr', ctypes.c_uint8 * 16),
|
||||
(
|
||||
'Time', ctypes.c_int),
|
||||
(
|
||||
'Time_us', ctypes.c_uint64),
|
||||
(
|
||||
'HWVersion', ctypes.c_uint32),
|
||||
(
|
||||
'abMACAddr', ctypes.c_uint8 * 6),
|
||||
(
|
||||
'acProduct', ctypes.c_char * 32),
|
||||
(
|
||||
'acNickname', ctypes.c_char * 32),
|
||||
(
|
||||
'acFWString', ctypes.c_char * 112),
|
||||
(
|
||||
'IsDHCPAssignedIP', ctypes.c_char),
|
||||
(
|
||||
'IsDHCPAssignedIPIsValid', ctypes.c_char),
|
||||
(
|
||||
'NumIPConnections', ctypes.c_char),
|
||||
(
|
||||
'NumIPConnectionsIsValid', ctypes.c_char),
|
||||
(
|
||||
'aPadding', ctypes.c_uint8 * 34)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a representation of this class.
|
||||
|
||||
Args:
|
||||
self (JLinkConnectInfo): the ``JlinkConnectInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the class.
|
||||
"""
|
||||
return 'JLinkConnectInfo(%s)' % self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the connection info.
|
||||
|
||||
Args:
|
||||
self (JLinkConnectInfo): the ``JLinkConnectInfo`` instance
|
||||
|
||||
Returns:
|
||||
String specifying the product, its serial number, and the type of
|
||||
connection that it has (one of USB or IP).
|
||||
"""
|
||||
conn = 'USB' if self.Connection == 1 else 'IP'
|
||||
return '%s <Serial No. %s, Conn. %s>' % (self.acProduct.decode(), self.SerialNumber, conn)
|
||||
|
||||
|
||||
class JLinkFlashArea(ctypes.Structure):
|
||||
__doc__ = 'Definition for a region of Flash.\n\n Attributes:\n Addr: address where the flash area starts.\n Size: size of the flash area.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'Addr', ctypes.c_uint32),
|
||||
(
|
||||
'Size', ctypes.c_uint32)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a representation of the instance.
|
||||
|
||||
Args:
|
||||
self (FlashArea): the ``FlashArea`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the Flash Area.
|
||||
"""
|
||||
return '%s(%s)' % (self.__class__.__name__, self.__str__())
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (FlashArea): the ``FlashArea`` instance
|
||||
|
||||
Returns:
|
||||
String specifying address of flash region, and its size.
|
||||
"""
|
||||
return 'Address = 0x%x, Size = %s' % (self.Addr, self.Size)
|
||||
|
||||
|
||||
class JLinkRAMArea(JLinkFlashArea):
|
||||
__doc__ = 'Definition for a region of RAM.\n\n Attributes:\n Addr: address where the flash area starts.\n Size: size of the flash area.\n '
|
||||
|
||||
|
||||
class JLinkDeviceInfo(ctypes.Structure):
|
||||
__doc__ = 'J-Link device information.\n\n This structure is used to represent a device that is supported by the\n J-Link.\n\n Attributes:\n SizeOfStruct: Size of the struct (DO NOT CHANGE).\n sName: name of the device.\n CoreId: core identifier of the device.\n FlashAddr: base address of the internal flash of the device.\n RAMAddr: base address of the internal RAM of the device.\n EndianMode: the endian mode of the device (0 -> only little endian,\n 1 -> only big endian, 2 -> both).\n FlashSize: total flash size in bytes.\n RAMSize: total RAM size in bytes.\n sManu: device manufacturer.\n aFlashArea: a list of ``JLinkFlashArea`` instances.\n aRamArea: a list of ``JLinkRAMArea`` instances.\n Core: CPU core.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeofStruct', ctypes.c_uint32),
|
||||
(
|
||||
'sName', ctypes.POINTER(ctypes.c_char)),
|
||||
(
|
||||
'CoreId', ctypes.c_uint32),
|
||||
(
|
||||
'FlashAddr', ctypes.c_uint32),
|
||||
(
|
||||
'RAMAddr', ctypes.c_uint32),
|
||||
(
|
||||
'EndianMode', ctypes.c_char),
|
||||
(
|
||||
'FlashSize', ctypes.c_uint32),
|
||||
(
|
||||
'RAMSize', ctypes.c_uint32),
|
||||
(
|
||||
'sManu', ctypes.POINTER(ctypes.c_char)),
|
||||
(
|
||||
'aFlashArea', JLinkFlashArea * 32),
|
||||
(
|
||||
'aRAMArea', JLinkRAMArea * 32),
|
||||
(
|
||||
'Core', ctypes.c_uint32)]
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
(super(JLinkDeviceInfo, self).__init__)(*args, **kwargs)
|
||||
self.SizeofStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a representation of this instance.
|
||||
|
||||
Args:
|
||||
self (JLinkDeviceInfo): the ``JLinkDeviceInfo`` instance
|
||||
|
||||
Returns:
|
||||
Returns a string representation of the instance.
|
||||
"""
|
||||
return 'JLinkDeviceInfo(%s)' % self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of this instance.
|
||||
|
||||
Args:
|
||||
self (JLinkDeviceInfo): the ``JLinkDeviceInfo`` instance
|
||||
|
||||
Returns:
|
||||
Returns a string specifying the device name, core, and manufacturer.
|
||||
"""
|
||||
manu = self.manufacturer
|
||||
return '%s <Core Id. %s, Manu. %s>' % (self.name, self.Core, manu)
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
"""Returns the name of the device.
|
||||
|
||||
Args:
|
||||
self (JLinkDeviceInfo): the ``JLinkDeviceInfo`` instance
|
||||
|
||||
Returns:
|
||||
Device name.
|
||||
"""
|
||||
return ctypes.cast(self.sName, ctypes.c_char_p).value.decode()
|
||||
|
||||
@property
|
||||
def manufacturer(self):
|
||||
"""Returns the name of the manufacturer of the device.
|
||||
|
||||
Args:
|
||||
self (JLinkDeviceInfo): the ``JLinkDeviceInfo`` instance
|
||||
|
||||
Returns:
|
||||
Manufacturer name.
|
||||
"""
|
||||
buf = ctypes.cast(self.sManu, ctypes.c_char_p).value
|
||||
if buf:
|
||||
return buf.decode()
|
||||
|
||||
|
||||
class JLinkHardwareStatus(ctypes.Structure):
|
||||
__doc__ = 'Definition for the hardware status information for a J-Link.\n\n Attributes:\n VTarget: target supply voltage.\n tck: measured state of TCK pin.\n tdi: measured state of TDI pin.\n tdo: measured state of TDO pin.\n tms: measured state of TMS pin.\n tres: measured state of TRES pin.\n trst: measured state of TRST pin.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'VTarget', ctypes.c_uint16),
|
||||
(
|
||||
'tck', ctypes.c_uint8),
|
||||
(
|
||||
'tdi', ctypes.c_uint8),
|
||||
(
|
||||
'tdo', ctypes.c_uint8),
|
||||
(
|
||||
'tms', ctypes.c_uint8),
|
||||
(
|
||||
'tres', ctypes.c_uint8),
|
||||
(
|
||||
'trst', ctypes.c_uint8)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkHardwareStatus): the ``JlinkHardwareStatus`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the instance.
|
||||
"""
|
||||
return '%s(VTarget=%dmV)' % (self.__class__.__name__, self.voltage)
|
||||
|
||||
@property
|
||||
def voltage(self):
|
||||
"""Returns the target supply voltage.
|
||||
|
||||
This is an alias for ``.VTarget``.
|
||||
|
||||
Args:
|
||||
self (JLInkHardwareStatus): the ``JLinkHardwareStatus`` instance
|
||||
|
||||
Returns:
|
||||
Target supply voltage as an integer.
|
||||
"""
|
||||
return self.VTarget
|
||||
|
||||
|
||||
class JLinkGPIODescriptor(ctypes.Structure):
|
||||
__doc__ = 'Definition for the structure that details the name and capabilities of a\n user-controllable GPIO.\n\n Attributes:\n acName: name of the GPIO.\n Caps: bitfield of capabilities.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'acName', ctypes.c_char * 32),
|
||||
(
|
||||
'Caps', ctypes.c_uint32)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkGPIODescriptor): the ``JLinkGPIODescriptor`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the instance.
|
||||
"""
|
||||
return '%s(%s)' % (self.__class__.__name__, self.__str__())
|
||||
|
||||
def __str__(self):
|
||||
"""Returns the GPIO name.
|
||||
|
||||
Args:
|
||||
self (JLinkGPIODescriptor): the ``JLInkGPIODescriptor`` instance
|
||||
|
||||
Returns:
|
||||
GPIO name.
|
||||
"""
|
||||
return self.acName.decode()
|
||||
|
||||
|
||||
class JLinkMemoryZone(ctypes.Structure):
|
||||
__doc__ = 'Represents a CPU memory zone.\n\n Attributes:\n sName: initials of the memory zone.\n sDesc: name of the memory zone.\n VirtAddr: start address of the virtual address space of the memory zone.\n abDummy: reserved for future use.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'sName', ctypes.c_char_p),
|
||||
(
|
||||
'sDesc', ctypes.c_char_p),
|
||||
(
|
||||
'VirtAddr', ctypes.c_uint64),
|
||||
(
|
||||
'abDummy', ctypes.c_uint8 * 16)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance
|
||||
|
||||
Args:
|
||||
self: the ``JLinkMemoryZone`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the instance.
|
||||
"""
|
||||
return '%s(%s)' % (self.__class__.__name__, self.__str__())
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a formatted string describing the memory zone.
|
||||
|
||||
Args:
|
||||
self: the ``JLinkMemoryZone`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the memory zone.
|
||||
"""
|
||||
return '%s <Desc. %s, VirtAddr. 0x%x>' % (self.sName, self.sDesc, self.VirtAddr)
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
"""Alias for the memory zone name.
|
||||
|
||||
Args:
|
||||
self (JLinkMemoryZone): the ``JLinkMemoryZone`` instance
|
||||
|
||||
Returns:
|
||||
The memory zone name.
|
||||
"""
|
||||
return self.sName
|
||||
|
||||
|
||||
class JLinkSpeedInfo(ctypes.Structure):
|
||||
__doc__ = "Represents information about an emulator's supported speeds.\n\n The emulator can support all target interface speeds calculated by dividing\n the base frequency by atleast ``MinDiv``.\n\n Attributes:\n SizeOfStruct: the size of this structure.\n BaseFreq: Base frequency (in HZ) used to calculate supported speeds.\n MinDiv: minimum divider allowed to divide the base frequency.\n SupportAdaptive: ``1`` if emulator supports adaptive clocking, otherwise\n ``0``.\n "
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_uint32),
|
||||
(
|
||||
'BaseFreq', ctypes.c_uint32),
|
||||
(
|
||||
'MinDiv', ctypes.c_uint16),
|
||||
(
|
||||
'SupportAdaptive', ctypes.c_uint16)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkSpeedInfo, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkSpeedInfo): the ``JLinkSpeedInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the instance.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns this instance formatted as a string.
|
||||
|
||||
Args:
|
||||
self (JLinkSpeedInfo): the ``JLinkSpeedInfo`` instance
|
||||
|
||||
Returns:
|
||||
String formatted instance.
|
||||
"""
|
||||
return '%s(Freq=%sHz)' % (self.__class__.__name__, self.BaseFreq)
|
||||
|
||||
|
||||
class JLinkSWOStartInfo(ctypes.Structure):
|
||||
__doc__ = 'Represents configuration information for collecting Serial Wire Output\n (SWO) information.\n\n Attributes:\n SizeofStruct: size of the structure.\n Interface: the interface type used for SWO.\n Speed: the frequency used for SWO communication in Hz.\n\n Note:\n You should *never* change ``.SizeofStruct`` or ``.Interface``.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeofStruct', ctypes.c_uint32),
|
||||
(
|
||||
'Interface', ctypes.c_uint32),
|
||||
(
|
||||
'Speed', ctypes.c_uint32)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkSWOStartInfo, self).__init__()
|
||||
self.SizeofStruct = ctypes.sizeof(self)
|
||||
self.Interface = enums.JLinkSWOInterfaces.UART
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a representation of this instance.
|
||||
|
||||
Args:
|
||||
self (JLinkSWOStartInfo): the ``JLinkSWOStartInfo`` instance
|
||||
|
||||
Returns:
|
||||
The string representation of this instance.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of this instance.
|
||||
|
||||
Args:
|
||||
self (JLinkSWOStartInfo): the ``JLinkSWOStartInfo`` instance
|
||||
|
||||
Returns:
|
||||
The string representation of this instance.
|
||||
"""
|
||||
return '%s(Speed=%sHz)' % (self.__class__.__name__, self.Speed)
|
||||
|
||||
|
||||
class JLinkSWOSpeedInfo(ctypes.Structure):
|
||||
__doc__ = "Structure representing information about target's supported SWO speeds.\n\n To calculate the supported SWO speeds, the base frequency is taken and\n divide by a number in the range of ``[ MinDiv, MaxDiv ]``.\n\n Attributes:\n SizeofStruct: size of the structure.\n Interface: interface type for the speed information.\n BaseFreq: base frequency (Hz) used to calculate supported SWO speeds.\n MinDiv: minimum divider allowed to divide the base frequency.\n MaxDiv: maximum divider allowed to divide the base frequency.\n MinPrescale: minimum prescaler allowed to adjust the base frequency.\n MaxPrescale: maximum prescaler allowed to adjust the base frequency.\n\n Note:\n You should *never* change ``.SizeofStruct`` or ``.Interface``.\n "
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeofStruct', ctypes.c_uint32),
|
||||
(
|
||||
'Interface', ctypes.c_uint32),
|
||||
(
|
||||
'BaseFreq', ctypes.c_uint32),
|
||||
(
|
||||
'MinDiv', ctypes.c_uint32),
|
||||
(
|
||||
'MaxDiv', ctypes.c_uint32),
|
||||
(
|
||||
'MinPrescale', ctypes.c_uint32),
|
||||
(
|
||||
'MaxPrescale', ctypes.c_uint32)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkSWOSpeedInfo, self).__init__()
|
||||
self.SizeofStruct = ctypes.sizeof(self)
|
||||
self.Interface = enums.JLinkSWOInterfaces.UART
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkSWOSpeedInfo): the ``JLinkSWOSpeedInfo`` instance
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representaton of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkSWOSpeedInfo): the ``JLinkSWOSpeedInfo`` instance
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
return '%s(Interface=UART, Freq=%sHz)' % (self.__class__.__name__, self.BaseFreq)
|
||||
|
||||
|
||||
class JLinkMOEInfo(ctypes.Structure):
|
||||
__doc__ = 'Structure representing the Method of Debug Entry (MOE).\n\n The method of debug entry is a reason for which a CPU has stopped. At any\n given time, there may be multiple methods of debug entry.\n\n Attributes:\n HaltReason: reason why the CPU stopped.\n Index: if cause of CPU stop was a code/data breakpoint, this identifies\n the index of the code/data breakpoint unit which causes the CPU to\n stop, otherwise it is ``-1``.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'HaltReason', ctypes.c_uint32),
|
||||
(
|
||||
'Index', ctypes.c_int)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
A string representation of the instance.
|
||||
"""
|
||||
return '%s(%s)' % (self.__class__.__name__, self.__str__())
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
A string representation of the instance.
|
||||
"""
|
||||
d = enums.JLinkHaltReasons.__dict__
|
||||
s = next((k for k, v in d.items() if v == self.HaltReason))
|
||||
if self.dbgrq():
|
||||
return s
|
||||
return s.replace('_', ' ').title()
|
||||
|
||||
def dbgrq(self):
|
||||
"""Returns whether this a DBGRQ.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if this is a DBGRQ, otherwise ``False``.
|
||||
"""
|
||||
return self.HaltReason == enums.JLinkHaltReasons.DBGRQ
|
||||
|
||||
def code_breakpoint(self):
|
||||
"""Returns whether this a code breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if this is a code breakpoint, otherwise ``False``.
|
||||
"""
|
||||
return self.HaltReason == enums.JLinkHaltReasons.CODE_BREAKPOINT
|
||||
|
||||
def data_breakpoint(self):
|
||||
"""Returns whether this a data breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if this is a data breakpoint, otherwise ``False``.
|
||||
"""
|
||||
return self.HaltReason == enums.JLinkHaltReasons.DATA_BREAKPOINT
|
||||
|
||||
def vector_catch(self):
|
||||
"""Returns whether this a vector catch.
|
||||
|
||||
Args:
|
||||
self (JLinkMOEInfo): the ``JLinkMOEInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if this is a vector catch, otherwise ``False``.
|
||||
"""
|
||||
return self.HaltReason == enums.JLinkHaltReasons.VECTOR_CATCH
|
||||
|
||||
|
||||
class JLinkBreakpointInfo(ctypes.Structure):
|
||||
__doc__ = 'Class representing information about a breakpoint.\n\n Attributes:\n SizeOfStruct: the size of the structure (this should not be modified).\n Handle: breakpoint handle.\n Addr: address of where the breakpoint has been set.\n Type: type flags which were specified when the breakpoint was created.\n ImpFlags: describes the current state of the breakpoint.\n UseCnt: describes how often the breakpoint is set at the same address.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_uint32),
|
||||
(
|
||||
'Handle', ctypes.c_uint32),
|
||||
(
|
||||
'Addr', ctypes.c_uint32),
|
||||
(
|
||||
'Type', ctypes.c_uint32),
|
||||
(
|
||||
'ImpFlags', ctypes.c_uint32),
|
||||
(
|
||||
'UseCnt', ctypes.c_uint32)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkBreakpointInfo, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a formatted string describing the breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkBreakpointInfo): the ``JLinkBreakpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
Stirng representation of the breakpoint.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a formatted string describing the breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkBreakpointInfo): the ``JLinkBreakpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
Stirng representation of the breakpoint.
|
||||
"""
|
||||
name = self.__class__.__name__
|
||||
return '%s(Handle %d, Address %d)' % (name, self.Handle, self.Addr)
|
||||
|
||||
def software_breakpoint(self):
|
||||
"""Returns whether this is a software breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkBreakpointInfo): the ``JLinkBreakpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the breakpoint is a software breakpoint, otherwise
|
||||
``False``.
|
||||
"""
|
||||
software_types = [
|
||||
enums.JLinkBreakpoint.SW_RAM,
|
||||
enums.JLinkBreakpoint.SW_FLASH,
|
||||
enums.JLinkBreakpoint.SW]
|
||||
return any((self.Type & stype for stype in software_types))
|
||||
|
||||
def hardware_breakpoint(self):
|
||||
"""Returns whether this is a hardware breakpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkBreakpointInfo): the ``JLinkBreakpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the breakpoint is a hardware breakpoint, otherwise
|
||||
``False``.
|
||||
"""
|
||||
return self.Type & enums.JLinkBreakpoint.HW
|
||||
|
||||
def pending(self):
|
||||
"""Returns if this breakpoint is pending.
|
||||
|
||||
Args:
|
||||
self (JLinkBreakpointInfo): the ``JLinkBreakpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
``True`` if the breakpoint is still pending, otherwise ``False``.
|
||||
"""
|
||||
return self.ImpFlags & enums.JLinkBreakpointImplementation.PENDING
|
||||
|
||||
|
||||
class JLinkDataEvent(ctypes.Structure):
|
||||
__doc__ = 'Class representing a data event.\n\n A data may halt the CPU, trigger SWO output, or trigger trace output.\n\n Attributes:\n SizeOfStruct: the size of the structure (this should not be modified).\n Type: the type of the data event (this should not be modified).\n Addr: the address on which the watchpoint was set\n AddrMask: the address mask used for comparision.\n Data: the data on which the watchpoint has been set.\n DataMask: the data mask used for comparision.\n Access: the control data on which the event has been set.\n AccessMask: the control mask used for comparison.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_int),
|
||||
(
|
||||
'Type', ctypes.c_int),
|
||||
(
|
||||
'Addr', ctypes.c_uint32),
|
||||
(
|
||||
'AddrMask', ctypes.c_uint32),
|
||||
(
|
||||
'Data', ctypes.c_uint32),
|
||||
(
|
||||
'DataMask', ctypes.c_uint32),
|
||||
(
|
||||
'Access', ctypes.c_uint8),
|
||||
(
|
||||
'AccessMask', ctypes.c_uint8)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkDataEvent, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
self.Type = enums.JLinkEventTypes.BREAKPOINT
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the data event.
|
||||
|
||||
Args:
|
||||
self (JLinkDataEvent): the ``JLinkDataEvent`` instance
|
||||
|
||||
Returns:
|
||||
A string representation of the data event.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the data event.
|
||||
|
||||
Args:
|
||||
self (JLinkDataEvent): the ``JLinkDataEvent`` instance
|
||||
|
||||
Returns:
|
||||
A string representation of the data event.
|
||||
"""
|
||||
name = self.__class__.__name__
|
||||
return '%s(Type %d, Address %d)' % (name, self.Type, self.Addr)
|
||||
|
||||
|
||||
class JLinkWatchpointInfo(ctypes.Structure):
|
||||
__doc__ = 'Class representing information about a watchpoint.\n\n Attributes:\n SizeOfStruct: the size of the structure (this should not be modified).\n Handle: the watchpoint handle.\n Addr: the address the watchpoint was set at.\n AddrMask: the address mask used for comparison.\n Data: the data on which the watchpoint was set.\n DataMask: the data mask used for comparision.\n Ctrl: the control data on which the breakpoint was set.\n CtrlMask: the control mask used for comparison.\n WPUnit: the index of the watchpoint unit.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_uint32),
|
||||
(
|
||||
'Handle', ctypes.c_uint32),
|
||||
(
|
||||
'Addr', ctypes.c_uint32),
|
||||
(
|
||||
'AddrMask', ctypes.c_uint32),
|
||||
(
|
||||
'Data', ctypes.c_uint32),
|
||||
(
|
||||
'DataMask', ctypes.c_uint32),
|
||||
(
|
||||
'Ctrl', ctypes.c_uint32),
|
||||
(
|
||||
'CtrlMask', ctypes.c_uint32),
|
||||
(
|
||||
'WPUnit', ctypes.c_uint8)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkWatchpointInfo, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a formatted string describing the watchpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkWatchpointInfo): the ``JLinkWatchpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the watchpoint.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a formatted string describing the watchpoint.
|
||||
|
||||
Args:
|
||||
self (JLinkWatchpointInfo): the ``JLinkWatchpointInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the watchpoint.
|
||||
"""
|
||||
name = self.__class__.__name__
|
||||
return '%s(Handle %d, Address %d)' % (name, self.Handle, self.Addr)
|
||||
|
||||
|
||||
class JLinkStraceEventInfo(ctypes.Structure):
|
||||
__doc__ = 'Class representing the STRACE event information.\n\n Attributes:\n SizeOfStruct: size of the structure.\n Type: type of event.\n Op: the STRACE operation to perform.\n AccessSize: access width for trace events.\n Reserved0: reserved.\n Addr: specifies the load/store address for data.\n Data: the data to be compared for the operation for data access events.\n DataMask: bitmask for bits of data to omit in comparision for data access\n events.\n AddrRangeSize: address range for range events.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_uint32),
|
||||
(
|
||||
'Type', ctypes.c_uint8),
|
||||
(
|
||||
'Op', ctypes.c_uint8),
|
||||
(
|
||||
'AccessSize', ctypes.c_uint8),
|
||||
(
|
||||
'Reserved0', ctypes.c_uint8),
|
||||
(
|
||||
'Addr', ctypes.c_uint64),
|
||||
(
|
||||
'Data', ctypes.c_uint64),
|
||||
(
|
||||
'DataMask', ctypes.c_uint64),
|
||||
(
|
||||
'AddrRangeSize', ctypes.c_uint32)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkStraceEventInfo, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a formatted string describing the event info.
|
||||
|
||||
Args:
|
||||
self (JLinkStraceEventInfo): the ``JLinkStraceEventInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the event info.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a formatted string describing the event info.
|
||||
|
||||
Args:
|
||||
self (JLinkStraceEventInfo): the ``JLinkStraceEventInfo`` instance
|
||||
|
||||
Returns:
|
||||
String representation of the event information.
|
||||
"""
|
||||
name = self.__class__.__name__
|
||||
return '%s(Type=%d, Op=%d)' % (name, self.Type, self.Op)
|
||||
|
||||
|
||||
class JLinkTraceData(ctypes.Structure):
|
||||
__doc__ = 'Structure representing trace data returned by the trace buffer.\n\n Attributes:\n PipeStat: type of trace data.\n Sync: sync point in buffer.\n Packet: trace data packet.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'PipeStat', ctypes.c_uint8),
|
||||
(
|
||||
'Sync', ctypes.c_uint8),
|
||||
(
|
||||
'Packet', ctypes.c_uint16)]
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the trace data instance.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
A string representation of the instance.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the trace data instance.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
A string representation of the instance.
|
||||
"""
|
||||
return '%s(%d)' % (self.__class__.__name__, self.Packet)
|
||||
|
||||
def instruction(self):
|
||||
"""Returns whether the data corresponds to an executed instruction.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for an executed instruction.
|
||||
"""
|
||||
return self.PipeStat == 0
|
||||
|
||||
def data_instruction(self):
|
||||
"""Returns whether the data corresponds to an data instruction.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for an data instruction.
|
||||
"""
|
||||
return self.PipeStat == 1
|
||||
|
||||
def non_instruction(self):
|
||||
"""Returns whether the data corresponds to an un-executed instruction.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for an un-executed instruction.
|
||||
"""
|
||||
return self.PipeStat == 2
|
||||
|
||||
def wait(self):
|
||||
"""Returns whether the data corresponds to a wait.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for a wait.
|
||||
"""
|
||||
return self.PipeStat == 3
|
||||
|
||||
def branch(self):
|
||||
"""Returns whether the data corresponds to a branch execution.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for a branch execution.
|
||||
"""
|
||||
return self.PipeStat == 4
|
||||
|
||||
def data_branch(self):
|
||||
"""Returns whether the data corresponds to a branch with data.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for a branch with data.
|
||||
"""
|
||||
return self.PipeStat == 5
|
||||
|
||||
def trigger(self):
|
||||
"""Returns whether the data corresponds to a trigger event.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for a trigger event.
|
||||
"""
|
||||
return self.PipeStat == 6
|
||||
|
||||
def trace_disabled(self):
|
||||
"""Returns whether the data corresponds to trace being disabled.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceData): the ``JLinkTraceData`` instance.
|
||||
|
||||
Returns:
|
||||
``True`` if this is trace data for the trace disabled event.
|
||||
"""
|
||||
return self.PipeStat == 7
|
||||
|
||||
|
||||
class JLinkTraceRegion(ctypes.Structure):
|
||||
__doc__ = 'Structure describing a trace region.\n\n Attributes:\n SizeOfStruct: size of the structure.\n RegionIndex: index of the region.\n NumSamples: number of samples in the region.\n Off: offset in the trace buffer.\n RegionCnt: number of trace regions.\n Dummy: unused.\n Timestamp: timestamp of last event written to buffer.\n '
|
||||
_fields_ = [
|
||||
(
|
||||
'SizeOfStruct', ctypes.c_uint32),
|
||||
(
|
||||
'RegionIndex', ctypes.c_uint32),
|
||||
(
|
||||
'NumSamples', ctypes.c_uint32),
|
||||
(
|
||||
'Off', ctypes.c_uint32),
|
||||
(
|
||||
'RegionCnt', ctypes.c_uint32),
|
||||
(
|
||||
'Dummy', ctypes.c_uint32),
|
||||
(
|
||||
'Timestamp', ctypes.c_uint64)]
|
||||
|
||||
def __init__(self):
|
||||
super(JLinkTraceRegion, self).__init__()
|
||||
self.SizeOfStruct = ctypes.sizeof(self)
|
||||
|
||||
def __repr__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceRegion): the ``JLinkTraceRegion`` instance.
|
||||
|
||||
Returns:
|
||||
String representation of the trace region.
|
||||
"""
|
||||
return self.__str__()
|
||||
|
||||
def __str__(self):
|
||||
"""Returns a string representation of the instance.
|
||||
|
||||
Args:
|
||||
self (JLinkTraceRegion): the ``JLinkTraceRegion`` instance.
|
||||
|
||||
Returns:
|
||||
String representation of the trace region.
|
||||
"""
|
||||
return '%s(Index=%d)' % (self.__class__.__name__, self.RegionIndex)
|
||||
# okay decompiling ./pylink/structs.pyc
|
||||
|
|
@ -1,45 +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: pylink/threads.py
|
||||
import threading
|
||||
|
||||
class ThreadReturn(threading.Thread):
|
||||
__doc__ = 'Implementation of a thread with a return value.\n\n See also:\n `StackOverflow <http://stackoverflow.com/questions/6893968/>`__.\n '
|
||||
|
||||
def __init__(self, daemon=False, *args, **kwargs):
|
||||
"""Initializes the thread.
|
||||
|
||||
Args:
|
||||
self (ThreadReturn): the ``ThreadReturn`` instance
|
||||
daemon (bool): if the thread should be spawned as a daemon
|
||||
args: optional list of arguments
|
||||
kwargs: optional key-word arguments
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
(super(ThreadReturn, self).__init__)(*args, **kwargs)
|
||||
self.daemon = daemon
|
||||
self._return = None
|
||||
|
||||
def run(self):
|
||||
"""Runs the thread.
|
||||
|
||||
Args:
|
||||
self (ThreadReturn): the ``ThreadReturn`` instance
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
target = getattr(self, '_Thread__target', getattr(self, '_target', None))
|
||||
args = getattr(self, '_Thread__args', getattr(self, '_args', None))
|
||||
kwargs = getattr(self, '_Thread__kwargs', getattr(self, '_kwargs', None))
|
||||
if target is not None:
|
||||
self._return = target(*args, **kwargs)
|
||||
|
||||
def join(self, *args, **kwargs):
|
||||
(super(ThreadReturn, self).join)(*args, **kwargs)
|
||||
return self._return
|
||||
# okay decompiling ./pylink/threads.pyc
|
||||
157
pylink/util.py
157
pylink/util.py
|
|
@ -1,157 +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: pylink/util.py
|
||||
from . import enums
|
||||
import platform, sys
|
||||
|
||||
def is_integer(val):
|
||||
"""Returns whether the given value is an integer.
|
||||
|
||||
Args:
|
||||
val (object): value to check
|
||||
|
||||
Returns:
|
||||
``True`` if the given value is an integer, otherwise ``False``.
|
||||
"""
|
||||
try:
|
||||
val += 1
|
||||
except TypeError:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
def is_natural(val):
|
||||
"""Returns whether the given value is a natrual number.
|
||||
|
||||
Args:
|
||||
val (object): value to check
|
||||
|
||||
Returns:
|
||||
``True`` if the given value is a natural number, otherwise ``False``.
|
||||
"""
|
||||
return is_integer(val) and val >= 0
|
||||
|
||||
|
||||
def is_os_64bit():
|
||||
"""Returns whether the current running platform is 64bit.
|
||||
|
||||
Returns:
|
||||
``True`` if the platform is 64bit, otherwise ``False``.
|
||||
"""
|
||||
return platform.machine().endswith('64')
|
||||
|
||||
|
||||
def noop(*args, **kwargs):
|
||||
"""No-op. Does nothing.
|
||||
|
||||
Args:
|
||||
args: list of arguments
|
||||
kwargs: keyword arguments dictionary
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
def unsecure_hook_dialog(title, msg, flags):
|
||||
"""No-op that ignores the dialog.
|
||||
|
||||
Args:
|
||||
title (str): title of the unsecure dialog
|
||||
msg (str): text of the unsecure dialog
|
||||
flags (int): flags specifying which values can be returned
|
||||
|
||||
Returns:
|
||||
``enums.JLinkFlags.DLG_BUTTON_NO``
|
||||
"""
|
||||
return enums.JLinkFlags.DLG_BUTTON_NO
|
||||
|
||||
|
||||
def progress_bar(iteration, total, prefix=None, suffix=None, decs=1, length=100):
|
||||
"""Creates a console progress bar.
|
||||
|
||||
This should be called in a loop to create a progress bar.
|
||||
|
||||
See `StackOverflow <http://stackoverflow.com/questions/3173320/>`__.
|
||||
|
||||
Args:
|
||||
iteration (int): current iteration
|
||||
total (int): total iterations
|
||||
prefix (str): prefix string
|
||||
suffix (str): suffix string
|
||||
decs (int): positive number of decimals in percent complete
|
||||
length (int): character length of the bar
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
|
||||
Note:
|
||||
This function assumes that nothing else is printed to the console in the
|
||||
interim.
|
||||
"""
|
||||
if prefix is None:
|
||||
prefix = ''
|
||||
if suffix is None:
|
||||
suffix = ''
|
||||
format_str = '{0:.' + str(decs) + 'f}'
|
||||
percents = format_str.format(100 * (iteration / float(total)))
|
||||
filled_length = int(round(length * iteration / float(total)))
|
||||
bar = '█' * filled_length + '-' * (length - filled_length)
|
||||
prefix, suffix = prefix.strip(), suffix.strip()
|
||||
sys.stdout.write('\r%s |%s| %s%s %s' % (prefix, bar, percents, '%', suffix))
|
||||
sys.stdout.flush()
|
||||
if iteration == total:
|
||||
sys.stdout.write('\n')
|
||||
sys.stdout.flush()
|
||||
|
||||
|
||||
def flash_progress_callback(action, progress_string, percentage):
|
||||
"""Callback that can be used with ``JLink.flash()``.
|
||||
|
||||
This callback generates a progress bar in the console to show the progress
|
||||
of each of the steps of the flash.
|
||||
|
||||
Args:
|
||||
action (str): the current action being invoked
|
||||
progress_string (str): the current step in the progress
|
||||
percentage (int): the percent to which the current step has been done
|
||||
|
||||
Returns:
|
||||
``None``
|
||||
|
||||
Note:
|
||||
This function ignores the compare action.
|
||||
"""
|
||||
if action.lower() != 'compare':
|
||||
return progress_bar((min(100, percentage)), 100, prefix=action)
|
||||
|
||||
|
||||
def calculate_parity(n):
|
||||
"""Calculates and returns the parity of a number.
|
||||
|
||||
The parity of a number is ``1`` if the number has an odd number of ones
|
||||
in its binary representation, otherwise ``0``.
|
||||
|
||||
Args:
|
||||
n (int): the number whose parity to calculate
|
||||
|
||||
Returns:
|
||||
``1`` if the number has an odd number of ones, otherwise ``0``.
|
||||
|
||||
Raises:
|
||||
ValueError: if ``n`` is less than ``0``.
|
||||
"""
|
||||
if not is_natural(n):
|
||||
raise ValueError('Expected n to be a positive integer.')
|
||||
y = 0
|
||||
n = abs(n)
|
||||
while n:
|
||||
y += n & 1
|
||||
n = n >> 1
|
||||
|
||||
return y & 1
|
||||
# okay decompiling ./pylink/util.pyc
|
||||
|
|
@ -1 +1,8 @@
|
|||
psutil==5.9.5
|
||||
six==1.16.0
|
||||
pyserial==3.5
|
||||
pylink-square==0.5.0
|
||||
pycryptodome==3.9.8
|
||||
pycklink==0.1.1
|
||||
ecdsa==0.18.0
|
||||
pycryptoplus==0.0.1
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user