Add Retimer FW status get/set command (#298)

Add Retimer FW status get/set command

---------

Co-authored-by: zhuyi <zhuyi@microsoft.com>

Author: zhuyi2024

Cargo.lock

@@ -92,6 +92,12 @@ pub enum PortCommandData {
     PortStatus,
     /// Get and clear events
     ClearEvents,
+    /// Get retimer fw update state
+    RetimerFwUpdateGetState,
+    /// Set retimer fw update state
+    RetimerFwUpdateSetState,
+    /// Clear retimer fw update state
+    RetimerFwUpdateClearState,
 }
 
 /// Port-specific commands
@@ -104,6 +110,16 @@ pub struct PortCommand {
     pub data: PortCommandData,
 }
 
+/// PD controller command-specific data
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum RetimerFwUpdateState {
+    /// Retimer FW Update Inactive
+    Inactive,
+    /// Revimer FW Update Active
+    Active,
+}
+
 /// Port-specific response data
 #[derive(Copy, Clone, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -114,6 +130,8 @@ pub enum PortResponseData {
     PortStatus(PortStatus),
     /// ClearEvents
     ClearEvents(PortEventKind),
+    /// Retimer Fw Update status
+    RtFwUpdateStatus(RetimerFwUpdateState),
 }
 
 impl PortResponseData {
@@ -311,6 +329,18 @@ pub trait Controller {
     /// Returns the port status
     fn get_port_status(&mut self, port: LocalPortId)
         -> impl Future<Output = Result<PortStatus, Error<Self::BusError>>>;
+    /// Returns the retimer fw update state
+    fn get_rt_fw_update_status(
+        &mut self,
+        port: LocalPortId,
+    ) -> impl Future<Output = Result<RetimerFwUpdateState, Error<Self::BusError>>>;
+    /// Set retimer fw update state
+    fn set_rt_fw_update_state(&mut self, port: LocalPortId) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
+    /// Clear retimer fw update state
+    fn clear_rt_fw_update_state(
+        &mut self,
+        port: LocalPortId,
+    ) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
     /// Enable or disable sink path
     fn enable_sink_path(
         &mut self,
@@ -596,6 +626,39 @@ impl ContextToken {
         }
     }
 
+    /// Get the retimer fw update status
+    pub async fn get_rt_fw_update_status(&self, port: GlobalPortId) -> Result<RetimerFwUpdateState, PdError> {
+        match self
+            .send_port_command(port, PortCommandData::RetimerFwUpdateGetState)
+            .await?
+        {
+            PortResponseData::RtFwUpdateStatus(status) => Ok(status),
+            _ => Err(PdError::InvalidResponse),
+        }
+    }
+
+    /// Set the retimer fw update state
+    pub async fn set_rt_fw_update_state(&self, port: GlobalPortId) -> Result<(), PdError> {
+        match self
+            .send_port_command(port, PortCommandData::RetimerFwUpdateSetState)
+            .await?
+        {
+            PortResponseData::Complete => Ok(()),
+            _ => Err(PdError::InvalidResponse),
+        }
+    }
+
+    /// Clear the retimer fw update state
+    pub async fn clear_rt_fw_update_state(&self, port: GlobalPortId) -> Result<(), PdError> {
+        match self
+            .send_port_command(port, PortCommandData::RetimerFwUpdateClearState)
+            .await?
+        {
+            PortResponseData::Complete => Ok(()),
+            _ => Err(PdError::InvalidResponse),
+        }
+    }
+
     /// Get current controller status
     pub async fn get_controller_status(
         &self,

embedded-service/src/type_c/controller.rs

@@ -4,7 +4,7 @@ use embedded_usb_pd::{GlobalPortId, PdError, PortId as LocalPortId};
 use super::{
     controller::{
         execute_external_controller_command, execute_external_port_command, lookup_controller, ControllerStatus,
-        PortStatus,
+        PortStatus, RetimerFwUpdateState,
     },
     ControllerId,
 };
@@ -44,6 +44,12 @@ pub type ControllerResponse<'a> = Result<ControllerResponseData<'a>, PdError>;
 pub enum PortCommandData {
     /// Get port status
     PortStatus,
+    /// Get retimer fw update status
+    RetimerFwUpdateGetState,
+    /// Set retimer fw update status
+    RetimerFwUpdateSetState,
+    /// Clear retimer fw update status
+    RetimerFwUpdateClearState,
 }
 
 /// Port-specific commands
@@ -60,8 +66,12 @@ pub struct PortCommand {
 #[derive(Copy, Clone, Debug)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum PortResponseData {
+    /// Command completed with no error
+    Complete,
     /// Get port status
     PortStatus(PortStatus),
+    /// Get retimer fw update status
+    RetimerFwUpdateGetState(RetimerFwUpdateState),
 }
 
 /// Port-specific command response
@@ -88,7 +98,6 @@ pub enum Response<'a> {
 }
 
 /// Get the status of the given port
-#[allow(unreachable_patterns)]
 pub async fn get_port_status(port: GlobalPortId) -> Result<PortStatus, PdError> {
     match execute_external_port_command(Command::Port(PortCommand {
         port,
@@ -133,3 +142,42 @@ pub async fn controller_port_to_global_id(
 ) -> Result<GlobalPortId, PdError> {
     lookup_controller(controller_id).await?.lookup_global_port(port_id)
 }
+
+/// Get the retimer fw update status of the given port
+pub async fn port_get_rt_fw_update_status(port: GlobalPortId) -> Result<RetimerFwUpdateState, PdError> {
+    match execute_external_port_command(Command::Port(PortCommand {
+        port,
+        data: PortCommandData::RetimerFwUpdateGetState,
+    }))
+    .await?
+    {
+        PortResponseData::RetimerFwUpdateGetState(status) => Ok(status),
+        _ => Err(PdError::InvalidResponse),
+    }
+}
+
+/// Set the retimer fw update state of the given port
+pub async fn port_set_rt_fw_update_state(port: GlobalPortId) -> Result<(), PdError> {
+    match execute_external_port_command(Command::Port(PortCommand {
+        port,
+        data: PortCommandData::RetimerFwUpdateSetState,
+    }))
+    .await?
+    {
+        PortResponseData::Complete => Ok(()),
+        _ => Err(PdError::InvalidResponse),
+    }
+}
+
+/// Clear the retimer fw update state of the given port
+pub async fn port_clear_rt_fw_update_state(port: GlobalPortId) -> Result<(), PdError> {
+    match execute_external_port_command(Command::Port(PortCommand {
+        port,
+        data: PortCommandData::RetimerFwUpdateClearState,
+    }))
+    .await?
+    {
+        PortResponseData::Complete => Ok(()),
+        _ => Err(PdError::InvalidResponse),
+    }
+}

embedded-service/src/type_c/external.rs

@@ -17,6 +17,18 @@ async fn task(_spawner: Spawner) {
     info!("Getting port status");
     let port_status = external::get_port_status(GlobalPortId(0)).await.unwrap();
     info!("Port status: {:?}", port_status);
+
+    info!("Getting retimer fw update status");
+    let rt_fw_update_status = external::port_get_rt_fw_update_status(GlobalPortId(0)).await.unwrap();
+    info!("Port status: {:?}", rt_fw_update_status);
+
+    info!("Setting retimer fw update state");
+    let cmd_state = external::port_set_rt_fw_update_state(GlobalPortId(0)).await.unwrap();
+    info!("Set retimer fw update state: {:?}", cmd_state);
+
+    info!("Clearing retimer fw update state");
+    let cmd_state = external::get_port_status(GlobalPortId(0)).await.unwrap();
+    info!("Clear retimer fw update state: {:?}", cmd_state);
 }
 
 fn main() {

examples/rt685s-evk/Cargo.lock

@@ -25,7 +25,7 @@ mod test_controller {
 
     use embassy_sync::{blocking_mutex::raw::NoopRawMutex, signal::Signal};
     use embedded_services::type_c::{
-        controller::{Contract, ControllerStatus, PortStatus},
+        controller::{Contract, ControllerStatus, PortStatus, RetimerFwUpdateState},
         event::PortEventKind,
     };
 
@@ -168,8 +168,25 @@ mod test_controller {
                 fw_version1: 0xdeadbeef,
             })
         }
-    }
 
+        async fn get_rt_fw_update_status(
+            &mut self,
+            _port: LocalPortId,
+        ) -> Result<RetimerFwUpdateState, Error<Self::BusError>> {
+            debug!("Get retimer fw update status");
+            Ok(RetimerFwUpdateState::Inactive)
+        }
+
+        async fn set_rt_fw_update_state(&mut self, _port: LocalPortId) -> Result<(), Error<Self::BusError>> {
+            debug!("Get set fw update status");
+            Ok(())
+        }
+
+        async fn clear_rt_fw_update_state(&mut self, _port: LocalPortId) -> Result<(), Error<Self::BusError>> {
+            debug!("Get clear fw update status");
+            Ok(())
+        }
+    }
     pub type Wrapper<'a> = type_c_service::wrapper::ControllerWrapper<'a, 1, Controller<'a>>;
 }
 

examples/std/Cargo.lock

@@ -259,6 +259,31 @@ impl<const N: usize, M: RawMutex, B: I2c> Controller for Tps6699x<'_, N, M, B> {
         Ok(self.port_status[port.0 as usize].get())
     }
 
+    #[allow(clippy::await_holding_refcell_ref)]
+    async fn get_rt_fw_update_status(
+        &mut self,
+        port: LocalPortId,
+    ) -> Result<type_c::controller::RetimerFwUpdateState, Error<Self::BusError>> {
+        let mut tps6699x = self.tps6699x.borrow_mut();
+        match tps6699x.get_rt_fw_update_status(port).await {
+            Ok(true) => Ok(type_c::controller::RetimerFwUpdateState::Active),
+            Ok(false) => Ok(type_c::controller::RetimerFwUpdateState::Inactive),
+            Err(e) => Err(e),
+        }
+    }
+
+    #[allow(clippy::await_holding_refcell_ref)]
+    async fn set_rt_fw_update_state(&mut self, port: LocalPortId) -> Result<(), Error<Self::BusError>> {
+        let mut tps6699x = self.tps6699x.borrow_mut();
+        tps6699x.set_rt_fw_update_state(port).await
+    }
+
+    #[allow(clippy::await_holding_refcell_ref)]
+    async fn clear_rt_fw_update_state(&mut self, port: LocalPortId) -> Result<(), Error<Self::BusError>> {
+        let mut tps6699x = self.tps6699x.borrow_mut();
+        tps6699x.clear_rt_fw_update_state(port).await
+    }
+
     #[allow(clippy::await_holding_refcell_ref)]
     async fn enable_sink_path(&mut self, port: LocalPortId, enable: bool) -> Result<(), Error<Self::BusError>> {
         debug!("Port{} enable sink path: {}", port.0, enable);