max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #327 from embassy-rs/remove-pin

Browse Source 
PeripheralMutex: Remove Pin
This commit is contained in:
Dario Nieuwenhuis 2021-08-02 20:28:54 +02:00 committed by GitHub
commit 9ca43752eb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 228 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
embassy-hal-common/src/peripheral.rs
View File

@ -1,6 +1,5 @@
use core::cell::UnsafeCell; use core::marker::PhantomData;
use core::marker::{PhantomData, PhantomPinned}; use core::mem::MaybeUninit;
use core::pin::Pin;
use cortex_m::peripheral::scb::VectActive; use cortex_m::peripheral::scb::VectActive;
use cortex_m::peripheral::{NVIC, SCB}; use cortex_m::peripheral::{NVIC, SCB};
@ -10,23 +9,23 @@ use embassy::interrupt::{Interrupt, InterruptExt};
/// ///
/// It needs to be `Send` because `&mut` references are sent back and forth between the 'thread' which owns the `PeripheralMutex` and the interrupt, /// 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`. /// and `&mut T` is only `Send` where `T: Send`.
///
/// It also requires `'static` to be used safely with `PeripheralMutex::register_interrupt`,
/// because although `Pin` guarantees that the memory of the state won't be invalidated,
/// it doesn't guarantee that the lifetime will last.
pub trait PeripheralState: Send { pub trait PeripheralState: Send {
type Interrupt: Interrupt; type Interrupt: Interrupt;
fn on_interrupt(&mut self); fn on_interrupt(&mut self);
} }
pub struct PeripheralMutex<S: PeripheralState> { pub struct StateStorage<S>(MaybeUninit<S>);
state: UnsafeCell<S>,
irq_setup_done: bool, impl<S> StateStorage<S> {
pub const fn new() -> Self {
Self(MaybeUninit::uninit())
}
}
pub struct PeripheralMutex<'a, S: PeripheralState> {
state: *mut S,
_phantom: PhantomData<&'a mut S>,
irq: S::Interrupt, irq: S::Interrupt,
_not_send: PhantomData<*mut ()>,
_pinned: PhantomPinned,
} }
/// Whether `irq` can be preempted by the current interrupt. /// Whether `irq` can be preempted by the current interrupt.
@ -50,58 +49,49 @@ pub(crate) fn can_be_preempted(irq: &impl Interrupt) -> bool {
} }
} }
impl<S: PeripheralState + 'static> PeripheralMutex<S> { impl<'a, S: PeripheralState> PeripheralMutex<'a, S> {
/// Registers `on_interrupt` as the wrapped interrupt's interrupt handler and enables it. /// Create a new `PeripheralMutex` wrapping `irq`, with `init` initializing the initial state.
/// ///
/// This requires this `PeripheralMutex`'s `PeripheralState` to live for `'static`, /// self requires `S` to live for `'static`, because if the `PeripheralMutex` is leaked, the
/// because `Pin` only guarantees that it's memory won't be repurposed, /// interrupt won't be disabled, which may try accessing the state at any time. To use non-`'static`
/// not that it's lifetime will last. /// state, see [`Self::new_unchecked`].
/// ///
/// To use non-`'static` `PeripheralState`, use the unsafe `register_interrupt_unchecked`. /// Registers `on_interrupt` as the `irq`'s handler, and enables it.
/// pub fn new(
/// Note: `'static` doesn't mean it _has_ to live for the entire program, like an `&'static T`; irq: S::Interrupt,
/// it just means it _can_ live for the entire program - for example, `u8` lives for `'static`. storage: &'a mut StateStorage<S>,
pub fn register_interrupt(self: Pin<&mut Self>) { init: impl FnOnce() -> S,
// SAFETY: `S: 'static`, so there's no way it's lifetime can expire. ) -> Self
unsafe { self.register_interrupt_unchecked() } where
'a: 'static,
{
// safety: safe because state is `'static`.
unsafe { Self::new_unchecked(irq, storage, init) }
} }
}
impl<S: PeripheralState> PeripheralMutex<S> { /// Create a `PeripheralMutex` without requiring the state is `'static`.
/// Create a new `PeripheralMutex` wrapping `irq`, with the initial state `state`. ///
pub fn new(state: S, irq: S::Interrupt) -> Self { /// See also [`Self::new`].
///
/// # Safety
/// The created instance must not be leaked (its `drop` must run).
pub unsafe fn new_unchecked(
irq: S::Interrupt,
storage: &'a mut StateStorage<S>,
init: impl FnOnce() -> S,
) -> Self {
if can_be_preempted(&irq) { if can_be_preempted(&irq) {
panic!("`PeripheralMutex` cannot be created in an interrupt with higher priority than the interrupt it wraps"); panic!("`PeripheralMutex` cannot be created in an interrupt with higher priority than the interrupt it wraps");
} }
Self { let state_ptr = storage.0.as_mut_ptr();
irq,
irq_setup_done: false,
state: UnsafeCell::new(state), // Safety: The pointer is valid and not used by anyone else
_not_send: PhantomData, // because we have the `&mut StateStorage`.
_pinned: PhantomPinned, state_ptr.write(init());
}
}
/// Registers `on_interrupt` as the wrapped interrupt's interrupt handler and enables it. irq.disable();
/// irq.set_handler(|p| {
/// # Safety
/// The lifetime of any data in `PeripheralState` that is accessed by the interrupt handler
/// must not end without `Drop` being called on this `PeripheralMutex`.
///
/// This can be accomplished by either not accessing any data with a lifetime in `on_interrupt`,
/// or making sure that nothing like `mem::forget` is used on the `PeripheralMutex`.
// TODO: this name isn't the best.
pub unsafe fn register_interrupt_unchecked(self: Pin<&mut Self>) {
let this = self.get_unchecked_mut();
if this.irq_setup_done {
return;
}
this.irq.disable();
this.irq.set_handler(|p| {
// Safety: it's OK to get a &mut to the state, since // 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`. // - We checked that the thread owning the `PeripheralMutex` can't preempt us in `new`.
// Interrupts' priorities can only be changed with raw embassy `Interrupts`, // Interrupts' priorities can only be changed with raw embassy `Interrupts`,
@ -110,23 +100,24 @@ impl<S: PeripheralState> PeripheralMutex<S> {
let state = unsafe { &mut *(p as *mut S) }; let state = unsafe { &mut *(p as *mut S) };
state.on_interrupt(); state.on_interrupt();
}); });
this.irq irq.set_handler_context(state_ptr as *mut ());
.set_handler_context((&mut this.state) as *mut _ as *mut ()); irq.enable();
this.irq.enable();
this.irq_setup_done = true; Self {
irq,
state: state_ptr,
_phantom: PhantomData,
}
} }
pub fn with<R>(self: Pin<&mut Self>, f: impl FnOnce(&mut S) -> R) -> R { pub fn with<R>(&mut self, f: impl FnOnce(&mut S) -> R) -> R {
let this = unsafe { self.get_unchecked_mut() }; self.irq.disable();
this.irq.disable();
// Safety: it's OK to get a &mut to the state, since the irq is disabled. // Safety: it's OK to get a &mut to the state, since the irq is disabled.
let state = unsafe { &mut *this.state.get() }; let state = unsafe { &mut *self.state };
let r = f(state); let r = f(state);
this.irq.enable(); self.irq.enable();
r r
} }
@ -152,9 +143,14 @@ impl<S: PeripheralState> PeripheralMutex<S> {
} }
} }
impl<S: PeripheralState> Drop for PeripheralMutex<S> { impl<'a, S: PeripheralState> Drop for PeripheralMutex<'a, S> {
fn drop(&mut self) { fn drop(&mut self) {
self.irq.disable(); self.irq.disable();
self.irq.remove_handler(); 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() }
} }
} }

