I2C 是很常用的一个串行通信接口，用于连接各种外设、传感器等器件。所以 I2C 是做嵌入式开发必须掌握的。 I.MX6U 有 4 个 I2C 接口，可以通过这 4 个 I2C 接口来连接一些 I2C 外设。

我们来学习一下如何在 Linux 下开发 I2C 接口器件驱动，重点是学习 Linux 下的 I2C 驱动框架，按照指定的框架去编写 I2C 设备驱动。.MX6U-ALPHA 使用 I2C1 接口连接了一个距离传感器 ，以 I.MX6U-ALPHA 开发板上的 AP3216C 这个三合一环境光传感器为例，通过 AP3216C 讲解一下如何编写 Linux 下的 I2C 设备驱动程序。

1. I2C & AP3216C简介

1.1 I2C 简介

I2C 是很常见的一种总线协议， I2C 是 NXP 公司设计的， I2C 使用两条线在主控制器和从机之间进行数据通信。一条是 SCL(串行时钟线)，另外一条是 SDA(串行数据线)，这两条数据线需要接上拉电阻，总线空闲的时候 SCL 和 SDA 处于高电平。 I2C 总线标准模式下速度可以达到 100Kb/S，快速模式下可以达到 400Kb/S。 I2C 总线工作是按照一定的协议来运行的，接下来就看一下 I2C 协议。

I2C 是支持多从机的，也就是一个 I2C 控制器下可以挂多个 I2C 从设备，这些不同的 I2C从设备有不同的器件地址，这样 I2C 主控制器就可以通过 I2C 设备的器件地址访问指定的 I2C设备了，一个 I2C 总线连接多个 I2C 设备如图 26.1.1.1 所示：

图 26.1.1.1 中 SDA 和 SCL 这两根线必须要接一个上拉电阻，一般是 4.7K。其余的 I2C 从器件都挂接到 SDA 和 SCL 这两根线上，这样就可以通过 SDA 和 SCL 这两根线来访问多个 I2C设备。

接下来看一下 I2C 协议有关的术语：

1、起始位

顾名思义，也就是 I2C 通信起始标志，通过这个起始位就可以告诉 I2C 从机，“我”要开始进行 I2C 通信了。在 SCL 为高电平的时候， SDA 出现下降沿就表示为起始位，如图 26.1.1.2 所示：

2、停止位

停止位就是停止 I2C 通信的标志位，和起始位的功能相反。在 SCL 为高电平的时候， SDA出现上升沿就表示为停止位，如图 26.1.1.3 所示：

3、数据传输

I2C 总线在数据传输的时候要保证在 SCL 高电平期间， SDA 上的数据稳定，因此 SDA 上的数据变化只能在 SCL 低电平期间发生，如图 26.1.1.4 所示：

4、应答信号

当 I2C 主机发送完 8 位数据以后会将 SDA 设置为输入状态，等待 I2C 从机应答，也就是等到 I2C 从机告诉主机它接收到数据了。应答信号是由从机发出的，主机需要提供应答信号所需的时钟，主机发送完 8 位数据以后紧跟着的一个时钟信号就是给应答信号使用的。从机通过将 SDA 拉低来表示发出应答信号，表示通信成功，否则表示通信失败。

5、I2C 写时序

主机通过 I2C 总线与从机之间进行通信不外乎两个操作：写和读， I2C 总线单字节写时序如图 26.1.1.5 所示：

图 26.1.1.5 就是 I2C 写时序，我们来看一下写时序的具体步骤：

1)、开始信号。
2)、发送 I2C 设备地址，每个 I2C 器件都有一个设备地址，通过发送具体的设备地址来决定访问哪个 I2C 器件。这是一个 8 位的数据，其中高 7 位是设备地址，最后 1 位是读写位，为1 的话表示这是一个读操作，为 0 的话表示这是一个写操作。
3)、 I2C 器件地址后面跟着一个读写位，为 0 表示写操作，为 1 表示读操作。
4)、从机发送的 ACK 应答信号。
5)、重新发送开始信号。
6)、发送要写写入数据的寄存器地址。
7)、从机发送的 ACK 应答信号。
8)、发送要写入寄存器的数据。
9)、从机发送的 ACK 应答信号。
10)、停止信号。

6、I2C 读时序

I2C 总线单字节读时序如图 26.1.1.6 所示：

I2C 单字节读时序比写时序要复杂一点，读时序分为 4 大步，第一步是发送设备地址，第二步是发送要读取的寄存器地址，第三步重新发送设备地址，最后一步就是 I2C 从器件输出要读取的寄存器值，我们具体来看一下这几步。

1)、主机发送起始信号。
2)、主机发送要读取的 I2C 从设备地址。
3)、读写控制位，因为是向 I2C 从设备发送数据，因此是写信号。
4)、从机发送的 ACK 应答信号。
5)、重新发送 START 信号。
6)、主机发送要读取的寄存器地址。
7)、从机发送的 ACK 应答信号。
8)、重新发送 START 信号。
9)、重新发送要读取的 I2C 从设备地址。
10)、读写控制位，这里是读信号，表示接下来是从 I2C 从设备里面读取数据。
11)、从机发送的 ACK 应答信号。
12)、从 I2C 器件里面读取到的数据。
13)、主机发出 NO ACK 信号，表示读取完成，不需要从机再发送 ACK 信号了。
14)、主机发出 STOP 信号，停止 I2C 通信。

7、I2C 多字节读写时序

有时候我们需要读写多个字节，多字节读写时序和单字节的基本一致，只是在读写数据的时候可以连续发送多个字节的数据，其他的控制时序都是和单字节一样的。

1.2 I.MX6U I2C 简介

I.MX6U 提供了 4 个 I2C 外设，通过这四个 I2C 外设即可完成与 I2C 从器件进行通信，I.MX6U 的 I2C 外设特性如下：

1、与标准 I2C 总线兼容。
2、多主机运行
3、软件可编程的 64 中不同的串行时钟序列。
4、软件可选择的应答位。
5、开始/结束信号生成和检测。
6、重复开始信号生成。
7、确认位生成。
8、总线忙检测

I.MX6U 的 I2C 支持两种模式：标准模式和快速模式，标准模式下 I2C 数据传输速率最高是 100Kbits/s，在快速模式下数据传输速率最高为 400Kbits/s。

我们接下来看一下 I2C 的几个重要的寄存器，首先看一下 I2Cx_IADR(x=1~4)寄存器，这是I2C 的地址寄存器，此寄存器结构如图 26.1.2.1 所示：

