refactor CFU to use deferred IPC channel

This is a BREAKING CHANGE which updates embedded-service::cfu's CfuDevice from utilizing a dual-channel model for communication to a deferred IPC channel. Cfu-service, type-c service and the examples were updated to reflect this change.

Author: madeleyneVaca

cfu-service/src/lib.rs

@@ -28,19 +28,16 @@ impl CfuClient {
             tp: comms::Endpoint::uninit(comms::EndpointID::Internal(comms::Internal::Nonvol)),
         })
     }
-    pub async fn process_request(&self) -> Result<(), CfuError> {
-        let request = self.context.wait_request().await;
+    pub async fn process_request(&self) -> InternalResponse {
+        let request = self.context.receive().await;
         //let device = self.context.get_device(request.id).await?;
-        let comp = request.id;
+        let comp = request.command.id;
 
-        match request.data {
+        match request.command.data {
             RequestData::FwVersionRequest => {
                 info!("Received FwVersionRequest, comp {}", comp);
                 if let Ok(device) = self.context.get_device(comp).await {
-                    let resp = device
-                        .execute_device_request(request.data)
-                        .await
-                        .map_err(CfuError::ProtocolError)?;
+                    let resp = device.execute_device_request(request.command).await?;
 
                     // TODO replace with signal to component to get its own fw version
                     //cfu::send_request(comp, RequestData::FwVersionRequest).await?;
@@ -54,15 +51,18 @@ impl CfuClient {
                             return Err(CfuError::ProtocolError(CfuProtocolError::BadResponse));
                         }
                     }
-                    self.context.send_response(resp).await;
-                    return Ok(());
+                    return Ok(resp);
                 }
                 Err(CfuError::InvalidComponent)
             }
-            RequestData::GiveContent(_content_cmd) => Ok(()),
-            RequestData::GiveOffer(_offer_cmd) => Ok(()),
-            RequestData::PrepareComponentForUpdate => Ok(()),
-            RequestData::FinalizeUpdate => Ok(()),
+            RequestData::GiveContent(_content_cmd) => {
+                Ok(InternalResponseData::ContentResponse(FwUpdateContentResponse::default()))
+            }
+            RequestData::GiveOffer(_offer_cmd) => {
+                Ok(InternalResponseData::OfferResponse(FwUpdateOfferResponse::default()))
+            }
+            RequestData::PrepareComponentForUpdate => Ok(InternalResponseData::ComponentPrepared),
+            RequestData::FinalizeUpdate => Ok(InternalResponseData::ComponentPrepared),
         }
     }
 }

embedded-service/src/cfu/component.rs

@@ -2,7 +2,6 @@
 use core::future::Future;
 
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
-use embassy_sync::channel::Channel;
 use embassy_sync::mutex::Mutex;
 use embedded_cfu_protocol::components::{CfuComponentInfo, CfuComponentStorage, CfuComponentTraits};
 use embedded_cfu_protocol::protocol_definitions::*;
@@ -12,6 +11,7 @@ use heapless::Vec;
 use super::CfuError;
 use crate::cfu::route_request;
 use crate::intrusive_list;
+use crate::ipc::deferred;
 
 /// Component internal update state
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -57,6 +57,16 @@ impl Default for InternalState {
     }
 }
 
+/// Request to the cfu service
+#[derive(Debug, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Request {
+    /// Component that sent this request
+    pub id: ComponentId,
+    /// Request data
+    pub data: RequestData,
+}
+
 /// CFU Request types and necessary data
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -93,17 +103,16 @@ pub enum InternalResponseData {
     ComponentPrepared,
 }
 
