Remove ConcurrentQueue & other minor tweaks (#4058)

* Remove ConcurrentQueue

* Unrequire preempt driver for 802.15.4

Author: bugadani

esp-preempt/src/queue.rs

@@ -68,6 +68,31 @@ impl QueueInner {
         true
     }
 
+    unsafe fn remove(&mut self, item: *const u8) {
+        // do what the ESP-IDF implementations does...
+        // just remove all elements and add them back except the one we need to remove -
+        // good enough for now
+        let count = self.len();
+
+        if count == 0 {
+            return;
+        }
+
+        let mut tmp_item = vec![0; self.item_size];
+
+        let item_slice = unsafe { core::slice::from_raw_parts(item, self.item_size) };
+        for _ in 0..count {
+            if !unsafe { self.try_dequeue(tmp_item.as_mut_ptr().cast()) } {
+                break;
+            }
+            if &tmp_item[..] != item_slice {
+                _ = unsafe { self.try_enqueue(tmp_item.as_mut_ptr().cast()) };
+            }
+            // Note that even if we find our item, we'll need to keep cycling through everything to
+            // keep insertion order.
+        }
+    }
+
     fn len(&self) -> usize {
         if self.current_write >= self.current_read {
             self.current_write - self.current_read
@@ -132,6 +157,10 @@ impl Queue {
         self.inner.with(|queue| unsafe { queue.try_dequeue(item) })
     }
 
+    unsafe fn remove(&self, item: *const u8) {
+        self.inner.with(|queue| unsafe { queue.remove(item) })
+    }
+
     fn messages_waiting(&self) -> usize {
         self.inner.with(|queue| queue.len())
     }
@@ -176,6 +205,12 @@ impl QueueImplementation for Queue {
         unsafe { queue.try_receive(item) }
     }
 
+    unsafe fn remove(queue: QueuePtr, item: *const u8) {
+        let queue = unsafe { Queue::from_ptr(queue) };
+
+        unsafe { queue.remove(item) }
+    }
+
     fn messages_waiting(queue: QueuePtr) -> usize {
         let queue = unsafe { Queue::from_ptr(queue) };
 

esp-radio-preempt-driver/src/queue.rs

@@ -22,6 +22,7 @@ unsafe extern "Rust" {
     fn esp_preempt_queue_try_send_to_back(queue: QueuePtr, item: *const u8) -> bool;
     fn esp_preempt_queue_receive(queue: QueuePtr, item: *mut u8, timeout_us: Option<u32>) -> bool;
     fn esp_preempt_queue_try_receive(queue: QueuePtr, item: *mut u8) -> bool;
+    fn esp_preempt_queue_remove(queue: QueuePtr, item: *const u8);
     fn esp_preempt_queue_messages_waiting(queue: QueuePtr) -> usize;
 }
 
@@ -97,6 +98,14 @@ pub trait QueueImplementation {
     /// a size equal to the queue's item size.
     unsafe fn try_receive(queue: QueuePtr, item: *mut u8) -> bool;
 
+    /// Removes an item from the queue.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `item` can be dereferenced and points to an allocation of
+    /// a size equal to the queue's item size.
+    unsafe fn remove(queue: QueuePtr, item: *const u8);
+
     /// Returns the number of messages in the queue.
     fn messages_waiting(queue: QueuePtr) -> usize;
 }
@@ -162,6 +171,12 @@ macro_rules! register_queue_implementation {
             unsafe { <$t as $crate::queue::QueueImplementation>::try_receive(queue, item) }
         }
 
+        #[unsafe(no_mangle)]
+        #[inline]
+        fn esp_preempt_queue_remove(queue: QueuePtr, item: *mut u8) {
+            unsafe { <$t as $crate::queue::QueueImplementation>::remove(queue, item) }
+        }
+
         #[unsafe(no_mangle)]
         #[inline]
         fn esp_preempt_queue_messages_waiting(queue: QueuePtr) -> usize {
@@ -278,6 +293,16 @@ impl QueueHandle {
         unsafe { esp_preempt_queue_try_receive(self.0, item) }
     }
 
+    /// Removes an item from the queue.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `item` can be dereferenced and points to an allocation of
+    /// a size equal to the queue's item size.
+    pub unsafe fn remove(&self, item: *const u8) {
+        unsafe { esp_preempt_queue_remove(self.0, item) }
+    }
+
     /// Returns the number of messages in the queue.
     pub fn messages_waiting(&self) -> usize {
         unsafe { esp_preempt_queue_messages_waiting(self.0) }