type-c-service: Pull in PPM state machine changes (#487)

Author: RobertZ2011

Cargo.lock

@@ -1174,15 +1174,18 @@ pub(super) async fn execute_external_controller_command(
 }
 
 /// Execute an external UCSI command
-pub(super) async fn execute_external_ucsi_command(
-    command: ucsi::GlobalCommand,
-) -> Result<external::UcsiResponse, PdError> {
+pub(super) async fn execute_external_ucsi_command(command: ucsi::GlobalCommand) -> external::UcsiResponse {
     let context = CONTEXT.get().await;
     match context.external_command.execute(external::Command::Ucsi(command)).await {
         external::Response::Ucsi(response) => response,
         r => {
             error!("Invalid response: expected external UCSI, got {:?}", r);
-            Err(PdError::InvalidResponse)
+            external::UcsiResponse {
+                // Always notify OPM of an error
+                notify_opm: true,
+                cci: ucsi::cci::GlobalCci::new_error(),
+                data: Err(PdError::InvalidResponse),
+            }
         }
     }
 }

embedded-service/src/type_c/controller.rs

@@ -132,8 +132,22 @@ pub enum Command {
 pub struct UcsiResponse {
     /// Notify the OPM, the function call
     pub notify_opm: bool,
-    /// UCSI response
-    pub response: ucsi::GlobalResponse,
+    /// Response CCI
+    pub cci: ucsi::cci::GlobalCci,
+    /// UCSI response data
+    pub data: Result<Option<ucsi::ResponseData>, PdError>,
+}
+
+/// Alias to help simplify conversion into a result
+pub type UcsiResponseResult = Result<ucsi::GlobalResponse, PdError>;
+
+impl From<UcsiResponse> for UcsiResponseResult {
+    fn from(value: UcsiResponse) -> Self {
+        match value.data {
+            Ok(data) => Ok(ucsi::GlobalResponse { cci: value.cci, data }),
+            Err(err) => Err(err),
+        }
+    }
 }
 
 /// External command response for type-C service
@@ -145,7 +159,7 @@ pub enum Response<'a> {
     /// Controller command response
     Controller(ControllerResponse<'a>),
     /// UCSI command response
-    Ucsi(Result<UcsiResponse, PdError>),
+    Ucsi(UcsiResponse),
 }
 
 /// Get the status of the given port.
@@ -327,7 +341,7 @@ pub async fn reconfigure_retimer(port: GlobalPortId) -> Result<(), PdError> {
 }
 
 /// Execute a UCSI command
-pub async fn execute_ucsi_command(command: ucsi::GlobalCommand) -> Result<UcsiResponse, PdError> {
+pub async fn execute_ucsi_command(command: ucsi::GlobalCommand) -> UcsiResponse {
     execute_external_ucsi_command(command).await
 }
 

embedded-service/src/type_c/external.rs

@@ -1,9 +1,11 @@
 use embassy_executor::{Executor, Spawner};
 use embedded_services::type_c::controller;
-use embedded_services::type_c::external::execute_ucsi_command;
+use embedded_services::type_c::external::{UcsiResponseResult, execute_ucsi_command};
+use embedded_usb_pd::GlobalPortId;
+use embedded_usb_pd::ucsi::ppm::ack_cc_ci::Ack;
 use embedded_usb_pd::ucsi::ppm::get_capability::ResponseData as UcsiCapabilities;
 use embedded_usb_pd::ucsi::ppm::set_notification_enable::NotificationEnable;
-use embedded_usb_pd::ucsi::{Command, ppm};
+use embedded_usb_pd::ucsi::{Command, lpm, ppm};
 use log::*;
 use static_cell::StaticCell;
 use type_c_service::service::config::Config;
@@ -15,39 +17,98 @@ async fn task(_spawner: Spawner) {
     controller::init();
 
     info!("Resetting PPM...");
-    let response = execute_ucsi_command(Command::PpmCommand(ppm::Command::PpmReset))
+    let response: UcsiResponseResult = execute_ucsi_command(Command::PpmCommand(ppm::Command::PpmReset))
         .await
-        .unwrap();
-    if !response.response.cci.reset_complete() || response.response.cci.error() {
-        error!("PPM reset failed: {:?}", response.response.cci);
+        .into();
+    let response = response.unwrap();
+    if !response.cci.reset_complete() || response.cci.error() {
+        error!("PPM reset failed: {:?}", response.cci);
     } else {
         info!("PPM reset successful");
     }
 
     info!("Set Notification enable...");
     let mut notifications = NotificationEnable::default();
     notifications.set_cmd_complete(true);
-    let response = execute_ucsi_command(Command::PpmCommand(ppm::Command::SetNotificationEnable(
+    let response: UcsiResponseResult = execute_ucsi_command(Command::PpmCommand(ppm::Command::SetNotificationEnable(
         ppm::set_notification_enable::Args {
             notification_enable: notifications,
         },
     )))
     .await
-    .unwrap();
-    if !response.response.cci.cmd_complete() || response.response.cci.error() {
-        error!("Set Notification enable failed: {:?}", response.response.cci);
+    .into();
+    let response = response.unwrap();
+    if !response.cci.cmd_complete() || response.cci.error() {
+        error!("Set Notification enable failed: {:?}", response.cci);
     } else {
         info!("Set Notification enable successful");
     }
 
+    info!("Sending command complete ack...");
+    let response: UcsiResponseResult =
+        execute_ucsi_command(Command::PpmCommand(ppm::Command::AckCcCi(ppm::ack_cc_ci::Args {
+            ack: *Ack::default().set_command_complete(true),
+        })))
+        .await
+        .into();
+    let response = response.unwrap();
+    if !response.cci.ack_command() || response.cci.error() {
+        error!("Sending command complete ack failed: {:?}", response.cci);
+    } else {
+        info!("Sending command complete ack successful");
+    }
+
     info!("Get PPM capabilities...");
-    let response = execute_ucsi_command(Command::PpmCommand(ppm::Command::GetCapability))
+    let response: UcsiResponseResult = execute_ucsi_command(Command::PpmCommand(ppm::Command::GetCapability))
         .await
-        .unwrap();
-    if !response.response.cci.cmd_complete() || response.response.cci.error() {
+        .into();
+    let response = response.unwrap();
+    if !response.cci.cmd_complete() || response.cci.error() {
         error!("Get PPM capabilities failed: {response:?}");
     } else {
-        info!("Get PPM capabilities successful: {:?}", response.response.data);
+        info!("Get PPM capabilities successful: {:?}", response.data);
+    }
+
+    info!("Sending command complete ack...");
+    let response: UcsiResponseResult =
+        execute_ucsi_command(Command::PpmCommand(ppm::Command::AckCcCi(ppm::ack_cc_ci::Args {
+            ack: *Ack::default().set_command_complete(true),
+        })))
+        .await
+        .into();
+    let response = response.unwrap();
+    if !response.cci.ack_command() || response.cci.error() {
+        error!("Sending command complete ack failed: {:?}", response.cci);
+    } else {
+        info!("Sending command complete ack successful");
+    }
+
+    info!("Get connector status...");
+    let response: UcsiResponseResult = execute_ucsi_command(Command::LpmCommand(lpm::GlobalCommand {
+        port: GlobalPortId(0),
+        operation: lpm::CommandData::GetConnectorStatus,
+    }))
+    .await
+    .into();
+    let response = response.unwrap();
+    if !response.cci.cmd_complete() || response.cci.error() {
+        error!("Get connector status failed: {:?}", response.cci);
+    } else {
+        info!("Get connector status successful: {:?}", response.data);
+    }
+
+    info!("Sending command complete ack...");
+    let response: UcsiResponseResult =
+        execute_ucsi_command(Command::PpmCommand(ppm::Command::AckCcCi(ppm::ack_cc_ci::Args {
+            ack: *Ack::default().set_command_complete(true),
+        })))
+        .await
+        .into();
+    let response = response.unwrap();
+    if !response.cci.ack_command() || response.cci.error() {
+        error!("Sending command complete ack failed: {:?}", response.cci);
+    } else {
+        info!("Sending command complete ack successful");
     }
 }