Implement union peripherals with clustering (TCA single mode / split mode on attiny's)

src/atdf/peripheral.rs

@@ -13,52 +13,36 @@ pub fn parse_list(
         let module_name = module.attr("name")?;
 
         for instance in module.iter_children_with_name("instance", Some("module")) {
-            let mut registers = vec![];
-
             // Find corresponding module
             let module = modules.first_child_by_attr(Some("module"), "name", module_name)?;
 
             // The register definitions can reference value-groups, that are stored on the same
             // level as the register-groups, so we parse them in here first.
             let value_groups = atdf::values::parse_value_groups(module)?;
 
-            for register_group in instance
-                .children
-                .iter()
-                .filter_map(|node| node.as_element().filter(|e| e.name == "register-group"))
-            {
-                let name = register_group.attr("name-in-module")?;
-                let offset = util::parse_int(register_group.attr("offset")?)?;
-
-                let group = module.first_child_by_attr(Some("register-group"), "name", name)?;
-
-                for register in group.iter_children_with_name("register", Some("register-group")) {
-                    registers.push(atdf::register::parse(register, offset, &value_groups)?);
-                }
-            }
-
-            let registers = registers
-                .into_iter()
-                .map(|r| {
-                    (
-                        match r.mode {
-                            Some(ref mode) => format!("{mode}_{}", r.name),
-                            _ => r.name.clone(),
-                        },
-                        r,
-                    )
-                })
-                .collect();
+            // An instance should always have one register-group
+            let instance_register_group = match instance.first_child("register-group") {
+                Ok(rg) => rg,
+                Err(_) => continue,
+            };
+            let name_in_module = instance_register_group.attr("name-in-module")?;
+            let offset = util::parse_int(instance_register_group.attr("offset")?)?;
+            let register_group_headers =
+                atdf::register::parse_register_group_headers(module, offset, &value_groups)?;
+            let main_register_group = register_group_headers.get(name_in_module).cloned().unwrap();
+            let registers = main_register_group.registers;
 
             peripherals.push(chip::Peripheral {
                 name: instance.attr("name")?.clone(),
+                name_in_module: name_in_module.clone(),
                 description: instance
                     .attr("caption")
                     .or(module.attr("caption"))
                     .ok()
                     .cloned()
                     .and_then(|d| if !d.is_empty() { Some(d) } else { None }),
                 registers,
+                register_group_headers: register_group_headers.clone(),
             })
         }
     }

src/atdf/register.rs

@@ -84,3 +84,150 @@ pub fn parse(
         fields,
     })
 }
+
+pub fn parse_list(
+    register_group_header_el: &xmltree::Element,
+    offset: usize,
+    value_groups: &atdf::values::ValueGroups,
+) -> crate::Result<BTreeMap<String, chip::Register>> {
+    let mut registers = vec![];
+
+    for register in
+        register_group_header_el.iter_children_with_name("register", Some("register-group"))
+    {
+        registers.push(atdf::register::parse(register, offset, value_groups)?);
+    }
+    Ok(registers
+        .into_iter()
+        .map(|r| {
+            (
+                match r.mode {
+                    Some(ref mode) => format!("{mode}_{}", r.name),
+                    _ => r.name.clone(),
+                },
+                r,
+            )
+        })
+        .collect())
+}
+
+pub fn parse_register_group_headers(
+    module_el: &xmltree::Element,
+    offset: usize,
+    value_groups: &atdf::values::ValueGroups,
+) -> crate::Result<BTreeMap<String, chip::RegisterGroupHeader>> {
+    let mut register_group_headers = BTreeMap::new();
+    for register_group_header_el in module_el
+        .children
+        .iter()
+        .filter_map(|node| node.as_element().filter(|e| e.name == "register-group"))
+    {
+        let name = register_group_header_el.attr("name")?.clone();
+        let class = register_group_header_el
+            .attributes
+            .get("class")
+            .and_then(|d| if !d.is_empty() { Some(d) } else { None })
+            .cloned();
+        let description = register_group_header_el
+            .attributes
+            .get("caption")
+            .and_then(|d| if !d.is_empty() { Some(d) } else { None })
+            .cloned();
+
+        let size = register_group_header_el
+            .attributes
+            .get("size")
+            .and_then(|d| {
+                if !d.is_empty() {
+                    util::parse_int(d).ok()
+                } else {
+                    None
+                }
+            });
+
+        let register_group_items = parse_register_group_items(register_group_header_el)?;
+        let registers = parse_list(register_group_header_el, offset, value_groups)?;
+
+        register_group_headers.insert(
+            name.clone(),
+            chip::RegisterGroupHeader {
+                name,
+                class,
+                description,
+                size,
+                register_group_items,
+                registers,
+            },
+        );
+    }
+    Ok(register_group_headers)
+}
+
+pub fn parse_register_group_items(
+    register_group_header_el: &xmltree::Element,
+) -> crate::Result<BTreeMap<String, chip::RegisterGroupItem>> {
+    let mut register_group_items = BTreeMap::new();
+
+    for register_group_item_el in register_group_header_el
+        .children
+        .iter()
+        .filter_map(|node| node.as_element().filter(|e| e.name == "register-group"))
+    {
+        let name = register_group_item_el.attr("name")?.clone();
+        let description = register_group_item_el
+            .attributes
+            .get("caption")
+            .and_then(|d| if !d.is_empty() { Some(d) } else { None })
+            .cloned();
+
+        let name_in_module = register_group_item_el
+            .attributes
+            .get("name-in-module")
+            .and_then(|d| if !d.is_empty() { Some(d) } else { None })
+            .cloned();
+
+        let size = register_group_item_el.attributes.get("size").and_then(|d| {
+            if !d.is_empty() {
+                util::parse_int(d).ok()
+            } else {
+                None
+            }
+        });
+
+        let offset = register_group_item_el
+            .attributes
+            .get("offset")
+            .and_then(|d| {
+                if !d.is_empty() {
+                    util::parse_int(d).ok()
+                } else {
+                    None
+                }
+            });
+
+        let count = register_group_item_el
+            .attributes
+            .get("count")
+            .and_then(|d| {
+                if !d.is_empty() {
+                    util::parse_int(d).ok()
+                } else {
+                    None
+                }
+            });
+
+        register_group_items.insert(
+            name.clone(),
+            chip::RegisterGroupItem {
+                name,
+                name_in_module,
+                description,
+                size,
+                offset,
+                count,
+            },
+        );
+    }
+
+    Ok(register_group_items)
+}

