(基于4.14内核版本)
为了梳理清楚linux内核中的i2c实现框架，从本文开始，博主将分几个章节分别解析i2c总线在linux内核中的形成过程、匹配过程、以及设备驱动程序源码实现。
在介绍linux内核中i2c框架之前，我们最好是知道怎么使用它，实现一个相应的i2c设备驱动程序demo，然后从使用去深挖背后的实现原理，先知道怎么用，然后再知道为什么可以这么用。
I2C的基本知识扫盲
回到本文的重点——I2C,做过裸板开发或者是单片机开发的朋友肯定对I2C不陌生，I2C是主从结构，主器件使用从机地址进行寻址，它的拓扑结构是这样的：
(图片来自网络，如有侵权，请联系我及时删除)
基本的流程是这样的：
主机发送从机地址
从机监听总线，检测到接收地址与自身地址地址匹配，回复。
主机启动收发数据
从机接收数据，响应
数据收发完毕，主机释放总线。
完整的I2C操作其实是比较复杂的，这里就不再展开讲解,博主将会在随后的章节中进行详解。
I2C设备驱动程序框架
I2C设备驱动程序框架分为两个部分：driver和device。
分别将driver和device加载到内存中，i2c bus在程序加载时会自动调用match函数，根据名称来匹配driver和device，匹配完成时调用probe()
在driver中，定义probe()函数，在probe函数中创建设备节点，针对不同的设备实现不同的功能。
在device中，设置设备I2C地址，选择I2C适配器。
I2C适配器：I2C的底层传输功能，一般指硬件I2C控制器。
I2C设备驱动程序
driver端示例
直接来看下面的示例代码：
i2c_bus_driver.c:
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
/* 结构体数组 结构体第一个参数为名称，第二个参数为private数据*/
static const struct i2c_device_id downey_drv_id_table[] = {
{"downey_i2c",0},
{},
};
static int major;
static struct class *i2c_test_cls;
static struct device *i2c_test_dev;
static const char* CLASS_NAME = "I2C_TEST_CLASS";
static const char* DEVICE_NAME = "I2C_TEST_DEVICE";
static struct i2c_client *downey_client;
static int i2c_test_open(struct inode *node, struct file *file)
{
printk(KERN_ALERT "i2c init \n");
return 0;
}
static ssize_t i2c_test_read(struct file *file,char *buf, size_t len,loff_t *offset)
{
int cnt = 0;
uint8_t reg = 0;
uint8_t val = 0;
copy_from_user(®,buf,1);
/*i2c读byte，通过这个函数可以从设备中指定地址读取数据*/
val = i2c_smbus_read_byte_data(downey_client,reg);
cnt = copy_to_user(&buf[1],&val,1);
return 1;
}
static ssize_t i2c_test_write(struct file *file,const char *buf,size_t len,loff_t *offset)
{
uint8_t recv_msg[255] = {0};
uint8_t reg = 0;
int cnt = 0;
cnt = copy_from_user(recv_msg,buf,len);
reg = recv_msg[0];
printk(KERN_INFO "recv data = %x.%x\n",recv_msg[0],recv_msg[1]);
/*i2c写byte，通过这个函数可以往设备中指定地址写数据*/
if(i2c_smbus_write_byte_data(downey_client,reg,recv_msg[1]) < 0){
printk(KERN_ALERT " write failed!!!\n");
return -EIO;
}
return len;
}
static int i2c_test_release(struct inode *node,struct file *file)
{
printk(KERN_INFO "Release!!\n");
return 0;
}
static struct file_operations file_oprts =
{
.open = i2c_test_open,
.read = i2c_test_read,
.write = i2c_test_write,
.release = i2c_test_release,
};
/*当i2c bus检测到匹配的device - driver，调用probe()函数，在probe函数中，申请设备号，创建设备节点，绑定相应的file operation结构体。*/
static int downey_drv_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
/*保存参数client，在i2c读写操作时需要用到这个参数，其中保存了适配器、设备地址等信息*/
printk(KERN_ALERT "addr = %x\n",client->addr);
downey_client = client;
major = register_chrdev(0,DEVICE_NAME,&file_oprts);
if(major < 0 ){
printk(KERN_ALERT "Register failed!!\r\n");
return major;
}
printk(KERN_ALERT "Registe success,major number is %d\r\n",major);
/*以CLASS_NAME创建一个class结构，这个动作将会在/sys/class目录创建一个名为CLASS_NAME的目录*/
i2c_test_cls = class_create(THIS_MODULE,CLASS_NAME);
if(IS_ERR(i2c_test_cls))
{
unregister_chrdev(major,DEVICE_NAME);
return PTR_ERR(i2c_test_cls);
}
/*以DEVICE_NAME为名，参考/sys/class/CLASS_NAME在/dev目录下创建一个设备：/dev/DEVICE_NAME*/
i2c_test_dev = device_create(i2c_test_cls,NULL,MKDEV(major,0),NULL,DEVICE_NAME);
if(IS_ERR(i2c_test_dev))
{
class_destroy(i2c_test_cls);
unregister_chrdev(major,DEVICE_NAME);
return PTR_ERR(i2c_test_dev);
}
printk(KERN_ALERT "i2c_test device init success!!\r\n");
return 0;
}
/*Remove :当匹配关系不存在时(device或是driver被卸载)，调用remove函数，remove函数是probe函数的反操作，将probe函数中申请的资源全部释放。*/
static int downey_drv_remove(struct i2c_client *client)
{
printk(KERN_ALERT "remove!!!\n");
device_destroy(i2c_test_cls,MKDEV(major,0));
class_unregister(i2c_test_cls);
class_destroy(i2c_test_cls);
unregister_chrdev(major,DEVICE_NAME);
return 0;
}
static struct i2c_driver downey_drv = {
/*.driver中的name元素仅仅是一个标识，并不作为bus匹配的name识别*/
.driver = {
.name = "random",
.owner = THIS_MODULE,
},
.probe = downey_drv_probe,
.remove = downey_drv_remove,
/*.id_table中存储driver名称，作为bus匹配时的识别*/
.id_table = downey_drv_id_table,
// .address_list = downey_i2c,
};
int drv_init(void)
{
int ret = 0;
printk(KERN_ALERT "init!!!\n");
ret = i2c_add_driver(&downey_drv);
if(ret){
printk(KERN_ALERT "add driver failed!!!\n");
return -ENODEV;
}
return 0;
}
void drv_exit(void)
{
i2c_del_driver(&downey_drv);
return ;
}
MODULE_LICENSE("GPL");
module_init(drv_init);
module_exit(drv_exit);
代码简述
入口函数drv_init()在i2c bus的driver链表中添加一个driver节点，当然这个操作是在加载模块时完成
i2c_add_driver函数以struct i2c_driver类型结构体为参数，开发者需要填充driver信息，probe(),remove()，以及id_table,其中id_table中包含了driver名称，在i2c bus做匹配时使用。
当driver-device匹配成功时，调用driver中的probe函数，在函数中，创建设备节点等等(之前章节中的字符驱动框架还记得吧)。
当匹配关系不存在时，调用remove函数，执行probe的反操作。
需要注意的是，在这里的示例中，这仅仅是一个demo，所以没有做任何操作，事实上，如果你要实现一个设备的驱动，需要在read或write函数中实现相应功能，这里仅仅是将在/dev目录下创建一个用户文件接口，将用户写的数据写入i2c设备，读取设备数据到用户空间。
device端代码示例
i2c_bus_driver.c:
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/regmap.h>
// #include <linux/paltform_device.h>
static struct i2c_adapter *adap;
static struct i2c_client *client;
#define I2C_DEVICE_ADDR 0x68
/**指定i2c device的信息
* downey_i2c 是device中的name元素，当这个模块被加载时，i2c总线将使用这个名称匹配相应的drv。
* I2C_DEVICE_ADDR 为设备的i2c地址
* */
static struct i2c_board_info downey_board = {
I2C_BOARD_INFO("downey_i2c",I2C_DEVICE_ADDR),
};
int dev_init(void)
{
/*获取i2c适配器，适配器一般指板上I2C控制器，实现i2c底层协议的字节收发，特殊情况下，用普通gpio模拟I2C也可作为适配器*/
adap = i2c_get_adapter(2);
if(IS_ERR(adap)){
printk(KERN_ALERT "I2c_get_adapter failed!!!\n");
return -ENODEV;
}
/*创建一个I2C device，并注册到i2c bus的device链表中*/
client = i2c_new_device(adap,&downey_board);
/*使能相应适配器*/
i2c_put_adapter(adap);
if(!client){
printk(KERN_ALERT "Get new device failed!!!\n");
return -ENODEV;
}
return 0;
}
void dev_exit(void)
{
i2c_unregister_device(client);
return ;
}
MODULE_LICENSE("GPL");
module_init(dev_init);
module_exit(dev_exit);
代码简述
在入口函数dev_init函数中先获取适配器，后续使用i2c_put_adapter将适配器放入执行列表，适配器一般指板上I2C控制器，实现i2c底层协议的字节收发，特殊情况下，用普通gpio模拟I2C也可作为适配器。
创建一个新的bus device，并将其链入bus 的device链表
创建device设备需要struct i2c_board_info类型结构体作为参数，函数包含匹配时使用的name元素，以及设备的i2c地址。
编译加载运行
driver和device作为两个独立的模块，需要分别编译，分别生成i2c_bus_driver.ko和i2c_bus_device.ko(编译过程我就不再啰嗦了)。
然后加载driver：
sudo insmod i2c_bus_driver.ko
log信息
Dec 31 07:21:49 beaglebone kernel: [13114.715050] init!!!
加载device:
sudo insmod i2c_bus_device.ko
log信息：
Dec 31 07:21:49 beaglebone kernel: [13114.717420] addr = 68
Dec 31 07:21:49 beaglebone kernel: [13114.726671] Registe success,major number is 241
Dec 31 07:21:49 beaglebone kernel: [13114.739575] i2c_test device init success!!
查看log可以发现，当加载完i2c_bus_device.ko时，driver中probe函数被调用，打印出设备地址，注册的设备号，表示注册成功。接下来就是写一个用户程序来测试驱动。
实验环境
开发板：beagle bone green开发板
内核版本 ：4.14.71-ti-r80
i2c设备 ：9轴传感器，i2c地址0x68
用户代码
#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
static char buf[256] = {1};
int main(int argc,char *argv[])
{
int ret = 0;
uint8_t buf[2] = {0};
char cmd[6] = {0};
int reg_addr = 0;
int value = 0;
int fd = open("/dev/I2C_TEST_DEVICE",O_RDWR);
if(fd < 0)
{
perror("Open file failed!!!\r\n");
}
while(1){
/*for example : write 0x00 0x08*/
/*The val should be 0 when the cmd is read.*/
printf("Enter your cmd:<read/write> <reg_addr> <val> : \n");
scanf("%s",cmd);
scanf("%x",®_addr);
scanf("%x",&value);
printf("%s :%x :%x\n",cmd,reg_addr,value);
if(0 == memcmp(cmd,"write",5)){
buf[0] = reg_addr;
buf[1] = value;
int ret = write(fd,buf,2);
if(ret < 0){
perror("Failed to write!!\n");
}else{
printf("Write value %x to reg addr %x success\n",value,reg_addr);
}
}
else if(0 == memcmp(cmd,"read",4)){
buf[0] = reg_addr;
ret = read(fd,buf,1);
if(ret < 0){
perror("Read failed!!\n");
}else{
printf("Read %x from addr %x\n",buf[1],reg_addr);
}
}
else{
printf("Unsupport cmd\n");
}
memset(cmd,0,sizeof(cmd));
}
close(fd);
return 0;
}
用户程序实现从终端读取用户指令，然后读写传感器的寄存器,代码都经过测试，自己试试吧！
device的另一种创建
在上述i2c的device创建中，我们使用了i2c_new_device()接口，值得一提的是，这个接口并不会检测设备是否存在，只要对应的device-driver存在，就会调用driver中的probe函数。
但是有时候会有这样的需求：在匹配时需要先检测设备是否插入，如果没有i2c设备连接在主板上，就拒绝模块的加载，这样可以有效地管理i2c设备的资源，避免无关设备占用i2c资源。
新的创建方式接口为：
struct i2c_client *i2c_new_probed_device(struct i2c_adapter *adap,struct i2c_board_info *info,unsigned short const *addr_list,int (*probe)(struct i2c_adapter *, unsigned short addr))
这个函数添加了在匹配模块时的检测功能：
参数1：adapter，适配器
参数2：board info，包含名称和i2c地址
参数3：设备地址列表，既然参数2中有地址，为什么还要增加一个参数列表呢？咱们下面分解
参数4：probe检测函数，此probe非彼probe，这个probe函数实现的功能是检测板上是否已经物理连接了相应的设备，当传入NULL时，就是用默认的probe函数，建议使用默认probe。
为了一探究竟，我们来看看i2c_new_probed_device的源代码实现：
struct i2c_client *i2c_new_probed_device(struct i2c_adapter *adap,struct i2c_board_info *info,unsigned short const *addr_list,int (*probe)(struct i2c_adapter *, unsigned short addr))
{
int i;
/*如果传入probe为NULL，则使用默认probe函数*/
if (!probe)
probe = i2c_default_probe;
/*轮询传入的addr_list，检测指定地址列表中地址是否合法*/
for (i = 0; addr_list[i] != I2C_CLIENT_END; i++) {
/* Check address validity */
if (i2c_check_7bit_addr_validity_strict(addr_list[i]) < 0) {
dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
addr_list[i]);
continue;
}
/*检测地址是否被占用*/
/* Check address availability (7 bit, no need to encode flags) */
if (i2c_check_addr_busy(adap, addr_list[i])) {
dev_dbg(&adap->dev,
"Address 0x%02x already in use, not probing\n",
addr_list[i]);
continue;
}
/*检测对应地址上设备是否正常运行*/
/* Test address responsiveness */
if (probe(adap, addr_list[i]))
break;
}
/*检测不到对应地址的设备，或对应设备正在被占用*/
if (addr_list[i] == I2C_CLIENT_END) {
dev_dbg(&adap->dev, "Probing failed, no device found\n");
return NULL;
}
/*检测到可用地址，将其赋值给board info结构体*/
info->addr = addr_list[i];
return i2c_new_device(adap, info);
}
根据源码中的显示，i2c_new_probed_device主要是执行了这样的操作：
轮询传入的addr_list，检测指定地址列表中地址是否合法，值得注意的是，在轮询addr_list时，判断列表中元素是否等于I2C_CLIENT_END，所以我们在给addr_list赋值时，应该以I2C_CLIENT_END结尾
检测地址是否被占用
检测对应地址上设备是否处于运行状态
将找到的地址赋值给info->addr
调用i2c_new_device
看到这里就一目了然了，一切细节在源码面前都无处可藏。其实就在对相应地址做一次检测而已，到最后还是调用i2c_new_device。
不过不知道你有没有发现，i2c_new_device传入的参数2的addr部分被忽略了，所以board info中的地址其实是无关紧要的，因为函数会在addr list中查找可用的地址然后赋值给board info的addr元素，而原本的addr被覆盖。所以，如果你在写内核代码时感到疑惑，看源码就好了！
好了，关于linux驱动中i2c驱动的讨论就到此为止啦，如果朋友们对于这个有什么疑问或者发现有文章中有什么错误，欢迎留言
原创博客，转载请注明出处！
祝各位早日实现项目丛中过，bug不沾身.
