svd-generator 0.7.0

Converts device information from flattened device tree into an SVD description
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::fs;
use std::io::{Read, Write};

use clap::Parser;

use svd_generator::svd::*;
use svd_generator::Result;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Flattened Devicetree input file
    #[arg(short = 'f', long)]
    fdt: String,

    /// Output SVD file
    #[arg(short = 'o', long, default_value = "out.svd")]
    out: String,
}

fn main() -> Result<()> {
    let mut builder = env_logger::Builder::new();
    builder.filter_level(log::LevelFilter::Info);
    builder.parse_default_env();
    builder.init();

    let Args { fdt, out } = Args::parse();

    log::info!("Loading flattened device tree from: {fdt}...");

    let md = fs::metadata(fdt.as_str())?;
    let mut dt_buf = Vec::with_capacity(md.len() as usize);

    fs::File::open(fdt.as_str())?.read_to_end(&mut dt_buf)?;

    let dt = fdt::Fdt::new(dt_buf.as_ref())?;

    log::info!("FDT loaded successfully!");

    log::trace!("{dt:?}");

    let model = dt.root()?.model();
    let peripherals = parse_peripherals(&dt)?;
    let device_desc = format!("From {model},model device generator");

    let device = svd::Device::builder()
        .name(model.into())
        .description(device_desc)
        .version("0.1".into())
        .address_unit_bits(8)
        .width(32)
        .peripherals(peripherals)
        .build(svd::ValidateLevel::Strict)?;

    let device_str = svd_encoder::encode(&device)?;

    log::trace!("Generated SVD device description:\n\n{device_str}");

    log::info!("Writing SVD to output file: {out}");

    fs::File::create(out.as_str())?.write_all(device_str.as_bytes())?;

    log::info!("SVD converted successfully!");

    Ok(())
}