- Interconnect is now PPI again

- Scary pointer math is now contained in the tasks and events
- ppi now sets the tasks and events immediately and the struct is now zero-sized
- StaticToOne is renamed to ZeroToOne
- Used DPPI tasks and events now panic when enabled twice

3 files changed, 463 insertions, 0 deletions

diff --git a/embassy-nrf/src/ppi/dppi.rs b/embassy-nrf/src/ppi/dppi.rs
new file mode 100644
index 000000000..083ec858a
--- /dev/null
+++ b/embassy-nrf/src/ppi/dppi.rs
@@ -0,0 +1,61 @@
+use super::{Channel, Event, Ppi, Task};
+
+const DPPI_ENABLE_BIT: u32 = 0x8000_0000;
+const DPPI_CHANNEL_MASK: u32 = 0x0000_00FF;
+
+impl<'d, C: Channel + 'd, const EVENT_COUNT: usize, const TASK_COUNT: usize>
+    Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
+{
+    pub(super) fn enable_task(task: &Task, channel: &C, _index: usize) {
+        unsafe {
+            if task.subscribe_reg().read_volatile() != 0 {
+                panic!("Task is already in use");
+            }
+            task.subscribe_reg()
+                .write_volatile(DPPI_ENABLE_BIT | (channel.number() as u32 & DPPI_CHANNEL_MASK));
+        }
+    }
+
+    pub(super) fn disable_task(task: &Task, _channel: &C, _index: usize) {
+        unsafe {
+            task.subscribe_reg().write_volatile(0);
+        }
+    }
+
+    pub(super) fn enable_event(event: &Event, channel: &C, _index: usize) {
+        unsafe {
+            if event.publish_reg().read_volatile() != 0 {
+                panic!("Task is already in use");
+            }
+            event
+                .publish_reg()
+                .write_volatile(DPPI_ENABLE_BIT | (channel.number() as u32 & DPPI_CHANNEL_MASK));
+        }
+    }
+
+    pub(super) fn disable_event(event: &Event, _channel: &C, _index: usize) {
+        unsafe {
+            event.publish_reg().write_volatile(0);
+        }
+    }
+
+    /// Enables all tasks and events
+    pub(super) fn enable_all(tasks: &[Task], events: &[Event], channel: &C) {
+        for (index, task) in tasks.iter().enumerate() {
+            Self::enable_task(task, channel, index);
+        }
+        for (index, event) in events.iter().enumerate() {
+            Self::enable_event(event, channel, index);
+        }
+    }
+
+    /// Disable all tasks and events
+    pub(super) 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);
+        }
+    }
+}
diff --git a/embassy-nrf/src/ppi/mod.rs b/embassy-nrf/src/ppi/mod.rs
new file mode 100644
index 000000000..ffb6af020
--- /dev/null
+++ b/embassy-nrf/src/ppi/mod.rs
@@ -0,0 +1,325 @@
+#![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,
+    #[cfg(feature = "_dppi")]
+    events: [Event; EVENT_COUNT],
+    #[cfg(feature = "_dppi")]
+    tasks: [Task; TASK_COUNT],
+    phantom: PhantomData<&'d mut C>,
+}
+
+impl<'d, C: Channel + 'd, 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(),
+            },
+            #[cfg(feature = "_dppi")]
+            events: self.events,
+            #[cfg(feature = "_dppi")]
+            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()) });
+    }
+}
+
+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: ZeroToOneChannel> Ppi<'d, C, 0, 1> {
+    pub fn new_static_to_one(ch: impl Unborrow<Target = C> + 'd, task: Task) -> Self {
+        unborrow!(ch);
+
+        let events = [];
+        let tasks = [task];
+
+        Self::enable_all(&tasks, &events, &ch);
+
+        Self {
+            ch,
+            #[cfg(feature = "_dppi")]
+            events,
+            #[cfg(feature = "_dppi")]
+            tasks,
+            phantom: PhantomData,
+        }
+    }
+}
+
+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 events = [event];
+        let tasks = [task];
+
+        Self::enable_all(&tasks, &events, &ch);
+
+        Self {
+            ch,
+            #[cfg(feature = "_dppi")]
+            events,
+            #[cfg(feature = "_dppi")]
+            tasks,
+            phantom: PhantomData,
+        }
+    }
+}
+
+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 events = [event];
+        let tasks = [task1, task2];
+
+        Self::enable_all(&tasks, &events, &ch);
+
+        Self {
+            ch,
+            #[cfg(feature = "_dppi")]
+            events,
+            #[cfg(feature = "_dppi")]
+            tasks,
+            phantom: PhantomData,
+        }
+    }
+}
+
+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);
+
+        Self::enable_all(&tasks, &events, &ch);
+
+        Self {
+            ch,
+            #[cfg(feature = "_dppi")]
+            events,
+            #[cfg(feature = "_dppi")]
+            tasks,
+            phantom: PhantomData,
+        }
+    }
+}
+
+const REGISTER_DPPI_CONFIG_OFFSET: usize = 0x80 / core::mem::size_of::<u32>();
+
+/// 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 _) })
+    }
+
+    pub fn subscribe_reg(&self) -> *mut u32 {
+        unsafe { self.0.as_ptr().add(REGISTER_DPPI_CONFIG_OFFSET) }
+    }
+}
+
+/// # 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 _) })
+    }
+
+    pub fn publish_reg(&self) -> *mut u32 {
+        unsafe { self.0.as_ptr().add(REGISTER_DPPI_CONFIG_OFFSET) }
+    }
+}
+
+/// # 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 ZeroToOneChannel: Channel {}
+pub trait OneToOneChannel: ZeroToOneChannel {}
+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::ppi::sealed::Channel for peripherals::$type {}
+        impl crate::ppi::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::ppi::ZeroToOneChannel 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::ppi::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::ppi::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::ppi::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);
diff --git a/embassy-nrf/src/ppi/ppi.rs b/embassy-nrf/src/ppi/ppi.rs
new file mode 100644
index 000000000..67d2086c3
--- /dev/null
+++ b/embassy-nrf/src/ppi/ppi.rs
@@ -0,0 +1,77 @@
+use super::{Channel, Event, Ppi, Task};
+use crate::pac;
+
+impl<'d, C: Channel + 'd, const EVENT_COUNT: usize, const TASK_COUNT: usize>
+    Ppi<'d, C, EVENT_COUNT, TASK_COUNT>
+{
+    fn set_main_task(task: Option<&Task>, channel: usize) {
+        let r = unsafe { &*pac::PPI::ptr() };
+        if let Some(task) = task {
+            r.ch[channel]
+                .tep
+                .write(|w| unsafe { w.bits(task.0.as_ptr() as u32) })
+        } else {
+            r.ch[channel].tep.write(|w| unsafe { w.bits(0) })
+        }
+    }
+
+    fn set_fork_task(task: Option<&Task>, channel: usize) {
+        let r = unsafe { &*pac::PPI::ptr() };
+        if let Some(task) = task {
+            r.fork[channel]
+                .tep
+                .write(|w| unsafe { w.bits(task.0.as_ptr() as u32) })
+        } else {
+            r.fork[channel].tep.write(|w| unsafe { w.bits(0) })
+        }
+    }
+
+    fn set_event(event: Option<&Event>, channel: usize) {
+        let r = unsafe { &*pac::PPI::ptr() };
+        if let Some(event) = event {
+            r.ch[channel]
+                .eep
+                .write(|w| unsafe { w.bits(event.0.as_ptr() as u32) })
+        } else {
+            r.ch[channel].eep.write(|w| unsafe { w.bits(0) })
+        }
+    }
+
+    /// Enables all tasks and events
+    pub(super) fn enable_all(tasks: &[Task], events: &[Event], channel: &C) {
+        // One configurable task, no fork
+        if channel.is_task_configurable() && TASK_COUNT == 1 {
+            Self::set_main_task(Some(&tasks[0]), channel.number());
+        }
+
+        // One configurable task, as fork
+        if !channel.is_task_configurable() && TASK_COUNT == 1 {
+            Self::set_fork_task(Some(&tasks[0]), channel.number());
+        }
+
+        // Two configurable tasks (main + fork)
+        if TASK_COUNT == 2 {
+            Self::set_main_task(Some(&tasks[0]), channel.number());
+            Self::set_fork_task(Some(&tasks[1]), channel.number());
+        }
+
+        if EVENT_COUNT == 1 {
+            Self::set_event(Some(&events[0]), channel.number());
+        }
+    }
+
+    /// Disable all tasks and events
+    pub(super) fn disable_all(&self) {
+        if self.ch.is_task_configurable() {
+            Self::set_main_task(None, self.ch.number());
+        }
+
+        if TASK_COUNT == 1 && !self.ch.is_task_configurable() || TASK_COUNT == 2 {
+            Self::set_fork_task(None, self.ch.number());
+        }
+
+        if EVENT_COUNT == 1 {
+            Self::set_event(None, self.ch.number());
+        }
+    }
+}