svd-generator 0.1.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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use crate::{Error, Result};

/// Convenience function to create a SVD register [`Cluster`](svd::Cluster).
pub fn create_cluster(
    name: &str,
    address_offset: u32,
    children: &[svd::RegisterCluster],
    dim_element: Option<svd::DimElement>,
) -> Result<svd::Cluster> {
    let name = if dim_element.is_some() {
        format!("{name}[%s]")
    } else {
        name.into()
    };
    let info = svd::ClusterInfo::builder()
        .name(name)
        .address_offset(address_offset)
        .children(children.into())
        .build(svd::ValidateLevel::Strict)?;

    match dim_element {
        Some(dim) => Ok(svd::Cluster::Array(info, dim)),
        None => Ok(svd::Cluster::Single(info)),
    }
}

/// Convenience function to create a SVD [`Register`](svd::Register).
pub fn create_register(
    name: &str,
    desc: &str,
    addr_offset: u32,
    properties: svd::RegisterProperties,
    fields: Option<&[svd::Field]>,
    dim_element: Option<svd::DimElement>,
) -> Result<svd::Register> {
    let name = if dim_element.is_some() {
        format!("{name}[%s]")
    } else {
        name.into()
    };
    let info = svd::RegisterInfo::builder()
        .name(name)
        .description(Some(desc.into()))
        .address_offset(addr_offset)
        .properties(properties)
        .fields(fields.map(|f| f.into()))
        .build(svd::ValidateLevel::Weak)?;

    match dim_element {
        Some(dim) => Ok(svd::Register::Array(info, dim)),
        None => Ok(svd::Register::Single(info)),
    }
}

/// Convenience function to create a SVD [`RegisterProperties`](svd::RegisterProperties).
pub fn create_register_properties(size: u32, reset_value: u64) -> Result<svd::RegisterProperties> {
    Ok(svd::RegisterProperties::new()
        .size(Some(size))
        .reset_value(Some(reset_value))
        .build(svd::ValidateLevel::Strict)?)
}

/// Convenience function to create a SVD register [`Field`](svd::Field).
pub fn create_field(
    name: &str,
    desc: &str,
    bit_range: svd::BitRange,
    access: svd::Access,
    dim_element: Option<svd::DimElement>,
) -> Result<svd::Field> {
    let info = svd::FieldInfo::builder()
        .name(name.into())
        .description(Some(desc.into()))
        .bit_range(bit_range)
        .access(Some(access))
        .build(svd::ValidateLevel::Strict)?;

    match dim_element {
        Some(dim) => Ok(svd::Field::Array(info, dim)),
        None => Ok(svd::Field::Single(info)),
    }
}

/// Convenience function to create a SVD register [`BitRange`](svd::BitRange).
pub fn create_bit_range(range: &str) -> Result<svd::BitRange> {
    svd::BitRange::from_bit_range(range).ok_or(Error::InvalidBitRange)
}