Linux驱动子系统之I2C

转自：http://www.linuxidc.com/Linux/2011-11/47651.htm

感谢作者cjok376240497 给我们写了这么好的分析，前人栽树，后人好乘凉啊~

硬件特性

[概述]

I2C总线是由Philips公司开发的两线式串行总线，这两根线为时钟线(SCL)和双向数据线(SDA)。由于I2C总线仅需要两根线，因此在电路板上占用的空间更少，带来的问题是带宽较窄。I2C在标准模式下传输速率最高100Kb/s，在快速模式下最高可达400kb/s。属于半双工。

在嵌入式系统中，I2C应用非常广泛，大多数微控制器中集成了I2C总线，一般用于和RTC，EEPROM，智能电池电路，传感器，LCD以及其他类似设备之间的通信。 

[I2C总线传输时序]

 

[I2C总线的信号状态]

1、  空闲状态：SDA和SCL都是高电平；

2、  开始条件(S)：SCL为高电平时，SDA由高电平向低电平跳变，开始传输数据；

3、  结束条件(P)：SCL为高电平时，SDA由低电平向高电平跳变，结束传输数据；

4、  数据有效：在SCL的高电平期间，SDA保持稳定，数据有效。SDA的改变只能发生在SCL的低电平期间；

5、  ACK信号：数据传输的过程中，接收器件每接收一个字节数据要产生一个ACK信号，向发送器件发出特定的低电平脉冲，表示已经收到数据。

 

[从设备地址]

I2C总线从设备使用7位地址，最后一个为读写控制位。下图是eeprom的原理图，我们可以计算出它的地址为0x50。

 

[I2C读写方式]

多字节写的时序

多字节读的时序

具体可参考datasheet

子系统

[LinuxI2C子系统架构]

在内核中已经提供I2C子系统，所以在做I2C驱动之前，就必须要熟悉该子系统。

三大组成部分：

1、I2C核心(i2c-core)

I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法(algorithm)上层的、与具体适配器无关的代码以及探测设备、检测设备地址的上层代码等。

2、I2C总线驱动(I2Cadapter/Algo driver)

I2C总线驱动是对I2C硬件体系结构中适配器端的实现，适配器可由CPU控制，甚至集成在CPU内部(大多数微控制器都这么做)。适配器就是我们经常所说的控制器。

经由I2C总线驱动的代码，我们可以控制I2C适配器以主控方式产生开始位，停止位，读写周期，以及以从设备方式被读写，产生ACK等。

I2C总线驱动由i2c_adapter和i2c_algorithm来描述

3、I2C客户驱动程序(I2Cclient driver)

I2C客户驱动是对I2C硬件体系结构中设备端的实现，设备一般挂接在收CPU控制的I2C适配器上，通过I2C适配器与CPU交换数据。

I2C客户驱动程序由i2c_driver来描述

所有的I2C驱动代码位于drivers/i2c目录下

I2c-core.c     实现I2C核心的功能

I2c-dev.c      实现I2C适配器设备文件的功能，每一个I2C适配器都被分配一个设备

Chips         特定的I2C设备驱动

Busses        I2C总线的驱动

Algos         实现了一些I2C总线适配器的algorithm

I2C驱动编写的两种方法

从上面的图我们可以看到两种编写驱动方法，一种是利用系统提供的i2c-dev.c来实现一个i2c适配器的设备文件，然后通过在应用层操作I2C适配器来控制I2C从设备；另一种是为I2C从设备独立编写一个设备驱动，不需要i2c-dev.c文件，相对来说简单很多。

[重要的数据结构]

每次分析子系统免不了分析它的数据结构，OK我们先来分析一下。

I2c_adapter结构体代表一个物理的I2C总线控制器

1. struct i2c_adapter {  
2.    struct module *owner;  
3.    unsigned int class;       /*classes to allow probing for */  
4.    const struct i2c_algorithm *algo; /* the algorithm to access the bus */  
5.    void *algo_data;        /*algorithm 数据 */  
6.    
7.    /* data fields that are valid for all devices   */  
8.    struct rt_mutex bus_lock;  
9.    
10.    int timeout;            /* injiffies */  
11.    int retries;             /* 重试次数 */  
12.    struct device dev;      /* theadapter device */  
13.    
14.    int nr;  
15.    char name[48];         /* 适配器名字 */  
16.    struct completion dev_released;   /* 用于同步 */  
17.    
18.    struct mutex userspace_clients_lock;  
19.    struct list_head userspace_clients;  
20. };  