寄存器 I2Cx_IADR 只有 ADR(bit7:1)位有效，用来保存 I2C 从设备地址数据。当我们要访问某个 I2C 从设备的时候就需要将其设备地址写入到 ADR 里面。接下来看一下寄存器I2Cx_IFDR，这个是 I2C 的分频寄存器，寄存器结构如图 26.1.2.2 所示：

寄存器 I2Cx_IFDR 也只有 IC(bit5:0)这个位，用来设置 I2C 的波特率，I2C 的时钟源可以选择 IPG_CLK_ROOT=66MHz，通过设置 IC 位既可以得到想要的 I2C 波特率。 IC 位可选的设置如图 26.1.2.3 所示：

不像其他外设的分频设置一样可以随意设置，图 26.1.2.3 中列出了 IC 的所有可选值。比如现在I2C的时钟源为66MHz，我们要设置I2C的波特率为100KHz，那么IC就可以设置为0X15，也就是 640 分频。 66000000/640=103.125KHz≈100KHz。

接下来看一下寄存器 I2Cx_I2CR，这个是 I2C 控制寄存器，此寄存器结构如图 26.1.2.4 所示：

寄存器 I2Cx_I2CR 的各位含义如下：

IEN(bit7)： I2C 使能位，为 1 的时候使能 I2C，为 0 的时候关闭 I2C。
IIEN(bit6)： I2C 中断使能位，为 1 的时候使能 I2C 中断，为 0 的时候关闭 I2C 中断。
MSTA(bit5)：主从模式选择位，设置 IIC 工作在主模式还是从模式，为 1 的时候工作在主模式，为 0 的时候工作在从模式。
MTX(bit4)：传输方向选择位，用来设置是进行发送还是接收，为 0 的时候是接收，为 1 的时候是发送。
TXAK(bit3)：传输应答位使能，为 0 的话发送 ACK 信号，为 1 的话发送 NO ACK 信号。
RSTA(bit2)：重复开始信号，为 1 的话产生一个重新开始信号。

接下来看一下寄存器 I2Cx_I2SR，这个是 I2C 的状态寄存器，寄存器结构如图 26.1.2.5 所示：

寄存器 I2Cx_I2SR 的各位含义如下：
ICF(bit7)：数据传输状态位，为 0 的时候表示数据正在传输，为 1 的时候表示数据传输完成。
IAAS(bit6)：当为 1 的时候表示 I2C 地址，也就是 I2Cx_IADR 寄存器中的地址是从设备地址。
IBB(bit5)： I2C 总线忙标志位，当为 0 的时候表示 I2C 总线空闲，为 1 的时候表示 I2C 总线忙。
IAL(bit4)：仲裁丢失位，为 1 的时候表示发生仲裁丢失。
SRW(bit2)：从机读写状态位，当 I2C 作为从机的时候使用，此位用来表明主机发送给从机的是读还是写命令。为 0 的时候表示主机要向从机写数据，为 1 的时候表示主机要从从机读取数据。
IIF(bit1)： I2C 中断挂起标志位，当为 1 的时候表示有中断挂起，此位需要软件清零。
RXAK(bit0)： 应答信号标志位，为 0 的时候表示接收到 ACK 应答信号，为 1 的话表示检测到 NO ACK 信号。

最后一个寄存器就是 I2Cx_I2DR，这是 I2C 的数据寄存器，此寄存器只有低 8 位有效，当要发送数据的时候将要发送的数据写入到此寄存器，如果要接收数据的话直接读取此寄存器即可得到接收到的数据。

1.3 AP3216C 简介

I.MX6U-ALPHA 开发板上通过 I2C1 连接了一个三合一环境传感器： AP3216C， AP3216C是由敦南科技推出的一款传感器，其支持环境光强度(ALS)、接近距离(PS)和红外线强度(IR)这三个环境参数检测。该芯片可以通过 IIC 接口与主控制相连，并且支持中断， AP3216C 的特点如下：

①、I2C 接口，快速模式下波特率可以到 400Kbit/S
②、多种工作模式选择： ALS、PS+IR、ALS+PS+IR、PD 等等。
③、内建温度补偿电路。
④、宽工作温度范围(-30° C ~ +80° C)。
⑤、超小封装， 4.1mm x 2.4mm x 1.35mm
⑥、环境光传感器具有 16 位分辨率。
⑦、接近传感器和红外传感器具有 10 位分辨率。

AP3216C 常被用于手机、平板、导航设备等，其内置的接近传感器可以用于检测是否有物体接近，比如手机上用来检测耳朵是否接触听筒，如果检测到的话就表示正在打电话，手机就会关闭手机屏幕以省电。也可以使用环境光传感器检测光照强度，可以实现自动背光亮度调节。

AP3216 的设备地址为 0X1E，同几乎所有的 I2C 从器件一样， AP3216C 内部也有一些寄存器，通过这些寄存器我们可以配置 AP3216C 的工作模式，并且读取相应的数据。 AP3216C 我们用的寄存器如表 26.1.3.1 所示：

在表 26.1.3.1 中， 0X00 这个寄存器是模式控制寄存器，用来设置 AP3216C 的工作模式，一般开始先将其设置为 0X04，也就是先软件复位一次 AP3216C。接下来根据实际使用情况选择合适的工作模式，比如设置为 0X03，也就是开启 ALS+PS+IR。从 0X0A~0X0F 这 6 个寄存器就是数据寄存器，保存着 ALS、 PS 和 IR 这三个传感器获取到的数据值。如果同时打开 ALS、PS 和 IR 则读取间隔最少要 112.5ms，因为 AP3216C 完成一次转换需要 112.5ms。关于 AP3216C的介绍就到这里，如果要想详细的研究此芯片的话，请大家自行查阅其数据手册。

本章实验中我们通过 I.MX6U 的 I2C1 来读取 AP3216C 内部的 ALS、 PS 和 IR 这三个传感器的值，并且在 LCD 上显示。开机会先检测 AP3216C 是否存在，一般的芯片是有个 ID 寄存器，通过读取 ID 寄存器判断 ID 是否正确就可以检测芯片是否存在。但是 AP3216C 没有 ID 寄存器，所以我们就通过向寄存器 0X00 写入一个值，然后再读取 0X00 寄存器，判断读出得到值和写入的是否相等，如果相等就表示 AP3216C 存在，否则的话 AP3216C 就不存在。

本章的配置步骤如下：
1、初始化相应的 IO
初始化 I2C1 相应的 IO，设置其复用功能，如果要使用 AP3216C 中断功能的话，还需要设
置 AP3216C 的中断 IO。
2、初始化 I2C1
初始化 I2C1 接口，设置波特率。
3、初始化 AP3216C
初始化 AP3216C，读取 AP3216C 的数据

