1 files changed, 51 insertions, 34 deletions

diff --git a/embassy-stm32-wpan/src/sub/ble.rs b/embassy-stm32-wpan/src/sub/ble.rs
index cd69a0479..d5ed2ca28 100644
--- a/embassy-stm32-wpan/src/sub/ble.rs
+++ b/embassy-stm32-wpan/src/sub/ble.rs
@@ -1,6 +1,6 @@
 use core::ptr;
 
-use embassy_stm32::ipcc::Ipcc;
+use embassy_stm32::ipcc::{IpccRxChannel, IpccTxChannel};
 use hci::Opcode;
 
 use crate::cmd::CmdPacket;
@@ -9,7 +9,7 @@ use crate::evt::{EvtBox, EvtPacket, EvtStub};
 use crate::sub::mm;
 use crate::tables::{BLE_CMD_BUFFER, BleTable, CS_BUFFER, EVT_QUEUE, HCI_ACL_DATA_BUFFER, TL_BLE_TABLE};
 use crate::unsafe_linked_list::LinkedListNode;
-use crate::{channels, evt};
+use crate::evt;
 
 /// A guard that, once constructed, may be used to send BLE commands to CPU2.
 ///
@@ -36,15 +36,21 @@ use crate::{channels, evt};
 /// # mbox.ble_subsystem.reset().await;
 /// # let _reset_response = mbox.ble_subsystem.read().await;
 /// ```
-pub struct Ble {
-    _private: (),
+pub struct Ble<'a> {
+    hw_ipcc_ble_cmd_channel: IpccTxChannel<'a>,
+    ipcc_ble_event_channel: IpccRxChannel<'a>,
+    ipcc_hci_acl_data_channel: IpccTxChannel<'a>,
 }
 
-impl Ble {
+impl<'a> Ble<'a> {
     /// Constructs a guard that allows for BLE commands to be sent to CPU2.
     ///
     /// This takes the place of `TL_BLE_Init`, completing that step as laid out in AN5289, Fig 66.
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new(
+        hw_ipcc_ble_cmd_channel: IpccTxChannel<'a>,
+        ipcc_ble_event_channel: IpccRxChannel<'a>,
+        ipcc_hci_acl_data_channel: IpccTxChannel<'a>,
+    ) -> Self {
         unsafe {
             LinkedListNode::init_head(EVT_QUEUE.as_mut_ptr());
 
@@ -56,44 +62,51 @@ impl Ble {
             });
         }
 
-        Self { _private: () }
+        Self {
+            hw_ipcc_ble_cmd_channel,
+            ipcc_ble_event_channel,
+            ipcc_hci_acl_data_channel,
+        }
     }
 
     /// `HW_IPCC_BLE_EvtNot`
-    pub async fn tl_read(&self) -> EvtBox<Self> {
-        Ipcc::receive(channels::cpu2::IPCC_BLE_EVENT_CHANNEL, || unsafe {
-            if let Some(node_ptr) = LinkedListNode::remove_head(EVT_QUEUE.as_mut_ptr()) {
-                Some(EvtBox::new(node_ptr.cast()))
-            } else {
-                None
-            }
-        })
-        .await
+    pub async fn tl_read(&mut self) -> EvtBox<Self> {
+        self.ipcc_ble_event_channel
+            .receive(|| unsafe {
+                if let Some(node_ptr) = LinkedListNode::remove_head(EVT_QUEUE.as_mut_ptr()) {
+                    Some(EvtBox::new(node_ptr.cast()))
+                } else {
+                    None
+                }
+            })
+            .await
     }
 
     /// `TL_BLE_SendCmd`
-    pub async fn tl_write(&self, opcode: u16, payload: &[u8]) {
-        Ipcc::send(channels::cpu1::IPCC_BLE_CMD_CHANNEL, || unsafe {
-            CmdPacket::write_into(BLE_CMD_BUFFER.as_mut_ptr(), TlPacketType::BleCmd, opcode, payload);
-        })
-        .await;
+    pub async fn tl_write(&mut self, opcode: u16, payload: &[u8]) {
+        self.hw_ipcc_ble_cmd_channel
+            .send(|| unsafe {
+                CmdPacket::write_into(BLE_CMD_BUFFER.as_mut_ptr(), TlPacketType::BleCmd, opcode, payload);
+            })
+            .await;
     }
 
     /// `TL_BLE_SendAclData`
-    pub async fn acl_write(&self, handle: u16, payload: &[u8]) {
-        Ipcc::send(channels::cpu1::IPCC_HCI_ACL_DATA_CHANNEL, || unsafe {
-            CmdPacket::write_into(
-                HCI_ACL_DATA_BUFFER.as_mut_ptr() as *mut _,
-                TlPacketType::AclData,
-                handle,
-                payload,
-            );
-        })
-        .await;
+    pub async fn acl_write(&mut self, handle: u16, payload: &[u8]) {
+        self.ipcc_hci_acl_data_channel
+            .send(|| unsafe {
+                CmdPacket::write_into(
+                    HCI_ACL_DATA_BUFFER.as_mut_ptr() as *mut _,
+                    TlPacketType::AclData,
+                    handle,
+                    payload,
+                );
+            })
+            .await;
     }
 }
 
-impl evt::MemoryManager for Ble {
+impl<'a> evt::MemoryManager for Ble<'a> {
     /// SAFETY: passing a pointer to something other than a managed event packet is UB
     unsafe fn drop_event_packet(evt: *mut EvtPacket) {
         let stub = unsafe {
@@ -110,13 +123,17 @@ impl evt::MemoryManager for Ble {
 
 pub extern crate stm32wb_hci as hci;
 
-impl hci::Controller for Ble {
+impl<'a> hci::Controller for Ble<'a> {
     async fn controller_write(&mut self, opcode: Opcode, payload: &[u8]) {
         self.tl_write(opcode.0, payload).await;
     }
 
+    #[allow(invalid_reference_casting)]
     async fn controller_read_into(&self, buf: &mut [u8]) {
-        let evt_box = self.tl_read().await;
+        // A complete hack since I cannot update the trait
+        let s = unsafe { &mut *(self as *const _ as *mut Ble) };
+
+        let evt_box = s.tl_read().await;
         let evt_serial = evt_box.serial();
 
         buf[..evt_serial.len()].copy_from_slice(evt_serial);