Merge time-driver and time-queue-driver traits, make HALs own and handle the queue.

2 files changed, 17 insertions, 135 deletions

diff --git a/embassy-time-queue-driver/src/lib.rs b/embassy-time-queue-driver/src/lib.rs
index 2d5fd449a..ed490a0ef 100644
--- a/embassy-time-queue-driver/src/lib.rs
+++ b/embassy-time-queue-driver/src/lib.rs
@@ -49,23 +49,18 @@
 //! embassy_time_queue_driver::timer_queue_impl!(static QUEUE: MyTimerQueue = MyTimerQueue{});
 //! ```
 
+use core::task::Waker;
+
 #[cfg(not(feature = "integrated-timers"))]
 pub mod queue_generic;
 #[cfg(feature = "integrated-timers")]
 pub mod queue_integrated;
 
-use core::cell::RefCell;
-use core::task::Waker;
-
-use critical_section::Mutex;
+#[cfg(feature = "integrated-timers")]
+pub use queue_integrated::Queue;
 
-/// Timer queue
-pub trait TimerQueue {
-    /// Schedules a waker in the queue to be awoken at moment `at`.
-    ///
-    /// If this moment is in the past, the waker might be awoken immediately.
-    fn schedule_wake(&'static self, at: u64, waker: &Waker);
-}
+#[cfg(not(feature = "integrated-timers"))]
+pub use queue_generic::Queue;
 
 extern "Rust" {
     fn _embassy_time_schedule_wake(at: u64, waker: &Waker);
@@ -73,7 +68,10 @@ extern "Rust" {
 
 /// Schedule the given waker to be woken at `at`.
 pub fn schedule_wake(at: u64, waker: &Waker) {
-    #[cfg(feature = "integrated-timers")]
+    // This function is not implemented in embassy-time-driver because it needs access to executor
+    // internals. The function updates task state, then delegates to the implementation provided
+    // by the time driver.
+    #[cfg(not(feature = "_generic-queue"))]
     {
         use embassy_executor::raw::task_from_waker;
         use embassy_executor::raw::timer_queue::TimerEnqueueOperation;
@@ -89,121 +87,3 @@ pub fn schedule_wake(at: u64, waker: &Waker) {
     }
     unsafe { _embassy_time_schedule_wake(at, waker) }
 }
-
-/// Set the TimerQueue implementation.
-///
-/// See the module documentation for an example.
-#[macro_export]
-macro_rules! timer_queue_impl {
-    (static $name:ident: $t: ty = $val:expr) => {
-        static $name: $t = $val;
-
-        #[no_mangle]
-        fn _embassy_time_schedule_wake(at: u64, waker: &core::task::Waker) {
-            <$t as $crate::TimerQueue>::schedule_wake(&$name, at, waker);
-        }
-    };
-}
-
-#[cfg(feature = "integrated-timers")]
-type InnerQueue = queue_integrated::TimerQueue;
-
-#[cfg(not(feature = "integrated-timers"))]
-type InnerQueue = queue_generic::Queue;
-
-/// A timer queue implementation that can be used as a global timer queue.
-///
-/// This implementation is not thread-safe, and should be protected by a mutex of some sort.
-pub struct GenericTimerQueue<F: Fn(u64) -> bool> {
-    queue: InnerQueue,
-    set_alarm: F,
-}
-
-impl<F: Fn(u64) -> bool> GenericTimerQueue<F> {
-    /// Creates a new timer queue.
-    ///
-    /// `set_alarm` is a function that should set the next alarm time. The function should
-    /// return `true` if the alarm was set, and `false` if the alarm was in the past.
-    pub const fn new(set_alarm: F) -> Self {
-        Self {
-            queue: InnerQueue::new(),
-            set_alarm,
-        }
-    }
-
-    /// Schedules a task to run at a specific time, and returns whether any changes were made.
-    pub fn schedule_wake(&mut self, at: u64, waker: &core::task::Waker) {
-        #[cfg(feature = "integrated-timers")]
-        let waker = embassy_executor::raw::task_from_waker(waker);
-
-        if self.queue.schedule_wake(at, waker) {
-            self.dispatch()
-        }
-    }
-
-    /// Dequeues expired timers and returns the next alarm time.
-    pub fn next_expiration(&mut self, now: u64) -> u64 {
-        self.queue.next_expiration(now)
-    }
-
-    /// Handle the alarm.
-    ///
-    /// Call this function when the next alarm is due.
-    pub fn dispatch(&mut self) {
-        let mut next_expiration = self.next_expiration(embassy_time_driver::now());
-
-        while !(self.set_alarm)(next_expiration) {
-            // next_expiration is in the past, dequeue and find a new expiration
-            next_expiration = self.next_expiration(next_expiration);
-        }
-    }
-}
-
-/// A [`GenericTimerQueue`] protected by a critical section. Directly useable as a [`TimerQueue`].
-pub struct GlobalTimerQueue {
-    inner: Mutex<RefCell<GenericTimerQueue<fn(u64) -> bool>>>,
-}
-
-impl GlobalTimerQueue {
-    /// Creates a new timer queue.
-    ///
-    /// `set_alarm` is a function that should set the next alarm time. The function should
-    /// return `true` if the alarm was set, and `false` if the alarm was in the past.
-    pub const fn new(set_alarm: fn(u64) -> bool) -> Self {
-        Self {
-            inner: Mutex::new(RefCell::new(GenericTimerQueue::new(set_alarm))),
-        }
-    }
-
-    /// Schedules a task to run at a specific time, and returns whether any changes were made.
-    pub fn schedule_wake(&self, at: u64, waker: &core::task::Waker) {
-        critical_section::with(|cs| {
-            let mut inner = self.inner.borrow_ref_mut(cs);
-            inner.schedule_wake(at, waker);
-        });
-    }
-
-    /// Dequeues expired timers and returns the next alarm time.
-    pub fn next_expiration(&self, now: u64) -> u64 {
-        critical_section::with(|cs| {
-            let mut inner = self.inner.borrow_ref_mut(cs);
-            inner.next_expiration(now)
-        })
-    }
-
-    /// Handle the alarm.
-    ///
-    /// Call this function when the next alarm is due.
-    pub fn dispatch(&self) {
-        critical_section::with(|cs| {
-            let mut inner = self.inner.borrow_ref_mut(cs);
-            inner.dispatch()
-        })
-    }
-}
-
-impl TimerQueue for GlobalTimerQueue {
-    fn schedule_wake(&'static self, at: u64, waker: &Waker) {
-        GlobalTimerQueue::schedule_wake(self, at, waker)
-    }
-}
diff --git a/embassy-time-queue-driver/src/queue_integrated.rs b/embassy-time-queue-driver/src/queue_integrated.rs
index b905c00c3..6bb4c0c1a 100644
--- a/embassy-time-queue-driver/src/queue_integrated.rs
+++ b/embassy-time-queue-driver/src/queue_integrated.rs
@@ -1,15 +1,16 @@
 //! Timer queue operations.
 use core::cell::Cell;
 use core::cmp::min;
+use core::task::Waker;
 
 use embassy_executor::raw::TaskRef;
 
 /// A timer queue, with items integrated into tasks.
-pub struct TimerQueue {
+pub struct Queue {
     head: Cell<Option<TaskRef>>,
 }
 
-impl TimerQueue {
+impl Queue {
     /// Creates a new timer queue.
     pub const fn new() -> Self {
         Self { head: Cell::new(None) }
@@ -19,11 +20,12 @@ impl TimerQueue {
     ///
     /// If this function returns `true`, the called should find the next expiration time and set
     /// a new alarm for that time.
-    pub fn schedule_wake(&mut self, at: u64, p: TaskRef) -> bool {
-        let item = p.timer_queue_item();
+    pub fn schedule_wake(&mut self, at: u64, waker: &Waker) -> bool {
+        let task = embassy_executor::raw::task_from_waker(waker);
+        let item = task.timer_queue_item();
         if item.next.get().is_none() {
             // If not in the queue, add it and update.
-            let prev = self.head.replace(Some(p));
+            let prev = self.head.replace(Some(task));
             item.next.set(if prev.is_none() {
                 Some(unsafe { TaskRef::dangling() })
             } else {