def data_from_svd(self, cmsis_svd_datapath, segment_size, vendor, chip):
if vendor == None:
self.vendors = os.listdir(cmsis_svd_datapath)
for v in self.vendors:
self.data_top_hash["vendors"][v] = {}
for f in glob.glob(os.path.join(cmsis_svd_datapath, v,
'*.svd')):
c = f.split(os.path.sep)[-1][:-4]
self.data_top_hash["vendors"][v][c] = {}
self.data_top_hash["vendors"][v][c]["file"] = f
self.data_top_hash["vendors"][v][c]["dirty"] = True
else:
self.vendors = [vendor]
self.data_top_hash["vendors"][vendor] = {}
if (chip):
self.data_top_hash["vendors"][vendor][chip] = {}
self.data_top_hash["vendors"][vendor][chip][
"file"] = os.path.join(cmsis_svd_datapath, vendor,
chip + '.svd')
self.data_top_hash["vendors"][vendor][chip]["dirty"] = True
else:
for f in glob.glob(
os.path.join(cmsis_svd_datapath, vendor, '*.svd')):
c = f.split(os.path.sep)[-1][:-4]
self.data_top_hash["vendors"][vendor][c] = {}
self.data_top_hash["vendors"][vendor][c]["file"] = f
self.data_top_hash["vendors"][vendor][c]["dirty"] = True
#print( self.data_top_hash)
for v in self.data_top_hash["vendors"].keys():
for c in sorted(self.data_top_hash["vendors"][v].keys()):
print(v, c)
self.parse_chip_svd(self.data_top_hash["vendors"][v][c],
SVDParser.for_packaged_svd(v, c + '.svd'))
def invoke(self, arg, from_tty):
args = gdb.string_to_argv(arg)
if len(args) >= 1:
if args[0] not in self.vendors:
raise gdb.GdbError("Invalid vendor name")
return
vendor_name = args[0]
vendor_filenames = self.vendors[vendor_name]
if len(args) == 1:
raise gdb.GdbError(
"Usage: svd_load <vendor-name> <filename.svd>")
elif len(args) >= 2:
filename = args[1]
try:
parser = SVDParser.for_packaged_svd(vendor_name, filename)
_svd_printer.set_device(parser.get_device())
except IOError:
raise gdb.GdbError("Failed to load SVD file")
else:
print("Loaded {}/{}".format(vendor_name, filename))
for peripheral in _svd_printer.device.peripherals:
print("%s @ 0x%08x" %
(peripheral.name, peripheral.base_address))
else:
raise gdb.GdbError("Usage: svd_load <vendor-name> <filename.svd>")
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_svd(self, vendor, file):
parser = SVDParser.for_packaged_svd(vendor, file)
for peripheral in parser.get_device().peripherals:
p_dict = peripheral.to_dict()
base_addr = p_dict['base_address']
size = int(p_dict['address_block']['size']) - 1 #hackhack
name = peripheral.name
self.add_memory_range(base_addr, size)
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 get_parser(mcu, svd):
try:
if mcu:
return SVDParser.for_packaged_svd(mcu[0], "{}.svd".format(mcu[1]))
return SVDParser(ET.ElementTree(ET.fromstring(svd.read())))
except IOError:
print("No SVD file found")
sys.exit()
def get_parser(mcu, svd):
try:
if mcu:
return SVDParser.for_packaged_svd(mcu[0], "{}.svd".format(mcu[1]))
return SVDParser(ET.ElementTree(ET.fromstring(svd.read())))
except IOError:
print("No SVD file found")
sys.exit()
def main():
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
dump_registers(peripherals,
open("src/chips/nrf51822/peripheral_registers.rs", "w"))
def main():
parser = SVDParser.for_packaged_svd('STMicro', 'STM32F0xx.svd')
address2peripheral = {}
for peripheral in parser.get_device().peripherals:
address2peripheral[peripheral.base_address] = peripheral
for _, peripheral in sorted(address2peripheral.items()):
print(f'{peripheral.name: <16} @ 0x{peripheral.base_address:08x}')
svd_dict = parser.get_device().to_dict()
print(json.dumps(svd_dict, sort_keys=True, indent=4))
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 main():
from jinja2 import Environment, FileSystemLoader
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
env = Environment(loader=FileSystemLoader('src/chips/nrf51822'))
template = env.get_template('peripheral_registers.rs.jinja')
template.stream(program=PROGRAM, peripherals=peripherals).dump(
'src/chips/nrf51822/peripheral_registers.rs')
def main():
from jinja2 import Environment, FileSystemLoader
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
#dump_json(parser)
interrupts = get_peripheral_interrupts(parser)
dump_macros(interrupts,
open("src/chips/nrf51822/src/peripheral_interrupts.h", "w"))
peripherals = get_peripheral_registers(parser, ["GPIO"])
env = Environment(loader=FileSystemLoader('src/chips/nrf51822/src'))
template = env.get_template('peripheral_registers.rs.jinja')
template.stream(program=PROGRAM, peripherals=peripherals).dump(
'src/chips/nrf51822/src/peripheral_registers.rs')
def parseFile(company, file):
print("Parsing %s,%s " % (company, file))
parser = SVDParser.for_packaged_svd(company, file + ".svd", 1)
extention = []
jsonPath = posixpath.join(posixpath.dirname(posixpath.abspath(__file__)),
"Extention", company, file + ".json")
#print(jsonPath)
device = parser.get_device()
if posixpath.isfile(jsonPath):
extFile = open(jsonPath, "r", encoding='utf-8')
extention = json.load(extFile)
subdir = Ft.formatCpuName(Ft.getKey(extention, ["device", "cpu", "name"]),
device)
chipDir = posixpath.join('..', '..', 'Lib', 'Chip')
subdir = posixpath.join(chipDir, subdir)
if not posixpath.exists(subdir):
os.makedirs(subdir)
subdir = posixpath.join(subdir, company)
if not posixpath.exists(subdir):
os.makedirs(subdir)
subdir = posixpath.join(subdir, file)
if not posixpath.exists(subdir):
os.makedirs(subdir)
chipText = "#pragma once \n"
chipText += "#include <cstdint>\n"
incDir = subdir[10:]
if Ft.getKey(extention, ["kvasir", "io"]):
parseIo(extention, device, subdir)
chipText += "#include <%s>\n" % (posixpath.join(incDir, "Io.hpp"))
for peripheral in device.peripherals:
if peripheral.name is not None:
chipText += "#include <%s>\n" % (posixpath.join(
incDir, peripheral.name + ".hpp"))
out = "#pragma once \n#include <Register/Utility.hpp>\n"
out += "namespace Kvasir {\n"
out += parsePeripheral(
peripheral, Ft.getKey(extention, ['.' + peripheral.name]))
out += "}\n"
outFile = open(posixpath.join(subdir, peripheral.name + ".hpp"),
'w',
encoding='utf-8')
outFile.write(out)
else:
print("error no name in %s" % (file))
outFile = open(posixpath.join(chipDir, file + ".hpp"),
'w',
encoding='utf-8')
outFile.write(chipText)
def main():
parser = SVDParser.for_packaged_svd(sys.argv[1], sys.argv[2] + '.svd')
device = parser.get_device()
zig_fmt = subprocess.Popen(('zig', 'fmt', '--stdin'),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
encoding='utf8')
generator = MMIOFileGenerator(zig_fmt.stdin)
generator.generate_file(device)
zig_fmt.stdin.flush()
zig_fmt.stdin.close()
print(zig_fmt.stdout.read())
def main(mcu, mcu_peripheral=None):
"""Given a chip and peripheral, prints the registers.
"""
parser = SVDParser.for_packaged_svd(*MCU2VENDOR_FILE[mcu])
address2peripheral = {}
for peripheral in parser.get_device().peripherals:
address2peripheral[peripheral.base_address] = peripheral
for _, peripheral in sorted(address2peripheral.items()):
print(
f'{peripheral.name: <16} @ 0x{peripheral.base_address:08x} ({peripheral.address_block.size: >4})'
)
if mcu_peripheral:
for peripheral in parser.get_device().peripherals:
if peripheral.name == mcu_peripheral or mcu_peripheral == ALL:
show_peripheral(peripheral)
def parseFile(company,file):
print("Parsing %s,%s " % (company,file))
parser = SVDParser.for_packaged_svd(company, file + ".svd",1,1)
extention = []
jsonPath = os.path.join(os.path.dirname(os.path.abspath(__file__)),"Extention",company,file+".json")
#print(jsonPath)
device = parser.get_device()
if os.path.isfile(jsonPath):
extFile = open(jsonPath,"r",encoding='utf-8')
extention = json.load(extFile)
subdir = Ft.formatCpuName(Ft.getKey(extention,["device","cpu","name"]),device)
chipDir = os.path.join('..','..','Lib','Chip')
subdir = os.path.join(chipDir, subdir)
if not os.path.exists(subdir):
os.makedirs(subdir)
subdir = os.path.join(subdir,company)
if not os.path.exists(subdir):
os.makedirs(subdir)
subdir = os.path.join(subdir,file)
if not os.path.exists(subdir):
os.makedirs(subdir)
chipText = "#pragma once \n"
incDir = subdir[10:]
if Ft.getKey(extention,["kvasir","io"]):
parseIo(extention,device,subdir)
chipText += "#include \"%s\"\n" % (os.path.join(incDir,"Io.hpp"))
for peripheral in device.peripherals:
if peripheral.name is not None:
chipText += "#include \"%s\"\n" % (os.path.join(incDir,peripheral.name+".hpp"))
out = "#pragma once \n#include \"Register/Utility.hpp\"\n"
out += "namespace Kvasir {\n"
out += parsePeripheral(peripheral,Ft.getKey(extention,['.'+peripheral.name]))
out += "}\n"
outFile = open(os.path.join(subdir,peripheral.name+".hpp"), 'w',encoding='utf-8')
outFile.write(out)
else:
print("error no name in %s" % (file))
outFile = open(os.path.join(chipDir,file + ".hpp"), 'w',encoding='utf-8')
outFile.write(chipText)
def test_packaged_xml(self):
parser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.svd')
device = parser.get_device()
self.assertTrue(len(device.peripherals) > 0)
def test_derived_from_registers(self):
parser = SVDParser.for_packaged_svd('ARM_SAMPLE', 'ARM_Sample.svd')
regs = {p.name: p.registers for p in parser.get_device().peripherals}
self.assertEqual(len(regs["TIMER0"]), len(regs["TIMER1"]))
self.assertEqual(len(regs["TIMER0"]), len(regs["TIMER2"]))
self.assertEqual(len(regs["TIMER1"]), len(regs["TIMER2"]))
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()
#
# Copyright 2015 Paul Osborne <*****@*****.**>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.xml')
for peripheral in parser.get_device().peripherals:
print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))
def banner(x):
comment('==== {:=<55}'.format("%s " % x))
def caption(x):
print()
comment('---- {:-<55}'.format("%s " % x))
def comment(x):
print(comment_str(x))
# ------------------------------------
parser = SVDParser.for_packaged_svd('STMicro', svd_name)
device = parser.get_device()
print()
banner('%s PERIPHERALS' % device.name)
comment('')
comment('CTU Prague, FEL, Department of Measurement')
comment('')
comment('-' * 60)
comment('')
comment('Generated from "%s"' % svd_name)
comment('')
comment('SVD parsing library (c) Paul Osborne, 2015-2016')
comment(' https://github.com/posborne/cmsis-svd')
comment('ASM building script (c) Ondrej Hruska, 2016')
comment('')
def load_svd_for_mcu(mcu):
vendor, filename = find_for_mcu(mcu)
if (vendor is None) or (filename is None):
return None
return SVDParser.for_packaged_svd(vendor, filename).get_device()
if (svd_file != None):
parser = SVDParser.for_xml_file(svd_file)
elif (selected_device != None):
device = None
dev = selected_device.lower().replace(".svd", "")
for v in pkg_resources.resource_listdir("cmsis_svd", "data"):
for d in pkg_resources.resource_listdir("cmsis_svd", "data/%s" % (v)):
if (dev == d.lower().replace(".svd", "")):
device = d
vendor = v
if (device == None):
print("Could not find %s in cmsis_svd data." % (selected_device))
exit(1)
parser = SVDParser.for_packaged_svd(vendor, device)
else:
print("No device selected.")
usage()
exit(1)
device_name = parser.get_device().name
if (output):
try:
os.mkdir(device_name)
except:
pass
if (selected_peripheral == None):
memorymap_str = "#pragma once \n\n"
#
# Copyright 2015 Paul Osborne <*****@*****.**>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.svd')
for peripheral in parser.get_device().peripherals:
print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))
# pip install -U cmsis-svd
# python3 nrf51.py >> nrf51.flags.r2
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('Nordic', 'nrf51.svd')
for peripheral in parser.get_device().peripherals:
print("f %s = 0x%08x" % (peripheral.name, peripheral.base_address))
for register in peripheral.registers:
print("f %s.%s = 0x%08x" %
(peripheral.name, register.name,
peripheral.base_address + register.address_offset))
print(comment_str(x))
def banner(x):
comment('==== {:=<55}'.format("%s " % x))
def caption(x):
print()
comment('---- {:-<55}'.format("%s " % x))
def comment(x):
print(comment_str(x))
# ------------------------------------
parser = SVDParser.for_packaged_svd('STMicro', svd_name)
device = parser.get_device()
print()
banner('%s PERIPHERALS' % device.name)
comment('')
comment('CTU Prague, FEL, Department of Measurement')
comment('')
comment('-' * 60)
comment('')
comment('Generated from "%s"' % svd_name)
comment('')
comment('SVD parsing library (c) Paul Osborne, 2015-2016')
comment(' https://github.com/posborne/cmsis-svd')
comment('ASM building script (c) Ondrej Hruska, 2016')
comment('')
print('\n'.join(vendors))
elif argc == 2:
svds = pkg_resources.resource_listdir("cmsis_svd",
"data/%s" % (sys.argv[1]))
print('\n'.join(svds))
else:
raise Exception('')
except:
print('Usage: .!r2svd [mcu] [svd]')
sys.exit(1)
sys.exit(0)
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']
size = p['address_block']['size'] / 8
print("CC %s @ 0x%x" % (p['description'], addr))
print("f %s %d 0x%x" % (p['name'], size, addr))
s = ""
for r in p['registers']:
offs = int(r['address_offset'])
at = int(addr) + math.floor(offs / 8)
bt = (offs % 8)
s += " " + r['name']
if at != addr:
print("f %s.%s %d 0x%x" % (p['name'], r['name'], size, at))
# print(" 0x%x %d %s"%(at, bt, r['name']))
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Simple script for ida loadProcConfig configuration file generator
#
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('STMicro', 'STM32F105xx.svd')
allregs = []
blocksize = 0x400 - 1
fmt = "{:28}{:28}{:12}"
for peripheral in parser.get_device().peripherals:
col1 = "area DATA " + peripheral.name
base = peripheral.base_address
if peripheral._address_block == None:
limit= base + blocksize
else:
limit= base + peripheral._address_block.size - 1
blocksize = peripheral._address_block.size - 1
col2 = "0x{0:08X}:0x{1:08X}".format(base, limit)
col3 = peripheral.name
import json
from cmsis_svd.parser import SVDParser
parser = SVDParser.for_packaged_svd('STMicro', 'STM32F042x.svd')
svd_dict = parser.get_device().to_dict()
print(json.dumps(svd_dict, sort_keys=True,
indent=4, separators=(',', ': ')))