I2c_algorithm对应一套通信方法

1. struct i2c_algorithm {  
2.          /*I2C传输函数指针 */  
3.    int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,  
4.                int num);  
5.          /*SMBUS传输函数指针 */  
6.    int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,  
7.                unsigned short flags, charread_write,  
8.                u8 command, int size, unioni2c_smbus_data *data);  
9.          /*返回适配器支持的功能 */  
10.    u32 (*functionality) (struct i2c_adapter *);  
11. };  

I2c_driver代表I2C从设备驱动

1. struct i2c_driver {  
2.     unsigned int class;  
3.   
4.     /* 这两个接口已经被probe和remove取代 */  
5.     int (*attach_adapter)(struct i2c_adapter *) __deprecated; /*依附i2c适配器函数指针*/  
6.     int (*detach_adapter)(struct i2c_adapter *) __deprecated;/*脱离i2c适配器函数指针*/  
7.   
8.     /* Standard driver model interfaces */  
9.     int (*probe)(struct i2c_client *, const struct i2c_device_id *);  
10.     int (*remove)(struct i2c_client *);  
11.   
12.     void (*shutdown)(struct i2c_client *);  
13.     int (*suspend)(struct i2c_client *, pm_message_t mesg);  
14.     int (*resume)(struct i2c_client *);  
15.     void (*alert)(struct i2c_client *, unsigned int data);  
16.   
17.     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);  
18.   
19.     struct device_driver driver;  
20.     const struct i2c_device_id *id_table;  /* 该驱动所支持的设备ID表 */  
21.   
22.     /* Device detection callback for automatic device creation */  
23.     int (*detect)(struct i2c_client *, struct i2c_board_info *);  
24.     const unsigned short *address_list;  
25.     struct list_head clients;  
26. };  

I2c_client代表I2C从设备

1. struct i2c_client {  
2. unsigned short flags;                 /*I2C_CLIENT_TEN：使用10位从地址，I2C_CLIENT_PEC：使用SMBus包错误检测*/  
3.          unsignedshort addr;                 /* chipaddress - NOTE: 7bit    */  
4.                                                /*addresses are stored in the         */  
5.                                                /*_LOWER_ 7 bits            */  
6.          charname[I2C_NAME_SIZE];  
7.          structi2c_adapter *adapter; /* 依附的i2c_adapter   */  
8.          structi2c_driver *driver;         /* 依附的i2c_driver*/  
9.          structdevice dev;             /* the devicestructure             */  
10.          intirq;                         /* irq issuedby device               */  
11.          structlist_head detected;  
12. };  

I2c_adapter与i2c_algorithm

一个I2C适配器需要I2C_algorithm中提供的通信函数来控制适配器上产生特定的访问周期。I2c_algorithm中的关键函数master_xfer()用于产生I2C访问周期需要的信号，以i2c_msg为单位。

1. struct i2c_msg {  
2.          __u16addr;     /* slave address                         */  
3.          __u16flags;    /* 读写标志*/  
4.          __u16len;                  /* msg length                              */  
5.          __u8*buf;                 /* pointer to msgdata                       */  
6. };  

I2c_driver与i2c_client

I2c_driver与i2c_client是一对多的关系，一个i2c_driver上可以支持多个同等类型的i2c_client。

 

I2c_adapter与i2c_client

I2c_adapter与i2c_client的关系与I2C硬件体系中适配器和从设备的关系一致，i2c_client依附在i2c_adapter。

[核心层提供的接口函数]

1、  增加/删除I2C适配器

1. int i2c_add_adapter(struct i2c_adapter *adapter)  
2. int i2c_del_adapter(struct i2c_adapter *adap)  

2、  增加/删除I2C从设备驱动

1. int i2c_register_driver(struct module *owner, structi2c_driver *driver)  
2. static inline int i2c_add_driver(struct i2c_driver *driver)  
3. void i2c_del_driver(struct i2c_driver *driver)  

i2c_add_driver是对i2c_register_driver简单的封装

3、  i2c传输，发送和接收

1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg*msgs, int num)  
2. int i2c_master_send(const struct i2c_client *client, constchar *buf, int count)  
3. int i2c_master_recv(const struct i2c_client *client, char*buf, int count)  

i2c_master_send和i2c_master_recv是i2c_transfer的封装

tips：3.1.0的内核中已经没有i2c_attach_client和i2c_detach_client接口

[I2C总线通信方法]

我们需要为特定的I2C适配器实现其通信方法，主要实现i2c_algorithm结构体中的两个函数：

