WIP: PMBus Status Registers via MGS

build/i2c/src/lib.rs

@@ -1381,6 +1381,8 @@ impl ConfigGenerator {
             all.sort();
 
             for (rail, (device, index)) in &all {
+                // if we update this code to be more clever than just to-lowercase'ing the rail names,
+                // you might need to go update the mapping in `validate-api`!
                 write!(
                     &mut self.output,
                     r##"
@@ -1776,6 +1778,7 @@ pub fn codegen(settings: impl Into<CodegenSettings>) -> Result<()> {
     Ok(())
 }
 
+#[derive(Debug, Clone)]
 pub struct I2cDeviceDescription {
     pub device: String,
     pub description: String,

drv/i2c-devices/src/lib.rs

@@ -66,22 +66,29 @@ macro_rules! pmbus_read {
 }
 
 macro_rules! pmbus_rail_read {
-    ($device:expr, $rail:expr, $cmd:ident) => {
+    (@raw => $device:expr, $rail:expr, $cmd_code:expr, $len:expr) => {
         $device
-            .write_read_reg::<u8, [u8; $cmd::CommandData::len()]>(
-                $cmd::CommandData::code(),
+            .write_read_reg::<u8, [u8; $len]>(
+                $cmd_code,
                 &[PAGE::CommandData::code(), $rail],
             )
             .map_err(|code| Error::BadRead {
-                cmd: $cmd::CommandData::code(),
+                cmd: $cmd_code,
                 code,
             })
+    };
+
+    ($device:expr, $rail:expr, $cmd:ident) => {{
+        let cmd_code = $cmd::CommandData::code();
+        const CMD_LEN: usize = $cmd::CommandData::len();
+
+        pmbus_rail_read!(@raw => $device, $rail, cmd_code, CMD_LEN)
             .and_then(|rval| {
                 $cmd::CommandData::from_slice(&rval).ok_or(Error::BadData {
                     cmd: $cmd::CommandData::code(),
                 })
             })
-    };
+    }};
 
     ($device:expr, $rail:expr, $dev:ident::$cmd:ident) => {{
         use $dev::{PAGE, $cmd};
@@ -271,6 +278,52 @@ pub trait Validate<T: core::convert::Into<drv_i2c_api::ResponseCode>> {
     }
 }
 
+// grumble grumble, copied from `gateway_messages::sp_to_mgs::PmbusStatus`
+// grumble grumble, also basically the same as `ereports/src/pwr`
+pub struct PmbusStatus {
+    pub status_word: u16,
+    pub status_vout: u8,
+    pub status_iout: u8,
+    pub status_temperature: u8,
+    pub status_cml: u8,
+    pub status_other: u8,
+    pub status_input: u8,
+    pub status_mfr_specific: u8,
+    pub status_fans_1_2: u8,
+    pub status_fans_3_4: u8,
+}
+
+pub enum PmbusStatusError {
+    BadRead { cmd: u8, code: ResponseCode },
+    BadData { cmd: u8, },
+}
+
+impl PmbusStatus {
+    pub fn read_from(dev: &I2cDevice, rail_idx: u8) -> Result<Self, ()> {
+        use pmbus::commands::*;
+        use PmbusStatusError as Error;
+
+        Ok(PmbusStatus {
+            status_word: pmbus_rail_read!(dev, rail_idx, STATUS_WORD).map_err(drop)?.0,
+            status_vout: pmbus_rail_read!(dev, rail_idx, STATUS_VOUT).map_err(drop)?.0,
+            status_iout: pmbus_rail_read!(dev, rail_idx, STATUS_IOUT).map_err(drop)?.0,
+            status_temperature: pmbus_rail_read!(dev, rail_idx, STATUS_TEMPERATURE).map_err(drop)?.0,
+            status_cml: pmbus_rail_read!(dev, rail_idx, STATUS_CML).map_err(drop)?.0,
+            status_other: pmbus_rail_read!(dev, rail_idx, STATUS_OTHER).map_err(drop)?.0,
+            status_input: pmbus_rail_read!(dev, rail_idx, STATUS_INPUT).map_err(drop)?.0,
+            status_fans_1_2: pmbus_rail_read!(dev, rail_idx, STATUS_FANS_1_2).map_err(drop)?.0,
+            status_fans_3_4: pmbus_rail_read!(dev, rail_idx, STATUS_FANS_3_4).map_err(drop)?.0,
+
+            // Unfortunately, STATUS_MFR_SPECIFIC *is* defined in the pmbus crate, but doesn't have a
+            // "structured" representation, so instead use a raw representation. It *could* be argued
+            // that since we're not actually peeking at any of the introspection stuff, we could do
+            // the same for all the items above, and save ourselved a little indirection, but for now
+            // just hole-punch the minimum amount necessary
+            status_mfr_specific: pmbus_rail_read!(@raw => dev, rail_idx, CommandCode::STATUS_MFR_SPECIFIC as u8, 1).map_err(drop)?[0],
+        })
+    }
+}
+
 pub mod adm127x;
 pub mod adt7420;
 pub mod at24csw080;

task/validate-api/build.rs

@@ -5,6 +5,11 @@
 use std::io::Write;
 
 fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    if let Err(e) = build_i2c::codegen(build_i2c::Disposition::Devices) {
+        println!("cargo::error=failed to generate I2C devices: {e}");
+        std::process::exit(1);
+    }
+
     write_pub_device_descriptions()?;
 
     idol::client::build_client_stub(
@@ -21,7 +26,7 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
     let out_dir = std::env::var("OUT_DIR")?;
     let dest_path =
         std::path::Path::new(&out_dir).join("device_descriptions.rs");
-    let file = std::fs::File::create(dest_path)?;
+    let file = std::fs::File::create(&dest_path)?;
     let mut file = std::io::BufWriter::new(file);
 
     writeln!(
@@ -57,13 +62,14 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
     // key.
     //
     let mut id2idx = std::collections::BTreeMap::new();
+    let mut pmbus_rail_names = std::collections::BTreeSet::new();
 
-    for (idx, dev) in devices.into_iter().enumerate() {
+    for (idx, dev) in devices.iter().cloned().enumerate() {
         let is_pmbus = dev.is_pmbus();
         writeln!(file, "    DeviceDescription {{")?;
         writeln!(file, "        device: {:?},", dev.device)?;
         writeln!(file, "        description: {:?},", dev.description)?;
-        if let Some(id) = dev.device_id {
+        if let Some(ref id) = dev.device_id {
             if let Ok(component) = SpComponent::try_from(id.as_ref()) {
                 writeln!(file, "        id: {:?},", component.id)?;
                 if id2idx.insert(component.id, idx).is_some() {
@@ -77,6 +83,15 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
                 );
                 ids_too_long += 1;
             }
+
+            if let Some(ref pmbus) = dev.pmbus {
+                for rail in pmbus.rails.iter() {
+                    // Returns "is unique", unlike `BTreeMap::insert().is_some()`!
+                    if !pmbus_rail_names.insert(rail.name.clone()) {
+                        panic!("cargo::warn=dupe: {:?}, {:?}", rail.name, dev);
+                    }
+                }
+            }
         } else {
             println!(
                 "cargo::error=device {:?} ({:?}) hath no device ID (refdes)",
@@ -114,6 +129,39 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
     }
     writeln!(file, "];")?;
 
+    let max_len = pmbus_rail_names.iter().map(String::len).max();
+    if let Some(_len) = max_len {
+
+        // TODO: do we need fixed-length bstrings? If we want to binary search, we probably want them to
+        // be truncated to some maximum length, so we either need to define the max length at the
+        // protocol level so mgs knows how long of a string to send us, or we could instead trim the
+        // trailing nulls and search by that instead.
+        //
+        // writeln!(file, "pub const MAX_PMBUS_RAIL_NAME: usize = {len};")?;
+        // writeln!(file, "pub const PMBUS_RAIL_TO_I2C_DEVICE_MAP: [([u8; MAX_PMBUS_RAIL_NAME], fn(TaskId) -> (drv_i2c_api::I2cDevice, u8)); {}] = [", pmbus_rail_names.len())?;
+        // for rail in pmbus_rail_names.iter() {
+        //     write!(file, "    (*b\"{rail}")?;
+        //     for _ in 0..(len.checked_sub(rail.len()).unwrap()) {
+        //         write!(file, "\\0")?;
+        //     }
+        //     write!(file, "\", ")?;
+        //     write!(file, "crate::i2c_config::pmbus::{}", rail.to_lowercase())?;
+        //     writeln!(file, "),")?;
+        // }
+        // writeln!(file, "];")?;
+
+        // Assuming we are going the trimmed route...
+        writeln!(file)?;
+        writeln!(file, "pub const PMBUS_RAIL_TO_I2C_DEVICE_MAP: [(&[u8], fn(TaskId) -> (drv_i2c_api::I2cDevice, u8)); {}] = [", pmbus_rail_names.len())?;
+        for rail in pmbus_rail_names.iter() {
+            write!(file, "    (b\"{rail}\", ")?;
+            // build_i2c *also* only to-lowercases the rail names to make functions
+            write!(file, "crate::i2c_config::pmbus::{}", rail.to_lowercase())?;
+            writeln!(file, "),")?;
+        }
+        writeln!(file, "];")?;
+    }
+
     file.flush()?;
 
     anyhow::ensure!(missing_ids == 0, "{missing_ids} devices have no ID!");
@@ -129,5 +177,9 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
         SpComponent::MAX_ID_LENGTH,
     );
 
+
+    // panic!("{}", dest_path.display());
+    // panic!("{max_len:?} {:#?}", pmbus_rail_names);
+
     Ok(())
 }

task/validate-api/src/lib.rs

@@ -79,3 +79,5 @@ pub struct DeviceDescription {
 }
 
 include!(concat!(env!("OUT_DIR"), "/device_descriptions.rs"));
+
+include!(concat!(env!("OUT_DIR"), "/i2c_config.rs"));