[ujson] enable skipping CRC sent with UJSON payloads

In manufacturing ATE environments, constant sized UJSON strings are
preferred. CRCs are variable in length. Therefore, we enable setting the
CRC to a fixed value of 0 and skipping the check on the host side.

Signed-off-by: Tim Trippel <[email protected]>
(cherry picked from commit 9a66cc2)

Author: timothytrippel

sw/device/lib/testing/test_framework/ujson_ottf.h

@@ -60,6 +60,22 @@ ujson_t ujson_ottf_console(void);
     err;                                                 \
   })
 
+/**
+ * Adds an empty CRC field to the response.
+ *
+ * Should not be used directly.
+ * It is used by other macros such as `RESP_OK_NO_CRC`.
+ *
+ * @param uj_ctx_ A `ujson_t` representing the IO context.
+ */
+#define RESP_NO_CRC(uj_ctx_)                \
+  ({                                        \
+    TRY(ujson_putbuf(uj_ctx_, " CRC:", 5)); \
+    TRY(ujson_putbuf(uj_ctx_, "0\n", 2));   \
+    TRY(ujson_flushbuf(uj));                \
+    OK_STATUS();                            \
+  })
+
 /**
  * Add a CRC to the response.
  * Should not be used directly.
@@ -78,7 +94,22 @@ ujson_t ujson_ottf_console(void);
   })
 
 /**
- * Respond with an OK result and JSON encoded data.
+ * Respond with an OK result, JSON encoded data, and empty CRC.
+ *
+ * @param responder_ A ujson serializer function for `data_`.
+ * @param uj_ctx_ A `ujson_t` representing the IO context.
+ * @param data_ A pointer to the data to send.
+ */
+#define RESP_OK_NO_CRC(responder_, uj_ctx_, data_) \
+  ({                                               \
+    TRY(ujson_putbuf(uj_ctx_, "RESP_OK:", 8));     \
+    TRY(responder_(uj_ctx_, data_));               \
+    RESP_NO_CRC(uj_ctx_);                          \
+    OK_STATUS();                                   \
+  })
+
+/**
+ * Respond with an OK result, JSON encoded data, and valid CRC.
  *
  * @param responder_ A ujson serializer function for `data_`.
  * @param uj_ctx_ A `ujson_t` representing the IO context.

sw/device/silicon_creator/manuf/tests/ujson_msg_size_functest.c

@@ -75,10 +75,11 @@ static status_t send_ujson_msgs(ujson_t *uj) {
   memset(&perso_blob_msg.body, UINT8_MAX, sizeof(perso_blob_msg.body));
 
   // TX payloads to the host.
-  RESP_OK(ujson_serialize_serdes_sha256_hash_t, uj, &sha256_hash_msg);
-  RESP_OK(ujson_serialize_lc_token_hash_t, uj, &lc_token_hash_msg);
-  RESP_OK(ujson_serialize_manuf_certgen_inputs_t, uj, &certgen_inputs_msg);
-  RESP_OK(ujson_serialize_perso_blob_t, uj, &perso_blob_msg);
+  RESP_OK_NO_CRC(ujson_serialize_serdes_sha256_hash_t, uj, &sha256_hash_msg);
+  RESP_OK_NO_CRC(ujson_serialize_lc_token_hash_t, uj, &lc_token_hash_msg);
+  RESP_OK_NO_CRC(ujson_serialize_manuf_certgen_inputs_t, uj,
+                 &certgen_inputs_msg);
+  RESP_OK_NO_CRC(ujson_serialize_perso_blob_t, uj, &perso_blob_msg);
 
   // RX payloads echoed back by host.
   TRY(ujson_deserialize_serdes_sha256_hash_t(uj, &sha256_hash_msg));

sw/host/opentitanlib/src/test_utils/gpio.rs

@@ -17,7 +17,7 @@ impl GpioSet {
     fn execute(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::GpioSet.send(uart)?;
         self.send(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 
@@ -148,7 +148,7 @@ impl GpioSet {
 impl GpioGet {
     pub fn read_all(uart: &dyn Uart) -> Result<u32> {
         TestCommand::GpioGet.send(uart)?;
-        let data = GpioGet::recv(uart, Duration::from_secs(300), false)?;
+        let data = GpioGet::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(data.state)
     }
 }

sw/host/opentitanlib/src/test_utils/i2c_target.rs

@@ -17,7 +17,7 @@ impl I2cTargetAddress {
     pub fn write(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::I2cTargetAddress.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -42,7 +42,7 @@ impl I2cTransferStart {
         TestCommand::I2cStartTransferRead.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
         f()?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 
@@ -52,7 +52,7 @@ impl I2cTransferStart {
     {
         TestCommand::I2cStartTransferWrite.send_with_crc(uart)?;
         f()?;
-        Self::recv(uart, Duration::from_secs(300), false)
+        Self::recv(uart, Duration::from_secs(300), false, false)
     }
 
     pub fn execute_write_slow<F>(uart: &dyn Uart, f: F) -> Result<Self>
@@ -61,7 +61,7 @@ impl I2cTransferStart {
     {
         TestCommand::I2cStartTransferWriteSlow.send_with_crc(uart)?;
         f()?;
-        Self::recv(uart, Duration::from_secs(300), false)
+        Self::recv(uart, Duration::from_secs(300), false, false)
     }
 
     pub fn execute_write_read<F>(&self, uart: &dyn Uart, f: F) -> Result<Self>
@@ -71,15 +71,15 @@ impl I2cTransferStart {
         TestCommand::I2cStartTransferWriteRead.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
         f()?;
-        Self::recv(uart, Duration::from_secs(300), false)
+        Self::recv(uart, Duration::from_secs(300), false, false)
     }
 }
 
 impl I2cTestConfig {
     pub fn write(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::I2cTestConfig.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }

sw/host/opentitanlib/src/test_utils/mem.rs

@@ -22,7 +22,7 @@ impl MemRead32Req {
         TestCommand::MemRead32.send_with_crc(device)?;
         let op = MemRead32Req { address };
         op.send_with_crc(device)?;
-        let resp = MemRead32Resp::recv(device, Duration::from_secs(300), false)?;
+        let resp = MemRead32Resp::recv(device, Duration::from_secs(300), false, false)?;
         Ok(resp.value)
     }
 }
@@ -46,7 +46,7 @@ impl MemReadReq {
                 data_len: op_size.try_into().unwrap(),
             };
             op.send_with_crc(device)?;
-            let resp = MemReadResp::recv(device, Duration::from_secs(300), false)?;
+            let resp = MemReadResp::recv(device, Duration::from_secs(300), false, false)?;
             data[bytes_read..(bytes_read + op_size)].copy_from_slice(resp.data.as_slice());
             bytes_read += op_size;
         }
@@ -62,7 +62,7 @@ impl MemWrite32Req {
         TestCommand::MemWrite32.send_with_crc(device)?;
         let op = MemWrite32Req { address, value };
         op.send_with_crc(device)?;
-        Status::recv(device, Duration::from_secs(300), false)?;
+        Status::recv(device, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -86,7 +86,7 @@ impl MemWriteReq {
                 .try_extend_from_slice(&data[bytes_written..(bytes_written + op_size)])?;
             op.data_len = op_size.try_into().unwrap();
             op.send_with_crc(device)?;
-            let _ = Status::recv(device, Duration::from_secs(300), false)?;
+            let _ = Status::recv(device, Duration::from_secs(300), false, false)?;
             bytes_written += op_size;
         }
         Ok(())

sw/host/opentitanlib/src/test_utils/pinmux_config.rs

@@ -89,7 +89,7 @@ impl PinmuxConfig {
 
             TestCommand::PinmuxConfig.send(uart)?;
             config.send(uart)?;
-            Status::recv(uart, Duration::from_secs(300), false)?;
+            Status::recv(uart, Duration::from_secs(300), false, false)?;
         }
 
         Ok(())

sw/host/opentitanlib/src/test_utils/rpc.rs

@@ -51,7 +51,7 @@ pub trait ConsoleRecv<T>
 where
     T: ConsoleDevice + ?Sized,
 {
-    fn recv(device: &T, timeout: Duration, quiet: bool) -> Result<Self>
+    fn recv(device: &T, timeout: Duration, quiet: bool, skip_crc: bool) -> Result<Self>
     where
         Self: Sized;
 }
@@ -61,7 +61,7 @@ where
     T: ConsoleDevice + ?Sized,
     U: DeserializeOwned,
 {
-    fn recv(device: &T, timeout: Duration, quiet: bool) -> Result<Self>
+    fn recv(device: &T, timeout: Duration, quiet: bool, skip_crc: bool) -> Result<Self>
     where
         Self: Sized,
     {
@@ -78,7 +78,9 @@ where
             PassFailResult::Pass(cap) => {
                 let json_str = &cap[1];
                 let crc_str = &cap[2];
-                check_crc(json_str, crc_str)?;
+                if !skip_crc {
+                    check_crc(json_str, crc_str)?;
+                }
                 Ok(serde_json::from_str::<Self>(json_str)?)
             }
             PassFailResult::Fail(cap) => {

sw/host/opentitanlib/src/test_utils/spi_passthru.rs

@@ -17,21 +17,21 @@ impl ConfigJedecId {
     pub fn execute(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiConfigureJedecId.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
 
 impl StatusRegister {
     pub fn read(uart: &dyn Uart) -> Result<Self> {
         TestCommand::SpiReadStatus.send_with_crc(uart)?;
-        Self::recv(uart, Duration::from_secs(300), false)
+        Self::recv(uart, Duration::from_secs(300), false, false)
     }
 
     pub fn write(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiWriteStatus.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -40,7 +40,7 @@ impl SfdpData {
     pub fn write(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiWriteSfdp.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -52,14 +52,14 @@ impl UploadInfo {
     {
         TestCommand::SpiWaitForUpload.send_with_crc(uart)?;
         f()?;
-        Self::recv(uart, Duration::from_secs(300), false)
+        Self::recv(uart, Duration::from_secs(300), false, false)
     }
 }
 
 impl SpiFlashReadId {
     pub fn execute(uart: &dyn Uart) -> Result<Self> {
         TestCommand::SpiFlashReadId.send_with_crc(uart)?;
-        let data = SpiFlashReadId::recv(uart, Duration::from_secs(300), false)?;
+        let data = SpiFlashReadId::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(data)
     }
 }
@@ -68,7 +68,7 @@ impl SpiFlashReadSfdp {
     pub fn execute(&self, uart: &dyn Uart) -> Result<SfdpData> {
         TestCommand::SpiFlashReadSfdp.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        let sfdp = SfdpData::recv(uart, Duration::from_secs(300), false)?;
+        let sfdp = SfdpData::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(sfdp)
     }
 }
@@ -77,7 +77,7 @@ impl SpiFlashEraseSector {
     pub fn execute(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiFlashEraseSector.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -86,7 +86,7 @@ impl SpiFlashWrite {
     pub fn execute(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiFlashWrite.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -95,7 +95,7 @@ impl SpiPassthruSwapMap {
     pub fn apply_address_swap(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiPassthruSetAddressMap.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -104,13 +104,13 @@ impl SpiMailboxMap {
     pub fn apply(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiMailboxMap.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 
     pub fn disable(uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiMailboxUnmap.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }
@@ -119,7 +119,7 @@ impl SpiMailboxWrite {
     pub fn execute(&self, uart: &dyn Uart) -> Result<()> {
         TestCommand::SpiMailboxWrite.send_with_crc(uart)?;
         self.send_with_crc(uart)?;
-        Status::recv(uart, Duration::from_secs(300), false)?;
+        Status::recv(uart, Duration::from_secs(300), false, false)?;
         Ok(())
     }
 }

sw/host/provisioning/cp_lib/src/lib.rs

@@ -127,7 +127,7 @@ pub fn run_sram_cp_provision(
 
     // Wait to receive CP device ID, and encode in big-endian in response.
     let _ = UartConsole::wait_for(spi_console, r"Exporting CP device ID ...", timeout)?;
-    response.cp_device_id = ManufCpProvisioningDataOut::recv(spi_console, timeout, true)?
+    response.cp_device_id = ManufCpProvisioningDataOut::recv(spi_console, timeout, true, false)?
         .cp_device_id
         .iter()
         .rev()

sw/host/provisioning/ft_lib/src/lib.rs

@@ -349,7 +349,12 @@ fn provision_certificates(
     // Wait until the device exports the TBS certificates.
     let t0 = Instant::now();
     let _ = UartConsole::wait_for(spi_console, r"Exporting TBS certificates ...", timeout)?;
-    let perso_blob = PersoBlob::recv(spi_console, timeout, /*quite=*/ true)?;
+    let perso_blob = PersoBlob::recv(
+        spi_console,
+        timeout,
+        /*quiet=*/ true,
+        /*skip_crc=*/ true,
+    )?;
     response.stats.log_elapsed_time("perso-tbs-export", t0);
 
     // Extract certificate byte vectors, endorse TBS certs, and ensure they parse with OpenSSL.
@@ -537,7 +542,13 @@ fn provision_certificates(
 
     // Check the integrity of the certificates written to the device's flash by comparing a
     // SHA256 over all certificates computed on the host and device sides.
-    let device_computed_certs_hash = SerdesSha256Hash::recv(spi_console, timeout, false)?;
+    let device_computed_certs_hash = SerdesSha256Hash::recv(
+        spi_console,
+        timeout,
+        /*quiet=*/ false,
+        /*skip_crc=*/ true,
+    )?;
+
     if !device_computed_certs_hash
         .data
         .as_bytes()