wpan: restructure ipcc and hil test wpan_mac

8 files changed, 168 insertions, 197 deletions

diff --git a/examples/stm32wb/src/bin/eddystone_beacon.rs b/examples/stm32wb/src/bin/eddystone_beacon.rs
index f309ca3a2..413b1ac8f 100644
--- a/examples/stm32wb/src/bin/eddystone_beacon.rs
+++ b/examples/stm32wb/src/bin/eddystone_beacon.rs
@@ -57,126 +57,112 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mut mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
+    let mut ble = mbox.ble_subsystem;
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
-
-    let _ = mbox.sys_subsystem.shci_c2_ble_init(Default::default()).await;
+    let _ = sys.shci_c2_ble_init(Default::default()).await;
 
     info!("resetting BLE...");
-    mbox.ble_subsystem.reset().await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.reset().await;
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("config public address...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::public_address(get_bd_addr()).build())
+    ble.write_config_data(&ConfigData::public_address(get_bd_addr()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("config random address...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::random_address(get_random_addr()).build())
+    ble.write_config_data(&ConfigData::random_address(get_random_addr()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("config identity root...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::identity_root(&get_irk()).build())
+    ble.write_config_data(&ConfigData::identity_root(&get_irk()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("config encryption root...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::encryption_root(&get_erk()).build())
+    ble.write_config_data(&ConfigData::encryption_root(&get_erk()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("config tx power level...");
-    mbox.ble_subsystem.set_tx_power_level(PowerLevel::ZerodBm).await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.set_tx_power_level(PowerLevel::ZerodBm).await;
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("GATT init...");
-    mbox.ble_subsystem.init_gatt().await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.init_gatt().await;
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("GAP init...");
-    mbox.ble_subsystem
-        .init_gap(Role::PERIPHERAL, false, BLE_GAP_DEVICE_NAME_LENGTH)
-        .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.init_gap(Role::PERIPHERAL, false, BLE_GAP_DEVICE_NAME_LENGTH).await;
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     // info!("set scan response...");
-    // mbox.ble_subsystem.le_set_scan_response_data(&[]).await.unwrap();
-    // let response = mbox.ble_subsystem.read().await.unwrap();
+    // ble.le_set_scan_response_data(&[]).await.unwrap();
+    // let response = ble.read().await.unwrap();
     // defmt::info!("{}", response);
 
     info!("set discoverable...");
-    mbox.ble_subsystem
-        .set_discoverable(&DiscoverableParameters {
-            advertising_type: AdvertisingType::NonConnectableUndirected,
-            advertising_interval: Some((Duration::from_millis(250), Duration::from_millis(250))),
-            address_type: OwnAddressType::Public,
-            filter_policy: AdvertisingFilterPolicy::AllowConnectionAndScan,
-            local_name: None,
-            advertising_data: &[],
-            conn_interval: (None, None),
-        })
-        .await
-        .unwrap();
-
-    let response = mbox.ble_subsystem.read().await;
+    ble.set_discoverable(&DiscoverableParameters {
+        advertising_type: AdvertisingType::NonConnectableUndirected,
+        advertising_interval: Some((Duration::from_millis(250), Duration::from_millis(250))),
+        address_type: OwnAddressType::Public,
+        filter_policy: AdvertisingFilterPolicy::AllowConnectionAndScan,
+        local_name: None,
+        advertising_data: &[],
+        conn_interval: (None, None),
+    })
+    .await
+    .unwrap();
+
+    let response = ble.read().await;
     defmt::info!("{}", response);
 
     // remove some advertisement to decrease the packet size
     info!("delete tx power ad type...");
-    mbox.ble_subsystem
-        .delete_ad_type(AdvertisingDataType::TxPowerLevel)
-        .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.delete_ad_type(AdvertisingDataType::TxPowerLevel).await;
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("delete conn interval ad type...");
-    mbox.ble_subsystem
-        .delete_ad_type(AdvertisingDataType::PeripheralConnectionInterval)
+    ble.delete_ad_type(AdvertisingDataType::PeripheralConnectionInterval)
         .await;
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("update advertising data...");
-    mbox.ble_subsystem
-        .update_advertising_data(&eddystone_advertising_data())
+    ble.update_advertising_data(&eddystone_advertising_data())
         .await
         .unwrap();
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("update advertising data type...");
-    mbox.ble_subsystem
-        .update_advertising_data(&[3, AdvertisingDataType::UuidCompleteList16 as u8, 0xaa, 0xfe])
+    ble.update_advertising_data(&[3, AdvertisingDataType::UuidCompleteList16 as u8, 0xaa, 0xfe])
         .await
         .unwrap();
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     info!("update advertising data flags...");
-    mbox.ble_subsystem
-        .update_advertising_data(&[
-            2,
-            AdvertisingDataType::Flags as u8,
-            (0x02 | 0x04) as u8, // BLE general discoverable, without BR/EDR support
-        ])
-        .await
-        .unwrap();
-    let response = mbox.ble_subsystem.read().await.unwrap();
+    ble.update_advertising_data(&[
+        2,
+        AdvertisingDataType::Flags as u8,
+        (0x02 | 0x04) as u8, // BLE general discoverable, without BR/EDR support
+    ])
+    .await
+    .unwrap();
+    let response = ble.read().await.unwrap();
     defmt::info!("{}", response);
 
     cortex_m::asm::wfi();
diff --git a/examples/stm32wb/src/bin/gatt_server.rs b/examples/stm32wb/src/bin/gatt_server.rs
index 2ed257566..3484f1844 100644
--- a/examples/stm32wb/src/bin/gatt_server.rs
+++ b/examples/stm32wb/src/bin/gatt_server.rs
@@ -69,92 +69,85 @@ async fn main(spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mut mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
+    let mut ble = mbox.ble_subsystem;
 
     spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
 
-    let _ = mbox.sys_subsystem.shci_c2_ble_init(Default::default()).await;
+    let _ = sys.shci_c2_ble_init(Default::default()).await;
 
     info!("resetting BLE...");
-    mbox.ble_subsystem.reset().await;
-    let response = mbox.ble_subsystem.read().await;
+    ble.reset().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("config public address...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::public_address(get_bd_addr()).build())
+    ble.write_config_data(&ConfigData::public_address(get_bd_addr()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("config random address...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::random_address(get_random_addr()).build())
+    ble.write_config_data(&ConfigData::random_address(get_random_addr()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("config identity root...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::identity_root(&get_irk()).build())
+    ble.write_config_data(&ConfigData::identity_root(&get_irk()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("config encryption root...");
-    mbox.ble_subsystem
-        .write_config_data(&ConfigData::encryption_root(&get_erk()).build())
+    ble.write_config_data(&ConfigData::encryption_root(&get_erk()).build())
         .await;
-    let response = mbox.ble_subsystem.read().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("config tx power level...");
-    mbox.ble_subsystem.set_tx_power_level(PowerLevel::ZerodBm).await;
-    let response = mbox.ble_subsystem.read().await;
+    ble.set_tx_power_level(PowerLevel::ZerodBm).await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("GATT init...");
-    mbox.ble_subsystem.init_gatt().await;
-    let response = mbox.ble_subsystem.read().await;
+    ble.init_gatt().await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("GAP init...");
-    mbox.ble_subsystem
-        .init_gap(Role::PERIPHERAL, false, BLE_GAP_DEVICE_NAME_LENGTH)
-        .await;
-    let response = mbox.ble_subsystem.read().await;
+    ble.init_gap(Role::PERIPHERAL, false, BLE_GAP_DEVICE_NAME_LENGTH).await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("set IO capabilities...");
-    mbox.ble_subsystem.set_io_capability(IoCapability::DisplayConfirm).await;
-    let response = mbox.ble_subsystem.read().await;
+    ble.set_io_capability(IoCapability::DisplayConfirm).await;
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("set authentication requirements...");
-    mbox.ble_subsystem
-        .set_authentication_requirement(&AuthenticationRequirements {
-            bonding_required: false,
-            keypress_notification_support: false,
-            mitm_protection_required: false,
-            encryption_key_size_range: (8, 16),
-            fixed_pin: Pin::Requested,
-            identity_address_type: AddressType::Public,
-            secure_connection_support: SecureConnectionSupport::Optional,
-        })
-        .await
-        .unwrap();
-    let response = mbox.ble_subsystem.read().await;
+    ble.set_authentication_requirement(&AuthenticationRequirements {
+        bonding_required: false,
+        keypress_notification_support: false,
+        mitm_protection_required: false,
+        encryption_key_size_range: (8, 16),
+        fixed_pin: Pin::Requested,
+        identity_address_type: AddressType::Public,
+        secure_connection_support: SecureConnectionSupport::Optional,
+    })
+    .await
+    .unwrap();
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     info!("set scan response data...");
-    mbox.ble_subsystem.le_set_scan_response_data(b"TXTX").await.unwrap();
-    let response = mbox.ble_subsystem.read().await;
+    ble.le_set_scan_response_data(b"TXTX").await.unwrap();
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     defmt::info!("initializing services and characteristics...");
-    let mut ble_context = init_gatt_services(&mut mbox.ble_subsystem).await.unwrap();
+    let mut ble_context = init_gatt_services(&mut ble).await.unwrap();
     defmt::info!("{}", ble_context);
 
     let discovery_params = DiscoverableParameters {
@@ -168,12 +161,12 @@ async fn main(spawner: Spawner) {
     };
 
     info!("set discoverable...");
-    mbox.ble_subsystem.set_discoverable(&discovery_params).await.unwrap();
-    let response = mbox.ble_subsystem.read().await;
+    ble.set_discoverable(&discovery_params).await.unwrap();
+    let response = ble.read().await;
     defmt::debug!("{}", response);
 
     loop {
-        let response = mbox.ble_subsystem.read().await;
+        let response = ble.read().await;
         defmt::debug!("{}", response);
 
         if let Ok(Packet::Event(event)) = response {
@@ -184,24 +177,23 @@ async fn main(spawner: Spawner) {
                 Event::DisconnectionComplete(_) => {
                     defmt::info!("disconnected");
                     ble_context.is_subscribed = false;
-                    mbox.ble_subsystem.set_discoverable(&discovery_params).await.unwrap();
+                    ble.set_discoverable(&discovery_params).await.unwrap();
                 }
                 Event::Vendor(vendor_event) => match vendor_event {
                     VendorEvent::AttReadPermitRequest(read_req) => {
                         defmt::info!("read request received {}, allowing", read_req);
-                        mbox.ble_subsystem.allow_read(read_req.conn_handle).await
+                        ble.allow_read(read_req.conn_handle).await
                     }
                     VendorEvent::AttWritePermitRequest(write_req) => {
                         defmt::info!("write request received {}, allowing", write_req);
-                        mbox.ble_subsystem
-                            .write_response(&WriteResponseParameters {
-                                conn_handle: write_req.conn_handle,
-                                attribute_handle: write_req.attribute_handle,
-                                status: Ok(()),
-                                value: write_req.value(),
-                            })
-                            .await
-                            .unwrap()
+                        ble.write_response(&WriteResponseParameters {
+                            conn_handle: write_req.conn_handle,
+                            attribute_handle: write_req.attribute_handle,
+                            status: Ok(()),
+                            value: write_req.value(),
+                        })
+                        .await
+                        .unwrap()
                     }
                     VendorEvent::GattAttributeModified(attribute) => {
                         defmt::info!("{}", ble_context);
@@ -224,7 +216,7 @@ async fn main(spawner: Spawner) {
 }
 
 #[embassy_executor::task]
-async fn run_mm_queue(memory_manager: mm::MemoryManager) {
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
@@ -285,7 +277,7 @@ pub struct CharHandles {
     pub notify: AttributeHandle,
 }
 
-pub async fn init_gatt_services(ble_subsystem: &mut Ble) -> Result<BleContext, ()> {
+pub async fn init_gatt_services<'a>(ble_subsystem: &mut Ble<'a>) -> Result<BleContext, ()> {
     let service_handle = gatt_add_service(ble_subsystem, Uuid::Uuid16(0x500)).await?;
 
     let read = gatt_add_char(
@@ -322,7 +314,7 @@ pub async fn init_gatt_services(ble_subsystem: &mut Ble) -> Result<BleContext, (
     })
 }
 
-async fn gatt_add_service(ble_subsystem: &mut Ble, uuid: Uuid) -> Result<AttributeHandle, ()> {
+async fn gatt_add_service<'a>(ble_subsystem: &mut Ble<'a>, uuid: Uuid) -> Result<AttributeHandle, ()> {
     ble_subsystem
         .add_service(&AddServiceParameters {
             uuid,
@@ -348,8 +340,8 @@ async fn gatt_add_service(ble_subsystem: &mut Ble, uuid: Uuid) -> Result<Attribu
     }
 }
 
-async fn gatt_add_char(
-    ble_subsystem: &mut Ble,
+async fn gatt_add_char<'a>(
+    ble_subsystem: &mut Ble<'a>,
     service_handle: AttributeHandle,
     characteristic_uuid: Uuid,
     characteristic_properties: CharacteristicProperty,
diff --git a/examples/stm32wb/src/bin/mac_ffd.rs b/examples/stm32wb/src/bin/mac_ffd.rs
index 18a52e162..4bab6ea9f 100644
--- a/examples/stm32wb/src/bin/mac_ffd.rs
+++ b/examples/stm32wb/src/bin/mac_ffd.rs
@@ -19,7 +19,7 @@ bind_interrupts!(struct Irqs{
 });
 
 #[embassy_executor::task]
-async fn run_mm_queue(memory_manager: mm::MemoryManager) {
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
@@ -54,74 +54,72 @@ async fn main(spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
 
     spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
-
-    core::mem::drop(sys_event);
-
-    let result = mbox.sys_subsystem.shci_c2_mac_802_15_4_init().await;
+    let result = sys.shci_c2_mac_802_15_4_init().await;
     info!("initialized mac: {}", result);
 
+    let (mut mac_rx, mut mac_tx) = mbox.mac_subsystem.split();
+
     info!("resetting");
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&ResetRequest {
             set_default_pib: true,
             ..Default::default()
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting extended address");
     let extended_address: u64 = 0xACDE480000000001;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &extended_address as *const _ as *const u8,
             pib_attribute: PibId::ExtendedAddress,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting short address");
     let short_address: u16 = 0x1122;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &short_address as *const _ as *const u8,
             pib_attribute: PibId::ShortAddress,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting association permit");
     let association_permit: bool = true;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &association_permit as *const _ as *const u8,
             pib_attribute: PibId::AssociationPermit,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting TX power");
     let transmit_power: i8 = 2;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &transmit_power as *const _ as *const u8,
             pib_attribute: PibId::TransmitPower,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("starting FFD device");
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&StartRequest {
             pan_id: PanId([0x1A, 0xAA]),
             channel_number: MacChannel::Channel16,
@@ -133,28 +131,27 @@ async fn main(spawner: Spawner) {
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting RX on when idle");
     let rx_on_while_idle: bool = true;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &rx_on_while_idle as *const _ as *const u8,
             pib_attribute: PibId::RxOnWhenIdle,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     loop {
-        let evt = mbox.mac_subsystem.read().await;
+        let evt = mac_rx.read().await;
         if let Ok(evt) = evt {
             defmt::info!("parsed mac event");
             defmt::info!("{:#x}", evt);
 
             match evt {
-                MacEvent::MlmeAssociateInd(association) => mbox
-                    .mac_subsystem
+                MacEvent::MlmeAssociateInd(association) => mac_tx
                     .send_command(&AssociateResponse {
                         device_address: association.device_address,
                         assoc_short_address: [0x33, 0x44],
diff --git a/examples/stm32wb/src/bin/mac_ffd_net.rs b/examples/stm32wb/src/bin/mac_ffd_net.rs
index 5d946b35b..b4789e3ee 100644
--- a/examples/stm32wb/src/bin/mac_ffd_net.rs
+++ b/examples/stm32wb/src/bin/mac_ffd_net.rs
@@ -27,7 +27,7 @@ bind_interrupts!(struct Irqs{
 });
 
 #[embassy_executor::task]
-async fn run_mm_queue(memory_manager: mm::MemoryManager) -> ! {
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) -> ! {
     memory_manager.run_queue().await
 }
 
@@ -72,15 +72,10 @@ async fn main(spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mut mbox = TlMbox::init(p.IPCC, Irqs, config).await;
 
     spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
-
-    core::mem::drop(sys_event);
-
     let result = mbox.sys_subsystem.shci_c2_mac_802_15_4_init().await;
     info!("initialized mac: {}", result);
 
diff --git a/examples/stm32wb/src/bin/mac_rfd.rs b/examples/stm32wb/src/bin/mac_rfd.rs
index 883179023..dae3c5200 100644
--- a/examples/stm32wb/src/bin/mac_rfd.rs
+++ b/examples/stm32wb/src/bin/mac_rfd.rs
@@ -21,7 +21,7 @@ bind_interrupts!(struct Irqs{
 });
 
 #[embassy_executor::task]
-async fn run_mm_queue(memory_manager: mm::MemoryManager) {
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
@@ -56,41 +56,39 @@ async fn main(spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
 
     spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
-
-    core::mem::drop(sys_event);
-
-    let result = mbox.sys_subsystem.shci_c2_mac_802_15_4_init().await;
+    let result = sys.shci_c2_mac_802_15_4_init().await;
     info!("initialized mac: {}", result);
 
+    let (mut mac_rx, mut mac_tx) = mbox.mac_subsystem.split();
+
     info!("resetting");
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&ResetRequest {
             set_default_pib: true,
             ..Default::default()
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("setting extended address");
     let extended_address: u64 = 0xACDE480000000002;
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &extended_address as *const _ as *const u8,
             pib_attribute: PibId::ExtendedAddress,
         })
         .await
         .unwrap();
-    defmt::info!("{:#x}", mbox.mac_subsystem.read().await.unwrap());
+    defmt::info!("{:#x}", mac_rx.read().await.unwrap());
 
     info!("getting extended address");
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&GetRequest {
             pib_attribute: PibId::ExtendedAddress,
             ..Default::default()
@@ -99,7 +97,7 @@ async fn main(spawner: Spawner) {
         .unwrap();
 
     {
-        let evt = mbox.mac_subsystem.read().await.unwrap();
+        let evt = mac_rx.read().await.unwrap();
         info!("{:#x}", evt);
 
         if let MacEvent::MlmeGetCnf(evt) = evt {
@@ -125,9 +123,9 @@ async fn main(spawner: Spawner) {
         key_index: 152,
     };
     info!("{}", a);
-    mbox.mac_subsystem.send_command(&a).await.unwrap();
+    mac_tx.send_command(&a).await.unwrap();
     let short_addr = {
-        let evt = mbox.mac_subsystem.read().await.unwrap();
+        let evt = mac_rx.read().await.unwrap();
         info!("{:#x}", evt);
 
         if let MacEvent::MlmeAssociateCnf(conf) = evt {
@@ -138,7 +136,7 @@ async fn main(spawner: Spawner) {
     };
 
     info!("setting short address");
-    mbox.mac_subsystem
+    mac_tx
         .send_command(&SetRequest {
             pib_attribute_ptr: &short_addr as *const _ as *const u8,
             pib_attribute: PibId::ShortAddress,
@@ -146,13 +144,13 @@ async fn main(spawner: Spawner) {
         .await
         .unwrap();
     {
-        let evt = mbox.mac_subsystem.read().await.unwrap();
+        let evt = mac_rx.read().await.unwrap();
         info!("{:#x}", evt);
     }
 
     info!("sending data");
     let data = b"Hello from embassy!";
-    mbox.mac_subsystem
+    mac_tx
         .send_command(
             DataRequest {
                 src_addr_mode: AddressMode::Short,
@@ -170,12 +168,12 @@ async fn main(spawner: Spawner) {
         .await
         .unwrap();
     {
-        let evt = mbox.mac_subsystem.read().await.unwrap();
+        let evt = mac_rx.read().await.unwrap();
         info!("{:#x}", evt);
     }
 
     loop {
-        match mbox.mac_subsystem.read().await {
+        match mac_rx.read().await {
             Ok(evt) => info!("{:#x}", evt),
             _ => continue,
         };
diff --git a/examples/stm32wb/src/bin/tl_mbox.rs b/examples/stm32wb/src/bin/tl_mbox.rs
index 4e7f2304d..0902e28e8 100644
--- a/examples/stm32wb/src/bin/tl_mbox.rs
+++ b/examples/stm32wb/src/bin/tl_mbox.rs
@@ -46,7 +46,7 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
 
     loop {
         let wireless_fw_info = mbox.sys_subsystem.wireless_fw_info();
diff --git a/examples/stm32wb/src/bin/tl_mbox_ble.rs b/examples/stm32wb/src/bin/tl_mbox_ble.rs
index 72a4c18e6..763dc32cd 100644
--- a/examples/stm32wb/src/bin/tl_mbox_ble.rs
+++ b/examples/stm32wb/src/bin/tl_mbox_ble.rs
@@ -7,6 +7,7 @@ use embassy_stm32::bind_interrupts;
 use embassy_stm32::ipcc::{Config, ReceiveInterruptHandler, TransmitInterruptHandler};
 use embassy_stm32::rcc::WPAN_DEFAULT;
 use embassy_stm32_wpan::TlMbox;
+use embassy_stm32_wpan::sub::mm;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs{
@@ -14,8 +15,13 @@ bind_interrupts!(struct Irqs{
     IPCC_C1_TX => TransmitInterruptHandler;
 });
 
+#[embassy_executor::task]
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
+    memory_manager.run_queue().await;
+}
+
 #[embassy_executor::main]
-async fn main(_spawner: Spawner) {
+async fn main(spawner: Spawner) {
     /*
         How to make this work:
 
@@ -45,18 +51,19 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
+    let mut ble = mbox.ble_subsystem;
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
+    spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
-    let _ = mbox.sys_subsystem.shci_c2_ble_init(Default::default()).await;
+    let _ = sys.shci_c2_ble_init(Default::default()).await;
 
     info!("starting ble...");
-    mbox.ble_subsystem.tl_write(0x0c, &[]).await;
+    ble.tl_write(0x0c, &[]).await;
 
     info!("waiting for ble...");
-    let ble_event = mbox.ble_subsystem.tl_read().await;
+    let ble_event = ble.tl_read().await;
 
     info!("ble event: {}", ble_event.payload());
 
diff --git a/examples/stm32wb/src/bin/tl_mbox_mac.rs b/examples/stm32wb/src/bin/tl_mbox_mac.rs
index 16d0a1527..235a48241 100644
--- a/examples/stm32wb/src/bin/tl_mbox_mac.rs
+++ b/examples/stm32wb/src/bin/tl_mbox_mac.rs
@@ -16,7 +16,7 @@ bind_interrupts!(struct Irqs{
 });
 
 #[embassy_executor::task]
-async fn run_mm_queue(memory_manager: mm::MemoryManager) {
+async fn run_mm_queue(mut memory_manager: mm::MemoryManager<'static>) {
     memory_manager.run_queue().await;
 }
 
@@ -51,16 +51,12 @@ async fn main(spawner: Spawner) {
     info!("Hello World!");
 
     let config = Config::default();
-    let mbox = TlMbox::init(p.IPCC, Irqs, config);
+    let mbox = TlMbox::init(p.IPCC, Irqs, config).await;
+    let mut sys = mbox.sys_subsystem;
 
     spawner.spawn(run_mm_queue(mbox.mm_subsystem).unwrap());
 
-    let sys_event = mbox.sys_subsystem.read().await;
-    info!("sys event: {}", sys_event.payload());
-
-    core::mem::drop(sys_event);
-
-    let result = mbox.sys_subsystem.shci_c2_mac_802_15_4_init().await;
+    let result = sys.shci_c2_mac_802_15_4_init().await;
     info!("initialized mac: {}", result);
 
     //