add read_fpga_regs() entry point + sequencer register descriptions

app/gimlet/rev-b.toml

@@ -138,6 +138,7 @@ stacksize = 1600
 start = true
 task-slots = ["sys", "i2c_driver", {spi_driver = "spi2_driver"}, "hf", "jefe"]
 notifications = ["timer"]
+copy-to-archive = ["register_defs"]
 
 [tasks.gimlet_seq.config]
 fpga_image = "fpga-b.bin"

app/gimlet/rev-c.toml

@@ -138,6 +138,7 @@ stacksize = 1600
 start = true
 task-slots = ["sys", "i2c_driver", {spi_driver = "spi2_driver"}, "hf", "jefe"]
 notifications = ["timer"]
+copy-to-archive = ["register_defs"]
 
 [tasks.gimlet_seq.config]
 fpga_image = "fpga-b.bin"

build/xtask/src/dist.rs

@@ -748,6 +748,82 @@ fn build_archive(cfg: &PackageConfig, image_name: &str) -> Result<PathBuf> {
         )?;
     }
 
+    let mut metadata = None;
+
+    //
+    // Iterate over tasks looking for elements that should be copied into
+    // the archive.  These are specified by the "copy-to-archive" array,
+    // which consists of keys into the config table; the values associated
+    // with these keys have the names of the files to add to the archive.
+    // All files added to the archive for a particular task will be in
+    // a directory dedicated to that task; all such directories will
+    // themselves be subdirectories in the "task" directory.
+    //
+    for (name, task) in &cfg.toml.tasks {
+        for c in &task.copy_to_archive {
+            match &task.config {
+                None => {
+                    bail!(
+                        "task {name}: {c} is specified to be copied \
+                        into archive, but config table is missing"
+                    );
+                }
+                Some(config) => match config.get(c) {
+                    Some(ordered_toml::Value::String(s)) => {
+                        //
+                        // This is a bit of a heavy hammer:  we need the
+                        // directory name for the task to find the file to be
+                        // copied into the archive, so we're going to iterate
+                        // over all packages to find the crate assocated with
+                        // this task.  (We cache the metadata itself, as it
+                        // takes on the order of ~150 ms to gather.)
+                        //
+                        use cargo_metadata::MetadataCommand;
+                        let metadata = match metadata.as_ref() {
+                            Some(m) => m,
+                            None => {
+                                let d = MetadataCommand::new()
+                                    .manifest_path("./Cargo.toml")
+                                    .exec()?;
+                                metadata.get_or_insert(d)
+                            }
+                        };
+
+                        let pkg = metadata
+                            .packages
+                            .iter()
+                            .find(|p| p.name == task.name)
+                            .unwrap();
+
+                        let dir = pkg.manifest_path.parent().unwrap();
+
+                        let f = dir.join(s);
+                        let task_dir = PathBuf::from("task").join(name).join(s);
+                        archive.copy(f, task_dir).with_context(|| {
+                            format!(
+                                "task {name}: failed to copy \"{s}\" in {} \
+                                into the archive",
+                                dir.display()
+                            )
+                        })?;
+                    }
+                    Some(_) => {
+                        bail!(
+                            "task {name}: {c} is specified to be copied into \
+                            the archive, but isn't a string in the config table"
+                        );
+                    }
+                    None => {
+                        bail!(
+                            "task {name}: {c} is specified to be copied into \
+                            the archive, but is missing in the config table"
+                        );
+                    }
+                },
+            }
+        }
+    }
+
     archive.finish()?;
     Ok(archive_path)
 }

drv/gimlet-seq-api/src/lib.rs

