Linux驱动框架之i2c驱动框架解析
一、引言
本文会通过简要的文字描述和源码分析，为大家分析梳理出Linux下的I2C驱动框架。
（文本所有代码都是经过删减的，所以不要纠结和源代码有出入的地方）。
二、I2C总线
I2C总线是由Philips公司开发的一种简单、双向二线制同步串行总线。
它只需要两根线（时钟线和数据线）即可在连接于总线上的器件之间传送信息。
三、Linux下的I2C驱动开发思路
目前，在Linux下开发i2c驱动，主要有两种途径：
- 将I2C当成普通字符设备来写，一切靠自己，要十分熟悉I2C协议和I2C操作才行；
- 借助Linux封装好的I2C驱动框架来写，需要了解I2C框架，熟悉它提供的标准接口。
只要接触学习过一段时间Linux驱动，相信都不会选择第一种方案。原因很简单。首先，不是所有人都对I2C协议和I2C操作很了解，因此不能保证其可靠性，其次，第一种方案写出来的驱动程序基本不具备可移植性。
四、Linux下的I2C驱动框架
Linux下的I2C驱动框架被分为三部分：I2C设备驱动、I2C总线驱动和I2C核心。
1、I2C核心
I2C核心是I2c总线和I2c设备驱动的中间枢纽，它以通用的、与平台无关的接口实现了I2C中设备与适配器的沟通，提供了I2C总线驱动和设备驱动的注册、注销方法，I2C通信方法（即“algorithm”）。
2、I2C总线驱动
I2C总线驱动是对I2C硬件体系结构中适配器的实现，适配器可由CPU控制，甚至可以直接集成在CPU内部。
I2C总线驱动主要包含了I2C适配器的数据结构（i2c_adapter）、I2C适配器的通信算法的数据结构（i2c_algorithm）等。
经由I2C总线驱动的代码，我们可以控制I2C适配器以主控制方式产生开始、停止位、读写周期，以及以从设备方式读写、产生ACK等。
3、I2C设备驱动
I2C设备驱动（也称为客户端驱动）是对I2C硬件体系结构中设备端的实现，设备一般挂接在受CPU控制的I2C适配器上，通过I2C适配器与CPU交换数据。
I2C设备驱动主要包含了数据结构体i2c_driver和i2c_client。
4、i2c_adapter和i2c_client。
i2c_adapter：即I2C适配器。简单来说，一根i2c总线就是一个i2c_adapter。
i2c_client：即I2C客户端。我们知道，一根i2c总线可以挂载多个从设备，所以，一个从设备就是一个i2c_client，对于实际项目而言，一般一根i2c总线就挂载1~2个从设备。
五、源码分析
1、I2C核心
I2C核心源码路径：linux/driver/i2c。
I2C核心源码是linux内核开发者所维护的，不需要我们关心。因为它是I2c总线和I2c设备驱动的中间枢纽，所以我们通过对I2c总线和I2c设备驱动来学习了解它。
2、I2C总线驱动
I2c总线驱动一般由硬件厂商所写，不需要我们普通驱动开发者关心，需要我们全权负责的，是I2C设备驱动的开发。
I2c总线驱动源码路径：linux/driver/i2c/busses。
因为我这里的平台是全志，所以我的I2C总线驱动为i2c-sunxi.c。
浏览驱动，从驱动入口看起。
static const struct of_device_id sunxi_i2c_match[] = {
{ .compatible = "allwinner,sun8i-twi", },
{},
};
static struct platform_driver sunxi_i2c_driver = {
.probe = sunxi_i2c_probe,
.remove = sunxi_i2c_remove,
.driver = {
.name = SUNXI_TWI_DEV_NAME,
.owner = THIS_MODULE,
.pm = SUNXI_I2C_DEV_PM_OPS,
.of_match_table = sunxi_i2c_match,
},
};
static int __init sunxi_i2c_adap_init(void)
{
return platform_driver_register(&sunxi_i2c_driver);
}
static void __exit sunxi_i2c_adap_exit(void)
{
platform_driver_unregister(&sunxi_i2c_driver);
}
module_init(sunxi_i2c_adap_init);
module_exit(sunxi_i2c_adap_exit); 从代码中，我们可以看到驱动的入口为sunxi_i2c_adap_init函数，sunxi_i2c_adap_init函数做的事情很简单，就是一个简单的平台驱动注册。
我们向Linux内核注册平台驱动之后，每次Linux内核启动起来，就会通过sunxi_i2c_match这个表里的compatible去设备树里寻找，找到一个就会调用一次probe函数。
我们这里的compatible为“allwinner,sun8i-twi”，所以会在设备树里找compatible="allwinner,sun8i-twi"的设备节点。
twi@0x05002000 {
#address-cells = <0x1>;
#size-cells = <0x0>;
compatible = "allwinner,sun8i-twi";
device_type = "twi0";
reg = <0x0 0x5002000 0x0 0x400>;
interrupts = <0x0 0x2e 0x4>;
clocks = <0x48>;
clock-frequency = <0x61a80>;
pinctrl-names = "default", "sleep";
status = "okay";
pinctrl-0 = <0x120>;
pinctrl-1 = <0x121>;
};现在已经从设备树里找到了对应的节点，也就是说有对应的设备，所以进入probe函数。
static int sunxi_i2c_probe(struct platform_device *pdev)
{
/* 获取设备节点 */
struct device_node *np = pdev->dev.of_node;
if (np == NULL) {
I2C_ERR("I2C failed to get of node\n");
return -ENODEV;
}
/* 获取twi总线id，也就是第几条总线 */
/* 这里说一下twi总线，twi总线是对i2c总线的继承和发展，可以简单理解成i2c总线 */
pdev->id = of_alias_get_id(np, "twi");
if (pdev->id < 0) {
I2C_ERR("I2C failed to get alias id\n");
ret = -EINVAL;
goto emem;
}
/* 内存映射 */
i2c->base_addr = ioremap(mem_res->start, resource_size(mem_res));
if (!i2c->base_addr) {
ret = -EIO;
goto eiomap;
}
/* 获取中断号 */
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
I2C_ERR("[i2c%d] failed to get irq\n", pdev->id);
ret = -EINVAL;
goto eiomap;
}
/* 获取时钟频率 */
ret = of_property_read_u32(np, "clock-frequency", &pdata->frequency);
if (ret) {
I2C_ERR("[i2c%d] failed to get clock frequency\n", pdev->id);
ret = -EINVAL;
goto eiomap;
}
/* 初始化i2c适配器 */
i2c->adap.owner = THIS_MODULE;
i2c->adap.nr = pdata->bus_num;
i2c->adap.retries = 3;
i2c->adap.timeout = 5*HZ;
i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
snprintf(i2c->adap.name, sizeof(i2c->adap.name), SUNXI_TWI_DEV_NAME"%u", i2c->adap.nr);
/* 获取时钟 */
i2c->mclk = of_clk_get(np, 0);
if (IS_ERR_OR_NULL(i2c->mclk)) {
I2C_ERR("[i2c%d] request TWI clock failed\n", i2c->bus_num);
ret = -EIO;
goto eremap;
}
/* 设置 i2c_algorithm */
i2c->adap.algo = &sunxi_i2c_algorithm;
/* 注册中断 */
ret = request_irq(irq, sunxi_i2c_handler, int_flag, i2c->adap.name, i2c);
if (ret) {
I2C_ERR("[i2c%d] requeset irq failed!\n", i2c->bus_num);
goto ereqirq;
}
/* 硬件初始化：初始化时钟、申请gpio等 */
if (sunxi_i2c_hw_init(i2c, pdata)) {
ret = -EIO;
goto ehwinit;
}
return 0;
}可以看到，代码中有设置i2c->adap.algo = &sunxi_i2c_algorithm。
static const struct i2c_algorithm sunxi_i2c_algorithm = {
.master_xfer = sunxi_i2c_xfer,
.functionality = sunxi_i2c_functionality,
};i2c_algorithm方法就是i2c总线驱动为i2c设备驱动提供的通信方法，也就是通讯接口。利用这个通讯接口，i2c设备驱动可以访问这个i2c_adapter上的所有设备。其中sunxi_i2c_xfer接口用于收发消息，sunxi_i2c_functionality接口用于查询适配器支持什么类型。
3、I2C设备驱动
还是老规矩，看驱动代码，首先从模块入口看起。
static const struct i2c_device_id sensor_id[] = {
{"mipi_max9288", 0},
{}
};
static struct i2c_driver sensor_driver = {
.driver = {
.owner = THIS_MODULE,
.name = SENSOR_NAME,
},
.probe = sensor_probe,
.remove = sensor_remove,
.id_table = sensor_id,
};
static __init int init_sensor(void)
{
return i2c_add_driver(sensor_driver);
}
static __exit void exit_sensor(void)
{
i2c_del_driver(sensor_driver);
}
module_init(init_sensor);
module_exit(exit_sensor); 看到上面的代码，首先，在module_init函数中，向内核注册了一个i2c驱动，注册的i2c_driver结构体为sensor_driver。
我们看到sensor_driver。
一般字符设备都是通过设备树来进行匹配，所以在.driver里面会有一个.of_match_table，而这里明显没有，不过细心的我们应该发现，在下面还有一个.id_table，看到这儿，大家应该就已经明白，没错，这就是i2c驱动match的一种方式。
static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
struct i2c_client *client = i2c_verify_client(dev);
struct i2c_driver *driver;
if (!client)
return 0;
/* Attempt an OF style match */
if (of_driver_match_device(dev, drv))
return 1;
/* Then ACPI style match */
if (acpi_driver_match_device(dev, drv))
return 1;
driver = to_i2c_driver(drv);
/* match on an id table if there is one */
if (driver->id_table)
return i2c_match_id(driver->id_table, client) != NULL;
return 0;
}上面就是I2C驱动的三种匹配方式，我们这里用的是第三种，i2c_match_id。
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, const struct i2c_client *client)
{
while (id->name[0]) {
if (strcmp(client->name, id->name) == 0)
return id;
id++;
}
return NULL;
} i2c_match_id的实现其实非常简单，就是单纯地比较i2c_device_id中的name和i2c_client中的name是否相同，相同则代表匹配成功。
那么i2c_device_id已经实现，i2c_client又在哪里创建的呢？继续看代码。
if (type == VIN_MODULE_TYPE_I2C) {
struct v4l2_subdev *sd = NULL;
/* 为bussel(twi6)获取适配器 */
struct i2c_adapter *adapter = i2c_get_adapter(bus_sel);
if (adapter == NULL) {
vin_err("%s request i2c%d adapter failed!\n", name, bus_sel);
return NULL;
}
/* 创建i2c_client并初始化name */
sd = v4l2_i2c_new_subdev(v4l2_dev, adapter, name, addr, NULL);
} 因为我们的I2C设备驱动是V4L2设备的一个子设备，所以我们的id_table在V4L2父设备中被创建和初始化。
首先，我们看到i2c_get_adapter，这个函数通过id获取i2c_adapter，而在总线驱动中，大概浏览过代码的朋友就应该有印象，在那里是获取过twi的id的，没有印象的可以回去看一下。
接下来，我们来简单看一下v4l2_i2c_new_subdev这个函数中大概做了些什么。
/* 使用设备类型和设备地址设置i2c板信息 */
struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev, struct i2c_adapter *adapter, const char *client_type, u8 addr, const unsigned short *probe_addrs)
{
struct i2c_board_info info;
memset(&info, 0, sizeof(info));
/* 设置type类型为client_type，在这里，传过来的client_type为mipi_max9288 */
strlcpy(info.type, client_type, sizeof(info.type));
info.addr = addr;
return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
}struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, struct i2c_adapter *adapter, struct i2c_board_info *info, const unsigned short *probe_addrs)
{
struct v4l2_subdev *sd = NULL;
struct i2c_client *client;
/* 创建一个i2c_client，提示：这里传进来的probe_addrs为null */
if (info->addr == 0 && probe_addrs)
client = i2c_new_probed_device(adapter, info, probe_addrs, NULL);
else
/* 创建i2c_client */
client = i2c_new_device(adapter, info);
sd = i2c_get_clientdata(client);
if (v4l2_device_register_subdev(v4l2_dev, sd))
sd = NULL;
return sd;
} 经过几次函数调用，i2c_client创建成功，并且它的名字也被赋值为了“mipi_max9288”，和i2c_device_id匹配起来了。
在这里，I2C设备驱动的probe函数我们就不分析了，无非就是V4L2子设备的一些初始化，将i2c_client设置为V4L2子设备的私有数据和一些字符设备节点的创建等。
我们来看看数据的读写具体是怎么进行的。
int read(struct v4l2_subdev *sd, unsigned char addr, unsigned char *value)
{
unsigned char data[2];
struct i2c_msg msg[2];
int ret;
struct i2c_client *client = v4l2_get_subdevdata(sd);
data[0] = addr;
data[1] = 0xee;
/* Send out the register address */
msg[0].addr = client->addr;
msg[0].flags = 0;
msg[0].len = 1;
msg[0].buf = &data[0];
/* then read back the result */
msg[1].addr = client->addr;
msg[1].flags = I2C_M_RD;
msg[1].len = 1;
msg[1].buf = &data[1];
ret = i2c_transfer(client->adapter, msg, 2);
if (ret >= 0) {
*value = data[1];
ret = 0;
}
return ret;
} 可以看到，读函数大概分为三步，第一步：设置你要读取的设备地址，第二步：设置flags为读，且设置你的读buffer，第三步，调用i2c_transfer。这里，在i2c_transfer函数中会去调用adapter的master_xfer方法。
接下来，我们再来看一下写函数。
int write(struct v4l2_subdev *sd, unsigned char addr, unsigned char value)
{
struct i2c_msg msg;
unsigned char data[2];
int ret;
struct i2c_client *client = v4l2_get_subdevdata(sd);
data[0] = addr;
data[1] = value;
msg.addr = client->addr;
msg.flags = 0;
msg.len = 2;
msg.buf = data;
ret = i2c_transfer(client->adapter, &msg, 1);
if (ret >= 0) {
ret = 0;
} else {
cci_err("%s error! slave = 0x%x, addr = 0x%2x, value = 0x%2x\n ",
__func__, client->addr, addr, value);
}
return ret;
}读函数相比于写函数来说，步骤要少一些，在这里，只需要设置msg的地址、flag等，然后再调用i2c_transfer就可以了。
六、总结
看完上面的内容，想来大家对Linux下的I2C驱动框架也有一定的了解了。
Linux下的I2C驱动框架，总共分为三层：I2C核心、I2C总线驱动、I2C设备驱动。I2C核心是负责联络I2C总线驱动和I2C设备驱动的媒婆，I2C总线驱动和I2C设备驱动则是一对相爱相杀的恋人。I2C总线驱动注册好特定总线的i2c_adapter，并设置好其中的i2c_algorithm通信方法。而I2C设备驱动则由注册在i2c_adapter上的i2c_client，通过i2c_algorithm与这条i2c总线上的各个设备完成感情的联络。