linux IIC子系统分析(七)——实例分析通过i2c-dev操作I2C设备

在前面的platform device和platform driver初始化中，我们已经实现了I2C总线驱动（adapter），但是我们的设备驱动还没有实现。如果我们现在要访问I2C设备（比如eeprom），我知道的有三总方法：

（一）i2c-dev操作I2C设备：不用添加设备驱动，用户直接在应用层完成对具体I2C 设备的驱动工作。

（二）sysfs操作I2C设备：需添加设备驱动，通过sys展示出来的文件操作设备（比如/sys/devices/platform/s3c2440-i2c/i2c-0/0-0050/eeprom）

（三）设备节点操作i2C设备：添加设备驱动，为设备驱动创建设备节点，从/dev访问I2C设备（比如/dev/eeprom）

AT24C02芯片在《linux IIC子系统分析(一)——AT24C02芯片简介》已介绍

下面以AT24C02为I2C设备实例，分别实现这三种方法。

用户要在应用程序的dev 目录下看到i2c设备节点，需要内核配置IIC选项：

I2C support-->

I2C device interface 

选上该选项之后，内核将会把i2c-dev.c文件编译进内核，同时产生设备节点/dev/i2c/n，它代表一个可操作的适配器。如果不配置I2C device interface，将看不到节点/dev/i2c/n。 view plain

查看include/linux/i2c-dev.h文件，可以看到i2c-dev支持的IOCTL命令。如i2c-dev IOCTL命令

#define I2C_RETRIES                    0x0701     /*设置收不到ACK时的重试次数*/

#define I2C_TIMEOUT                 0x0702 /* 设置超时时限的jiffies */

#define I2C_SLAVE                       0x0703 /*设置从机地址 */

#define I2C_SLAVE_FORCE        0x0706  /* 强制设置从机地址 */

#define I2C_TENBIT                      0x0704 /*选择地址位长:=0 for 7bit , != 0 for 10 bit */

#define I2C_FUNCS                      0x0705 /*获取适配器支持的功能 */

#define I2C_RDWR                        0x0707                                 /*Combined R/W transfer (one STOP only)  */

#define I2C_PEC                            0x0708                                  /* != 0 to use PEC with SMBus */

#define I2C_SMBUS                      0x0720                                   /*SMBus transfer  */

  co

 /*i2c_test.c
 */
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 //#include
 #define I2C_RETRIES 0x070
 #define I2C_TIMEOUT 0x0702
 #define I2C_RDWR 0x0707
 /*********定义struct i2c_rdwr_ioctl_data和struct i2c_msg，要和内核一致*******/
 struct i2c_msg
 {
     unsigned short addr;
     unsigned short flags;
     #define I2C_M_TEN 0x0010
     #define I2C_M_RD 0x0001
     unsigned short len;
     unsigned charchar *buf;
 };
 struct i2c_rdwr_ioctl_data
 {
     struct i2c_msg *msgs;
     int nmsgs;
     /* nmsgs这个数量决定了有多少开始信号，对于“单开始时序”，取1*/
 };

 int main()
 {
         int fd,ret;
         struct i2c_rdwr_ioctl_data e2prom_data;
         fd=open("/dev/i2c/0",O_RDWR);
         if(fd<0)
         {
                 perror("open error");
         }
         e2prom_data.nmsgs=2;
         e2prom_data.msgs=(struct i2c_msg*)malloc(e2prom_data.nmsgs*sizeof(struct i2c_msg));
         if(!e2prom_data.msgs)
         {
                 perror("malloc error");
                 exit(1);
         }
         ioctl(fd,I2C_TIMEOUT,1);
         ioctl(fd,I2C_RETRIES,2);
         /***write data to e2prom**/

         e2prom_data.nmsgs=1;
         (e2prom_data.msgs[0]).len=2;
         (e2prom_data.msgs[0]).addr=0x50;
         (e2prom_data.msgs[0]).flags=0;
         (e2prom_data.msgs[0]).buf=(unsigned char*)malloc(2);
         (e2prom_data.msgs[0]).buf[0]=0x10;
         (e2prom_data.msgs[0]).buf[1]=0x58;
         ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);
         if(ret<0)
         {
                 perror("ioctl error1");
         }
         sleep(1);
         /******read data from e2prom*******/
         e2prom_data.nmsgs=2;
         (e2prom_data.msgs[0]).len=1;
         (e2prom_data.msgs[0]).addr=0x50;
         (e2prom_data.msgs[0]).flags=0;//write
         (e2prom_data.msgs[0]).buf[0]=0x10;
         (e2prom_data.msgs[1]).len=1;
         (e2prom_data.msgs[1]).addr=0x50;
         (e2prom_data.msgs[1]).flags=I2C_M_RD;//read
         (e2prom_data.msgs[1]).buf=(unsigned char*)malloc(1);
         (e2prom_data.msgs[1]).buf[0]=0;
         ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);
         if(ret<0)
         {
                 perror("ioctl error2");
         }
         printf("buff[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);
         close(fd);
         return 0;
 }