1. struct i2c_algorithm {  
2.          int(*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,  
3.                                int num);  
4.          u32(*functionality) (struct i2c_adapter *);  
5. };  

Functionality函数用于返回algorithm所支持的通信协议；

Master_xfer函数在I2C适配器上完成数据的传输；

Master_xfer函数实现模板

1. static int i2c_adapter_xxx_xfer(structi2c_adapter *adap, struct i2c_msg *msgs, int num)  
2. {  
3.    ......  
4.    for (i = 0; i < num; i++) {  
5.        i2c_adapter_xxx_start();         /*产生起始位*/  
6.        if (msgs[i]->flags & I2C_M_RD) {    /*读取*/  
7.            i2c_adapter_xxx_setaddr((msg->addr << 1) | 1);  /*发送从设备地址*/  
8.            i2c_adapter_xxx_wait_ack();   /*获得从设备的ACK*/  
9. i2c_adapter_xxx_readbytes(msgs[i]->buf,msgs[i]->len);  /*读取len长度的数据到buf中*/  
10.        } else {  
11.            i2c_adapter_xxx_setaddr(msg->addr << 1);  
12.            i2c_adapter_xxx_wait_ack();  
13.            i2c_adapter_xxx_writebytes(msgs[i]->buf, msgs[i]->len);  
14.        }  
15.     }  
16.    i2c_adapter_xxx_stop(); /*产生停止位*/  
17. }  

上面调用的函数用于完成适配器的底层硬件操作，与I2C适配器和CPU的具体硬件直接相关，需要由工程师根据芯片的数据手册来实现。在内核源码中，针对不同的I2C适配器都有master_xfer的实现，风格与模板不尽相同，但是可以用该模板作为参考来看源代码，受益匪浅。

[I2C从设备驱动与I2C适配器的match]

I2C从设备驱动也就是上图中的I2C客户驱动，适配器与从设备是一对多的关系。在这里极好的体现了外设驱动和主机驱动的分离思想，带来优势是极为明显的。

我们来大致分析一下匹配的过程：

添加一个I2C从设备驱动(i2c_driver)

当调用i2c_add_driver函数向I2C总线(i2c-core.c文件中注册的”i2c”总线)增加一个i2c_driver时，会遍历总线中的所有i2c_client，调用总线注册的match函数I2C适配器上是否有与i2c_driver匹配的i2c_client，如果匹配会调用I2C注册的probe函数，然后再调用i2c_driver定义的probe来进行关联和初始化工作。

如果对Linux设备驱动模型有了解，对上面的分析应该不难理解。

i2c-dev

[概述]

之前在介绍I2C子系统时，提到过使用i2c-dev.c文件在应用程序中实现我们的I2C从设备驱动。不过，它实现的是一个虚拟，临时的i2c_client，随着设备文件的打开而产生，并随着设备文件的关闭而撤销。I2c-dev.c针对每个I2C适配器生成一个主设备号为89的设备文件，实现了i2c_driver的成员函数以及文件操作接口，所以i2c-dev.c的主题是”i2c_driver成员函数+字符设备驱动”。

[i2c-dev.c源码分析]

I2c-dev初始化函数主要做了注册名为”i2c”的字符设备文件和”i2c-dev”的类。

I2c-dev.c中实现的i2cdev_read和i2cdev_write函数不具有太强的通用性，只适合下面这种单开始信号情况：

而不适合多开始信号的情况：

所以我们经常会使用i2cdev_ioctl函数的I2C_RDWR，在分析i2cdev_ioctl函数之前，我们需要了解一个结构体：

1. /* This is the structure as used in theI2C_RDWR ioctl call */  
2. struct i2c_rdwr_ioctl_data {  
3.          structi2c_msg __user *msgs;         /* pointersto i2c_msgs */  
4.          __u32nmsgs;                    /* number ofi2c_msgs */  
5. };  

Msgs     表示单个开始信号传递的数据；

Nmsgs     表示有多少个msgs，比如上图，单开始信号时，nmsgs等于1；多开始信号时，nmsgs等于2