AP3216C 是在 I.MX6U-ALPHA 开发板底板上，原理图如图所示：

从图可以看出 AP3216C 使用的是 I2C1，其中 I2C1_SCL 使用的 UART4_TXD 这个IO、 I2C1_SDA 使用的是 UART4_R XD 这个 IO。

2. Linux I2C 驱动框架简介

回想一下我们在裸机篇中是怎么编写 AP3216C 驱动的，我们编写了四个文件： bsp_i2c.c、bsp_i2c.h、 bsp_ap3216c.c 和 bsp_ap3216c.h。其中前两个是 I.MX6U 的 IIC 接口驱动，后两个文件是 AP3216C 这个 I2C 设备驱动文件。相当于有两部分驱动：

①、 I2C 主机驱动。
②、 I2C 设备驱动。

对于 I2C 主机驱动，一旦编写完成就不需要再做修改，其他的 I2C 设备直接调用主机驱动提供的 API 函数完成读写操作即可。这个正好符合 Linux 的驱动分离与分层的思想，因此 Linux内核也将 I2C 驱动分为两部分：
①、 I2C 总线驱动， I2C 总线驱动就是 SOC 的 I2C 控制器驱动，也叫做 I2C 适配器驱动。
②、 I2C 设备驱动， I2C 设备驱动就是针对具体的 I2C 设备而编写的驱动。

2.1 I2C 总线驱动

首先来看一下 I2C 总线，在讲 platform 的时候就说过， platform 是虚拟出来的一条总线，目的是为了实现总线、设备、驱动框架。对于 I2C 而言，不需要虚拟出一条总线，直接使用 I2C总线即可。 I2C 总线驱动重点是 I2C 适配器(也就是 SOC 的 I2C 接口控制器)驱动，这里要用到两个重要的数据结构： i2c_adapter 和 i2c_algorithm， Linux 内核将 SOC 的 I2C 适配器(控制器)抽象成 i2c_adapter，i2c_adapter 结构体定义在 include/linux/i2c.h 文件中，结构体内容如下：

// 示例代码 61.1.1.1 i2c_adapter 结构体
498 struct i2c_adapter {
499     struct module *owner;
500     unsigned int class; /* classes to allow probing for */
501     const struct i2c_algorithm *algo; /* 总线访问算法 */
502     void *algo_data;
503
504     /* data fields that are valid for all devices */
505     struct rt_mutex bus_lock;
506
507     int timeout; /* in jiffies */
508     int retries;
509     struct device dev; /* the adapter device */
510
511     int nr;
512     char name[48];
513     struct completion dev_released;
514
515     struct mutex userspace_clients_lock;
516     struct list_head userspace_clients;
517
518     struct i2c_bus_recovery_info *bus_recovery_info;
519     const struct i2c_adapter_quirks *quirks;
520 };

第 501 行， i2c_algorithm 类型的指针变量 algo，对于一个 I2C 适配器，肯定要对外提供读写 API 函数，设备驱动程序可以使用这些 API 函数来完成读写操作。 i2c_algorithm 就是 I2C 适配器与 IIC 设备进行通信的方法。

i2c_algorithm 结构体定义在 include/linux/i2c.h 文件中，内容如下(删除条件编译)：

// 示例代码 61.1.1.2 i2c_algorithm 结构体
391 struct i2c_algorithm {
    ......
398     int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
399     int num);
400     int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
401     unsigned short flags, char read_write,
402     u8 command, int size, union i2c_smbus_data *data);
403
404     /* To determine what the adapter supports */
405     u32 (*functionality) (struct i2c_adapter *);
    ......
411 };

第 398 行， master_xfer 就是 I2C 适配器的传输函数，可以通过此函数来完成与 IIC 设备之间的通信。
第 400 行， smbus_xfer 就是 SMBUS 总线的传输函数。

综上所述， I2C 总线驱动，或者说 I2C 适配器驱动的主要工作就是初始化 i2c_adapter 结构体变量，然后设置 i2c_algorithm 中的 master_xfer 函数。完成以后通过 i2c_add_numbered_adapter或 i2c_add_adapter 这两个函数向系统注册设置好的 i2c_adapter，这两个函数的原型如下：

int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_add_numbered_adapter(struct i2c_adapter *adap)

这两个函数的区别在于 i2c_add_adapter 使用动态的总线号，而 i2c_add_numbered_adapter使用静态总线号。函数参数和返回值含义如下：
adapter 或 adap：要添加到 Linux 内核中的 i2c_adapter，也就是 I2C 适配器。
返回值： 0，成功；负值，失败。

如果要删除 I2C 适配器的话使用 i2c_del_adapter 函数即可，函数原型如下：

void i2c_del_adapter(struct i2c_adapter * adap)

函数参数和返回值含义如下：
adap：要删除的 I2C 适配器。
返回值： 无。

关于 I2C 的总线(控制器或适配器)驱动就讲解到这里，一般 SOC 的 I2C 总线驱动都是由半导体厂商编写的，比如 I.MX6U 的 I2C 适配器驱动 NXP 已经编写好了，这个不需要用户去编写。因此 I2C 总线驱动对我们这些 SOC 使用者来说是被屏蔽掉的，我们只要专注于 I2C 设备驱
动即可。除非你是在半导体公司上班，工作内容就是写 I2C 适配器驱动。

2.2 I2C 设备驱动

I2C 设备驱动重点关注两个数据结构： i2c_client 和 i2c_driver，根据总线、设备和驱动模型，I2C 总线上一小节已经讲了。还剩下设备和驱动， i2c_client 就是描述设备信息的， i2c_driver 描述驱动内容，类似于 platform_driver。

1、 i2c_client 结构体

i2c_client 结构体定义在 include/linux/i2c.h 文件中，内容如下：

// 示例代码 61.1.2.1 i2c_client 结构体
217 struct i2c_client {
218     unsigned short flags; /* 标志 */
219     unsigned short addr; /* 芯片地址， 7 位，存在低 7 位*/
    ......
222     char name[I2C_NAME_SIZE]; /* 名字 */
223     struct i2c_adapter *adapter; /* 对应的 I2C 适配器 */
224     struct device dev; /* 设备结构体 */
225     int irq; /* 中断 */
226     struct list_head detected;
    ......
230 };

一个设备对应一个 i2c_client，每检测到一个 I2C 设备就会给这个 I2C 设备分配一个i2c_client。

2、 i2c_driver 结构体

i2c_driver 类似 platform_driver，是我们编写 I2C 设备驱动重点要处理的内容， i2c_driver 结构体定义在 include/linux/i2c.h 文件中，内容如下：

