Fix usbc charge fail issue (#329)

1. Add new event source_caps_received and sink_ready for future use.
2. Set default usb current to 900mA for now to follow G3.
3. Call
set_new_power_contract_as_consumer/set_new_power_contract_as_provider
only when there is int event indicating that power negotiation is
complete.
4. Fix process_new_consumer_contract from ConnectedProvider state issue
5. Remove pr_swap and unused code.
6. Update some comments and function name for easy understanding.

---------

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

Author: zhuyi2024

Cargo.lock

@@ -69,7 +69,7 @@ impl<'a, S: Kind> Device<'a, S> {
         capability: Option<PowerCapability>,
     ) -> Result<(), Error> {
         info!(
-            "Device {} consume capability updated {:#?}",
+            "Device {} consume capability updated: {:#?}",
             self.device.id().0,
             capability
         );
@@ -150,4 +150,9 @@ impl<'a> Device<'a, ConnectedProvider> {
     pub async fn request_provider_power_capability(&self, capability: PowerCapability) -> Result<(), Error> {
         self.request_provider_power_capability_internal(capability).await
     }
+
+    /// Notify the power policy service of an updated consumer power capability
+    pub async fn notify_consumer_power_capability(&self, capability: Option<PowerCapability>) -> Result<(), Error> {
+        self.notify_consumer_power_capability_internal(capability).await
+    }
 }

embedded-service/src/power/policy/action/device.rs

@@ -66,12 +66,12 @@ impl<'a, S: Kind> Policy<'a, S> {
         }
     }
 
-    /// Common connect provider function used by multiple states
-    async fn connect_provider_internal_no_timeout(&self, capability: PowerCapability) -> Result<(), Error> {
+    /// Common connect as provider function used by multiple states
+    async fn connect_as_provider_internal_no_timeout(&self, capability: PowerCapability) -> Result<(), Error> {
         info!("Device {} connecting provider", self.device.id().0);
 
         self.device
-            .execute_device_command(device::CommandData::ConnectProvider(capability))
+            .execute_device_command(device::CommandData::ConnectAsProvider(capability))
             .await?
             .complete_or_err()?;
 
@@ -84,7 +84,12 @@ impl<'a, S: Kind> Policy<'a, S> {
 
     /// Common connect provider function used by multiple states
     async fn connect_provider_internal(&self, capability: PowerCapability) -> Result<(), Error> {
-        match with_timeout(DEFAULT_TIMEOUT, self.connect_provider_internal_no_timeout(capability)).await {
+        match with_timeout(
+            DEFAULT_TIMEOUT,
+            self.connect_as_provider_internal_no_timeout(capability),
+        )
+        .await
+        {
             Ok(r) => r,
             Err(TimeoutError) => Err(Error::Timeout),
         }
@@ -96,14 +101,14 @@ impl Policy<'_, Detached> {}
 
 impl<'a> Policy<'a, Idle> {
     /// Connect this device as a consumer
-    pub async fn connect_consumer_no_timeout(
+    pub async fn connect_as_consumer_no_timeout(
         self,
         capability: PowerCapability,
     ) -> Result<Policy<'a, ConnectedConsumer>, Error> {
-        info!("Device {} connecting consumer", self.device.id().0);
+        info!("Device {} connecting as consumer", self.device.id().0);
 
         self.device
-            .execute_device_command(device::CommandData::ConnectConsumer(capability))
+            .execute_device_command(device::CommandData::ConnectAsConsumer(capability))
             .await?
             .complete_or_err()?;
 
@@ -115,7 +120,7 @@ impl<'a> Policy<'a, Idle> {
 
     /// Connect this device as a consumer
     pub async fn connect_consumer(self, capability: PowerCapability) -> Result<Policy<'a, ConnectedConsumer>, Error> {
-        match with_timeout(DEFAULT_TIMEOUT, self.connect_consumer_no_timeout(capability)).await {
+        match with_timeout(DEFAULT_TIMEOUT, self.connect_as_consumer_no_timeout(capability)).await {
             Ok(r) => r,
             Err(TimeoutError) => Err(Error::Timeout),
         }
@@ -126,7 +131,7 @@ impl<'a> Policy<'a, Idle> {
         self,
         capability: PowerCapability,
     ) -> Result<Policy<'a, ConnectedProvider>, Error> {
-        self.connect_provider_internal_no_timeout(capability)
+        self.connect_as_provider_internal_no_timeout(capability)
             .await
             .map(|_| Policy::new(self.device))
     }
@@ -171,12 +176,38 @@ impl<'a> Policy<'a, ConnectedProvider> {
         }
     }
 
+    /// Connect this device as a consumer
+    pub async fn connect_as_consumer_no_timeout(
+        self,
+        capability: PowerCapability,
+    ) -> Result<Policy<'a, ConnectedConsumer>, Error> {
+        info!("Device {} connecting as consumer", self.device.id().0);
+
+        self.device
+            .execute_device_command(device::CommandData::ConnectAsConsumer(capability))
+            .await?
+            .complete_or_err()?;
+
+        self.device
+            .set_state(device::State::ConnectedConsumer(capability))
+            .await;
+        Ok(Policy::new(self.device))
+    }
+
+    /// Connect this device as a consumer
+    pub async fn connect_consumer(self, capability: PowerCapability) -> Result<Policy<'a, ConnectedConsumer>, Error> {
+        match with_timeout(DEFAULT_TIMEOUT, self.connect_as_consumer_no_timeout(capability)).await {
+            Ok(r) => r,
+            Err(TimeoutError) => Err(Error::Timeout),
+        }
+    }
+
     /// Connect this device as a provider
     pub async fn connect_provider_no_timeout(
         &self,
         capability: PowerCapability,
     ) -> Result<Policy<'a, ConnectedProvider>, Error> {
-        self.connect_provider_internal_no_timeout(capability)
+        self.connect_as_provider_internal_no_timeout(capability)
             .await
             .map(|_| Policy::new(self.device))
     }

embedded-service/src/power/policy/action/policy.rs

@@ -16,9 +16,9 @@ pub enum StateKind {
     Detached,
     /// Device is attached
     Idle,
-    /// Device is actively providing power
+    /// Device is actively providing power, USB PD source mode
     ConnectedProvider,
-    /// Device is actively consuming power
+    /// Device is actively consuming power, USB PD sink mode
     ConnectedConsumer,
 }
 
@@ -65,9 +65,9 @@ struct InternalState {
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum CommandData {
     /// Start consuming on this device
-    ConnectConsumer(PowerCapability),
-    /// Start providinig on this device
-    ConnectProvider(PowerCapability),
+    ConnectAsConsumer(PowerCapability),
+    /// Start providing power to port partner on this device
+    ConnectAsProvider(PowerCapability),
     /// Stop providing or consuming on this device
     Disconnect,
 }

embedded-service/src/power/policy/device.rs

@@ -347,25 +347,6 @@ pub trait Controller {
         port: LocalPortId,
         enable: bool,
     ) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
-    /// Enable or disable sourcing
-    fn set_sourcing(
-        &mut self,
-        port: LocalPortId,
-        enable: bool,
-    ) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
-    /// Set source current capability
-    fn set_source_current(
-        &mut self,
-        port: LocalPortId,
-        current: TypecCurrent,
-        signal_event: bool,
-    ) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
-    /// Initiate a power-role swap to the given role
-    fn request_pr_swap(
-        &mut self,
-        port: LocalPortId,
-        role: PowerRole,
-    ) -> impl Future<Output = Result<(), Error<Self::BusError>>>;
     /// Get current controller status
     fn get_controller_status(
         &mut self,

embedded-service/src/type_c/controller.rs

@@ -15,6 +15,10 @@ bitfield! {
     pub u8, new_power_contract_as_provider, set_new_power_contract_as_provider: 2, 2;
     /// New power contract as consumer
     pub u8, new_power_contract_as_consumer, set_new_power_contract_as_consumer: 3, 3;
+    /// Source Caps received
+    pub u8, source_caps_received, set_source_caps_received: 4, 4;
+    /// Sink ready
+    pub u8, sink_ready, set_sink_ready: 5, 5;
 }
 
 /// Type-safe wrapper for the raw port event kind
@@ -63,6 +67,26 @@ impl PortEventKind {
     pub fn set_new_power_contract_as_consumer(&mut self, value: bool) {
         self.0.set_new_power_contract_as_consumer(value.into());
     }
+
+    /// Returns true if a source caps msg received
+    pub fn source_caps_received(self) -> bool {
+        self.0.source_caps_received() != 0
+    }
+
+    /// Sets the source caps received event
+    pub fn set_source_caps_received(&mut self, value: bool) {
+        self.0.set_source_caps_received(value.into());
+    }
+
+    /// Returns true if a sink ready event triggered
+    pub fn sink_ready(self) -> bool {
+        self.0.sink_ready() != 0
+    }
+
+    /// Sets the sink ready event
+    pub fn set_sink_ready(&mut self, value: bool) {
+        self.0.set_sink_ready(value.into());
+    }
 }
 
 /// Bit vector type to store pending port events

embedded-service/src/type_c/event.rs

@@ -98,8 +98,8 @@ impl From<type_c::Current> for policy::PowerCapability {
     fn from(current: type_c::Current) -> Self {
         policy::PowerCapability {
             voltage_mv: 5000,
-            // Assume lower power for now
-            current_ma: current.to_ma(true),
+            // Assume higher power for now
+            current_ma: current.to_ma(false),
         }
     }
 }

embedded-service/src/type_c/mod.rs

@@ -176,6 +176,7 @@ async fn main(spawner: Spawner) {
             mask.set_intel_vid_status_updated(true);
             mask.set_usb_status_updated(true);
             mask.set_power_path_switch_changed(true);
+            mask.set_sink_ready(true);
             *mask
         })
         .await