embassy/embassy-nrf/src/gpiote.rs

428 lines
12 KiB
Rust
Raw Normal View History

2021-03-20 03:09:42 +01:00
use core::convert::Infallible;
use core::future::Future;
2021-03-20 03:09:42 +01:00
use core::marker::PhantomData;
use core::task::{Context, Poll};
2021-05-12 01:01:08 +02:00
use embassy::interrupt::{Interrupt, InterruptExt};
use embassy::traits::gpio::{WaitForAnyEdge, WaitForHigh, WaitForLow};
use embassy::waitqueue::AtomicWaker;
use embassy_hal_common::unsafe_impl_unborrow;
2021-03-27 16:13:32 +01:00
use embedded_hal::digital::v2::{InputPin, StatefulOutputPin};
use futures::future::poll_fn;
2020-09-23 00:32:49 +02:00
2021-03-20 03:09:42 +01:00
use crate::gpio::sealed::Pin as _;
use crate::gpio::{AnyPin, Input, Output, Pin as GpioPin};
use crate::pac;
2021-03-27 16:13:32 +01:00
use crate::ppi::{Event, Task};
2021-03-20 03:09:42 +01:00
use crate::{interrupt, peripherals};
2020-09-23 00:32:49 +02:00
2020-11-08 18:59:31 +01:00
pub const CHANNEL_COUNT: usize = 8;
#[cfg(any(feature = "nrf52833", feature = "nrf52840"))]
2020-11-08 18:59:31 +01:00
pub const PIN_COUNT: usize = 48;
#[cfg(not(any(feature = "nrf52833", feature = "nrf52840")))]
2020-11-08 18:59:31 +01:00
pub const PIN_COUNT: usize = 32;
2021-10-18 00:55:43 +02:00
#[allow(clippy::declare_interior_mutable_const)]
const NEW_AW: AtomicWaker = AtomicWaker::new();
static CHANNEL_WAKERS: [AtomicWaker; CHANNEL_COUNT] = [NEW_AW; CHANNEL_COUNT];
static PORT_WAKERS: [AtomicWaker; PIN_COUNT] = [NEW_AW; PIN_COUNT];
2020-11-08 17:38:45 +01:00
pub enum InputChannelPolarity {
2020-09-23 00:32:49 +02:00
None,
HiToLo,
LoToHi,
Toggle,
}
2020-09-29 19:18:52 +02:00
/// Polarity of the `task out` operation.
2020-11-08 17:38:45 +01:00
pub enum OutputChannelPolarity {
2020-09-29 19:18:52 +02:00
Set,
Clear,
Toggle,
}
pub(crate) fn init(irq_prio: crate::interrupt::Priority) {
#[cfg(any(feature = "nrf52833", feature = "nrf52840"))]
2021-10-12 11:43:57 +02:00
let ports = unsafe { &[&*pac::P0::ptr(), &*pac::P1::ptr()] };
#[cfg(not(any(feature = "nrf52833", feature = "nrf52840")))]
2021-10-12 11:43:57 +02:00
let ports = unsafe { &[&*pac::P0::ptr()] };
2021-03-20 03:09:42 +01:00
for &p in ports {
// Enable latched detection
p.detectmode.write(|w| w.detectmode().ldetect());
// Clear latch
p.latch.write(|w| unsafe { w.bits(0xFFFFFFFF) })
}
// Enable interrupts
2021-05-12 01:01:08 +02:00
2021-10-11 10:39:38 +02:00
#[cfg(not(feature = "nrf9160"))]
2021-05-12 01:01:08 +02:00
let irq = unsafe { interrupt::GPIOTE::steal() };
2021-10-11 10:39:38 +02:00
#[cfg(feature = "nrf9160")]
let irq = unsafe { interrupt::GPIOTE1::steal() };
2021-03-20 03:09:42 +01:00
irq.unpend();
irq.set_priority(irq_prio);
2021-03-20 03:09:42 +01:00
irq.enable();
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
2021-05-12 01:01:08 +02:00
g.events_port.write(|w| w);
g.intenset.write(|w| w.port().set());
}
2021-10-11 10:39:38 +02:00
#[cfg(not(feature = "nrf9160"))]
2021-05-12 01:01:08 +02:00
#[interrupt]
2021-10-11 10:39:38 +02:00
fn GPIOTE() {
unsafe { handle_gpiote_interrupt() };
}
#[cfg(feature = "nrf9160")]
#[interrupt]
fn GPIOTE1() {
unsafe { handle_gpiote_interrupt() };
}
unsafe fn handle_gpiote_interrupt() {
2021-10-12 11:43:57 +02:00
let g = &*pac::GPIOTE::ptr();
2020-11-08 18:59:31 +01:00
2021-03-20 03:09:42 +01:00
for i in 0..CHANNEL_COUNT {
if g.events_in[i].read().bits() != 0 {
g.intenclr.write(|w| unsafe { w.bits(1 << i) });
2021-03-20 03:09:42 +01:00
CHANNEL_WAKERS[i].wake();
2020-11-08 18:59:31 +01:00
}
2020-09-23 00:32:49 +02:00
}
2020-12-29 01:53:17 +01:00
2021-03-20 03:09:42 +01:00
if g.events_port.read().bits() != 0 {
g.events_port.write(|w| w);
2020-12-29 01:53:17 +01:00
#[cfg(any(feature = "nrf52833", feature = "nrf52840"))]
2021-10-12 11:43:57 +02:00
let ports = &[&*pac::P0::ptr(), &*pac::P1::ptr()];
#[cfg(not(any(feature = "nrf52833", feature = "nrf52840")))]
2021-10-12 11:43:57 +02:00
let ports = &[&*pac::P0::ptr()];
2020-12-29 01:53:17 +01:00
2021-03-20 03:09:42 +01:00
for (port, &p) in ports.iter().enumerate() {
let bits = p.latch.read().bits();
for pin in BitIter(bits) {
p.pin_cnf[pin as usize].modify(|_, w| w.sense().disabled());
PORT_WAKERS[port * 32 + pin as usize].wake();
2020-12-29 01:53:17 +01:00
}
2021-03-20 03:09:42 +01:00
p.latch.write(|w| w.bits(bits));
2020-12-29 01:53:17 +01:00
}
}
2020-09-23 00:32:49 +02:00
}
2021-03-20 03:09:42 +01:00
struct BitIter(u32);
2020-11-08 18:59:31 +01:00
2021-03-20 03:09:42 +01:00
impl Iterator for BitIter {
type Item = u32;
2020-11-08 18:59:31 +01:00
2021-03-20 03:09:42 +01:00
fn next(&mut self) -> Option<Self::Item> {
match self.0.trailing_zeros() {
32 => None,
b => {
self.0 &= !(1 << b);
Some(b)
}
}
}
2020-11-08 18:59:31 +01:00
}
2021-03-27 16:13:32 +01:00
/// GPIOTE channel driver in input mode
pub struct InputChannel<'d, C: Channel, T: GpioPin> {
ch: C,
pin: Input<'d, T>,
2020-09-23 00:32:49 +02:00
}
impl<'d, C: Channel, T: GpioPin> Drop for InputChannel<'d, C, T> {
2020-09-23 00:32:49 +02:00
fn drop(&mut self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
let num = self.ch.number();
g.config[num].write(|w| w.mode().disabled());
g.intenclr.write(|w| unsafe { w.bits(1 << num) });
2020-09-23 00:32:49 +02:00
}
}
impl<'d, C: Channel, T: GpioPin> InputChannel<'d, C, T> {
2021-05-12 01:01:08 +02:00
pub fn new(ch: C, pin: Input<'d, T>, polarity: InputChannelPolarity) -> Self {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
let num = ch.number();
g.config[num].write(|w| {
match polarity {
InputChannelPolarity::HiToLo => w.mode().event().polarity().hi_to_lo(),
InputChannelPolarity::LoToHi => w.mode().event().polarity().lo_to_hi(),
InputChannelPolarity::None => w.mode().event().polarity().none(),
InputChannelPolarity::Toggle => w.mode().event().polarity().toggle(),
};
#[cfg(any(feature = "nrf52833", feature = "nrf52840"))]
w.port().bit(match pin.pin.port() {
crate::gpio::Port::Port0 => false,
crate::gpio::Port::Port1 => true,
});
unsafe { w.psel().bits(pin.pin.pin()) }
});
g.events_in[num].reset();
InputChannel { ch, pin }
}
pub async fn wait(&self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
let num = self.ch.number();
// Enable interrupt
g.events_in[num].reset();
g.intenset.write(|w| unsafe { w.bits(1 << num) });
poll_fn(|cx| {
CHANNEL_WAKERS[num].register(cx.waker());
if g.events_in[num].read().bits() != 0 {
Poll::Ready(())
} else {
Poll::Pending
}
})
.await;
}
2021-03-27 16:13:32 +01:00
/// Returns the IN event, for use with PPI.
pub fn event_in(&self) -> Event {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
2021-03-27 16:13:32 +01:00
Event::from_reg(&g.events_in[self.ch.number()])
}
}
impl<'d, C: Channel, T: GpioPin> InputPin for InputChannel<'d, C, T> {
type Error = Infallible;
fn is_high(&self) -> Result<bool, Self::Error> {
self.pin.is_high()
2020-09-23 00:32:49 +02:00
}
fn is_low(&self) -> Result<bool, Self::Error> {
self.pin.is_low()
}
2020-09-23 00:32:49 +02:00
}
2021-03-27 16:13:32 +01:00
/// GPIOTE channel driver in output mode
pub struct OutputChannel<'d, C: Channel, T: GpioPin> {
ch: C,
2021-03-27 16:13:32 +01:00
_pin: Output<'d, T>,
2020-09-29 19:18:52 +02:00
}
impl<'d, C: Channel, T: GpioPin> Drop for OutputChannel<'d, C, T> {
2020-09-29 19:18:52 +02:00
fn drop(&mut self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
let num = self.ch.number();
g.config[num].write(|w| w.mode().disabled());
g.intenclr.write(|w| unsafe { w.bits(1 << num) });
2020-09-29 19:18:52 +02:00
}
}
impl<'d, C: Channel, T: GpioPin> OutputChannel<'d, C, T> {
2021-05-12 01:01:08 +02:00
pub fn new(ch: C, pin: Output<'d, T>, polarity: OutputChannelPolarity) -> Self {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
let num = ch.number();
g.config[num].write(|w| {
w.mode().task();
match pin.is_set_high().unwrap() {
true => w.outinit().high(),
false => w.outinit().low(),
};
match polarity {
OutputChannelPolarity::Set => w.polarity().lo_to_hi(),
OutputChannelPolarity::Clear => w.polarity().hi_to_lo(),
OutputChannelPolarity::Toggle => w.polarity().toggle(),
};
#[cfg(any(feature = "nrf52833", feature = "nrf52840"))]
w.port().bit(match pin.pin.port() {
crate::gpio::Port::Port0 => false,
crate::gpio::Port::Port1 => true,
});
unsafe { w.psel().bits(pin.pin.pin()) }
});
2021-03-27 16:13:32 +01:00
OutputChannel { ch, _pin: pin }
}
2020-09-29 19:18:52 +02:00
/// Triggers `task out` (as configured with task_out_polarity, defaults to Toggle).
pub fn out(&self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
g.tasks_out[self.ch.number()].write(|w| unsafe { w.bits(1) });
2020-09-29 19:18:52 +02:00
}
2020-09-29 19:18:52 +02:00
/// Triggers `task set` (set associated pin high).
#[cfg(not(feature = "nrf51"))]
2020-09-29 19:18:52 +02:00
pub fn set(&self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
g.tasks_set[self.ch.number()].write(|w| unsafe { w.bits(1) });
2020-09-29 19:18:52 +02:00
}
2020-09-29 19:18:52 +02:00
/// Triggers `task clear` (set associated pin low).
#[cfg(not(feature = "nrf51"))]
2020-09-29 19:18:52 +02:00
pub fn clear(&self) {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
g.tasks_clr[self.ch.number()].write(|w| unsafe { w.bits(1) });
2020-09-29 19:18:52 +02:00
}
2021-03-27 16:13:32 +01:00
/// Returns the OUT task, for use with PPI.
pub fn task_out(&self) -> Task {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
2021-03-27 16:13:32 +01:00
Task::from_reg(&g.tasks_out[self.ch.number()])
2020-09-29 19:18:52 +02:00
}
2021-03-27 16:13:32 +01:00
/// Returns the CLR task, for use with PPI.
#[cfg(not(feature = "nrf51"))]
2021-03-27 16:13:32 +01:00
pub fn task_clr(&self) -> Task {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
2021-03-27 16:13:32 +01:00
Task::from_reg(&g.tasks_clr[self.ch.number()])
2020-09-29 19:18:52 +02:00
}
2021-03-27 16:13:32 +01:00
/// Returns the SET task, for use with PPI.
#[cfg(not(feature = "nrf51"))]
2021-03-27 16:13:32 +01:00
pub fn task_set(&self) -> Task {
2021-10-12 11:43:57 +02:00
let g = unsafe { &*pac::GPIOTE::ptr() };
2021-03-27 16:13:32 +01:00
Task::from_reg(&g.tasks_set[self.ch.number()])
2020-09-29 19:18:52 +02:00
}
}
2021-03-27 16:13:32 +01:00
/// GPIOTE port input driver
2021-03-24 18:31:11 +01:00
pub struct PortInput<'d, T: GpioPin> {
pin: Input<'d, T>,
2021-03-20 03:09:42 +01:00
}
2020-11-08 18:59:31 +01:00
2021-03-24 18:31:11 +01:00
impl<'d, T: GpioPin> Unpin for PortInput<'d, T> {}
impl<'d, T: GpioPin> PortInput<'d, T> {
2021-05-12 01:01:08 +02:00
pub fn new(pin: Input<'d, T>) -> Self {
2021-03-20 03:09:42 +01:00
Self { pin }
2020-09-23 00:32:49 +02:00
}
}
2021-03-24 18:31:11 +01:00
impl<'d, T: GpioPin> InputPin for PortInput<'d, T> {
2021-03-20 03:09:42 +01:00
type Error = Infallible;
2021-03-20 03:09:42 +01:00
fn is_high(&self) -> Result<bool, Self::Error> {
self.pin.is_high()
}
2021-03-20 03:09:42 +01:00
fn is_low(&self) -> Result<bool, Self::Error> {
self.pin.is_low()
}
}
2021-03-24 18:31:11 +01:00
impl<'d, T: GpioPin> WaitForHigh for PortInput<'d, T> {
2021-03-20 03:09:42 +01:00
type Future<'a> = PortInputFuture<'a>;
2021-04-14 16:25:54 +02:00
fn wait_for_high<'a>(&'a mut self) -> Self::Future<'a> {
2021-03-20 03:09:42 +01:00
self.pin.pin.conf().modify(|_, w| w.sense().high());
PortInputFuture {
2021-03-20 03:09:42 +01:00
pin_port: self.pin.pin.pin_port(),
phantom: PhantomData,
}
}
}
2021-03-24 18:31:11 +01:00
impl<'d, T: GpioPin> WaitForLow for PortInput<'d, T> {
2021-03-20 03:09:42 +01:00
type Future<'a> = PortInputFuture<'a>;
2021-04-14 16:25:54 +02:00
fn wait_for_low<'a>(&'a mut self) -> Self::Future<'a> {
2021-03-20 03:09:42 +01:00
self.pin.pin.conf().modify(|_, w| w.sense().low());
PortInputFuture {
2021-03-20 03:09:42 +01:00
pin_port: self.pin.pin.pin_port(),
phantom: PhantomData,
}
}
}
impl<'d, T: GpioPin> WaitForAnyEdge for PortInput<'d, T> {
type Future<'a> = PortInputFuture<'a>;
fn wait_for_any_edge<'a>(&'a mut self) -> Self::Future<'a> {
if self.is_high().ok().unwrap() {
self.pin.pin.conf().modify(|_, w| w.sense().low());
} else {
self.pin.pin.conf().modify(|_, w| w.sense().high());
}
PortInputFuture {
pin_port: self.pin.pin.pin_port(),
phantom: PhantomData,
}
}
}
2021-03-20 03:09:42 +01:00
pub struct PortInputFuture<'a> {
pin_port: u8,
phantom: PhantomData<&'a mut AnyPin>,
}
2021-03-20 03:09:42 +01:00
impl<'a> Drop for PortInputFuture<'a> {
fn drop(&mut self) {
let pin = unsafe { AnyPin::steal(self.pin_port) };
pin.conf().modify(|_, w| w.sense().disabled());
}
}
2021-03-20 03:09:42 +01:00
impl<'a> Future for PortInputFuture<'a> {
type Output = ();
fn poll(self: core::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
2021-03-20 03:09:42 +01:00
PORT_WAKERS[self.pin_port as usize].register(cx.waker());
let pin = unsafe { AnyPin::steal(self.pin_port) };
if pin.conf().read().sense().is_disabled() {
Poll::Ready(())
} else {
Poll::Pending
}
}
}
mod sealed {
pub trait Channel {}
}
pub trait Channel: sealed::Channel + Sized {
fn number(&self) -> usize;
fn degrade(self) -> AnyChannel {
AnyChannel {
number: self.number() as u8,
}
}
}
pub struct AnyChannel {
number: u8,
}
2021-05-19 23:21:31 +02:00
unsafe_impl_unborrow!(AnyChannel);
impl sealed::Channel for AnyChannel {}
impl Channel for AnyChannel {
fn number(&self) -> usize {
self.number as usize
}
}
macro_rules! impl_channel {
($type:ident, $number:expr) => {
impl sealed::Channel for peripherals::$type {}
impl Channel for peripherals::$type {
fn number(&self) -> usize {
$number as usize
}
}
};
}
impl_channel!(GPIOTE_CH0, 0);
impl_channel!(GPIOTE_CH1, 1);
impl_channel!(GPIOTE_CH2, 2);
impl_channel!(GPIOTE_CH3, 3);
impl_channel!(GPIOTE_CH4, 4);
impl_channel!(GPIOTE_CH5, 5);
impl_channel!(GPIOTE_CH6, 6);
impl_channel!(GPIOTE_CH7, 7);