-/// Channel size for device requests
-pub const DEVICE_CHANNEL_SIZE: usize = 1;
+/// Wrapper type to make code cleaner
+pub type InternalResponse = Result<InternalResponseData, CfuError>;
 
 /// CfuDevice struct
 /// Can be inserted in an intrusive-list+
 pub struct CfuDevice {
     node: intrusive_list::Node,
     component_id: ComponentId,
     state: Mutex<NoopRawMutex, InternalState>,
-    request: Channel<NoopRawMutex, RequestData, DEVICE_CHANNEL_SIZE>,
-    response: Channel<NoopRawMutex, InternalResponseData, DEVICE_CHANNEL_SIZE>,
+    request: deferred::Channel<NoopRawMutex, Request, InternalResponse>,
 }
 
 impl intrusive_list::NodeContainer for CfuDevice {
@@ -124,15 +133,17 @@ impl CfuDeviceContainer for CfuDevice {
     }
 }
 
+/// Convenience type for CFU request
+pub type CfuRequest<'a> = deferred::Request<'a, NoopRawMutex, Request, InternalResponse>;
+
 impl CfuDevice {
     /// Constructor for CfuDevice
     pub fn new(component_id: ComponentId) -> Self {
         Self {
             node: intrusive_list::Node::uninit(),
             component_id,
             state: Mutex::new(InternalState::default()),
-            request: Channel::new(),
-            response: Channel::new(),
+            request: deferred::Channel::new(),
         }
     }
     /// Getter for component id
@@ -151,19 +162,13 @@ impl CfuDevice {
     }
 
     /// Sends a request to this device and returns a response
-    pub async fn execute_device_request(&self, request: RequestData) -> Result<InternalResponseData, CfuProtocolError> {
-        self.send_request(request).await;
-        Ok(self.wait_response().await)
-    }
-
-    /// Wait for a request
-    pub async fn wait_request(&self) -> RequestData {
-        self.request.receive().await
+    pub async fn execute_device_request(&self, request: Request) -> InternalResponse {
+        self.request.execute(request).await
     }
 
     /// Send a response
-    pub async fn send_response(&self, response: InternalResponseData) {
-        self.response.send(response).await;
+    pub async fn receive(&self) -> CfuRequest {
+        self.request.receive().await
     }
 
     /// Waits for a response
@@ -213,7 +218,8 @@ impl<W: CfuWriter> CfuComponentDefault<W> {
     }
     /// wait for a request and process it
     pub async fn process_request(&self) -> Result<(), CfuError> {
-        match self.device.wait_request().await {
+        let request = self.device.receive().await;
+        match request.command.data {
             RequestData::FwVersionRequest => {
                 let fwv = self.get_fw_version().await.map_err(CfuError::ProtocolError)?;
                 let dev_inf = FwVerComponentInfo::new(fwv, self.get_component_id());
@@ -250,9 +256,7 @@ impl<W: CfuWriter> CfuComponentDefault<W> {
                     ),
                     component_info: comp_info,
                 };
-                self.device
-                    .send_response(InternalResponseData::FwVersionResponse(resp))
-                    .await;
+                request.respond(Ok(InternalResponseData::FwVersionResponse(resp)));
             }
             RequestData::PrepareComponentForUpdate => {
                 self.storage_prepare()
@@ -263,9 +267,7 @@ impl<W: CfuWriter> CfuComponentDefault<W> {
                 // accept any and all offers regardless of what version it is
                 if buf.component_info.component_id == self.get_component_id() {
                     let resp = FwUpdateOfferResponse::new_accept(HostToken::Driver);
-                    self.device
-                        .send_response(InternalResponseData::OfferResponse(resp))
-                        .await;
+                    request.respond(Ok(InternalResponseData::OfferResponse(resp)));
                 }
             }
             RequestData::GiveContent(buf) => {
@@ -276,8 +278,14 @@ impl<W: CfuWriter> CfuComponentDefault<W> {
                     .cfu_write(Some(offset), &buf.data)
                     .await
                     .map_err(|e| CfuError::ProtocolError(CfuProtocolError::WriterError(e)))?;
+                request.respond(Ok(InternalResponseData::ContentResponse(FwUpdateContentResponse::new(
+                    buf.header.sequence_num,
+                    CfuUpdateContentResponseStatus::Success,
+                ))));
+            }
+            RequestData::FinalizeUpdate => {
+                request.respond(Ok(InternalResponseData::ComponentPrepared));
             }
-            RequestData::FinalizeUpdate => {}
         }
         Ok(())
     }

embedded-service/src/cfu/mod.rs

@@ -5,11 +5,11 @@ pub mod component;
 use core::sync::atomic::{AtomicBool, Ordering};
 
 use embassy_sync::blocking_mutex::raw::NoopRawMutex;
-use embassy_sync::channel::Channel;
 use embassy_sync::once_lock::OnceLock;
 use embedded_cfu_protocol::protocol_definitions::{CfuProtocolError, ComponentId};
 
-use crate::cfu::component::{CfuDevice, CfuDeviceContainer, InternalResponseData, RequestData, DEVICE_CHANNEL_SIZE};
+use crate::cfu::component::{CfuDevice, CfuDeviceContainer, CfuRequest, InternalResponse, Request, RequestData};
+use crate::ipc::deferred;
 use crate::{error, intrusive_list};
 
 /// Error type
@@ -24,34 +24,23 @@ pub enum CfuError {
     ComponentBusy,
     /// Component encountered a protocol error during execution
     ProtocolError(CfuProtocolError),
-}
-
-/// Request to the power policy service
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct Request {
-    /// Component that sent this request
-    pub id: ComponentId,
-    /// Request data
-    pub data: RequestData,
+    /// Timeout occurred while waiting for a response
+    Timeout,
 }
 
 /// Cfu context
 struct ClientContext {
     /// Registered devices
     devices: intrusive_list::IntrusiveList,
     /// Request to components
-    request: Channel<NoopRawMutex, Request, { DEVICE_CHANNEL_SIZE }>,
-    /// Response from components
-    response: Channel<NoopRawMutex, InternalResponseData, { DEVICE_CHANNEL_SIZE }>,
+    request: deferred::Channel<NoopRawMutex, Request, InternalResponse>,
 }
 
 impl ClientContext {
     fn new() -> Self {
         Self {
             devices: intrusive_list::IntrusiveList::new(),
-            request: Channel::new(),
-            response: Channel::new(),
+            request: deferred::Channel::new(),
         }
     }
 }
@@ -89,29 +78,27 @@ async fn get_device(id: ComponentId) -> Option<&'static CfuDevice> {
 }
 
 /// Convenience function to send a request to the Cfu service
-pub async fn send_request(from: ComponentId, request: RequestData) -> Result<InternalResponseData, CfuError> {
+pub async fn send_request(from: ComponentId, request: RequestData) -> InternalResponse {
     let context = CONTEXT.get().await;
     context
         .request
-        .send(Request {
+        .execute(Request {
             id: from,
             data: request,
         })
-        .await;
-    Ok(context.response.receive().await)
+        .await
 }
 
 /// Convenience function to route a request to a specific component
-pub async fn route_request(to: ComponentId, request: RequestData) -> Result<InternalResponseData, CfuError> {
+pub async fn route_request(to: ComponentId, request: RequestData) -> InternalResponse {
     let device = get_device(to).await;
     if device.is_none() {
         return Err(CfuError::InvalidComponent);
     }
     device
         .unwrap()
-        .execute_device_request(request)
+        .execute_device_request(Request { id: to, data: request })
         .await
-        .map_err(CfuError::ProtocolError)
 }
 
 /// Send a request to the specific CFU device, but don't wait for a response
@@ -148,14 +135,9 @@ impl ContextToken {
         Some(ContextToken(()))
     }
 
-    /// Wait for a cfu request
-    pub async fn wait_request(&self) -> Request {
-        CONTEXT.get().await.request.receive().await
-    }
-
     /// Send a response to a cfu request
-    pub async fn send_response(&self, response: InternalResponseData) {
-        CONTEXT.get().await.response.send(response).await
+    pub async fn receive(&self) -> CfuRequest {
+        CONTEXT.get().await.request.receive().await
     }
 
     /// Get a device by its ID