Separate esp-radio support code (#4175)

Author: bugadani

esp-preempt/Cargo.toml

@@ -15,6 +15,7 @@ doc-config = { features = ["esp-hal/unstable"] }
 check-configs = [
     { features = ["esp-hal/unstable"] },
     { features = ["esp-hal/unstable", "esp-alloc"] },
+    { features = ["esp-hal/unstable", "esp-radio"] },
 ]
 clippy-configs = [
     { features = ["esp-hal/unstable", "esp-alloc", "defmt"] },
@@ -40,7 +41,7 @@ document-features  = "0.2.11"
 esp-alloc = { version = "0.8.0", path = "../esp-alloc", optional = true }
 esp-config = { version = "0.5.0", path = "../esp-config" }
 esp-sync = { version = "0.0.0", path = "../esp-sync" }
-esp-radio-preempt-driver = { version = "0.0.1", path = "../esp-radio-preempt-driver" }
+esp-radio-preempt-driver = { version = "0.0.1", path = "../esp-radio-preempt-driver", optional = true }
 portable-atomic = { version = "1.11.0", default-features = false }
 
 # Logging interfaces, they are mutually exclusive so they need to be behind separate features.
@@ -55,7 +56,7 @@ esp-metadata-generated = { version = "0.1.0", path = "../esp-metadata-generated"
 esp-hal = { version = "1.0.0-rc.0", path = "../esp-hal", features = ["unstable"] }
 
 [features]
-default = ["esp-alloc"]
+default = ["esp-alloc", "esp-radio"]
 
 ## Enable the use of the `esp-alloc` crate for dynamic memory allocation.
 ##
@@ -64,6 +65,9 @@ default = ["esp-alloc"]
 ## - `pub extern "C" fn free_internal(ptr: *mut u8)`
 esp-alloc = ["dep:esp-alloc"]
 
+## Enables esp-radio support.
+esp-radio = ["dep:esp-radio-preempt-driver"]
+
 #! ### Chip selection
 #! One of the following features must be enabled to select the target chip:
 

esp-preempt/src/esp_radio/mod.rs

@@ -0,0 +1,171 @@
+//! esp-radio support
+
+use core::{ffi::c_void, ptr::NonNull};
+
+use allocator_api2::boxed::Box;
+use esp_hal::{
+    system::Cpu,
+    time::{Duration, Instant},
+};
+use esp_radio_preempt_driver::{
+    register_semaphore_implementation,
+    semaphore::{SemaphoreImplementation, SemaphoreKind, SemaphorePtr},
+};
+
+use crate::{
+    SCHEDULER,
+    run_queue::MaxPriority,
+    scheduler::Scheduler,
+    semaphore::Semaphore,
+    task::{self, Task},
+};
+
+mod queue;
+mod timer_queue;
+
+impl esp_radio_preempt_driver::Scheduler for Scheduler {
+    fn initialized(&self) -> bool {
+        self.with(|scheduler| {
+            if scheduler.time_driver.is_none() {
+                warn!("Trying to initialize esp-radio before starting esp-preempt");
+                return false;
+            }
+
+            let current_cpu = Cpu::current() as usize;
+            if !scheduler.per_cpu[current_cpu].initialized {
+                warn!(
+                    "Trying to initialize esp-radio on {:?} but esp-preempt is not running on this core",
+                    current_cpu
+                );
+                return false;
+            }
+
+            true
+        })
+    }
+
+    fn yield_task(&self) {
+        task::yield_task();
+    }
+
+    fn yield_task_from_isr(&self) {
+        task::yield_task();
+    }
+
+    fn max_task_priority(&self) -> u32 {
+        MaxPriority::MAX_PRIORITY as u32
+    }
+
+    fn task_create(
+        &self,
+        name: &str,
+        task: extern "C" fn(*mut c_void),
+        param: *mut c_void,
+        priority: u32,
+        pin_to_core: Option<u32>,
+        task_stack_size: usize,
+    ) -> *mut c_void {
+        self.create_task(
+            name,
+            task,
+            param,
+            task_stack_size,
+            priority.min(self.max_task_priority()),
+            pin_to_core.and_then(|core| match core {
+                0 => Some(Cpu::ProCpu),
+                #[cfg(multi_core)]
+                1 => Some(Cpu::AppCpu),
+                _ => {
+                    warn!("Invalid core number: {}", core);
+                    None
+                }
+            }),
+        )
+        .as_ptr()
+        .cast()
+    }
+
+    fn current_task(&self) -> *mut c_void {
+        self.current_task().as_ptr().cast()
+    }
+
+    fn schedule_task_deletion(&self, task_handle: *mut c_void) {
+        task::schedule_task_deletion(task_handle as *mut Task)
+    }
+
+    fn current_task_thread_semaphore(&self) -> SemaphorePtr {
+        task::with_current_task(|task| {
+            NonNull::from(
+                task.thread_semaphore
+                    .get_or_insert_with(|| Semaphore::new_counting(0, 1)),
+            )
+            .cast()
+        })
+    }
+
+    fn usleep(&self, us: u32) {
+        SCHEDULER.sleep_until(Instant::now() + Duration::from_micros(us as u64));
+    }
+
+    fn now(&self) -> u64 {
+        // We're using a SingleShotTimer as the time driver, which lets us use the system timer's
+        // timestamps.
+        Instant::now().duration_since_epoch().as_micros()
+    }
+}
+
+impl Semaphore {
+    unsafe fn from_ptr<'a>(ptr: SemaphorePtr) -> &'a Self {
+        unsafe { ptr.cast::<Self>().as_ref() }
+    }
+}
+
+impl SemaphoreImplementation for Semaphore {
+    fn create(kind: SemaphoreKind) -> SemaphorePtr {
+        let sem = Box::new(match kind {
+            SemaphoreKind::Counting { max, initial } => Semaphore::new_counting(initial, max),
+            SemaphoreKind::Mutex => Semaphore::new_mutex(false),
+            SemaphoreKind::RecursiveMutex => Semaphore::new_mutex(true),
+        });
+        NonNull::from(Box::leak(sem)).cast()
+    }
+
+    unsafe fn delete(semaphore: SemaphorePtr) {
+        let sem = unsafe { Box::from_raw(semaphore.cast::<Semaphore>().as_ptr()) };
+        core::mem::drop(sem);
+    }
+
+    unsafe fn take(semaphore: SemaphorePtr, timeout_us: Option<u32>) -> bool {
+        let semaphore = unsafe { Semaphore::from_ptr(semaphore) };
+
+        semaphore.take(timeout_us)
+    }
+
+    unsafe fn give(semaphore: SemaphorePtr) -> bool {
+        let semaphore = unsafe { Semaphore::from_ptr(semaphore) };
+
+        semaphore.give()
+    }
+
+    unsafe fn current_count(semaphore: SemaphorePtr) -> u32 {
+        let semaphore = unsafe { Semaphore::from_ptr(semaphore) };
+
+        semaphore.current_count()
+    }
+
+    unsafe fn try_take(semaphore: SemaphorePtr) -> bool {
+        let semaphore = unsafe { Semaphore::from_ptr(semaphore) };
+
+        semaphore.try_take()
+    }
+
+    unsafe fn try_give_from_isr(semaphore: SemaphorePtr, _hptw: Option<&mut bool>) -> bool {
+        unsafe { <Self as SemaphoreImplementation>::give(semaphore) }
+    }
+
+    unsafe fn try_take_from_isr(semaphore: SemaphorePtr, _hptw: Option<&mut bool>) -> bool {
+        unsafe { <Self as SemaphoreImplementation>::try_take(semaphore) }
+    }
+}
+
+register_semaphore_implementation!(Semaphore);

esp-preempt/src/queue.rs renamed to esp-preempt/src/esp_radio/queue.rs

@@ -61,13 +61,13 @@ extern crate alloc;
 // MUST be the first module
 mod fmt;
 
-mod queue;
+#[cfg(feature = "esp-radio")]
+mod esp_radio;
 mod run_queue;
 mod scheduler;
-mod semaphore;
+pub mod semaphore;
 mod task;
 mod timer;
-mod timer_queue;
 mod wait_queue;
 
 use core::mem::MaybeUninit;
@@ -87,6 +87,7 @@ use esp_hal::{
     time::{Duration, Instant},
 };
 pub(crate) use scheduler::SCHEDULER;
+pub use task::CurrentThreadHandle;
 
 use crate::timer::TimeDriver;