linux 标准i2c接口（一）

一：I2C设备操作方式：

1.  应用程序操作法：i2c的设备的驱动可以直接利用linux内核提供的i2c-dev.c文件提供的ioctl函数接口在应用层实现对i2c设备的读写，但是在应用层使用ioctl函数对应用程序员要求较高，需要自行构建msg结构体，必须了解设备的操作流程，时序之类的。

这方式实现需要用用程序员调用 read， write， ioctl， open， close等linux标准文件接口操作/dev/i2c(X)设备文件。

2. 驱动程序操作法：i2c设备的驱动也可以通过普通的设备驱动实现，像往常的驱动一样实现，然后在应用层就可以像读取普通文件一样操作，无需再考虑读写时序。其实普通的设备驱动也可以用两种方法实现，

1）构建字符设备驱动，在open,read,write等函数中直接操作i2c总线的相关寄存器来读写i2c设备，但是这种方法因平台不同，设备不同都要重新写驱动

2）在设备驱动中调用i2c-core.c提供的i2c_transfer函数来实现和i2c设备的通信，这样只要对不同的设备写不同的驱动就行了。

二：首先我们来看一看应用程序操作法：

标准i2c接口提供的标准的设备/dev/i2c，首先我们看看linux下标准i2c的结构。

在/linux-kernel-3.8/drivers/i2c目录下

        ----Algos/                  一些i2c总线适配器通信的算法，个人感觉是用I/O口模拟实现i2c通信的算法

        ----Busses/               I2C总线驱动的方法，对应于君正4775适配器驱动的文件是i2c-jz4775.c

        ----Chips/                 I2C设备驱动，具体到某个设备，比如at24c08等

        ----I2c-boardinfo.c     定义i2c_register_board_info 注册i2c设备相关信息（其实就是将要注册的i2c设备添加到i2c设备链表）

        ----I2c-core.c           I2C核心文件，用于联系设备驱动和总线驱动，作为一个桥梁，有用的函数i2c_add_addapter

                                       i2c_add_driver，和i2c_transfer函数 （其实就是定义了一些标准的API接口函数）

        ----I2c-dev.c            通用的i2c设备驱动（其实就是生成的标准的/dev/i2c字符设备文件接口）

        ----Kconfig

        ----Makefile

我们要选择编译/linux-kernel-3.8/drivers/i2c/相关的platform driver和arch/mips/xburst/soc-4775/board//trunk/core/core-misc.c相结合最终生成的固件就会有/dev/i2c0标准接口。

以下是笔者做qn8025FM驱动时写下的通过标准i2c设备文件实现的读写函数：通过这两个读写函数就可以直接读写i2c设备的寄存器实现想用的功能

/*
* Version: V1.0.2.
* Date: 2014-11-25.
*/

#include "qn8025_i2c.h"

/*源头即是  IOCTL 呼叫, 通道为 I2C_SMBUS,
而 args 则定义了: 读或写, 位置, 长度,  以及回传值的资讯内容.*/
//ioctl(file, I2C_SMBUS, (i2c_smbus_ioctl_data*)msgset);
static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command,
                                     int size, union i2c_smbus_data *data)
{
    struct i2c_smbus_ioctl_data args;

    args.read_write = read_write;
    args.command = command;
    args.size = size;
    args.data = data;
    int ret=  ioctl(file,I2C_SMBUS,&args);//set Smbus transfer
    //printf("ioctl-read_i2c: %#x ", args.data->byte);
    return ret;
}

//向设备发送一个比特
static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
{
    return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,(union i2c_smbus_data *)0);
}
   
static inline __s32 i2c_smbus_read_byte(int file)
{
    union i2c_smbus_data data;
    if (i2c_smbus_access(file,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,&data))
        return -1;
    else
        return 0x0FF & data.byte;
}

static inline __s32 i2c_smbus_write_byte(int file, __u8 value)
{
    return i2c_smbus_access(file,I2C_SMBUS_WRITE,value,
                            I2C_SMBUS_BYTE,(union i2c_smbus_data *)0);
}

static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
{
    union i2c_smbus_data data;
    data.byte = 0;
//    printf("before read_byte: %#x ", data.byte);
    if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
                         I2C_SMBUS_BYTE_DATA,&data))
        return -1;
    else{
//        printf("read_byte: %#x ", data.byte);
        return 0x0FF & data.byte;
        }
}