经测试，可以正常输出：buff[0]=58

从上面的代码中可以看出来，用户直接在应用层通过适配器dev/i2c/0接口操作连接在I2C0总线上的设备。这种操作方式需要对I2C通讯总线以及I2C设备都非常熟悉才能够很好的操作，并且它的可移植性非常的差。对那些非常简单的I2C设备进行简单的操作可以使用这种方法。

上面代码是我自己写的一个测试程序。

如果要在应用层实现对EEPROM设备的所有操作接口函数，友善支臂有提供更好的应用程序。

以下代码为友善支臂提供，以供参考：

24cXX.h

 /***************************************************************************
     copyright            : (C) by 2003-2004 Stefano Barbato
     email                : [email protected]

     $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $
  ***************************************************************************/

 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #ifndef _24CXX_H_
 #define _24CXX_H_
 #include
 #include

 #define EEPROM_TYPE_UNKNOWN 0
 #define EEPROM_TYPE_8BIT_ADDR   1
 #define EEPROM_TYPE_16BIT_ADDR  2

 struct eeprom
 {
     charchar *dev;  // device file i.e. /dev/i2c-N
     int addr;   // i2c address
     int fd;     // file descriptor
     int type;   // eeprom type
 };

 /*
  * opens the eeprom device at [dev_fqn] (i.e. /dev/i2c-N) whose address is
  * [addr] and set the eeprom_24c32 [e]
  */
 int eeprom_open(charchar *dev_fqn, int addr, int type, struct eeprom*);
 /*
  * closees the eeprom device [e]
  */
 int eeprom_close(struct eeprom *e);
 /*
  * read and returns the eeprom byte at memory address [mem_addr]
  * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address)
  */
 int eeprom_read_byte(struct eeprom* e, __u16 mem_addr);
 /*
  * read the current byte
  * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address)
  */
 int eeprom_read_current_byte(struct eeprom *e);
 /*
  * writes [data] at memory address [mem_addr]
  * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address)
  */
 int eeprom_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data);

 #endif

