abstracted async-cortex-m over specifics of WFE/SEV across ISAs. Added several RISC-V implementations of WFE/SEV, as RISC-V leaves implementation of these to SoC designers.

Author: ilya-epifanov

Cargo.lock

@@ -7,9 +7,18 @@ publish = false
 version = "0.0.0-alpha.0"
 
 [dependencies]
-cortex-m = "0.6.2"
-cortex-m-udf = { path = "../cortex-m-udf" }
+cortex-m = { version = "0.6.2", optional = true }
+cortex-m-udf = { path = "../cortex-m-udf", optional = true }
 generic-array = "0.13.2"
 heapless = { git = "https://github.com/japaric/heapless", branch = "slab" }
 pin-utils = "0.1.0-alpha.4"
+riscv = { version = "0.5.6", optional = true }
 typenum = "1.11.2"
+
+[features]
+default = ["riscv-wait-nop"]
+isa-cortex-m = ["cortex-m", "cortex-m-udf"]
+isa-riscv = ["riscv"]
+riscv-wait-nop = []
+riscv-wait-wfi-single-hart = []
+wait-extern = []

async-cortex-m/Cargo.toml

@@ -7,7 +7,6 @@ use core::{
     task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
 };
 
-use cortex_m::asm;
 use heapless::Vec;
 use pin_utils::pin_mut;
 
@@ -120,7 +119,7 @@ impl Executor {
 
             // try to sleep; this will be a no-op if any of the previous tasks generated a SEV or an
             // interrupt ran (regardless of whether it generated a wake-up or not)
-            asm::wfe();
+            unsafe { crate::wait_for_event() };
         };
         self.in_block_on.set(false);
         val

async-cortex-m/src/executor.rs

@@ -10,7 +10,92 @@ mod executor;
 pub mod task;
 pub mod unsync;
 
-use cortex_m_udf::udf as abort;
+#[cfg(feature = "isa-cortex-m")]
+use cortex_m::asm;
+
+#[cfg(feature = "isa-cortex-m")]
+pub use cortex_m_udf::udf as abort;
+
+#[cfg(all(feature = "isa-cortex-m"))]
+#[inline]
+/// Prevent next `wait_for_interrupt` from sleeping, wake up other harts if needed.
+/// This particular implementation does nothing, since `wait_for_interrupt` never sleeps
+pub(crate) unsafe fn signal_event_ready() {
+    asm::sev();
+}
+
+#[cfg(all(feature = "isa-cortex-m"))]
+#[inline]
+/// Wait for an interrupt or until notified by other hart via `signal_task_ready`
+/// This particular implementation does nothing
+pub(crate) unsafe fn wait_for_event() {
+    asm::wfe();
+}
+
+#[cfg(feature = "isa-riscv")]
+/// This keeps dropping into the debugger and never returns
+pub fn abort() -> ! {
+    loop {
+        unsafe { riscv::asm::ebreak() }
+    }
+}
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-nop"))]
+#[inline]
+/// Prevent next `wait_for_interrupt` from sleeping, wake up other harts if needed.
+/// This particular implementation does nothing, since `wait_for_interrupt` never sleeps
+pub(crate) unsafe fn signal_event_ready() {}
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-nop"))]
+#[inline]
+/// Wait for an interrupt or until notified by other hart via `signal_task_ready`
+/// This particular implementation does nothing
+pub(crate) unsafe fn wait_for_event() {}
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-extern"))]
+extern "C" {
+    /// Prevent next `wait_for_interrupt` from sleeping, wake up other harts if needed.
+    /// User is expected to provide an actual implementation, like the one shown below.
+    ///
+    /// #[no_mangle]
+    /// pub extern "C" fn signal_event_ready() {
+    ///     unimplemented!();
+    /// }
+    pub(crate) fn signal_event_ready();
+
+    /// Wait for an interrupt or until notified by other hart via `signal_task_ready`
+    /// User is expected to provide an actual implementation, like the one shown below.
+    ///
+    /// #[no_mangle]
+    /// pub extern "C" fn wait_for_event() {
+    ///     unimplemented!();
+    /// }
+    pub(crate) fn wait_for_event();
+}
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-wfi-single-hart"))]
+static mut TASK_READY: bool = false;
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-wfi-single-hart"))]
+#[inline]
+/// Prevent next `wait_for_interrupt` from sleeping, wake up other harts if needed.
+/// This particular implementation prevents `wait_for_interrupt` from sleeping by setting
+/// a global mutable flag
+pub(crate) unsafe fn signal_event_ready() {
+    TASK_READY = true;
+}
+
+#[cfg(all(feature = "isa-riscv", feature = "riscv-wait-wfi-single-hart"))]
+#[inline]
+/// Wait for an interrupt or until notified by other hart via `signal_task_ready`
+/// This particular implementation decides whether to sleep or not by checking
+/// a global mutable flag that's set by `signal_task_ready`
+pub(crate) unsafe fn wait_for_event() {
+    if !TASK_READY {
+        riscv::asm::wfi();
+        TASK_READY = false;
+    }
+}
 
 /// Maximum number of tasks (TODO this could be user configurable)
 type NTASKS = typenum::consts::U8;

async-cortex-m/src/lib.rs

@@ -6,8 +6,6 @@ use core::{
     task::{Context, Poll},
 };
 
-use cortex_m::asm;
-
 use crate::executor;
 
 /// Drives the future `f` to completion
@@ -43,7 +41,7 @@ pub async fn r#yield() {
                 self.yielded = true;
                 // wake ourselves
                 cx.waker().wake_by_ref();
-                asm::sev();
+                unsafe { crate::signal_event_ready(); }
                 Poll::Pending
             }
         }

async-cortex-m/src/task.rs

@@ -12,7 +12,6 @@ use core::{
     task::{Context, Poll},
 };
 
-use cortex_m::asm;
 use generic_array::{typenum::Unsigned, GenericArray};
 
 use super::waker_set::WakerSet;
@@ -137,7 +136,7 @@ impl<T> Channel<T> {
                 self.read.set(read.wrapping_add(1));
                 // notify a sender
                 self.send_wakers.notify_one();
-                asm::sev();
+                crate::signal_event_ready();
                 Some(val)
             } else {
                 // empty
@@ -162,7 +161,7 @@ impl<T> Channel<T> {
                 self.write.set(write.wrapping_add(1));
                 // notify a receiver
                 self.recv_wakers.notify_one();
-                asm::sev();
+                crate::signal_event_ready();
                 Ok(())
             } else {
                 // full

async-cortex-m/src/unsync/channel.rs

@@ -8,8 +8,6 @@ use core::{
     task::{Context, Poll},
 };
 
-use cortex_m::asm;
-
 use super::waker_set::WakerSet;
 
 /// A mutual exclusion primitive for protecting shared data
@@ -94,7 +92,7 @@ impl<T> Drop for MutexGuard<'_, T> {
     fn drop(&mut self) {
         self.0.locked.set(false);
         self.0.wakers.notify_any();
-        asm::sev();
+        unsafe { crate::signal_event_ready(); }
     }
 }
 

async-cortex-m/src/unsync/mutex.rs

@@ -15,7 +15,7 @@ panic-semihosting = "0.5.3"
 panic-udf = { path = "../panic-udf" }
 
 [dependencies]
-async-cortex-m = { path = "../async-cortex-m" }
+async-cortex-m = { path = "../async-cortex-m", features = ["isa-cortex-m"] }
 cortex-m = "0.6.2"
 cortex-m-rt = "0.6.12"
 pac = { package = "nrf52840-pac", version = "0.9.0", features = ["rt"] }