static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command,
                                              __u8 value)
{
    union i2c_smbus_data data;
    data.byte = value;
//    printf("before write_byte: %#x ", data.byte);
    int ret = i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                            I2C_SMBUS_BYTE_DATA, &data);
//    printf("write_byte: %#x ", data.byte);
    return ret;
}

static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)
{
    union i2c_smbus_data data;
    if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
                         I2C_SMBUS_WORD_DATA,&data))
        return -1;
    else
        return 0x0FFFF & data.word;
}

static inline __s32 i2c_smbus_write_word_data(int file, __u8 command,
                                              __u16 value)
{
    union i2c_smbus_data data;
    data.word = value;
    return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                            I2C_SMBUS_WORD_DATA, &data);
}

static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)
{
    union i2c_smbus_data data;
    data.word = value;
    if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                         I2C_SMBUS_PROC_CALL,&data))
        return -1;
    else
        return 0x0FFFF & data.word;
}

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_block_data(int file, __u8 command,
                                              __u8 *values)
{
    union i2c_smbus_data data;
    int i;
    if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
                         I2C_SMBUS_BLOCK_DATA,&data))
        return -1;
    else {
        for (i = 1; i <= data.block[0]; i++)
            values[i-1] = data.block[i];
        return data.block[0];
    }
}

static inline __s32 i2c_smbus_write_block_data(int file, __u8 command,
                                               __u8 length, const __u8 *values)
{
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i-1];
    data.block[0] = length;
    return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                            I2C_SMBUS_BLOCK_DATA, &data);
}

/* Returns the number of read bytes */
/* Until kernel 2.6.22, the length is hardcoded to 32 bytes. If you
   ask for less than 32 bytes, your code will only work with kernels
   2.6.23 and later. */
static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,
                                                  __u8 length, __u8 *values)
{
    union i2c_smbus_data data;
    int i;

    if (length > 32)
        length = 32;
    data.block[0] = length;
    if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
                         length == 32 ? I2C_SMBUS_I2C_BLOCK_BROKEN :
                          I2C_SMBUS_I2C_BLOCK_DATA,&data))
        return -1;
    else {
        for (i = 1; i <= data.block[0]; i++)
            values[i-1] = data.block[i];
        return data.block[0];
    }
}

static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,
                                                   __u8 length,
                                                   const __u8 *values)
{
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i-1];
    data.block[0] = length;
    return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                            I2C_SMBUS_I2C_BLOCK_BROKEN, &data);
}

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_block_process_call(int file, __u8 command,
                                                 __u8 length, __u8 *values)
{
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i-1];
    data.block[0] = length;
    if (i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                         I2C_SMBUS_BLOCK_PROC_CALL,&data))
        return -1;
    else {
        for (i = 1; i <= data.block[0]; i++)
            values[i-1] = data.block[i];
        return data.block[0];
    }
}

//检测i2c设备功能
/*static int check_funcs(int file, int size, int daddress, int pec)
{
    unsigned long funcs;

    //check adapter functionality
    if (ioctl(file, I2C_FUNCS, &funcs) < 0) {//获取i2c设备支持的功能
        fprintf(stderr, "Error: Could not get the adapter "
            "functionality matrix: %s ", strerror(errno));
        return -1;
    }

    switch (size) {
    case I2C_SMBUS_BYTE:
        if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {
            fprintf(stderr, MISSING_FUNC_FMT, "SMBus receive byte");
            return -1;
        }
        if (daddress >= 0
         && !(funcs & I2C_FUNC_SMBUS_WRITE_BYTE)) {
            fprintf(stderr, MISSING_FUNC_FMT, "SMBus send byte");
            return -1;
        }
        break;

    case I2C_SMBUS_BYTE_DATA:
        if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
            fprintf(stderr, MISSING_FUNC_FMT, "SMBus read byte");
            return -1;
        }
        break;

    case I2C_SMBUS_WORD_DATA:
        if (!(funcs & I2C_FUNC_SMBUS_READ_WORD_DATA)) {
            fprintf(stderr, MISSING_FUNC_FMT, "SMBus read word");
            return -1;
        }
        break;
    }
    if (pec
     && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C))) {
        fprintf(stderr, "Warning: Adapter does "
            "not seem to support PEC ");
    }

    return 0;
}
*/

