wip: rtio/i2c

Author: d3zd3z

dt-rust.yaml

@@ -35,6 +35,22 @@
         value: gpios
       device: crate::device::gpio::GpioPin
 
+# Hook up the gpio-keys as gpio pins as well
+- name: gpio-keys
+  rules:
+  - type: compatible
+    value:
+      names:
+      - gpio-keys
+      level: 1
+  actions:
+  - type: instance
+    value:
+      raw:
+        type: phandle
+        value: gpios
+      device: crate::device::gpio::GpioPin
+
 # Flash controllers don't have any particular property to identify them, so we need a list of
 # compatible values that should match.
 - name: flash-controller
@@ -45,6 +61,8 @@
       - "nordic,nrf52-flash-controller"
       - "nordic,nrf51-flash-controller"
       - "raspberrypi,pico-flash-controller"
+      - "st,stm32g4-flash-controller"
+      - "st,stm32l5-flash-controller"
       - "zephyr,sim-flash"
       level: 0
   actions:
@@ -80,6 +98,21 @@
           - type: reg
       device: "crate::device::flash::FlashPartition"
 
+# I2C.
+- name: i2c
+  rules:
+    - type: compatible
+      value:
+        names:
+          - "snps,designware-i2c"
+        level: 0
+  actions:
+    - type: instance
+      value:
+        raw:
+          type: myself
+        device: crate::device::i2c::I2C
+
 # Generate a pseudo node that matches all of the labels across the tree with their nodes.
 - name: labels
   rules:

zephyr-sys/build.rs