1. struct i2c_msg {  
2.          __u16addr;     /* slave address                         */  
3.          __u16flags;  /* 默认为写入 */  
4. #define I2C_M_TEN                  0x0010     /*this is a ten bit chip address */   
5. #define I2C_M_RD           0x0001     /* readdata, from slave to master */   
6. #define I2C_M_NOSTART                  0x4000     /* if I2C_FUNC_PROTOCOL_MANGLING */   
7. #define I2C_M_REV_DIR_ADDR     0x2000     /*if I2C_FUNC_PROTOCOL_MANGLING */   
8. #define I2C_M_IGNORE_NAK          0x1000     /*if I2C_FUNC_PROTOCOL_MANGLING */   
9. #define I2C_M_NO_RD_ACK           0x0800     /* if I2C_FUNC_PROTOCOL_MANGLING */   
10. #define I2C_M_RECV_LEN               0x0400     /* length will be first received byte */   
11.          __u16len;                  /* msg length                              */  
12.          __u8*buf;                 /* pointer to msgdata                       */  
13. };  

使用i2cdev_ioctl函数的I2C_RDWR指令会调用到i2cdev_ioctl_rdrw函数：

1. static noinline inti2cdev_ioctl_rdrw(struct i2c_client *client,  
2.                    unsignedlong arg)  
3. {  
4.          structi2c_rdwr_ioctl_data rdwr_arg;  
5.          structi2c_msg *rdwr_pa;  
6.          u8__user **data_ptrs;  
7.          inti, res;  
8.    
9.          if(copy_from_user(&rdwr_arg,  
10.                                (struct i2c_rdwr_ioctl_data __user *)arg,  
11.                                sizeof(rdwr_arg)))  
12.                    return-EFAULT;  
13.    
14.          /*Put an arbitrary limit on the number of messages that can 
15.           * be sent at once */  
16.          if(rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)  
17.                    return-EINVAL;  
18.    
19.          rdwr_pa= kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL);  
20.          if(!rdwr_pa)  
21.                    return-ENOMEM;  
22.    
23.          if(copy_from_user(rdwr_pa, rdwr_arg.msgs,  
24.                                rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {  
25.                    kfree(rdwr_pa);  
26.                    return-EFAULT;  
27.          }  
28.    
29.          data_ptrs= kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);  
30.          if(data_ptrs == NULL) {  
31.                    kfree(rdwr_pa);  
32.                    return-ENOMEM;  
33.          }  
34.    
35.          res= 0;  
36.          for(i = 0; i < rdwr_arg.nmsgs; i++) {  
37.                    /*Limit the size of the message to a sane amount; 
38.                     * and don't let length change either. */  
39.                    if((rdwr_pa[i].len > 8192) ||  
40.                        (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {  
41.                             res= -EINVAL;  
42.                             break;  
43.                    }  
44.                    data_ptrs[i]= (u8 __user *)rdwr_pa[i].buf;  
45.                    rdwr_pa[i].buf= memdup_user(data_ptrs[i], rdwr_pa[i].len);  
46.                    if(IS_ERR(rdwr_pa[i].buf)) {  
47.                             res= PTR_ERR(rdwr_pa[i].buf);  
48.                             break;  
49.                    }  
50.          }  
51.          if(res < 0) {  
52.                    intj;  
53.                    for(j = 0; j < i; ++j)  
54.                             kfree(rdwr_pa[j].buf);  
55.                    kfree(data_ptrs);  
56.                    kfree(rdwr_pa);  
57.                    returnres;  
58.          }  
59.    
60.          res= i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);  
61.          while(i-- > 0) {  
62.                    if(res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {  
63.                             if(copy_to_user(data_ptrs[i], rdwr_pa[i].buf,  
64.                                                 rdwr_pa[i].len))  
65.                                      res= -EFAULT;  
66.                    }  
67.                    kfree(rdwr_pa[i].buf);  
68.          }  
69.          kfree(data_ptrs);  
70.          kfree(rdwr_pa);  
71.          returnres;  
72. }  

咋一看，还挺复杂，其实主要做了一件事情：把用户空间传递过来的i2c_rdwr_ioctl_data数据进行错误检查，www.linuxidc.com 然后调用i2c_transfer函数与适配器进行通信，如果是接收数据，代码会将访问到的数据传回i2c_rdwr_ioctl_data的buf中。I2c_transfer最终会调用到I2C适配器具体实现的master_xfer函数来与硬件进行通信。

[eeprom实例]

预备知识

使用的mini2440开发板，eeprom的地址为0x50，实验完成一个数据的读写，先看下读写时序

AT24C08任意地址字节写的时序：

AT24C08任意地址字节写的时序：

下面的代码可以按照上面的两个图来阅读：

1. #include <stdio.h>   
2. #include <linux/types.h>   
3. #include <fcntl.h>   
4. #include <unistd.h>   
5. #include <stdlib.h>   
6. #include <sys/types.h>   
7. #include <sys/ioctl.h>   
8. #include <errno.h>   
9. #include <assert.h>   
10. #include <string.h>   
11. #include <linux/i2c.h>   
12. #include <linux/i2c-dev.h>   
13.    
14. int main()  
15. {  
16.          intfd, ret;  
17.          unsignedchar rdwr_addr = 0x42;   /* e2prom 读写地址 */  
18.          unsignedchar device_addr = 0x50; /* e2prom 设备地址 */  
19.          unsignedchar data = 0x12;  /* 向e2prom写的数据 */  
20.          structi2c_rdwr_ioctl_data e2prom_data;  
21.    
22.          fd= open("/dev/i2c/0", O_RDWR);  
23.          if(fd < 0) {  
24.                    perror("openerror");  
25.                    exit(1);  
26.          }  
27.    
28.          e2prom_data.msgs= (struct i2c_msg *)malloc(e2prom_data.nmsgs * \  
29.                                                sizeof(structi2c_msg));  
30.          if(e2prom_data.msgs == NULL) {  
31.                    perror("mallocerror");  
32.                    exit(1);  
33.          }  
34.    
35.          ioctl(fd,I2C_TIMEOUT, 1); /* 设置超时 */  
36.          ioctl(fd,I2C_RETRIES, 2); /* 设置重试次数 */  
37.    
38.           
39.          /*向e2prom的rdwr_addr地址写入数据data*/  
40.          e2prom_data.nmsgs= 1;  
41.          e2prom_data.msgs[0].len= 2;  
42.          e2prom_data.msgs[0].addr= device_addr;  
43.          e2prom_data.msgs[0].flags= 0;     /* write */  
44.    
45.           
46.          e2prom_data.msgs[0].buf= (unsigned char *)malloc(2);  
47.          e2prom_data.msgs[0].buf[0]= rdwr_addr;    /* write address */  
48.          e2prom_data.msgs[0].buf[1]= data;      /* write data */  
49.    
50.          ret= ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);  
51.          if(ret < 0) {  
52.                    perror("writedata error");  
53.                    exit(1);  
54.          }  
55.          printf("writedata: %d to address: %#x\n", data, rdwr_addr);  
56.          data= 0;  /* be zero*/  
57.    
58.    
59.          /*从e2prom的rdwr_addr地址读取数据存入buf*/  
60.          e2prom_data.nmsgs= 2;  
61.          e2prom_data.msgs[0].len= 1;  
62.          e2prom_data.msgs[0].addr= device_addr;  
63. //      e2prom_data.msgs[0].flags= 0;     /* write */   
64.          e2prom_data.msgs[0].buf= &rdwr_addr;  
65.    
66.          e2prom_data.msgs[1].len= 1;  
67.          e2prom_data.msgs[1].addr= device_addr;  
68.          e2prom_data.msgs[1].flags= 1;     /* read */  
69.          e2prom_data.msgs[1].buf= &data;  
70.    
71.          ret= ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);  
72.          if(ret < 0) {  
73.                    perror("readerror");  
74.                    exit(1);  
75.          }  
76.          printf("read  data: %d from address: %#x\n", data,rdwr_addr);  
77.           
78.          free(e2prom_data.msgs);  
79.          close(fd);  
80.    
81.          return0;  
82. }  

