refactor: read system attributes

Signed-off-by: Adrian Lungu <lunguadrian30@gmail.com>

Author: addrian-77

tockloader-lib/src/attributes/system_attributes.rs

@@ -3,11 +3,9 @@
 // Copyright OXIDOS AUTOMOTIVE 2024.
 
 use byteorder::{ByteOrder, LittleEndian};
-use probe_rs::{Core, MemoryInterface};
-use tokio_serial::SerialStream;
 
-use crate::bootloader_serial::{issue_command, Command, Response};
 use crate::errors::{AttributeParseError, TockError, TockloaderError};
+use crate::IO;
 
 use super::decode::{bytes_to_string, decode_attribute};
 
@@ -50,29 +48,27 @@ impl SystemAttributes {
         }
     }
 
-    /// Read system attributes using a probe-rs connection. A bootloader must be
+    /// Read system attributes using a generalized connection. A bootloader must be
     /// present on this board for this function to work properly.
     ///
     /// # Parameters
-    /// - `board_core` : Core access, obtained from a
-    ///   [ProbeRSConnection](crate::connection::ProbeRSConnection)
+    /// - `conn` : Either a SerialConnection or a ProbeRSConnection
     ///
     /// # Returns
     /// - Ok(result): if attributes were read successfully
     /// - Err(TockloaderError::MisconfiguredBoard): if no start address is found or valid
     /// - Err(TockloaderError::MisconfiguredBoard): if attributes don't follow the UTF-8 format
