Reimplement IPCs using WaitQueue (#4559)

* Use driver API for thread semaphore

* Update scheduler related naming

* Add ThreadPtr

* Hide CompatQueue behind feature, remove impl from esp-rtos

* Replace CompatQueue's mutex with esp-sync

* Deduplicate/fix queue operations

* Also hide CompatTimer

* Re-add logging to CompatTimer

* Create timer thread when initializing the queue

* Pull set_priority up into the scheduler

* Replace Mutex in CompatTimer with esp-sync

* Add WaitQueue, move radio Semaphore impl

* Remove esp_rtos semaphore

* Fix up changelog

* Assert that there are no tasks waiting when queue is dropped

* Update NPL glue code

* Fix clippy

* Remove redundant pointer write

* Hide WaitQueue behind esp-radio feature for now

Author: bugadani

esp-radio-rtos-driver/CHANGELOG.md

@@ -13,12 +13,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `SemaphoreHandle::take_with_deadline` to take a semaphore with a deadline. (#4555)
 - `QueueHandle::{send_to_front_with_deadline, send_to_back_with_deadline, receive_with_deadline}` for queue operations with a deadline. (#4555)
 - `timer::CompatTimer` to simplify OS integration. (#4555)
+- `semaphore::CompatSemaphore` to simplify OS integration. (#4559)
+- `wait_queue::WaitQueueImplementation` as an alternative way to integrate with an OS. (#4559)
+- `ThreadPtr` (#4559)
+- The `ipc-implementations` feature, which enables the `CompatQueue`, `CompatSemaphore` and `CompatTimer` types (#4559)
+- Chip-specific features required for the `ipc-implementations` feature (#4559)
 
 ### Changed
 
+- Renamed `Scheduler` to `SchedulerImplementation` and `scheduler_impl!` to `register_scheduler_implementation!` (#4559)
+- `current_task`, `task_create` and `schedule_task_deletion` functions now work with `ThreadPtr` instead of `*mut c_void` (#4559)
+- `schedule_task_deletion` now takes an `Option` (#4559)
 
 ### Fixed
 
+- `register_queue_implementation` no longer requires `QueuePtr` to be in scope (#4559)
 
 ### Removed
 

esp-radio-rtos-driver/Cargo.toml

@@ -21,3 +21,26 @@ portable-atomic = "1"
 
 [target."cfg(not(target_has_atomic = \"32\"))".dependencies]
 portable-atomic = { version = "1", features = ["unsafe-assume-single-core"] }
+
+[dependencies]
+esp-sync = { version = "0.1.1", path = "../esp-sync", optional = true }
+cfg-if = "1"
+
+# Logging interfaces, they are mutually exclusive so they need to be behind separate features.
+defmt  = { version = "1.0", optional = true }
+log-04 = { package = "log", version = "0.4", optional = true }
+
+[features]
+ipc-implementations = ["esp-sync"]
+# One of the following features must be enabled to select the target chip, if the `ipc-implementations` feature is enabled.
+esp32 = ["esp-sync?/esp32"]
+esp32c2 = ["esp-sync?/esp32c2"]
+esp32c3 = ["esp-sync?/esp32c3"]
+esp32c6 = ["esp-sync?/esp32c6"]
+esp32h2 = ["esp-sync?/esp32h2"]
+esp32s2 = ["esp-sync?/esp32s2"]
+esp32s3 = ["esp-sync?/esp32s3"]
+
+# Logging Feature Flags
+log-04 = ["dep:log-04"]
+defmt = ["dep:defmt"]

esp-radio-rtos-driver/src/fmt.rs

@@ -0,0 +1,332 @@
+#![macro_use]
+#![allow(unused_macros)]
+
+use core::fmt::{Debug, Display, LowerHex};
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::assert!($($x)*);
+                } else {
+                    ::core::assert!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert_eq {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::assert_eq!($($x)*);
+                } else {
+                    ::core::assert_eq!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! assert_ne {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::assert_ne!($($x)*);
+                } else {
+                    ::core::assert_ne!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::debug_assert!($($x)*);
+                } else {
+                    ::core::debug_assert!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert_eq {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::debug_assert_eq!($($x)*);
+                } else {
+                    ::core::debug_assert_eq!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug_assert_ne {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::debug_assert_ne!($($x)*);
+                } else {
+                    ::core::debug_assert_ne!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! todo {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::todo!($($x)*);
+                } else {
+                    ::core::todo!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! unreachable {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::unreachable!($($x)*);
+                } else {
+                    ::core::unreachable!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! panic {
+    ($($x:tt)*) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::panic!($($x)*);
+                } else {
+                    ::core::panic!($($x)*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! trace {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::trace!($s $(, $x)*);
+                } else if #[cfg(feature = "log-04")] {
+                    ::log_04::trace!($s $(, $x)*);
+                } else {
+                    let _ = ($( & $x ),*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::debug!($s $(, $x)*);
+                } else if #[cfg(feature = "log-04")] {
+                    ::log_04::debug!($s $(, $x)*);
+                } else {
+                    let _ = ($( & $x ),*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! info {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::info!($s $(, $x)*);
+                } else if #[cfg(feature = "log-04")] {
+                    ::log_04::info!($s $(, $x)*);
+                } else {
+                    let _ = ($( & $x ),*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! warn {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::warn!($s $(, $x)*);
+                } else if #[cfg(feature = "log-04")] {
+                    ::log_04::warn!($s $(, $x)*);
+                } else {
+                    let _ = ($( & $x ),*);
+                }
+            }
+        }
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! error {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        {
+            cfg_if::cfg_if! {
+                if #[cfg(feature = "defmt")] {
+                    ::defmt::error!($s $(, $x)*);
+                } else if #[cfg(feature = "log-04")] {
+                    ::log_04::error!($s $(, $x)*);
+                } else {
+                    let _ = ($( & $x ),*);
+                }
+            }
+        }
+    };
+}
+
+#[cfg(feature = "defmt")]
+#[collapse_debuginfo(yes)]
+macro_rules! unwrap {
+    ($($x:tt)*) => {
+        ::defmt::unwrap!($($x)*)
+    };
+}
+
+#[cold]
+#[inline(never)]
+#[cfg(not(feature = "defmt"))]
+pub(crate) fn __unwrap_failed(arg: &str, e: impl ::core::fmt::Debug) -> ! {
+    ::core::panic!("unwrap of `{}` failed: {:?}", arg, e);
+}
+
+#[cold]
+#[inline(never)]
+#[cfg(not(feature = "defmt"))]
+pub(crate) fn __unwrap_failed_with_message(
+    arg: &str,
+    e: impl core::fmt::Debug,
+    msg: impl core::fmt::Display,
+) -> ! {
+    ::core::panic!("unwrap of `{}` failed: {}: {:?}", arg, msg, e);
+}
+
+#[cfg(not(feature = "defmt"))]
+#[collapse_debuginfo(yes)]
+macro_rules! unwrap {
+    ($arg:expr) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => { $crate::fmt::__unwrap_failed(::core::stringify!($arg), e) }
+        }
+    };
+    ($arg:expr, $msg:expr) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => { $crate::fmt::__unwrap_failed_with_message(::core::stringify!($arg), e, $msg) }
+        }
+    };
+    ($arg:expr, $($msg:expr),+ $(,)? ) => {
+        match $crate::fmt::Try::into_result($arg) {
+            ::core::result::Result::Ok(t) => t,
+            ::core::result::Result::Err(e) => { $crate::fmt::__unwrap_failed_with_message(::core::stringify!($arg), e, ::core::format_args!($($msg,)*)) }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct NoneError;
+
+pub trait Try {
+    type Ok;
+    type Error;
+    #[allow(unused)]
+    fn into_result(self) -> Result<Self::Ok, Self::Error>;
+}
+
+impl<T> Try for Option<T> {
+    type Ok = T;
+    type Error = NoneError;
+
+    #[inline]
+    fn into_result(self) -> Result<T, NoneError> {
+        self.ok_or(NoneError)
+    }
+}
+
+impl<T, E> Try for Result<T, E> {
+    type Ok = T;
+    type Error = E;
+
+    #[inline]
+    fn into_result(self) -> Self {
+        self
+    }
+}
+
+/// A way to `{:x?}` format a byte slice which is compatible with `defmt`
+#[allow(unused)]
+pub(crate) struct Bytes<'a>(pub &'a [u8]);
+
+impl Debug for Bytes<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl Display for Bytes<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+impl LowerHex for Bytes<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{:#02x?}", self.0)
+    }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Bytes<'_> {
+    fn format(&self, fmt: defmt::Formatter<'_>) {
+        defmt::write!(fmt, "{:02x}", self.0)
+    }
+}