在mini2440开发板上已经实验成功。

总线驱动

[概述]

I2C总线驱动是对I2C硬件体系结构中适配器的实现，主要提供了数据传输的算法和各种信号(起始，停止，ACK等)实现的函数，总线驱动由i2c_adapter和i2c_algorithm来描述。

[s3c2440I2C总线驱动分析]

S3c2440I2C控制器的硬件描述

S3c2440处理器内部集成了一个I2C控制器，通过四个寄存器来进行控制：

IICCON     I2C控制寄存器

IICSTAT     I2C状态寄存器

IICDS       I2C收发数据移位寄存器

IICADD     I2C地址寄存器

通过IICCON,IICDS,IICADD寄存器操作，www.linuxidc.com 可在I2C总线上产生开始位、停止位、数据和地址，而传输的状态则通过IICSTAT寄存器来获取。

[i2c-s3c2410代码分析]

I2C总线驱动代码在drivers/i2c/busses/i2c-s3c2410.c，这个代码同样支持s3c2410,s3c6410,s5pc110等Samsung 系列的芯片。 

初始化模块和卸载模块

1. static int __init i2c_adap_s3c_init(void)  
2. {  
3.          returnplatform_driver_register(&s3c24xx_i2c_driver);  
4. }  
5.    
6. static void __exit i2c_adap_s3c_exit(void)  
7. {  
8.          platform_driver_unregister(&s3c24xx_i2c_driver);  
9. }  