24cXX.c 

 /***************************************************************************
     copyright            : (C) by 2003-2004 Stefano Barbato
     email                : [email protected]

     $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $
  ***************************************************************************/

 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include "24cXX.h"


 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;
     return ioctl(file,I2C_SMBUS,&args);
 }


 static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
 {
     return i2c_smbus_access(file,value,0,I2C_SMBUS_QUICK,NULL);
 }

 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,NULL);
 }

 static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
 {
     union i2c_smbus_data data;
     if (i2c_smbus_access(file,I2C_SMBUS_READ,command,
                          I2C_SMBUS_BYTE_DATA,&data))
         return -1;
     else
         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;
     return i2c_smbus_access(file,I2C_SMBUS_WRITE,command,
                             I2C_SMBUS_BYTE_DATA, &data);
 }

 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, __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 */
 static inline __s32 i2c_smbus_read_i2c_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_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, __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_DATA, &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];
     }
 }

 static int i2c_write_1b(struct eeprom *e, __u8 buf)
 {
     int r;
     // we must simulate a plain I2C byte write with SMBus functions
     r = i2c_smbus_write_byte(e->fd, buf);
     if(r < 0)
         fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));
     usleep(10);
     return r;
 }

 static int i2c_write_2b(struct eeprom *e, __u8 buf[2])
 {
     int r;
     // we must simulate a plain I2C byte write with SMBus functions
     r = i2c_smbus_write_byte_data(e->fd, buf[0], buf[1]);
     if(r < 0)
         fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));
     usleep(10);
     return r;
 }

 static int i2c_write_3b(struct eeprom *e, __u8 buf[3])
 {
     int r;
     // we must simulate a plain I2C byte write with SMBus functions
     // the __u16 data field will be byte swapped by the SMBus protocol
     r = i2c_smbus_write_word_data(e->fd, buf[0], buf[2] << 8 | buf[1]);
     if(r < 0)
         fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));
     usleep(10);
     return r;
 }


 #define CHECK_I2C_FUNC( var, label ) \
     do {    if(0 == (var & label)) { \
         fprintf(stderr, "\nError: " \
             #label " function is required. Program halted.\n\n"); \
         exit(1); } \
     } while(0);

 int eeprom_open(charchar *dev_fqn, int addr, int type, struct eeprom* e)
 {
     int funcs, fd, r;
     e->fd = e->addr = 0;
     e->dev = 0;

     fd = open(dev_fqn, O_RDWR);
     if(fd <= 0)
     {
         fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
         return -1;
     }

     // get funcs list
     if((r = ioctl(fd, I2C_FUNCS, &funcs) < 0))
     {
         fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
         return -1;
     }


     // check for req funcs
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE );
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE );
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_BYTE_DATA );
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_BYTE_DATA );
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_READ_WORD_DATA );
     CHECK_I2C_FUNC( funcs, I2C_FUNC_SMBUS_WRITE_WORD_DATA );

     // set working device
     if( ( r = ioctl(fd, I2C_SLAVE, addr)) < 0)
     {
         fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
         return -1;
     }
     e->fd = fd;
     e->addr = addr;
     e->dev = dev_fqn;
     e->type = type;
     return 0;
 }

 int eeprom_close(struct eeprom *e)
 {
     close(e->fd);
     e->fd = -1;
     e->dev = 0;
     e->type = EEPROM_TYPE_UNKNOWN;
     return 0;
 }

 #if 0
 int eeprom_24c32_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
 {
     __u8 buf[3] = { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
     return i2c_write_3b(e, buf);
 }


 int eeprom_24c32_read_current_byte(struct eeprom* e)
 {
     ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
     return i2c_smbus_read_byte(e->fd);
 }

 int eeprom_24c32_read_byte(struct eeprom* e, __u16 mem_addr)
 {
     int r;
     ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
     __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
     r = i2c_write_2b(e, buf);
     if (r < 0)
         return r;
     r = i2c_smbus_read_byte(e->fd);
     return r;
 }
 #endif


 int eeprom_read_current_byte(struct eeprom* e)
 {
     ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
     return i2c_smbus_read_byte(e->fd);
 }

 int eeprom_read_byte(struct eeprom* e, __u16 mem_addr)
 {
     int r;
     ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
     if(e->type == EEPROM_TYPE_8BIT_ADDR)
     {
         __u8 buf =  mem_addr & 0x0ff;
         r = i2c_write_1b(e, buf);
     } else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
         __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
         r = i2c_write_2b(e, buf);
     } else {
         fprintf(stderr, "ERR: unknown eeprom type\n");
         return -1;
     }
     if (r < 0)
         return r;
     r = i2c_smbus_read_byte(e->fd);
     return r;
 }

 int eeprom_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
 {
     if(e->type == EEPROM_TYPE_8BIT_ADDR) {
         __u8 buf[2] = { mem_addr & 0x00ff, data };
         return i2c_write_2b(e, buf);
     } else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
         __u8 buf[3] =
             { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
         return i2c_write_3b(e, buf);
     }
     fprintf(stderr, "ERR: unknown eeprom type\n");
     return -1;
 }