示例代码 61.1.2.2 i2c_driver 结构体
161 struct i2c_driver {
162     unsigned int class;
163
164     /* Notifies the driver that a new bus has appeared. You should
165      * avoid using this, it will be removed in a near future.
166      */
167     int (*attach_adapter)(struct i2c_adapter *) __deprecated;
168
169     /* Standard driver model interfaces */
170     int (*probe)(struct i2c_client *, const struct i2c_device_id *);
171     int (*remove)(struct i2c_client *);
172
173     /* driver model interfaces that don't relate to enumeration */
174     void (*shutdown)(struct i2c_client *);
175
176     /* Alert callback, for example for the SMBus alert protocol.
177     * The format and meaning of the data value depends on the
178     * protocol.For the SMBus alert protocol, there is a single bit
179     * of data passed as the alert response's low bit ("event
180     flag"). */
181     void (*alert)(struct i2c_client *, unsigned int data);
182
183     /* a ioctl like command that can be used to perform specific
184      * functions with the device.
185      */
186     int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
187
188     struct device_driver driver;
189     const struct i2c_device_id *id_table;
190
191     /* Device detection callback for automatic device creation */
192     int (*detect)(struct i2c_client *, struct i2c_board_info *);
193     const unsigned short *address_list;
194     struct list_head clients;
195 };

第 170 行，当 I2C 设备和驱动匹配成功以后 probe 函数就会执行，和 platform 驱动一样。
第 188 行， device_driver 驱动结构体，如果使用设备树的话，需要设置 device_driver 的of_match_table 成员变量，也就是驱动的兼容(compatible)属性。
第 189 行， id_table 是传统的、未使用设备树的设备匹配 ID 表。

对于我们 I2C 设备驱动编写人来说，重点工作就是构建 i2c_driver，构建完成以后需要向Linux 内核注册这个 i2c_driver。 i2c_driver 注册函数为 int i2c_register_driver，此函数原型如下：

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)

函数参数和返回值含义如下：
owner： 一般为 THIS_MODULE。
driver：要注册的 i2c_driver。
返回值： 0，成功；负值，失败。

另外 i2c_add_driver 也常常用于注册 i2c_driver， i2c_add_driver 是一个宏，定义如下：

// 示例代码 61.1.2.3 i2c_add_driver 宏
587 #define i2c_add_driver(driver) \
588     i2c_register_driver(THIS_MODULE, driver)

i2c_add_driver 就是对 i2c_register_driver 做了一个简单的封装，只有一个参数，就是要注册的 i2c_driver。
注销 I2C 设备驱动的时候需要将前面注册的 i2c_driver 从 Linux 内核中注销掉，需要用到i2c_del_driver 函数，此函数原型如下：

void i2c_del_driver(struct i2c_driver *driver)

函数参数和返回值含义如下：
driver：要注销的 i2c_driver。
返回值： 无。

i2c_driver 的注册示例代码如下：

// 示例代码 61.1.2.4 i2c_driver 注册流程
1 /* i2c 驱动的 probe 函数 */
2 static int xxx_probe(struct i2c_client *client, const struct i2c_device_id *id)
3 {
4     /* 函数具体程序 */
5     return 0;
6 }
7
8
/* i2c 驱动的 remove 函数 */
9 static int xxx_remove(struct i2c_client *client)
10 {
11     /* 函数具体程序 */
12     return 0;
13 }
14
15 /* 传统匹配方式 ID 列表 */
16 static const struct i2c_device_id xxx_id[] = {
17     {"xxx", 0},
18     {}
19 };
20
21 /* 设备树匹配列表 */
22 static const struct of_device_id xxx_of_match[] = {
23     { .compatible = "xxx" },
24     { /* Sentinel */ }
25 };
26
27 /* i2c 驱动结构体 */
28 static struct i2c_driver xxx_driver = {
29     .probe = xxx_probe,
30     .remove = xxx_remove,
31     .driver = {
32     .owner = THIS_MODULE,
33     .name = "xxx",
34     .of_match_table = xxx_of_match,
35 },
36     .id_table = xxx_id,
37 };
38
39 /* 驱动入口函数 */
40 static int __init xxx_init(void)
41 {
42     int ret = 0;
43
44     ret = i2c_add_driver(&xxx_driver);
45     return ret;
46 }
47
48 /* 驱动出口函数 */
49 static void __exit xxx_exit(void)
50 {
51     i2c_del_driver(&xxx_driver);
52 }
53
54 module_init(xxx_init);
55 module_exit(xxx_exit);

第 16~19 行， i2c_device_id，无设备树的时候匹配 ID 表。
第 22~25 行， of_device_id，设备树所使用的匹配表。
第 28~37 行， i2c_driver，当 I2C 设备和 I2C 驱动匹配成功以后 probe 函数就会执行，这些和 platform 驱动一样， probe 函数里面基本就是标准的字符设备驱动那一套了。

2.3 I2C 设备和驱动匹配过程

I2C 设备和驱动的匹配过程是由 I2C 核心来完成的， drivers/i2c/i2c-core.c 就是 I2C 的核心部分， I2C 核心提供了一些与具体硬件无关的 API 函数，比如前面讲过的：

1、 i2c_adapter 注册/注销函数

int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
void i2c_del_adapter(struct i2c_adapter * adap)

2、 i2c_driver 注册/注销函数

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
int i2c_add_driver (struct i2c_driver *driver)
void i2c_del_driver(struct i2c_driver *driver)

设备和驱动的匹配过程也是由 I2C 总线完成的， I2C 总线的数据结构为 i2c_bus_type，定义在 drivers/i2c/i2c-core.c 文件，i2c_bus_type 内容如下：

示例代码 61.1.2.5 i2c_bus_type 总线
736 struct bus_type i2c_bus_type = {
737     .name = "i2c",
738     .match = i2c_device_match,
739     .probe = i2c_device_probe,
740     .remove = i2c_device_remove,
741     .shutdown = i2c_device_shutdown,
742 };

.match 就是 I2C 总线的设备和驱动匹配函数，在这里就是 i2c_device_match 这个函数，此函数内容如下：

// 示例代码 61.1.2.6 i2c_device_match 函数
457 static int i2c_device_match(struct device *dev, struct
                                device_driver *drv)
