Update to use AcpiCommsMsg

Author: kurtjd

Cargo.toml

@@ -71,4 +71,4 @@ syn = "2.0"
 tps6699x = { git = "https://github.com/OpenDevicePartnership/tps6699x" }
 tokio = { version = "1.42.0" }
 zerocopy = "0.8.26"
-uuid = { version = "1.17.0", default-features = false }
+uuid = { version = "=1.17.0", default-features = false }

examples/std/Cargo.lock

@@ -49,7 +49,6 @@ log = "0.4.14"
 heapless = "0.8.0"
 static_cell = "2"
 embedded-hal-async = "1.0.0"
-embedded-hal = "1.0.0"
 embedded-hal-mock = { version = "0.11.1", features = ["embedded-hal-async"] }
 
 critical-section = { version = "1.1", features = ["std"] }

examples/std/Cargo.toml

@@ -4,28 +4,34 @@ use crate::mptf;
 use crate::{Error, Event, fan, sensor};
 use embassy_sync::channel::Channel;
 use embedded_services::GlobalRawMutex;
+use embedded_services::buffer::OwnedRef;
 use embedded_services::{error, intrusive_list};
 
-pub(crate) struct Context {
+embedded_services::define_static_buffer!(mctp_buf, u8, [0u8; 69]);
+
+pub(crate) struct Context<'a> {
     // Registered temperature sensors
     sensors: intrusive_list::IntrusiveList,
     // Registered fans
     fans: intrusive_list::IntrusiveList,
     // MPTF Request Queue
     mptf: Channel<GlobalRawMutex, mptf::Request, 10>,
     // Raw MCTP Payload Queue
-    mctp: Channel<GlobalRawMutex, mctp::Payload, 10>,
+    mctp: Channel<GlobalRawMutex, mctp::AcpiMsgComms<'a>, 10>,
+    // MCTP message buffer
+    mctp_buf: OwnedRef<'a, u8>,
     // Event queue
     events: Channel<GlobalRawMutex, Event, 10>,
 }
 
