zephyr: device: gpio: Implementing wait for low

The api allows for either waiting for high or low.  This somewhat works,
but seems to lock up after a few times.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

tests/drivers/gpio-async/src/lib.rs

@@ -5,7 +5,6 @@
 
 extern crate alloc;
 
-use embassy_time::{Duration, Timer};
 use zephyr::{embassy::Executor, raw::{GPIO_INPUT, GPIO_OUTPUT_ACTIVE, GPIO_PULL_DOWN}};
 
 use embassy_executor::Spawner;
@@ -41,21 +40,10 @@ async fn main(spawner: Spawner) {
         row0.configure(&mut gpio_token, GPIO_INPUT | GPIO_PULL_DOWN);
     }
 
-    let mut last = false;
-
     loop {
-        let current = unsafe { row0.get(&mut gpio_token) };
-        // info!("Current: {:?}", current);
-        if current != last {
-            if current {
-                info!("Pressed");
-            } else {
-                info!("Released: Waiting for high");
-                unsafe { row0.wait_for_high(&mut gpio_token).await };
-            }
-            last = current;
-        }
-
-        Timer::after(Duration::from_millis(25)).await;
+        unsafe { row0.wait_for_high(&mut gpio_token).await };
+        info!("Pressed");
+        unsafe { row0.wait_for_low(&mut gpio_token).await };
+        info!("Released");
     }
 }

zephyr/src/device/gpio.rs

@@ -20,11 +20,13 @@ mod async_io {
     //! the largest number currently used, although this might change with 64-bit targest in the
     //! future.
 
-    use core::{cell::UnsafeCell, future::Future, mem, sync::atomic::Ordering, task::{Poll, Waker}};
+    use core::{cell::UnsafeCell, ffi::c_int, future::Future, mem, sync::atomic::Ordering, task::{Poll, Waker}};
 
     use embassy_sync::waitqueue::AtomicWaker;
     use portable_atomic::AtomicBool;
-    use zephyr_sys::{device, gpio_add_callback, gpio_callback, gpio_init_callback, gpio_pin_get, gpio_pin_interrupt_configure, gpio_pin_interrupt_configure_dt, gpio_port_pins_t, GPIO_INT_LEVEL_HIGH, ZR_GPIO_INT_MODE_DISABLE_ONLY};
+    use zephyr_sys::{device, gpio_add_callback, gpio_callback, gpio_init_callback, gpio_pin_get, gpio_pin_interrupt_configure, gpio_pin_interrupt_configure_dt, gpio_port_pins_t, GPIO_INT_LEVEL_HIGH, GPIO_INT_LEVEL_LOW, ZR_GPIO_INT_MODE_DISABLE_ONLY};
+
+    use crate::printkln;
 
     use super::{GpioPin, GpioToken};
 
@@ -135,19 +137,31 @@ mod async_io {
         /// more than one GPIO.
         ///
         pub unsafe fn wait_for_high(&mut self, _token: &mut GpioToken) -> impl Future<Output = ()> + use<'_> {
-            GpioWait::new(self)
+            GpioWait::new(self, 1)
+        }
+
+        /// Asynchronously wait for a gpio pin to become low.
+        ///
+        /// # Safety
+        ///
+        /// The `_token` enforces single use of gpios.  Note that this makes it impossible to wait
+        /// for more than one GPIO.
+        pub unsafe fn wait_for_low(&mut self, _token: &mut GpioToken) -> impl Future<Output = ()> + use<'_> {
+            GpioWait::new(self, 0)
         }
     }
 
     /// A future that waits for a gpio to become high.
     pub struct GpioWait<'a> {
         pin: &'a mut GpioPin,
+        level: u8,
     }
 
     impl<'a> GpioWait<'a> {
-        fn new(pin: &'a mut GpioPin) -> Self {
+        fn new(pin: &'a mut GpioPin, level: u8) -> Self {
             Self {
                 pin,
+                level,
             }
         }
     }
@@ -160,10 +174,16 @@ mod async_io {
 
             self.pin.data.register(self.pin.pin.pin, cx.waker());
 
+            let mode = match self.level {
+                0 => GPIO_INT_LEVEL_LOW,
+                1 => GPIO_INT_LEVEL_HIGH,
+                _ => unreachable!(),
+            };
+
             unsafe {
-                gpio_pin_interrupt_configure_dt(&self.pin.pin, GPIO_INT_LEVEL_HIGH);
+                gpio_pin_interrupt_configure_dt(&self.pin.pin, mode);
 
-                if gpio_pin_get(self.pin.pin.port, self.pin.pin.pin) == 1 {
+                if gpio_pin_get(self.pin.pin.port, self.pin.pin.pin) == self.level as c_int {
                     // TODO: Need to match with level.
                     // Zephyr doesn't have a way to determine if a given interrupt is pending, so the
                     // best we can do is just read the pin.  This doesn't work for edges though.