458 {
459     struct i2c_client *client = i2c_verify_client(dev);
460     struct i2c_driver *driver;
461
462     if (!client)
463         return 0;
464
465     /* Attempt an OF style match */
466     if (of_driver_match_device(dev, drv))
467         return 1;
468
469     /* Then ACPI style match */
470     if (acpi_driver_match_device(dev, drv))
471         return 1;
472
473     driver = to_i2c_driver(drv);
474     /* match on an id table if there is one */
475     if (driver->id_table)
476         return i2c_match_id(driver->id_table, client) != NULL;
477
478     return 0;
479 }

第 466 行， of_driver_match_device 函数用于完成设备树设备和驱动匹配。比较 I2C 设备节点的 compatible 属性和 of_device_id 中的 compatible 属性是否相等，如果相当的话就表示 I2C设备和驱动匹配。
第 470 行， acpi_driver_match_device 函数用于 ACPI 形式的匹配。
第 476 行， i2c_match_id 函数用于传统的、无设备树的 I2C 设备和驱动匹配过程。比较 I2C设备名字和 i2c_device_id 的 name 字段是否相等，相等的话就说明 I2C 设备和驱动匹配。

2.4 I.MX6U 的 I2C 适配器驱动分析

上一小节我们讲解了 Linux 下的 I2C 驱动框架，重点分为 I2C 适配器驱动和 I2C 设备驱动，其中 I2C 适配器驱动就是 SOC 的 I2C 控制器驱动。 I2C 设备驱动是需要用户根据不同的 I2C 设备去编写，而 I2C 适配器驱动一般都是 SOC 厂商去编写的，比如 NXP 就编写好了 I.MX6U 的I2C 适配器驱动。在 imx6ull.dtsi 文件中找到 I.MX6U 的 I2C1 控制器节点，节点内容如下所示：

示例代码 61.2.1 I2C1 控制器节点
1 i2c1: i2c@021a0000 {
2     #address-cells = <1>;
3     #size-cells = <0>;
4     compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c";
5     reg = <0x021a0000 0x4000>;
6     interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>;
7     clocks = <&clks IMX6UL_CLK_I2C1>;
8     status = "disabled";
9 };

重点关注 i2c1 节点的 compatible 属性值，因为通过 compatible 属性值可以在 Linux 源码里面找到对应的驱动文件。这里i2c1节点的compatible属性值有两个：“fsl,imx6ul-i2c”和“fsl,imx21-i2c”，在 Linux 源码中搜索这两个字符串即可找到对应的驱动文件。 I.MX6U 的 I2C 适配器驱动

驱动文件为 drivers/i2c/busses/i2c-imx.c，在此文件中有如下内容：

// 示例代码 61.2.2 i2c-imx.c 文件代码段
244 static struct platform_device_id imx_i2c_devtype[] = {
245     {
246         .name = "imx1-i2c",
247         .driver_data = (kernel_ulong_t)&imx1_i2c_hwdata,
248     }, {
249         .name = "imx21-i2c",
250         .driver_data = (kernel_ulong_t)&imx21_i2c_hwdata,
251     }, {
252     /* sentinel */
253     }
254 };
255 MODULE_DEVICE_TABLE(platform, imx_i2c_devtype);
256
257 static const struct of_device_id i2c_imx_dt_ids[] = {
258     { .compatible = "fsl,imx1-i2c", .data = &imx1_i2c_hwdata, },
259     { .compatible = "fsl,imx21-i2c", .data = &imx21_i2c_hwdata, },
260     { .compatible = "fsl,vf610-i2c", .data = &vf610_i2c_hwdata, },
261     { /* sentinel */ }
262 };
263 MODULE_DEVICE_TABLE(of, i2c_imx_dt_ids);
......
1119 static struct platform_driver i2c_imx_driver = {
1120     .probe = i2c_imx_probe,
1121     .remove = i2c_imx_remove,
1122     .driver = {
1123     .name = DRIVER_NAME,
1124     .owner = THIS_MODULE,
1125     .of_match_table = i2c_imx_dt_ids,
1126     .pm = IMX_I2C_PM,
1127 },
1128     .id_table = imx_i2c_devtype,
1129 };
1130
1131 static int __init i2c_adap_imx_init(void)
1132 {
1133     return platform_driver_register(&i2c_imx_driver);
1134 }
1135 subsys_initcall(i2c_adap_imx_init);
1136
1137 static void __exit i2c_adap_imx_exit(void)
1138 {
1139     platform_driver_unregister(&i2c_imx_driver);
1140 }
1141 module_exit(i2c_adap_imx_exit);

从示例代码 61.2.2 可以看出， I.MX6U 的 I2C 适配器驱动是个标准的 platform 驱动，由此可以看出，虽然 I2C 总线为别的设备提供了一种总线驱动框架，但是 I2C 适配器却是 platform驱动。就像你的部门老大是你的领导，你是他的下属，但是放到整个公司，你的部门老大却也是老板的下属。
第 259 行，“fsl,imx21-i2c”属性值，设备树中 i2c1 节点的 compatible 属性值就是与此匹配上的。因此 i2c-imx.c 文件就是 I.MX6U 的 I2C 适配器驱动文件。

第 1120 行，当设备和驱动匹配成功以后 i2c_imx_probe 函数就会执行， i2c_imx_probe 函数就会完成 I2C 适配器初始化工作。
i2c_imx_probe 函数内容如下所示(有省略)：

// 示例代码 61.2.3 i2c_imx_probe 函数代码段
971 static int i2c_imx_probe(struct platform_device *pdev)
972 {
973     const struct of_device_id *of_id =
974     of_match_device(i2c_imx_dt_ids, &pdev->dev);
975     struct imx_i2c_struct *i2c_imx;
976     struct resource *res;
977     struct imxi2c_platform_data *pdata = dev_get_platdata(&pdev->dev);
978     void __iomem *base;
979     int irq, ret;
980     dma_addr_t phy_addr;
981
982     dev_dbg(&pdev->dev, "<%s>\n", __func__);
983
984     irq = platform_get_irq(pdev, 0);
    ......
990     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
991     base = devm_ioremap_resource(&pdev->dev, res);
992     if (IS_ERR(base))
993         return PTR_ERR(base);
994
995     phy_addr = (dma_addr_t)res->start;
996     i2c_imx = devm_kzalloc(&pdev->dev, sizeof(*i2c_imx), GFP_KERNEL);
997     if (!i2c_imx)
998         return -ENOMEM;
999
1000     if (of_id)
1001         i2c_imx->hwdata = of_id->data;
1002     else
1003         i2c_imx->hwdata = (struct imx_i2c_hwdata *)
1004         platform_get_device_id(pdev)->driver_data;
1005
1006     /* Setup i2c_imx driver structure */
1007     strlcpy(i2c_imx->adapter.name, pdev->name, sizeof(i2c_imx->adapter.name));
1008     i2c_imx->adapter.owner = THIS_MODULE;
1009     i2c_imx->adapter.algo = &i2c_imx_algo;
1010     i2c_imx->adapter.dev.parent = &pdev->dev;
1011     i2c_imx->adapter.nr = pdev->id;
1012     i2c_imx->adapter.dev.of_node = pdev->dev.of_node;
1013     i2c_imx->base = base;
1014
1015     /* Get I2C clock */
1016     i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);
    ......