总线驱动是基于platform来实现的，很符合设备驱动模型的思想。

1. static struct platform_drivers3c24xx_i2c_driver = {  
2.          .probe                = s3c24xx_i2c_probe,  
3.          .remove            = s3c24xx_i2c_remove,  
4.          .id_table  = s3c24xx_driver_ids,  
5.          .driver                = {  
6.                    .owner     = THIS_MODULE,  
7.                    .name       = "s3c-i2c",  
8.                    .pm  = S3C24XX_DEV_PM_OPS,  
9.                    .of_match_table= s3c24xx_i2c_match,  
10.          },  
11. };  

s3c24xx_i2c_probe函数

当调用platform_driver_register函数注册platform_driver结构体时，如果platformdevice 和 platform driver匹配成功后，会调用probe函数，来初始化适配器硬件。

1. static int s3c24xx_i2c_probe(structplatform_device *pdev)  
2. {  
3.          ……  
4.          /*初始化适配器信息 */  
5.          strlcpy(i2c->adap.name,"s3c2410-i2c", sizeof(i2c->adap.name));  
6.          i2c->adap.owner   = THIS_MODULE;  
7.          i2c->adap.algo    = &s3c24xx_i2c_algorithm;  
8.          i2c->adap.retries= 2;  
9.          i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;  
10.          i2c->tx_setup     = 50;  
11.    
12.          /*初始化自旋锁和等待队列头 */  
13.          spin_lock_init(&i2c->lock);  
14.          init_waitqueue_head(&i2c->wait);  
15.    
16.          /*find the clock and enable it */  
17.          i2c->dev= &pdev->dev;  
18.          i2c->clk= clk_get(&pdev->dev, "i2c");  
19.          clk_enable(i2c->clk);  
20.    
21.          /*映射寄存器 */  
22.          res= platform_get_resource(pdev, IORESOURCE_MEM, 0);  
23.          i2c->ioarea= request_mem_region(res->start, resource_size(res),  
24.                                                 pdev->name);  
25.          i2c->regs= ioremap(res->start, resource_size(res));  
26.    
27.          /*设置I2C核心需要的信息 */  
28.          i2c->adap.algo_data= i2c;  
29.          i2c->adap.dev.parent= &pdev->dev;  
30.    
31.          /*初始化I2C控制器 */  
32.          ret= s3c24xx_i2c_init(i2c);  
33.    
34.          /*申请中断 */  
35.          i2c->irq= ret = platform_get_irq(pdev, 0);  
36.          ret= request_irq(i2c->irq, s3c24xx_i2c_irq, 0,  
37.                               dev_name(&pdev->dev), i2c);  
38.    
39.          ret= s3c24xx_i2c_register_cpufreq(i2c);  
40.          i2c->adap.nr= i2c->pdata->bus_num;  
41.          i2c->adap.dev.of_node= pdev->dev.of_node;  
42.    
43.          ret= i2c_add_numbered_adapter(&i2c->adap);  
44.           
45.          /*注册I2C适配器 */  
46.          of_i2c_register_devices(&i2c->adap);  
47.          platform_set_drvdata(pdev,i2c);  
48.    
49.          dev_info(&pdev->dev,"%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));  
50.          clk_disable(i2c->clk);  
51.          return0;  
52.          ……  
53. }  

Probe主要工作是时能硬件并申请I2C适配器使用的IO地址，中断号等，然后向I2C核心添加这个适配器。当处理器包含多个I2C控制器时，我们通过板文件定义的platform数据中的bus_num来区分。

I2C总线通信方法

1. static const struct i2c_algorithms3c24xx_i2c_algorithm = {  
2.          .master_xfer             = s3c24xx_i2c_xfer,  
3.          .functionality             = s3c24xx_i2c_func,  
4. };  

s3c24xx_i2c_xfer函数是总线通信方式的具体实现；

s3c24xx_i2c_func函数返回适配器所支持的通信功能。

完整的通信过程还需要借助中断s3c24xx_i2c_irq，具体分析可以参考《Linux设备驱动开发详解》

[适配器的设备资源]

S3c2440的I2C总线驱动是基于platform来实现，前面我们分析了platformdriver部分，再来看下platform device部分。

在arch/arm/plat-samsung/dev-i2c0.c文件中定义了platform_device结构体以及I2C控制器的资源信息：

1. static struct resource s3c_i2c_resource[] ={  
2.          [0]= {  
3.                    .start= S3C_PA_IIC,  
4.                    .end   = S3C_PA_IIC + SZ_4K - 1,  
5.                    .flags= IORESOURCE_MEM,  
6.          },  
7.          [1]= {  
8.                    .start= IRQ_IIC,  
9.                    .end   = IRQ_IIC,  
10.                    .flags= IORESOURCE_IRQ,  
11.          },  
12. };  
13.    
14. struct platform_device s3c_device_i2c0 = {  
15.          .name                 = "s3c2410-i2c",   /* 设备名 */  
16. #ifdef CONFIG_S3C_DEV_I2C1   
17.          .id               = 0,  
18. #else   
19.          .id               = -1,  
20. #endif   
21.          .num_resources         =ARRAY_SIZE(s3c_i2c_resource),  
22.          .resource   =s3c_i2c_resource,  
23. };  
24.    
25. struct s3c2410_platform_i2cdefault_i2c_data __initdata = {  
26.          .flags                  = 0,  
27.          .slave_addr      = 0x10,  /* I2C适配器的地址 */  
28.          .frequency        = 100*1000,  /* 总线频率 */  
29.          .sda_delay        = 100,   /* SDA边沿延迟时间ns */  
30. };  
31.    
32. void __init s3c_i2c0_set_platdata(structs3c2410_platform_i2c *pd)  
33. {  
34.          structs3c2410_platform_i2c *npd;  
35.    
36.          if(!pd)  
37.                    pd= &default_i2c_data;  
38.    
39.          npd= s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),  
40.                                    &s3c_device_i2c0);  
41.    
42.          if(!npd->cfg_gpio)  
43.                    npd->cfg_gpio= s3c_i2c0_cfg_gpio;  
44. }  