src/chip.rs

@@ -18,15 +18,57 @@ pub struct Chip {
 #[derive(Debug, Clone)]
 pub struct Peripheral {
     pub name: String,
+    pub name_in_module: String,
     pub description: Option<String>,
 
     pub registers: BTreeMap<String, Register>,
+    pub register_group_headers: BTreeMap<String, RegisterGroupHeader>,
 }
 
 impl Peripheral {
     pub fn base_address(&self) -> Option<usize> {
+        if self.is_union() {
+            return self
+                .get_union_register_group_headers()
+                .iter()
+                .flat_map(|(h, _)| h.registers.values())
+                .map(|r| r.address)
+                .min();
+        }
         self.registers.values().map(|r| r.address).min()
     }
+
+    pub fn module_register_group_header(&self) -> Option<&RegisterGroupHeader> {
+        self.register_group_headers.get(&self.name_in_module)
+    }
+
+    pub fn is_union(&self) -> bool {
+        let module_register_group_header = self.module_register_group_header();
+        match module_register_group_header {
+            Some(header) => header.is_union(),
+            None => false,
+        }
+    }
+
+    pub fn get_union_register_group_headers(
+        &self,
+    ) -> Vec<(&RegisterGroupHeader, &RegisterGroupItem)> {
+        match self.module_register_group_header() {
+            Some(module_header) if module_header.is_union() => module_header
+                .register_group_items
+                .values()
+                .filter_map(|group_item| {
+                    group_item.name_in_module.as_ref().and_then(|header_name| {
+                        self.register_group_headers
+                            .iter()
+                            .find(|(_, header)| &header.name == header_name)
+                            .map(|(_, header)| (header, group_item))
+                    })
+                })
+                .collect(),
+            _ => vec![],
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -52,6 +94,33 @@ pub enum ValueRestriction {
     Enumerated(BTreeMap<String, EnumeratedValue>),
 }
 
+#[derive(Debug, Clone)]
+pub struct RegisterGroupHeader {
+    pub name: String,
+    pub class: Option<String>,
+    pub description: Option<String>,
+    pub size: Option<usize>,
+
+    pub register_group_items: BTreeMap<String, RegisterGroupItem>,
+    pub registers: BTreeMap<String, Register>,
+}
+
+impl RegisterGroupHeader {
+    pub fn is_union(&self) -> bool {
+        self.class.as_deref() == Some("union")
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct RegisterGroupItem {
+    pub name: String,
+    pub name_in_module: Option<String>,
+    pub description: Option<String>,
+    pub size: Option<usize>,
+    pub offset: Option<usize>,
+    pub count: Option<usize>,
+}
+
 #[derive(Debug, Clone)]
 pub struct Register {
     pub name: String,

src/svd/chip.rs

@@ -45,6 +45,12 @@ pub fn generate(c: &chip::Chip) -> crate::Result<svd_rs::Device> {
 }
 
 fn has_registers(peripheral: &&chip::Peripheral) -> bool {
+    if peripheral.is_union() {
+        return peripheral
+            .get_union_register_group_headers()
+            .iter()
+            .any(|(header, _)| !header.registers.values().len() > 0);
+    }
     let regs = !peripheral.registers.is_empty();
     if !regs {
         log::warn!("No registers found for peripheral {}", peripheral.name);