def parse_svd(svds_directory, family, cpu):
"""
Parse the SVD files (if available) and return the peripherals.
The data is returned from cache if available, to speedup the parsing
process.
"""
if not svds_directory:
return []
svd_file = os.path.join(svds_directory, family.upper(),
"%s.svd" % (cpu.upper()))
cache_key = hashlib.md5(svd_file.encode("ascii")).hexdigest()
cache_file = os.path.join("cache", cache_key)
if not os.path.isfile(svd_file):
return []
if not os.path.isfile(cache_file):
device = SVDParser.for_xml_file(svd_file).get_device()
with open(cache_file, "w") as fp:
json.dump(
[peripheral.to_dict() for peripheral in device.peripherals],
fp)
with open(cache_file, "r") as fp:
return json.load(fp)
def core_data_from_svd(self, core_svd_datapath, segment_size, core):
if core == None:
for f in sorted(glob.glob(os.path.join(core_svd_datapath,
'*.svd'))):
c = f.split(os.path.sep)[-1][:-4]
if (c.lower().find("cortex-") == 0):
c = c[7:]
if (c.lower().find("CM") == 0):
c = c[1:]
print(f, "\t", c)
self.data_top_hash["cores"][c] = {}
self.data_top_hash["cores"][c]["file"] = f
self.data_top_hash["cores"][c]["dirty"] = True
else:
f = os.path.join(core_svd_datapath, core) + ".svd"
if (core.lower().find("cortex-") > -1):
core = core[7:]
self.data_top_hash["cores"][core] = {}
self.data_top_hash["cores"][core]["file"] = f
self.data_top_hash["cores"][core]["dirty"] = True
for c in self.data_top_hash["cores"].keys():
#print("---------->",core_svd_datapath ,c + '.svd')
self.parse_chip_svd(
self.data_top_hash["cores"][c],
SVDParser.for_xml_file(self.data_top_hash["cores"][c]["file"]))
def monitor(self, arg):
if not self.svd_device:
try:
from cmsis_svd.parser import SVDParser
if os.path.isfile(SvdRegisters.FILE):
with open(SvdRegisters.FILE, 'r') as f:
lines = [l.strip() for l in f.readlines()]
parser = SVDParser.for_xml_file(lines[0])
self.svd_device = parser.get_device()
except:
raise Exception(
"Cannot open or parse SVD file. Check 'cmsis_svd' library installed"
)
if self.svd_device and arg:
args = arg.split()
name = args[0]
if name not in self.table:
r = self.find_register(name)
if r:
r.alias = args[1] if len(args) > 1 else "_"
with open(SvdRegisters.FILE, "a") as f:
f.write(str(r) + "\n")
else:
raise Exception("Register {} not found".format(name))
else:
raise Exception("Register {} already exists".format(name))
def parse_cores(self, core_svd_datapath):
self.core_files = sorted(
glob.glob(os.path.join(core_svd_datapath, '*.svd')))
self.cores = {}
pp = pprint.PrettyPrinter(indent=4)
for c in self.core_files:
self.parse_core(c, SVDParser.for_xml_file(c))
def main(unused_argv):
del unused_argv
svd_path = os.path.abspath(FLAGS.svd_path)
if FLAGS.svd_yaml_patch:
patch_path = os.path.abspath(FLAGS.svd_yaml_patch)
with open(patch_path, "r") as f:
root = yaml.safe_load(f)
root["_path"] = patch_path
svd = ET.parse(svd_path)
svdtools.patch.yaml_includes(root)
svdtools.patch.process_device(svd, root)
_, svd_path = tempfile.mkstemp()
svd.write(svd_path)
parser = SVDParser.for_xml_file(svd_path)
peripheral = None
for p in parser.get_device().peripherals:
if p.name.lower() == FLAGS.peripheral.lower():
peripheral = p
break
formatter = Formatter(FLAGS.output_path)
Biffile(formatter).write_peripheral(peripheral)
formatter.finish()
if FLAGS.verify:
verify(FLAGS.output_path, peripheral)
def verify_cmsis_output(self, filename):
filepath = 'test/sampleData/cmsis-svd/' + filename + '.svd'
print('Parsing ' + filepath)
parser = SVDParser.for_xml_file(filepath)
self.assertEqual(
filename,
parser.get_device().peripherals[0].name,
msg="{0} is not the provided name in the CMSIS SVD file")
def on_cmbSVD_currentIndexChanged(self, path):
if not os.path.exists(path): return
self.device = SVDParser.for_xml_file(path).get_device()
self.cmbPeriph.clear()
self.cmbPeriph.addItems(
sorted([periph.name for periph in self.device.peripherals]))
def load(self):
if not isCmsisSvdAvailable:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
def load(self):
if not isCmsisSvdAvailable:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
def LPC43xxTarget(device):
""" Factory function that creates a low-level LPC43xx target. """
from .. import find_greatfet_asset
svd_file = find_greatfet_asset('LPC43xx_43Sxx.svd')
svd = SVDParser.for_xml_file(svd_file)
return VirtualLPC43xxTarget.from_svd(svd.get_device(), device)
def load(self):
if not IS_CMSIS_SVD_AVAILABLE:
return
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(
self.vendor, self.filename).get_device()
def invoke(self, args, from_tty):
args = gdb.string_to_argv(args)
argc = len(args)
if argc == 1:
gdb.write("Loading SVD file {}...\n".format(args[0]))
parser = SVDParser.for_xml_file(svd_file)
elif argc == 2:
gdb.write("Loading SVD file {}/{}...\n".format(args[0], args[1]))
parser = SVDParser.for_packaged_svd(vendor, device)
self.dont_repeat()
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) != 1:
raise gdb.GdbError("Usage: svd_load_file <filename.svd>")
path = args[0]
try:
parser = SVDParser.for_xml_file(path)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}".format(path))
def main():
parser = argparse.ArgumentParser(description = 'Generate C++ project from CMSIS SVD XML file')
parser.add_argument('input', metavar='inputsvd', nargs=1, help='Input SVD file to generate BSP from')
parser.add_argument('project', metavar='project', nargs=1, help='Path to output project')
args = parser.parse_args()
if args.input:
file = args.input[0]
if args.project:
if os.path.exists(args.project[0]):
print("Path exists, exiting!")
exit(-1)
else:
os.mkdir(args.project[0])
os.mkdir(os.path.join(args.project[0], "inc"))
os.mkdir(os.path.join(args.project[0], "src"))
name = getProjName(args.project[0])
parser = SVDParser.for_xml_file(file)
dev = parser.get_device()
outfile = dev.name+".h"
f=open(os.path.join(args.project[0], "inc", outfile), "w+")
f.write("#pragma once\r\n")
f.write("#include <cstdint>\r\n")
f.write("#include <reg.h>\r\n")
f.write("\r\nnamespace %s {\r\n" % dev.name)
DeviceStartup(dev, args.project[0])
for peripheral in dev.peripherals:
p = PeripheralNamespace(peripheral)
p.dump(f)
f.write("};\r\n")
f.close()
shutil.copyfile("reg.h.template", os.path.join(os.path.join(args.project[0], "inc"),'reg.h'))
shutil.copyfile("load_target.sh.template", os.path.join(args.project[0],'load_target.sh'))
shutil.copyfile("target.cfg.template", os.path.join(args.project[0],'target.cfg'))
shutil.copyfile("linker.template", os.path.join(args.project[0],'linker.ld'))
subst_target('runme.gdb.template', os.path.join(args.project[0],'runme.gdb'), getProjName(args.project[0]))
subst_target('Makefile.template', os.path.join(args.project[0],'Makefile'), getProjName(args.project[0]))
targetMain = open(os.path.join(args.project[0],getProjName(args.project[0])+".cpp"), "w+")
targetMain.write("int main(void)\r\n{\r\n while(1);\r\n}\r\n");
targetMain.close()
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) != 1:
raise gdb.GdbError("Usage: svd_load_file <filename.svd>")
path = args[0]
try:
parser = SVDParser.for_xml_file(path)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}".format(path))
for peripheral in _svd_printer.device.peripherals:
print("%s @ 0x%08x" %
(peripheral.name, peripheral.base_address))
def __init__(self, path):
parser = [periph for periph in SVDParser.for_xml_file(path).get_device().peripherals]
# Read peripherals and their registers
self.device = []
for periph in parser:
self.device += [{"type": "periph",
"name": periph.name,
"description": periph.description,
"base_address": periph.base_address,
"group_name": periph.group_name,
"regs": periph.derived_from}] # regs value will be replaced with regs list
if (self.device[-1]["regs"] is not None):
self.device[-1]["regs"] = next(periph for periph in self.device if periph["name"] == self.device[-1]["regs"])["regs"].copy()
else:
self.device[-1]["regs"] = []
for reg in periph.registers:
self.device[-1]["regs"] += [{"type": "reg",
"name": reg.name,
"description": reg.description,
"address_offset": reg.address_offset,
"fields": []}]
for field in reg.fields:
self.device[-1]["regs"][-1]["fields"] += [{"type": "field",
"name": field.name,
"description": field.description,
"address_offset": reg.address_offset,
"lsb": field.bit_offset,
"msb": field.bit_offset + field.bit_width - 1,
"access": field.access,
"enums": None}]
if field.enumerated_values:
self.device[-1]["regs"][-1]["fields"][-1]["enums"] = []
for enum in field.enumerated_values:
self.device[-1]["regs"][-1]["fields"][-1]["enums"] += [{"name": enum.name,
"description": enum.description,
"value": enum.value}]
self.device = sorted(self.device, key=itemgetter('base_address'))
def invoke(self, arg, from_tty):
try:
argv = gdb.string_to_argv(arg)
if len(argv) != 1:
raise Exception("Invalide parameter")
pathfile = argv[0]
gdb.write("Svd Loading {} ".format(pathfile))
parser = SVDParser.for_xml_file(pathfile)
device = parser.get_device()
peripherals = dict((peripheral.name, peripheral)
for peripheral in device.peripherals)
GdbSvdGetCmd(device, peripherals)
GdbSvdSetCmd(device, peripherals)
GdbSvdInfoCmd(device, peripherals)
except Exception as inst:
gdb.write("\n{}\n".format(inst))
gdb.execute("help svd")
except IOError:
gdb.write("\nFailed to load SVD file\n")
else:
gdb.write("Done\n")
def verify_svd_validity():
parser = SVDParser.for_xml_file(svd_path)
device = parser.get_device()
assert device is not None
print('Usage: .!r2svd [mcu] [svd]')
sys.exit(1)
sys.exit(0)
def filter_name(n):
n = n.replace(' ', '')
n = n.replace('/', '')
n = n.replace('(', '')
n = n.replace(')', '')
return n
svdfile = sys.argv[1]
if os.path.isfile(svdfile):
parser = SVDParser.for_xml_file(svdfile)
else:
mcu = sys.argv[1] # Freescale
svd = sys.argv[2] # MK20D7.svd
parser = SVDParser.for_packaged_svd(mcu, svd)
svd_dict = parser.get_device().to_dict()
for p in svd_dict['peripherals']:
addr = p['base_address']
try:
size = p['address_block']['size'] / 8
except:
size = 4
name = filter_name(p['name'])
print("\"CC %s @ 0x%x\"" % (p['description'], addr))
print("f %s %d 0x%x" % (name, size, addr))
if width < 8:
print(f"{register.name}::{name}, w:{width}, off:{offset}")
if width == 1:
v = 1 << offset
code += f"{name} = {v:#010x},"
else:
values = [i for i in range(1, 2**width)]
pprint.pprint(values)
for val in values:
v = val << offset
code += f"{name}_{val:0{width}b} = {v:#010x},"
code += "};\n"
return code
parser = SVDParser.for_xml_file("STM32F412.svd")
device = parser.get_device()
peripherals = device.peripherals
for periph in peripherals:
print(periph.name)
outfile = open(f"./out/{periph.name}.h", "a")
h_file_template = open("header_periph_template.txt", "r").read()
template_data = {
"name": periph.name,
"size": get_periph_size(periph),
"register_definitions": generate_register_definition(periph),
"enum_definitions": generate_enum_definitions(periph),
}
a = Template(h_file_template).substitute(template_data)
outfile.write(a)
def load(self):
if self.is_local:
self.device = SVDParser.for_xml_file(self.filename).get_device()
else:
self.device = SVDParser.for_packaged_svd(self.vendor, self.filename).get_device()
def run():
parser = argparse.ArgumentParser(description='CMSIS Code Generator')
parser.add_argument('-i',
'--input',
metavar='FILE',
help="CMSIS SVD file to parse",
type=str,
dest='svd_file',
required=True)
parser.add_argument('-t',
'--templates',
metavar='FILE',
help="Jinja Template Directory",
type=str,
dest='template_dir')
parser.add_argument('-o',
'--output',
metavar='PATH',
help="Output Directory",
type=str,
default='./output',
dest='output_dir')
parser.add_argument('--force-bool',
help="Force one-bit fields to bool type",
action='store_true')
#argv = parser.parse_args(['-i', 'apollo3.svd', '-o', './test_output'])
argv = parser.parse_args()
# use default template directory if none is provided
if not argv.template_dir:
argv.template_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'cpp17_templates')
device = SVDParser.for_xml_file(argv.svd_file).get_device()
# create output directory if it doesn't exist
Path(argv.output_dir).mkdir(exist_ok=True, parents=True)
# set jinja search path to the template directory
templateLoader = jinja2.FileSystemLoader(searchpath=argv.template_dir)
templateEnv = jinja2.Environment(loader=templateLoader)
# create device file if template exists
if os.path.exists(os.path.join(argv.template_dir, 'device.hpp.in')):
with open(os.path.join(argv.output_dir, 'device.hpp'), 'w') as ofile:
t = templateEnv.get_template('device.hpp.in')
code = t.render(device=device)
ofile.write(code)
ofile.close()
# create peripheral headers if a tempalte exists
if os.path.exists(os.path.join(argv.template_dir, 'peripheral.hpp.in')):
t = templateEnv.get_template('peripheral.hpp.in')
for peripheral in device.peripherals:
ofile_name = f"{peripheral.name}.hpp"
with open(os.path.join(argv.output_dir, ofile_name), 'w') as ofile:
device_meta = {
'name': device.name,
'vendor': device.vendor,
'version': device.version
}
code = t.render(peripheral=peripheral,
device_meta=device_meta,
force_bools=True)
ofile.write(code)
ofile.close()
return 0
def parse_path(self, path):
self.__fill_device([periph for periph in SVDParser.for_xml_file(path).get_device().peripherals])
from cmsis_svd.parser import SVDParser
import argparse
import sys
import os
import csv
parser = argparse.ArgumentParser(
description="Generate a chipfinder signature from an SVD file.")
parser.add_argument("svd_file", help="SVD file to load")
parser.add_argument("signature_file", help="Signature file to write")
args = parser.parse_args()
print(args)
print("Loading SVD file...")
parser = SVDParser.for_xml_file(str(args.svd_file))
print("\tDone!")
peripherals = parser.get_device().peripherals
rows = 0
print("Writing signature file...")
with open(args.signature_file, "w") as csvfile:
w = csv.writer(csvfile,
delimiter=',',
quotechar='"',
quoting=csv.QUOTE_MINIMAL)
for peripheral in peripherals:
try:
for register in peripheral.registers:
w.writerow([peripheral.base_address + register.address_offset])
def verify_svd_validity():
parser = SVDParser.for_xml_file(svd_path)
device = parser.get_device()
assert device is not None
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('input_file', help = 'input SVD file')
arg_parser.add_argument('-p', metavar = 'PERIPHERAL', help = 'generate code only for specified peripheral')
arg_parser.add_argument('-o', help = 'overwrite existing enumerations header files', action = 'store_true')
args = arg_parser.parse_args()
parser = SVDParser.for_xml_file(args.input_file)
device = process_device(parser.get_device())
device_name = camel_case(device.name)
if (not os.path.isdir(device_name)):
os.mkdir(device_name)
if (not os.path.isdir('{}\FieldValues'.format(device_name))):
os.mkdir('{}\FieldValues'.format(device_name))
if (args.p != None):
peripherals = [x for x in device.peripherals if x.name.lower() == args.p.lower()]
else:
peripherals = device.peripherals
for peripheral in peripherals:
peripheral_name = peripheral.name.lower().replace('_', '')
reg_file_name = '{}registers.hpp'.format(peripheral_name)
enum_file_name = '{}fieldvalues.hpp'.format(peripheral_name)
enum_file_full_name = '{}\FieldValues\{}'.format(device_name, enum_file_name)
with open('{}\{}'.format(device_name, reg_file_name), 'w') as registers_file:
if (peripheral.description != None):
per_description = '{}. This header file is auto-generated for {} device.'.format(
peripheral.description.rstrip('. '),
device.name)
else:
per_description = 'This header file is auto-generated for {} device.'.format(device.name)
registers_file.write(create_file_description(reg_file_name, per_description))
reg_guard = '{}REGISTERS_HPP'.format(peripheral_name.upper())
registers_file.write('\n')
registers_file.write('#if !defined({})\n'.format(reg_guard))
registers_file.write('#define {}\n'.format(reg_guard))
registers_file.write('\n')
registers_file.write('#include "{}" //for Bits Fields defs \n'.format(enum_file_name))
registers_file.write('#include "registerbase.hpp" //for RegisterBase\n')
registers_file.write('#include "register.hpp" //for Register\n')
registers_file.write('#include "accessmode.hpp" //for ReadMode, WriteMode, ReadWriteMode \n')
registers_file.write('\n')
if((args.o) or (not os.path.isfile(enum_file_full_name))):
with open(enum_file_full_name, 'w') as enumerations_file:
enumerations_file.write(create_file_description(
enum_file_name,
'Enumerations related with {} peripheral. This header file is auto-generated for {} device.'.format(
peripheral.name,
device.name)))
enum_guard = '{}ENUMS_HPP'.format(peripheral_name.upper())
enumerations_file.write('\n')
enumerations_file.write('#if !defined({})\n'.format(enum_guard))
enumerations_file.write('#define {}\n'.format(enum_guard))
enumerations_file.write('\n')
enumerations_file.write('#include "fieldvalue.hpp" //for FieldValues \n')
enumerations_file.write('\n')
generate_peripheral(peripheral, registers_file, enumerations_file)
enumerations_file.write('#endif //#if !defined({})\n'.format(enum_guard))
else:
generate_peripheral(peripheral, registers_file)
registers_file.write('#endif //#if !defined({})\n'.format(reg_guard))
def setUp(self):
svd = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.xml")
self.parser = SVDParser.for_xml_file(svd)
return reduce_memory_regions(regions)
return regions
def calculate_peripheral_size(peripheral, default_register_size):
size = 0
for register in peripheral.registers:
register_size = default_register_size if not register._size else register._size
size = max(size, register.address_offset + register_size / 8)
return size
svd_file = askFile("Choose SVD file", "Load SVD File")
print("Loading SVD file...")
parser = SVDParser.for_xml_file(str(svd_file))
print("\tDone!")
# CM0, CM4, etc
cpu_type = parser.get_device().cpu.name
# little/big
cpu_endian = parser.get_device().cpu.endian
default_register_size = parser.get_device().size
# Not all SVDs contain these fields
#if cpu_type and not cpu_type.startswith("CM"):
# print("Currently only Cortex-M CPUs are supported.")
# print("Supplied CPU type was: " + cpu_type)
# sys.exit(1)
#!/usr/bin/env python
from cmsis_svd.parser import SVDParser
v850_6bit_msb_gone = lambda addr: hex(addr & 0x3fffffff)
parser = SVDParser.for_xml_file("v850-datasheet2svd.svd")
for peripheral in parser.get_device().peripherals:
# print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))
print("%s\t@\t%s" %
(peripheral.name, v850_6bit_msb_gone(peripheral.base_address)))
# print(dir(parser._parse_registers(peripheral)))
# for register in parser.get_device().registers:
# print(register.name)
def parse_svd(svd_file):
svd = SVDParser.for_xml_file(svd_file)
xml = minidom.parse(svd_file)
return parse_device(svd.get_device(), xml)
def setUpClass(cls):
svd = os.path.join(DATA_DIR, "Nordic", "nrf51.svd")
cls.parser = SVDParser.for_xml_file(svd)
cls.device = cls.parser.get_device()
def setUpClass(cls):
svd = os.path.join(DATA_DIR, "Nordic", "nrf51.svd")
cls.parser = SVDParser.for_xml_file(svd)
cls.device = cls.parser.get_device()
def setUpClass(cls):
cls.svd_path = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.svd")
cls.json_path = os.path.join(THIS_DIR, "MKL25Z4.json")
cls.parser = SVDParser.for_xml_file(cls.svd_path)
cls.device = cls.parser.get_device()
def setUpClass(cls):
cls.svd_path = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.svd")
cls.json_path = os.path.join(THIS_DIR, "MKL25Z4.json")
cls.parser = SVDParser.for_xml_file(cls.svd_path)
cls.device = cls.parser.get_device()
def setUp(self):
svd = os.path.join(DATA_DIR, "Freescale", "MKL25Z4.svd")
self.parser = SVDParser.for_xml_file(svd)