51
embassy-hal-common/src/usb/mod.rs
View File

@ -9,14 +9,31 @@ use usb_device::device::UsbDevice;
mod cdc_acm; mod cdc_acm;
pub mod usb_serial; pub mod usb_serial;
use crate::peripheral::{PeripheralMutex, PeripheralState}; use crate::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
use embassy::interrupt::Interrupt; use embassy::interrupt::Interrupt;
use usb_serial::{ReadInterface, UsbSerial, WriteInterface}; use usb_serial::{ReadInterface, UsbSerial, WriteInterface};
/// Marker trait to mark an interrupt to be used with the [`Usb`] abstraction. /// Marker trait to mark an interrupt to be used with the [`Usb`] abstraction.
pub unsafe trait USBInterrupt: Interrupt + Send {} pub unsafe trait USBInterrupt: Interrupt + Send {}
pub(crate) struct State<'bus, B, T, I> pub struct State<'bus, B, T, I>(StateStorage<StateInner<'bus, B, T, I>>)
where
B: UsbBus,
T: ClassSet<B>,
I: USBInterrupt;
impl<'bus, B, T, I> State<'bus, B, T, I>
where
B: UsbBus,
T: ClassSet<B>,
I: USBInterrupt,
{
pub fn new() -> Self {
Self(StateStorage::new())
}
}
pub(crate) struct StateInner<'bus, B, T, I>
where where
B: UsbBus, B: UsbBus,
T: ClassSet<B>, T: ClassSet<B>,
@ -34,7 +51,7 @@ where
I: USBInterrupt, I: USBInterrupt,
{ {
// Don't you dare moving out `PeripheralMutex` // Don't you dare moving out `PeripheralMutex`
inner: RefCell<PeripheralMutex<State<'bus, B, T, I>>>, inner: RefCell<PeripheralMutex<'bus, StateInner<'bus, B, T, I>>>,
} }
impl<'bus, B, T, I> Usb<'bus, B, T, I> impl<'bus, B, T, I> Usb<'bus, B, T, I>
@ -43,30 +60,22 @@ where
T: ClassSet<B>, T: ClassSet<B>,
I: USBInterrupt, I: USBInterrupt,
{ {
pub fn new<S: IntoClassSet<B, T>>(device: UsbDevice<'bus, B>, class_set: S, irq: I) -> Self { /// safety: the returned instance is not leak-safe
let state = State { pub unsafe fn new<S: IntoClassSet<B, T>>(
state: &'bus mut State<'bus, B, T, I>,
device: UsbDevice<'bus, B>,
class_set: S,
irq: I,
) -> Self {
let mutex = PeripheralMutex::new_unchecked(irq, &mut state.0, || StateInner {
device, device,
classes: class_set.into_class_set(), classes: class_set.into_class_set(),
_interrupt: PhantomData, _interrupt: PhantomData,
}; });
let mutex = PeripheralMutex::new(state, irq);
Self { Self {
inner: RefCell::new(mutex), inner: RefCell::new(mutex),
} }
} }
/// # Safety
/// The `UsbDevice` passed to `Self::new` must not be dropped without calling `Drop` on this `Usb` first.
pub unsafe fn start(self: Pin<&mut Self>) {
let this = self.get_unchecked_mut();
let mut mutex = this.inner.borrow_mut();
let mutex = Pin::new_unchecked(&mut *mutex);
// Use inner to register the irq
// SAFETY: the safety contract of this function makes sure the `UsbDevice` won't be invalidated
// without the `PeripheralMutex` being dropped.
mutex.register_interrupt_unchecked();
}
} }
impl<'bus, 'c, B, T, I> Usb<'bus, B, T, I> impl<'bus, 'c, B, T, I> Usb<'bus, B, T, I>
@ -129,7 +138,7 @@ where
} }
} }
impl<'bus, B, T, I> PeripheralState for State<'bus, B, T, I> impl<'bus, B, T, I> PeripheralState for StateInner<'bus, B, T, I>
where where
B: UsbBus, B: UsbBus,
T: ClassSet<B>, T: ClassSet<B>,