-impl Context {
+impl<'a> Context<'a> {
     pub(crate) fn new() -> Self {
         Self {
             sensors: intrusive_list::IntrusiveList::new(),
             fans: intrusive_list::IntrusiveList::new(),
             mptf: Channel::new(),
             mctp: Channel::new(),
+            mctp_buf: mctp_buf::get_mut().unwrap(),
             events: Channel::new(),
         }
     }
@@ -105,15 +111,19 @@ impl Context {
         self.mptf.receive().await
     }
 
-    pub(crate) fn send_mctp_payload(&self, msg: mctp::Payload) -> Result<(), Error> {
+    pub(crate) fn send_mctp_payload(&self, msg: mctp::AcpiMsgComms<'a>) -> Result<(), Error> {
         self.mctp.try_send(msg).map_err(|_| Error)?;
         Ok(())
     }
 
-    pub(crate) async fn wait_mctp_payload(&self) -> mctp::Payload {
+    pub(crate) async fn wait_mctp_payload(&self) -> mctp::AcpiMsgComms<'_> {
         self.mctp.receive().await
     }
 
+    pub(crate) fn get_mctp_buf(&self) -> &OwnedRef<'a, u8> {
+        &self.mctp_buf
+    }
+
     pub(crate) async fn send_event(&self, event: Event) {
         self.events.send(event).await
     }

thermal-service/src/context.rs

@@ -3,6 +3,7 @@
 
 use embassy_sync::once_lock::OnceLock;
 use embedded_sensors_hal_async::temperature::DegreesCelsius;
+use embedded_services::buffer::OwnedRef;
 use embedded_services::{comms, error, info, intrusive_list};
 
 mod context;
@@ -31,12 +32,12 @@ pub enum Event {
     FanFailure(fan::DeviceId, fan::Error),
 }
 
-struct Service {
-    context: context::Context,
+struct Service<'a> {
+    context: context::Context<'a>,
     endpoint: comms::Endpoint,
 }
 
-impl Service {
+impl<'a> Service<'a> {
     fn new() -> Self {
         Self {
             context: context::Context::new(),
@@ -45,12 +46,12 @@ impl Service {
     }
 }
 
-impl comms::MailboxDelegate for Service {
+impl<'a> comms::MailboxDelegate for Service<'a> {
     fn receive(&self, message: &comms::Message) -> Result<(), comms::MailboxDelegateError> {
         // Queue for later processing
-        if let Some(&msg) = message.data.get::<mctp::Payload>() {
+        if let Some(msg) = message.data.get::<mctp::AcpiMsgComms>() {
             self.context
-                .send_mctp_payload(msg)
+                .send_mctp_payload(msg.clone())
                 .map_err(|_| comms::MailboxDelegateError::BufferFull)
         } else if let Some(&msg) = message.data.get::<mptf::Request>() {
             self.context
@@ -99,10 +100,14 @@ pub async fn wait_mptf_request() -> mptf::Request {
 }
 
 /// Wait for a MCTP payload
-pub async fn wait_mctp_payload() -> mctp::Payload {
+pub async fn wait_mctp_payload<'a>() -> mctp::AcpiMsgComms<'a> {
     SERVICE.get().await.context.wait_mctp_payload().await
 }
 
+pub fn get_mctp_buf<'a>() -> &'a OwnedRef<'a, u8> {
+    SERVICE.try_get().unwrap().context.get_mctp_buf()
+}
+
 /// Send a thermal event
 pub async fn send_event(event: Event) {
     SERVICE.get().await.context.send_event(event).await

thermal-service/src/lib.rs

@@ -1,10 +1,9 @@
 use crate::mptf::*;
+use core::borrow::{Borrow, BorrowMut};
+pub use embedded_services::{comms, ec_type::message::AcpiMsgComms};
 
 pub const CURRENT_VERSION: u8 = 1;
 
-/// Raw MCTP Payload
-pub type Payload = ([u8; 69], usize);
-
 /// MCTP Payload Error
 pub struct PayloadError {
     command: u8,
@@ -17,16 +16,18 @@ impl PayloadError {
     }
 }
 
-impl TryFrom<Payload> for Request {
+impl TryFrom<AcpiMsgComms<'_>> for Request {
     type Error = PayloadError;
-    fn try_from(payload: Payload) -> Result<Self, Self::Error> {
-        let payload_len = payload.1;
+    fn try_from(acpi: AcpiMsgComms<'_>) -> Result<Self, Self::Error> {
+        let access = acpi.payload.borrow();
+        let payload: &[u8] = access.borrow();
+
         let (version, _rsvd, _status, command, data) = (
-            payload.0[0],
-            payload.0[1],
-            payload.0[2],
-            payload.0[3],
-            &payload.0[4..payload_len],
+            payload[0],
+            payload[1],
+            payload[2],
+            payload[3],
+            &payload[4..acpi.payload_len],
         );
         if version != CURRENT_VERSION {
             return Err(PayloadError::new(command, Status::UnsupportedRevision));
@@ -109,15 +110,17 @@ impl TryFrom<Payload> for Request {
     }
 }
 
-impl From<Response> for Payload {
+impl From<Response> for AcpiMsgComms<'_> {
     fn from(response: Response) -> Self {
-        let mut payload = [0; 69];
-        payload[0] = CURRENT_VERSION; // Version
-        payload[1] = 0; // Reserved
-        payload[2] = u8::from(response.status); // Status
-        payload[3] = response.data.into(); // Command
-
+        let mut access = crate::get_mctp_buf().borrow_mut();
+        let payload: &mut [u8] = access.borrow_mut();
         let (header, data) = payload.split_at_mut(4);
+
+        header[0] = CURRENT_VERSION; // Version
+        header[1] = 0; // Reserved
+        header[2] = u8::from(response.status); // Status
+        header[3] = response.data.into(); // Command
+
         let header_len = header.len();
 
         let data_len = match response.data {
@@ -151,17 +154,28 @@ impl From<Response> for Payload {
             }
         };
 
-        (payload, header_len + data_len)
+        AcpiMsgComms {
+            payload: crate::context::mctp_buf::get(),
+            payload_len: header_len + data_len,
+            endpoint: comms::EndpointID::Internal(comms::Internal::Thermal),
+        }
     }
 }
 
-impl From<PayloadError> for Payload {
+impl From<PayloadError> for AcpiMsgComms<'_> {
     fn from(mctp_error: PayloadError) -> Self {
-        let mut payload = [0; 69];
+        let mut access = crate::get_mctp_buf().borrow_mut();
+        let payload: &mut [u8] = access.borrow_mut();
+
         payload[0] = CURRENT_VERSION; // Version
         payload[1] = 0; // Reserved
         payload[2] = u8::from(mctp_error.error); // Status
         payload[3] = mctp_error.command; // Command
-        (payload, 4)
+
+        AcpiMsgComms {
+            payload: crate::context::mctp_buf::get(),
+            payload_len: 4,
+            endpoint: comms::EndpointID::Internal(comms::Internal::Thermal),
+        }
     }
 }

thermal-service/src/mctp.rs

@@ -362,10 +362,13 @@ pub async fn handle_requests() {
                     // Packet is OK
                     Ok(request) => {
                         let response = process_request(request).await;
-                        mctp::Payload::from(response)
+                        mctp::AcpiMsgComms::from(response)
                     }
                     // Packet is malformed
-                    Err(payload_error) => mctp::Payload::from(payload_error),
+                    Err(payload_error) => {
+                        error!("Thermal received malformed packet");
+                        mctp::AcpiMsgComms::from(payload_error)
+                    }
                 };
                 ts::send_service_msg(comms::EndpointID::External(comms::External::Host), &response).await
             }