@@ -18,6 +18,7 @@ pub enum SeqError {
     MuxToHostCPUFailed,
     MuxToSPFailed,
     ClockConfigFailed,
+    ReadRegsFailed,
 
     #[idol(server_death)]
     ServerRestarted,

drv/gimlet-seq-server/src/main.rs

@@ -755,6 +755,22 @@ impl<S: SpiServer> idl::InOrderSequencerImpl for ServerImpl<S> {
         self.sys.gpio_set(SP_TO_SP3_NMI_SYNC_FLOOD_L);
         Ok(())
     }
+
+    fn read_fpga_regs(
+        &mut self,
+        _: &RecvMessage,
+    ) -> Result<[u8; 64], RequestError<SeqError>> {
+        let mut buf = [0; 64];
+        let size = 8;
+
+        for i in (0..buf.len()).step_by(size) {
+            self.seq
+                .read_bytes(i as u16, &mut buf[i..i + size])
+                .map_err(|_| SeqError::ReadRegsFailed)?;
+        }
+
+        Ok(buf)
+    }
 }
 
 fn reprogram_fpga<S: SpiServer>(

drv/gimlet-seq-server/src/seq_spi.rs

@@ -76,7 +76,7 @@ impl<S: SpiServer> SequencerFpga<S> {
     }
 
     /// Performs the READ command against `addr`. This can read as many bytes as
-    /// you like into `data_out`.
+    /// you like into `data_out`, limited by `raw_spi_read` buffer size
     pub fn read_bytes(
         &self,
         addr: impl Into<u16>,
@@ -142,14 +142,16 @@ impl<S: SpiServer> SequencerFpga<S> {
         let header = CmdHeader { cmd, addr };
         let header = header.as_bytes();
 
+        if data_out.len() > data.len() - header.len() {
+            return Err(spi_api::SpiError::BadTransferSize);
+        }
+
         data[..header.len()].copy_from_slice(header);
 
         self.spi.exchange(&data, &mut rval)?;
 
         for i in 0..data_out.len() {
-            if i + header.len() < data.len() {
-                data_out[i] = rval[i + header.len()];
-            }
+            data_out[i] = rval[i + header.len()];
         }
 
         Ok(())

drv/local-vpd/src/lib.rs

@@ -38,6 +38,7 @@ struct EepromReader<'a> {
 #[derive(Copy, Clone, PartialEq)]
 enum Trace {
     EepromError(drv_i2c_devices::at24csw080::Error),
+    Error(LocalVpdError),
     None,
 }
 
@@ -122,26 +123,32 @@ pub fn read_config_into(
         i2c_config::devices::at24csw080_local_vpd(i2c_task),
     );
     let eeprom_reader = EepromReader { eeprom: &eeprom };
+
+    let err = |e| {
+        ringbuf_entry!(Trace::Error(e));
+        e
+    };
+
     let mut reader = TlvcReader::begin(eeprom_reader)
-        .map_err(|_| LocalVpdError::DeviceError)?;
+        .map_err(|_| err(LocalVpdError::DeviceError))?;
 
     while let Ok(Some(chunk)) = reader.next() {
         let mut scratch = [0u8; 32];
         if chunk.header().tag == *b"FRU0" {
             chunk
                 .check_body_checksum(&mut scratch)
-                .map_err(|_| LocalVpdError::InvalidChecksum)?;
+                .map_err(|_| err(LocalVpdError::InvalidChecksum))?;
             let mut inner = chunk.read_as_chunks();
             while let Ok(Some(chunk)) = inner.next() {
                 if chunk.header().tag == tag {
                     chunk
                         .check_body_checksum(&mut scratch)
-                        .map_err(|_| LocalVpdError::InvalidChecksum)?;
+                        .map_err(|_| err(LocalVpdError::InvalidChecksum))?;
 
                     let chunk_len = chunk.len() as usize;
 
                     if chunk_len > out.len() {
-                        return Err(LocalVpdError::InvalidChunkSize);
+                        return Err(err(LocalVpdError::InvalidChunkSize));
                     }
 
                     chunk
@@ -150,10 +157,10 @@ pub fn read_config_into(
                     return Ok(chunk_len);
                 }
             }
-            return Err(LocalVpdError::NoSuchChunk);
+            return Err(err(LocalVpdError::NoSuchChunk));
         }
     }
-    Err(LocalVpdError::NoRootChunk)
+    Err(err(LocalVpdError::NoRootChunk))
 }
 
 include!(concat!(env!("OUT_DIR"), "/i2c_config.rs"));

drv/mock-gimlet-seq-server/src/main.rs

@@ -92,6 +92,13 @@ impl idl::InOrderSequencerImpl for ServerImpl {
     ) -> Result<(), RequestError<core::convert::Infallible>> {
         Ok(())
     }
+
+    fn read_fpga_regs(
+        &mut self,
+        _: &RecvMessage,
+    ) -> Result<[u8; 64], RequestError<SeqError>> {
+        Ok([0; 64])
+    }
 }
 
 mod idl {

idl/gimlet-seq.idol

@@ -48,5 +48,13 @@ Interface(
                 err: ServerDeath,
             ),
         ),
+        "read_fpga_regs": (
+            doc: "Raw read of the FPGA registers",
+            args: {},
+            reply: Result(
+                ok: "[u8; 64]",
+                err: CLike("SeqError"),
+            ),
+        ),
     },
 )

lib/toml-task/src/lib.rs

@@ -30,6 +30,8 @@ pub struct Task<T = ordered_toml::Value> {
     pub features: Vec<String>,
     #[serde(default)]
     pub notifications: Vec<String>,
+    #[serde(default)]
+    pub copy_to_archive: Vec<String>,
 
     // Order matters here:
     // TOML serialization doesn't allow us to put a value type after any Table