From eec75c8f82efda9a2f537cc17cdfc5d4cdc092aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1niel=20Buga?= Date: Mon, 25 Nov 2024 18:06:05 +0100 Subject: [PATCH] Replace some esp-wifi critical sections with locks (#2554) * Replace some esp-wifi critical sections with locks * Remove critical section from event handlers * Fix doc warnings and accidentally hard-coded esp32s3 * Use Lock in wifi_int_disable/restore * Replace critical_section in ConcurrentQueue * Deduplicate wifi_int_disable --- esp-wifi/src/compat/common.rs | 17 +- esp-wifi/src/compat/timer_compat.rs | 19 +- esp-wifi/src/lib.rs | 7 +- esp-wifi/src/preempt/mod.rs | 29 ++- esp-wifi/src/tasks.rs | 19 +- esp-wifi/src/timer/mod.rs | 6 +- esp-wifi/src/timer/riscv.rs | 18 +- esp-wifi/src/timer/xtensa.rs | 14 +- esp-wifi/src/wifi/event.rs | 187 ++++++++---------- esp-wifi/src/wifi/mod.rs | 70 +++---- esp-wifi/src/wifi/os_adapter.rs | 25 +-- esp-wifi/src/wifi/os_adapter_esp32.rs | 39 ---- esp-wifi/src/wifi/os_adapter_esp32c2.rs | 44 +---- esp-wifi/src/wifi/os_adapter_esp32c3.rs | 44 +---- esp-wifi/src/wifi/os_adapter_esp32c6.rs | 44 +---- esp-wifi/src/wifi/os_adapter_esp32h2.rs | 40 +--- esp-wifi/src/wifi/os_adapter_esp32s2.rs | 19 -- esp-wifi/src/wifi/os_adapter_esp32s3.rs | 19 -- examples/src/bin/wifi_access_point.rs | 8 +- examples/src/bin/wifi_embassy_access_point.rs | 2 +- 20 files changed, 195 insertions(+), 475 deletions(-) diff --git a/esp-wifi/src/compat/common.rs b/esp-wifi/src/compat/common.rs index 784c0366c..219ac01e4 100644 --- a/esp-wifi/src/compat/common.rs +++ b/esp-wifi/src/compat/common.rs @@ -12,6 +12,7 @@ use esp_wifi_sys::include::malloc; use super::malloc::free; use crate::{ binary::c_types::{c_int, c_void}, + hal::sync::Locked, memory_fence::memory_fence, preempt::current_task, timer::yield_task, @@ -27,36 +28,34 @@ struct Mutex { } pub(crate) struct ConcurrentQueue { - raw_queue: critical_section::Mutex>, + raw_queue: Locked, } impl ConcurrentQueue { pub(crate) fn new(count: usize, item_size: usize) -> Self { Self { - raw_queue: critical_section::Mutex::new(RefCell::new(RawQueue::new(count, item_size))), + raw_queue: Locked::new(RawQueue::new(count, item_size)), } } fn release_storage(&mut self) { - critical_section::with(|cs| unsafe { - self.raw_queue.borrow_ref_mut(cs).release_storage(); - }) + self.raw_queue.with(|q| unsafe { q.release_storage() }) } pub(crate) fn enqueue(&mut self, item: *mut c_void) -> i32 { - critical_section::with(|cs| unsafe { self.raw_queue.borrow_ref_mut(cs).enqueue(item) }) + self.raw_queue.with(|q| unsafe { q.enqueue(item) }) } pub(crate) fn try_dequeue(&mut self, item: *mut c_void) -> bool { - critical_section::with(|cs| unsafe { self.raw_queue.borrow_ref_mut(cs).try_dequeue(item) }) + self.raw_queue.with(|q| unsafe { q.try_dequeue(item) }) } pub(crate) fn remove(&mut self, item: *mut c_void) { - critical_section::with(|cs| unsafe { self.raw_queue.borrow_ref_mut(cs).remove(item) }); + self.raw_queue.with(|q| unsafe { q.remove(item) }) } pub(crate) fn count(&self) -> usize { - critical_section::with(|cs| unsafe { self.raw_queue.borrow_ref(cs).count() }) + self.raw_queue.with(|q| unsafe { q.count() }) } } diff --git a/esp-wifi/src/compat/timer_compat.rs b/esp-wifi/src/compat/timer_compat.rs index 62204f12b..42b9e94e4 100644 --- a/esp-wifi/src/compat/timer_compat.rs +++ b/esp-wifi/src/compat/timer_compat.rs @@ -1,7 +1,6 @@ use alloc::boxed::Box; -use core::cell::RefCell; -use critical_section::Mutex; +use esp_hal::sync::Locked; use crate::binary::{ c_types, @@ -138,7 +137,7 @@ impl TimerQueue { unsafe impl Send for TimerQueue {} -pub(crate) static TIMERS: Mutex> = Mutex::new(RefCell::new(TimerQueue::new())); +pub(crate) static TIMERS: Locked = Locked::new(TimerQueue::new()); pub(crate) fn compat_timer_arm(ets_timer: *mut ets_timer, tmout: u32, repeat: bool) { compat_timer_arm_us(ets_timer, tmout * 1000, repeat); @@ -156,8 +155,8 @@ pub(crate) fn compat_timer_arm_us(ets_timer: *mut ets_timer, us: u32, repeat: bo repeat ); - critical_section::with(|cs| { - if let Some(timer) = TIMERS.borrow_ref_mut(cs).find(ets_timer) { + TIMERS.with(|timers| { + if let Some(timer) = timers.find(ets_timer) { timer.started = systick; timer.timeout = ticks; timer.active = true; @@ -170,8 +169,8 @@ pub(crate) fn compat_timer_arm_us(ets_timer: *mut ets_timer, us: u32, repeat: bo pub fn compat_timer_disarm(ets_timer: *mut ets_timer) { trace!("timer disarm"); - critical_section::with(|cs| { - if let Some(timer) = TIMERS.borrow_ref_mut(cs).find(ets_timer) { + TIMERS.with(|timers| { + if let Some(timer) = timers.find(ets_timer) { trace!("timer_disarm {:x}", timer.id()); timer.active = false; } else { @@ -182,8 +181,7 @@ pub fn compat_timer_disarm(ets_timer: *mut ets_timer) { pub fn compat_timer_done(ets_timer: *mut ets_timer) { trace!("timer done"); - critical_section::with(|cs| { - let mut timers = TIMERS.borrow_ref_mut(cs); + TIMERS.with(|timers| { if let Some(timer) = timers.find(ets_timer) { trace!("timer_done {:x}", timer.id()); timer.active = false; @@ -211,8 +209,7 @@ pub(crate) fn compat_timer_setfn( pfunction, parg ); - let set = critical_section::with(|cs| unsafe { - let mut timers = TIMERS.borrow_ref_mut(cs); + let set = TIMERS.with(|timers| unsafe { if let Some(timer) = timers.find(ets_timer) { timer.callback = TimerCallback::new(pfunction, parg); timer.active = false; diff --git a/esp-wifi/src/lib.rs b/esp-wifi/src/lib.rs index b01fb4cff..a7c890210 100644 --- a/esp-wifi/src/lib.rs +++ b/esp-wifi/src/lib.rs @@ -22,16 +22,15 @@ //! ```toml //! [dependencies.esp-wifi] //! # A supported chip needs to be specified, as well as specific use-case features -//! features = ["esp32s3", "wifi", "esp-now"] +#![doc = concat!(r#"features = [""#, esp_hal::chip!(), r#"", "wifi", "esp-now"]"#)] //! ``` -//! +//! //! ### Optimization Level //! //! It is necessary to build with optimization level 2 or 3 since otherwise, it //! might not even be able to connect or advertise. //! //! To make it work also for your debug builds add this to your `Cargo.toml` -//! //! ```toml //! [profile.dev.package.esp-wifi] //! opt-level = 3 @@ -419,7 +418,7 @@ pub unsafe fn deinit_unchecked() -> Result<(), InitializationError> { shutdown_timer_isr(); crate::preempt::delete_all_tasks(); - critical_section::with(|cs| crate::timer::TIMER.borrow_ref_mut(cs).take()); + crate::timer::TIMER.with(|timer| timer.take()); crate::flags::ESP_WIFI_INITIALIZED.store(false, Ordering::Release); diff --git a/esp-wifi/src/preempt/mod.rs b/esp-wifi/src/preempt/mod.rs index 18e2ffe7e..1589fb996 100644 --- a/esp-wifi/src/preempt/mod.rs +++ b/esp-wifi/src/preempt/mod.rs @@ -2,10 +2,10 @@ #[cfg_attr(target_arch = "xtensa", path = "preempt_xtensa.rs")] pub mod arch_specific; -use core::{cell::RefCell, mem::size_of}; +use core::mem::size_of; use arch_specific::*; -use critical_section::Mutex; +use esp_hal::sync::Locked; use esp_wifi_sys::include::malloc; use crate::{compat::malloc::free, hal::trapframe::TrapFrame, memory_fence::memory_fence}; @@ -15,14 +15,12 @@ struct ContextWrapper(*mut Context); unsafe impl Send for ContextWrapper {} -static CTX_NOW: Mutex> = - Mutex::new(RefCell::new(ContextWrapper(core::ptr::null_mut()))); +static CTX_NOW: Locked = Locked::new(ContextWrapper(core::ptr::null_mut())); static mut SCHEDULED_TASK_TO_DELETE: *mut Context = core::ptr::null_mut(); pub(crate) fn allocate_main_task() -> *mut Context { - critical_section::with(|cs| unsafe { - let mut ctx_now = CTX_NOW.borrow_ref_mut(cs); + CTX_NOW.with(|ctx_now| unsafe { if !ctx_now.0.is_null() { panic!("Tried to allocate main task multiple times"); } @@ -36,8 +34,7 @@ pub(crate) fn allocate_main_task() -> *mut Context { } fn allocate_task() -> *mut Context { - critical_section::with(|cs| unsafe { - let mut ctx_now = CTX_NOW.borrow_ref_mut(cs); + CTX_NOW.with(|ctx_now| unsafe { if ctx_now.0.is_null() { panic!("Called `allocate_task` before allocating main task"); } @@ -51,8 +48,7 @@ fn allocate_task() -> *mut Context { } fn next_task() { - critical_section::with(|cs| unsafe { - let mut ctx_now = CTX_NOW.borrow_ref_mut(cs); + CTX_NOW.with(|ctx_now| unsafe { ctx_now.0 = (*ctx_now.0).next; }); } @@ -61,8 +57,8 @@ fn next_task() { /// /// This will also free the memory (stack and context) allocated for it. pub(crate) fn delete_task(task: *mut Context) { - critical_section::with(|cs| unsafe { - let mut ptr = CTX_NOW.borrow_ref_mut(cs).0; + CTX_NOW.with(|ctx_now| unsafe { + let mut ptr = ctx_now.0; let initial = ptr; loop { if (*ptr).next == task { @@ -85,9 +81,8 @@ pub(crate) fn delete_task(task: *mut Context) { } pub(crate) fn delete_all_tasks() { - critical_section::with(|cs| unsafe { - let mut ctx_now_ref = CTX_NOW.borrow_ref_mut(cs); - let current_task = ctx_now_ref.0; + CTX_NOW.with(|ctx_now| unsafe { + let current_task = ctx_now.0; if current_task.is_null() { return; @@ -108,14 +103,14 @@ pub(crate) fn delete_all_tasks() { task_to_delete = next_task; } - ctx_now_ref.0 = core::ptr::null_mut(); + ctx_now.0 = core::ptr::null_mut(); memory_fence(); }); } pub(crate) fn current_task() -> *mut Context { - critical_section::with(|cs| CTX_NOW.borrow_ref(cs).0) + CTX_NOW.with(|ctx_now| ctx_now.0) } pub(crate) fn schedule_task_deletion(task: *mut Context) { diff --git a/esp-wifi/src/tasks.rs b/esp-wifi/src/tasks.rs index 7dae1e046..4e51e505d 100644 --- a/esp-wifi/src/tasks.rs +++ b/esp-wifi/src/tasks.rs @@ -18,21 +18,16 @@ pub(crate) fn init_tasks() { pub(crate) extern "C" fn timer_task(_param: *mut esp_wifi_sys::c_types::c_void) { loop { let current_timestamp = systimer_count(); - let to_run = critical_section::with(|cs| unsafe { - let mut timers = TIMERS.borrow_ref_mut(cs); - let to_run = timers.find_next_due(current_timestamp); + let to_run = TIMERS.with(|timers| { + let to_run = unsafe { timers.find_next_due(current_timestamp) }?; - if let Some(to_run) = to_run { - to_run.active = to_run.periodic; + to_run.active = to_run.periodic; - if to_run.periodic { - to_run.started = current_timestamp; - } - - Some(to_run.callback) - } else { - None + if to_run.periodic { + to_run.started = current_timestamp; } + + Some(to_run.callback) }); // run the due timer callback NOT in an interrupt free context diff --git a/esp-wifi/src/timer/mod.rs b/esp-wifi/src/timer/mod.rs index 0cd4d541e..56fd1dd95 100644 --- a/esp-wifi/src/timer/mod.rs +++ b/esp-wifi/src/timer/mod.rs @@ -1,6 +1,4 @@ -use core::cell::RefCell; - -use critical_section::Mutex; +use esp_hal::sync::Locked; #[cfg_attr(esp32, path = "timer_esp32.rs")] #[cfg_attr(esp32c2, path = "timer_esp32c2.rs")] @@ -20,7 +18,7 @@ pub(crate) use chip_specific::*; use crate::TimeBase; -pub(crate) static TIMER: Mutex>> = Mutex::new(RefCell::new(None)); +pub(crate) static TIMER: Locked> = Locked::new(None); pub(crate) fn setup_timer_isr(timebase: TimeBase) { setup_radio_isr(); diff --git a/esp-wifi/src/timer/riscv.rs b/esp-wifi/src/timer/riscv.rs index b0a4bb263..a73e3b18e 100644 --- a/esp-wifi/src/timer/riscv.rs +++ b/esp-wifi/src/timer/riscv.rs @@ -30,16 +30,17 @@ pub(crate) fn setup_timer(mut alarm0: TimeBase) { let cb: extern "C" fn() = unsafe { core::mem::transmute(handler as *const ()) }; alarm0.set_interrupt_handler(InterruptHandler::new(cb, interrupt::Priority::Priority1)); unwrap!(alarm0.start(TIMESLICE_FREQUENCY.into_duration())); - critical_section::with(|cs| { + TIMER.with(|timer| { alarm0.enable_interrupt(true); - TIMER.borrow_ref_mut(cs).replace(alarm0); + timer.replace(alarm0); }); } pub(crate) fn disable_timer() { - critical_section::with(|cs| { - unwrap!(TIMER.borrow_ref_mut(cs).as_mut()).enable_interrupt(false); - unwrap!(unwrap!(TIMER.borrow_ref_mut(cs).as_mut()).cancel()); + TIMER.with(|timer| { + let timer = unwrap!(timer.as_mut()); + timer.enable_interrupt(false); + unwrap!(timer.cancel()); }); } @@ -60,8 +61,8 @@ pub(crate) fn disable_multitasking() { extern "C" fn handler(trap_frame: &mut TrapFrame) { // clear the systimer intr - critical_section::with(|cs| { - unwrap!(TIMER.borrow_ref_mut(cs).as_mut()).clear_interrupt(); + TIMER.with(|timer| { + unwrap!(timer.as_mut()).clear_interrupt(); }); task_switch(trap_frame); @@ -76,8 +77,7 @@ extern "C" fn FROM_CPU_INTR3(trap_frame: &mut TrapFrame) { .modify(|_, w| w.cpu_intr_from_cpu_3().clear_bit()); } - critical_section::with(|cs| { - let mut alarm0 = TIMER.borrow_ref_mut(cs); + TIMER.with(|alarm0| { let alarm0 = unwrap!(alarm0.as_mut()); alarm0.clear_interrupt(); }); diff --git a/esp-wifi/src/timer/xtensa.rs b/esp-wifi/src/timer/xtensa.rs index 3cff547ac..fc4771411 100644 --- a/esp-wifi/src/timer/xtensa.rs +++ b/esp-wifi/src/timer/xtensa.rs @@ -27,16 +27,17 @@ pub(crate) fn setup_timer(mut timer1: TimeBase) { interrupt::Priority::Priority2, )); unwrap!(timer1.start(TIMESLICE_FREQUENCY.into_duration())); - critical_section::with(|cs| { + TIMER.with(|timer| { timer1.enable_interrupt(true); - TIMER.borrow_ref_mut(cs).replace(timer1); + timer.replace(timer1); }); } pub(crate) fn disable_timer() { - critical_section::with(|cs| { - unwrap!(TIMER.borrow_ref_mut(cs).as_mut()).enable_interrupt(false); - unwrap!(unwrap!(TIMER.borrow_ref_mut(cs).as_mut()).cancel()); + TIMER.with(|timer| { + let timer = unwrap!(timer.as_mut()); + timer.enable_interrupt(false); + unwrap!(timer.cancel()); }); } @@ -58,8 +59,7 @@ pub(crate) fn disable_multitasking() { } fn do_task_switch(context: &mut TrapFrame) { - critical_section::with(|cs| { - let mut timer = TIMER.borrow_ref_mut(cs); + TIMER.with(|timer| { let timer = unwrap!(timer.as_mut()); timer.clear_interrupt(); }); diff --git a/esp-wifi/src/wifi/event.rs b/esp-wifi/src/wifi/event.rs index f0daf78d4..e4925d921 100644 --- a/esp-wifi/src/wifi/event.rs +++ b/esp-wifi/src/wifi/event.rs @@ -1,7 +1,6 @@ use alloc::boxed::Box; -use core::cell::RefCell; -use critical_section::Mutex; +use esp_hal::sync::Locked; use super::WifiEvent; @@ -10,17 +9,17 @@ pub(crate) mod sealed { pub trait Event { /// Get the static reference to the handler for this event. - fn handler() -> &'static Mutex>>>>; + fn handler() -> &'static Locked>>>; /// # Safety /// `ptr` must be a valid for casting to this event's inner event data. unsafe fn from_raw_event_data(ptr: *mut crate::binary::c_types::c_void) -> Self; } } /// The type of handlers of events. -pub type Handler = dyn FnMut(critical_section::CriticalSection<'_>, &T) + Sync + Send; +pub type Handler = dyn FnMut(&T) + Sync + Send; fn default_handler() -> Box> { - fn drop_ref(_: critical_section::CriticalSection<'_>, _: &T) {} + fn drop_ref(_: &T) {} // perf: `drop_ref` is a ZST [function item](https://doc.rust-lang.org/reference/types/function-item.html) // so this doesn't actually allocate. Box::new(drop_ref) @@ -29,9 +28,10 @@ fn default_handler() -> Box> { /// Extension trait for setting handlers for an event. /// /// Register a new event handler like: -/// ``` +/// +/// ```rust, no_run /// # use esp_wifi::wifi::event::{self, *}; -/// # fn new_handler(_: critical_section::CriticalSection<'_>, _: &ApStaconnected) {} +/// # fn new_handler(_: &ApStaconnected) {} /// event::ApStaconnected::update_handler(|_cs, event| { /// new_handler(event); /// }) @@ -43,46 +43,28 @@ fn default_handler() -> Box> { pub trait EventExt: sealed::Event + Sized + 'static { /// Get the handler for this event, replacing it with the default handler. fn take_handler() -> Box> { - critical_section::with(|cs| { - Self::handler() - .borrow_ref_mut(cs) - .take() - .unwrap_or_else(default_handler::) - }) + Self::handler().with(|handler| handler.take().unwrap_or_else(default_handler::)) } /// Set the handler for this event, returning the old handler. - fn replace_handler< - F: FnMut(critical_section::CriticalSection<'_>, &Self) + Sync + Send + 'static, - >( - f: F, - ) -> Box> { - critical_section::with(|cs| { - Self::handler() - .borrow_ref_mut(cs) + fn replace_handler(f: F) -> Box> { + Self::handler().with(|handler| { + handler .replace(Box::new(f)) .unwrap_or_else(default_handler::) }) } - /// Atomic combination of [`take_handler`] and [`replace_handler`]. Use this - /// to add a new handler which runs after the previously registered - /// handlers. - fn update_handler< - F: FnMut(critical_section::CriticalSection<'_>, &Self) + Sync + Send + 'static, - >( - mut f: F, - ) { - critical_section::with(move |cs| { - let mut handler: Box> = Self::handler() - .borrow_ref_mut(cs) - .take() - .unwrap_or_else(default_handler::); - Self::handler().borrow_ref_mut(cs).replace(Box::new( - move |cs: critical_section::CriticalSection<'_>, event| { - handler(cs, event); - f(cs, event) - }, - )); - }); + /// Atomic combination of [`Self::take_handler`] and + /// [`Self::replace_handler`]. Use this to add a new handler which runs + /// after the previously registered handlers. + fn update_handler(mut f: F) { + Self::handler().with(|handler| { + let mut prev: Box> = + handler.take().unwrap_or_else(default_handler::); + handler.replace(Box::new(move |event| { + prev(event); + f(event) + })); + }) } } impl EventExt for T {} @@ -97,9 +79,8 @@ macro_rules! impl_wifi_event { unsafe fn from_raw_event_data(_: *mut crate::binary::c_types::c_void) -> Self { Self } - fn handler() -> &'static Mutex>>>> { - static HANDLE: Mutex>>>> = - Mutex::new(RefCell::new(None)); + fn handler() -> &'static Locked>>> { + static HANDLE: Locked>>> = Locked::new(None); &HANDLE } } @@ -114,9 +95,8 @@ macro_rules! impl_wifi_event { unsafe fn from_raw_event_data(ptr: *mut crate::binary::c_types::c_void) -> Self { Self(unsafe { *ptr.cast() }) } - fn handler() -> &'static Mutex>>>> { - static HANDLE: Mutex>>>> = - Mutex::new(RefCell::new(None)); + fn handler() -> &'static Locked>>> { + static HANDLE: Locked>>> = Locked::new(None); &HANDLE } } @@ -170,23 +150,21 @@ impl_wifi_event!(HomeChannelChange, wifi_event_home_channel_change_t); impl_wifi_event!(StaNeighborRep, wifi_event_neighbor_report_t); /// Handle the given event using the registered event handlers. -pub fn handle( - cs: critical_section::CriticalSection<'_>, - event_data: &Event, -) -> bool { - if let Some(handler) = &mut *Event::handler().borrow_ref_mut(cs) { - handler(cs, event_data); - true - } else { - false - } +pub fn handle(event_data: &Event) -> bool { + Event::handler().with(|handler| { + if let Some(handler) = handler { + handler(event_data); + true + } else { + false + } + }) } /// Handle an event given the raw pointers. /// # Safety /// The pointer should be valid to cast to `Event`'s inner type (if it has one) pub(crate) unsafe fn handle_raw( - cs: critical_section::CriticalSection<'_>, event_data: *mut crate::binary::c_types::c_void, event_data_size: usize, ) -> bool { @@ -195,7 +173,7 @@ pub(crate) unsafe fn handle_raw( core::mem::size_of::(), "wrong size event data" ); - handle::(cs, unsafe { &Event::from_raw_event_data(event_data) }) + handle::(unsafe { &Event::from_raw_event_data(event_data) }) } /// Handle event regardless of its type. @@ -203,146 +181,145 @@ pub(crate) unsafe fn handle_raw( /// Arguments should be self-consistent. #[rustfmt::skip] pub(crate) unsafe fn dispatch_event_handler( - cs: critical_section::CriticalSection<'_>, event: WifiEvent, event_data: *mut crate::binary::c_types::c_void, event_data_size: usize, ) -> bool { match event { WifiEvent::WifiReady => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ScanDone => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaStart => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaStop => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaConnected => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaDisconnected => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaAuthmodeChange => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaWpsErSuccess => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaWpsErFailed => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaWpsErTimeout => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaWpsErPin => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaWpsErPbcOverlap => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApStart => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApStop => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApStaconnected => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApStadisconnected => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApProbereqrecved => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::FtmReport => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaBssRssiLow => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ActionTxStatus => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::RocDone => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaBeaconTimeout => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ConnectionlessModuleWakeIntervalStart => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApWpsRgSuccess => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApWpsRgFailed => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApWpsRgTimeout => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApWpsRgPin => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ApWpsRgPbcOverlap => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ItwtSetup => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ItwtTeardown => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ItwtProbe => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::ItwtSuspend => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::TwtWakeup => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::BtwtSetup => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::BtwtTeardown => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NanStarted => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NanStopped => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NanSvcMatch => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NanReplied => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NanReceive => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NdpIndication => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NdpConfirm => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::NdpTerminated => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::HomeChannelChange => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } WifiEvent::StaNeighborRep => { - handle_raw::(cs, event_data, event_data_size) + handle_raw::(event_data, event_data_size) } } } diff --git a/esp-wifi/src/wifi/mod.rs b/esp-wifi/src/wifi/mod.rs index d317a15fd..fa931bc85 100644 --- a/esp-wifi/src/wifi/mod.rs +++ b/esp-wifi/src/wifi/mod.rs @@ -6,15 +6,14 @@ pub(crate) mod state; use alloc::collections::vec_deque::VecDeque; use core::{ - cell::{RefCell, RefMut}, fmt::Debug, mem::{self, MaybeUninit}, ptr::addr_of, time::Duration, }; -use critical_section::{CriticalSection, Mutex}; use enumset::{EnumSet, EnumSetType}; +use esp_hal::sync::Locked; use esp_wifi_sys::include::{ esp_eap_client_clear_ca_cert, esp_eap_client_clear_certificate_and_key, @@ -952,11 +951,11 @@ const DATA_FRAME_SIZE: usize = MTU + ETHERNET_FRAME_HEADER_SIZE; const RX_QUEUE_SIZE: usize = crate::CONFIG.rx_queue_size; const TX_QUEUE_SIZE: usize = crate::CONFIG.tx_queue_size; -pub(crate) static DATA_QUEUE_RX_AP: Mutex>> = - Mutex::new(RefCell::new(VecDeque::new())); +pub(crate) static DATA_QUEUE_RX_AP: Locked> = + Locked::new(VecDeque::new()); -pub(crate) static DATA_QUEUE_RX_STA: Mutex>> = - Mutex::new(RefCell::new(VecDeque::new())); +pub(crate) static DATA_QUEUE_RX_STA: Locked> = + Locked::new(VecDeque::new()); /// Common errors. #[derive(Debug, Clone, Copy)] @@ -1529,14 +1528,13 @@ unsafe extern "C" fn recv_cb_sta( eb: *mut c_types::c_void, ) -> esp_err_t { let packet = EspWifiPacketBuffer { buffer, len, eb }; - // We must handle the result outside of the critical section because + // We must handle the result outside of the lock because // EspWifiPacketBuffer::drop must not be called in a critical section. // Dropping an EspWifiPacketBuffer will call `esp_wifi_internal_free_rx_buffer` // which will try to lock an internal mutex. If the mutex is already taken, // the function will try to trigger a context switch, which will fail if we - // are in a critical section. - if critical_section::with(|cs| { - let mut queue = DATA_QUEUE_RX_STA.borrow_ref_mut(cs); + // are in an interrupt-free context. + if DATA_QUEUE_RX_STA.with(|queue| { if queue.len() < RX_QUEUE_SIZE { queue.push_back(packet); true @@ -1563,9 +1561,8 @@ unsafe extern "C" fn recv_cb_ap( // Dropping an EspWifiPacketBuffer will call `esp_wifi_internal_free_rx_buffer` // which will try to lock an internal mutex. If the mutex is already taken, // the function will try to trigger a context switch, which will fail if we - // are in a critical section. - if critical_section::with(|cs| { - let mut queue = DATA_QUEUE_RX_AP.borrow_ref_mut(cs); + // are in an interrupt-free context. + if DATA_QUEUE_RX_AP.with(|queue| { if queue.len() < RX_QUEUE_SIZE { queue.push_back(packet); true @@ -1905,7 +1902,7 @@ mod sealed { fn wrap_config(config: Self::Config) -> Configuration; - fn data_queue_rx(self, cs: CriticalSection) -> RefMut<'_, VecDeque>; + fn data_queue_rx(self) -> &'static Locked>; fn can_send(self) -> bool { WIFI_TX_INFLIGHT.load(Ordering::SeqCst) < TX_QUEUE_SIZE @@ -1928,13 +1925,12 @@ mod sealed { } fn rx_token(self) -> Option<(WifiRxToken, WifiTxToken)> { - let is_empty = critical_section::with(|cs| self.data_queue_rx(cs).is_empty()); + let is_empty = self.data_queue_rx().with(|q| q.is_empty()); if is_empty || !self.can_send() { crate::timer::yield_task(); } - let is_empty = - is_empty && critical_section::with(|cs| self.data_queue_rx(cs).is_empty()); + let is_empty = is_empty && self.data_queue_rx().with(|q| q.is_empty()); if !is_empty { self.tx_token().map(|tx| (WifiRxToken { mode: self }, tx)) @@ -1967,8 +1963,8 @@ mod sealed { Configuration::Client(config) } - fn data_queue_rx(self, cs: CriticalSection) -> RefMut<'_, VecDeque> { - DATA_QUEUE_RX_STA.borrow_ref_mut(cs) + fn data_queue_rx(self) -> &'static Locked> { + &DATA_QUEUE_RX_STA } fn interface(self) -> wifi_interface_t { @@ -2003,8 +1999,8 @@ mod sealed { Configuration::AccessPoint(config) } - fn data_queue_rx(self, cs: CriticalSection) -> RefMut<'_, VecDeque> { - DATA_QUEUE_RX_AP.borrow_ref_mut(cs) + fn data_queue_rx(self) -> &'static Locked> { + &DATA_QUEUE_RX_AP } fn interface(self) -> wifi_interface_t { @@ -2321,7 +2317,7 @@ impl PromiscuousPkt<'_> { frame_type, len, data: core::slice::from_raw_parts( - (buf as *const u8).add(size_of::()), + (buf as *const u8).add(core::mem::size_of::()), len, ), } @@ -2329,18 +2325,14 @@ impl PromiscuousPkt<'_> { } #[cfg(feature = "sniffer")] -#[allow(clippy::type_complexity)] -static SNIFFER_CB: Mutex>> = Mutex::new(RefCell::new(None)); +static SNIFFER_CB: Locked> = Locked::new(None); #[cfg(feature = "sniffer")] unsafe extern "C" fn promiscuous_rx_cb(buf: *mut core::ffi::c_void, frame_type: u32) { - critical_section::with(|cs| { - let Some(sniffer_callback) = *SNIFFER_CB.borrow_ref(cs) else { - return; - }; + if let Some(sniffer_callback) = SNIFFER_CB.with(|callback| *callback) { let promiscuous_pkt = PromiscuousPkt::from_raw(buf as *const _, frame_type); sniffer_callback(promiscuous_pkt); - }); + } } #[cfg(feature = "sniffer")] @@ -2385,9 +2377,7 @@ impl Sniffer { } /// Set the callback for receiving a packet. pub fn set_receive_cb(&mut self, cb: fn(PromiscuousPkt)) { - critical_section::with(|cs| { - *SNIFFER_CB.borrow_ref_mut(cs) = Some(cb); - }); + SNIFFER_CB.with(|callback| *callback = Some(cb)); } } @@ -2675,21 +2665,19 @@ impl WifiRxToken { where F: FnOnce(&mut [u8]) -> R, { - let mut data = critical_section::with(|cs| { - let mut queue = self.mode.data_queue_rx(cs); - + let mut data = self.mode.data_queue_rx().with(|queue| { unwrap!( queue.pop_front(), "unreachable: transmit()/receive() ensures there is a packet to process" ) }); - // We handle the received data outside of the critical section because + // We handle the received data outside of the lock because // EspWifiPacketBuffer::drop must not be called in a critical section. // Dropping an EspWifiPacketBuffer will call `esp_wifi_internal_free_rx_buffer` // which will try to lock an internal mutex. If the mutex is already // taken, the function will try to trigger a context switch, which will - // fail if we are in a critical section. + // fail if we are in an interrupt-free context. let buffer = data.as_slice_mut(); dump_packet_info(buffer); @@ -3321,7 +3309,7 @@ mod asynch { } fn clear_events(events: impl Into>) { - critical_section::with(|cs| WIFI_EVENTS.borrow_ref_mut(cs).remove_all(events.into())); + WIFI_EVENTS.with(|evts| evts.get_mut().remove_all(events.into())); } /// Wait for one [`WifiEvent`]. @@ -3390,7 +3378,7 @@ mod asynch { cx: &mut core::task::Context<'_>, ) -> Poll { self.event.waker().register(cx.waker()); - if critical_section::with(|cs| WIFI_EVENTS.borrow_ref_mut(cs).remove(self.event)) { + if WIFI_EVENTS.with(|events| events.get_mut().remove(self.event)) { Poll::Ready(()) } else { Poll::Pending @@ -3417,8 +3405,8 @@ mod asynch { self: core::pin::Pin<&mut Self>, cx: &mut core::task::Context<'_>, ) -> Poll { - let output = critical_section::with(|cs| { - let mut events = WIFI_EVENTS.borrow_ref_mut(cs); + let output = WIFI_EVENTS.with(|events| { + let events = events.get_mut(); let active = events.intersection(self.event); events.remove_all(active); active diff --git a/esp-wifi/src/wifi/os_adapter.rs b/esp-wifi/src/wifi/os_adapter.rs index 1fe92992f..10e77a929 100644 --- a/esp-wifi/src/wifi/os_adapter.rs +++ b/esp-wifi/src/wifi/os_adapter.rs @@ -9,8 +9,8 @@ pub(crate) mod os_adapter_chip_specific; use core::{cell::RefCell, ptr::addr_of_mut}; -use critical_section::Mutex; use enumset::EnumSet; +use esp_hal::sync::{Lock, Locked}; use super::WifiEvent; use crate::{ @@ -35,12 +35,14 @@ use crate::{ timer::yield_task, }; +static WIFI_LOCK: Lock = Lock::new(); + static mut QUEUE_HANDLE: *mut ConcurrentQueue = core::ptr::null_mut(); // useful for waiting for events - clear and wait for the event bit to be set // again -pub(crate) static WIFI_EVENTS: Mutex>> = - Mutex::new(RefCell::new(enumset::enum_set!())); +pub(crate) static WIFI_EVENTS: Locked>> = + Locked::new(RefCell::new(enumset::enum_set!())); /// ************************************************************************** /// Name: wifi_env_is_chip @@ -214,10 +216,11 @@ pub unsafe extern "C" fn spin_lock_delete(lock: *mut crate::binary::c_types::c_v /// /// ************************************************************************* pub unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, + _wifi_int_mux: *mut crate::binary::c_types::c_void, ) -> u32 { trace!("wifi_int_disable"); - crate::wifi::os_adapter::os_adapter_chip_specific::wifi_int_disable(wifi_int_mux) + // TODO: can we use wifi_int_mux? + unsafe { WIFI_LOCK.acquire() as _ } } /// ************************************************************************** @@ -236,11 +239,12 @@ pub unsafe extern "C" fn wifi_int_disable( /// /// ************************************************************************* pub unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, + _wifi_int_mux: *mut crate::binary::c_types::c_void, tmp: u32, ) { trace!("wifi_int_restore"); - crate::wifi::os_adapter::os_adapter_chip_specific::wifi_int_restore(wifi_int_mux, tmp) + let token = tmp as critical_section::RawRestoreState; + unsafe { WIFI_LOCK.release(token) } } /// ************************************************************************** @@ -867,11 +871,8 @@ pub unsafe extern "C" fn event_post( let event = unwrap!(WifiEvent::from_i32(event_id)); trace!("EVENT: {:?}", event); - let mut handled = false; - critical_section::with(|cs| { - WIFI_EVENTS.borrow_ref_mut(cs).insert(event); - handled = super::event::dispatch_event_handler(cs, event, event_data, event_data_size); - }); + WIFI_EVENTS.with(|events| events.borrow_mut().insert(event)); + let handled = super::event::dispatch_event_handler(event, event_data, event_data_size); super::state::update_state(event, handled); diff --git a/esp-wifi/src/wifi/os_adapter_esp32.rs b/esp-wifi/src/wifi/os_adapter_esp32.rs index f91e0b515..6cd0fd5a1 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32.rs @@ -1,11 +1,5 @@ -#![allow(unused_variables)] -#![allow(dead_code)] -#![allow(non_snake_case)] - use crate::hal::{interrupt, peripherals}; -const DPORT_WIFI_CLK_WIFI_EN_M: u32 = 0x406; - pub(crate) fn chip_ints_on(mask: u32) { unsafe { crate::hal::xtensa_lx::interrupt::enable_mask(mask) }; } @@ -14,21 +8,6 @@ pub(crate) fn chip_ints_off(mask: u32) { crate::hal::xtensa_lx::interrupt::disable_mask(mask); } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - core::mem::transmute(critical_section::acquire()) -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - critical_section::release(core::mem::transmute::( - tmp, - )) -} - pub(crate) unsafe extern "C" fn phy_common_clock_disable() { crate::common_adapter::chip_specific::phy_disable_clock(); } @@ -50,24 +29,6 @@ pub(crate) unsafe extern "C" fn set_intr( intr_matrix_set(0, intr_source, intr_num); } -pub(crate) unsafe extern "C" fn wifi_clock_enable() { - let dport = &*crate::hal::peripherals::SYSTEM::ptr(); - dport.wifi_clk_en().modify(|r, w| { - let old = r.bits(); - let new_bits = old | DPORT_WIFI_CLK_WIFI_EN_M; - w.bits(new_bits) - }); -} - -pub(crate) unsafe extern "C" fn wifi_clock_disable() { - let dport = &*crate::hal::peripherals::SYSTEM::ptr(); - dport.wifi_clk_en().modify(|r, w| { - let old = r.bits(); - let new_bits = old & !DPORT_WIFI_CLK_WIFI_EN_M; - w.bits(new_bits) - }); -} - /// ************************************************************************** /// Name: esp_set_isr /// diff --git a/esp-wifi/src/wifi/os_adapter_esp32c2.rs b/esp-wifi/src/wifi/os_adapter_esp32c2.rs index ef95f0f59..6493e3457 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32c2.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32c2.rs @@ -1,8 +1,4 @@ -use crate::hal::{ - interrupt, - peripherals::{self, Interrupt}, - riscv, -}; +use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { unsafe { @@ -20,40 +16,6 @@ pub(crate) fn chip_ints_off(mask: u32) { } } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - let res = if riscv::register::mstatus::read().mie() { - 1 - } else { - 0 - }; - riscv::interrupt::disable(); - - trace!( - "wifi_int_disable wifi_int_mux {:?} - return {}", - wifi_int_mux, - res, - ); - - res -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - trace!( - "wifi_int_restore wifi_int_mux {:?} tmp {}", - wifi_int_mux, - tmp - ); - - if tmp == 1 { - riscv::interrupt::enable(); - } -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, _intr_source: u32, @@ -103,11 +65,11 @@ pub unsafe extern "C" fn set_isr( #[cfg(feature = "wifi")] { unwrap!(interrupt::enable( - Interrupt::WIFI_MAC, + peripherals::Interrupt::WIFI_MAC, interrupt::Priority::Priority1 )); unwrap!(interrupt::enable( - Interrupt::WIFI_PWR, + peripherals::Interrupt::WIFI_PWR, interrupt::Priority::Priority1 )); } diff --git a/esp-wifi/src/wifi/os_adapter_esp32c3.rs b/esp-wifi/src/wifi/os_adapter_esp32c3.rs index 3104284ca..39e73c2d6 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32c3.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32c3.rs @@ -1,8 +1,4 @@ -use crate::hal::{ - interrupt, - peripherals::{self, Interrupt}, - riscv, -}; +use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { unsafe { @@ -20,40 +16,6 @@ pub(crate) fn chip_ints_off(mask: u32) { } } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - let res = if riscv::register::mstatus::read().mie() { - 1 - } else { - 0 - }; - riscv::interrupt::disable(); - - trace!( - "wifi_int_disable wifi_int_mux {:?} - return {}", - wifi_int_mux, - res, - ); - - res -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - trace!( - "wifi_int_restore wifi_int_mux {:?} tmp {}", - wifi_int_mux, - tmp - ); - - if tmp == 1 { - riscv::interrupt::enable(); - } -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, _intr_source: u32, @@ -104,11 +66,11 @@ pub unsafe extern "C" fn set_isr( #[cfg(feature = "wifi")] { unwrap!(interrupt::enable( - Interrupt::WIFI_MAC, + peripherals::Interrupt::WIFI_MAC, interrupt::Priority::Priority1 )); unwrap!(interrupt::enable( - Interrupt::WIFI_PWR, + peripherals::Interrupt::WIFI_PWR, interrupt::Priority::Priority1 )); } diff --git a/esp-wifi/src/wifi/os_adapter_esp32c6.rs b/esp-wifi/src/wifi/os_adapter_esp32c6.rs index 767669452..77d8bbe9e 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32c6.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32c6.rs @@ -1,8 +1,4 @@ -use crate::hal::{ - interrupt, - peripherals::{self, Interrupt}, - riscv, -}; +use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { unsafe { @@ -20,40 +16,6 @@ pub(crate) fn chip_ints_off(mask: u32) { } } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - let res = if riscv::register::mstatus::read().mie() { - 1 - } else { - 0 - }; - riscv::interrupt::disable(); - - trace!( - "wifi_int_disable wifi_int_mux {:?} - return {}", - wifi_int_mux, - res, - ); - - res -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - trace!( - "wifi_int_restore wifi_int_mux {:?} tmp {}", - wifi_int_mux, - tmp - ); - - if tmp == 1 { - riscv::interrupt::enable(); - } -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, _intr_source: u32, @@ -117,11 +79,11 @@ pub unsafe extern "C" fn set_isr( #[cfg(feature = "wifi")] { unwrap!(interrupt::enable( - Interrupt::WIFI_MAC, + peripherals::Interrupt::WIFI_MAC, interrupt::Priority::Priority1 )); unwrap!(interrupt::enable( - Interrupt::WIFI_PWR, + peripherals::Interrupt::WIFI_PWR, interrupt::Priority::Priority1 )); } diff --git a/esp-wifi/src/wifi/os_adapter_esp32h2.rs b/esp-wifi/src/wifi/os_adapter_esp32h2.rs index 74048a325..fc05c13f8 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32h2.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32h2.rs @@ -1,8 +1,4 @@ -use crate::hal::{ - interrupt, - peripherals::{self, Interrupt}, - riscv, -}; +use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { unsafe { @@ -20,40 +16,6 @@ pub(crate) fn chip_ints_off(mask: u32) { } } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - let res = if riscv::register::mstatus::read().mie() { - 1 - } else { - 0 - }; - riscv::interrupt::disable(); - - trace!( - "wifi_int_disable wifi_int_mux {:?} - return {}", - wifi_int_mux, - res, - ); - - res -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - trace!( - "wifi_int_restore wifi_int_mux {:?} tmp {}", - wifi_int_mux, - tmp - ); - - if tmp == 1 { - riscv::interrupt::enable(); - } -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, _intr_source: u32, diff --git a/esp-wifi/src/wifi/os_adapter_esp32s2.rs b/esp-wifi/src/wifi/os_adapter_esp32s2.rs index 811e0a792..fa2ac9159 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32s2.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32s2.rs @@ -1,7 +1,3 @@ -#![allow(unused_variables)] -#![allow(dead_code)] -#![allow(non_snake_case)] - use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { @@ -12,21 +8,6 @@ pub(crate) fn chip_ints_off(mask: u32) { crate::hal::xtensa_lx::interrupt::disable_mask(mask); } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - core::mem::transmute(critical_section::acquire()) -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - critical_section::release(core::mem::transmute::( - tmp, - )) -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, intr_source: u32, diff --git a/esp-wifi/src/wifi/os_adapter_esp32s3.rs b/esp-wifi/src/wifi/os_adapter_esp32s3.rs index 51ce70299..94240b9b4 100644 --- a/esp-wifi/src/wifi/os_adapter_esp32s3.rs +++ b/esp-wifi/src/wifi/os_adapter_esp32s3.rs @@ -1,7 +1,3 @@ -#![allow(unused_variables)] -#![allow(dead_code)] -#![allow(non_snake_case)] - use crate::hal::{interrupt, peripherals}; pub(crate) fn chip_ints_on(mask: u32) { @@ -12,21 +8,6 @@ pub(crate) fn chip_ints_off(mask: u32) { crate::hal::xtensa_lx::interrupt::disable_mask(mask); } -pub(crate) unsafe extern "C" fn wifi_int_disable( - wifi_int_mux: *mut crate::binary::c_types::c_void, -) -> u32 { - core::mem::transmute(critical_section::acquire()) -} - -pub(crate) unsafe extern "C" fn wifi_int_restore( - wifi_int_mux: *mut crate::binary::c_types::c_void, - tmp: u32, -) { - critical_section::release(core::mem::transmute::( - tmp, - )) -} - pub(crate) unsafe extern "C" fn set_intr( _cpu_no: i32, intr_source: u32, diff --git a/examples/src/bin/wifi_access_point.rs b/examples/src/bin/wifi_access_point.rs index 249c3b323..235668705 100644 --- a/examples/src/bin/wifi_access_point.rs +++ b/examples/src/bin/wifi_access_point.rs @@ -52,15 +52,15 @@ fn main() -> ! { // Set event handlers for wifi before init to avoid missing any. let mut connections = 0u32; - _ = event::ApStart::replace_handler(|_, _| esp_println::println!("ap start event")); - event::ApStaconnected::update_handler(move |_, event| { + _ = event::ApStart::replace_handler(|_| esp_println::println!("ap start event")); + event::ApStaconnected::update_handler(move |event| { connections += 1; esp_println::println!("connected {}, mac: {:?}", connections, event.0.mac); }); - event::ApStaconnected::update_handler(|_, event| { + event::ApStaconnected::update_handler(|event| { esp_println::println!("connected aid: {}", event.0.aid); }); - event::ApStadisconnected::update_handler(|_, event| { + event::ApStadisconnected::update_handler(|event| { esp_println::println!( "disconnected mac: {:?}, reason: {:?}", event.0.mac, diff --git a/examples/src/bin/wifi_embassy_access_point.rs b/examples/src/bin/wifi_embassy_access_point.rs index 21704a3f3..3ceca80c8 100644 --- a/examples/src/bin/wifi_embassy_access_point.rs +++ b/examples/src/bin/wifi_embassy_access_point.rs @@ -9,7 +9,7 @@ //! Because of the huge task-arena size configured this won't work on ESP32-S2 //! -//% FEATURES: embassy embassy-generic-timers esp-wifi esp-wifi/wifi esp-wifi/utils +//% FEATURES: embassy embassy-generic-timers esp-wifi esp-wifi/wifi esp-wifi/utils esp-wifi/sniffer //% CHIPS: esp32 esp32s2 esp32s3 esp32c2 esp32c3 esp32c6 #![no_std]