Add more information to PortStatus command (#389)

1. Add plug_orientation, power_role, data_role to PortStatus command
2. Fix Power switch
3. Add argument "cached" in get_port_status() to call
update_port_status() to get the latest port status

---------

Co-authored-by: zhuyi <zhuyi@microsoft.com>
Co-authored-by: Adam Sasine <adam.sasine@gmail.com>

Author: 3 people

Cargo.lock

@@ -7,7 +7,7 @@ use embassy_sync::signal::Signal;
 use embassy_time::{Duration, with_timeout};
 use embedded_usb_pd::ucsi::lpm;
 use embedded_usb_pd::{
-    Error, GlobalPortId, PdError, PortId as LocalPortId,
+    DataRole, Error, GlobalPortId, PdError, PlugOrientation, PortId as LocalPortId, PowerRole,
     pdinfo::{AltMode, PowerPathStatus},
     type_c::ConnectionState,
 };
@@ -40,6 +40,12 @@ pub struct PortStatus {
     pub connection_state: Option<ConnectionState>,
     /// Port partner supports dual-power roles
     pub dual_power: bool,
+    /// plug orientation
+    pub plug_orientation: PlugOrientation,
+    /// power role
+    pub power_role: PowerRole,
+    /// data role
+    pub data_role: DataRole,
     /// Active alt-modes
     pub alt_mode: AltMode,
     /// Power path status
@@ -55,6 +61,9 @@ impl PortStatus {
             available_sink_contract: None,
             connection_state: None,
             dual_power: false,
+            plug_orientation: PlugOrientation::CC1,
+            power_role: PowerRole::Sink,
+            data_role: DataRole::Dfp,
             alt_mode: AltMode::none(),
             power_path: PowerPathStatus::none(),
         }
@@ -87,7 +96,7 @@ impl Default for PortStatus {
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum PortCommandData {
     /// Get port status
-    PortStatus,
+    PortStatus(bool),
     /// Get and clear events
     ClearEvents,
     /// Get retimer fw update state
@@ -313,8 +322,12 @@ pub trait Controller {
         port: LocalPortId,
     ) -> impl Future<Output = Result<PortEventKind, Error<Self::BusError>>>;
     /// Returns the port status
-    fn get_port_status(&mut self, port: LocalPortId)
-    -> impl Future<Output = Result<PortStatus, Error<Self::BusError>>>;
+    fn get_port_status(
+        &mut self,
+        port: LocalPortId,
+        cached: bool,
+    ) -> impl Future<Output = Result<PortStatus, Error<Self::BusError>>>;
+
     /// Returns the retimer fw update state
     fn get_rt_fw_update_status(
         &mut self,
@@ -620,8 +633,11 @@ impl ContextToken {
     }
 
     /// Get the current port status
-    pub async fn get_port_status(&self, port: GlobalPortId) -> Result<PortStatus, PdError> {
-        match self.send_port_command(port, PortCommandData::PortStatus).await? {
+    pub async fn get_port_status(&self, port: GlobalPortId, cached: bool) -> Result<PortStatus, PdError> {
+        match self
+            .send_port_command(port, PortCommandData::PortStatus(cached))
+            .await?
+        {
             PortResponseData::PortStatus(status) => Ok(status),
             r => {
                 error!("Invalid response: expected port status, got {:?}", r);

embedded-service/src/type_c/controller.rs

@@ -47,7 +47,7 @@ pub type ControllerResponse<'a> = Result<ControllerResponseData<'a>, PdError>;
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum PortCommandData {
     /// Get port status
-    PortStatus,
+    PortStatus(bool),
     /// Get retimer fw update status
     RetimerFwUpdateGetState,
     /// Set retimer fw update status
@@ -107,7 +107,7 @@ pub enum Response<'a> {
 pub async fn get_port_status(port: GlobalPortId) -> Result<PortStatus, PdError> {
     match execute_external_port_command(Command::Port(PortCommand {
         port,
-        data: PortCommandData::PortStatus,
+        data: PortCommandData::PortStatus(false),
     }))
     .await?
     {

embedded-service/src/type_c/external.rs

@@ -2,7 +2,7 @@ use embassy_executor::{Executor, Spawner};
 use embassy_sync::once_lock::OnceLock;
 use embassy_time::Timer;
 use embedded_services::power;
-use embedded_services::type_c::{controller, ControllerId};
+use embedded_services::type_c::{ControllerId, controller};
 use embedded_usb_pd::ucsi::lpm;
 use embedded_usb_pd::{GlobalPortId, PdError as Error};
 use log::*;
@@ -82,7 +82,7 @@ mod test_controller {
             command: controller::PortCommand,
         ) -> Result<controller::PortResponseData, Error> {
             Ok(match command.data {
-                controller::PortCommandData::PortStatus => {
+                controller::PortCommandData::PortStatus(true) => {
                     info!("Port status for port {}", command.port.0);
                     controller::PortResponseData::PortStatus(PortStatus::new())
                 }
@@ -149,10 +149,10 @@ async fn task(spawner: Spawner) {
     let status = context.get_controller_status(CONTROLLER0).await.unwrap();
     info!("Controller 0 status: {status:#?}");
 
-    let status = context.get_port_status(PORT0).await.unwrap();
+    let status = context.get_port_status(PORT0, true).await.unwrap();
     info!("Port 0 status: {status:#?}");
 
-    let status = context.get_port_status(PORT1).await.unwrap();
+    let status = context.get_port_status(PORT1, true).await.unwrap();
     info!("Port 1 status: {status:#?}");
 }
 

examples/rt633/Cargo.lock

@@ -1,6 +1,6 @@
 //! Low-level example of external messaging with a simple type-C service
 use embassy_executor::{Executor, Spawner};
-use embedded_services::type_c::{external, ControllerId};
+use embedded_services::type_c::{ControllerId, external};
 use embedded_usb_pd::GlobalPortId;
 use log::*;
 use static_cell::StaticCell;

examples/rt685s-evk/Cargo.lock

@@ -120,7 +120,11 @@ mod test_controller {
             Ok(events)
         }
 
-        async fn get_port_status(&mut self, _port: LocalPortId) -> Result<PortStatus, Error<Self::BusError>> {
+        async fn get_port_status(
+            &mut self,
+            _port: LocalPortId,
+            _cached: bool,
+        ) -> Result<PortStatus, Error<Self::BusError>> {
             debug!("Get port status: {:#?}", *self.state.status.lock().await);
             Ok(*self.state.status.lock().await)
         }

examples/std/Cargo.lock

@@ -21,7 +21,7 @@ use embedded_services::{debug, info, trace, type_c, warn, GlobalRawMutex};
 use embedded_usb_pd::pdinfo::PowerPathStatus;
 use embedded_usb_pd::pdo::{sink, source, Common, Rdo};
 use embedded_usb_pd::type_c::Current as TypecCurrent;
-use embedded_usb_pd::{Error, GlobalPortId, PdError, PortId as LocalPortId};
+use embedded_usb_pd::{DataRole, Error, GlobalPortId, PdError, PlugOrientation, PortId as LocalPortId, PowerRole};
 use tps6699x::asynchronous::embassy as tps6699x_drv;
 use tps6699x::asynchronous::fw_update::UpdateTarget;
 use tps6699x::asynchronous::fw_update::{
@@ -136,6 +136,22 @@ impl<'a, const N: usize, M: RawMutex, B: I2c> Tps6699x<'a, N, M, B> {
                 port_status.available_sink_contract = new_contract;
             }
 
+            port_status.plug_orientation = if status.plug_orientation() {
+                PlugOrientation::CC2
+            } else {
+                PlugOrientation::CC1
+            };
+            port_status.power_role = if status.port_role() {
+                PowerRole::Source
+            } else {
+                PowerRole::Sink
+            };
+            port_status.data_role = if status.data_role() {
+                DataRole::Dfp
+            } else {
+                DataRole::Ufp
+            };
+
             // Update alt-mode status
             let alt_mode = tps6699x.get_alt_mode_status(port).await?;
             debug!("Port{} alt mode: {:#?}", port.0, alt_mode);
@@ -145,12 +161,12 @@ impl<'a, const N: usize, M: RawMutex, B: I2c> Tps6699x<'a, N, M, B> {
             let power_path = tps6699x.get_power_path_status(port).await?;
             port_status.power_path = match port {
                 PORT0 => PowerPathStatus::new(
-                    power_path.pa_ext_vbus_sw() == PpExtVbusSw::EnabledInput,
                     power_path.pa_int_vbus_sw() == PpIntVbusSw::EnabledOutput,
+                    power_path.pa_ext_vbus_sw() == PpExtVbusSw::EnabledInput,
                 ),
                 PORT1 => PowerPathStatus::new(
-                    power_path.pb_ext_vbus_sw() == PpExtVbusSw::EnabledInput,
                     power_path.pb_int_vbus_sw() == PpIntVbusSw::EnabledOutput,
+                    power_path.pb_ext_vbus_sw() == PpExtVbusSw::EnabledInput,
                 ),
                 _ => Err(PdError::InvalidPort)?,
             };
@@ -349,11 +365,26 @@ impl<const N: usize, M: RawMutex, B: I2c> Controller for Tps6699x<'_, N, M, B> {
     async fn get_port_status(
         &mut self,
         port: LocalPortId,
+        cached: bool,
     ) -> Result<type_c::controller::PortStatus, Error<Self::BusError>> {
         if port.0 >= self.port_status.len() as u8 {
             return PdError::InvalidPort.into();
         }
 
+        // sync port status
+        if !cached {
+            debug!("update port status");
+
+            let mut tps6699x = self
+                .tps6699x
+                .try_lock()
+                .expect("Driver should not have been locked before this, thus infallible");
+
+            let _ = self.update_port_status(&mut tps6699x, port).await;
+        } else {
+            debug!("using cached port status");
+        }
+
         Ok(*self.port_status[port.0 as usize].lock().await)
     }