1 files changed, 77 insertions, 67 deletions

diff --git a/embassy-stm32-wpan/src/sub/mac.rs b/embassy-stm32-wpan/src/sub/mac.rs
index 93cafbc72..ce2903e61 100644
--- a/embassy-stm32-wpan/src/sub/mac.rs
+++ b/embassy-stm32-wpan/src/sub/mac.rs
@@ -4,67 +4,78 @@ use core::sync::atomic::{AtomicBool, Ordering};
 use core::task::Poll;
 
 use embassy_futures::poll_once;
-use embassy_stm32::ipcc::Ipcc;
+use embassy_stm32::ipcc::{Ipcc, IpccRxChannel, IpccTxChannel};
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::cmd::CmdPacket;
 use crate::consts::TlPacketType;
+use crate::evt;
 use crate::evt::{EvtBox, EvtPacket};
 use crate::mac::commands::MacCommand;
 use crate::mac::event::MacEvent;
 use crate::mac::typedefs::MacError;
 use crate::tables::{MAC_802_15_4_CMD_BUFFER, MAC_802_15_4_NOTIF_RSP_EVT_BUFFER};
-use crate::{channels, evt};
+use crate::unsafe_linked_list::LinkedListNode;
 
 static MAC_WAKER: AtomicWaker = AtomicWaker::new();
 static MAC_EVT_OUT: AtomicBool = AtomicBool::new(false);
 
-pub struct Mac {
-    _private: (),
+pub struct Mac<'a> {
+    ipcc_mac_802_15_4_cmd_rsp_channel: IpccTxChannel<'a>,
+    ipcc_mac_802_15_4_notification_ack_channel: IpccRxChannel<'a>,
 }
 
