mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
svd2repl: add program to generate a repl file
Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
parent
b06e8d2a81
commit
74abf35a08
7 changed files with 765 additions and 1 deletions
12
Cargo.lock
generated
12
Cargo.lock
generated
|
|
@ -1460,6 +1460,16 @@ dependencies = [
|
|||
"xous-names",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "svd2repl"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"clap",
|
||||
"convert_case",
|
||||
"quick-xml",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "svd2utra"
|
||||
version = "0.1.0"
|
||||
|
|
@ -1874,7 +1884,7 @@ checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
|
|||
|
||||
[[package]]
|
||||
name = "xous"
|
||||
version = "0.8.0"
|
||||
version = "0.8.1"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"compiler_builtins",
|
||||
|
|
|
|||
|
|
@ -46,6 +46,7 @@ members = [
|
|||
"services/rkyv-test-server",
|
||||
"services/rkyv-test-client",
|
||||
"services/shellchat",
|
||||
"svd2repl",
|
||||
"svd2utra",
|
||||
"xtask",
|
||||
"imports/blitstr-ref",
|
||||
|
|
|
|||
14
svd2repl/Cargo.toml
Normal file
14
svd2repl/Cargo.toml
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
[package]
|
||||
name = "svd2repl"
|
||||
description = "Convert an SVD file into a Renode Platform description"
|
||||
version = "0.1.0"
|
||||
authors = ["Sean Cross <sean@xobs.io>"]
|
||||
edition = "2018"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
quick-xml = "0.19"
|
||||
clap = "2"
|
||||
anyhow = "1.0"
|
||||
convert_case = "0.4"
|
||||
51
svd2repl/build.rs
Normal file
51
svd2repl/build.rs
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
use std::env;
|
||||
use std::error::Error;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
|
||||
struct IgnoredError {}
|
||||
|
||||
impl<E> From<E> for IgnoredError
|
||||
where
|
||||
E: Error,
|
||||
{
|
||||
fn from(_: E) -> IgnoredError {
|
||||
IgnoredError {}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
|
||||
|
||||
File::create(out_dir.join("commit-info.txt"))
|
||||
.unwrap()
|
||||
.write_all(commit_info().as_bytes())
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
fn commit_info() -> String {
|
||||
match (commit_hash(), commit_date()) {
|
||||
(Ok(hash), Ok(date)) => format!(" ({} {})", hash.trim(), date.trim()),
|
||||
_ => String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn commit_hash() -> Result<String, IgnoredError> {
|
||||
Ok(String::from_utf8(
|
||||
Command::new("git")
|
||||
.args(&["rev-parse", "--short", "HEAD"])
|
||||
.output()?
|
||||
.stdout,
|
||||
)?)
|
||||
}
|
||||
|
||||
fn commit_date() -> Result<String, IgnoredError> {
|
||||
Ok(String::from_utf8(
|
||||
Command::new("git")
|
||||
.args(&["log", "-1", "--date=short", "--pretty=format:%cd"])
|
||||
.output()?
|
||||
.stdout,
|
||||
)?)
|
||||
}
|
||||
629
svd2repl/src/generate.rs
Normal file
629
svd2repl/src/generate.rs
Normal file
|
|
@ -0,0 +1,629 @@
|
|||
use quick_xml::events::Event;
|
||||
use quick_xml::Reader;
|
||||
use std::io::{BufRead, BufReader, Read, Write};
|
||||
#[derive(Debug)]
|
||||
pub enum ParseError {
|
||||
UnexpectedTag,
|
||||
MissingValue,
|
||||
ParseIntError,
|
||||
NonUTF8,
|
||||
WriteError,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Field {
|
||||
name: String,
|
||||
lsb: usize,
|
||||
msb: usize,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Register {
|
||||
name: String,
|
||||
offset: usize,
|
||||
description: Option<String>,
|
||||
fields: Vec<Field>,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Interrupt {
|
||||
name: String,
|
||||
value: usize,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Peripheral {
|
||||
name: String,
|
||||
pub base: usize,
|
||||
size: usize,
|
||||
interrupt: Vec<Interrupt>,
|
||||
registers: Vec<Register>,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct MemoryRegion {
|
||||
pub name: String,
|
||||
pub base: usize,
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Constant {
|
||||
pub name: String,
|
||||
pub value: String,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Description {
|
||||
pub peripherals: Vec<Peripheral>,
|
||||
pub memory_regions: Vec<MemoryRegion>,
|
||||
pub constants: Vec<Constant>,
|
||||
}
|
||||
|
||||
impl core::fmt::Display for ParseError {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
use ParseError::*;
|
||||
match *self {
|
||||
UnexpectedTag => write!(f, "unexpected XML tag encountered"),
|
||||
MissingValue => write!(f, "XML tag should have contained a value"),
|
||||
ParseIntError => write!(f, "unable to parse number"),
|
||||
NonUTF8 => write!(f, "file is not UTF-8"),
|
||||
WriteError => write!(f, "unable to write destination file"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for ParseError {}
|
||||
|
||||
pub fn get_base(value: &str) -> (&str, u32) {
|
||||
if value.starts_with("0x") {
|
||||
(value.trim_start_matches("0x"), 16)
|
||||
} else if value.starts_with("0X") {
|
||||
(value.trim_start_matches("0X"), 16)
|
||||
} else if value.starts_with("0b") {
|
||||
(value.trim_start_matches("0b"), 2)
|
||||
} else if value.starts_with("0B") {
|
||||
(value.trim_start_matches("0B"), 2)
|
||||
} else if value.starts_with('0') && value != "0" {
|
||||
(value.trim_start_matches('0'), 8)
|
||||
} else {
|
||||
(value, 10)
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_usize(value: &[u8]) -> Result<usize, ParseError> {
|
||||
let value_as_str = String::from_utf8(value.to_vec()).or(Err(ParseError::NonUTF8))?;
|
||||
let (value, base) = get_base(&value_as_str);
|
||||
usize::from_str_radix(value, base).or(Err(ParseError::ParseIntError))
|
||||
}
|
||||
|
||||
fn extract_contents<T: BufRead>(reader: &mut Reader<T>) -> Result<String, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let contents = reader
|
||||
.read_event(&mut buf)
|
||||
.map_err(|_| ParseError::UnexpectedTag)?;
|
||||
match contents {
|
||||
Event::Text(t) => t
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8),
|
||||
_ => Err(ParseError::UnexpectedTag),
|
||||
}
|
||||
}
|
||||
|
||||
fn generate_field<T: BufRead>(reader: &mut Reader<T>) -> Result<Field, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut name = None;
|
||||
let mut lsb = None;
|
||||
let mut msb = None;
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => {
|
||||
let tag_name = e
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8)?;
|
||||
match tag_name.as_str() {
|
||||
"name" => name = Some(extract_contents(reader)?),
|
||||
"lsb" => lsb = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||
"msb" => msb = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
Ok(Event::End(ref e)) => {
|
||||
if let b"field" = e.name() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(_) => (),
|
||||
Err(e) => panic!("error parsing: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Field {
|
||||
name: name.ok_or(ParseError::MissingValue)?,
|
||||
lsb: lsb.ok_or(ParseError::MissingValue)?,
|
||||
msb: msb.ok_or(ParseError::MissingValue)?,
|
||||
})
|
||||
}
|
||||
|
||||
fn generate_fields<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
fields: &mut Vec<Field>,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"field" => fields.push(generate_field(reader)?),
|
||||
_ => panic!("unexpected tag in <field>: {:?}", e),
|
||||
},
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"fields" => {
|
||||
// println!("End fields");
|
||||
break;
|
||||
}
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_register<T: BufRead>(reader: &mut Reader<T>) -> Result<Register, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut name = None;
|
||||
let mut offset = None;
|
||||
let description = None;
|
||||
let mut fields = vec![];
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => {
|
||||
let tag_name = e
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8)?;
|
||||
match tag_name.as_str() {
|
||||
"name" => name = Some(extract_contents(reader)?),
|
||||
"addressOffset" => {
|
||||
offset = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||
}
|
||||
"fields" => generate_fields(reader, &mut fields)?,
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
Ok(Event::End(ref e)) => {
|
||||
if let b"register" = e.name() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(_) => (),
|
||||
Err(e) => panic!("error parsing: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Register {
|
||||
name: name.ok_or(ParseError::MissingValue)?,
|
||||
offset: offset.ok_or(ParseError::MissingValue)?,
|
||||
description,
|
||||
fields,
|
||||
})
|
||||
}
|
||||
|
||||
fn generate_interrupts<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
interrupts: &mut Vec<Interrupt>,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut name = None;
|
||||
let mut value = None;
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => {
|
||||
let tag_name = e
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8)?;
|
||||
match tag_name.as_str() {
|
||||
"name" => name = Some(extract_contents(reader)?),
|
||||
"value" => value = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
Ok(Event::End(ref e)) => {
|
||||
if let b"interrupt" = e.name() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(_) => (),
|
||||
Err(e) => panic!("error parsing: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
interrupts.push(Interrupt {
|
||||
name: name.ok_or(ParseError::MissingValue)?,
|
||||
value: value.ok_or(ParseError::MissingValue)?,
|
||||
});
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_registers<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
registers: &mut Vec<Register>,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"register" => registers.push(generate_register(reader)?),
|
||||
_ => panic!("unexpected tag in <registers>: {:?}", e),
|
||||
},
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"registers" => {
|
||||
break;
|
||||
}
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_peripheral<T: BufRead>(reader: &mut Reader<T>) -> Result<Peripheral, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut name = None;
|
||||
let mut base = None;
|
||||
let mut size = None;
|
||||
let mut registers = vec![];
|
||||
let mut interrupts = vec![];
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => {
|
||||
let tag_name = e
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8)?;
|
||||
match tag_name.as_str() {
|
||||
"name" => name = Some(extract_contents(reader)?),
|
||||
"baseAddress" => {
|
||||
base = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||
}
|
||||
"size" => size = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||
"registers" => generate_registers(reader, &mut registers)?,
|
||||
"interrupt" => generate_interrupts(reader, &mut interrupts)?,
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
Ok(Event::End(ref e)) => {
|
||||
if let b"peripheral" = e.name() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(_) => (),
|
||||
Err(e) => panic!("error parsing: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(Peripheral {
|
||||
name: name.ok_or(ParseError::MissingValue)?,
|
||||
base: base.ok_or(ParseError::MissingValue)?,
|
||||
size: size.ok_or(ParseError::MissingValue)?,
|
||||
interrupt: interrupts,
|
||||
registers,
|
||||
})
|
||||
}
|
||||
|
||||
fn generate_peripherals<T: BufRead>(reader: &mut Reader<T>) -> Result<Vec<Peripheral>, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut peripherals = vec![];
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"peripheral" => peripherals.push(generate_peripheral(reader)?),
|
||||
_ => panic!("unexpected tag in <peripherals>: {:?}", e),
|
||||
},
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"peripherals" => {
|
||||
break;
|
||||
}
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(peripherals)
|
||||
}
|
||||
|
||||
fn generate_memory_region<T: BufRead>(reader: &mut Reader<T>) -> Result<MemoryRegion, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let mut name = None;
|
||||
let mut base = None;
|
||||
let mut size = None;
|
||||
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => {
|
||||
let tag_name = e
|
||||
.unescape_and_decode(reader)
|
||||
.map_err(|_| ParseError::NonUTF8)?;
|
||||
match tag_name.as_str() {
|
||||
"name" => name = Some(extract_contents(reader)?),
|
||||
"baseAddress" => {
|
||||
base = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||
}
|
||||
"size" => size = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
Ok(Event::End(ref e)) => {
|
||||
if let b"memoryRegion" = e.name() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(_) => (),
|
||||
Err(e) => panic!("error parsing: {:?}", e),
|
||||
}
|
||||
}
|
||||
|
||||
Ok(MemoryRegion {
|
||||
name: name.ok_or(ParseError::MissingValue)?,
|
||||
base: base.ok_or(ParseError::MissingValue)?,
|
||||
size: size.ok_or(ParseError::MissingValue)?,
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_memory_regions<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
description: &mut Description,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"memoryRegion" => description
|
||||
.memory_regions
|
||||
.push(generate_memory_region(reader)?),
|
||||
_ => panic!("unexpected tag in <memoryRegions>: {:?}", e),
|
||||
},
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"memoryRegions" => {
|
||||
break;
|
||||
}
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_constants<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
description: &mut Description,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Empty(ref e)) => match e.name() {
|
||||
b"constant" => {
|
||||
let mut constant_descriptor = Constant::default();
|
||||
for maybe_att in e.attributes() {
|
||||
match maybe_att {
|
||||
Ok(att) => {
|
||||
let att_name = String::from_utf8(att.key.to_vec())
|
||||
.expect("constant: error parsing attribute name");
|
||||
let att_value = String::from_utf8(att.value.to_vec())
|
||||
.expect("constant: error parsing attribute value");
|
||||
match att_name {
|
||||
_ if att_name == "name" => constant_descriptor.name = att_value,
|
||||
_ if att_name == "value" => {
|
||||
constant_descriptor.value = att_value
|
||||
}
|
||||
_ => panic!("unexpected attribute name"),
|
||||
}
|
||||
}
|
||||
_ => panic!("unexpected value in constant: {:?}", maybe_att),
|
||||
}
|
||||
}
|
||||
description.constants.push(constant_descriptor)
|
||||
}
|
||||
_ => panic!("unexpected tag in <constants>: {:?}", e),
|
||||
},
|
||||
// note to future self: if Litex goe away from attributes to nested elements, you would want
|
||||
// Ok(Event::Start(ref e) => match e.name() ... to descend into the next tag level, and then
|
||||
// use the tag_name match and extract_contents methods from other functions to generate
|
||||
// the structure.
|
||||
// note that the two formats could be mutually exclusively compatible within the same code base:
|
||||
// if there are no attributes, the attribute iterator would do nothing; and if there are no
|
||||
// child elements, the recursive descent would also do nothing.
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"constants" => break,
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_vendor_extensions<T: BufRead>(
|
||||
reader: &mut Reader<T>,
|
||||
description: &mut Description,
|
||||
) -> Result<(), ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"memoryRegions" => parse_memory_regions(reader, description)?,
|
||||
b"constants" => generate_constants(reader, description)?,
|
||||
_ => panic!("unexpected tag in <vendorExtensions>: {:?}", e),
|
||||
},
|
||||
Ok(Event::End(ref e)) => match e.name() {
|
||||
b"vendorExtensions" => {
|
||||
break;
|
||||
}
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
},
|
||||
Ok(Event::Text(_)) => (),
|
||||
e => panic!("unhandled value: {:?}", e),
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_header<U: Write>(out: &mut U) -> std::io::Result<()> {
|
||||
let s = r####"
|
||||
cpu: CPU.VexRiscv @ sysbus
|
||||
cpuType: "rv32imac"
|
||||
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
||||
PerformanceInMips: 120
|
||||
"####;
|
||||
out.write_all(s.as_bytes())
|
||||
}
|
||||
|
||||
fn print_footer<U: Write>(out: &mut U) -> std::io::Result<()> {
|
||||
let s = r####"
|
||||
sysbus:
|
||||
init:
|
||||
ApplySVD @soc/renode.svd
|
||||
"####;
|
||||
out.write_all(s.as_bytes())
|
||||
}
|
||||
|
||||
fn print_memory_regions<U: Write>(regions: &[MemoryRegion], out: &mut U) -> std::io::Result<()> {
|
||||
writeln!(out, "// Physical base addresses of memory regions")?;
|
||||
for region in regions {
|
||||
let mut region_name = region.name.to_lowercase();
|
||||
let region_size = if region.size < 4096 {
|
||||
4096
|
||||
} else {
|
||||
if region.size & 4095 != 0 {
|
||||
region.size + 4096 - (region.size & 4095)
|
||||
} else {
|
||||
region.size
|
||||
}
|
||||
};
|
||||
|
||||
// Ignore the CSR region, since we explicitly define registers there.
|
||||
if region_name == "csr" {
|
||||
continue;
|
||||
}
|
||||
|
||||
// The current design doubles-up on this identifier, so bodge in a new name.
|
||||
if region_name == "memlcd" {
|
||||
region_name = "fbmem".to_string();
|
||||
}
|
||||
|
||||
writeln!(
|
||||
out,
|
||||
"{}: Memory.MappedMemory @ sysbus 0x{:08x}",
|
||||
region_name, region.base
|
||||
)?;
|
||||
writeln!(out, " size: 0x{:08x}", region_size)?;
|
||||
writeln!(out)?;
|
||||
}
|
||||
writeln!(out)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn print_peripherals<U: Write>(
|
||||
peripherals: &[Peripheral],
|
||||
constants: &[Constant],
|
||||
out: &mut U,
|
||||
) -> std::io::Result<()> {
|
||||
use std::collections::HashMap;
|
||||
let mut known_peripherals = HashMap::new();
|
||||
known_peripherals.insert("console", "UART.LiteX_UART");
|
||||
known_peripherals.insert("uart", "UART.LiteX_UART");
|
||||
known_peripherals.insert("app_uart", "UART.LiteX_UART");
|
||||
known_peripherals.insert("timer0", "Timers.LiteX_Timer_32");
|
||||
|
||||
known_peripherals.insert("memlcd", "Video.BetrustedLCD");
|
||||
known_peripherals.insert("keyboard", "Input.BetrustedKbd");
|
||||
known_peripherals.insert("trng_kernel", "Miscellaneous.BetrustedRNGKernel");
|
||||
known_peripherals.insert("trng_server", "Miscellaneous.BetrustedRNGServer");
|
||||
known_peripherals.insert("ticktimer", "Timers.TickTimer");
|
||||
writeln!(out, "// Platform Peripherals")?;
|
||||
for peripheral in peripherals {
|
||||
let lc_name = peripheral.name.to_lowercase();
|
||||
// let peripheral_size = if peripheral.size < 4096 {
|
||||
// 4096
|
||||
// } else {
|
||||
// peripheral.size
|
||||
// };
|
||||
if let Some(renode_device) = known_peripherals.get(lc_name.as_str()) {
|
||||
writeln!(
|
||||
out,
|
||||
"{}: {} @ sysbus 0x{:08x}",
|
||||
lc_name, renode_device, peripheral.base
|
||||
)?;
|
||||
|
||||
// TODO: Get the frequency from the `constants` table under `CONFIG_CLOCK_FREQUENCY`
|
||||
if lc_name == "timer0" {
|
||||
let mut freq_found = false;
|
||||
for constant in constants {
|
||||
if constant.name == "CONFIG_CLOCK_FREQUENCY" {
|
||||
writeln!(out, " frequency: {}", constant.value)?;
|
||||
freq_found = true;
|
||||
}
|
||||
}
|
||||
if !freq_found {
|
||||
panic!("Couldn't discover clock frequency when creating timer0 object");
|
||||
}
|
||||
}
|
||||
|
||||
// Note: we skip the `size` value here, since peripherals don't have a known size.
|
||||
|
||||
// Add the interrupt, if one exists.
|
||||
if let Some(irq) = peripheral.interrupt.get(0) {
|
||||
writeln!(out, " -> cpu @ {}", 1000 + irq.value)?;
|
||||
}
|
||||
} else {
|
||||
writeln!(out, "// Unrecognized peripheral: {}", lc_name)?;
|
||||
}
|
||||
writeln!(out)?;
|
||||
}
|
||||
writeln!(out)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn parse_svd<T: Read>(src: T) -> Result<Description, ParseError> {
|
||||
let mut buf = Vec::new();
|
||||
let buf_reader = BufReader::new(src);
|
||||
let mut reader = Reader::from_reader(buf_reader);
|
||||
let mut description = Description::default();
|
||||
loop {
|
||||
match reader.read_event(&mut buf) {
|
||||
Ok(Event::Start(ref e)) => match e.name() {
|
||||
b"peripherals" => {
|
||||
description.peripherals = generate_peripherals(&mut reader)?;
|
||||
}
|
||||
b"vendorExtensions" => {
|
||||
parse_vendor_extensions(&mut reader, &mut description)?;
|
||||
}
|
||||
_ => (),
|
||||
},
|
||||
Ok(Event::Eof) => break,
|
||||
Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
|
||||
_ => (),
|
||||
}
|
||||
buf.clear();
|
||||
}
|
||||
Ok(description)
|
||||
}
|
||||
|
||||
pub fn generate<T: Read, U: Write>(src: T, dest: &mut U) -> Result<(), ParseError> {
|
||||
let description = parse_svd(src)?;
|
||||
|
||||
print_header(dest).or(Err(ParseError::WriteError))?;
|
||||
print_peripherals(&description.peripherals, &description.constants, dest)
|
||||
.or(Err(ParseError::WriteError))?;
|
||||
print_memory_regions(&description.memory_regions, dest).or(Err(ParseError::WriteError))?;
|
||||
print_footer(dest).or(Err(ParseError::WriteError))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
15
svd2repl/src/lib.rs
Normal file
15
svd2repl/src/lib.rs
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
mod generate;
|
||||
pub use generate::*;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::fs::{DirBuilder, File};
|
||||
#[test]
|
||||
fn basic_generate() {
|
||||
let src = File::open("examples/soc.svd").unwrap();
|
||||
DirBuilder::new().recursive(true).create("target").unwrap();
|
||||
let mut dest = File::create("target/example.rs").unwrap();
|
||||
generate(src, &mut dest).unwrap();
|
||||
}
|
||||
}
|
||||
44
svd2repl/src/main.rs
Normal file
44
svd2repl/src/main.rs
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
mod generate;
|
||||
|
||||
use anyhow::Context;
|
||||
use clap::{App, Arg};
|
||||
use std::fs::File;
|
||||
use std::io::{Read, Write};
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
let matches = App::new("svd2repl")
|
||||
.about("Generate a Rebide Platform description from SVD files")
|
||||
.arg(
|
||||
Arg::with_name("input")
|
||||
.help("Input SVD file")
|
||||
.short("i")
|
||||
.takes_value(true)
|
||||
.value_name("FILE"),
|
||||
)
|
||||
.arg(
|
||||
Arg::with_name("output")
|
||||
.help("Output .repl file or directory")
|
||||
.short("o")
|
||||
.takes_value(true)
|
||||
.value_name("FILE"),
|
||||
)
|
||||
.version(concat!(
|
||||
env!("CARGO_PKG_VERSION"),
|
||||
include_str!(concat!(env!("OUT_DIR"), "/commit-info.txt"))
|
||||
))
|
||||
.get_matches();
|
||||
|
||||
let src: Box<dyn Read> = match matches.value_of("input") {
|
||||
Some(file) => Box::new(File::open(file).context("Cannot open the SVD file")?),
|
||||
None => Box::new(std::io::stdin()),
|
||||
};
|
||||
|
||||
let mut dest: Box<dyn Write> = match matches.value_of("output") {
|
||||
None => Box::new(std::io::stdout()),
|
||||
Some(path) => Box::new(File::create(path).context("Cannot open destination file")?),
|
||||
};
|
||||
|
||||
generate::generate(src, &mut dest).context("Cannot generate output file")?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
Loading…
Reference in a new issue