1022     ret = clk_prepare_enable(i2c_imx->clk);
    ......
1027     /* Request IRQ */
1028     ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr,
1029     IRQF_NO_SUSPEND, pdev->name, i2c_imx);
    ......
1035     /* Init queue */
1036     init_waitqueue_head(&i2c_imx->queue);
1037
1038     /* Set up adapter data */
1039     i2c_set_adapdata(&i2c_imx->adapter, i2c_imx);
1040
1041     /* Set up clock divider */
1042     i2c_imx->bitrate = IMX_I2C_BIT_RATE;
1043     ret = of_property_read_u32(pdev->dev.of_node,
1044     "clock-frequency", &i2c_imx->bitrate);
1045     if (ret < 0 && pdata && pdata->bitrate)
1046     i2c_imx->bitrate = pdata->bitrate;
1047
1048     /* Set up chip registers to defaults */
1049     imx_i2c_write_reg(i2c_imx->hwdata->i2cr_ien_opcode ^ I2CR_IEN,
1050                                     i2c_imx, IMX_I2C_I2CR);
1051     imx_i2c_write_reg(i2c_imx->hwdata->i2sr_clr_opcode, i2c_imx, IMX_I2C_I2SR);
1052
1053     /* Add I2C adapter */
1054     ret = i2c_add_numbered_adapter(&i2c_imx->adapter);
1055     if (ret < 0) {
1056     dev_err(&pdev->dev, "registration failed\n");
1057     goto clk_disable;
1058 }
1059
1060     /* Set up platform driver data */
1061     platform_set_drvdata(pdev, i2c_imx);
1062     clk_disable_unprepare(i2c_imx->clk);
        ......
1070     /* Init DMA config if supported */
1071     i2c_imx_dma_request(i2c_imx, phy_addr);
1072
1073     return 0; /* Return OK */
1074
1075     clk_disable:
1076     clk_disable_unprepare(i2c_imx->clk);
1077     return ret;
1078 }

第 984 行，调用 platform_get_irq 函数获取中断号。
第 990~991 行，调用 platform_get_resource 函数从设备树中获取 I2C1 控制器寄存器物理基地址，也就是 0X021A0000。获取到寄存器基地址以后使用 devm_ioremap_resource 函数对其进行内存映射，得到可以在 Linux 内核中使用的虚拟地址。
第 996 行， NXP 使用 imx_i2c_struct 结构体来表示 I.MX 系列 SOC 的 I2C 控制器，这里使用 devm_kzalloc 函数来申请内存。
第 1008~1013 行， imx_i2c_struct 结构体要有个叫做 adapter 的成员变量， adapter 就是i2c_adapter，这里初始化i2c_adapter。第1009行设置i2c_adapter 的algo成员变量为i2c_imx_algo，也就是设置 i2c_algorithm。
第 1028~1029 行，注册 I2C 控制器中断，中断服务函数为 i2c_imx_isr。
第 1042~1044 行，设置 I2C 频率默认为 IMX_I2C_BIT_RATE=100KHz，如果设备树节点设置了“clock-frequency”属性的话 I2C 频率就使用 clock-frequency 属性值。
第 1049~1051 行，设置 I2C1 控制的 I2CR 和 I2SR 寄存器。
第 1054 行，调用 i2c_add_numbered_adapter 函数向 Linux 内核注册 i2c_adapter。
第 1071 行， 申请 DMA， 看来 I.MX 的 I2C 适配器驱动采用了 DMA 方式。

i2c_imx_probe 函数主要的工作就是一下两点：
①、初始化 i2c_adapter，设置 i2c_algorithm 为 i2c_imx_algo，最后向 Linux 内核注册i2c_adapter。
②、初始化 I2C1 控制器的相关寄存器。

i2c_imx_algo 包含 I2C1 适配器与 I2C 设备的通信函数 master_xfer， i2c_imx_algo 结构体定义如下：

// 示例代码 61.2.4 i2c_imx_algo 结构体
966 static struct i2c_algorithm i2c_imx_algo = {
967     .master_xfer = i2c_imx_xfer,
968     .functionality = i2c_imx_func,
969 };

我们先来看一下. functionality， functionality用于返回此I2C适配器支持什么样的通信协议，在这里 functionality 就是 i2c_imx_func 函数， i2c_imx_func 函数内容如下：

// 示例代码 61.2.5 i2c_imx_func 函数
static u32 i2c_imx_func(struct i2c_adapter *adapter)
{
    return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL
            | I2C_FUNC_SMBUS_READ_BLOCK_DATA;
}

重点来看一下 i2c_imx_xfer 函数，因为最终就是通过此函数来完成与 I2C 设备通信的， 此函数内容如下(有省略)：

// 示例代码 61.2.6 i2c_imx_xfer 函数
888 static int i2c_imx_xfer(struct i2c_adapter *adapter,
889                         struct i2c_msg *msgs, int num)
890 {
891     unsigned int i, temp;
892     int result;
893     bool is_lastmsg = false;
894     struct imx_i2c_struct *i2c_imx = i2c_get_adapdata(adapter);
895
896     dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__);
897
898     /* Start I2C transfer */
899     result = i2c_imx_start(i2c_imx);
900     if (result)
901         goto fail0;
902
903     /* read/write data */
904     for (i = 0; i < num; i++) {
905         if (i == num - 1)
906             is_lastmsg = true;
907
908         if (i) {
909             dev_dbg(&i2c_imx->adapter.dev,
910                     "<%s> repeated start\n", __func__);
911         temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR);
912         temp |= I2CR_RSTA;
913         imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR);
914         result = i2c_imx_bus_busy(i2c_imx, 1);
915         if (result)
916             goto fail0;
917         }
918         dev_dbg(&i2c_imx->adapter.dev,
919         "<%s> transfer message: %d\n", __func__, i);
920         /* write/read data */
        ......
