wpan: restructure ipcc and hil test wpan_mac

13 files changed, 348 insertions, 282 deletions

diff --git a/embassy-stm32-wpan/src/channels.rs b/embassy-stm32-wpan/src/channels.rs
index 9a2be1cfa..58f857136 100644
--- a/embassy-stm32-wpan/src/channels.rs
+++ b/embassy-stm32-wpan/src/channels.rs
@@ -48,9 +48,20 @@
 //!  |<----HW_IPCC_TRACES_CHANNEL----------------------|
 //!  |                                                 |
 //!
+//!
+
+#[repr(u8)]
+pub enum IpccChannel {
+    Channel1 = 1,
+    Channel2 = 2,
+    Channel3 = 3,
+    Channel4 = 4,
+    Channel5 = 5,
+    Channel6 = 6,
+}
 
 pub mod cpu1 {
-    use embassy_stm32::ipcc::IpccChannel;
+    use super::IpccChannel;
 
     pub const IPCC_BLE_CMD_CHANNEL: IpccChannel = IpccChannel::Channel1;
     pub const IPCC_SYSTEM_CMD_RSP_CHANNEL: IpccChannel = IpccChannel::Channel2;
@@ -70,7 +81,7 @@ pub mod cpu1 {
 }
 
 pub mod cpu2 {
-    use embassy_stm32::ipcc::IpccChannel;
+    use super::IpccChannel;
 
     pub const IPCC_BLE_EVENT_CHANNEL: IpccChannel = IpccChannel::Channel1;
     pub const IPCC_SYSTEM_EVENT_CHANNEL: IpccChannel = IpccChannel::Channel2;
diff --git a/embassy-stm32-wpan/src/lib.rs b/embassy-stm32-wpan/src/lib.rs
index f6b1f6021..18b0feada 100644
--- a/embassy-stm32-wpan/src/lib.rs
+++ b/embassy-stm32-wpan/src/lib.rs
@@ -26,7 +26,7 @@ use core::sync::atomic::{Ordering, compiler_fence};
 
 use embassy_hal_internal::Peri;
 use embassy_stm32::interrupt;
-use embassy_stm32::ipcc::{Config, Ipcc, ReceiveInterruptHandler, TransmitInterruptHandler};
+use embassy_stm32::ipcc::{Config, Ipcc, IpccRxChannel, ReceiveInterruptHandler, TransmitInterruptHandler};
 use embassy_stm32::peripherals::IPCC;
 use sub::mm::MemoryManager;
 use sub::sys::Sys;
@@ -53,14 +53,13 @@ type PacketHeader = LinkedListNode;
 
 /// Transport Layer for the Mailbox interface
 pub struct TlMbox<'d> {
-    _ipcc: Peri<'d, IPCC>,
-
-    pub sys_subsystem: Sys,
-    pub mm_subsystem: MemoryManager,
+    pub sys_subsystem: Sys<'d>,
+    pub mm_subsystem: MemoryManager<'d>,
     #[cfg(feature = "ble")]
-    pub ble_subsystem: sub::ble::Ble,
+    pub ble_subsystem: sub::ble::Ble<'d>,
     #[cfg(feature = "mac")]
-    pub mac_subsystem: sub::mac::Mac,
+    pub mac_subsystem: sub::mac::Mac<'d>,
+    pub traces: IpccRxChannel<'d>,
 }
 
 impl<'d> TlMbox<'d> {
@@ -92,7 +91,7 @@ impl<'d> TlMbox<'d> {
     /// be handled by `TL_BLE_Init`; see Figure 66). This completes the procedure laid out in
     /// Figure 66.
     // TODO: document what the user should do after calling init to use the mac_802_15_4 subsystem
-    pub fn init(
+    pub async fn init(
         ipcc: Peri<'d, IPCC>,
         _irqs: impl interrupt::typelevel::Binding<interrupt::typelevel::IPCC_C1_RX, ReceiveInterruptHandler>
         + interrupt::typelevel::Binding<interrupt::typelevel::IPCC_C1_TX, TransmitInterruptHandler>,
@@ -185,16 +184,35 @@ impl<'d> TlMbox<'d> {
         compiler_fence(Ordering::SeqCst);
 
         // this is equivalent to `HW_IPCC_Enable`, which is called by `TL_Enable`
-        Ipcc::enable(config);
+        let [
+            (_hw_ipcc_ble_cmd_channel, _ipcc_ble_event_channel),
+            (ipcc_system_cmd_rsp_channel, ipcc_system_event_channel),
+            (_ipcc_mac_802_15_4_cmd_rsp_channel, _ipcc_mac_802_15_4_notification_ack_channel),
+            (ipcc_mm_release_buffer_channel, _ipcc_traces_channel),
+            (_ipcc_ble_lld_cmd_channel, _ipcc_ble_lld_rsp_channel),
+            (_ipcc_hci_acl_data_channel, _),
+        ] = Ipcc::new(ipcc, _irqs, config).split();
+
+        let mm = sub::mm::MemoryManager::new(ipcc_mm_release_buffer_channel);
+        let mut sys = sub::sys::Sys::new(ipcc_system_cmd_rsp_channel, ipcc_system_event_channel);
+
+        debug!("sys event: {}", sys.read().await.payload());
 
         Self {
-            _ipcc: ipcc,
-            sys_subsystem: sub::sys::Sys::new(),
+            sys_subsystem: sys,
             #[cfg(feature = "ble")]
-            ble_subsystem: sub::ble::Ble::new(),
+            ble_subsystem: sub::ble::Ble::new(
+                _hw_ipcc_ble_cmd_channel,
+                _ipcc_ble_event_channel,
+                _ipcc_hci_acl_data_channel,
+            ),
             #[cfg(feature = "mac")]
-            mac_subsystem: sub::mac::Mac::new(),
-            mm_subsystem: sub::mm::MemoryManager::new(),
+            mac_subsystem: sub::mac::Mac::new(
+                _ipcc_mac_802_15_4_cmd_rsp_channel,
+                _ipcc_mac_802_15_4_notification_ack_channel,
+            ),
+            mm_subsystem: mm,
+            traces: _ipcc_traces_channel,
         }
     }
 }
diff --git a/embassy-stm32-wpan/src/mac/commands.rs b/embassy-stm32-wpan/src/mac/commands.rs
index a3a40f377..d96f0094a 100644
--- a/embassy-stm32-wpan/src/mac/commands.rs
+++ b/embassy-stm32-wpan/src/mac/commands.rs
@@ -393,9 +393,14 @@ impl<'a, T: AsRef<[u8]>> TryFrom<Frame<&'a T>> for DataRequest {
             dst_pan_id: frame.dst_pan_id().ok_or(())?.into(),
             dst_address: frame.dst_addr().ok_or(())?.into(),
             msdu_handle: frame.sequence_number().ok_or(())?,
-            ack_tx: 0x00,
+            key_source: frame.key_source().unwrap_or_default().try_into().unwrap_or_default(),
+            ack_tx: frame.ack_request() as u8,
             gts_tx: false,
-            security_level: SecurityLevel::Unsecure,
+            security_level: if frame.security_enabled() {
+                SecurityLevel::Secured
+            } else {
+                SecurityLevel::Unsecure
+            },
             ..Default::default()
         };
 
diff --git a/embassy-stm32-wpan/src/mac/control.rs b/embassy-stm32-wpan/src/mac/control.rs
index d2a7b65ee..14c6fdd2b 100644
--- a/embassy-stm32-wpan/src/mac/control.rs
+++ b/embassy-stm32-wpan/src/mac/control.rs
@@ -20,7 +20,7 @@ use crate::sub::mac::MacTx;
 
 pub struct Control<'a> {
     rx_event_channel: &'a ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'a>>,
-    mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx>,
+    mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx<'a>>,
     #[allow(unused)]
     network_state: &'a blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<NetworkState>>,
 }
@@ -28,7 +28,7 @@ pub struct Control<'a> {
 impl<'a> Control<'a> {
     pub(crate) fn new(
         rx_event_channel: &'a ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'a>>,
-        mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx>,
+        mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx<'a>>,
         network_state: &'a blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<NetworkState>>,
     ) -> Self {
         Self {
diff --git a/embassy-stm32-wpan/src/mac/driver.rs b/embassy-stm32-wpan/src/mac/driver.rs
index c43d595b7..41171ce3d 100644
--- a/embassy-stm32-wpan/src/mac/driver.rs
+++ b/embassy-stm32-wpan/src/mac/driver.rs
@@ -37,8 +37,8 @@ impl NetworkState {
 }
 
 pub struct DriverState<'d> {
-    pub mac_tx: Mutex<CriticalSectionRawMutex, MacTx>,
-    pub mac_rx: MacRx,
+    pub mac_tx: Mutex<CriticalSectionRawMutex, MacTx<'d>>,
+    pub mac_rx: MacRx<'d>,
     pub rx_event_channel: ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'d>>,
     pub rx_data_channel: Channel<CriticalSectionRawMutex, MacEvent<'d>, 1>,
     pub tx_data_channel: Channel<CriticalSectionRawMutex, (&'d mut [u8; MTU], usize), BUF_SIZE>,
@@ -48,7 +48,7 @@ pub struct DriverState<'d> {
 }
 
 impl<'d> DriverState<'d> {
-    pub const fn new(mac: Mac) -> Self {
+    pub const fn new(mac: Mac<'d>) -> Self {
         let (mac_rx, mac_tx) = mac.split();
         let mac_tx = Mutex::new(mac_tx);
 
diff --git a/embassy-stm32-wpan/src/mac/event.rs b/embassy-stm32-wpan/src/mac/event.rs
index 9ca4f5a2a..39856e185 100644
--- a/embassy-stm32-wpan/src/mac/event.rs
+++ b/embassy-stm32-wpan/src/mac/event.rs
@@ -10,7 +10,7 @@ use super::responses::{
 };
 use crate::evt::{EvtBox, MemoryManager};
 use crate::mac::opcodes::OpcodeM0ToM4;
-use crate::sub::mac::{self, Mac};
+use crate::sub::mac::{self, MacRx};
 
 pub(crate) trait ParseableMacEvent: Sized {
     fn from_buffer<'a>(buf: &'a [u8]) -> Result<&'a Self, ()> {
@@ -53,7 +53,7 @@ pub enum MacEvent<'a> {
 }
 
 impl<'a> MacEvent<'a> {
-    pub(crate) fn new(event_box: EvtBox<Mac>) -> Result<Self, ()> {
+    pub(crate) fn new(event_box: EvtBox<MacRx>) -> Result<Self, ()> {
         let payload = event_box.payload();
         let opcode = u16::from_le_bytes(payload[0..2].try_into().unwrap());
 
@@ -148,6 +148,6 @@ unsafe impl<'a> Send for MacEvent<'a> {}
 
 impl<'a> Drop for MacEvent<'a> {
     fn drop(&mut self) {
-        unsafe { mac::Mac::drop_event_packet(ptr::null_mut()) };
+        unsafe { mac::MacRx::drop_event_packet(ptr::null_mut()) };
     }
 }
diff --git a/embassy-stm32-wpan/src/mac/runner.rs b/embassy-stm32-wpan/src/mac/runner.rs
index acca70019..3b7d895df 100644
--- a/embassy-stm32-wpan/src/mac/runner.rs
+++ b/embassy-stm32-wpan/src/mac/runner.rs
@@ -24,11 +24,11 @@ pub struct Runner<'a> {
     // therefore, we don't need to worry about overwriting events
     rx_event_channel: &'a ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'a>>,
     rx_data_channel: &'a Channel<CriticalSectionRawMutex, MacEvent<'a>, 1>,
-    mac_rx: &'a mut MacRx,
+    mac_rx: Mutex<NoopRawMutex, &'a mut MacRx<'a>>,
 
     tx_data_channel: &'a Channel<CriticalSectionRawMutex, (&'a mut [u8; MTU], usize), BUF_SIZE>,
     tx_buf_channel: &'a Channel<CriticalSectionRawMutex, &'a mut [u8; MTU], BUF_SIZE>,
-    mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx>,
+    mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx<'a>>,
 
     #[allow(unused)]
     network_state: &'a blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<NetworkState>>,
@@ -38,10 +38,10 @@ impl<'a> Runner<'a> {
     pub(crate) fn new(
         rx_event_channel: &'a ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'a>>,
         rx_data_channel: &'a Channel<CriticalSectionRawMutex, MacEvent<'a>, 1>,
-        mac_rx: &'a mut MacRx,
+        mac_rx: &'a mut MacRx<'a>,
         tx_data_channel: &'a Channel<CriticalSectionRawMutex, (&'a mut [u8; MTU], usize), BUF_SIZE>,
         tx_buf_channel: &'a Channel<CriticalSectionRawMutex, &'a mut [u8; MTU], BUF_SIZE>,
-        mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx>,
+        mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx<'a>>,
         tx_buf_queue: &'a mut [[u8; MTU]; BUF_SIZE],
         network_state: &'a blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<NetworkState>>,
         short_address: [u8; 2],
@@ -61,7 +61,7 @@ impl<'a> Runner<'a> {
         Self {
             rx_event_channel,
             rx_data_channel,
-            mac_rx,
+            mac_rx: Mutex::new(mac_rx),
             tx_data_channel,
             tx_buf_channel,
             mac_tx,
@@ -83,7 +83,7 @@ impl<'a> Runner<'a> {
         join::join(
             async {
                 loop {
-                    if let Ok(mac_event) = self.mac_rx.read().await {
+                    if let Ok(mac_event) = self.mac_rx.try_lock().unwrap().read().await {
                         match mac_event {
                             MacEvent::MlmeAssociateCnf(_)
                             | MacEvent::MlmeDisassociateCnf(_)
diff --git a/embassy-stm32-wpan/src/shci.rs b/embassy-stm32-wpan/src/shci.rs
index 30d689716..1946c55fd 100644
--- a/embassy-stm32-wpan/src/shci.rs
+++ b/embassy-stm32-wpan/src/shci.rs
@@ -274,69 +274,64 @@ pub struct ShciBleInitCmdParam {
     pub options: u8,
     /// Reserved for future use - shall be set to 0
     pub hw_version: u8,
-    //    /**
-    //     * Maximum number of connection-oriented channels in initiator mode.
-    //     * Range: 0 .. 64
-    //     */
-    //    pub max_coc_initiator_nbr: u8,
-    //
-    //    /**
-    //     * Minimum transmit power in dBm supported by the Controller.
-    //     * Range: -127 .. 20
-    //     */
-    //    pub min_tx_power: i8,
-    //
-    //    /**
-    //     * Maximum transmit power in dBm supported by the Controller.
-    //     * Range: -127 .. 20
-    //     */
-    //    pub max_tx_power: i8,
-    //
-    //    /**
-    //     * RX model configuration
-    //     * - bit 0:   1: agc_rssi model improved vs RF blockers    0: Legacy agc_rssi model
-    //     * - other bits: reserved ( shall be set to 0)
-    //     */
-    //    pub rx_model_config: u8,
-    //
-    //    /* Maximum number of advertising sets.
-    //     * Range: 1 .. 8 with limitation:
-    //     * This parameter is linked to max_adv_data_len such as both compliant with allocated Total memory computed with BLE_EXT_ADV_BUFFER_SIZE based
-    //     * on Max Extended advertising configuration supported.
-    //     * This parameter is considered by the CPU2 when Options has SHCI_C2_BLE_INIT_OPTIONS_EXT_ADV flag set
-    //     */
-    //    pub max_adv_set_nbr: u8,
-    //
-    //    /* Maximum advertising data length (in bytes)
-    //     * Range: 31 .. 1650 with limitation:
-    //     * This parameter is linked to max_adv_set_nbr such as both compliant with allocated Total memory computed with BLE_EXT_ADV_BUFFER_SIZE based
-    //     * on Max Extended advertising configuration supported.
-    //     * This parameter is considered by the CPU2 when Options has SHCI_C2_BLE_INIT_OPTIONS_EXT_ADV flag set
-    //     */
-    //    pub max_adv_data_len: u16,
-    //
-    //    /* RF TX Path Compensation Value (16-bit signed integer). Units: 0.1 dB.
-    //     * Range: -1280 .. 1280
-    //     */
-    //    pub tx_path_compens: i16,
-    //
-    //    /* RF RX Path Compensation Value (16-bit signed integer). Units: 0.1 dB.
-    //     * Range: -1280 .. 1280
-    //     */
-    //    pub rx_path_compens: i16,
-    //
-    //    /* BLE core specification version (8-bit unsigned integer).
-    //     * values as: 11(5.2), 12(5.3)
-    //     */
-    //    pub ble_core_version: u8,
-    //
-    //    /**
-    //     * Options flags extension
-    //     * - bit 0:   1: appearance Writable              0: appearance Read-Only
-    //     * - bit 1:   1: Enhanced ATT supported           0: Enhanced ATT not supported
-    //     * - other bits: reserved ( shall be set to 0)
-    //     */
-    //    pub options_extension: u8,
+    ///
+    /// Maximum number of connection-oriented channels in initiator mode.
+    /// Range: 0 .. 64
+    pub max_coc_initiator_nbr: u8,
+
+    ///
+    /// Minimum transmit power in dBm supported by the Controller.
+    /// Range: -127 .. 20
+    pub min_tx_power: i8,
+
+    ///
+    /// Maximum transmit power in dBm supported by the Controller.
+    /// Range: -127 .. 20
+    pub max_tx_power: i8,
+
+    ///
+    /// RX model configuration
+    /// - bit 0:   1: agc_rssi model improved vs RF blockers    0: Legacy agc_rssi model
+    /// - other bits: reserved ( shall be set to 0)
+    pub rx_model_config: u8,
+
+    /// Maximum number of advertising sets.
+    /// Range: 1 .. 8 with limitation:
+    /// This parameter is linked to max_adv_data_len such as both compliant with allocated Total memory computed with BLE_EXT_ADV_BUFFER_SIZE based
+    /// on Max Extended advertising configuration supported.
+    /// This parameter is considered by the CPU2 when Options has SHCI_C2_BLE_INIT_OPTIONS_EXT_ADV flag set
+    pub max_adv_set_nbr: u8,
+
+    /// Maximum advertising data length (in bytes)
+    /// Range: 31 .. 1650 with limitation:
+    /// This parameter is linked to max_adv_set_nbr such as both compliant with allocated Total memory computed with BLE_EXT_ADV_BUFFER_SIZE based
+    /// on Max Extended advertising configuration supported.
+    /// This parameter is considered by the CPU2 when Options has SHCI_C2_BLE_INIT_OPTIONS_EXT_ADV flag set
+    pub max_adv_data_len: u16,
+
+    /// RF TX Path Compensation Value (16-bit signed integer). Units: 0.1 dB.
+    /// Range: -1280 .. 1280
+    pub tx_path_compens: i16,
+
+    //// RF RX Path Compensation Value (16-bit signed integer). Units: 0.1 dB.
+    /// Range: -1280 .. 1280
+    pub rx_path_compens: i16,
+
+    /// BLE core specification version (8-bit unsigned integer).
+    /// values as: 11(5.2), 12(5.3)
+    pub ble_core_version: u8,
+
+    /// Options flags extension
+    /// - bit 0:   1: appearance Writable              0: appearance Read-Only
+    /// - bit 1:   1: Enhanced ATT supported           0: Enhanced ATT not supported
+    /// - other bits: reserved ( shall be set to 0)
+    pub options_extension: u8,
+
+    /// MaxAddEattBearers
+    /// Maximum number of bearers that can be created for Enhanced ATT
+    /// in addition to the number of links
+    ///     - Range: 0 .. 4
+    pub max_add_eatt_bearers: u8,
 }
 
 impl ShciBleInitCmdParam {
@@ -351,7 +346,7 @@ impl Default for ShciBleInitCmdParam {
             p_ble_buffer_address: 0,
             ble_buffer_size: 0,
             num_attr_record: 68,
-            num_attr_serv: 8,
+            num_attr_serv: 4,
             attr_value_arr_size: 1344,
             num_of_links: 2,
             extended_packet_length_enable: 1,
@@ -366,6 +361,17 @@ impl Default for ShciBleInitCmdParam {
             viterbi_enable: 1,
             options: 0,
             hw_version: 0,
+            max_coc_initiator_nbr: 32,
+            min_tx_power: -40,
+            max_tx_power: 6,
+            rx_model_config: 0,
+            max_adv_set_nbr: 2,
+            max_adv_data_len: 1650,
+            tx_path_compens: 0,
+            rx_path_compens: 0,
+            ble_core_version: 11,
+            options_extension: 0,
+            max_add_eatt_bearers: 4,
         }
     }
 }
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);
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();
     }
 }
diff --git a/embassy-stm32-wpan/src/sub/mm.rs b/embassy-stm32-wpan/src/sub/mm.rs
index a90c6ee55..aac252929 100644
--- a/embassy-stm32-wpan/src/sub/mm.rs
+++ b/embassy-stm32-wpan/src/sub/mm.rs
@@ -5,26 +5,26 @@ use core::task::Poll;
 
 use aligned::{A4, Aligned};
 use cortex_m::interrupt;
-use embassy_stm32::ipcc::Ipcc;
+use embassy_stm32::ipcc::IpccTxChannel;
 use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::consts::POOL_SIZE;
+use crate::evt;
 use crate::evt::EvtPacket;
 #[cfg(feature = "ble")]
 use crate::tables::BLE_SPARE_EVT_BUF;
 use crate::tables::{EVT_POOL, FREE_BUF_QUEUE, MemManagerTable, SYS_SPARE_EVT_BUF, TL_MEM_MANAGER_TABLE};
 use crate::unsafe_linked_list::LinkedListNode;
-use crate::{channels, evt};
 
 static MM_WAKER: AtomicWaker = AtomicWaker::new();
 static mut LOCAL_FREE_BUF_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::uninit());
 
-pub struct MemoryManager {
-    _private: (),
+pub struct MemoryManager<'a> {
+    ipcc_mm_release_buffer_channel: IpccTxChannel<'a>,
 }
 
-impl MemoryManager {
-    pub(crate) fn new() -> Self {
+impl<'a> MemoryManager<'a> {
+    pub(crate) fn new(ipcc_mm_release_buffer_channel: IpccTxChannel<'a>) -> Self {
         unsafe {
             LinkedListNode::init_head(FREE_BUF_QUEUE.as_mut_ptr());
             LinkedListNode::init_head(LOCAL_FREE_BUF_QUEUE.as_mut_ptr());
@@ -43,10 +43,12 @@ impl MemoryManager {
             });
         }
 
-        Self { _private: () }
+        Self {
+            ipcc_mm_release_buffer_channel,
+        }
     }
 
-    pub async fn run_queue(&self) -> ! {
+    pub async fn run_queue(&mut self) -> ! {
         loop {
             poll_fn(|cx| unsafe {
                 MM_WAKER.register(cx.waker());
@@ -58,20 +60,21 @@ impl MemoryManager {
             })
             .await;
 
-            Ipcc::send(channels::cpu1::IPCC_MM_RELEASE_BUFFER_CHANNEL, || {
-                interrupt::free(|_| unsafe {
-                    // CS required while moving nodes
-                    while let Some(node_ptr) = LinkedListNode::remove_head(LOCAL_FREE_BUF_QUEUE.as_mut_ptr()) {
-                        LinkedListNode::insert_head(FREE_BUF_QUEUE.as_mut_ptr(), node_ptr);
-                    }
+            self.ipcc_mm_release_buffer_channel
+                .send(|| {
+                    interrupt::free(|_| unsafe {
+                        // CS required while moving nodes
+                        while let Some(node_ptr) = LinkedListNode::remove_head(LOCAL_FREE_BUF_QUEUE.as_mut_ptr()) {
+                            LinkedListNode::insert_head(FREE_BUF_QUEUE.as_mut_ptr(), node_ptr);
+                        }
+                    })
                 })
-            })
-            .await;
+                .await;
         }
     }
 }
 
-impl evt::MemoryManager for MemoryManager {
+impl<'a> evt::MemoryManager for MemoryManager<'a> {
     /// SAFETY: passing a pointer to something other than a managed event packet is UB
     unsafe fn drop_event_packet(evt: *mut EvtPacket) {
         interrupt::free(|_| unsafe {
diff --git a/embassy-stm32-wpan/src/sub/sys.rs b/embassy-stm32-wpan/src/sub/sys.rs
index 8a3382f86..dffe9942c 100644
--- a/embassy-stm32-wpan/src/sub/sys.rs
+++ b/embassy-stm32-wpan/src/sub/sys.rs
@@ -1,5 +1,7 @@
 use core::ptr;
 
+use embassy_stm32::ipcc::{IpccRxChannel, IpccTxChannel};
+
 use crate::cmd::CmdPacket;
 use crate::consts::TlPacketType;
 use crate::evt::{CcEvt, EvtBox, EvtPacket};
@@ -8,16 +10,20 @@ use crate::shci::{SchiCommandStatus, ShciBleInitCmdParam, ShciOpcode};
 use crate::sub::mm;
 use crate::tables::{SysTable, WirelessFwInfoTable};
 use crate::unsafe_linked_list::LinkedListNode;
-use crate::{Ipcc, SYS_CMD_BUF, SYSTEM_EVT_QUEUE, TL_DEVICE_INFO_TABLE, TL_SYS_TABLE, channels};
+use crate::{SYS_CMD_BUF, SYSTEM_EVT_QUEUE, TL_DEVICE_INFO_TABLE, TL_SYS_TABLE};
 
 /// A guard that, once constructed, allows for sys commands to be sent to CPU2.
-pub struct Sys {
-    _private: (),
+pub struct Sys<'a> {
+    ipcc_system_cmd_rsp_channel: IpccTxChannel<'a>,
+    ipcc_system_event_channel: IpccRxChannel<'a>,
 }
 
-impl Sys {
+impl<'a> Sys<'a> {
     /// TL_Sys_Init
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new(
+        ipcc_system_cmd_rsp_channel: IpccTxChannel<'a>,
+        ipcc_system_event_channel: IpccRxChannel<'a>,
+    ) -> Self {
         unsafe {
             LinkedListNode::init_head(SYSTEM_EVT_QUEUE.as_mut_ptr());
 
@@ -27,7 +33,10 @@ impl Sys {
             });
         }
 
-        Self { _private: () }
+        Self {
+            ipcc_system_cmd_rsp_channel,
+            ipcc_system_event_channel,
+        }
     }
 
     /// Returns CPU2 wireless firmware information (if present).
@@ -38,17 +47,22 @@ impl Sys {
         if info.version != 0 { Some(info) } else { None }
     }
 
-    pub async fn write(&self, opcode: ShciOpcode, payload: &[u8]) {
-        Ipcc::send(channels::cpu1::IPCC_SYSTEM_CMD_RSP_CHANNEL, || unsafe {
-            CmdPacket::write_into(SYS_CMD_BUF.as_mut_ptr(), TlPacketType::SysCmd, opcode as u16, payload);
-        })
-        .await;
+    pub async fn write(&mut self, opcode: ShciOpcode, payload: &[u8]) {
+        self.ipcc_system_cmd_rsp_channel
+            .send(|| unsafe {
+                CmdPacket::write_into(SYS_CMD_BUF.as_mut_ptr(), TlPacketType::SysCmd, opcode as u16, payload);
+            })
+            .await;
     }
 
     /// `HW_IPCC_SYS_CmdEvtNot`
-    pub async fn write_and_get_response(&self, opcode: ShciOpcode, payload: &[u8]) -> Result<SchiCommandStatus, ()> {
+    pub async fn write_and_get_response(
+        &mut self,
+        opcode: ShciOpcode,
+        payload: &[u8],
+    ) -> Result<SchiCommandStatus, ()> {
         self.write(opcode, payload).await;
-        Ipcc::flush(channels::cpu1::IPCC_SYSTEM_CMD_RSP_CHANNEL).await;
+        self.ipcc_system_cmd_rsp_channel.flush().await;
 
         unsafe {
             let p_event_packet = SYS_CMD_BUF.as_ptr() as *const EvtPacket;
@@ -60,26 +74,7 @@ impl Sys {
     }
 
     #[cfg(feature = "mac")]
-    pub async fn shci_c2_mac_802_15_4_init(&self) -> Result<SchiCommandStatus, ()> {
-        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,
-        };
-
-        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(),
-            });
-        };
-
+    pub async fn shci_c2_mac_802_15_4_init(&mut self) -> Result<SchiCommandStatus, ()> {
         self.write_and_get_response(ShciOpcode::Mac802_15_4Init, &[]).await
     }
 
@@ -90,7 +85,7 @@ impl Sys {
     /// `HW_IPCC_SYS_EvtNot`, aka `IoBusCallBackUserEvt` (as detailed in Figure 65), aka
     /// [crate::sub::ble::hci::host::uart::UartHci::read].
     #[cfg(feature = "ble")]
-    pub async fn shci_c2_ble_init(&self, param: ShciBleInitCmdParam) -> Result<SchiCommandStatus, ()> {
+    pub async fn shci_c2_ble_init(&mut self, param: ShciBleInitCmdParam) -> Result<SchiCommandStatus, ()> {
         self.write_and_get_response(ShciOpcode::BleInit, param.payload()).await
     }
 
@@ -99,14 +94,15 @@ impl Sys {
     /// This method takes the place of the `HW_IPCC_SYS_EvtNot`/`SysUserEvtRx`/`APPE_SysUserEvtRx`,
     /// as the embassy implementation avoids the need to call C public bindings, and instead
     /// handles the event channels directly.
-    pub async fn read(&self) -> EvtBox<mm::MemoryManager> {
-        Ipcc::receive(channels::cpu2::IPCC_SYSTEM_EVENT_CHANNEL, || unsafe {
-            if let Some(node_ptr) = LinkedListNode::remove_head(SYSTEM_EVT_QUEUE.as_mut_ptr()) {
-                Some(EvtBox::new(node_ptr.cast()))
-            } else {
-                None
-            }
-        })
-        .await
+    pub async fn read<'b>(&mut self) -> EvtBox<mm::MemoryManager<'b>> {
+        self.ipcc_system_event_channel
+            .receive(|| unsafe {
+                if let Some(node_ptr) = LinkedListNode::remove_head(SYSTEM_EVT_QUEUE.as_mut_ptr()) {
+                    Some(EvtBox::new(node_ptr.cast()))
+                } else {
+                    None
+                }
+            })
+            .await
     }
 }
diff --git a/embassy-stm32-wpan/src/tables.rs b/embassy-stm32-wpan/src/tables.rs
index 1dafed159..20d2c190f 100644
--- a/embassy-stm32-wpan/src/tables.rs
+++ b/embassy-stm32-wpan/src/tables.rs
@@ -191,93 +191,93 @@ pub struct RefTable {
 
 // --------------------- ref table ---------------------
 #[unsafe(link_section = "TL_REF_TABLE")]
-pub static mut TL_REF_TABLE: MaybeUninit<RefTable> = MaybeUninit::uninit();
+pub static mut TL_REF_TABLE: MaybeUninit<RefTable> = MaybeUninit::zeroed();
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_DEVICE_INFO_TABLE: Aligned<A4, MaybeUninit<DeviceInfoTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_DEVICE_INFO_TABLE: Aligned<A4, MaybeUninit<DeviceInfoTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_BLE_TABLE: Aligned<A4, MaybeUninit<BleTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_BLE_TABLE: Aligned<A4, MaybeUninit<BleTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_THREAD_TABLE: Aligned<A4, MaybeUninit<ThreadTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_THREAD_TABLE: Aligned<A4, MaybeUninit<ThreadTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_LLD_TESTS_TABLE: Aligned<A4, MaybeUninit<LldTestsTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_LLD_TESTS_TABLE: Aligned<A4, MaybeUninit<LldTestsTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_BLE_LLD_TABLE: Aligned<A4, MaybeUninit<BleLldTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_BLE_LLD_TABLE: Aligned<A4, MaybeUninit<BleLldTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_SYS_TABLE: Aligned<A4, MaybeUninit<SysTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_SYS_TABLE: Aligned<A4, MaybeUninit<SysTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_MEM_MANAGER_TABLE: Aligned<A4, MaybeUninit<MemManagerTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_MEM_MANAGER_TABLE: Aligned<A4, MaybeUninit<MemManagerTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_TRACES_TABLE: Aligned<A4, MaybeUninit<TracesTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_TRACES_TABLE: Aligned<A4, MaybeUninit<TracesTable>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_MAC_802_15_4_TABLE: Aligned<A4, MaybeUninit<Mac802_15_4Table>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_MAC_802_15_4_TABLE: Aligned<A4, MaybeUninit<Mac802_15_4Table>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TL_ZIGBEE_TABLE: Aligned<A4, MaybeUninit<ZigbeeTable>> = Aligned(MaybeUninit::uninit());
+pub static mut TL_ZIGBEE_TABLE: Aligned<A4, MaybeUninit<ZigbeeTable>> = Aligned(MaybeUninit::zeroed());
 
 // --------------------- tables ---------------------
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut FREE_BUF_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::uninit());
+pub static mut FREE_BUF_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::zeroed());
 
 #[allow(dead_code)]
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut TRACES_EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::uninit());
+pub static mut TRACES_EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM2")]
 pub static mut CS_BUFFER: Aligned<A4, MaybeUninit<[u8; TL_PACKET_HEADER_SIZE + TL_EVT_HEADER_SIZE + TL_CS_EVT_SIZE]>> =
-    Aligned(MaybeUninit::uninit());
+    Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM2")]
-pub static mut EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::uninit());
+pub static mut EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM2")]
-pub static mut SYSTEM_EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::uninit());
+pub static mut SYSTEM_EVT_QUEUE: Aligned<A4, MaybeUninit<LinkedListNode>> = Aligned(MaybeUninit::zeroed());
 
 // --------------------- app tables ---------------------
 #[cfg(feature = "mac")]
 #[unsafe(link_section = "MB_MEM2")]
-pub static mut MAC_802_15_4_CMD_BUFFER: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::uninit());
+pub static mut MAC_802_15_4_CMD_BUFFER: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::zeroed());
 
 #[cfg(feature = "mac")]
 #[unsafe(link_section = "MB_MEM2")]
 pub static mut MAC_802_15_4_NOTIF_RSP_EVT_BUFFER: MaybeUninit<
     Aligned<A4, [u8; TL_PACKET_HEADER_SIZE + TL_EVT_HEADER_SIZE + 255]>,
-> = MaybeUninit::uninit();
+> = MaybeUninit::zeroed();
 
 #[unsafe(link_section = "MB_MEM2")]
-pub static mut EVT_POOL: Aligned<A4, MaybeUninit<[u8; POOL_SIZE]>> = Aligned(MaybeUninit::uninit());
+pub static mut EVT_POOL: Aligned<A4, MaybeUninit<[u8; POOL_SIZE]>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM2")]
-pub static mut SYS_CMD_BUF: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::uninit());
+pub static mut SYS_CMD_BUF: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::zeroed());
 
 #[unsafe(link_section = "MB_MEM2")]
 pub static mut SYS_SPARE_EVT_BUF: Aligned<A4, MaybeUninit<[u8; TL_PACKET_HEADER_SIZE + TL_EVT_HEADER_SIZE + 255]>> =
-    Aligned(MaybeUninit::uninit());
+    Aligned(MaybeUninit::zeroed());
 
 #[cfg(feature = "mac")]
 #[unsafe(link_section = "MB_MEM2")]
 pub static mut MAC_802_15_4_CNFINDNOT: Aligned<A4, MaybeUninit<[u8; C_SIZE_CMD_STRING]>> =
-    Aligned(MaybeUninit::uninit());
+    Aligned(MaybeUninit::zeroed());
 
 #[cfg(feature = "ble")]
 #[unsafe(link_section = "MB_MEM1")]
-pub static mut BLE_CMD_BUFFER: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::uninit());
+pub static mut BLE_CMD_BUFFER: Aligned<A4, MaybeUninit<CmdPacket>> = Aligned(MaybeUninit::zeroed());
 
 #[cfg(feature = "ble")]
 #[unsafe(link_section = "MB_MEM2")]
 pub static mut BLE_SPARE_EVT_BUF: Aligned<A4, MaybeUninit<[u8; TL_PACKET_HEADER_SIZE + TL_EVT_HEADER_SIZE + 255]>> =
-    Aligned(MaybeUninit::uninit());
+    Aligned(MaybeUninit::zeroed());
 
 #[cfg(feature = "ble")]
 #[unsafe(link_section = "MB_MEM2")]
 //                                                 fuck these "magic" numbers from ST ---v---v
 pub static mut HCI_ACL_DATA_BUFFER: Aligned<A4, MaybeUninit<[u8; TL_PACKET_HEADER_SIZE + 5 + 251]>> =
-    Aligned(MaybeUninit::uninit());
+    Aligned(MaybeUninit::zeroed());