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,24 +66,31 @@ 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) => {{
+    ($device:expr, $rail:expr, $dev:ident::$cmd:ident $(,)?) => {{
         use $dev::{PAGE, $cmd};
         pmbus_rail_read!($device, $rail, $cmd)
     }};
@@ -271,6 +278,69 @@ 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: Result<u8, PmbusStatusError>,
+    pub status_iout: Result<u8, PmbusStatusError>,
+    pub status_temperature: Result<u8, PmbusStatusError>,
+    pub status_cml: Result<u8, PmbusStatusError>,
+    pub status_other: Result<u8, PmbusStatusError>,
+    pub status_input: Result<u8, PmbusStatusError>,
+    pub status_mfr_specific: Result<u8, PmbusStatusError>,
+    pub status_fans_1_2: Result<u8, PmbusStatusError>,
+    pub status_fans_3_4: Result<u8, PmbusStatusError>,
+}
+
+/// An error for querying PMBus `STATUS_*` registers.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum PmbusStatusError {
+    BadRead { cmd: u8, code: ResponseCode },
+    BadData { cmd: u8, },
+}
+
+impl PmbusStatus {
+    /// Attempt to read a [`PmbusStatus`] from the given device and rail.
+    ///
+    /// This function returns an error if the initial attempt to obtain `STATUS_WORD` from the
+    /// device fails, otherwise returnining successfully even if "leaf" status bytes were unable
+    /// to be read, either due to ephemeral hiccups, or that status byte being unsupported by
+    /// the device queried.
+    pub fn try_read_from(dev: &I2cDevice, rail_idx: u8) -> Result<Self, PmbusStatusError> {
+        use pmbus::commands::*;
+        use PmbusStatusError as Error;
+
+        Ok(PmbusStatus {
+            // Status word *must* succeed, otherwise we don't have reasonable data to return.
+            // We may want to consider making some/all of these retryable, but for now you either
+            // get them or you don't.
+            status_word: pmbus_rail_read!(dev, rail_idx, STATUS_WORD)?.0,
+            status_vout: pmbus_rail_read!(dev, rail_idx, STATUS_VOUT).map(|v| v.0),
+            status_iout: pmbus_rail_read!(dev, rail_idx, STATUS_IOUT).map(|v| v.0),
+            status_temperature: pmbus_rail_read!(dev, rail_idx, STATUS_TEMPERATURE).map(|v| v.0),
+            status_cml: pmbus_rail_read!(dev, rail_idx, STATUS_CML).map(|v| v.0),
+            status_other: pmbus_rail_read!(dev, rail_idx, STATUS_OTHER).map(|v| v.0),
+            status_input: pmbus_rail_read!(dev, rail_idx, STATUS_INPUT).map(|v| v.0),
+            status_fans_1_2: pmbus_rail_read!(dev, rail_idx, STATUS_FANS_1_2).map(|v| v.0),
+            status_fans_3_4: pmbus_rail_read!(dev, rail_idx, STATUS_FANS_3_4).map(|v| v.0),
+
+            // Unfortunately, STATUS_MFR_SPECIFIC *is* defined in the pmbus crate, but doesn't have a
+            // "structured" representation, so instead use a raw accessor. 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 ourselves a little indirection, but for now
+            // just hole-punch the minimum amount necessary. Indexing is fine here because we know
+            // (statically) the returned value is `[u8; 1]`.
+            status_mfr_specific: pmbus_rail_read!(
+                @raw => dev,
+                rail_idx,
+                CommandCode::STATUS_MFR_SPECIFIC as u8,
+                1,
+            ).map(|v| v[0]),
+        })
+    }
+}
+
 pub mod adm127x;
 pub mod adt7420;
 pub mod at24csw080;

task/control-plane-agent/Cargo.toml

@@ -25,6 +25,7 @@ drv-caboose = { path = "../../drv/caboose" }
 drv-caboose-pos = { path = "../../drv/caboose-pos" }
 drv-hf-api = { path = "../../drv/hf-api", optional = true }
 drv-cpu-seq-api = { path = "../../drv/cpu-seq-api", optional = true }
+drv-i2c-api = { path = "../../drv/i2c-api" }
 drv-ignition-api = { path = "../../drv/ignition-api", optional = true }
 drv-lpc55-update-api = { path = "../../drv/lpc55-update-api" }
 drv-monorail-api = { path = "../../drv/monorail-api", optional = true }
@@ -53,6 +54,7 @@ userlib = { path = "../../sys/userlib", features = ["panic-messages"] }
 static-cell = { path = "../../lib/static-cell" }
 
 [build-dependencies]
+build-i2c = { path = "../../build/i2c" }
 build-util = { path = "../../build/util" }
 anyhow = { workspace = true }
 idol = { workspace = true }

task/control-plane-agent/build.rs

@@ -35,6 +35,64 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     if let Some(cfg) = cfg {
         write_keys(cfg)?;
     }
+
+    do_pmbus()?;
+
+    Ok(())
+}
+
+fn do_pmbus() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let out_dir = std::env::var("OUT_DIR")?;
+    let dest_path =
+        std::path::Path::new(&out_dir).join("pmbus_mapping.rs");
+    let file = std::fs::File::create(&dest_path)?;
+    let mut file = std::io::BufWriter::new(file);
+
+    // Generate the necessary rail names
+    if let Err(e) = build_i2c::codegen(build_i2c::Disposition::Devices) {
+        println!("cargo::error=failed to generate I2C devices: {e}");
+        std::process::exit(1);
+    }
+
+    let devices = build_i2c::device_descriptions()
+        .collect::<Vec<_>>();
+
+    let mut pmbus_rail_names = std::collections::BTreeSet::new();
+    let mut pmbus_rail_dupes = 0;
+    for dev in devices {
+        // We only need to map PMBus devices
+        let Some(ref pmbus) = dev.pmbus else {
+            continue;
+        };
+
+        // pmbus devices must have a refdes
+        assert!(dev.device_id.is_some());
+
+        // Aggregate a list of all PMBus-visible rails
+        for rail in pmbus.rails.iter() {
+            // `BTreeSet::insert` return value means "is unique", which is the inverse of
+            // `BTreeMap::insert().is_some()`!
+            if !pmbus_rail_names.insert(rail.name.clone()) {
+                pmbus_rail_dupes += 1;
+                println!("cargo::error=Duplicate Rail name: {:?}", rail.name);
+            }
+        }
+    }
+
+    // Create a mapping between rail names and generated accessor functions for obtaining
+    // the device handle and rail index
+    writeln!(file)?;
+    writeln!(file, "pub const PMBUS_RAIL_TO_I2C_DEVICE_MAP: [(&[u8], fn(userlib::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, "];")?;
+
+    assert_eq!(pmbus_rail_dupes, 0);
+
     Ok(())
 }
 

task/control-plane-agent/src/main.rs

@@ -627,3 +627,7 @@ mod idl {
 }
 
 include!(concat!(env!("OUT_DIR"), "/notifications.rs"));
+
+include!(concat!(env!("OUT_DIR"), "/i2c_config.rs"));
+
+include!(concat!(env!("OUT_DIR"), "/pmbus_mapping.rs"));