938         if (msgs[i].flags & I2C_M_RD)
939             result = i2c_imx_read(i2c_imx, &msgs[i], is_lastmsg);
940         else {
941             if (i2c_imx->dma && msgs[i].len >= DMA_THRESHOLD)
942                 result = i2c_imx_dma_write(i2c_imx, &msgs[i]);
943             else
944                 result = i2c_imx_write(i2c_imx, &msgs[i]);
945         }
946         if (result)
947             goto fail0;
948     }
949
950     fail0:
951     /* Stop I2C transfer */
952     i2c_imx_stop(i2c_imx);
953
954     dev_dbg(&i2c_imx->adapter.dev, "<%s> exit with: %s: %d\n", __func__,
955                     (result < 0) ? "error" : "success msg",
956                     (result < 0) ? result : num);
957     return (result < 0) ? result : num;
958 }

第 899 行，调用 i2c_imx_start 函数开启 I2C 通信。
第 939 行，如果是从 I2C 设备读数据的话就调用 i2c_imx_read 函数。
第 941~945 行，向 I2C 设备写数据，如果要用 DMA 的话就使用 i2c_imx_dma_write 函数来完成写数据。如果不使用 DMA 的话就使用 i2c_imx_write 函数完成写数据。
第 952 行， I2C 通信完成以后调用 i2c_imx_stop 函数停止 I2C 通信。
i2c_imx_start、 i2c_imx_read、 i2c_imx_write 和 i2c_imx_stop 这些函数就是 I2C 寄存器的具体操作函数.

3. I2C 设备驱动编写流程

I2C 适配器驱动 SOC 厂商已经替我们编写好了，我们需要做的就是编写具体的设备驱动，本小节我们就来学习一下 I2C 设备驱动的详细编写流程。

3.1 I2C 设备信息描述

1、未使用设备树的时候

首先肯定要描述 I2C 设备节点信息，先来看一下没有使用设备树的时候是如何在 BSP 里面描述 I2C 设备信息的，在未使用设备树的时候需要在 BSP 里面使用 i2c_board_info 结构体来描述一个具体的 I2C 设备。 i2c_board_info 结构体如下：

// 示例代码 61.3.1.1 i2c_board_info 结构体
295 struct i2c_board_info {
296     char type[I2C_NAME_SIZE]; /* I2C 设备名字 */
297     unsigned short flags; /* 标志 */
298     unsigned short addr; /* I2C 器件地址 */
299     void *platform_data;
300     struct dev_archdata *archdata;
301     struct device_node *of_node;
302     struct fwnode_handle *fwnode;
303     int irq;
304 };

type 和 addr 这两个成员变量是必须要设置的，一个是 I2C 设备的名字，一个是 I2C 设备的器件地址。打开 arch/arm/mach-imx/mach-mx27_3ds.c 文件，此文件中关于 OV2640 的 I2C 设备信息描述如下：

示例代码 61.3.1.2 OV2640 的 I2C 设备信息
392 static struct i2c_board_info mx27_3ds_i2c_camera = {
393     I2C_BOARD_INFO("ov2640", 0x30),
394 };

示例代码 61.3.1.2 中使用 I2C_BOARD_INFO 来完成 mx27_3ds_i2c_camera 的初始化工作，I2C_BOARD_INFO 是一个宏，定义如下：

示例代码 61.3.1.3 I2C_BOARD_INFO 宏
316 #define I2C_BOARD_INFO(dev_type, dev_addr) \
317     .type = dev_type, .addr = (dev_addr)

可以看出， I2C_BOARD_INFO 宏其实就是设置 i2c_board_info 的 type 和 addr 这两个成员变量，因此示例代码 61.3.1.2 的主要工作就是设置 I2C 设备名字为 ov2640， ov2640 的器件地址为 0X30。
大家可以在 Linux 源码里面全局搜索 i2c_board_info，会找到大量以 i2c_board_info 定义的I2C 设备信息，这些就是未使用设备树的时候 I2C 设备的描述方式，当采用了设备树以后就不会再使用 i2c_board_info 来描述 I2C 设备了。

2、使用设备树的时候

使用设备树的时候 I2C 设备信息通过创建相应的节点就行了，比如 NXP 官方的 EVK 开发板在 I2C1 上接了 mag3110 这个磁力计芯片，因此必须在 i2c1 节点下创建 mag3110 子节点，然后在这个子节点内描述 mag3110 这个芯片的相关信息。打开 imx6ull-14x14-evk.dts 这个设备树文件，然后找到如下内容：

// 示例代码 61.3.1.4 mag3110 子节点
1 &i2c1 {
2     clock-frequency = <100000>;
3     pinctrl-names = "default";
4     pinctrl-0 = <&pinctrl_i2c1>;
5     status = "okay";
6
7    mag3110@0e {
8         compatible = "fsl,mag3110";
9         reg = <0x0e>;
10         position = <2>;
11     };
    ......
20 };

第 7~11 行，向 i2c1 添加 mag3110 子节点，第 7 行“mag3110@0e”是子节点名字，“@”后面的“0e”就是 mag3110 的 I2C 器件地址。第 8 行设置 compatible 属性值为“fsl,mag3110”。
第 9 行的 reg 属性也是设置 mag3110 的器件地址的，因此值为 0x0e。 I2C 设备节点的创建重点是 compatible 属性和 reg 属性的设置，一个用于匹配驱动，一个用于设置器件地址。

3.2 I2C设备数据收发处理流程

I2C 设备驱动首先要做的就是初始化 i2c_driver 并向 Linux 内核注册。当设备和驱动匹配以后 i2c_driver 里面的 probe 函数就会执行， probe 函数里面所做的就是字符设备驱动那一套了。 一般需要在 probe 函数里面初始化 I2C 设备，要初始化 I2C 设备就必须能够对 I2C 设备寄存器进行读写操作，这里就要用到 i2c_transfer 函数了。 i2c_transfer 函数最终会调用 I2C 适配器中 i2c_algorithm 里面的 master_xfer 函数，对于 I.MX6U 而言就是i2c_imx_xfer 这个函数。 i2c_transfer 函数原型如下：

int i2c_transfer(struct i2c_adapter *adap,
                struct i2c_msg *msgs,
                int num)

函数参数和返回值含义如下：
adap： 所使用的 I2C 适配器， i2c_client 会保存其对应的 i2c_adapter。
msgs： I2C 要发送的一个或多个消息。
num： 消息数量，也就是 msgs 的数量。
返回值： 负值，失败，其他非负值，发送的 msgs 数量。
我们重点来看一下 msgs 这个参数，这是一个 i2c_msg 类型的指针参数， I2C 进行数据收发说白了就是消息的传递， Linux 内核使用 i2c_msg 结构体来描述一个消息。 i2c_msg 结构体定义
在 include/uapi/linux/i2c.h 文件中，结构体内容如下：

