Linux I2C总线（一）I2C驱动框架

分手后的思念是犯贱 2024-04-17 06:24 94阅读 0赞

**Linux I2C总线**

[Linux I2C总线（一）I2C驱动框架][Linux I2C_I2C]

[Linux I2C总线（二）I2C设备驱动编写方法][Linux I2C_I2C 1]

# Linux I2C总线（一）I2C驱动框架 #

### 文章目录 ###

*  Linux I2C总线（一）I2C驱动框架
 *   *  一、Linux I2C驱动的主要对象
     *   *  1.1 I2C总线
         *  1.2 I2C设备
         *  1.3 I2C驱动
         *  1.4 I2C适配器
     *  二、Linux I2C驱动框架
     *  三、I2C驱动框架源码剖析
     *   *  3.1 注册I2C设备
         *  3.2 注册I2C驱动
         *  3.3 I2C适配器的构建
         *  3.4 I2C数据传输

## 一、Linux I2C驱动的主要对象 ##

### 1.1 I2C总线 ###

I2C总线用于管理I2C设备和I2C驱动，维护一个设备链表和驱动链表，定义了设备和驱动的匹配规则，定义了匹配成功后的行为，其在内核中的定义如下

struct bus_type i2c_bus_type = {
        
    	.name		= "i2c",
    	.match		= i2c_device_match, //匹配规则
    	.probe		= i2c_device_probe, //匹配后的行为
    	.remove		= i2c_device_remove,
    	.shutdown	= i2c_device_shutdown,
    	.pm		= &i2c_device_pm_ops,
    };

### 1.2 I2C设备 ###

I2C设备描述了I2C设备的硬件信息，例如I2C设备的地址、I2C设备在接在哪一个I2C控制器上，其结构体定义如下

struct i2c_client {
        
    	unsigned short addr; //设备地址
    	char name[I2C_NAME_SIZE]; //设备名称
    	struct i2c_adapter *adapter; //适配器，指I2C控制器
    	struct i2c_driver *driver; //设备对应的驱动
    	struct device dev; //表明这是一个设备
    	int irq; //中断号
    	struct list_head detected;
    };

### 1.3 I2C驱动 ###

I2C驱动是I2C设备的驱动程序，用于匹配I2C设备，其结构体定义如下

struct i2c_driver {
        
    	int (*probe)(struct i2c_client *, const struct i2c_device_id *); //probe函数
    	struct device_driver driver; //表明这是一个驱动
    	const struct i2c_device_id *id_table; //要匹配的从设备信息(名称)
    	int (*detect)(struct i2c_client *, struct i2c_board_info *); //设备探测函数
    	const unsigned short *address_list; //设备地址
    	struct list_head clients; //设备链表
        ...
    };

### 1.4 I2C适配器 ###

I2C适配器是SOC上的I2C控制器的软件抽象，可以通过其定义的算法向硬件设备传输数据，其结构体定义如下

struct i2c_adapter {
        
    	unsigned int id;
    	unsigned int class;
    	const struct i2c_algorithm *algo; //算法
    	void *algo_data;
    	...
    	struct device dev;		/* the adapter device */
    	...
    };

其中的`i2c_algorithm`表示算法，用于向硬件设备传输数据，其定义如下

struct i2c_algorithm {
        
    	int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
    			   int num);
    	int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
    			   unsigned short flags, char read_write,
    			   u8 command, int size, union i2c_smbus_data *data);
    	u32 (*functionality) (struct i2c_adapter *);
    };

**总结一下**：I2C驱动的主要对象是`I2C总线`、`I2C设备`、`I2C驱动`、`I2C适配器`

I2C总线用于管理I2C设备和I2C驱动

I2C设备描述了I2C设备的硬件信息

I2C驱动是I2C设备对应的驱动程序

I2C适配器是SOC上的I2C控制器，其定义了算法，可以向I2C硬件设备传输数据

其中直接面向编写I2C设备驱动的开发者的是`I2C设备`和`I2C驱动`，`I2C总线`和`I2C适配器`是幕后工作者

## 二、Linux I2C驱动框架 ##

I2C驱动框架可以分为四部分，`I2C核心`、`I2C设备`、`I2C驱动`、`I2C适配器`，其中I2C总线位于I2C核心中

可以用下图来总结

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]

I2C核心维护着一条`I2C总线`，提供了注册`I2C设备`、`I2C驱动`、`I2C适配器`的接口

`I2C总线`维护着一条设备链表和驱动链表，当向I2C核心层注册设备时，会将其添加到总线的设备链表中，然后遍历总线上的驱动链表，查看二者是否匹配，如果匹配就调用驱动的probe函数

当注册I2C驱动时，也会将其添加到I2C总线的驱动链表中，然后遍历总线的设备链表，查看二者是否匹配，如果匹配就调用驱动的probe函数

在I2C驱动程序中，通过I2C适配器中的算法向I2C硬件设备传输数据

## 三、I2C驱动框架源码剖析 ##

### 3.1 注册I2C设备 ###

注册I2C适配可以通过`i2c_new_device`，此函数会生成一个`i2c_client`，指定对应的总线为I2C总线，然后向总线注册设备

struct i2c_client *
    i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
    {
        
        struct i2c_client	*client;
        client = kzalloc(sizeof *client, GFP_KERNEL);
            
        client->dev.bus = &i2c_bus_type; //指定I2C总线
        
        device_register(&client->dev); //向总线注册设备
    }

看一下其中的`i2c_bus_type`对象，其表示I2C总线，定义了设备和驱动的匹配规则还有匹配成功后的行为

struct bus_type i2c_bus_type = {
        
