diff --git a/Cargo.lock b/Cargo.lock index 930cba46d..661457b1c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -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", diff --git a/Cargo.toml b/Cargo.toml index 3fac29549..84363453f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -46,6 +46,7 @@ members = [ "services/rkyv-test-server", "services/rkyv-test-client", "services/shellchat", + "svd2repl", "svd2utra", "xtask", "imports/blitstr-ref", diff --git a/svd2repl/Cargo.toml b/svd2repl/Cargo.toml new file mode 100644 index 000000000..e428874ee --- /dev/null +++ b/svd2repl/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "svd2repl" +description = "Convert an SVD file into a Renode Platform description" +version = "0.1.0" +authors = ["Sean Cross "] +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" diff --git a/svd2repl/build.rs b/svd2repl/build.rs new file mode 100644 index 000000000..56ee3e0a1 --- /dev/null +++ b/svd2repl/build.rs @@ -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 From 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 { + Ok(String::from_utf8( + Command::new("git") + .args(&["rev-parse", "--short", "HEAD"]) + .output()? + .stdout, + )?) +} + +fn commit_date() -> Result { + Ok(String::from_utf8( + Command::new("git") + .args(&["log", "-1", "--date=short", "--pretty=format:%cd"]) + .output()? + .stdout, + )?) +} diff --git a/svd2repl/src/generate.rs b/svd2repl/src/generate.rs new file mode 100644 index 000000000..b7224bf1a --- /dev/null +++ b/svd2repl/src/generate.rs @@ -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, + fields: Vec, +} + +#[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, + registers: Vec, +} + +#[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, + pub memory_regions: Vec, + pub constants: Vec, +} + +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 { + 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(reader: &mut Reader) -> Result { + 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(reader: &mut Reader) -> Result { + 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( + reader: &mut Reader, + fields: &mut Vec, +) -> 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 : {:?}", 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(reader: &mut Reader) -> Result { + 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( + reader: &mut Reader, + interrupts: &mut Vec, +) -> 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( + reader: &mut Reader, + registers: &mut Vec, +) -> 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 : {:?}", 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(reader: &mut Reader) -> Result { + 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(reader: &mut Reader) -> Result, 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 : {:?}", 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(reader: &mut Reader) -> Result { + 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( + reader: &mut Reader, + 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 : {:?}", 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( + reader: &mut Reader, + 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 : {:?}", 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( + reader: &mut Reader, + 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 : {:?}", 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(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(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(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( + 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(src: T) -> Result { + 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(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(()) +} diff --git a/svd2repl/src/lib.rs b/svd2repl/src/lib.rs new file mode 100644 index 000000000..4a81ed72c --- /dev/null +++ b/svd2repl/src/lib.rs @@ -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(); + } +} diff --git a/svd2repl/src/main.rs b/svd2repl/src/main.rs new file mode 100644 index 000000000..cb324f679 --- /dev/null +++ b/svd2repl/src/main.rs @@ -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 = 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 = 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(()) +}