Add support for extracting EEPROM size

dbrgn · dbrgn · commit 0ed91113675a · 2020-12-08T23:41:59.000+01:00
diff --git a/README.md b/README.md
@@ -2,7 +2,9 @@
 
 [![Build Status][github-actions-badge]][github-actions]
 
-A program to extract AF modes on MCU pins from the database files provided with STM32CubeMX.
+A program to extract hardware configuration information from the MCU database
+files shipped with STM32CubeMX.
+
 
 ## Usage
 
@@ -32,10 +34,6 @@ are available:
 * STM32MP1
 * STM32WB
 
-The program will output one AF mode definition per GPIO variant, with a
-corresponding feature gate.
-
-More on the generated feature groups can be found below.
 
 ## The STM32CubeMX Database
 
@@ -160,7 +158,8 @@ As you can see, this element describes the pin `PB6`. Depending on the chosen
 Alternative Function (AF), it can become an `I2C1_SCL` pin (AF1), a `USART1_TX`
 pin (AF0), or some other variants.
 
-## Feature Groups
+
+## GPIO Feature Groups
 
 When generating pin function mappings, we want to avoid generating a mapping
 for every possible MCU, since that would result in dozens or even hundreds of
@@ -212,6 +211,7 @@ In order to simplify the GPIO IP version selection for the user, alias features
 are generated. These are purely a convenience for the user and are never used
 directly as feature gates in the source code.
 
+
 <!-- Badges -->
 [github-actions]: https://github.com/dbrgn/cube-parse/actions?query=branch%3Amaster
 [github-actions-badge]: https://github.com/dbrgn/cube-parse/workflows/CI/badge.svg
diff --git a/src/main.rs b/src/main.rs
@@ -12,8 +12,9 @@ mod utils;
 
 #[derive(Debug, PartialEq)]
 enum GenerateTarget {
-    PinMappings,
     Features,
+    PinMappings,
+    EepromSizes,
 }
 
 lazy_static! {
@@ -31,6 +32,11 @@ fn gpio_version_to_feature(version: &str) -> Result<String, String> {
     }
 }
 