    	.name		= "i2c",
    	.match		= i2c_device_match, //匹配规则
    	.probe		= i2c_device_probe, //匹配成功后的行为
    	.remove		= i2c_device_remove,
    	.shutdown	= i2c_device_shutdown,
    	.pm		= &i2c_device_pm_ops,
    };

下面再来看看`device_register`向总线注册设备过程中会发生什么

`device_register`首先会将设备添加到总线的设备链表中，然后遍历总线的驱动链表，判断设备和驱动是否匹配，如果匹配就调用驱动的probe函数，下面看一看源码分析

int device_register(struct device *dev)
    {
        
        device_add(dev);
    }

int device_add(struct device *dev)
    {
        
        bus_add_device(dev); //添加设备到总线的设备链表中
        
        bus_probe_device(dev); //遍历总线的驱动
    }

其中`bus_add_device`函数会将设备添加到总线的设备链表中，如下

int bus_add_device(struct device *dev)
    {
        
        klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
    }

`bus_probe_device`函数会遍历总线的驱动链表，如下

void bus_probe_device(struct device *dev)
    {
        
        device_attach(dev);
    }

int device_attach(struct device *dev)
    {
        
        /* 遍历总线的驱动链表 */
        bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
    }

`bus_for_each_drv(dev->bus, NULL, dev, __device_attach);`会遍历总线的驱动链表的每一项，然后调用`__device_attach`

static int __device_attach(struct device_driver *drv, void *data)
    {
        
    	if (!driver_match_device(drv, dev))
    		return 0;
        
    	return driver_probe_device(drv, dev);
    }

`driver_match_device`函数会判断设备和驱动是否匹配，如果匹配就调用`driver_probe_device`

首先来看一看`driver_match_device`函数的定义

static inline int driver_match_device(struct device_driver *drv,
    				      struct device *dev)
    {
        
    	return drv->bus->match ? drv->bus->match(dev, drv) : 1;
    }

发现它调用了总线的match函数，这里的总线在注册I2C设备的时候已经被设置为I2C总线了，定义如下

所以这里会调用到`i2c_device_match`函数，`i2c_device_match`会通过I2C驱动的id\_table中每一的name和I2C设备的name进行匹配

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;
    }
    
    static int i2c_device_match(struct device *dev, struct device_driver *drv)
    {
        
        i2c_match_id(driver->id_table, client);
    }

如果匹配成功会调用`driver_probe_device`，下面再来看看`driver_probe_device`

`driver_probe_device`函数最终会先调用到I2C总线的probe函数，然后再调用I2C驱动的probe函数

int driver_probe_device(struct device_driver *drv, struct device *dev)
    {
        
        really_probe(dev, drv);
    }

static int really_probe(struct device *dev, struct device_driver *drv)
    {
        
        
    }

总线的probe函数为`i2c_device_probe`，此函数会调用驱动的probe函数

static int i2c_device_probe(struct device *dev)
    {
        
        /* 调用驱动的probe函数 */
        driver->probe(client, i2c_match_id(driver->id_table, client));
    }

### 3.2 注册I2C驱动 ###

可以通过`i2c_add_driver`注册I2C驱动，该函数会指定驱动对应的总线为I2C总线，然后向总线注册驱动，

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
    {
        
        driver->driver.bus = &i2c_bus_type; //指定I2C总线
        
        driver_register(&driver->driver); //向总线注册驱动
    }

`i2c_bus_type`的定义如下

`driver_register`函数遍历总线的设备链表进行操作，然后将驱动添加到总线的驱动链表中

int driver_register(struct device_driver *drv)
    {
        
        bus_add_driver(drv);
    }

int bus_add_driver(struct device_driver *drv)
    {
        
        driver_attach(drv); //此函数会遍历总线设备链表进行操作
        
        klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); // 添加进bus的driver链表中
    }

int driver_attach(struct device_driver *drv)
    {
        
        /* 遍历总线的设备链表，调用__driver_attach */
        bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
    }

下面来看一看`__driver_attach`函数，此函数会判断设备和驱动是否匹配，如果匹配就调用驱动的probe函数

static int __driver_attach(struct device *dev, void *data)
    {
        
    	if (!driver_match_device(drv, dev))
    		return 0;
        
        driver_probe_device(drv, dev);
    }

这个过程和注册设备的过程是一样的，这里不再分析

### 3.3 I2C适配器的构建 ###

对于I2C适配器，我们不讨论它的注册细节，我们看它是如何构建的

对于三星平台，在`drivers\i2c\busses\i2c-s3c2410.c`文件中构建并注册了I2C适配器，这是三星平台I2C控制器的驱动

static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
        
    	.master_xfer		= s3c24xx_i2c_xfer,
    	.functionality		= s3c24xx_i2c_func,
    };
    
    static int s3c24xx_i2c_probe(struct platform_device *pdev)
    {
        
        i2c->adap.algo    = &s3c24xx_i2c_algorithm; //构建了算法
        
        i2c_add_numbered_adapter(&i2c->adap); //注册了适配器
    }

其中的`s3c24xx_i2c_algorithm`中的`s3c24xx_i2c_xfer`就是通过操作寄存器来通过I2C控制器传输数据

### 3.4 I2C数据传输 ###

上面介绍I2C数据传输是通过I2C适配器完成的，下面来分析一下源码

在I2C驱动中，使用`i2c_transfer`来传输I2C数据，此函数肯定是通过I2C适配器的算法进行操作的，如下

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
    {
        
        adap->algo->master_xfer(adap, msgs, num); //调用适配器的算法
    }

[Linux I2C_I2C]: https://blog.csdn.net/weixin_42462202/article/details/100083025
[Linux I2C_I2C 1]: https://blog.csdn.net/weixin_42462202/article/details/100083033
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190826163419771.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg==,size_16,color_FFFFFF,t_70