319 lines
9.0 KiB
Rust
319 lines
9.0 KiB
Rust
|
#![macro_use]
|
||
|
|
|
||
|
|
//! HAL interface for the PPI and DPPI peripheral.
|
||
|
|
//!
|
||
|
|
//! The (Distributed) Programmable Peripheral Interconnect interface allows for an autonomous interoperability
|
||
|
|
//! between peripherals through their events and tasks. There are fixed PPI channels and fully
|
||
|
|
//! configurable ones. Fixed channels can only connect specific events to specific tasks. For fully
|
||
|
|
//! configurable channels, it is possible to choose, via software, the event and the task that it
|
||
|
|
//! will triggered by the event.
|
||
|
|
//!
|
||
|
|
//! On nRF52 devices, there is also a fork task endpoint, where the user can configure one more task
|
||
|
|
//! to be triggered by the same event, even fixed PPI channels have a configurable fork task.
|
||
|
|
//!
|
||
|
|
//! The DPPI for nRF53 and nRF91 devices works in a different way. Every channel can support infinitely
|
||
|
|
//! many tasks and events, but any single task or event can only be coupled with one channel.
|
||
|
|
//!
|
||
|
|
|
||
|
|
use crate::{pac, peripherals};
|
||
|
|
use core::marker::PhantomData;
|
||
|
|
use core::ptr::NonNull;
|
||
|
|
use embassy::util::Unborrow;
|
||
|
|
use embassy_hal_common::{unborrow, unsafe_impl_unborrow};
|
||
|
|
|
||
|
|
#[cfg(feature = "_dppi")]
|
||
|
|
mod dppi;
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
mod ppi;
|
||
|
|
|
||
|
|
pub struct Ppi<'d, C: Channel, const EVENT_COUNT: usize, const TASK_COUNT: usize> {
|
||
|
|
ch: C,
|
||
|
|
events: [Event; EVENT_COUNT],
|
||
|
|
tasks: [Task; TASK_COUNT],
|
||
|
|
phantom: PhantomData<&'d mut C>,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: Channel, const EVENT_COUNT: usize, const TASK_COUNT: usize>
|
||
|
|
Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
|
||
|
|
{
|
||
|
|
pub fn degrade(self) -> Ppi<'d, AnyChannel, EVENT_COUNT, TASK_COUNT> {
|
||
|
|
Ppi {
|
||
|
|
ch: AnyChannel {
|
||
|
|
number: self.ch.number() as u8,
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
has_configurable_task: self.ch.is_task_configurable(),
|
||
|
|
},
|
||
|
|
events: self.events,
|
||
|
|
tasks: self.tasks,
|
||
|
|
phantom: PhantomData,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Enables the channel.
|
||
|
|
pub fn enable(&mut self) {
|
||
|
|
let r = unsafe { &*pac::PPI::ptr() };
|
||
|
|
r.chenset
|
||
|
|
.write(|w| unsafe { w.bits(1 << self.ch.number()) });
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Disables the channel.
|
||
|
|
pub fn disable(&mut self) {
|
||
|
|
let r = unsafe { &*pac::PPI::ptr() };
|
||
|
|
r.chenclr
|
||
|
|
.write(|w| unsafe { w.bits(1 << self.ch.number()) });
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Enables all tasks and events
|
||
|
|
fn enable_all(&self) {
|
||
|
|
for (index, task) in self.tasks.iter().enumerate() {
|
||
|
|
Self::enable_task(task, &self.ch, index);
|
||
|
|
}
|
||
|
|
for (index, event) in self.events.iter().enumerate() {
|
||
|
|
Self::enable_event(event, &self.ch, index);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Disable all tasks and events
|
||
|
|
fn disable_all(&self) {
|
||
|
|
for (index, task) in self.tasks.iter().enumerate() {
|
||
|
|
Self::disable_task(task, &self.ch, index);
|
||
|
|
}
|
||
|
|
for (index, event) in self.events.iter().enumerate() {
|
||
|
|
Self::disable_event(event, &self.ch, index);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: Channel, const EVENT_COUNT: usize, const TASK_COUNT: usize> Drop
|
||
|
|
for Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
|
||
|
|
{
|
||
|
|
fn drop(&mut self) {
|
||
|
|
self.disable();
|
||
|
|
self.disable_all();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: StaticToOneChannel> Ppi<'d, C, 0, 1> {
|
||
|
|
pub fn new_static_to_one(ch: impl Unborrow<Target = C> + 'd, task: Task) -> Self {
|
||
|
|
unborrow!(ch);
|
||
|
|
|
||
|
|
let s = Self {
|
||
|
|
ch,
|
||
|
|
events: [],
|
||
|
|
tasks: [task],
|
||
|
|
phantom: PhantomData,
|
||
|
|
};
|
||
|
|
|
||
|
|
s.enable_all();
|
||
|
|
s
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: OneToOneChannel> Ppi<'d, C, 1, 1> {
|
||
|
|
pub fn new_one_to_one(ch: impl Unborrow<Target = C> + 'd, event: Event, task: Task) -> Self {
|
||
|
|
unborrow!(ch);
|
||
|
|
|
||
|
|
let s = Self {
|
||
|
|
ch,
|
||
|
|
events: [event],
|
||
|
|
tasks: [task],
|
||
|
|
phantom: PhantomData,
|
||
|
|
};
|
||
|
|
|
||
|
|
s.enable_all();
|
||
|
|
s
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: OneToTwoChannel> Ppi<'d, C, 1, 2> {
|
||
|
|
pub fn new_one_to_two(
|
||
|
|
ch: impl Unborrow<Target = C> + 'd,
|
||
|
|
event: Event,
|
||
|
|
task1: Task,
|
||
|
|
task2: Task,
|
||
|
|
) -> Self {
|
||
|
|
unborrow!(ch);
|
||
|
|
|
||
|
|
let s = Self {
|
||
|
|
ch,
|
||
|
|
events: [event],
|
||
|
|
tasks: [task1, task2],
|
||
|
|
phantom: PhantomData,
|
||
|
|
};
|
||
|
|
|
||
|
|
s.enable_all();
|
||
|
|
s
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'d, C: ManyToManyChannel, const EVENT_COUNT: usize, const TASK_COUNT: usize>
|
||
|
|
Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
|
||
|
|
{
|
||
|
|
pub fn new_many_to_many(
|
||
|
|
ch: impl Unborrow<Target = C> + 'd,
|
||
|
|
events: [Event; EVENT_COUNT],
|
||
|
|
tasks: [Task; TASK_COUNT],
|
||
|
|
) -> Self {
|
||
|
|
unborrow!(ch);
|
||
|
|
|
||
|
|
let s = Self {
|
||
|
|
ch,
|
||
|
|
events,
|
||
|
|
tasks,
|
||
|
|
phantom: PhantomData,
|
||
|
|
};
|
||
|
|
|
||
|
|
s.enable_all();
|
||
|
|
s
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Represents a task that a peripheral can do.
|
||
|
|
/// When a task is subscribed to a PPI channel it will run when the channel is triggered by
|
||
|
|
/// a published event.
|
||
|
|
///
|
||
|
|
/// The pointer is to a task register
|
||
|
|
#[derive(PartialEq, Eq, Clone, Copy)]
|
||
|
|
pub struct Task(pub NonNull<u32>);
|
||
|
|
impl Task {
|
||
|
|
pub(crate) fn from_reg<T>(reg: &T) -> Self {
|
||
|
|
Self(unsafe { NonNull::new_unchecked(reg as *const _ as *mut _) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// # Safety
|
||
|
|
///
|
||
|
|
/// NonNull is not send, but this event is only allowed to point at registers and those exist in any context on the same core.
|
||
|
|
unsafe impl Send for Task {}
|
||
|
|
|
||
|
|
/// Represents an event that a peripheral can publish.
|
||
|
|
/// An event can be set to publish on a PPI channel when the event happens.
|
||
|
|
///
|
||
|
|
/// The pointer is to an event register
|
||
|
|
#[derive(PartialEq, Eq, Clone, Copy)]
|
||
|
|
pub struct Event(pub NonNull<u32>);
|
||
|
|
impl Event {
|
||
|
|
pub(crate) fn from_reg<T>(reg: &T) -> Self {
|
||
|
|
Self(unsafe { NonNull::new_unchecked(reg as *const _ as *mut _) })
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// # Safety
|
||
|
|
///
|
||
|
|
/// NonNull is not send, but this event is only allowed to point at registers and those exist in any context on the same core.
|
||
|
|
unsafe impl Send for Event {}
|
||
|
|
|
||
|
|
// ======================
|
||
|
|
// traits
|
||
|
|
|
||
|
|
pub(crate) mod sealed {
|
||
|
|
pub trait Channel {}
|
||
|
|
pub trait Group {}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub trait Channel: sealed::Channel + Unborrow<Target = Self> + Sized {
|
||
|
|
/// Returns the number of the channel
|
||
|
|
fn number(&self) -> usize;
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
fn is_task_configurable(&self) -> bool;
|
||
|
|
}
|
||
|
|
|
||
|
|
pub trait StaticToOneChannel: Channel {}
|
||
|
|
pub trait OneToOneChannel: StaticToOneChannel {}
|
||
|
|
pub trait OneToTwoChannel: OneToOneChannel {}
|
||
|
|
pub trait ManyToManyChannel: OneToTwoChannel {}
|
||
|
|
|
||
|
|
pub trait Group: sealed::Group + Sized {
|
||
|
|
fn number(&self) -> usize;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ======================
|
||
|
|
// channels
|
||
|
|
|
||
|
|
pub struct AnyChannel {
|
||
|
|
number: u8,
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
has_configurable_task: bool,
|
||
|
|
}
|
||
|
|
unsafe_impl_unborrow!(AnyChannel);
|
||
|
|
impl sealed::Channel for AnyChannel {}
|
||
|
|
impl Channel for AnyChannel {
|
||
|
|
fn number(&self) -> usize {
|
||
|
|
self.number as usize
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
fn is_task_configurable(&self) -> bool {
|
||
|
|
self.has_configurable_task
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
macro_rules! impl_ppi_channel {
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr) => {
|
||
|
|
impl crate::interconnect::sealed::Channel for peripherals::$type {}
|
||
|
|
impl crate::interconnect::Channel for peripherals::$type {
|
||
|
|
fn number(&self) -> usize {
|
||
|
|
$number
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "_ppi")]
|
||
|
|
fn is_task_configurable(&self) -> bool {
|
||
|
|
$has_configurable_task
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr, 0, 0) => {
|
||
|
|
impl_ppi_channel!($type, $number, $has_configurable_task);
|
||
|
|
};
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr, 0, 1) => {
|
||
|
|
impl_ppi_channel!($type, $number, $has_configurable_task, 0, 0);
|
||
|
|
impl crate::interconnect::StaticToOneChannel for peripherals::$type {}
|
||
|
|
};
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr, 1, 1) => {
|
||
|
|
impl_ppi_channel!($type, $number, $has_configurable_task, 0, 1);
|
||
|
|
impl crate::interconnect::OneToOneChannel for peripherals::$type {}
|
||
|
|
};
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr, 1, 2) => {
|
||
|
|
impl_ppi_channel!($type, $number, $has_configurable_task, 1, 1);
|
||
|
|
impl crate::interconnect::OneToTwoChannel for peripherals::$type {}
|
||
|
|
};
|
||
|
|
($type:ident, $number:expr, $has_configurable_task:expr, many, many) => {
|
||
|
|
impl_ppi_channel!($type, $number, $has_configurable_task, 1, 2);
|
||
|
|
impl crate::interconnect::ManyToManyChannel for peripherals::$type {}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// ======================
|
||
|
|
// groups
|
||
|
|
|
||
|
|
pub struct AnyGroup {
|
||
|
|
number: u8,
|
||
|
|
}
|
||
|
|
unsafe_impl_unborrow!(AnyGroup);
|
||
|
|
impl sealed::Group for AnyGroup {}
|
||
|
|
impl Group for AnyGroup {
|
||
|
|
fn number(&self) -> usize {
|
||
|
|
self.number as usize
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
macro_rules! impl_group {
|
||
|
|
($type:ident, $number:expr) => {
|
||
|
|
impl sealed::Group for peripherals::$type {}
|
||
|
|
impl Group for peripherals::$type {
|
||
|
|
fn number(&self) -> usize {
|
||
|
|
$number
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
impl_group!(PPI_GROUP0, 0);
|
||
|
|
impl_group!(PPI_GROUP1, 1);
|
||
|
|
impl_group!(PPI_GROUP2, 2);
|
||
|
|
impl_group!(PPI_GROUP3, 3);
|
||
|
|
#[cfg(not(feature = "nrf51"))]
|
||
|
|
impl_group!(PPI_GROUP4, 4);
|
||
|
|
#[cfg(not(feature = "nrf51"))]
|
||
|
|
impl_group!(PPI_GROUP5, 5);
|