wpan: fix comp errors and impl. some of runner

embassy-stm32-wpan/src/mac/driver.rs

@@ -25,6 +25,8 @@ impl<'d> embassy_net_driver::Driver for Driver<'d> {
     type TxToken<'a> = TxToken where Self: 'a;
 
     fn receive(&mut self, cx: &mut Context) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
+        self.runner.rx_waker.register(cx.waker());
+
         // WAKER.register(cx.waker());
         //        if self.rx.available().is_some() && self.tx.available().is_some() {
         //            Some((RxToken { rx: &mut self.rx }, TxToken { tx: &mut self.tx }))
@@ -36,6 +38,8 @@ impl<'d> embassy_net_driver::Driver for Driver<'d> {
     }
 
     fn transmit(&mut self, cx: &mut Context) -> Option<Self::TxToken<'_>> {
+        self.runner.tx_waker.register(cx.waker());
+
         // WAKER.register(cx.waker());
         // /        if self.tx.available().is_some() {
         // /            Some(TxToken { tx: &mut self.tx })
@@ -84,7 +88,7 @@ impl embassy_net_driver::RxToken for RxToken {
         // NOTE(unwrap): we checked the queue wasn't full when creating the token.
         // let pkt = unwrap!(self.rx.available());
 
-        let pkt = &[];
+        let pkt = &mut [];
         let r = f(&mut pkt[0..]);
         // self.rx.pop_packet();
         r
@@ -102,7 +106,7 @@ impl embassy_net_driver::TxToken for TxToken {
     {
         // NOTE(unwrap): we checked the queue wasn't full when creating the token.
         // let pkt = unwrap!(self.tx.available());
-        let pkt = &[];
+        let pkt = &mut [];
         let r = f(&mut pkt[..len]);
         // self.tx.transmit(len);
         r

embassy-stm32-wpan/src/mac/mod.rs

@@ -15,16 +15,11 @@ use core::slice;
 pub use crate::mac::control::{Control, Error as ControlError};
 use crate::mac::driver::Driver;
 pub use crate::mac::runner::Runner;
-use crate::sub::mac::Mac;
 
 const MTU: usize = 127;
 
-pub async fn new<'a>(mac: Mac) -> (Runner, Control<'a>, Driver<'a>) {
-    let runner = Runner::new(mac);
-    let control = Control::new(&runner);
-    let driver = Driver::new(&runner);
-
-    (runner, control, driver)
+pub async fn new<'a>(runner: &'a Runner) -> (Control<'a>, Driver<'a>) {
+    (Control::new(runner), Driver::new(runner))
 }
 
 fn slice8_mut(x: &mut [u32]) -> &mut [u8] {

embassy-stm32-wpan/src/mac/runner.rs

@@ -1,27 +1,86 @@
 use embassy_futures::select::{select3, Either3};
+use embassy_sync::waitqueue::AtomicWaker;
 
+use crate::mac::event::{Event, MacEvent};
 use crate::mac::MTU;
 use crate::sub::mac::Mac;
 
+pub(crate) struct TxRing {
+    // stores n packets of up to mtu size
+    ring: [[u8; MTU]; 5],
+    pending: bool,
+    //    start: u8,
+    //    end: u8,
+}
+
+impl TxRing {
+    pub(crate) fn new() -> Self {
+        Self {
+            ring: [[0; MTU]; 5],
+            pending: false,
+        }
+    }
+
+    // wait for a free packet to become available
+    pub fn is_packet_free(&self) -> bool {
+        !self.pending
+    }
+
+    // get the next available free packet
+    pub fn get_free_packet<'a>(&'a mut self) -> &'a mut [u8] {
+        self.pending = true;
+
+        &mut self.ring[0]
+    }
+
+    pub fn get_packet_to_transmit<'a>(&'a mut self) -> Option<&'a [u8]> {
+        if self.pending {
+            self.pending = false;
+
+            Some(&self.ring[0])
+        } else {
+            None
+        }
+    }
+}
+
 pub struct Runner {
-    mac: Mac,
-    // TODO: tx_ring
-    // TODO: rx_buf
+    mac_subsystem: Mac,
+    pub(crate) rx_ring: Option<Event>,
+    pub(crate) tx_ring: TxRing,
+    pub(crate) rx_waker: AtomicWaker,
+    pub(crate) tx_waker: AtomicWaker,
 }
 
 impl Runner {
-    pub(crate) fn new(mac: Mac) -> Self {
-        Self { mac }
+    pub fn new(mac: Mac) -> Self {
+        Self {
+            mac_subsystem: mac,
+            rx_ring: None,
+            tx_ring: TxRing::new(),
+            rx_waker: AtomicWaker::new(),
+            tx_waker: AtomicWaker::new(),
+        }
     }
 
     pub(crate) async fn init(&mut self, firmware: &[u8]) {
         debug!("wifi init done");
     }
 
-    pub async fn run(mut self) -> ! {
-        let mut buf = [0; 512];
+    pub async fn run(&self) -> ! {
         loop {
-            // TODO
+            let event = self.mac_subsystem.read().await;
+            if let Ok(evt) = event.mac_event() {
+                match evt {
+                    MacEvent::McpsDataInd(data_ind) => {
+                        // TODO: store mac_event in rx_ring
+                        self.rx_waker.wake();
+                    }
+                    _ => {}
+                }
+            }
+
+            // TODO: select tx event
         }
     }
 }