Refactor STM32H753 GPIO configuration printing support to a module.

Applied several suggestions from Matt.

    Co-authored-by: Matt Keeter <matt@oxide.computer>

Author: lzrd

Cargo.toml

@@ -101,7 +101,6 @@ tlvc-text = {git = "https://github.com/oxidecomputer/tlvc"}
 vsc7448-info = { git = "https://github.com/oxidecomputer/vsc7448.git" }
 vsc7448-types = { git = "https://github.com/oxidecomputer/vsc7448.git" }
 ipcc-data = { git = "https://github.com/oxidecomputer/ipcc-rs" }
-stm32h7 = { version = "0.14", default-features = false }
 
 #
 # We depend on the oxide-stable branch of Oxide's fork of probe-rs to assure
@@ -248,6 +247,7 @@ serde-xml-rs = "0.5.1"
 sha2 = "0.10.1"
 splitty = "0.1.0"
 srec = "0.2"
+stm32h7 = { version = "0.14", features = ["stm32h753"] }
 strum = "0.22"
 strum_macros = "0.22"
 syn = "1.0"

cmd/gpio/Cargo.toml

@@ -10,7 +10,7 @@ clap.workspace = true
 anyhow.workspace = true
 parse_int.workspace = true
 lazy_static.workspace = true
-stm32h7 = { workspace = true, features = ["rt", "stm32h753"] }
+stm32h7.workspace = true
 zerocopy.workspace = true
 
 humility-cli.workspace = true

cmd/gpio/src/lib.rs

@@ -73,8 +73,8 @@
 //! Port J    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
 //! Port K    0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
 //! ```
-//! To get input values with GPIO configuration settings,
-//! use the --with-config or -w flag with --input:
+//! To get input values with STM32H753 GPIO configuration settings,
+//! use the `--with-config` or `-w` flag with --input:
 //!
 //! ```console
 //! $ humility gpio --input -with-config --pins B:0,B:14,E:1
@@ -85,7 +85,7 @@
 //! ```
 //!
 //! If no pins are specified, then the pin names, values and config settings
-//! are printeed one per line for all GPIO pins.
+//! are printed one per line for all GPIO pins.
 //!
 //! ### Configure
 //!
@@ -105,15 +105,39 @@
 //! ```
 //!
 
+mod stm32h753;
+
 use humility_cli::{ExecutionContext, Subcommand};
 use humility_cmd::{Archive, Attach, Command, CommandKind, Validate};
-use humility_hiffy::{HiffyContext, IpcError};
-use std::mem::MaybeUninit;
-use std::str;
+use humility_hiffy::HiffyContext;
 
 use anyhow::{anyhow, bail, Result};
 use clap::{CommandFactory, Parser};
 use hif::*;
+use humility_hiffy::IpcError;
+
+fn show_gpio_with_config(
+    context: &mut ExecutionContext,
+    gpio_input: &humility_hiffy::HiffyFunction,
+    args: &[(u16, Option<u8>, String)],
+    results: &[Result<Vec<u8>, IpcError>],
+) -> Result<()> {
+    let hubris = context.archive.as_ref().unwrap();
+    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}'")),
+        }
+    } else {
+        Err(anyhow!(
+            "GPIO `--with-config` is not supported when chip is not specified"
+        ))
+    }
+}
+
 
 use std::convert::TryInto;
 
@@ -167,251 +191,6 @@ struct GpioArgs {
     pins: Option<Vec<String>>,
 }
 