-    /// - Err(TockloaderError::ProbeRsReadError): if reading fails
-    pub(crate) fn read_system_attributes_probe(
-        board_core: &mut Core,
-    ) -> Result<Self, TockloaderError> {
+    /// - Err(TockloaderError::ProbeRsReadError): if reading fails on ProbeRS
+    /// - Err(TockloaderError::SerialReadError): if reading fails on Serial
+    pub(crate) async fn read_system_attributes(
+        conn: &mut dyn IO,
+    ) -> Result<SystemAttributes, TockloaderError> {
         let mut result = SystemAttributes::new();
         // System attributes start at 0x600 and up to 0x9FF. See:
         // https://book.tockos.org/doc/memory_layout#flash-1
         let address = 0x600;
-        // Each attribute is 64 bytes exactly, and there are 16 slots
-        let mut buf = [0u8; 64 * 16];
 
-        board_core.read(address, &mut buf)?;
+        let buf = conn.read(address, 64 * 16).await?;
 
         let mut data = buf.chunks(64);
 
@@ -125,9 +121,8 @@ impl SystemAttributes {
         // TODO(george-cosma): separate kernel attributes from kernel flags.
 
         let address = 0x40E;
-        let mut buf = [0u8; 8];
 
-        board_core.read_8(address, &mut buf)?;
+        let buf = conn.read(address, 8).await?;
 
         let string = String::from_utf8(buf.to_vec())
             .map_err(|e| TockError::AttributeParsing(AttributeParseError::InvalidString(e)))?;
@@ -137,151 +132,11 @@ impl SystemAttributes {
         result.bootloader_version = Some(string.to_owned());
 
         // The 100 bytes prior to the application start address are reserved for the kernel attributes and flags
-        let mut kernel_attr_binary = [0u8; 100];
         let kernel_attr_addr = result
             .appaddr
             .ok_or(TockError::MissingAttribute("appaddr".to_owned()))?
             - 100;
-        board_core.read(kernel_attr_addr, &mut kernel_attr_binary)?;
-
-        let sentinel = bytes_to_string(&kernel_attr_binary[96..100]);
-        let kernel_version = LittleEndian::read_uint(&kernel_attr_binary[95..96], 1);
-
-        let app_memory_len = LittleEndian::read_u32(&kernel_attr_binary[84..92]);
-        let app_memory_start = LittleEndian::read_u32(&kernel_attr_binary[80..84]);
-
-        let kernel_binary_start = LittleEndian::read_u32(&kernel_attr_binary[68..72]);
-        let kernel_binary_len = LittleEndian::read_u32(&kernel_attr_binary[72..76]);
-
-        result.sentinel = Some(sentinel);
-        result.kernel_version = Some(kernel_version);
-        result.app_mem_start = Some(app_memory_start);
-        result.app_mem_len = Some(app_memory_len);
-        result.kernel_bin_start = Some(kernel_binary_start);
-        result.kernel_bin_len = Some(kernel_binary_len);
-
-        Ok(result)
-    }
-
-    /// Read system attributes using a serial connection. A bootloader must be
-    /// present on this board for this function to work properly.
-    ///
-    /// # Parameters
-    /// - `port`: Serial access, obtained from a
-    ///   [SerialConnection](crate::connection::SerialConnection)
-    ///
-    /// # Returns
-    /// - Ok(result): if attributes were read successfully
-    /// - Err(TockloaderError::MisconfiguredBoard): if no start address is found or valid
-    /// - Err(TockloaderError::MisconfiguredBoard): if attributes don't follow the UTF-8 format
-    /// - Err(TockloaderError::SerialReadError): if reading fails
-    pub(crate) async fn read_system_attributes_serial(
-        port: &mut SerialStream,
-    ) -> Result<Self, TockloaderError> {
-        let mut result = SystemAttributes::new();
-
-        // System attributes start at 0x600 and up to 0x9FF. See:
-        // https://book.tockos.org/doc/memory_layout#flash-1
-        let mut pkt = (0x600_u32).to_le_bytes().to_vec();
-        // Each attribute is 64 bytes exactly, and there are 16 slots
-        let length = (1024_u16).to_le_bytes().to_vec();
-        for i in length {
-            pkt.push(i);
-        }
-
-        // Read the kernel attributes
-        let (_, buf) = issue_command(
-            port,
-            Command::ReadRange,
-            pkt,
-            true,
-            64 * 16,
-            Response::ReadRange,
-        )
-        .await?;
-
-        let mut data = buf.chunks(64);
-
-        for current_slot in 0..data.len() {
-            let slot_data = match data.next() {
-                Some(data) => data,
-                None => break,
-            };
-
-            if let Some(decoded_attributes) = decode_attribute(slot_data) {
-                match current_slot {
-                    0 => {
-                        result.board = Some(decoded_attributes.value.to_string());
-                    }
-                    1 => {
-                        result.arch = Some(decoded_attributes.value.to_string());
-                    }
-                    2 => {
-                        // Parse hex string like "0x40000" into actual u64 value
-                        result.appaddr = Some(
-                            u64::from_str_radix(
-                                decoded_attributes
-                                    .value
-                                    .to_string()
-                                    .trim_start_matches("0x"),
-                                16,
-                            )
-                            .map_err(|e| {
-                                TockError::AttributeParsing(AttributeParseError::InvalidNumber(e))
-                            })?,
-                        );
-                    }
-                    3 => {
-                        result.boothash = Some(decoded_attributes.value.to_string());
-                    }
-                    _ => {}
-                }
-            } else {
-                continue;
-            }
-        }
-
-        // TODO(george-cosma): separate kernel attributes from kernel flags.
-
-        let mut pkt = (0x40E_u32).to_le_bytes().to_vec();
-        let length = (8_u16).to_le_bytes().to_vec();
-        for i in length {
-            pkt.push(i);
-        }
-
-        // Read bootloader version
-        let (_, buf) =
-            issue_command(port, Command::ReadRange, pkt, true, 8, Response::ReadRange).await?;
-
-        let string = String::from_utf8(buf)
-            .map_err(|e| TockError::AttributeParsing(AttributeParseError::InvalidString(e)))?;
-
-        // Strip null bytes
-        let string = string.trim_matches(char::from(0));
-        result.bootloader_version = Some(string.to_owned());
-
-        // The 100 bytes prior to the application start address are reserved
-        // for the kernel attributes and flags
-        let kernel_attr_addr = (result
-            .appaddr
-            .ok_or(TockError::MissingAttribute("appaddr".to_owned()))?
-            - 100) as u32;
-        let mut pkt = kernel_attr_addr.to_le_bytes().to_vec();
-        let length = (100_u16).to_le_bytes().to_vec();
-        for i in length {
-            pkt.push(i);
-        }
-
-        // Read kernel flags
-        let (_, kernel_attr_binary) = issue_command(
-            port,
-            Command::ReadRange,
-            pkt,
-            true,
-            100,
-            Response::ReadRange,
-        )
-        .await?;
+        let kernel_attr_binary = conn.read(kernel_attr_addr, 100).await?;
 
         let sentinel = bytes_to_string(&kernel_attr_binary[96..100]);
         let kernel_version = LittleEndian::read_uint(&kernel_attr_binary[95..96], 1);

tockloader-lib/src/command_impl/probers/io.rs

@@ -56,11 +56,7 @@ impl IOCommands for ProbeRSConnection {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
         }
-        let session = self.session.as_mut().expect("Board must be open");
-
-        let mut core = session.core(self.target_info.core)?;
-
-        let system_attributes = SystemAttributes::read_system_attributes_probe(&mut core)?;
+        let system_attributes = SystemAttributes::read_system_attributes(self).await?;
         Ok(system_attributes)
     }
 }

tockloader-lib/src/command_impl/serial/io.rs

@@ -83,7 +83,7 @@ impl IOCommands for SerialConnection {
 
         ping_bootloader_and_wait_for_response(stream).await?;
 
-        let system_attributes = SystemAttributes::read_system_attributes_serial(stream).await?;
+        let system_attributes = SystemAttributes::read_system_attributes(self).await?;
         Ok(system_attributes)
     }
 }