Refactor Edge interrupt handling

Author: martinsp

rp2040-hal/src/gpio/pin/non_blocking.rs

@@ -3,7 +3,7 @@ use crate::{
         sealed::{IrqWaker, Wakeable},
         AsyncPeripheral, CancellablePollFn as CPFn,
     },
-    atomic_register_access::write_bitmask_clear,
+    atomic_register_access::{write_bitmask_clear, write_bitmask_set},
     gpio::{
         func::{FunctionSio, SioConfig},
         pin::pin_sealed::{PinIdOps, TypeLevelPinId},
@@ -14,6 +14,8 @@ use crate::{
 use core::task::Poll;
 use embedded_hal_async::digital::Wait;
 
+const EDGE_INTERRUPTS_MASK: u32 = Interrupt::EdgeLow.mask() | Interrupt::EdgeHigh.mask();
+
 impl<I, P, S> AsyncPeripheral for Pin<I, FunctionSio<S>, P>
 where
     I: PinId + TypeLevelPinId,
@@ -27,9 +29,6 @@ where
             | Interrupt::EdgeLow.mask()
             | Interrupt::EdgeHigh.mask();
 
-        // Level interrupts are not latched and can't be cleared
-        const CLEAR_INTERRUPTS_MASK: u32 = Interrupt::EdgeLow.mask() | Interrupt::EdgeHigh.mask();
-
         let pin_id = I::ID;
 
         let (ints_reg, ints_offset) = pin_id.proc_ints(Sio::core());
@@ -43,9 +42,8 @@ where
                 write_bitmask_clear(inte_reg.as_ptr(), INTERRUPTS_MASK << inte_offset);
             }
 
-            // Clear interrupts for Pin
-            let (intr_reg, intr_offset) = pin_id.intr();
-            intr_reg.write(|w| unsafe { w.bits(CLEAR_INTERRUPTS_MASK << intr_offset) });
+            // Don't need to clear any interrupts here. Level interrupts are not latched,
+            // Edge interrupts are cleared in the relevant poll functions
 
             Self::waker().wake();
         }
@@ -85,6 +83,42 @@ where
         }
     }
 
+    fn poll_rising_edge(&mut self) -> Poll<Result<(), Error>> {
+        // read raw interrupt status, because interrupt is disabled in on_interrupt(), but is not cleared
+        if self.raw_interrupt_status(Interrupt::EdgeHigh) {
+            self.clear_interrupt(Interrupt::EdgeHigh);
+
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn poll_falling_edge(&mut self) -> Poll<Result<(), Error>> {
+        // read raw interrupt status, because interrupt is disabled in on_interrupt(), but is not cleared
+        if self.raw_interrupt_status(Interrupt::EdgeLow) {
+            self.clear_interrupt(Interrupt::EdgeLow);
+
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn poll_any_edge(&mut self) -> Poll<Result<(), Error>> {
+        // read raw interrupt status, because interrupt is disabled in on_interrupt(), but is not cleared
+        let (reg, offset) = self.id.intr();
+        let bits = reg.read().bits() >> offset;
+
+        if bits & EDGE_INTERRUPTS_MASK != 0 {
+            reg.write(|w| unsafe { w.bits(EDGE_INTERRUPTS_MASK << offset) });
+
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
     fn disable_level_high_irq(&mut self) {
         self.set_interrupt_enabled(Interrupt::LevelHigh, false);
     }
@@ -117,6 +151,26 @@ where
         self.set_interrupt_enabled(Interrupt::EdgeLow, true)
     }
 
+    fn disable_any_edge_irq(&mut self) {
+        let (reg, offset) = self.id.proc_inte(Sio::core());
+        unsafe {
+            write_bitmask_clear(reg.as_ptr(), EDGE_INTERRUPTS_MASK << offset);
+        }
+    }
+
+    fn enable_any_edge_irq(&mut self) {
+        let (reg, offset) = self.id.proc_inte(Sio::core());
+        unsafe {
+            write_bitmask_set(reg.as_ptr(), EDGE_INTERRUPTS_MASK << offset);
+        }
+    }
+
+    fn raw_interrupt_status(&self, interrupt: Interrupt) -> bool {
+        let (reg, offset) = self.id.intr();
+        let mask = interrupt.mask();
+        (reg.read().bits() >> offset) & mask == mask
+    }
+
     async fn _wait_for_high(&mut self) {
         let _ = CPFn::new(
             self,
@@ -138,39 +192,33 @@ where
     }
 
     async fn _wait_for_rising_edge(&mut self) {
-        if self._is_high() {
-            self._wait_for_low().await;
-        }
-
         let _ = CPFn::new(
             self,
-            Self::poll_is_high,
+            Self::poll_rising_edge,
             Self::enable_rising_edge_irq,
             Self::disable_rising_edge_irq,
         )
         .await;
     }
 
     async fn _wait_for_falling_edge(&mut self) {
-        if self._is_low() {
-            self._wait_for_high().await;
-        }
-
         let _ = CPFn::new(
             self,
-            Self::poll_is_high,
+            Self::poll_falling_edge,
             Self::enable_falling_edge_irq,
             Self::disable_falling_edge_irq,
         )
         .await;
     }
 
     async fn _wait_for_any_edge(&mut self) {
-        if self._is_high() {
-            self._wait_for_falling_edge().await;
-        } else {
-            self._wait_for_rising_edge().await;
-        }
+        let _ = CPFn::new(
+            self,
+            Self::poll_any_edge,
+            Self::enable_any_edge_irq,
+            Self::disable_any_edge_irq,
+        )
+        .await;
     }
 }