在板文件中把platform_device注册进内核：

1. static struct platform_device*mini2440_devices[] __initdata = {  
2.          ……  
3.          &s3c_device_i2c0,  
4. ……  
5. };  

调用s3c_i2c0_set_platdata 函数把适配器具体的数据赋值给dev.platform_data：

1. static void __init mini2440_init(void)  
2. {  
3.          ……  
4. s3c_i2c0_set_platdata(NULL);  
5. }  

I2C总线驱动就分析到这里。

客户驱动

5 客户驱动

5.1 概述

I2C客户驱动是对I2C从设备的实现，一个具体的I2C客户驱动包括两个部分：一部分是i2c_driver，用于将设备挂接于i2c总线；另一部分是设备本身的驱动。

I2C客户驱动程序主要由i2c_driver和i2c_client来描述。 

5.2 实例源码分析

好了，我们来深入了解客户驱动代码的实现，drivers/misc/eeprom/at24.c文件支持大多数I2C接口的eeprom

I2c_driver实现

1. static struct i2c_driver at24_driver = {  
2.          .driver= {  
3.                    .name= "at24",  
4.                    .owner= THIS_MODULE,  
5.          },  
6.          .probe= at24_probe,  /* 当i2c_client和i2c_driver匹配时调用 */  
7.          .remove= __devexit_p(at24_remove), /* 注销时调用 */  
8.          .id_table= at24_ids,   /* i2c_driver支持的i2c_client类型 */  
9. };  

初始化和卸载

1. static int __init at24_init(void)  
2. {  
3.          returni2c_add_driver(&at24_driver);  
4. }  
5.    
6. static void __exit at24_exit(void)  
7. {  
8.          i2c_del_driver(&at24_driver);  
9. }  

At24_Probe函数

