Rework i2cbus implementation

Author: eldruin

examples/pca9956b.rs

@@ -10,9 +10,9 @@ extern crate i2cdev;
 extern crate docopt;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
-use i2cdev::linux::{LinuxI2CBus, I2CMsg};
+use i2cdev::core::{I2CBus, I2CMessage};
 #[cfg(any(target_os = "linux", target_os = "android"))]
-use i2cdev::core::I2CBus;
+use i2cdev::linux::{LinuxI2CBus, LinuxI2CMessage};
 
 use std::env::args;
 use docopt::Docopt;
@@ -44,7 +44,7 @@ fn main() {
         Ok(bus) => bus,
         Err(_e) => {
             println!("Error opening I2C Bus {} {}", path, _e);
-            return
+            return;
         }
     };
     println!("Opened I2C Bus OK: {}", path);
@@ -53,30 +53,26 @@ fn main() {
     // 1) Write the MODE1 register address, with top bit indcating auto-
     //    increment should be enabled
     // 2) Read 10 bytes from the current register onwards
-    let mut dataw: Vec<u8> = vec![0b1000_0000]; 
-    let mut data: Vec<u8> = vec![0; 10]; 
-    let mut msgs: Vec<I2CMsg> = Vec::new();
-    msgs.push(I2CMsg::new(ADDR, &mut dataw));
-    msgs.push(I2CMsg::new(ADDR, &mut data));
-    msgs[1].set_read();
+    let mut data = [0; 10];
+    let mut msgs = [
+        LinuxI2CMessage::write(ADDR, &[0b1000_0000]),
+        LinuxI2CMessage::read(ADDR, &mut data),
+    ];
 
     // Send the messages to the kernel to process
-    match bus.rdwr(&mut msgs) {
-        Ok(rc) => {
-            println!("Successful RDWR call: {} messages processed", rc)
-        },
+    match bus.transfer(&mut msgs) {
+        Ok(rc) => println!("Successful transfer call: {} messages processed", rc),
         Err(_e) => {
             println!("Error reading/writing {}", _e);
-            return
-        },
+            return;
+        }
     }
 
     // Print the data read from the device.  A recently reset PCA9956B should
     // return:
     // 0x8005000000000000ff00
     let mut output = "Result: 0x".to_string();
-    let data = msgs[1].data();
-    for byte in data {
+    for byte in &data {
         output = format!("{}{:02x}", output, byte);
     }
     println!("{}", output);

src/core.rs

@@ -125,89 +125,19 @@ pub trait I2CDevice {
 /// in use.  The trait is based on the Linux i2cdev interface.
 pub trait I2CBus {
     type Error: Error;
+    type Message: I2CMessage;
 
     // Performs multiple serially chained I2C read/write transactions.  On
     // success the return code is the number of successfully executed
     // transactions
-    fn rdwr<'a>(&mut self, msgs: &mut Vec<I2CMsg<'a>>) -> Result<i32, Self::Error>;
+    fn transfer(&mut self, msgs: &mut [Self::Message]) -> Result<u32, Self::Error>;
 }
 
-bitflags! {
-    pub struct I2CMsgFlags: u16 {
-        /// this is a ten bit chip address
-        const I2C_M_TEN = 0x0010;
-        /// read data, from slave to master
-        const I2C_M_RD = 0x0001;
-        /// if I2C_FUNC_PROTOCOL_MANGLING
-        const I2C_M_STOP = 0x8000;
-        /// if I2C_FUNC_NOSTART
-        const I2C_M_NOSTART = 0x4000;
-        /// if I2C_FUNC_PROTOCOL_MANGLING
-        const I2C_M_REV_DIR_ADDR = 0x2000;
-        /// if I2C_FUNC_PROTOCOL_MANGLING
-        const I2C_M_IGNORE_NAK = 0x1000;
-        /// if I2C_FUNC_PROTOCOL_MANGLING
-        const I2C_M_NO_RD_ACK = 0x0800;
-        /// length will be first received byte
-        const I2C_M_RECV_LEN = 0x0400;
-    }
-}
-
-/// Rust version of i2c_msg
-pub struct I2CMsg<'a> {
-    /// slave address
-    pub(crate) addr: u16,
-    /// serialized I2CMsgFlags
-    pub(crate) flags: u16,
-
-    /// msg length comes from msg Vector length
-
-    /// msg data to be sent/received
-    pub(crate) data: &'a mut Vec<u8>,
-}
+/// Read/Write I2C message
+pub trait I2CMessage {
+    /// Read data from device
+    fn read(slave_address: u16, data: &mut [u8]) -> Self;
 
-impl<'a> I2CMsg<'a> {
-    /// Create I2CMsg from address and data buffer
-    pub fn new(addr: u16, data: &'a mut Vec<u8>) -> Self {
-        I2CMsg {
-            addr,
-            flags: 0,
-            data
-        }
-    }
-
-    /// Set flags
-    pub fn set_flags(&mut self, flags: u16) {
-        self.flags = flags;
-    }
-
-    /// Get flags
-    pub fn flags(&mut self) -> u16 {
-        self.flags
-    }
-
-    /// Set addr
-    pub fn set_addr(&mut self, addr: u16) {
-        self.addr = addr;
-    }
-
-    /// Get addr
-    pub fn addr(&mut self) -> u16 {
-        self.addr
-    }
-
-    /// Set data
-    pub fn set_data(&mut self, data: &'a mut Vec<u8>) {
-        self.data = data;
-    }
-
-    /// Get addr
-    pub fn data(&mut self) -> Vec<u8> {
-        self.data.clone()
-    }
-
-    /// Sets the read flag
-    pub fn set_read(&mut self) {
-        self.flags |= I2CMsgFlags::I2C_M_RD.bits;
-    }
+    /// Write data to device
+    fn write(slave_address: u16, data: &[u8]) -> Self;
 }

src/ffi.rs

@@ -16,38 +16,21 @@ use std::io::Cursor;
 use std::os::unix::prelude::*;
 use std::marker::PhantomData;
 use byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
-use core::{I2CMsg};
 use libc::c_int;
 
 pub type I2CError = nix::Error;
 
 #[repr(C)]
-#[derive(Debug)]
-/// C version of i2c_msg structure
-// See linux/i2c.h
-struct i2c_msg<'a> {
+pub struct i2c_msg {
     /// slave address
-    addr: u16,
+    pub(crate) addr: u16,
     /// serialized I2CMsgFlags
-    flags: u16,
+    pub(crate) flags: u16,
     /// msg length
-    len: u16,
+    pub(crate) len: u16,
     /// pointer to msg data
-    buf: *mut u8,
-    _phantom: PhantomData<&'a mut u8>,
-}
-
-impl<'a, 'b> From<&'b mut I2CMsg<'a>> for i2c_msg<'a> {
-    fn from(msg: &mut I2CMsg) -> Self {
-        i2c_msg {
-            addr: msg.addr,
-            flags: msg.flags,
-            len: msg.data.len() as u16,
-            buf: msg.data.as_mut_ptr(),
-            _phantom: PhantomData
+    pub(crate) buf: *const u8,
         }
-    }
-}
 
 bitflags! {
     struct I2CFunctions: u32 {
@@ -163,9 +146,9 @@ pub struct i2c_smbus_ioctl_data {
 /// This is the structure as used in the I2C_RDWR ioctl call
 // see linux/i2c-dev.h
 #[repr(C)]
-pub struct i2c_rdwr_ioctl_data<'a> {
+pub struct i2c_rdwr_ioctl_data {
     // struct i2c_msg __user *msgs;
-    msgs: *mut i2c_msg<'a>,
+    msgs: *mut i2c_msg,
     // __u32 nmsgs;
     nmsgs: u32,
 }
@@ -430,30 +413,15 @@ pub fn i2c_smbus_process_call_block(fd: RawFd, register: u8, values: &[u8]) -> R
     Ok((&data.block[1..(count + 1) as usize]).to_vec())
 }
 
-// Returns the number of messages succesfully processed
-unsafe fn i2c_rdwr_access(fd: RawFd,
-                          msgs: *mut i2c_msg,
-                          nmsgs: usize)
-                          -> Result<(c_int), I2CError> {
-    let args = i2c_rdwr_ioctl_data {
-        msgs,
-        nmsgs: nmsgs as u32,
+#[inline]
+pub fn i2c_rdwr(fd: RawFd, values: &mut [i2c_msg]) -> Result<u32, I2CError> {
+    let i2c_data = i2c_rdwr_ioctl_data {
+        msgs: values.as_mut_ptr(),
+        nmsgs: values.len() as u32,
     };
 
-    ioctl::i2c_rdwr(fd, &args)
-}
-
-pub fn i2c_rdwr_read_write(fd: RawFd,
-                           msgs: &mut Vec<I2CMsg>) -> Result<(i32), I2CError> {
-    // Building the msgs to push is safe.
-    // We have to use iter_mut as buf needs to be mutable.
-    let mut cmsgs = msgs.iter_mut().map(<i2c_msg>::from).collect::<Vec<_>>();
-
-    // But calling the ioctl is definitely not!
     unsafe {
-        i2c_rdwr_access(fd,
-                        cmsgs.as_mut_ptr(),
-                        cmsgs.len())
+        let n = ioctl::i2c_rdwr(fd, &i2c_data)?;
+        Ok(n as u32)
     }
 }
-

src/lib.rs

@@ -41,6 +41,33 @@
 //!     }
 //! }
 //! ```
+//! 
+//! ```rust,no_run
+//! extern crate i2cdev;
+//!
+//! use std::thread;
+//! use std::time::Duration;
+//!
+//! use i2cdev::core::*;
+//! use i2cdev::linux::{LinuxI2CDevice, LinuxI2CError, LinuxI2CMessage};
+//!
+//! const SLAVE_ADDR: u16 = 0x57;
+//!
+//! fn write_read_transaction() -> Result<(), LinuxI2CError> {
+//!     let mut dev = LinuxI2CBus::new("/dev/i2c-1")?;
+//!
+//!     let mut read_data = [0; 2];
+//!     let mut msgs = [
+//!         LinuxI2CMessage::write(SLAVE_ADDR, &[0x01]),
+//!         LinuxI2CMessage::read(SLAVE_ADDR, &mut read_data)
+//!     ];
+//!     dev.transfer(&mut msgs)?;
+//!     thread::sleep(Duration::from_millis(100));
+//!
+//!     println!("Reading: {:?}", read_data);
+//!     Ok(())
+//! }
+//! ```
 
 #![crate_name = "i2cdev"]
 #![crate_type = "lib"]

src/linux.rs

@@ -19,7 +19,7 @@ use std::io::prelude::*;
 use std::os::unix::prelude::*;
 
 // Expose these core structs from this module
-pub use core::{I2CMsgFlags, I2CMsg};
+pub use core::I2CMessage;
 
 pub struct LinuxI2CDevice {
     devfile: File,
@@ -250,11 +250,71 @@ impl LinuxI2CBus {
     }
 }
 
+/// Linux I2C message
+pub type LinuxI2CMessage = ffi::i2c_msg;
+
 impl I2CBus for LinuxI2CBus {
     type Error = LinuxI2CError;
+    type Message = LinuxI2CMessage;
 
     /// Issue the provided sequence of I2C transactions
-    fn rdwr(&mut self, msgs: &mut Vec<I2CMsg>) -> Result<i32, LinuxI2CError> {
-        ffi::i2c_rdwr_read_write(self.as_raw_fd(), msgs).map_err(From::from)
+    fn transfer(&mut self, msgs: &mut [Self::Message]) -> Result<u32, LinuxI2CError> {
+        ffi::i2c_rdwr(self.as_raw_fd(), msgs).map_err(From::from)
+    }
+}
+
+bitflags! {
+    /// Various flags used by the i2c_rdwr ioctl on Linux. For details, see
+    /// https://www.kernel.org/doc/Documentation/i2c/i2c-protocol
+    ///
+    /// In general, these are for special cases and should not be needed
+    pub struct I2CMessageFlags: u16 {
+        /// Use ten bit addressing on this message
+        const TEN_BIT_ADDRESS = 0x0010;
+        /// Read data, from slave to master
+        const READ = 0x0001;
+        /// Force an I2C stop condition on this message
+        const STOP = 0x8000;
+        /// Avoid sending an I2C start condition on this message
+        const NO_START = 0x4000;
+        /// If you need to invert a 'read' command bit to a 'write'
+        const INVERT_COMMAND = 0x2000;
+        /// Force this message to ignore I2C negative acknowlegements
+        const IGNORE_NACK = 0x1000;
+        /// Force message to ignore acknowledgement
+        const IGNORE_ACK = 0x0800;
+        /// Allow the client to specify how many bytes it will send
+        const USE_RECEIVE_LENGTH = 0x0400;
+    }
+}
+
+impl I2CMessage for LinuxI2CMessage {
+    fn read(slave_address: u16, data: &mut [u8]) -> LinuxI2CMessage {
+        Self {
+            addr: slave_address,
+            flags: I2CMessageFlags::READ.bits(),
+            len: data.len() as u16,
+            buf: data.as_ptr(),
+        }
+    }
+
+    fn write(slave_address: u16, data: &[u8]) -> LinuxI2CMessage {
+        Self {
+            addr: slave_address,
+            flags: I2CMessageFlags::empty().bits(),
+            len: data.len() as u16,
+            buf: data.as_ptr(),
+        }
+    }
+}
+
+impl LinuxI2CMessage {
+    pub fn with_flags(self, flags: I2CMessageFlags) -> Self {
+        Self {
+            addr: self.addr,
+            flags: flags.bits(),
+            len: self.len,
+            buf: self.buf,
+        }
     }
 }