Add base spi api

Co-developed-by: Martin Schmidt <[email protected]>
Signed-off-by: Martin Schmidt <[email protected]>
Co-developed-by: Arthur Cohen <[email protected]>
Signed-off-by: Arthur Cohen <[email protected]>

Add base spi api

spi: Add spi low level support

spi: Add drop implementation for spi::Registration

spi: Add base for spi driver "methods"

spi: Add spi_method! to define SPI methods easily

spi: Refactor module

spi: Fix overzealous typo fix

spi: Rename Registration -> DriverRegistration for clarity

spi: Add base abstraction for spi_*() functions

spi: spi_method!, pass SpiDevice as mutable

spi: Make DriverRegistration Sync + Send

spi: Do not register a Pin<Box>

spi: Remove builder pattern

spi: Register driver in new_pinned

Rename KernelResult to Result

Signed-off-by: Esteban Blanc <[email protected]>

Author: Skallwar

rust/kernel/bindings_helper.h

@@ -12,6 +12,7 @@
 #include <linux/miscdevice.h>
 #include <linux/poll.h>
 #include <linux/mm.h>
+#include <linux/spi/spi.h>
 #include <uapi/linux/android/binder.h>
 
 // `bindgen` gets confused at certain things

rust/kernel/lib.rs

@@ -68,6 +68,9 @@ pub mod user_ptr;
 pub use crate::error::{Error, Result};
 pub use crate::types::{CStr, Mode};
 
+#[cfg(CONFIG_SPI)]
+pub mod spi;
+
 /// Page size defined in terms of the `PAGE_SHIFT` macro from C.
 ///
 /// [`PAGE_SHIFT`]: ../../../include/asm-generic/page.h

