wip: zephyr: i2c support

Start of i2c support, including using rtio for it.

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

Author: d3zd3z

docgen/prj.conf

@@ -7,3 +7,6 @@ CONFIG_GPIO=y
 CONFIG_GPIO_ENABLE_DISABLE_INTERRUPT=y
 CONFIG_PRINTK=y
 CONFIG_POLL=y
+CONFIG_I2C=y
+CONFIG_I2C_RTIO=y
+CONFIG_RTIO=y

dt-rust.yaml

@@ -98,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/i2c.rs

@@ -0,0 +1,108 @@
+//! 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

@@ -75,6 +75,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;
@@ -124,6 +126,9 @@ pub mod devicetree {
 
     // Don't enforce doc comments on the generated device tree.
     #![allow(missing_docs)]
+    // Allow nodes to have non-snake-case names.  This comes from addresses in the node names, which
+    // usually use uppercase.
+    #![allow(non_snake_case)]
 
     include!(concat!(env!("OUT_DIR"), "/devicetree.rs"));
 }

zephyr/src/rtio.rs

@@ -0,0 +1,194 @@
+//! Interface to Zephyr 'rtio' infrastructure.
+
+use core::ffi::c_void;
+
+use crate::error::to_result_void;
+use crate::raw;
+use crate::object::{ObjectInit, ZephyrObject};
+
+/// The underlying structure, holding the rtio, it's semaphores, and pools.
+///
+/// Note that putting these together in a single struct makes this "pleasant" to use from Rust, but
+/// does make the end result incompatible with userspace.
+#[repr(C)]
+pub struct RtioData<const SQE_SZ: usize, const CQE_SZ: usize> {
+    /// The overall rtio struct.
+    rtio: raw::rtio,
+    /// Sempahore used for the submission queue.
+    #[cfg(CONFIG_RTIO_SUBMIT_SEM)]
+    submit_sem: raw::k_sem,
+    /// Semaphore used for the consumption queue.
+    #[cfg(CONFIG_RTIO_CONSUME_SEM)]
+    consume_sem: raw::k_sem,
+    /// The SQE items.
+    sqe_pool_items: [raw::rtio_iodev_sqe; SQE_SZ],
+    /// The SQE pool itself.
+    sqe_pool: raw::rtio_sqe_pool,
+    /// The CQE items.
+    cqe_pool_items: [raw::rtio_cqe; CQE_SZ],
+    /// The pool of CQEs.
+    cqe_pool: raw:: rtio_cqe_pool,
+}
+
+/// Init based reference to the the underlying rtio object.
+///
+/// Note that this declaration will _not_ support userspace currently, as the object will not be
+/// placed in an iterable linker section.  Also, the linker sevction will not work as the
+/// ZephyrObject will have an attached atomic used to ensure proper initialization.
+pub struct RtioObject<const SQE_SZ: usize, const CQE_SZ: usize>(pub(crate) ZephyrObject<RtioData<SQE_SZ, CQE_SZ>>);
+
+unsafe impl<const SQE_SZ: usize, const CQE_SZ: usize> Sync for RtioObject<SQE_SZ, CQE_SZ> {}
+
+impl<const SQE_SZ: usize, const CQE_SZ: usize> RtioObject<SQE_SZ, CQE_SZ> {
+    /// Construct a new RTIO pool.
+    ///
+    /// Create a new RTIO object.  These objects generally need to be statically allocated.
+    pub const fn new() -> Self {
+        let this = <ZephyrObject<RtioData<SQE_SZ, CQE_SZ>>>::new_raw();
+        RtioObject(this)
+    }
+
+    /// Acquire a submission object.
+    pub fn sqe_acquire(&'static self) -> Option<Sqe> {
+        let this = unsafe { self.0.get() };
+
+        let ptr = unsafe {
+            raw::rtio_sqe_acquire(&raw mut (*this).rtio)
+        };
+
+        if ptr.is_null() {
+            None
+        } else {
+            Some(Sqe { item: ptr })
+        }
+    }
+
+    /// Submit the work.
+    pub fn submit(&'static self, wait: usize) -> crate::Result<()> {
+        let this = unsafe { self.0.get() };
+
+        unsafe {
+            to_result_void(raw::rtio_submit(&raw mut (*this).rtio, wait as u32))
+        }
+    }
+
+    /// Consume a single completion.
+    ///
+    /// Will return the completion if available.  If returned, it will be released upon drop.
+    pub fn cqe_consume(&'static self) -> Option<Cqe> {
+        let this = unsafe { self.0.get() };
+
+        let ptr = unsafe {
+            raw::rtio_cqe_consume(&raw mut (*this).rtio)
+        };
+
+        if ptr.is_null() {
+            None
+        } else {
+            Some(Cqe {
+                item: ptr,
+                rtio: unsafe { &raw mut (*this).rtio },
+            })
+        }
+    }
+}
+
+impl<const SQE_SZ: usize, const CQE_SZ: usize> ObjectInit<RtioData<SQE_SZ, CQE_SZ>> for ZephyrObject<RtioData<SQE_SZ, CQE_SZ>> {
+    fn init(item: *mut RtioData<SQE_SZ, CQE_SZ>) {
+        #[cfg(CONFIG_RTIO_SUBMIT_SEM)]
+        unsafe {
+            raw::k_sem_init(&raw mut (*item).submit_sem, 0, raw::K_SEM_MAX_LIMIT);
+            (*item).rtio.submit_sem = &raw mut (*item).submit_sem;
+            (*item).rtio.submit_count = 0;
+        }
+        #[cfg(CONFIG_RTIO_CONSUME_SEM)]
+        unsafe {
+            raw::k_sem_init(&raw mut (*item).consume_sem, 0, raw::K_SEM_MAX_LIMIT);
+            (*item).rtio.consume_sem = &raw mut (*item).consume_sem;
+        }
+        unsafe {
+            // TODO: Zephyr atomic init?
+            (*item).rtio.cq_count = 0;
+            (*item).rtio.xcqcnt = 0;
+
+            // Set up the sqe pool.
+            raw::mpsc_init(&raw mut (*item).sqe_pool.free_q);
+            (*item).sqe_pool.pool_size = SQE_SZ as u16;
+            (*item).sqe_pool.pool_free = SQE_SZ as u16;
+            (*item).sqe_pool.pool = (*item).sqe_pool_items.as_mut_ptr();
+
+            for p in &mut (*item).sqe_pool_items {
+                raw::mpsc_push(&raw mut (*item).sqe_pool.free_q, &raw mut p.q);
+            }
+
+            // Set up the cqe pool
+            raw::mpsc_init(&raw mut (*item).cqe_pool.free_q);
+            (*item).cqe_pool.pool_size = CQE_SZ as u16;
+            (*item).cqe_pool.pool_free = CQE_SZ as u16;
+            (*item).cqe_pool.pool = (*item).cqe_pool_items.as_mut_ptr();
+
+            for p in &mut (*item).cqe_pool_items {
+                raw::mpsc_push(&raw mut (*item).cqe_pool.free_q, &raw mut p.q);
+            }
+
+            (*item).rtio.sqe_pool = &raw mut (*item).sqe_pool;
+            (*item).rtio.cqe_pool = &raw mut (*item).cqe_pool;
+
+            raw::mpsc_init(&raw mut (*item).rtio.sq);
+            raw::mpsc_init(&raw mut (*item).rtio.cq);
+        }
+    }
+}
+
+/// A single Sqe.
+///
+/// TODO: How to bind the lifetime to the Rtio meaningfully, even though it is all static.
+pub struct Sqe {
+    item: *mut raw::rtio_sqe,
+}
+
+impl Sqe {
+    /// Configure this SQE as a callback.
+    pub fn prep_callback(&mut self, callback: raw::rtio_callback_t, arg0: *mut c_void, userdata: *mut c_void) {
+        unsafe {
+            raw::rtio_sqe_prep_callback(self.item, callback, arg0, userdata);
+        }
+    }
+
+    /// Configure this SQE as a nop.
+    pub fn prep_nop(&mut self, dev: *mut raw::rtio_iodev, userdata: *mut c_void) {
+        unsafe {
+            raw::rtio_sqe_prep_nop(self.item, dev, userdata);
+        }
+    }
+
+    /// Add flags.
+    pub fn or_flags(&mut self, flags: u16) {
+        unsafe {
+            (*self.item).flags |= flags;
+        }
+    }
+}
+
+/// A single Cqe.
+pub struct Cqe {
+    item: *mut raw::rtio_cqe,
+    rtio: *mut raw::rtio,
+}
+
+impl Cqe {
+    /// Retrieve the result of this operation.
+    pub fn result(&self) -> i32 {
+        unsafe {
+            (*self.item).result
+        }
+    }
+}
+
+impl Drop for Cqe {
+    fn drop(&mut self) {
+        unsafe {
+            raw::rtio_cqe_release(self.rtio, self.item);
+        }
+    }
+}