@@ -76,9 +76,13 @@ fn main() -> Result<()> {
         .derive_copy(false)
         .allowlist_function("k_.*")
         .allowlist_function("gpio_.*")
+        .allowlist_function("i2c_.*")
         .allowlist_function("flash_.*")
         .allowlist_function("zr_.*")
+        .allowlist_function("mpsc_.*")
+        .allowlist_function("rtio.*")
         .allowlist_item("GPIO_.*")
+        .allowlist_item("I2C_.*")
         .allowlist_item("FLASH_.*")
         .allowlist_item("Z_.*")
         .allowlist_item("ZR_.*")

zephyr-sys/wrapper.h

@@ -43,6 +43,9 @@ extern int errno;
 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/drivers/flash.h>
 #include <zephyr/irq.h>
+#include <zephyr/drivers/i2c.h>
+#include <zephyr/rtio/rtio.h>
+#include <zephyr/sys/mpsc_lockfree.h>
 
 /*
  * bindgen will only output #defined constants that resolve to simple numbers.  These are some
@@ -63,6 +66,12 @@ const uint32_t ZR_GPIO_INT_MODE_DISABLE_ONLY = GPIO_INT_MODE_DISABLE_ONLY;
 const uint32_t ZR_GPIO_INT_MODE_ENABLE_ONLY = GPIO_INT_MODE_ENABLE_ONLY;
 #endif
 
+const uint8_t ZR_I2C_MSG_WRITE = I2C_MSG_WRITE;
+const uint8_t ZR_I2C_MSG_READ = I2C_MSG_READ;
+const uint8_t ZR_I2C_MSG_STOP = I2C_MSG_STOP;
+
+const uint16_t ZR_RTIO_SQE_NO_RESPONSE = RTIO_SQE_NO_RESPONSE;
+
 /*
  * Zephyr's irq_lock() and irq_unlock() are macros not inline functions, so we need some inlines to
  * access them.

zephyr/src/device.rs

@@ -12,6 +12,7 @@ use crate::sync::atomic::{AtomicBool, Ordering};
 
 pub mod flash;
 pub mod gpio;
+pub mod i2c;
 
 // Allow dead code, because it isn't required for a given build to have any devices.
 /// Device uniqueness.

zephyr/src/device/gpio.rs

@@ -35,7 +35,10 @@ mod async_io {
         ZR_GPIO_INT_MODE_DISABLE_ONLY,
     };
 
-    use crate::sync::atomic::{AtomicBool, AtomicU32};
+    use crate::{
+        printkln,
+        sync::atomic::{AtomicBool, AtomicU32},
+    };
 
     use super::{GpioPin, GpioToken};
 
@@ -112,6 +115,7 @@ mod async_io {
             cb: *mut gpio_callback,
             mut pins: gpio_port_pins_t,
         ) {
+            printkln!("GPIO callback: {}", pins);
             let data = unsafe {
                 cb.cast::<u8>()
                     .sub(mem::offset_of!(Self, callback))

zephyr/src/device/i2c.rs

@@ -0,0 +1,100 @@
+//! Zpehyr I2C interface
+
+use core::{ffi::c_int, marker::PhantomData};
+
+use crate::{error::to_result, printkln, raw};
+
+use super::{NoStatic, Unique};
+
+/// A single I2C controller.
+pub struct I2C {
+    /// The underlying device itself.
+    #[allow(dead_code)]
+    pub(crate) device: *const raw::device,
+}
+
+unsafe impl Send for I2C {}
+
+impl I2C {
+    /// Constructor, used by the devicetree generated code.
+    #[allow(dead_code)]
+    pub(crate) unsafe fn new(
+        unique: &Unique,
+        _data: &'static NoStatic,
+        device: *const raw::device,
+    ) -> Option<Self> {
+        if !unique.once() {
+            return None;
+        }
+        Some(I2C { device })
+    }
+
+    /// Do a write/read.
+    pub fn write_read(&mut self, write: &[u8], read: &mut [u8]) -> crate::Result<c_int> {
+        let mut msg = [
+            raw::i2c_msg {
+                buf: write.as_ptr() as *mut _,
+                len: write.len() as u32,
+                flags: raw::ZR_I2C_MSG_WRITE,
+            },
+            raw::i2c_msg {
+                buf: read.as_mut_ptr(),
+                len: read.len() as u32,
+                flags: raw::ZR_I2C_MSG_READ | raw::ZR_I2C_MSG_STOP,
+            },
+        ];
+        let res = unsafe { to_result(raw::i2c_transfer(self.device, msg.as_mut_ptr(), 2, 0x42)) };
+
+        printkln!("res: {} {}", msg[1].len, msg[1].flags);
+
+        res
+    }
+
+    /// Add an i2c operation to the RTIO.
+    ///
+    /// TODO: Unclear how to indicate that the buffers must live long enough for the submittion.
+    /// As it is, this is actually completely unsound.
+    pub fn rtio_write_read(&mut self, write: &[u8], read: &mut [u8]) -> crate::Result<()> {
+        let _msg = [
+            raw::i2c_msg {
+                buf: write.as_ptr() as *mut _,
+                len: write.len() as u32,
+                flags: raw::ZR_I2C_MSG_WRITE,
+            },
+            raw::i2c_msg {
+                buf: read.as_mut_ptr(),
+                len: read.len() as u32,
+                flags: raw::ZR_I2C_MSG_READ | raw::ZR_I2C_MSG_STOP,
+            },
+        ];
+
+        todo!()
+    }
+}
+
+/// An i2c transaction.
+pub struct ReadWrite<'a> {
+    _phantom: PhantomData<&'a ()>,
+    msgs: [raw::i2c_msg; 2],
+}
+
+impl<'a> ReadWrite<'a> {
+    /// Construct a new read/write transaction.
+    pub fn new(write: &'a [u8], read: &'a mut [u8]) -> Self {
+        Self {
+            _phantom: PhantomData,
+            msgs: [
+                raw::i2c_msg {
+                    buf: write.as_ptr() as *mut _,
+                    len: write.len() as u32,
+                    flags: raw::ZR_I2C_MSG_WRITE,
+                },
+                raw::i2c_msg {
+                    buf: read.as_mut_ptr(),
+                    len: read.len() as u32,
+                    flags: raw::ZR_I2C_MSG_READ | raw::ZR_I2C_MSG_STOP,
+                },
+            ],
+        }
+    }
+}

zephyr/src/lib.rs

@@ -74,6 +74,8 @@ pub mod embassy;
 pub mod error;
 pub mod logging;
 pub mod object;
+#[cfg(CONFIG_RTIO)]
+pub mod rtio;
 #[cfg(CONFIG_RUST_ALLOC)]
 pub mod simpletls;
 pub mod sync;