rust/kernel/spi.rs

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: GPL-2.0
+
+use crate::bindings;
+use crate::c_types;
+use crate::error::{Error, Result};
+use crate::CStr;
+use alloc::boxed::Box;
+use core::pin::Pin;
+
+#[derive(Clone, Copy)]
+pub struct SpiDevice(*mut bindings::spi_device);
+
+impl SpiDevice {
+    pub fn from_ptr(dev: *mut bindings::spi_device) -> Self {
+        SpiDevice(dev)
+    }
+
+    pub fn to_ptr(&mut self) -> *mut bindings::spi_device {
+        self.0
+    }
+}
+
+pub struct DriverRegistration {
+    this_module: &'static crate::ThisModule,
+    registered: bool,
+    name: CStr<'static>,
+    probe: Option<SpiMethod>,
+    remove: Option<SpiMethod>,
+    shutdown: Option<SpiMethodVoid>,
+    spi_driver: Option<bindings::spi_driver>,
+}
+
+impl DriverRegistration {
+    fn new(
+        this_module: &'static crate::ThisModule,
+        name: CStr<'static>,
+        probe: Option<SpiMethod>,
+        remove: Option<SpiMethod>,
+        shutdown: Option<SpiMethodVoid>,
+    ) -> Self {
+        DriverRegistration {
+            this_module,
+            name,
+            registered: false,
+            probe,
+            remove,
+            shutdown,
+            spi_driver: None,
+        }
+    }
+
+    // FIXME: Add documentation
+    pub fn new_pinned(
+        this_module: &'static crate::ThisModule,
+        name: CStr<'static>,
+        probe: Option<SpiMethod>,
+        remove: Option<SpiMethod>,
+        shutdown: Option<SpiMethodVoid>,
+    ) -> Result<Pin<Box<Self>>> {
+        let mut registration = Pin::from(Box::try_new(Self::new(
+            this_module,
+            name,
+            probe,
+            remove,
+            shutdown,
+        ))?);
+
+        registration.as_mut().register()?;
+
+        Ok(registration)
+    }
+
+    // FIXME: Add documentation
+    pub fn register(self: Pin<&mut Self>) -> Result {
+        let mut spi_driver = bindings::spi_driver::default();
+        spi_driver.driver.name = self.name.as_ptr() as *const c_types::c_char;
+        spi_driver.probe = self.probe;
+        spi_driver.remove = self.remove;
+        spi_driver.shutdown = self.shutdown;
+
+        let this = unsafe { self.get_unchecked_mut() };
+        if this.registered {
+            return Err(Error::EINVAL);
+        }
+
+        this.spi_driver = Some(spi_driver);
+
+        let res = unsafe { bindings::__spi_register_driver(this.this_module.0, &mut spi_driver) };
+
+        match res {
+            0 => {
+                this.registered = true;
+                Ok(())
+            }
+            _ => Err(Error::from_kernel_errno(res)),
+        }
+    }
+}
+
+impl Drop for DriverRegistration {
+    fn drop(&mut self) {
+        unsafe { bindings::driver_unregister(&mut self.spi_driver.unwrap().driver) }
+        // FIXME: No unwrap? But it's safe?
+    }
+}
+
+// FIXME: Fix SAFETY documentation
+
+// SAFETY: The only method is `register()`, which requires a (pinned) mutable `Registration`, so it
+// is safe to pass `&Registration` to multiple threads because it offers no interior mutability.
+unsafe impl Sync for DriverRegistration {}
+
+// SAFETY: The only method is `register()`, which requires a (pinned) mutable `Registration`, so it
+// is safe to pass `&Registration` to multiple threads because it offers no interior mutability.
+unsafe impl Send for DriverRegistration {}
+
+type SpiMethod = unsafe extern "C" fn(*mut bindings::spi_device) -> c_types::c_int;
+type SpiMethodVoid = unsafe extern "C" fn(*mut bindings::spi_device) -> ();
+
+#[macro_export]
+macro_rules! spi_method {
+    (fn $method_name:ident (mut $device_name:ident : SpiDevice) -> Result $block:block) => {
+        unsafe extern "C" fn $method_name(dev: *mut kernel::bindings::spi_device) -> kernel::c_types::c_int {
+            use kernel::spi::SpiDevice;
+
+            fn inner(mut $device_name: SpiDevice) -> Result $block
+
+            match inner(SpiDevice::from_ptr(dev)) {
+                Ok(_) => 0,
+                Err(e) => e.to_kernel_errno(),
+            }
+        }
+    };
+    (fn $method_name:ident (mut $device_name:ident : SpiDevice) $block:block) => {
+        unsafe extern "C" fn $method_name(dev: *mut kernel::bindings::spi_device) {
+            use kernel::spi::SpiDevice;
+
+            fn inner(mut $device_name: SpiDevice) $block
+
+            inner(SpiDevice::from_ptr(dev))
+        }
+    };
+}
+
+pub struct Spi;
+
+impl Spi {
+    pub fn write_then_read(
+        dev: &mut SpiDevice,
+        tx_buf: &[u8],
+        n_tx: usize,
+        rx_buf: &mut [u8],
+        n_rx: usize,
+    ) -> Result {
+        let res = unsafe {
+            bindings::spi_write_then_read(
+                dev.to_ptr(),
+                tx_buf.as_ptr() as *const c_types::c_void,
+                n_tx as c_types::c_uint,
+                rx_buf.as_ptr() as *mut c_types::c_void,
+                n_rx as c_types::c_uint,
+            )
+        };
+
+        match res {
+            0 => Ok(()),                               // 0 indicates a valid transfer,
+            err => Err(Error::from_kernel_errno(err)), // A negative number indicates an error
+        }
+    }
+
+    #[inline]
+    pub fn write(dev: &mut SpiDevice, tx_buf: &[u8], n_tx: usize) -> Result {
+        Spi::write_then_read(dev, tx_buf, n_tx, &mut [0u8; 0], 0)
+    }
+
+    #[inline]
+    pub fn read(dev: &mut SpiDevice, rx_buf: &mut [u8], n_rx: usize) -> Result {
+        Spi::write_then_read(dev, &[0u8; 0], 0, rx_buf, n_rx)
+    }
+}