1. static int at24_probe(struct i2c_client*client, const struct i2c_device_id *id)  
2. {  
3.          ……  
4.           
5.          /* 
6.           * Export the EEPROM bytes through sysfs, sincethat's convenient. 
7.           * By default, only root should see the data(maybe passwords etc) 
8.           */  
9.          sysfs_bin_attr_init(&at24->bin);  
10.          at24->bin.attr.name= "eeprom";  
11.          at24->bin.attr.mode= chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;  
12.          at24->bin.read= at24_bin_read;  
13.          at24->bin.size= chip.byte_len;  
14.    
15.          at24->macc.read= at24_macc_read;  
16.         writable = !(chip.flags &AT24_FLAG_READONLY);  
17.          if(writable) {  
18.                    if(!use_smbus || i2c_check_functionality(client->adapter,  
19.                                      I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)){  
20.    
21.                             unsignedwrite_max = chip.page_size;  
22.    
23.                             at24->macc.write= at24_macc_write;  
24.    
25.                             at24->bin.write= at24_bin_write;  
26.                             at24->bin.attr.mode|= S_IWUSR;  
27.                             ……  
28.          }  
29. ……  
30.           
31. err = sysfs_create_bin_file(&client->dev.kobj,&at24->bin);  
32.          if(err)  
33.                    gotoerr_clients;  
34.    
35.          i2c_set_clientdata(client,at24);  
36.          ……  
37. }  

Probe函数主要的工作是在sys目录下创建bin节点文件，用户可以同此节点文件来操作eeprom，并提供操作方法(read，write) 

5.3  I2c_client实现

At24c不依赖于具体的CPU和I2C控制器硬件特性，因此如果电路板包含该外设，只需要添加对应的i2c_board_info，下面是at24c08 i2c_client在板文件中的实现：

1. static struct at24_platform_data at24c08 ={  
2.          .byte_len = SZ_8K / 8,   /* eeprom的存储大小B */  
3.          .page_size        = 16,      /* 页大小 */  
4. };  
5.    
6. static struct i2c_board_infomini2440_i2c_devs[] __initdata = {  
7.          {  
8.                    I2C_BOARD_INFO("24c08",0x50),          /* 24c08设备名，0x50设备地址 */  
9.                    .platform_data= &at24c08,  
10.          },  
11. };  
12. static void __init mini2440_init(void)  
13. {  
14.          ……  
15.          i2c_register_board_info(0,mini2440_i2c_devs,  
16.                                      ARRAY_SIZE(mini2440_i2c_devs));  
17.          ……  
18. }  

I2c_register_board_info函数会把I2C从设备硬件特性信息注册到全局链表__i2c_board_list，在调用i2c_add_adapter函数时，会遍历__i2c_board_list获得从设备信息来构造i2c_client。 

I2c_client的构建

我们调用I2c_register_board_info函数会把I2C从设备硬件特性信息注册到全局链表__i2c_board_list，但是还没有构建出一个i2c_client结构体，也没有注册进I2C总线。我们来分析一下构造的过程，调用i2c_add_adapter函数时，会遍历__i2c_board_list获得从设备信息来构造i2c_client：i2c_register_adapter()->i2c_scan_static_board_info()->i2c_new_device()->device_register()。 

5.4  I2c_driver和i2c_client的match

在调用i2c_add_driver注册i2c_driver和构建i2c_client时，都会调用i2c bus中注册的i2c_device_match()->i2c_match_id()函数通过i2c_driver->id_table->name和client->name来匹配

1. static const struct i2c_device_id*i2c_match_id(const struct i2c_device_id *id,  
2.                                                         conststruct i2c_client *client)  
3. {  
4.          while(id->name[0]) {  
5.                    if(strcmp(client->name, id->name) == 0)  
6.                             returnid;  
7.                    id++;  
8.          }  
9.          returnNULL;  
10. }  

5.5 测试

已在mini2440上实验成功，在/sys/bus/i2c/devices/0-0050/目录下(50代表从设备地址)会产生一个eeprom文件，这个文件相当于是硬件设备eeprom的映射，我们可以像普通文件一样对eeprom文件进行操作，实质上就是就硬件eeprom的操作。重启开发板，你会发现对eeprom文件修改过的内容不会改变，这就证明实验成功了，要知道sys文件系统是无法对数据保存的。

总结

6 总结

下图根据之前的分析丰富的架构图

Tips：I2C适配器驱动不一定是基于platform实现，这里是以s3c-i2c为例。

 

I2c_driver、i2c_client与i2c_adapter

I2c_driver与i2c_client是一对多的关系，一个i2c_driver上可以支持多个同等类型的i2c_client。调用i2c_add_driver函数将I2c_driver注册到I2C总线上，调用i2c_register_board_info函数将i2c_client注册到全局链表__i2c_board_list。当调用i2c_add_adapter注册适配器时，遍历__i2c_board_list链表，i2c_register_adapter()->i2c_scan_static_board_info()->i2c_new_device()会构建i2c_client结构。当调用i2c_add_driver时，会先注册i2c_driver到I2C总线上，然后调用I2C BUS注册的match函数进行匹配，如果匹配成功，则先调用I2C BUS中注册的probe函数，在调用i2c_driver中实现的probe函数，完成相应的工作。