// 示例代码 61.3.2.1 i2c_msg 结构体
68 struct i2c_msg {
69     __u16 addr; /* 从机地址 */
70     __u16 flags; /* 标志 */
71     #define I2C_M_TEN 0x0010
72     #define I2C_M_RD 0x0001
73     #define I2C_M_STOP 0x8000
74     #define I2C_M_NOSTART 0x4000
75     #define I2C_M_REV_DIR_ADDR 0x2000
76    #define I2C_M_IGNORE_NAK 0x1000
77     #define I2C_M_NO_RD_ACK 0x0800
78     #define I2C_M_RECV_LEN 0x0400
79     __u16 len; /* 消息(本 msg)长度 */
80     __u8 *buf; /* 消息数据 */
81 };

使用 i2c_transfer 函数发送数据之前要先构建好 i2c_msg，使用 i2c_transfer 进行 I2C 数据收发的示例代码如下：

// 示例代码 61.3.2.2 I2C 设备多寄存器数据读写
1 /* 设备结构体 */
2 struct xxx_dev {
3     ......
4     void *private_data; /* 私有数据，一般会设置为 i2c_client */
5 };
6
7/*
8 * @description : 读取 I2C 设备多个寄存器数据
9 * @param – dev : I2C 设备
10 * @param – reg : 要读取的寄存器首地址
11 * @param – val : 读取到的数据
12 * @param – len : 要读取的数据长度
13 * @return : 操作结果
14 */
15 static int xxx_read_regs(struct xxx_dev *dev, u8 reg, void *val, int len)
16 {
17     int ret;
18     struct i2c_msg msg[2];
19     struct i2c_client *client = (struct i2c_client *)dev->private_data;
20
21     /* msg[0]，第一条写消息，发送要读取的寄存器首地址 */
22     msg[0].addr = client->addr; /* I2C 器件地址 */
23     msg[0].flags = 0; /* 标记为发送数据 */
24     msg[0].buf = ® /* 读取的首地址 */
25     msg[0].len = 1; /* reg 长度 */
26
27     /* msg[1]，第二条读消息，读取寄存器数据 */
28     msg[1].addr = client->addr; /* I2C 器件地址 */
29     msg[1].flags = I2C_M_RD; /* 标记为读取数据 */
30     msg[1].buf = val; /* 读取数据缓冲区 */
31     msg[1].len = len; /* 要读取的数据长度
32
33     ret = i2c_transfer(client->adapter, msg, 2);
34     if(ret == 2) {
35         ret = 0;
36     } else {
37         ret = -EREMOTEIO;
38     }
39     return ret;
40 }
41
42 /*
43 * @description : 向 I2C 设备多个寄存器写入数据
44 * @param – dev : 要写入的设备结构体
45 * @param – reg : 要写入的寄存器首地址
46 * @param – buf : 要写入的数据缓冲区
47 * @param – len : 要写入的数据长度
48 * @return : 操作结果
49 */
50 static s32 xxx_write_regs(struct xxx_dev *dev, u8 reg, u8 *buf, u8 len)
51 {
52     u8 b[256];
53     struct i2c_msg msg;
54     struct i2c_client *client = (struct i2c_client *)dev->private_data;
55
56     b[0] = reg; /* 寄存器首地址 */
57     memcpy(&b[1],buf,len); /* 将要发送的数据拷贝到数组 b 里面 */
58
59     msg.addr = client->addr; /* I2C 器件地址 */
60     msg.flags = 0; /* 标记为写数据 */
61
62     msg.buf = b; /* 要发送的数据缓冲区 */
63     msg.len = len + 1; /* 要发送的数据长度 */
64
65     return i2c_transfer(client->adapter, &msg, 1);
66 }

第2~5行，设备结构体，在设备结构体里面添加一个指向void的指针成员变量private_data，此成员变量用于保存设备的私有数据。在 I2C 设备驱动中我们一般将其指向 I2C 设备对应的i2c_client。

第 15~40 行， xxx_read_regs 函数用于读取 I2C 设备多个寄存器数据。第 18 行定义了一个i2c_msg 数组， 2 个数组元素，因为 I2C 读取数据的时候要先发送要读取的寄存器地址，然后再读取数据，所以需要准备两个 i2c_msg。一个用于发送寄存器地址，一个用于读取寄存器值。对于 msg[0]，将 flags 设置为 0，表示写数据。 msg[0]的 addr 是 I2C 设备的器件地址，msg[0]的 buf成员变量就是要读取的寄存器地址。对于 msg[1]，将 flags 设置为 I2C_M_RD，表示读取数据。msg[1]的 buf 成员变量用于保存读取到的数据， len 成员变量就是要读取的数据长度。调用i2c_transfer 函数完成 I2C 数据读操作。

第 50~66 行， xxx_write_regs 函数用于向 I2C 设备多个寄存器写数据， I2C 写操作要比读操作简单一点，因此一个 i2c_msg 即可。数组 b 用于存放寄存器首地址和要发送的数据，第 59 行设置 msg 的 addr 为 I2C 器件地址。第 60 行设置 msg 的 flags 为 0，也就是写数据。第 62 行设置要发送的数据，也就是数组 b。第 63 行设置 msg 的 len 为 len+1，因为要加上一个字节的寄存器地址。最后通过 i2c_transfer 函数完成向 I2C 设备的写操作。

另外还有两个API函数分别用于I2C数据的收发操作，这两个函数最终都会调用i2c_transfer。
首先来看一下 I2C 数据发送函数 i2c_master_send，函数原型如下：

int i2c_master_send(const struct i2c_client *client,
                    const char *buf,
                    int count)

函数参数和返回值含义如下：
client： I2C 设备对应的 i2c_client。
buf：要发送的数据。
count： 要发送的数据字节数，要小于 64KB， 因为 i2c_msg 的 len 成员变量是一个 u16(无符号 16 位)类型的数据。
返回值： 负值，失败，其他非负值，发送的字节数。
I2C 数据接收函数为 i2c_master_recv，函数原型如下：

int i2c_master_recv(const struct i2c_client *client,
                    char *buf,
                    int count)

函数参数和返回值含义如下：
client： I2C 设备对应的 i2c_client。
buf：要接收的数据。
count： 要接收的数据字节数，要小于 64KB， 因为 i2c_msg 的 len 成员变量是一个 u16(无符号 16 位)类型的数据。
返回值： 负值，失败，其他非负值，发送的字节数。
关于 Linux 下 I2C 设备驱动的编写流程就讲解到这里，重点就是 i2c_msg 的构建和i2c_transfer 函数的调用，接下来我们就编写 AP3216C 这个 I2C 设备的 Linux 驱动。