copeeprog.c

 /***************************************************************************
     copyright            : (C) by 2009 Guangzhou FriendlyaRM, in China
     email                : [email protected]
     website      : http://www.arm9.net

  ***************************************************************************/

 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include "24cXX.h"

 #define usage_if(a) do { do_usage_if( a , __LINE__); } while(0);
 void do_usage_if(int b, int line)
 {
     const static charchar *eeprog_usage =
         "I2C-24C08(256 bytes) Read/Write Program, ONLY FOR TEST!\n"
         "FriendlyARM Computer Tech. 2009\n";
     if(!b)
         return;
     fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);
     exit(1);
 }


 #define die_if(a, msg) do { do_die_if( a , msg, __LINE__); } while(0);
 void do_die_if(int b, char* msg, int line)
 {
     if(!b)
         return;
     fprintf(stderr, "Error at line %d: %s\n", line, msg);
     fprintf(stderr, "   sysmsg: %s\n", strerror(errno));
     exit(1);
 }


 static int read_from_eeprom(struct eeprom *e, int addr, int size)
 {
     int ch, i;
     for(i = 0; i < size; ++i, ++addr)
     {
         die_if((ch = eeprom_read_byte(e, addr)) < 0, "read error");
         if( (i % 16) == 0 )
             printf("\n %.4x|  ", addr);
         else if( (i % 8) == 0 )
             printf("  ");
         printf("%.2x ", ch);
         fflush(stdout);
     }
     fprintf(stderr, "\n\n");
     return 0;
 }

 static int write_to_eeprom(struct eeprom *e, int addr)
 {
     int i;
     for(i=0, addr=0; i<256; i++, addr++)
     {
         if( (i % 16) == 0 )
             printf("\n %.4x|  ", addr);
         else if( (i % 8) == 0 )
             printf("  ");
         printf("%.2x ", i);
         fflush(stdout);
         die_if(eeprom_write_byte(e, addr, i), "write error");
     }
     fprintf(stderr, "\n\n");
     return 0;
 }

 int main(int argc, char** argv)
 {
     struct eeprom e;
     int op;

     op = 0;

     usage_if(argc != 2 || argv[1][0] != '-' || argv[1][2] != '\0');
     op = argv[1][1];

     fprintf(stderr, "Open /dev/i2c/0 with 8bit mode\n");
     die_if(eeprom_open("/dev/i2c/0", 0x50, EEPROM_TYPE_8BIT_ADDR, &e) < 0,
             "unable to open eeprom device file "
             "(check that the file exists and that it's readable)");
     switch(op)
     {
     case 'r':
         fprintf(stderr, "  Reading 256 bytes from 0x0\n");
         read_from_eeprom(&e, 0, 256);
         break;
     case 'w':
         fprintf(stderr, "  Writing 0x00-0xff into 24C08 \n");
         write_to_eeprom(&e, 0);
         break;
     default:
         usage_if(1);
         exit(1);
     }
     eeprom_close(&e);

     return 0;
 }

Makefile

 CFLAGS= -Wall -O2
 CC=arm-linux-gcc

 i2c: eeprog.o 24cXX.o
     $(CC) $(CFLAGS) -o i2c eeprog.o 24cXX.o

 clean:
     rm -f i2c 24cXX.o eeprog.o

说明：

1.分析的内核版本是linux2.6.32.2

2.开发板为友善之臂的mini2440, 用的是ARM9(S3C2440A)处理器

3.链接的IIC设备是EEPROM(AT24C02)

4.按照内核I2C子系统的注册顺序分析。