-impl Mac {
-    pub(crate) fn new() -> Self {
-        Self { _private: () }
-    }
-
-    pub const fn split(self) -> (MacRx, MacTx) {
-        (MacRx { _private: () }, MacTx { _private: () })
-    }
-
-    pub async fn tl_write_and_get_response(&self, opcode: u16, payload: &[u8]) -> u8 {
-        MacTx { _private: () }.tl_write_and_get_response(opcode, payload).await
-    }
-
-    pub async fn tl_write(&self, opcode: u16, payload: &[u8]) {
-        MacTx { _private: () }.tl_write(opcode, payload).await
-    }
-
-    pub async fn send_command<T>(&self, cmd: &T) -> Result<(), MacError>
-    where
-        T: MacCommand,
-    {
-        MacTx { _private: () }.send_command(cmd).await
-    }
+impl<'a> Mac<'a> {
+    pub(crate) fn new(
+        ipcc_mac_802_15_4_cmd_rsp_channel: IpccTxChannel<'a>,
+        ipcc_mac_802_15_4_notification_ack_channel: IpccRxChannel<'a>,
+    ) -> Self {
+        use crate::tables::{
+            MAC_802_15_4_CMD_BUFFER, MAC_802_15_4_NOTIF_RSP_EVT_BUFFER, Mac802_15_4Table, TL_MAC_802_15_4_TABLE,
+            TL_TRACES_TABLE, TRACES_EVT_QUEUE, TracesTable,
+        };
 
-    pub async fn tl_read(&self) -> EvtBox<Mac> {
-        MacRx { _private: () }.tl_read().await
+        unsafe {
+            LinkedListNode::init_head(TRACES_EVT_QUEUE.as_mut_ptr() as *mut _);
+
+            TL_TRACES_TABLE.as_mut_ptr().write_volatile(TracesTable {
+                traces_queue: TRACES_EVT_QUEUE.as_ptr() as *const _,
+            });
+
+            TL_MAC_802_15_4_TABLE.as_mut_ptr().write_volatile(Mac802_15_4Table {
+                p_cmdrsp_buffer: MAC_802_15_4_CMD_BUFFER.as_mut_ptr().cast(),
+                p_notack_buffer: MAC_802_15_4_NOTIF_RSP_EVT_BUFFER.as_mut_ptr().cast(),
+                evt_queue: core::ptr::null_mut(),
+            });
+        };
+
+        Self {
+            ipcc_mac_802_15_4_cmd_rsp_channel,
+            ipcc_mac_802_15_4_notification_ack_channel,
+        }
     }
 
-    pub async fn read(&self) -> Result<MacEvent<'_>, ()> {
-        MacRx { _private: () }.read().await
+    pub const fn split(self) -> (MacRx<'a>, MacTx<'a>) {
+        (
+            MacRx {
+                ipcc_mac_802_15_4_notification_ack_channel: self.ipcc_mac_802_15_4_notification_ack_channel,
+            },
+            MacTx {
+                ipcc_mac_802_15_4_cmd_rsp_channel: self.ipcc_mac_802_15_4_cmd_rsp_channel,
+            },
+        )
     }
 }
 
-pub struct MacTx {
-    _private: (),
+pub struct MacTx<'a> {
+    ipcc_mac_802_15_4_cmd_rsp_channel: IpccTxChannel<'a>,
 }
 
-impl MacTx {
+impl<'a> MacTx<'a> {
     /// `HW_IPCC_MAC_802_15_4_CmdEvtNot`
-    pub async fn tl_write_and_get_response(&self, opcode: u16, payload: &[u8]) -> u8 {
+    pub async fn tl_write_and_get_response(&mut self, opcode: u16, payload: &[u8]) -> u8 {
         self.tl_write(opcode, payload).await;
-        Ipcc::flush(channels::cpu1::IPCC_MAC_802_15_4_CMD_RSP_CHANNEL).await;
+        self.ipcc_mac_802_15_4_cmd_rsp_channel.flush().await;
 
         unsafe {
             let p_event_packet = MAC_802_15_4_CMD_BUFFER.as_ptr() as *const EvtPacket;
@@ -75,19 +86,20 @@ impl MacTx {
     }
 
     /// `TL_MAC_802_15_4_SendCmd`
-    pub async fn tl_write(&self, opcode: u16, payload: &[u8]) {
-        Ipcc::send(channels::cpu1::IPCC_MAC_802_15_4_CMD_RSP_CHANNEL, || unsafe {
-            CmdPacket::write_into(
-                MAC_802_15_4_CMD_BUFFER.as_mut_ptr(),
-                TlPacketType::MacCmd,
-                opcode,
-                payload,
-            );
-        })
-        .await;
+    pub async fn tl_write(&mut self, opcode: u16, payload: &[u8]) {
+        self.ipcc_mac_802_15_4_cmd_rsp_channel
+            .send(|| unsafe {
+                CmdPacket::write_into(
+                    MAC_802_15_4_CMD_BUFFER.as_mut_ptr(),
+                    TlPacketType::MacCmd,
+                    opcode,
+                    payload,
+                );
+            })
+            .await;
     }
 
-    pub async fn send_command<T>(&self, cmd: &T) -> Result<(), MacError>
+    pub async fn send_command<T>(&mut self, cmd: &T) -> Result<(), MacError>
     where
         T: MacCommand,
     {
@@ -101,19 +113,19 @@ impl MacTx {
     }
 }
 
-pub struct MacRx {
-    _private: (),
+pub struct MacRx<'a> {
+    ipcc_mac_802_15_4_notification_ack_channel: IpccRxChannel<'a>,
 }
 
-impl MacRx {
+impl<'a> MacRx<'a> {
     /// `HW_IPCC_MAC_802_15_4_EvtNot`
     ///
     /// This function will stall if the previous `EvtBox` has not been dropped
-    pub async fn tl_read(&self) -> EvtBox<Mac> {
+    pub async fn tl_read(&mut self) -> EvtBox<MacRx<'a>> {
         // Wait for the last event box to be dropped
         poll_fn(|cx| {
             MAC_WAKER.register(cx.waker());
-            if MAC_EVT_OUT.load(Ordering::SeqCst) {
+            if MAC_EVT_OUT.load(Ordering::Acquire) {
                 Poll::Pending
             } else {
                 Poll::Ready(())
@@ -122,22 +134,23 @@ impl MacRx {
         .await;
 
         // Return a new event box
-        Ipcc::receive(channels::cpu2::IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL, || unsafe {
-            // The closure is not async, therefore the closure must execute to completion (cannot be dropped)
-            // Therefore, the event box is guaranteed to be cleaned up if it's not leaked
-            MAC_EVT_OUT.store(true, Ordering::SeqCst);
-
-            Some(EvtBox::new(MAC_802_15_4_NOTIF_RSP_EVT_BUFFER.as_mut_ptr() as *mut _))
-        })
-        .await
+        self.ipcc_mac_802_15_4_notification_ack_channel
+            .receive(|| unsafe {
+                // The closure is not async, therefore the closure must execute to completion (cannot be dropped)
+                // Therefore, the event box is guaranteed to be cleaned up if it's not leaked
+                MAC_EVT_OUT.store(true, Ordering::SeqCst);
+
+                Some(EvtBox::new(MAC_802_15_4_NOTIF_RSP_EVT_BUFFER.as_mut_ptr() as *mut _))
+            })
+            .await
     }
 
-    pub async fn read(&self) -> Result<MacEvent<'_>, ()> {
+    pub async fn read<'b>(&mut self) -> Result<MacEvent<'b>, ()> {
         MacEvent::new(self.tl_read().await)
     }
 }
 
-impl evt::MemoryManager for Mac {
+impl<'a> evt::MemoryManager for MacRx<'a> {
     /// SAFETY: passing a pointer to something other than a managed event packet is UB
     unsafe fn drop_event_packet(_: *mut EvtPacket) {
         trace!("mac drop event");
@@ -151,13 +164,10 @@ impl evt::MemoryManager for Mac {
         );
 
         // Clear the rx flag
-        let _ = poll_once(Ipcc::receive::<()>(
-            channels::cpu2::IPCC_MAC_802_15_4_NOTIFICATION_ACK_CHANNEL,
-            || None,
-        ));
+        let _ = poll_once(Ipcc::receive::<()>(3, || None));
 
         // Allow a new read call
-        MAC_EVT_OUT.store(false, Ordering::SeqCst);
+        MAC_EVT_OUT.store(false, Ordering::Release);
         MAC_WAKER.wake();
     }
 }