Add normalize_peri_name.

stm32-data-gen/src/chips.rs

@@ -5,6 +5,7 @@ use stm32_data_serde::chip::core::peripheral::Pin;
 
 use super::*;
 use crate::gpio_af::parse_signal_name;
+use crate::normalize_peris::normalize_peri_name;
 
 mod xml {
     use serde::Deserialize;
@@ -1008,7 +1009,7 @@ fn process_core(
 
     let mut peri_kinds = HashMap::new();
     for ip in group.ips.values() {
-        let pname = ip.instance_name.clone();
+        let pname = normalize_peri_name(&ip.instance_name);
         let pkind = format!("{}:{}", ip.name, ip.version);
         let pkind = pkind.strip_suffix("_Cube").unwrap_or(&pkind);
 
@@ -1035,18 +1036,10 @@ fn process_core(
             "TOUCHSENSING",
         ];
 
-        if FAKE_PERIPHERALS.contains(&pname.as_str()) {
+        if FAKE_PERIPHERALS.contains(&pname) {
             continue;
         }
 
-        let pname = match pname.as_str() {
-            "HDMI_CEC" => "CEC".to_string(),
-            "SUBGHZ" => "SUBGHZSPI".to_string(),
-            // remove when https://github.com/stm32-rs/stm32-rs/pull/789 merges
-            "USB_DRD_FS" => "USB".to_string(),
-            _ => pname,
-        };
-
         if pname.starts_with("ADC") {
             if let Entry::Vacant(entry) = peri_kinds.entry("ADC_COMMON".to_string()) {
                 entry.insert(format!("ADC_COMMON:{}", ip.version.strip_suffix("_Cube").unwrap()));
@@ -1057,7 +1050,7 @@ fn process_core(
                 entry.insert(format!("ADC3_COMMON:{}", ip.version.strip_suffix("_Cube").unwrap()));
             }
         }
-        peri_kinds.insert(pname, pkind.to_string());
+        peri_kinds.insert(pname.to_string(), pkind.to_string());
     }
     const GHOST_PERIS: &[&str] = &[
         "GPIOA",
@@ -1169,15 +1162,7 @@ fn process_core(
             continue;
         }
 
-        let addr = if (chip_name.starts_with("STM32F0")
+        let addr = if let Some(cap) = regex!(r"^FDCANRAM(?P<idx>[0-9]+)$").captures(&pname) {
-            || chip_name.starts_with("STM32L1")
-            || chip_name.starts_with("STM32L0"))
-            && pname == "ADC"
-        {
-            defines.get_peri_addr("ADC1")
-        } else if chip_name.starts_with("STM32H7") && pname == "HRTIM" {
-            defines.get_peri_addr("HRTIM1")
-        } else if let Some(cap) = regex!(r"^FDCANRAM(?P<idx>[0-9]+)$").captures(&pname) {
             defines.get_peri_addr("FDCANRAM").map(|addr| {
                 if chip_name.starts_with("STM32H7") {
                     addr
@@ -1192,10 +1177,7 @@ fn process_core(
             defines.get_peri_addr(&pname)
         };
 
-        let addr = match addr {
+        let Some(addr) = addr else { continue };
-            Some(addr) => addr,
-            None => continue,
-        };
 
         let mut p = stm32_data_serde::chip::core::Peripheral {
             name: if pname == "SBS" {

stm32-data-gen/src/dma.rs

@@ -2,6 +2,8 @@ use std::collections::HashMap;
 
 use anyhow::Context;
 
+use crate::normalize_peris::normalize_peri_name;
+
 mod xml {
     use serde::Deserialize;
 
@@ -150,7 +152,7 @@ impl DmaChannels {
                                 };
                                 chip_dma
                                     .peripherals
-                                    .entry(target_peri_name.to_string())
+                                    .entry(normalize_peri_name(target_peri_name).to_string())
                                     .or_default()
                                     .push(stm32_data_serde::chip::core::peripheral::DmaChannel {
                                         signal: request.to_string(),
@@ -270,7 +272,7 @@ impl DmaChannels {
                                     };
                                     chip_dma
                                         .peripherals
-                                        .entry(target_peri_name.to_string())
+                                        .entry(normalize_peri_name(target_peri_name).to_string())
                                         .or_default()
                                         .push(entry);
                                 }
@@ -320,7 +322,7 @@ impl DmaChannels {
                 };
                 chip_dma
                     .peripherals
-                    .entry(target_peri_name.to_string())
+                    .entry(normalize_peri_name(target_peri_name).to_string())
                     .or_default()
                     .push(stm32_data_serde::chip::core::peripheral::DmaChannel {
                         signal: request.to_string(),

stm32-data-gen/src/gpio_af.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 
+use crate::normalize_peris::normalize_peri_name;
 use crate::regex;
 
 mod xml {
@@ -121,6 +122,6 @@ pub fn parse_signal_name(signal_name: &str) -> Option<(&str, &str)> {
 
         Some((peri_name, signal_name.strip_suffix("OUT").unwrap_or(signal_name)))
     } else {
-        Some((peri_name, signal_name))
+        Some((normalize_peri_name(peri_name), signal_name))
     }
 }

stm32-data-gen/src/header.rs

@@ -175,6 +175,7 @@ impl Defines {
                 &["OCTOSPI2_R_BASE", "OCTOSPI2_R_BASE_NS", "OCTOSPI2_REG_BASE"],
             ),
             ("FLASH", &["FLASH_R_BASE", "FLASH_REG_BASE"]),
+            ("ADC", &["ADC1_BASE", "ADC_BASE"]),
             (
                 "ADC_COMMON",
                 &["ADC_COMMON", "ADC1_COMMON", "ADC12_COMMON", "ADC123_COMMON"],

stm32-data-gen/src/interrupts.rs

@@ -3,6 +3,7 @@ use std::collections::{HashMap, HashSet};
 use log::*;
 
 use crate::chips::ChipGroup;
+use crate::normalize_peris::normalize_peri_name;
 use crate::regex;
 
 mod xml {
@@ -342,6 +343,7 @@ impl ChipInterrupts {
             }
 
             for (p, s) in interrupt_signals {
+                let p = normalize_peri_name(&p).to_string();
                 let signals = chip_signals.entry(p).or_default();
                 let irqs = signals.entry(s).or_default();
                 irqs.insert(header_name.clone());

stm32-data-gen/src/main.rs

@@ -5,6 +5,7 @@ mod gpio_af;
 mod header;
 mod interrupts;
 mod memory;
+mod normalize_peris;
 mod rcc;
 mod registers;
 

stm32-data-gen/src/normalize_peris.rs

@@ -0,0 +1,14 @@
+#[rustfmt::skip]
+static NORMALIZE: &[(&str, &str)] = &[
+    ("HRTIM", "HRTIM1"),
+    ("HDMI_CEC", "CEC"),
+    ("SUBGHZ", "SUBGHZSPI"),
+    ("USB_DRD_FS", "USB"),
+];
+
+pub fn normalize_peri_name(name: &str) -> &str {
+    if let Some((_, res)) = NORMALIZE.iter().find(|(n, _)| *n == name) {
+        return res;
+    }
+    return name;
+}