//设置i2c从设备地址
static int set_slave_addr(int file, int address, int force)
{
    /* With force, let the user read from/write to the registers
       even when a driver is also running */
    if (ioctl(file, force ? I2C_SLAVE_FORCE : I2C_SLAVE, address) < 0) {
        fprintf(stderr,
            "Error: Could not set address to 0x%02x: %s ",
            address, strerror(errno));
        return -errno;
    }

    return 0;
}

//打开i2c设备
static int open_i2c_dev(int i2cbus, char *filename, size_t size, int quiet)
{
    int file;

    snprintf(filename, size, "/dev/i2c/%d", i2cbus);
    filename[size - 1] = '';
    file = open(filename, O_RDWR);//打开i2c设备
    if (file < 0 && (errno == ENOENT || errno == ENOTDIR)) {
        sprintf(filename, "/dev/i2c-%d", i2cbus);
        file = open(filename, O_RDWR);
    }

    if (file < 0 && !quiet) {
        if (errno == ENOENT) {
            fprintf(stderr, "Error: Could not open file "
                "`/dev/i2c-%d' or `/dev/i2c/%d': %s ",
                i2cbus, i2cbus, strerror(ENOENT));
        } else {
            fprintf(stderr, "Error: Could not open file "
                "`%s': %s ", filename, strerror(errno));
            if (errno == EACCES)
                fprintf(stderr, "Run as root? ");
        }
    }

    return file;
}

//向i2c设备写数据 (0, 0x58,  , 9300, 0)
static int i2c_write_data(int i2cbus,int addr,int daddr,int set_val,int vmask)
{
    int res, file;
    int value;
    char filename[20];

    //打开设备描述符，可以自动寻找合适的设备名
    file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);
    if (file < 0 || set_slave_addr(file, addr, 1)) {
    //    perror("open i2c");
        printf("open %s fail ", filename);
        return -1;
    }

    //掩码，可以单独设置某一位而不影响其他位
    if (vmask) {
        int oldvalue;

        oldvalue = i2c_smbus_read_byte_data(file, daddr);
    printf("write and read ");
        if (oldvalue < 0) {
            fprintf(stderr, "Error: Failed to read old value ");
            close(file);
            return -1;
        }

        value = (set_val & vmask) | (oldvalue & ~vmask);
    } else {
        value = set_val;
    }

    res = i2c_smbus_write_byte_data(file, daddr, value);
    if (res < 0) {
        fprintf(stderr, "Error: Write failed ");
        close(file);
        return -1;
    }

    //res = i2c_smbus_read_byte_data(file, daddr);
   
    close(file);

    //if (res < 0) {
    //    printf("Warning - readback failed ");
    //} else
    //if (res != value) {
    //    printf("Warning - data mismatch - wrote 0x%0*x, read back 0x%0*x ",2,value,2, res);
    //} else {
        //printf("Value 0x%0*x written, readback matched ",2, value);
       
        return 0;//读到的值和写入的值一致，才返回成功
    //}

    //return -1;
}

//从i2c读取数据
static int i2c_read_data(int i2cbus,int addr,int daddr,unsigned char *read_data)
{
    int file,res;
    char filename[20] = {0};
    //打开i2c设备
    file = open_i2c_dev(0, filename, sizeof(filename), 0);
    if (file < 0 || set_slave_addr(file, addr, 1))//设置从设备地址
        return -1;

    res = i2c_smbus_read_byte_data(file, daddr);
    close(file);

    if (res < 0) {
        fprintf(stderr, "Error: Read failed ");
        return -1;
    }

    *read_data = res;
    //printf("read data -- 0x%x ",*read_data);

    return 0;
}

/* qn8025 set "set_value" to register "daddr"
addr: slave address
daddr: register address
set_val: the value wiil put into register
vmask: value maske
*/
int qn8025_i2c_write_data(int addr, int daddr, int set_val, int vmask)
{
    return i2c_write_data(0, addr, daddr, set_val, vmask);
}

/* qn8025 get "read_data" from register "daddr"
addr: slave address
daddr: register address
set_val: the value wiil get from register
*/
int qn8025_i2c_read_data(int addr, int daddr, unsigned char *read_data)
{
    return i2c_read_data(0, addr, daddr, read_data);
}