10
embassy-hal-common/src/usb/usb_serial.rs
View File

@ -10,9 +10,10 @@ use usb_device::class_prelude::*;
use usb_device::UsbError; use usb_device::UsbError;
use super::cdc_acm::CdcAcmClass; use super::cdc_acm::CdcAcmClass;
use super::StateInner;
use crate::peripheral::PeripheralMutex; use crate::peripheral::PeripheralMutex;
use crate::ring_buffer::RingBuffer; use crate::ring_buffer::RingBuffer;
use crate::usb::{ClassSet, SerialState, State, USBInterrupt}; use crate::usb::{ClassSet, SerialState, USBInterrupt};
pub struct ReadInterface<'a, 'bus, 'c, I, B, T, INT> pub struct ReadInterface<'a, 'bus, 'c, I, B, T, INT>
where where
@ -22,7 +23,7 @@ where
INT: USBInterrupt, INT: USBInterrupt,
{ {
// Don't you dare moving out `PeripheralMutex` // Don't you dare moving out `PeripheralMutex`
pub(crate) inner: &'a RefCell<PeripheralMutex<State<'bus, B, T, INT>>>, pub(crate) inner: &'a RefCell<PeripheralMutex<'bus, StateInner<'bus, B, T, INT>>>,
pub(crate) _buf_lifetime: PhantomData<&'c T>, pub(crate) _buf_lifetime: PhantomData<&'c T>,
pub(crate) _index: PhantomData<I>, pub(crate) _index: PhantomData<I>,
} }
@ -39,7 +40,7 @@ where
INT: USBInterrupt, INT: USBInterrupt,
{ {
// Don't you dare moving out `PeripheralMutex` // Don't you dare moving out `PeripheralMutex`
pub(crate) inner: &'a RefCell<PeripheralMutex<State<'bus, B, T, INT>>>, pub(crate) inner: &'a RefCell<PeripheralMutex<'bus, StateInner<'bus, B, T, INT>>>,
pub(crate) _buf_lifetime: PhantomData<&'c T>, pub(crate) _buf_lifetime: PhantomData<&'c T>,
pub(crate) _index: PhantomData<I>, pub(crate) _index: PhantomData<I>,
} }
@ -54,7 +55,6 @@ where
fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> { fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
let this = self.get_mut(); let this = self.get_mut();
let mut mutex = this.inner.borrow_mut(); let mut mutex = this.inner.borrow_mut();
let mutex = unsafe { Pin::new_unchecked(&mut *mutex) };
mutex.with(|state| { mutex.with(|state| {
let serial = state.classes.get_serial(); let serial = state.classes.get_serial();
let serial = Pin::new(serial); let serial = Pin::new(serial);
@ -76,7 +76,6 @@ where
fn consume(self: Pin<&mut Self>, amt: usize) { fn consume(self: Pin<&mut Self>, amt: usize) {
let this = self.get_mut(); let this = self.get_mut();
let mut mutex = this.inner.borrow_mut(); let mut mutex = this.inner.borrow_mut();
let mutex = unsafe { Pin::new_unchecked(&mut *mutex) };
mutex.with(|state| { mutex.with(|state| {
let serial = state.classes.get_serial(); let serial = state.classes.get_serial();
let serial = Pin::new(serial); let serial = Pin::new(serial);
@ -100,7 +99,6 @@ where
) -> Poll<io::Result<usize>> { ) -> Poll<io::Result<usize>> {
let this = self.get_mut(); let this = self.get_mut();
let mut mutex = this.inner.borrow_mut(); let mut mutex = this.inner.borrow_mut();
let mutex = unsafe { Pin::new_unchecked(&mut *mutex) };
mutex.with(|state| { mutex.with(|state| {
let serial = state.classes.get_serial(); let serial = state.classes.get_serial();
let serial = Pin::new(serial); let serial = Pin::new(serial);

92
embassy-nrf/src/buffered_uarte.rs
View File

@ -7,7 +7,7 @@ use core::task::{Context, Poll};
use embassy::interrupt::InterruptExt; use embassy::interrupt::InterruptExt;
use embassy::io::{AsyncBufRead, AsyncWrite, Result}; use embassy::io::{AsyncBufRead, AsyncWrite, Result};
use embassy::util::{Unborrow, WakerRegistration}; use embassy::util::{Unborrow, WakerRegistration};
use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState}; use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
use embassy_hal_common::ring_buffer::RingBuffer; use embassy_hal_common::ring_buffer::RingBuffer;
use embassy_hal_common::{low_power_wait_until, unborrow}; use embassy_hal_common::{low_power_wait_until, unborrow};
@ -35,7 +35,14 @@ enum TxState {
Transmitting(usize), Transmitting(usize),
} }
struct State<'d, U: UarteInstance, T: TimerInstance> { pub struct State<'d, U: UarteInstance, T: TimerInstance>(StateStorage<StateInner<'d, U, T>>);
impl<'d, U: UarteInstance, T: TimerInstance> State<'d, U, T> {
pub fn new() -> Self {
Self(StateStorage::new())
}
}
struct StateInner<'d, U: UarteInstance, T: TimerInstance> {
phantom: PhantomData<&'d mut U>, phantom: PhantomData<&'d mut U>,
timer: Timer<'d, T>, timer: Timer<'d, T>,
_ppi_ch1: Ppi<'d, AnyConfigurableChannel>, _ppi_ch1: Ppi<'d, AnyConfigurableChannel>,
@ -51,20 +58,16 @@ struct State<'d, U: UarteInstance, T: TimerInstance> {
} }
/// Interface to a UARTE instance /// Interface to a UARTE instance
///
/// This is a very basic interface that comes with the following limitations:
/// - The UARTE instances share the same address space with instances of UART.
/// You need to make sure that conflicting instances
/// are disabled before using `Uarte`. See product specification:
/// - nrf52832: Section 15.2
/// - nrf52840: Section 6.1.2
pub struct BufferedUarte<'d, U: UarteInstance, T: TimerInstance> { pub struct BufferedUarte<'d, U: UarteInstance, T: TimerInstance> {
inner: PeripheralMutex<State<'d, U, T>>, inner: PeripheralMutex<'d, StateInner<'d, U, T>>,
} }
impl<'d, U: UarteInstance, T: TimerInstance> Unpin for BufferedUarte<'d, U, T> {}
impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> { impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
/// unsafe: may not leak self or futures /// unsafe: may not leak self or futures
pub unsafe fn new( pub unsafe fn new(
state: &'d mut State<'d, U, T>,
_uarte: impl Unborrow<Target = U> + 'd, _uarte: impl Unborrow<Target = U> + 'd,
timer: impl Unborrow<Target = T> + 'd, timer: impl Unborrow<Target = T> + 'd,
ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel> + 'd, ppi_ch1: impl Unborrow<Target = impl ConfigurableChannel> + 'd,
@ -152,31 +155,26 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
ppi_ch2.set_task(Task::from_reg(&r.tasks_stoprx)); ppi_ch2.set_task(Task::from_reg(&r.tasks_stoprx));
ppi_ch2.enable(); ppi_ch2.enable();
BufferedUarte { Self {
inner: PeripheralMutex::new( inner: PeripheralMutex::new_unchecked(irq, &mut state.0, move || StateInner {
State { phantom: PhantomData,
phantom: PhantomData, timer,
timer, _ppi_ch1: ppi_ch1,
_ppi_ch1: ppi_ch1, _ppi_ch2: ppi_ch2,
_ppi_ch2: ppi_ch2,
rx: RingBuffer::new(rx_buffer), rx: RingBuffer::new(rx_buffer),
rx_state: RxState::Idle, rx_state: RxState::Idle,
rx_waker: WakerRegistration::new(), rx_waker: WakerRegistration::new(),
tx: RingBuffer::new(tx_buffer), tx: RingBuffer::new(tx_buffer),
tx_state: TxState::Idle, tx_state: TxState::Idle,
tx_waker: WakerRegistration::new(), tx_waker: WakerRegistration::new(),
}, }),
irq,
),
} }
} }
pub fn set_baudrate(self: Pin<&mut Self>, baudrate: Baudrate) { pub fn set_baudrate(&mut self, baudrate: Baudrate) {
let mut inner = self.inner(); self.inner.with(|state| {
unsafe { inner.as_mut().register_interrupt_unchecked() }
inner.with(|state| {
let r = U::regs(); let r = U::regs();
let timeout = 0x8000_0000 / (baudrate as u32 / 40); let timeout = 0x8000_0000 / (baudrate as u32 / 40);
@ -186,17 +184,11 @@ impl<'d, U: UarteInstance, T: TimerInstance> BufferedUarte<'d, U, T> {
r.baudrate.write(|w| w.baudrate().variant(baudrate)); r.baudrate.write(|w| w.baudrate().variant(baudrate));
}); });
} }
fn inner(self: Pin<&mut Self>) -> Pin<&mut PeripheralMutex<State<'d, U, T>>> {
unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().inner) }
}
} }
impl<'d, U: UarteInstance, T: TimerInstance> AsyncBufRead for BufferedUarte<'d, U, T> { impl<'d, U: UarteInstance, T: TimerInstance> AsyncBufRead for BufferedUarte<'d, U, T> {
fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> { fn poll_fill_buf(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>> {
let mut inner = self.inner(); self.inner.with(|state| {
unsafe { inner.as_mut().register_interrupt_unchecked() }
inner.with(|state| {
// Conservative compiler fence to prevent optimizations that do not // Conservative compiler fence to prevent optimizations that do not
// take in to account actions by DMA. The fence has been placed here, // take in to account actions by DMA. The fence has been placed here,
// before any DMA action has started // before any DMA action has started
@ -218,22 +210,22 @@ impl<'d, U: UarteInstance, T: TimerInstance> AsyncBufRead for BufferedUarte<'d,
}) })
} }
fn consume(self: Pin<&mut Self>, amt: usize) { fn consume(mut self: Pin<&mut Self>, amt: usize) {
let mut inner = self.inner(); self.inner.with(|state| {
unsafe { inner.as_mut().register_interrupt_unchecked() }
inner.as_mut().with(|state| {
trace!("consume {:?}", amt); trace!("consume {:?}", amt);
state.rx.pop(amt); state.rx.pop(amt);
}); });
inner.pend(); self.inner.pend();
} }
} }
impl<'d, U: UarteInstance, T: TimerInstance> AsyncWrite for BufferedUarte<'d, U, T> { impl<'d, U: UarteInstance, T: TimerInstance> AsyncWrite for BufferedUarte<'d, U, T> {
fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<Result<usize>> { fn poll_write(
let mut inner = self.inner(); mut self: Pin<&mut Self>,
unsafe { inner.as_mut().register_interrupt_unchecked() } cx: &mut Context<'_>,
let poll = inner.as_mut().with(|state| { buf: &[u8],
) -> Poll<Result<usize>> {
let poll = self.inner.with(|state| {
trace!("poll_write: {:?}", buf.len()); trace!("poll_write: {:?}", buf.len());
let tx_buf = state.tx.push_buf(); let tx_buf = state.tx.push_buf();
@ -257,13 +249,13 @@ impl<'d, U: UarteInstance, T: TimerInstance> AsyncWrite for BufferedUarte<'d, U,
Poll::Ready(Ok(n)) Poll::Ready(Ok(n))
}); });
inner.pend(); self.inner.pend();
poll poll
} }
} }
impl<'a, U: UarteInstance, T: TimerInstance> Drop for State<'a, U, T> { impl<'a, U: UarteInstance, T: TimerInstance> Drop for StateInner<'a, U, T> {
fn drop(&mut self) { fn drop(&mut self) {
let r = U::regs(); let r = U::regs();
@ -285,7 +277,7 @@ impl<'a, U: UarteInstance, T: TimerInstance> Drop for State<'a, U, T> {
} }
} }
impl<'a, U: UarteInstance, T: TimerInstance> PeripheralState for State<'a, U, T> { impl<'a, U: UarteInstance, T: TimerInstance> PeripheralState for StateInner<'a, U, T> {
type Interrupt = U::Interrupt; type Interrupt = U::Interrupt;
fn on_interrupt(&mut self) { fn on_interrupt(&mut self) {
trace!("irq: start"); trace!("irq: start");

173
embassy-stm32/src/eth/v2/mod.rs
View File

@ -1,10 +1,9 @@
use core::marker::PhantomData; use core::marker::PhantomData;
use core::pin::Pin;
use core::sync::atomic::{fence, Ordering}; use core::sync::atomic::{fence, Ordering};
use core::task::Waker; use core::task::Waker;
use embassy::util::{AtomicWaker, Unborrow}; use embassy::util::{AtomicWaker, Unborrow};
use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState}; use embassy_hal_common::peripheral::{PeripheralMutex, PeripheralState, StateStorage};
use embassy_hal_common::unborrow; use embassy_hal_common::unborrow;
use embassy_net::{Device, DeviceCapabilities, LinkState, PacketBuf, MTU}; use embassy_net::{Device, DeviceCapabilities, LinkState, PacketBuf, MTU};
@ -19,8 +18,14 @@ mod descriptors;
use super::{StationManagement, PHY}; use super::{StationManagement, PHY};
use descriptors::DescriptorRing; use descriptors::DescriptorRing;
pub struct State<'d, const TX: usize, const RX: usize>(StateStorage<Inner<'d, TX, RX>>);
impl<'d, const TX: usize, const RX: usize> State<'d, TX, RX> {
pub const fn new() -> Self {
Self(StateStorage::new())
}
}
pub struct Ethernet<'d, P: PHY, const TX: usize, const RX: usize> { pub struct Ethernet<'d, P: PHY, const TX: usize, const RX: usize> {
state: PeripheralMutex<Inner<'d, TX, RX>>, state: PeripheralMutex<'d, Inner<'d, TX, RX>>,
pins: [AnyPin; 9], pins: [AnyPin; 9],
_phy: P, _phy: P,
clock_range: u8, clock_range: u8,
@ -29,7 +34,9 @@ pub struct Ethernet<'d, P: PHY, const TX: usize, const RX: usize> {
} }
impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> { impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> {
pub fn new( /// safety: the returned instance is not leak-safe
pub unsafe fn new(
state: &'d mut State<'d, TX, RX>,
peri: impl Unborrow<Target = peripherals::ETH> + 'd, peri: impl Unborrow<Target = peripherals::ETH> + 'd,
interrupt: impl Unborrow<Target = crate::interrupt::ETH> + 'd, interrupt: impl Unborrow<Target = crate::interrupt::ETH> + 'd,
ref_clk: impl Unborrow<Target = impl RefClkPin> + 'd, ref_clk: impl Unborrow<Target = impl RefClkPin> + 'd,
@ -49,7 +56,7 @@ impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> {
// Enable the necessary Clocks // Enable the necessary Clocks
// NOTE(unsafe) We have exclusive access to the registers // NOTE(unsafe) We have exclusive access to the registers
critical_section::with(|_| unsafe { critical_section::with(|_| {
RCC.apb4enr().modify(|w| w.set_syscfgen(true)); RCC.apb4enr().modify(|w| w.set_syscfgen(true));
RCC.ahb1enr().modify(|w| { RCC.ahb1enr().modify(|w| {
w.set_eth1macen(true); w.set_eth1macen(true);
@ -71,53 +78,51 @@ impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> {
tx_d1.configure(); tx_d1.configure();
tx_en.configure(); tx_en.configure();
let inner = Inner::new(peri); // NOTE(unsafe) We are ourselves not leak-safe.
let state = PeripheralMutex::new(inner, interrupt); let state = PeripheralMutex::new_unchecked(interrupt, &mut state.0, || Inner::new(peri));
// NOTE(unsafe) We have exclusive access to the registers // NOTE(unsafe) We have exclusive access to the registers
unsafe { let dma = ETH.ethernet_dma();
let dma = ETH.ethernet_dma(); let mac = ETH.ethernet_mac();
let mac = ETH.ethernet_mac(); let mtl = ETH.ethernet_mtl();
let mtl = ETH.ethernet_mtl();
// Reset and wait // Reset and wait
dma.dmamr().modify(|w| w.set_swr(true)); dma.dmamr().modify(|w| w.set_swr(true));
while dma.dmamr().read().swr() {} while dma.dmamr().read().swr() {}
mac.maccr().modify(|w| { mac.maccr().modify(|w| {
w.set_ipg(0b000); // 96 bit times w.set_ipg(0b000); // 96 bit times
w.set_acs(true); w.set_acs(true);
w.set_fes(true); w.set_fes(true);
w.set_dm(true); w.set_dm(true);
// TODO: Carrier sense ? ECRSFD // TODO: Carrier sense ? ECRSFD
}); });
mac.maca0lr().write(|w| { mac.maca0lr().write(|w| {
w.set_addrlo( w.set_addrlo(
u32::from(mac_addr[0]) u32::from(mac_addr[0])
| (u32::from(mac_addr[1]) << 8) | (u32::from(mac_addr[1]) << 8)
| (u32::from(mac_addr[2]) << 16) | (u32::from(mac_addr[2]) << 16)
| (u32::from(mac_addr[3]) << 24), | (u32::from(mac_addr[3]) << 24),
) )
}); });
mac.maca0hr() mac.maca0hr()
.modify(|w| w.set_addrhi(u16::from(mac_addr[4]) | (u16::from(mac_addr[5]) << 8))); .modify(|w| w.set_addrhi(u16::from(mac_addr[4]) | (u16::from(mac_addr[5]) << 8)));
mac.macpfr().modify(|w| w.set_saf(true)); mac.macpfr().modify(|w| w.set_saf(true));
mac.macqtx_fcr().modify(|w| w.set_pt(0x100)); mac.macqtx_fcr().modify(|w| w.set_pt(0x100));
mtl.mtlrx_qomr().modify(|w| w.set_rsf(true)); mtl.mtlrx_qomr().modify(|w| w.set_rsf(true));
mtl.mtltx_qomr().modify(|w| w.set_tsf(true)); mtl.mtltx_qomr().modify(|w| w.set_tsf(true));
dma.dmactx_cr().modify(|w| w.set_txpbl(1)); // 32 ? dma.dmactx_cr().modify(|w| w.set_txpbl(1)); // 32 ?
dma.dmacrx_cr().modify(|w| { dma.dmacrx_cr().modify(|w| {
w.set_rxpbl(1); // 32 ? w.set_rxpbl(1); // 32 ?
w.set_rbsz(MTU as u16); w.set_rbsz(MTU as u16);
}); });
}
// NOTE(unsafe) We got the peripheral singleton, which means that `rcc::init` was called // NOTE(unsafe) We got the peripheral singleton, which means that `rcc::init` was called
let hclk = unsafe { crate::rcc::get_freqs().ahb1 }; let hclk = crate::rcc::get_freqs().ahb1;
let hclk_mhz = hclk.0 / 1_000_000; let hclk_mhz = hclk.0 / 1_000_000;
// Set the MDC clock frequency in the range 1MHz - 2.5MHz // Set the MDC clock frequency in the range 1MHz - 2.5MHz
@ -145,52 +150,44 @@ impl<'d, P: PHY, const TX: usize, const RX: usize> Ethernet<'d, P, TX, RX> {
tx_en.degrade(), tx_en.degrade(),
]; ];
Self { let mut this = Self {
state, state,
pins, pins,
_phy: phy, _phy: phy,
clock_range, clock_range,
phy_addr, phy_addr,
mac_addr, mac_addr,
} };
}
pub fn init(self: Pin<&mut Self>) { this.state.with(|s| {
// NOTE(unsafe) We won't move this
let this = unsafe { self.get_unchecked_mut() };
let mut mutex = unsafe { Pin::new_unchecked(&mut this.state) };
// SAFETY: The lifetime of `Inner` is only due to `PhantomData`; it isn't actually referencing any data with that lifetime.
unsafe { mutex.as_mut().register_interrupt_unchecked() }
mutex.with(|s| {
s.desc_ring.init(); s.desc_ring.init();
fence(Ordering::SeqCst); fence(Ordering::SeqCst);
unsafe { let mac = ETH.ethernet_mac();
let mac = ETH.ethernet_mac(); let mtl = ETH.ethernet_mtl();
let mtl = ETH.ethernet_mtl(); let dma = ETH.ethernet_dma();
let dma = ETH.ethernet_dma();
mac.maccr().modify(|w| { mac.maccr().modify(|w| {
w.set_re(true); w.set_re(true);
w.set_te(true); w.set_te(true);
}); });
mtl.mtltx_qomr().modify(|w| w.set_ftq(true)); mtl.mtltx_qomr().modify(|w| w.set_ftq(true));
dma.dmactx_cr().modify(|w| w.set_st(true)); dma.dmactx_cr().modify(|w| w.set_st(true));
dma.dmacrx_cr().modify(|w| w.set_sr(true)); dma.dmacrx_cr().modify(|w| w.set_sr(true));
// Enable interrupts // Enable interrupts
dma.dmacier().modify(|w| { dma.dmacier().modify(|w| {
w.set_nie(true); w.set_nie(true);
w.set_rie(true); w.set_rie(true);
w.set_tie(true); w.set_tie(true);
}); });
}
}); });
P::phy_reset(this); P::phy_reset(&mut this);
P::phy_init(this); P::phy_init(&mut this);
this
} }
} }
@ -232,29 +229,17 @@ unsafe impl<'d, P: PHY, const TX: usize, const RX: usize> StationManagement
} }
} }
impl<'d, P: PHY, const TX: usize, const RX: usize> Device for Pin<&mut Ethernet<'d, P, TX, RX>> { impl<'d, P: PHY, const TX: usize, const RX: usize> Device for Ethernet<'d, P, TX, RX> {
fn is_transmit_ready(&mut self) -> bool { fn is_transmit_ready(&mut self) -> bool {
// NOTE(unsafe) We won't move out of self self.state.with(|s| s.desc_ring.tx.available())
let this = unsafe { self.as_mut().get_unchecked_mut() };
let mutex = unsafe { Pin::new_unchecked(&mut this.state) };
mutex.with(|s| s.desc_ring.tx.available())
} }
fn transmit(&mut self, pkt: PacketBuf) { fn transmit(&mut self, pkt: PacketBuf) {
// NOTE(unsafe) We won't move out of self self.state.with(|s| unwrap!(s.desc_ring.tx.transmit(pkt)));
let this = unsafe { self.as_mut().get_unchecked_mut() };
let mutex = unsafe { Pin::new_unchecked(&mut this.state) };
mutex.with(|s| unwrap!(s.desc_ring.tx.transmit(pkt)));
} }
fn receive(&mut self) -> Option<PacketBuf> { fn receive(&mut self) -> Option<PacketBuf> {
// NOTE(unsafe) We won't move out of self self.state.with(|s| s.desc_ring.rx.pop_packet())
let this = unsafe { self.as_mut().get_unchecked_mut() };
let mutex = unsafe { Pin::new_unchecked(&mut this.state) };
mutex.with(|s| s.desc_ring.rx.pop_packet())
} }
fn register_waker(&mut self, waker: &Waker) { fn register_waker(&mut self, waker: &Waker) {
@ -269,10 +254,7 @@ impl<'d, P: PHY, const TX: usize, const RX: usize> Device for Pin<&mut Ethernet<
} }
fn link_state(&mut self) -> LinkState { fn link_state(&mut self) -> LinkState {
// NOTE(unsafe) We won't move out of self if P::poll_link(self) {
let this = unsafe { self.as_mut().get_unchecked_mut() };
if P::poll_link(this) {
LinkState::Up LinkState::Up
} else { } else {
LinkState::Down LinkState::Down
@ -280,10 +262,7 @@ impl<'d, P: PHY, const TX: usize, const RX: usize> Device for Pin<&mut Ethernet<
} }
fn ethernet_address(&mut self) -> [u8; 6] { fn ethernet_address(&mut self) -> [u8; 6] {
// NOTE(unsafe) We won't move out of self self.mac_addr
let this = unsafe { self.as_mut().get_unchecked_mut() };
this.mac_addr
} }
} }

3
examples/nrf/src/bin/buffered_uart.rs
View File

@ -11,6 +11,7 @@ mod example_common;
use defmt::panic; use defmt::panic;
use embassy::executor::Spawner; use embassy::executor::Spawner;
use embassy::io::{AsyncBufReadExt, AsyncWriteExt}; use embassy::io::{AsyncBufReadExt, AsyncWriteExt};
use embassy_nrf::buffered_uarte::State;
use embassy_nrf::gpio::NoPin; use embassy_nrf::gpio::NoPin;
use embassy_nrf::{buffered_uarte::BufferedUarte, interrupt, uarte, Peripherals}; use embassy_nrf::{buffered_uarte::BufferedUarte, interrupt, uarte, Peripherals};
use example_common::*; use example_common::*;
@ -26,8 +27,10 @@ async fn main(_spawner: Spawner, p: Peripherals) {
let mut rx_buffer = [0u8; 4096]; let mut rx_buffer = [0u8; 4096];
let irq = interrupt::take!(UARTE0_UART0); let irq = interrupt::take!(UARTE0_UART0);
let mut state = State::new();
let u = unsafe { let u = unsafe {
BufferedUarte::new( BufferedUarte::new(
&mut state,
p.UARTE0, p.UARTE0,
p.TIMER0, p.TIMER0,
p.PPI_CH0, p.PPI_CH0,

24
examples/stm32h7/src/bin/eth.rs
View File

@ -6,7 +6,6 @@
#![feature(impl_trait_in_bindings)] #![feature(impl_trait_in_bindings)]
#![feature(type_alias_impl_trait)] #![feature(type_alias_impl_trait)]
use core::pin::Pin;
use core::sync::atomic::{AtomicUsize, Ordering}; use core::sync::atomic::{AtomicUsize, Ordering};
use cortex_m_rt::entry; use cortex_m_rt::entry;
@ -22,7 +21,7 @@ use embassy_net::{
}; };
use embassy_stm32::clock::{Alarm, Clock}; use embassy_stm32::clock::{Alarm, Clock};
use embassy_stm32::eth::lan8742a::LAN8742A; use embassy_stm32::eth::lan8742a::LAN8742A;
use embassy_stm32::eth::Ethernet; use embassy_stm32::eth::{Ethernet, State};
use embassy_stm32::rcc::{Config as RccConfig, Rcc}; use embassy_stm32::rcc::{Config as RccConfig, Rcc};
use embassy_stm32::rng::Random; use embassy_stm32::rng::Random;
use embassy_stm32::time::Hertz; use embassy_stm32::time::Hertz;
@ -42,7 +41,7 @@ defmt::timestamp! {"{=u64}", {
#[embassy::task] #[embassy::task]
async fn main_task( async fn main_task(
device: &'static mut Pin<&'static mut Ethernet<'static, LAN8742A, 4, 4>>, device: &'static mut Ethernet<'static, LAN8742A, 4, 4>,
config: &'static mut StaticConfigurator, config: &'static mut StaticConfigurator,
spawner: Spawner, spawner: Spawner,
) { ) {
@ -99,8 +98,8 @@ static mut RNG_INST: Option<Random<RNG>> = None;
static EXECUTOR: Forever<Executor> = Forever::new(); static EXECUTOR: Forever<Executor> = Forever::new();
static TIMER_RTC: Forever<Clock<TIM2>> = Forever::new(); static TIMER_RTC: Forever<Clock<TIM2>> = Forever::new();
static ALARM: Forever<Alarm<TIM2>> = Forever::new(); static ALARM: Forever<Alarm<TIM2>> = Forever::new();
static STATE: Forever<State<'static, 4, 4>> = Forever::new();
static ETH: Forever<Ethernet<'static, LAN8742A, 4, 4>> = Forever::new(); static ETH: Forever<Ethernet<'static, LAN8742A, 4, 4>> = Forever::new();
static DEVICE: Forever<Pin<&'static mut Ethernet<'static, LAN8742A, 4, 4>>> = Forever::new();
static CONFIG: Forever<StaticConfigurator> = Forever::new(); static CONFIG: Forever<StaticConfigurator> = Forever::new();
static NET_RESOURCES: Forever<StackResources<1, 2, 8>> = Forever::new(); static NET_RESOURCES: Forever<StackResources<1, 2, 8>> = Forever::new();
@ -135,14 +134,13 @@ fn main() -> ! {
let eth_int = interrupt_take!(ETH); let eth_int = interrupt_take!(ETH);
let mac_addr = [0x10; 6]; let mac_addr = [0x10; 6];
let eth = ETH.put(Ethernet::new( let state = STATE.put(State::new());
p.ETH, eth_int, p.PA1, p.PA2, p.PC1, p.PA7, p.PC4, p.PC5, p.PB12, p.PB13, p.PB11, LAN8742A, let eth = unsafe {
mac_addr, 1, ETH.put(Ethernet::new(
)); state, p.ETH, eth_int, p.PA1, p.PA2, p.PC1, p.PA7, p.PC4, p.PC5, p.PB12, p.PB13,
p.PB11, LAN8742A, mac_addr, 1,
// NOTE(unsafe) This thing is a &'static ))
let net_device = DEVICE.put(unsafe { Pin::new_unchecked(eth) }); };
net_device.as_mut().init();
let config = StaticConfigurator::new(NetConfig { let config = StaticConfigurator::new(NetConfig {
address: Ipv4Cidr::new(Ipv4Address::new(192, 168, 0, 61), 24), address: Ipv4Cidr::new(Ipv4Address::new(192, 168, 0, 61), 24),
@ -156,6 +154,6 @@ fn main() -> ! {
executor.set_alarm(alarm); executor.set_alarm(alarm);
executor.run(move |spawner| { executor.run(move |spawner| {
unwrap!(spawner.spawn(main_task(net_device, config, spawner))); unwrap!(spawner.spawn(main_task(eth, config, spawner)));
}) })
} }