wip

Author: hawkw

app/gimlet/base.toml

@@ -287,6 +287,7 @@ task-slots = [
     "packrat",
     "user_leds",
     "vpd",
+    "i2c_driver",
 ]
 features = [
     "gimlet",

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

@@ -2,6 +2,7 @@
 // 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 drv_i2c_devices::at24csw080::At24Csw080;
 use gateway_messages::measurement::{
     Measurement, MeasurementError, MeasurementKind,
 };
@@ -18,54 +19,56 @@ use userlib::UnwrapLite;
 
 userlib::task_slot!(VALIDATE, validate);
 userlib::task_slot!(SENSOR, sensor);
-userlib::task_slot!(I2C, i2c);
+userlib::task_slot!(I2C, i2c_driver);
 
 pub(crate) struct Inventory {
     validate_task: Validate,
     sensor_task: SensorTask,
+    fruid_buf: &'static mut [u8],
 }
 
-pub(crate) struct FixedStr {
-    buf: [u8; 32],
-    len: usize,
-}
-
-impl FixedStr {
-    pub fn copy_from_slice(slice: &[u8]) -> Result<Self, core::str::Utf8Error> {
-        core::str::from_utf8(slice)?;
-        let mut buf = [0u8; 32];
-        buf[..slice.len()].copy_from_slice(slice);
-        Ok(Self {
-            buf,
-            len: slice.len(),
-        })
-    }
-
-    pub fn from_buf(
-        bytes: [u8; 32],
-        len: usize,
-    ) -> Result<Self, core::str::Utf8Error> {
-        core::str::from_utf8(&bytes[..len])?;
-        Ok(Self { buf: bytes, len })
-    }
-}
-
-impl AsRef<str> for FixedStr {
-    fn as_ref(&self) -> &str {
-        unsafe {
-            // SAFETY: This is checked when constructing the FixedStr.
-            core::str::from_utf8_unchecked(&self.buf[..self.len])
-        }
-    }
-}
+// pub(crate) struct FixedStr {
+//     buf: [u8; 32],
+//     len: usize,
+// }
+
+// impl FixedStr {
+//     pub fn copy_from_slice(slice: &[u8]) -> Result<Self, core::str::Utf8Error> {
+//         core::str::from_utf8(slice)?;
+//         let mut buf = [0u8; 32];
+//         buf[..slice.len()].copy_from_slice(slice);
+//         Ok(Self {
+//             buf,
+//             len: slice.len(),
+//         })
+//     }
+
+//     pub fn from_buf(
+//         bytes: [u8; 32],
+//         len: usize,
+//     ) -> Result<Self, core::str::Utf8Error> {
+//         core::str::from_utf8(&bytes[..len])?;
+//         Ok(Self { buf: bytes, len })
+//     }
+// }
+
+// impl AsRef<str> for FixedStr {
+//     fn as_ref(&self) -> &str {
+//         unsafe {
+//             // SAFETY: This is checked when constructing the FixedStr.
+//             core::str::from_utf8_unchecked(&self.buf[..self.len])
+//         }
+//     }
+// }
 
 impl Inventory {
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new(fruid_buf: &'static mut [u8]) -> Self {
         let () = devices_with_static_validation::ASSERT_EACH_DEVICE_FITS_IN_ONE_PACKET;
 
         Self {
             validate_task: Validate::from(VALIDATE.get_task_id()),
             sensor_task: SensorTask::from(SENSOR.get_task_id()),
+            fruid_buf,
         }
     }
 
@@ -93,11 +96,11 @@ impl Inventory {
         }
     }
 
-    pub(crate) fn component_details(
-        &self,
+    pub(crate) fn component_details<'buf>(
+        &'buf mut self,
         component: &SpComponent,
         component_index: BoundsChecked,
-    ) -> ComponentDetails<FixedStr> {
+    ) -> ComponentDetails<&'buf str> {
         // `component_index` is guaranteed to be in the range
         // `0..num_component_details(component)`, and we only return a value
         // greater than 0 from that method for indices in the VALIDATE_DEVICES
@@ -108,20 +111,38 @@ impl Inventory {
             Ok(Index::ValidateDevice(i)) => i,
             Ok(Index::OurDevice(_)) | Err(_) => panic!(),
         };
+        let device = &VALIDATE_DEVICES[val_device_index];
+        // First, measurement channels...
+        if let Some(sensor_description) =
+            device.sensors.get(component_index.0 as usize)
+        {
+            let value = self
+                .sensor_task
+                .get(sensor_description.id)
+                .map_err(|err| SensorErrorConvert(err).into());
+
+            return ComponentDetails::Measurement(Measurement {
+                name: sensor_description.name.unwrap_or(""),
+                kind: MeasurementKindConvert(sensor_description.kind).into(),
+                value,
+            });
+        }
 
-        let sensor_description = &VALIDATE_DEVICES[val_device_index].sensors
-            [component_index.0 as usize];
-
-        let value = self
-            .sensor_task
-            .get(sensor_description.id)
-            .map_err(|err| SensorErrorConvert(err).into());
+        // If the index is greater than the maximum number of measurement
+        // channels, it must be a FRUID.
+        let Some(fruid) = device.fruid else {
+            // Index is bounds-checked.
+            unreachable!()
+        };
 
-        ComponentDetails::Measurement(Measurement {
-            name: sensor_description.name.unwrap_or(""),
-            kind: MeasurementKindConvert(sensor_description.kind).into(),
-            value,
-        })
+        match fruid {
+            FruidMode::At24Csw080Barcode(f) => {
+                let dev = f(I2C.get_task_id());
+                todo!()
+            }
+            FruidMode::At24Csw080Nested(_) => todo!(),
+            FruidMode::Tmp117(_) => todo!(),
+        }
     }
 
     pub(crate) fn device_description(

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

@@ -57,23 +57,30 @@ pub(crate) struct MgsCommon {
     dump_state: DumpState,
 
     reset_component_requested: Option<SpComponent>,
-    inventory: Inventory,
+    pub inventory: Inventory,
     base_mac_address: MacAddress,
     packrat: Packrat,
     sprot: SpRot,
     update_sp: Update,
     sensor: Sensor,
 }
 
+const FRUID_BUF_SIZE: usize = 256;
+
 impl MgsCommon {
     pub(crate) fn claim_static_resources(base_mac_address: MacAddress) -> Self {
+        use static_cell::ClaimOnceCell;
+        let fruid_buf = {
+            static BUF: ClaimOnceCell<[u8; FRUID_BUF_SIZE]> =
+                ClaimOnceCell::new([0; FRUID_BUF_SIZE]);
+            BUF.claim()
+        };
         Self {
             sp_update: SpUpdate::new(),
             rot_update: RotUpdate::new(),
             dump_state: DumpState::new(),
-
             reset_component_requested: None,
-            inventory: Inventory::new(),
+            inventory: Inventory::new(fruid_buf),
             base_mac_address,
             packrat: Packrat::from(PACKRAT.get_task_id()),
             sprot: SpRot::from(SPROT.get_task_id()),

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

@@ -913,8 +913,8 @@ impl SpHandler for MgsHandler {
         &mut self,
         component: SpComponent,
         index: BoundsChecked,
-    ) -> ComponentDetails<crate::inventory::FixedStr> {
-        self.common.inventory().component_details(&component, index)
+    ) -> ComponentDetails<&str> {
+        self.common.inventory.component_details(&component, index)
     }
 
     fn component_get_active_slot(

task/validate-api/build.rs

@@ -57,6 +57,7 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
     let mut missing_ids = 0;
     let mut duplicate_ids = 0;
     let mut ids_too_long = 0;
+    #[cfg(feature = "fruid")]
     let mut bad_fruids = 0;
     //
     // The DEVICE_INDICES_BY_SORTED_ID array is used to look up indices by ID
@@ -179,6 +180,7 @@ fn write_pub_device_descriptions() -> anyhow::Result<()> {
         SpComponent::MAX_ID_LENGTH,
     );
 
+    #[cfg(feature = "fruid")]
     anyhow::ensure!(
         bad_fruids == 0,
         "{bad_fruids} devices have invalid FRUID configs!"