From 2a435e53b761182dabf9496963052f8323125f3a Mon Sep 17 00:00:00 2001 From: Dario Nieuwenhuis Date: Thu, 1 Jun 2023 02:22:31 +0200 Subject: [PATCH] cortex-m: remove PeripheralMutex. --- embassy-cortex-m/src/lib.rs | 1 - embassy-cortex-m/src/peripheral.rs | 144 ----------------------------- 2 files changed, 145 deletions(-) delete mode 100644 embassy-cortex-m/src/peripheral.rs diff --git a/embassy-cortex-m/src/lib.rs b/embassy-cortex-m/src/lib.rs index e4b713a06..7bc16d3ba 100644 --- a/embassy-cortex-m/src/lib.rs +++ b/embassy-cortex-m/src/lib.rs @@ -7,4 +7,3 @@ pub(crate) mod fmt; pub use embassy_executor as executor; pub mod interrupt; -pub mod peripheral; diff --git a/embassy-cortex-m/src/peripheral.rs b/embassy-cortex-m/src/peripheral.rs deleted file mode 100644 index e2f295579..000000000 --- a/embassy-cortex-m/src/peripheral.rs +++ /dev/null @@ -1,144 +0,0 @@ -//! Peripheral interrupt handling specific to cortex-m devices. -use core::mem::MaybeUninit; - -use cortex_m::peripheral::scb::VectActive; -use cortex_m::peripheral::{NVIC, SCB}; -use embassy_hal_common::{into_ref, Peripheral, PeripheralRef}; - -use crate::interrupt::{Interrupt, InterruptExt, Priority}; - -/// A type which can be used as state with `PeripheralMutex`. -/// -/// It needs to be `Send` because `&mut` references are sent back and forth between the 'thread' which owns the `PeripheralMutex` and the interrupt, -/// and `&mut T` is only `Send` where `T: Send`. -pub trait PeripheralState: Send { - /// The interrupt that is used for this peripheral. - type Interrupt: Interrupt; - - /// The interrupt handler that should be invoked for the peripheral. Implementations need to clear the appropriate interrupt flags to ensure the handle will not be called again. - fn on_interrupt(&mut self); -} - -/// A type for storing the state of a peripheral that can be stored in a static. -pub struct StateStorage(MaybeUninit); - -impl StateStorage { - /// Create a new instance for storing peripheral state. - pub const fn new() -> Self { - Self(MaybeUninit::uninit()) - } -} - -/// A type for a peripheral that keeps the state of a peripheral that can be accessed from thread mode and an interrupt handler in -/// a safe way. -pub struct PeripheralMutex<'a, S: PeripheralState> { - state: *mut S, - irq: PeripheralRef<'a, S::Interrupt>, -} - -/// Whether `irq` can be preempted by the current interrupt. -pub(crate) fn can_be_preempted(irq: &impl Interrupt) -> bool { - match SCB::vect_active() { - // Thread mode can't preempt anything. - VectActive::ThreadMode => false, - // Exceptions don't always preempt interrupts, - // but there isn't much of a good reason to be keeping a `PeripheralMutex` in an exception anyway. - VectActive::Exception(_) => true, - VectActive::Interrupt { irqn } => { - #[derive(Clone, Copy)] - struct NrWrap(u16); - unsafe impl cortex_m::interrupt::InterruptNumber for NrWrap { - fn number(self) -> u16 { - self.0 - } - } - NVIC::get_priority(NrWrap(irqn.into())) < irq.get_priority().into() - } - } -} - -impl<'a, S: PeripheralState> PeripheralMutex<'a, S> { - /// Create a new `PeripheralMutex` wrapping `irq`, with `init` initializing the initial state. - /// - /// Registers `on_interrupt` as the `irq`'s handler, and enables it. - pub fn new( - irq: impl Peripheral

+ 'a, - storage: &'a mut StateStorage, - init: impl FnOnce() -> S, - ) -> Self { - into_ref!(irq); - - if can_be_preempted(&*irq) { - panic!( - "`PeripheralMutex` cannot be created in an interrupt with higher priority than the interrupt it wraps" - ); - } - - let state_ptr = storage.0.as_mut_ptr(); - - // Safety: The pointer is valid and not used by anyone else - // because we have the `&mut StateStorage`. - unsafe { state_ptr.write(init()) }; - - irq.disable(); - irq.set_handler(|p| unsafe { - // Safety: it's OK to get a &mut to the state, since - // - We checked that the thread owning the `PeripheralMutex` can't preempt us in `new`. - // Interrupts' priorities can only be changed with raw embassy `Interrupts`, - // which can't safely store a `PeripheralMutex` across invocations. - // - We can't have preempted a with() call because the irq is disabled during it. - let state = &mut *(p as *mut S); - state.on_interrupt(); - }); - irq.set_handler_context(state_ptr as *mut ()); - irq.enable(); - - Self { irq, state: state_ptr } - } - - /// Access the peripheral state ensuring interrupts are disabled so that the state can be - /// safely accessed. - pub fn with(&mut self, f: impl FnOnce(&mut S) -> R) -> R { - self.irq.disable(); - - // Safety: it's OK to get a &mut to the state, since the irq is disabled. - let state = unsafe { &mut *self.state }; - let r = f(state); - - self.irq.enable(); - - r - } - - /// Returns whether the wrapped interrupt is currently in a pending state. - pub fn is_pending(&self) -> bool { - self.irq.is_pending() - } - - /// Forces the wrapped interrupt into a pending state. - pub fn pend(&self) { - self.irq.pend() - } - - /// Forces the wrapped interrupt out of a pending state. - pub fn unpend(&self) { - self.irq.unpend() - } - - /// Gets the priority of the wrapped interrupt. - pub fn priority(&self) -> Priority { - self.irq.get_priority() - } -} - -impl<'a, S: PeripheralState> Drop for PeripheralMutex<'a, S> { - fn drop(&mut self) { - self.irq.disable(); - self.irq.remove_handler(); - - // safety: - // - we initialized the state in `new`, so we know it's initialized. - // - the irq is disabled, so it won't preempt us while dropping. - unsafe { self.state.drop_in_place() } - } -}