libi2c - publicly accessible functions provided by the i2c library

       Simon G. Vogl, Frodo Looijaard, Jean Delvare and others

i2c-tools                                        September 2020                                        libi2c(3)

       To report bugs or send fixes, please write to the Linux I2C mailing list <linux-i2c@vger.kernel.org> with
       Cc to the current maintainer: Jean Delvare <jdelvare@suse.de>.

       Structure i2c_smbus_ioctl_data is used to send data to and retrieve data from the kernel through the i2c-
       dev driver.  It will be filled out for you by i2c_smbus_access() so you do not need  to  care  about  the
       details.

       Union i2c_smbus_data is used to store all possible SMBus data.

       union i2c_smbus_data {
            __u8 byte;
            __u16 word;
            __u8 block[I2C_SMBUS_BLOCK_MAX + 2];
       };

       block[0]  is  used for length and the last byte is reserved.  If you use the higher-level functions, this
       structure will be filled out for you so you do not have to care about the  details.   Only  if  you  call
       i2c_smbus_access() directly, you need to fill it out yourself.

       This  library  offers  to user-space an SMBus-level API similar to the in-kernel one.  Each function is a
       wrapper around the appropriate ioctl call for i2c-dev to process.  The i2c-dev kernel driver will convert
       the ioctl to its in-kernel equivalent function call, and pass the result back to the user-space caller.

       i2c_smbus_access() is the universal function to run any SMBus transaction.  You have to fill out and link
       the data structures yourself.  It returns 0 on success, or a negative errno value on error.  In  practice
       you  should  never  need to call this function directly, instead use one of the specific functions below,
       which will prepare the data and then call it for you.

       i2c_smbus_write_quick() runs an SMBus "Quick command" transaction.

       i2c_smbus_write_byte() runs an SMBus "Send byte" transaction.

       i2c_smbus_write_byte_data() runs an SMBus "Write byte" transaction.

       i2c_smbus_write_word_data() runs an SMBus "Write word" transaction.

       These write transaction functions return 0 on success.  On error, a negative errno value is returned.

       i2c_smbus_read_byte() runs an SMBus "Receive byte" transaction.

       i2c_smbus_read_byte_data() runs an SMBus "Read byte" transaction.

       i2c_smbus_read_word_data() runs an SMBus "Read word" transaction.

       i2c_smbus_process_call() runs an SMBus "Process call" transaction.

       These read transaction functions return the read byte or word value on success.   On  error,  a  negative
       errno value is returned.

       i2c_smbus_write_block_data() runs an SMBus "Block write" transaction.

       i2c_smbus_read_block_data() runs an SMBus "Block read" transaction.

       i2c_smbus_block_process_call() runs an SMBus "Block write-block read process call" transaction.

       These  block  transaction  functions  return 0 on success.  On error, a negative errno value is returned.
       The block length is limited to 32 bytes.

       i2c_smbus_write_i2c_block_data() runs an "I2C block write" transaction. This is typically used  to  write
       to an EEPROM up to 4 kb in size.

       i2c_smbus_read_i2c_block_data() runs an "I2C block read" transaction. This is typically used to read from
       an EEPROM up to 4 kb in size.

       While technically not part of the SMBus specification, these I2C block transactions are supported by many
       SMBus  host  controllers.   These  block transaction functions return 0 on success.  On error, a negative
       errno value is returned.  Like their SMBus counterparts, the block length is limited to 32 bytes.

       libi2c - publicly accessible functions provided by the i2c library

#include<linux/i2c.h>#include<i2c/smbus.h>

       /* Universal SMBus transaction */
       __s32i2c_smbus_access(intfile,charread_write,__u8command,intsize,unioni2c_smbus_data*data);

       /* Simple SMBus transactions */
       __s32i2c_smbus_write_quick(intfile,__u8value);__s32i2c_smbus_read_byte(intfile);__s32i2c_smbus_write_byte(intfile,__u8value);__s32i2c_smbus_read_byte_data(intfile,__u8command);__s32i2c_smbus_write_byte_data(intfile,__u8command,__u8value);__s32i2c_smbus_read_word_data(intfile,__u8command);__s32i2c_smbus_write_word_data(intfile,__u8command,__u16value);__s32i2c_smbus_process_call(intfile,__u8command,__u16value);

       /* Block SMBus (and non-SMBus) transactions */
       __s32i2c_smbus_read_block_data(intfile,__u8command,__u8*values);__s32i2c_smbus_write_block_data(intfile,__u8command,__u8length,const__u8*values);__s32i2c_smbus_block_process_call(intfile,__u8command,__u8length,__u8*values);__s32i2c_smbus_read_i2c_block_data(intfile,__u8command,__u8length,__u8*values);__s32i2c_smbus_write_i2c_block_data(intfile,__u8command,__u8length,const__u8*values);