+/// Get the EEPROM size (in KiB) feature for a certain size.
+fn eeprom_size_to_feature(size: u32) -> String {
+    format!("eeprom-{}", size)
+}
+
 fn main() -> Result<(), String> {
     let args = App::new("cube-parse")
         .version(env!("CARGO_PKG_VERSION"))
@@ -47,7 +53,7 @@ fn main() -> Result<(), String> {
             Arg::with_name("generate")
                 .help("What to generate")
                 .takes_value(true)
-                .possible_values(&["pin_mappings", "features"])
+                .possible_values(&["features", "pin_mappings", "eeprom_sizes"])
                 .required(true),
         )
         .arg(
@@ -62,8 +68,9 @@ fn main() -> Result<(), String> {
     let db_dir = Path::new(args.value_of("db_dir").unwrap());
     let mcu_family = args.value_of("mcu_family").unwrap();
     let generate = match args.value_of("generate").unwrap() {
-        "pin_mappings" => GenerateTarget::PinMappings,
         "features" => GenerateTarget::Features,
+        "pin_mappings" => GenerateTarget::PinMappings,
+        "eeprom_sizes" => GenerateTarget::EepromSizes,
         _ => unreachable!(),
     };
 
@@ -79,39 +86,68 @@ fn main() -> Result<(), String> {
 
     // MCU map
     //
+    // This maps a MCU ref name to the corresponding `mcu::Mcu` instance.
+    let mut mcu_map: HashMap<String, mcu::Mcu> = HashMap::new();
+
+    // GPIO map
+    //
     // The keys of this map are GPIO peripheral version strings (e.g.
     // "STM32L051_gpio_v1_0"), while the value is a Vec of MCU ref names.
     let mut mcu_gpio_map: HashMap<String, Vec<String>> = HashMap::new();
 
     // Package map
     //
-    // The keys of this map are MCU ref names, the values are package names
-    // (e.g. ).
+    // The keys of this map are MCU ref names, the values are package names.
     let mut mcu_package_map: HashMap<String, String> = HashMap::new();
 
+    // EEPROM size map
+    //
+    // The keys of this map are EEPROM sizes in KiB, the values are Vecs of MCU ref names.
+    let mut mcu_eeprom_size_map: HashMap<u32, Vec<String>> = HashMap::new();
+
+    // Iterate through subfamilies, then through MCUs. Fill the maps above with
+    // aggregated data.
     for sf in family {
         for mcu in sf {
+            // Load MCU data from the XML files
             let mcu_dat = mcu::Mcu::load(&db_dir, &mcu.name)
                 .map_err(|e| format!("Could not load MCU data: {}", e))?;
 
+            // Fill GPIO map
             let gpio_version = mcu_dat.get_ip("GPIO").unwrap().get_version().to_string();
             mcu_gpio_map
                 .entry(gpio_version)
                 .or_insert(vec![])
                 .push(mcu.ref_name.clone());
 
+            // Fill package map
             if mcu_family == "STM32L0" {
                 // The stm32l0xx-hal has package based features
                 mcu_package_map.insert(mcu.ref_name.clone(), mcu.package_name.clone());
             }
+
+            // Fill EEPROM size map
+            if let Some(size) = mcu_dat.get_eeprom_size_kib() {
+                mcu_eeprom_size_map
+                    .entry(size)
+                    .or_insert(vec![])
+                    .push(mcu.ref_name.clone());
+            }
+
+            mcu_map.insert(mcu.ref_name.clone(), mcu_dat);
         }
     }
 
     match generate {
-        GenerateTarget::Features => {
-            generate_features(&mcu_gpio_map, &mcu_package_map, &mcu_family)?
-        }
+        GenerateTarget::Features => generate_features(
+            &mcu_map,
+            &mcu_gpio_map,
+            &mcu_package_map,
+            &mcu_eeprom_size_map,
+            &mcu_family,
+        )?,
         GenerateTarget::PinMappings => generate_pin_mappings(&mcu_gpio_map, &db_dir)?,
+        GenerateTarget::EepromSizes => generate_eeprom_sizes(&mcu_eeprom_size_map)?,
     };
 
     Ok(())
@@ -132,31 +168,67 @@ lazy_static! {
     };
 }
 
-/// Print the IO features, followed by MCU features that act purely as aliases
-/// for the IO features.
+/// Generate all Cargo features
 ///
-/// Both lists are sorted alphanumerically.
+/// Feature categories:
+///
+/// - IO features (`io-*`)
+/// - EEPROM features (`eeprom-*`)
+///
+/// Finally, the MCU features are printed, they act purely as aliases for the
+/// other features.
 fn generate_features(
+    mcu_map: &HashMap<String, mcu::Mcu>,
     mcu_gpio_map: &HashMap<String, Vec<String>>,
     mcu_package_map: &HashMap<String, String>,
+    mcu_eeprom_size_map: &HashMap<u32, Vec<String>>,
     mcu_family: &str,
 ) -> Result<(), String> {
-    let mut main_features = mcu_gpio_map
+    // IO features
+    let mut io_features = mcu_gpio_map
         .keys()
         .map(|gpio| gpio_version_to_feature(gpio))
         .collect::<Result<Vec<String>, String>>()?;
-    main_features.sort();
+    io_features.sort();
+    println!("# Features based on the GPIO peripheral version");
+    println!("# This determines the pin function mapping of the MCU");
+    for feature in io_features {
+        println!("{} = []", feature);
+    }
+    println!();
 
+    // EEPROM sizes
+    let mut eeprom_sizes = mcu_eeprom_size_map.keys().collect::<Vec<_>>();
+    eeprom_sizes.sort();
+    println!("# Features based on EEPROM size (in KiB)");
+    for size in eeprom_sizes {
+        println!("{} = []", eeprom_size_to_feature(*size));
+    }
+    println!();
+
+    // Physical packages
+    if !mcu_package_map.is_empty() {
+        println!("# Physical packages");
+        let mut packages = mcu_package_map
+            .values()
+            .map(|v| v.to_lowercase())
+            .collect::<Vec<_>>();
+        packages.sort_by(|a, b| compare_str(a, b));
+        packages.dedup();
+        for pkg in packages {
+            println!("{} = []", pkg);
+        }
+        println!();
+    }
+
+    // MCU features
     let mut mcu_aliases = vec![];
     for (gpio, mcu_list) in mcu_gpio_map {
         let gpio_version_feature = gpio_version_to_feature(gpio).unwrap();
         for mcu in mcu_list {
             let mut dependencies = vec![];
 
-            // GPIO version feature
-            dependencies.push(gpio_version_feature.clone());
-
-            // Additional dependencies
+            // Static feature dependencies
             if let Some(family) = FEATURE_DEPENDENCIES.get(mcu_family) {
                 for (pattern, feature) in family {
                     if Regex::new(pattern).unwrap().is_match(&mcu) {
@@ -171,10 +243,17 @@ fn generate_features(
                 dependencies.push(package.to_lowercase());
             }
 
-            let mcu_feature = format!("mcu-{}", mcu);
+            // GPIO version feature
+            dependencies.push(gpio_version_feature.clone());
+
+            // EEPROM size
+            if let Some(size) = mcu_map.get(mcu).unwrap().get_eeprom_size_kib() {
+                dependencies.push(eeprom_size_to_feature(size));
+            }
+
             mcu_aliases.push(format!(
-                "{} = [{}]",
-                mcu_feature,
+                "mcu-{} = [{}]",
+                mcu,
                 &dependencies.iter().map(|val| format!("\"{}\"", val)).fold(
                     String::new(),
                     |mut acc, x| {
@@ -189,27 +268,12 @@ fn generate_features(
         }
     }
     mcu_aliases.sort();
-
-    println!("# Features based on the GPIO peripheral version");
-    println!("# This determines the pin function mapping of the MCU");
-    for feature in main_features {
-        println!("{} = []", feature);
-    }
-    println!();
-    if !mcu_package_map.is_empty() {
-        println!("# Physical packages");
-        let mut packages = mcu_package_map
-            .values()
-            .map(|v| v.to_lowercase())
-            .collect::<Vec<_>>();
-        packages.sort_by(|a, b| compare_str(a, b));
-        packages.dedup();
-        for pkg in packages {
-            println!("{} = []", pkg);
-        }
-        println!();
-    }
-    println!("# MCUs");
+    println!("# MCU aliases");
+    println!("#");
+    println!("# Note: These are just aliases, they should not be used to directly feature gate");
+    println!(
+        "# functionality in the HAL! However, user code should usually depend on a MCU alias."
+    );
     for alias in mcu_aliases {
         println!("{}", alias);
     }
@@ -235,6 +299,16 @@ fn generate_pin_mappings(
     Ok(())
 }
 
+/// Generate code containing the EEPROM size.
+fn generate_eeprom_sizes(mcu_eeprom_size_map: &HashMap<u32, Vec<String>>) -> Result<(), String> {
+    println!("// EEPROM sizes in KiB, generated with cube-parse");
+    for size in mcu_eeprom_size_map.keys() {
+        println!("#[cfg({})]", eeprom_size_to_feature(*size));
+        println!("const EEPROM_SIZE_KIB: u32 = {};", size);
+    }
+    Ok(())
+}
+
 fn render_pin_modes(ip: &internal_peripheral::IpGPIO) {
     let mut pin_map: HashMap<String, Vec<String>> = HashMap::new();
 
diff --git a/src/mcu.rs b/src/mcu.rs
@@ -9,6 +9,8 @@ use crate::utils::load_file;
 pub struct Mcu {
     #[serde(rename = "IP", default)]
     ip: Vec<IP>,
+    #[serde(rename = "E2prom")]
+    eeprom_size_kib: String,
 }
 
 impl Mcu {
@@ -19,6 +21,11 @@ impl Mcu {
     pub fn get_ip(&self, name: &str) -> Option<&IP> {
         self.ip.iter().find(|v| v.name == name)
     }
+
+    /// Return the EEPROM size in KiB
+    pub fn get_eeprom_size_kib(&self) -> Option<u32> {
+        self.eeprom_size_kib.parse().ok()
+    }
 }
 
 #[derive(Debug, Deserialize)]

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ use crate::utils::load_file;`
`9`	`9`	`pub struct Mcu {`
`10`	`10`	`#[serde(rename = "IP", default)]`
`11`	`11`	`ip: Vec<IP>,`
	`12`	`+ #[serde(rename = "E2prom")]`
	`13`	`+ eeprom_size_kib: String,`
`12`	`14`	`}`
`13`	`15`
`14`	`16`	`impl Mcu {`
`@@ -19,6 +21,11 @@ impl Mcu {`
`19`	`21`	`pub fn get_ip(&self, name: &str) -> Option<&IP> {`
`20`	`22`	`self.ip.iter().find(\|v\| v.name == name)`
`21`	`23`	`}`
	`24`	`+`
	`25`	`+ /// Return the EEPROM size in KiB`
	`26`	`+ pub fn get_eeprom_size_kib(&self) -> Option<u32> {`
	`27`	`+ self.eeprom_size_kib.parse().ok()`
	`28`	`+ }`
`22`	`29`	`}`
`23`	`30`
`24`	`31`	`#[derive(Debug, Deserialize)]`