[opentitantool] Output OTP image overlays with hex values

Signed-off-by: Jon Flatley <[email protected]>

Author: Jon Flatley

sw/host/opentitanlib/src/otp/otp_img.rs

@@ -12,7 +12,9 @@ use anyhow::{anyhow, bail, Result};
 use serde::de::{self, Unexpected};
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Debug, PartialEq, Eq)]
+use serde_annotate::Annotate;
+
+#[derive(Annotate, Serialize, Debug, PartialEq, Eq)]
 #[serde(untagged)]
 pub enum OtpImgValue {
     Word(u64),
@@ -90,22 +92,25 @@ impl<'de> Deserialize<'de> for OtpImgValue {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[derive(Annotate, Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub struct OtpImgItem {
     pub name: String,
     pub value: OtpImgValue,
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[derive(Annotate, Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub struct OtpImgPartition {
     pub name: String,
     pub items: Option<Vec<OtpImgItem>>,
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
+#[derive(Annotate, Serialize, Deserialize, Debug, PartialEq, Eq)]
 pub struct OtpImg {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub seed: Option<u64>,
+    // FIXME: Needed to get `OtpImgValue` serailization to emit hex values.
+    // See: https://github.com/cfrantz/serde-annotate/issues/5.
+    #[annotate(format = hex)]
     pub partitions: Vec<OtpImgPartition>,
 }
 

sw/host/opentitanlib/src/util/num_de.rs

@@ -255,17 +255,17 @@ mod test {
     fn byte_field_test() {
         assert_eq!(Vec::from_str("0x1"), Ok(vec![0x1]));
         assert_eq!(
-            Vec::from_str("0x4b4b4b4b4b4ba5a5"),
-            Ok(vec![0xa5, 0xa5, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b])
+            Vec::from_str("0x0706050403020100"),
+            Ok(vec![0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07])
         );
         assert_eq!(
             u64::from_ne_bytes(
-                Vec::from_str("0x4b4b4b4b4b4ba5a5")
+                Vec::from_str("0x0706050403020100")
                     .unwrap()
                     .try_into()
                     .unwrap()
             ),
-            u64::from_str("0x4b4b4b4b4b4ba5a5").unwrap()
+            u64::from_str("0x0706050403020100").unwrap()
         );
         assert!(Vec::from_str("-1").is_err());
     }

sw/host/opentitantool/src/command/otp.rs

@@ -9,7 +9,7 @@ use std::path::PathBuf;
 
 use anyhow::{bail, Result};
 
-use serde_annotate::{serialize, Annotate};
+use serde_annotate::{serialize, Annotate, Base};
 
 use structopt::StructOpt;
 
@@ -24,8 +24,6 @@ use opentitanlib::otp::otp_img::{OtpImg, OtpImgItem, OtpImgPartition, OtpImgValu
 pub struct AlertDigest {
     #[structopt(help = "OTP memory map file containing alert_handler config in HJSON format")]
     alert_cfg: PathBuf,
-    #[structopt(help = r#"Life cycle state ("TEST", "DEV", "PROD", PROD_END, "RMA")"#)]
-    lc_state: String,
     #[structopt(
         long,
         help = "Output file to write the new OTP overlay to instead of printing"
@@ -37,8 +35,6 @@ pub struct AlertDigest {
         help = "Override switch to specify a custom partition"
     )]
     partition: String,
-    #[structopt(long, help = "Override switch to specify a custom OTP item name")]
-    name: Option<String>,
 }
 
 impl CommandDispatch for AlertDigest {
@@ -50,48 +46,53 @@ impl CommandDispatch for AlertDigest {
         // From kErrorOk in ROM.
         const ERROR_OK: u32 = 0x739;
 
+        // Life cycle states to generate digests for.
+        let lc_states = [
+            ("OWNER_SW_CFG_ROM_ALERT_DIGEST_PROD", LcStateVal::Prod),
+            ("OWNER_SW_CFG_ROM_ALERT_DIGEST_PROD_END", LcStateVal::ProdEnd),
+            ("OWNER_SW_CFG_ROM_ALERT_DIGEST_DEV", LcStateVal::Dev),
+            ("OWNER_SW_CFG_ROM_ALERT_DIGEST_RMA", LcStateVal::Rma),
+        ];
+
         // Read in the OTP img description.
         let otp = OtpImg::from_file(&self.alert_cfg)?;
 
-        let lc_str = self.lc_state.to_uppercase();
-        let lc_state = match lc_str.as_ref() {
-            "TEST" => LcStateVal::Test,
-            "DEV" => LcStateVal::Dev,
-            "PROD" => LcStateVal::Prod,
-            "PROD_END" => LcStateVal::ProdEnd,
-            "RMA" => LcStateVal::Rma,
-            _ => bail!("invalid life cycle state {}", self.lc_state),
-        };
+        let mut items = Vec::<OtpImgItem>::new();
 
-        // Create model for alert_handler register states.
-        let alert = AlertRegs::try_new(lc_state, &otp)?;
+        for lc_state in lc_states {
+            // Create model for alert_handler register states.
+            let alert = AlertRegs::try_new(lc_state.1, &otp)?;
 
-        // Use alert_handler registers states to construct CRC32 checksum.
-        let crc32 = alert.crc32();
+            // Use alert_handler registers states to construct CRC32 checksum.
+            let crc32 = alert.crc32();
 
-        // Match digest format expected by ROM.
-        let digest = crc32 ^ lc_state as u32 ^ ERROR_OK;
+            // Match digest format expected by ROM.
+            let digest = crc32 ^ lc_state.1 as u32 ^ ERROR_OK;
 
-        let item_name = self
-            .name
-            .clone()
-            .unwrap_or(format!("OWNER_SW_CFG_ROM_ALERT_DIGEST_{}", self.lc_state).to_string());
+            items.push(OtpImgItem {
+                name: lc_state.0.to_owned(),
+                value: OtpImgValue::Word(digest as u64),
+            });
+        }
 
         // Construct OTP image overlay.
         let img_out = OtpImg {
             seed: None,
             partitions: vec![OtpImgPartition {
                 name: self.partition.clone(),
-                items: Some(vec![OtpImgItem {
-                    name: item_name,
-                    value: OtpImgValue::Word(digest as u64),
-                }]),
+                items: Some(items),
             }],
         };
 
         if let Some(output) = &self.output {
             let mut file = File::create(&output)?;
-            file.write_all(serialize(&img_out)?.to_json().to_string().as_bytes())?;
+            file.write_all(
+                serialize(&img_out)?
+                    .to_json()
+                    .bases(&[Base::Hex])
+                    .to_string()
+                    .as_bytes(),
+            )?;
             Ok(None)
         } else {
             Ok(Some(Box::new(img_out)))