-use device::gpioa::RegisterBlock;
-use humility_hiffy::HiffyFunction;
-use lazy_static::lazy_static;
-use std::collections::BTreeMap;
-use std::ops::RangeInclusive;
-use stm32h7::stm32h753 as device;
-
-lazy_static! {
-    static ref GPIO_REGISTERS: BTreeMap<&'static str, RangeInclusive<u32>> = {
-        let mut map = BTreeMap::new();
-        // Section 11.4: GPIO registers
-        map.insert("A", 0x58020000..=0x580203FF);
-        map.insert("B", 0x58020400..=0x580207FF);
-        map.insert("C", 0x58020800..=0x58020BFF);
-        map.insert("D", 0x58020C00..=0x58020FFF);
-        map.insert("E", 0x58021000..=0x580213FF);
-        map.insert("F", 0x58021400..=0x580217FF);
-        map.insert("G", 0x58021800..=0x58021BFF);
-        map.insert("H", 0x58021C00..=0x58021FFF);
-        map.insert("I", 0x58022000..=0x580223FF);
-        map.insert("J", 0x58022400..=0x580227FF);
-        map.insert("K", 0x58022800..=0x58022BFF);
-        map
-    };
-}
-
-// This is a hack.
-struct PinConfig {
-    mode: String,
-    otype: String,
-    speed: String,
-    pull: String,
-    input: String,
-    output: String,
-    lock: String,
-    alternate: String,
-}
-
-use std::fmt;
-
-impl fmt::Display for PinConfig {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Use the write! macro to format the output to the formatter 'f'
-        write!(
-            f,
-            "{}:{}:{}:{}:{}:{}:{}:{}",
-            self.mode,
-            self.otype,
-            self.speed,
-            self.pull,
-            self.alternate,
-            self.lock,
-            self.input,
-            self.output
-        )
-    }
-}
-
-struct ConfigCache {
-    cache: BTreeMap<String, RegisterBlock>,
-}
-
-impl ConfigCache {
-    fn new() -> ConfigCache {
-        let cache: BTreeMap<String, RegisterBlock> = BTreeMap::new();
-        Self { cache }
-    }
-
-    fn get_pin_config(
-        &mut self,
-        context: &mut ExecutionContext,
-        group: &str,
-        pin: u32,
-    ) -> Result<PinConfig> {
-        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()
-            }
-            Some(rb) => rb,
-        };
-
-        let reg = rb.moder.read().bits();
-        let mode = match (reg >> (pin * 2)) & 3 {
-            0 => "Input",
-            1 => "Output",
-            2 => "Alternate",
-            3 => "Analog",
-            _ => unreachable!(),
-        };
-
-        let reg = rb.otyper.read().bits();
-        let otype = match (reg >> pin) & 1 {
-            0 => "OutPushPull",
-            1 => "OutOpenDrain",
-            _ => unreachable!(),
-        };
-
-        let reg = rb.ospeedr.read().bits();
-        let speed = match (reg >> (pin * 2)) & 3 {
-            0 => "LowSpeed",
-            1 => "MediumSpeed",
-            2 => "HighSpeed",
-            3 => "VeryHighSpeed",
-            _ => unreachable!(),
-        };
-
-        let reg = rb.pupdr.read().bits();
-        let pull = match (reg >> (pin * 2)) & 3 {
-            0 => "NoPull",
-            1 => "PullUp",
-            2 => "PullDown",
-            3 => "ReservedPull",
-            _ => unreachable!(),
-        };
-
-        let reg = rb.idr.read().bits();
-        let input = match (reg >> pin) & 1 {
-            0 => "InZero",
-            1 => "InOne",
-            _ => unreachable!(),
-        };
-
-        let reg = rb.odr.read().bits();
-        let output = match (reg >> pin) & 1 {
-            0 => "OutZero",
-            1 => "OutOne",
-            _ => unreachable!(),
-        };
-
-        // Note: Bit 16 indicates that the register is locked or unlocked.
-        let reg = rb.lckr.read().bits();
-        let lock = match (reg >> pin) & 1 {
-            0 => "Unlocked",
-            1 => "Locked",
-            _ => unreachable!(),
-        };
-
-        let alternate = format!(
-            "AF{}",
-            if pin < 8 {
-                let reg = rb.afrl.read().bits();
-                (reg >> (pin * 4)) & 15
-            } else {
-                let reg = rb.afrh.read().bits();
-                (reg >> ((pin - 8) * 4)) & 15
-            }
-        );
-
-        Ok(PinConfig {
-            mode: mode.to_string(),
-            otype: otype.to_string(),
-            speed: speed.to_string(),
-            pull: pull.to_string(),
-            input: input.to_string(),
-            output: output.to_string(),
-            lock: lock.to_string(),
-            alternate,
-        })
-    }
-}
-
-fn read_gpio_register_block(
-    context: &mut ExecutionContext,
-    group: &str,
-) -> Result<RegisterBlock> {
-    let core = &mut **context.core.as_mut().unwrap();
-    let span = GPIO_REGISTERS
-        .get(group)
-        .ok_or(anyhow!("no address for GPIO group {}", group))?;
-    let mut buffer = vec![0u8; std::mem::size_of::<RegisterBlock>()];
-    core.read_8(*span.start(), &mut buffer)?;
-
-    let mut rb: MaybeUninit<RegisterBlock> = MaybeUninit::uninit();
-    // let ptr: *mut u8 = rb.as_mut_ptr() as *mut u8;
-    unsafe {
-        // Get a mutable pointer to the allocated memory
-        let dest_ptr = rb.as_mut_ptr() as *mut u8;
-
-        // Copy the raw bytes into the struct's memory location
-        // Ensure the size of raw_bytes matches the size of MyStruct
-        // to avoid out-of-bounds access.
-        std::ptr::copy_nonoverlapping(buffer.as_ptr(), dest_ptr, buffer.len());
-
-        Ok(rb.assume_init())
-    }
-}
-
-fn show_gpio_with_config(
-    context: &mut ExecutionContext,
-    gpio_input: &HiffyFunction,
-    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)?;
-                println!(
-                    "{}:{:<2} = {} {}",
-                    arg.2,
-                    pin,
-                    match results[ndx] {
-                        Err(code) => {
-                            gpio_input.strerror(code)
-                        }
-                        Ok(ref val) => {
-                            let arr: &[u8; 2] = val[0..2].try_into()?;
-                            let v = u16::from_le_bytes(*arr);
-                            format!("{}", (v >> pin) & 1)
-                        }
-                    },
-                    config
-                );
-            }
-
-            None => match results[ndx] {
-                Err(code) => {
-                    println!("Port {}: {}", arg.2, gpio_input.strerror(code))
-                }
-                Ok(ref val) => {
-                    let arr: &[u8; 2] = val[0..2].try_into()?;
-                    let v = u16::from_le_bytes(*arr);
-
-                    for i in 0..16 {
-                        let config = config_cache
-                            .get_pin_config(context, &arg.2, i as u32)?;
-                        println!(
-                            "{}:{:<2} = {} ({})",
-                            arg.2,
-                            i,
-                            (v >> i) & 1,
-                            config
-                        );
-                    }
-                }
-            },
-        }
-    }
-    Ok(())
-}
-
 fn gpio(context: &mut ExecutionContext) -> Result<()> {
     let core = &mut **context.core.as_mut().unwrap();
     let Subcommand::Other(subargs) = context.cli.cmd.as_ref().unwrap();
@@ -526,8 +305,7 @@ fn gpio(context: &mut ExecutionContext) -> Result<()> {
         let mut header = false;
 
         if subargs.with_config {
-            let _ =
-                show_gpio_with_config(context, &gpio_input, &args, &results);
+            show_gpio_with_config(context, &gpio_input, &args, &results)?;
         } else {
             for (ndx, arg) in args.iter().enumerate() {
                 match arg.1 {