Generalize to support STM32H743 and emit errors for unknown chips.

Author: lzrd

cmd/gpio/src/lib.rs

@@ -105,7 +105,7 @@
 //! ```
 //!
 
-mod stm32h753;
+mod stm32h7;
 
 use humility_cli::{ExecutionContext, Subcommand};
 use humility_cmd::{Archive, Attach, Command, CommandKind, Validate};
@@ -122,14 +122,24 @@ fn show_gpio_with_config(
     args: &[(u16, Option<u8>, String)],
     results: &[Result<Vec<u8>, IpcError>],
 ) -> Result<()> {
-    let hubris = context.archive.as_ref().unwrap();
+    let hubris = context
+        .archive
+        .as_ref()
+        .ok_or_else(|| anyhow!("Cannot get GPIO config: archive not loaded"))?;
     if let Some(chip) = hubris.chip() {
-        match chip.as_str() {
-            "stm32h7" => {
-                // Call the stm32h753-specific function
-                stm32h753::show_gpio_with_config(context, gpio_input, args, results)
-            }
-            _ => Err(anyhow!("GPIO `--with-config` is not supported for chip '{chip}'")),
+        if chip.to_ascii_lowercase().starts_with("stm32h7") {
+            // Call the stm32h7-specific function
+            stm32h7::show_gpio_with_config(
+                context,
+                gpio_input,
+                chip.as_str(),
+                args,
+                results,
+            )
+        } else {
+            Err(anyhow!(
+                "GPIO `--with-config` is not supported for chip '{chip}'"
+            ))
         }
     } else {
         Err(anyhow!(
@@ -138,7 +148,6 @@ fn show_gpio_with_config(
     }
 }
 
-
 use std::convert::TryInto;
 
 #[derive(Parser, Debug)]

cmd/gpio/src/stm32h753.rs cmd/gpio/src/stm32h7.rscmd/gpio/src/stm32h753.rs renamed to cmd/gpio/src/stm32h7.rs

@@ -1,9 +1,13 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use anyhow::{anyhow, Result};
 use humility_cli::ExecutionContext;
 use humility_hiffy::IpcError;
-use std::mem::MaybeUninit;
 use std::fmt;
-use anyhow::{anyhow, Result};
- 
+use std::mem::MaybeUninit;
+
 use device::gpioa::RegisterBlock;
 use humility_hiffy::HiffyFunction;
 use std::collections::BTreeMap;
@@ -38,27 +42,30 @@ impl fmt::Display for PinConfig {
     }
 }
 
+/// Store an STM32H7 GPIO group ID ('A', 'B', etc.) and the associated GPIO
+/// configuration register block to avoid repeated IO for each Pin.
 struct ConfigCache {
-    cache: BTreeMap<String, RegisterBlock>,
+    cache: BTreeMap<char, RegisterBlock>,
 }
 
 impl ConfigCache {
     fn new() -> ConfigCache {
-        let cache: BTreeMap<String, RegisterBlock> = BTreeMap::new();
+        let cache: BTreeMap<char, RegisterBlock> = BTreeMap::new();
         Self { cache }
     }
 
     fn get_pin_config(
         &mut self,
         context: &mut ExecutionContext,
-        group: &str,
+        chip: &str,
+        group: char,
         pin: u32,
     ) -> Result<PinConfig> {
-        let rb = match self.cache.get(group) {
+        let rb = match self.cache.get(&group) {
             None => {
-                let rb = read_gpio_register_block(context, group)?;
-                self.cache.insert(group.to_string(), rb);
-                self.cache.get(group).unwrap()
+                let rb = read_gpio_register_block(context, chip, group)?;
+                self.cache.insert(group, rb);
+                self.cache.get(&group).unwrap()
             }
             Some(rb) => rb,
         };
@@ -143,30 +150,52 @@ impl ConfigCache {
     }
 }
 
-fn stm32h753_gpio_registerblock_addr(group: &str) -> Option<u32> {
+/// Lookup STM32H7 GPIO configuration register addresses.
+fn stm32h753_gpio_registerblock_addr(group: char) -> Option<u32> {
     // Section 11.4: GPIO registers
     match group {
-        "A" => Some(device::GPIOA::ptr() as u32),
-        "B" => Some(device::GPIOB::ptr() as u32),
-        "C" => Some(device::GPIOC::ptr() as u32),
-        "D" => Some(device::GPIOD::ptr() as u32),
-        "E" => Some(device::GPIOE::ptr() as u32),
-        "F" => Some(device::GPIOF::ptr() as u32),
-        "G" => Some(device::GPIOG::ptr() as u32),
-        "H" => Some(device::GPIOH::ptr() as u32),
-        "I" => Some(device::GPIOI::ptr() as u32),
-        "J" => Some(device::GPIOJ::ptr() as u32),
-        "K" => Some(device::GPIOK::ptr() as u32),
+        'A' => Some(device::GPIOA::ptr() as u32),
+        'B' => Some(device::GPIOB::ptr() as u32),
+        'C' => Some(device::GPIOC::ptr() as u32),
+        'D' => Some(device::GPIOD::ptr() as u32),
+        'E' => Some(device::GPIOE::ptr() as u32),
+        'F' => Some(device::GPIOF::ptr() as u32),
+        'G' => Some(device::GPIOG::ptr() as u32),
+        'H' => Some(device::GPIOH::ptr() as u32),
+        'I' => Some(device::GPIOI::ptr() as u32),
+        'J' => Some(device::GPIOJ::ptr() as u32),
+        'K' => Some(device::GPIOK::ptr() as u32),
         _ => None,
     }
 }
 
+// Several other STM32 families share the same GPIO register format as the
+// STM32H7 series:
+//   - STM32F7 series
+//   - STM32G4 series
+// Support for those chips can be added if needed.
+// Note: verify that the non-STM32H7 series are using the same addressing or adapt.
+fn chip_has_group(chip: &str, group: char) -> Result<bool> {
+    let name = chip.to_ascii_lowercase();
+
+    if name.starts_with("stm32h753") {
+        Ok(matches!(group, 'A'..='K'))
+    } else if name.starts_with("stm32h743") {
+        Ok(matches!(group, 'A'..='I'))
+    } else {
+        Err(anyhow!("unknown STM32H7 chip '{}'", chip))
+    }
+}
+
 fn read_gpio_register_block(
     context: &mut ExecutionContext,
-    group: &str,
+    chip: &str,
+    group: char,
 ) -> Result<RegisterBlock> {
     let core = &mut **context.core.as_mut().unwrap();
-    let addr = stm32h753_gpio_registerblock_addr(group).ok_or(anyhow!("no address for GPIO group {}", group))?;
+    chip_has_group(chip, group)?;
+    let addr = stm32h753_gpio_registerblock_addr(group)
+        .ok_or(anyhow!("no address for GPIO group {}", group))?;
     let mut buffer = vec![0u8; std::mem::size_of::<RegisterBlock>()];
     core.read_8(addr, &mut buffer)?;
 
@@ -183,15 +212,21 @@ fn read_gpio_register_block(
 pub fn show_gpio_with_config(
     context: &mut ExecutionContext,
     gpio_input: &HiffyFunction,
+    chip: &str,
     args: &[(u16, Option<u8>, String)],
     results: &[Result<Vec<u8>, IpcError>],
 ) -> Result<()> {
     let mut config_cache = ConfigCache::new();
     for (ndx, arg) in args.iter().enumerate() {
         match arg.1 {
             Some(pin) => {
-                let config =
-                    config_cache.get_pin_config(context, &arg.2, pin as u32)?;
+                let group = arg
+                    .2
+                    .chars()
+                    .next()
+                    .ok_or(anyhow!("invalid group '{}'", arg.2))?;
+                let config = config_cache
+                    .get_pin_config(context, chip, group, pin as u32)?;
                 println!(
                     "{}:{:<2} = {} {}",
                     arg.2,
@@ -219,8 +254,13 @@ pub fn show_gpio_with_config(
                     let v = u16::from_le_bytes(*arr);
 
                     for i in 0..16 {
+                        let group = arg
+                            .2
+                            .chars()
+                            .next()
+                            .ok_or(anyhow!("invalid group '{}'", arg.2))?;
                         let config = config_cache
-                            .get_pin_config(context, &arg.2, i as u32)?;
+                            .get_pin_config(context, chip, group, i as u32)?;
                         println!(
                             "{}:{:<2} = {} {}",
                             arg.2,