patch-svd 0.1.0

Load and patch svd files.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

#![allow(dead_code)]

use patch_svd::output::*;

pub const SPARSE_DEVICE: &str = r#"
    <device>
        <schemaVersion>1.0.0</schemaVersion>
        <name>ucName</name>
        <version>1.0.0</version>
        <description>Some description</description>
        <cpu>
            <name>CM0</name>
            <revision>r4</revision>
            <endian>little</endian>
            <mpuPresent>true</mpuPresent>
            <fpuPresent>true</fpuPresent>
            <nvicPrioBits>8</nvicPrioBits>
            <vendorSystickConfig>true</vendorSystickConfig>
        </cpu>
        <addressUnitBits>32</addressUnitBits>
        <width>32</width>
        <peripherals>
            <peripheral>
                <name>PeripheralName</name>
                <baseAddress>77</baseAddress>
            </peripheral>
        </peripherals>
    </device>
    "#;

pub const SPARSE_PERIPHERAL: &str = r#"
    <device>
        <schemaVersion>1.0.0</schemaVersion>
        <name>ucName</name>
        <version>1.0.0</version>
        <description>Some description</description>
        <cpu>
            <name>CM0</name>
            <revision>r4</revision>
            <endian>little</endian>
            <mpuPresent>true</mpuPresent>
            <fpuPresent>true</fpuPresent>
            <nvicPrioBits>8</nvicPrioBits>
            <vendorSystickConfig>true</vendorSystickConfig>
        </cpu>
        <addressUnitBits>32</addressUnitBits>
        <width>32</width>
        <peripherals>
            <peripheral>
                <name>PERIPHERAL_NAME_1</name>
                <baseAddress>1234</baseAddress>
            </peripheral>
        </peripherals>
    </device>
    "#;

pub fn get_sparse_device() -> Device {
    Device {
        schema_version: "1.0.0".to_string(),
        vendor: None,
        vendor_id: None,
        name: "ucName".to_string(),
        series: None,
        version: "1.0.0".to_string(),
        description: "Some description".to_string(),
        license_text: None,
        cpu: Cpu {
            name: CpuNameType::CM0,
            revision: "r4".to_string(),
            endian: EndianType::Little,
            mpu_present: true,
            fpu_present: true,
            fpu_d_p: None,
            dsp_present: None,
            icache_present: None,
            dcache_present: None,
            itcm_present: None,
            dtcm_present: None,
            vtor_present: None,
            nvic_prio_bits: SvdConstant { value: 8 },
            vendor_systick_config: true,
            device_num_interrupts: None,
            sau_num_regions: None,
            sau_regions_config: None,
        },
        header_system_filename: None,
        header_definitions_prefix: None,
        address_unit_bits: SvdConstant { value: 32 },
        width: SvdConstant { value: 32 },
        size: None,
        access: None,
        protection: None,
        reset_value: None,
        reset_mask: None,
        peripherals: Peripherals {
            peripheral: vec![Peripheral {
                derived_from: None,
                dim: None,
                dim_increment: None,
                dim_index: None,
                dim_name: None,
                dim_array_index: None,
                name: "PeripheralName".to_string(),
                version: None,
                description: None,
                alternate_peripheral: None,
                group_name: None,
                prepend_to_name: None,
                append_to_name: None,
                header_struct_name: None,
                disable_condition: None,
                base_address: SvdConstant { value: 77 },
                size: None,
                access: None,
                protection: None,
                reset_value: None,
                reset_mask: None,
                address_block: None,
                interrupt: None,
                registers: None,
            }],
        },
    }
}

pub enum SparsePeripheralContent {
    Interrupts(Vec<Interrupt>),
    Registers(Registers),
}

pub fn get_sparse_peripheral(sparse_peripheral_content: Option<SparsePeripheralContent>) -> Device {
    let (interrupt, registers) = match sparse_peripheral_content {
        None => (None, None),
        Some(SparsePeripheralContent::Interrupts(interrupts)) => (Some(interrupts), None),
        Some(SparsePeripheralContent::Registers(registers)) => (None, Some(registers)),
    };
    let mut device = get_sparse_device();
    device.peripherals = Peripherals {
        peripheral: vec![Peripheral {
            derived_from: None,
            dim: None,
            dim_increment: None,
            dim_index: None,
            dim_name: None,
            dim_array_index: None,
            name: "PERIPHERAL_NAME_1".to_string(),
            version: None,
            description: None,
            alternate_peripheral: None,
            group_name: None,
            prepend_to_name: None,
            append_to_name: None,
            header_struct_name: None,
            disable_condition: None,
            base_address: SvdConstant { value: 1234 },
            size: None,
            access: None,
            protection: None,
            reset_value: None,
            reset_mask: None,
            address_block: None,
            interrupt,
            registers,
        }],
    };
    device
}