add tracing possibilities

Murmele · Dec 6, 2024 · 8fbd73b · 8fbd73b
1 parent e485870
commit 8fbd73b
Show file tree

Hide file tree

Showing 2 changed files with 58 additions and 2 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -17,6 +17,7 @@ embedded-hal = { version = "1.0"}
 embedded-hal-async = { version = "1.0", default-features = false }
 heapless = "^0.8"
 log = {version = "0.4", default-features = false, optional = true}
+rtos-trace = { version = "0.1.2", optional = true }
 
 [dev-dependencies]
 chrono = "0.4"

diff --git a/src/sdcard/mod.rs b/src/sdcard/mod.rs
@@ -10,6 +10,25 @@ pub mod proto;
 use crate::{trace, Block, BlockCount, BlockDevice, BlockIdx};
 use core::cell::RefCell;
 use proto::*;
+#[cfg(feature = "rtos-trace")]
+use rtos_trace::trace;
+
+enum Marker {
+    SDCardRead = 7,
+    SDCardReadInnerCardCommand = 8,
+    SDCardReadInnerReadData = 9,
+    SDCardReadInnerTransferBuffer = 10,
+    SDCardReadInnerCardCommandWaitNotBusy = 11,
+    SDCardReadInnerCardCommandWriteInfo = 12,
+    SDCardReadInnerCardCommandWaitReady = 13,
+    SDCardReadInnerCardCommandWaitOk = 14,
+}
+
+impl From<Marker> for u32 {
+    fn from(value: Marker) -> Self {
+        value as u32
+    }
+}
 
 // ****************************************************************************
 // Imports
@@ -266,8 +285,17 @@ where
     async fn read_inner(&mut self, blocks: &mut [Block], start_idx: u32) -> Result<(), Error> {
         if blocks.len() == 1 {
             // Start a single-block read
+            #[cfg(feature = "rtos-trace")]
+            rtos_trace::trace::marker_begin(Marker::SDCardReadInnerCardCommand.into());
             self.card_command(CMD17, start_idx).await?;
+            #[cfg(feature = "rtos-trace")]
+            rtos_trace::trace::marker_end(Marker::SDCardReadInnerCardCommand.into());
+
+            #[cfg(feature = "rtos-trace")]
+            rtos_trace::trace::marker_begin(Marker::SDCardReadInnerReadData.into());
             self.read_data(&mut blocks[0].contents).await?;
+            #[cfg(feature = "rtos-trace")]
+            rtos_trace::trace::marker_end(Marker::SDCardReadInnerReadData.into());
         } else {
             // Start a multi-block read
             self.card_command(CMD18, start_idx).await?;
@@ -282,6 +310,8 @@ where
 
     /// Read one or more blocks, starting at the given block index.
     async fn read(&mut self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), Error> {
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_begin(Marker::SDCardRead.into());
         let start_idx = match self.card_type {
             Some(CardType::SD1 | CardType::SD2) => start_block_idx.0 * 512,
             Some(CardType::SDHC) => start_block_idx.0,
@@ -290,6 +320,8 @@ where
         self.cs_low()?;
         let result = self.read_inner(blocks, start_idx).await;
         self.cs_high()?;
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_end(Marker::SDCardRead.into());
         result
     }
 
@@ -439,7 +471,11 @@ where
         for b in buffer.iter_mut() {
             *b = 0xFF;
         }
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_begin(Marker::SDCardReadInnerTransferBuffer.into());
         self.transfer_bytes(buffer).await?;
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_end(Marker::SDCardReadInnerTransferBuffer.into());
 
         // These two bytes are always sent. They are either a valid CRC, or
         // junk, depending on whether CRC mode was enabled.
@@ -601,7 +637,11 @@ where
     /// Perform a command.
     async fn card_command(&mut self, command: u8, arg: u32) -> Result<u8, Error> {
         if command != CMD0 && command != CMD12 {
+            // #[cfg(feature = "rtos-trace")]
+            // rtos_trace::trace::marker_begin(Marker::SDCardReadInnerCardCommandWaitNotBusy.into());
             self.wait_not_busy(Delay::new_command()).await?;
+            // #[cfg(feature = "rtos-trace")]
+            // rtos_trace::trace::marker_end(Marker::SDCardReadInnerCardCommandWaitNotBusy.into());
         }
 
         let mut buf = [
@@ -614,22 +654,37 @@ where
         ];
         buf[5] = crc7(&buf[0..5]);
 
+        // #[cfg(feature = "rtos-trace")]
+        // rtos_trace::trace::marker_begin(Marker::SDCardReadInnerCardCommandWriteInfo.into());
         self.write_bytes(&buf).await?;
+        // #[cfg(feature = "rtos-trace")]
+        // rtos_trace::trace::marker_end(Marker::SDCardReadInnerCardCommandWriteInfo.into());
 
         // skip stuff byte for stop read
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_begin(Marker::SDCardReadInnerCardCommandWaitReady.into());
         if command == CMD12 {
             let _result = self.read_byte().await?;
         }
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_end(Marker::SDCardReadInnerCardCommandWaitReady.into());
 
         let mut delay = Delay::new_command();
+        #[cfg(feature = "rtos-trace")]
+        rtos_trace::trace::marker_begin(Marker::SDCardReadInnerCardCommandWaitOk.into());
         loop {
             let result = self.read_byte().await?;
             if (result & 0x80) == ERROR_OK {
                 return Ok(result);
             }
-            delay
+            let res = delay
                 .delay(&mut self.delayer, Error::TimeoutCommand(command))
-                .await?;
+                .await;
+            if let Err(e) = res {
+                #[cfg(feature = "rtos-trace")]
+                rtos_trace::trace::marker_end(Marker::SDCardReadInnerCardCommandWaitOk.into());
+                return Err(e);
+            }
         }
     }