I2C驱动框架

Linux的I2C体系结构分为3个组成部分，分别是I2C核心、I2C总线驱动和I2C设备驱动。
I2C控制器的驱动程序称为总线驱动（包含两部分，硬件相关、硬件无关），将I2C设备的驱动程序称为设备驱动（包含两部分，I2C设备匹配相关、I2C设备操作方法集）。

I2C驱动设计过程简述：

I2C设备注册：
首先要向I2C核心层注册一个I2C设备，I2C总线会将其添加到总线的设备链表中，然后遍历总线上的驱动链表，查看二者是否匹配，如果匹配就调用驱动的probe函数。
I2C驱动注册：
注册I2C驱动时，也会将其添加到I2C总线的驱动链表中，然后遍历总线的设备链表，查看二者是否匹配，如果匹配就调用驱动的probe函数。
I2C适配器注册：
I2C适配器也是以设备的形式挂在总线上，通过操作寄存器来传输数据。

I2C总线基础详解链接

具体实现程序详解

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

struct bus_type i2c_bus_type = {
    .name                = "i2c",    //总线的名称
    .match                = i2c_device_match,    /* i2c设备与驱动注册时候会调用这个函数进行匹配操作，里面有匹配规则，目前是通过IIC设备i2c_client结构体中名字与驱动i2c_driver结构体中id_table匹配，注意：并不会匹配驱动名字！ */
    .probe                = i2c_device_probe,    //匹配成功后会调用总线的probe函数，在里面进一步调用iic驱动的prob函数（也就是自己写的）
    .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 flags;                //I2C_CLIENT_TEN表示设备使用10bit从地址，I2C_CLIENT_PEC表示设备使用SMBus检错
    unsigned short addr;                /*I2C设备基地址，7bit。这里说一下为什么是7位，因为最后以为0表示写，1表示读，通过对这个7bit地址移位处理即可。addr<<1 & 0x0即写，addr<<1 | 0x01即读*/
    char name[I2C_NAME_SIZE];      //i2c设备名字，用于匹配iic驱动
    struct i2c_adapter *adapter;        /*iic设备是挂在哪个适配器（总线）上        */
    struct device dev;                /* 表明这是一个设备，挂在I2C总线上        */
    int irq;                        /* 中断号，用于申请中断，一般是在自己实现的i2c驱动的probe函数中使用*/
    struct list_head detected;    //是i2c_adapter结构体或i2c_driver结构体中链表的节点
};

i2c_client结构体成员的参数是通过i2c_board_info中的成员进行赋值，用于I2C设备的注册，具体内容如下：

struct i2c_board_info {
    char        type[I2C_NAME_SIZE];  //设备名，最长20个字符，最终安装到client的name上
    unsigned short    flags;  //最终安装到client.flags
    unsigned short    addr;  //设备从地址slave address，最终安装到client.addr上
    void        *platform_data;  //设备数据，最终存储到i2c_client.dev.platform_data上
    struct dev_archdata    *archdata;
    struct device_node *of_node;  //OpenFirmware设备节点指针
    struct acpi_dev_node acpi_node;
    int        irq;  //设备采用的中断号，最终存储到i2c_client.irq上
};

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

struct i2c_driver {
    unsigned int class;
    int (*attach_adapter)(struct i2c_adapter *) __deprecated;    //老的匹配函数
    /* Standard driver model interfaces */
    int (*probe)(struct i2c_client *, const struct i2c_device_id *);    //当前匹配成功后执行函数，一般是申请资源，注册字符驱动
    int (*remove)(struct i2c_client *);    //当前移除设备或驱动时执行的移除函数，一般是释放资源
    int (*probe_new)(struct i2c_client *);    //未来匹配成功后的执行函数
    void (*shutdown)(struct i2c_client *);    //关闭设备
    void (*alert)(struct i2c_client *, enum i2c_alert_protocol protocol,unsigned int data);
    int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
    struct device_driver driver;    //表明这是一个驱动，驱动模型用来挂在I2C总线上
    const struct i2c_device_id *id_table;    //设备匹配列表，非常重要，IIC设备的名字与这个列表匹配
    int (*detect)(struct i2c_client *, struct i2c_board_info *);
    const unsigned short *address_list;    //该驱动所支持的所有（次设备）的地址数组，用于注册驱动时自动去匹配
    struct list_head clients;    //用来挂接与该i2c_driver匹配成功的i2c_client (次设备)的一个链表头
    bool disable_i2c_core_irq_mapping;
};

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

struct i2c_adapter {
    struct module *owner;//所有者
    unsigned int class;                  /*适配器支持的从设备类型 */
    const struct i2c_algorithm *algo; /* 适配器的通信方法，也就是上面的i2c_algorithm */
    void *algo_data;    //algo私有数据
    int timeout;                        /* 超时时间 */
    int retries;                               //重传次数，在通信方法中使用
    struct device dev;                /* 表明这是一个设备，挂载在I2C总线上 */
    int nr;                                          //适配器（总线）的编号
    char name[48];                        //适配器名称
    struct list_head userspace_clients;     //IIC设备的client依附链表头，只有在用户层echo name addr > /sys/bus/i2c/devices/i2c-x/new_device时候创建的client才会依附在此链表
    …//省略部分无关成员
};

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

struct i2c_algorithm {
    int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,   int num);    //I2C传输函数指针，i2c_transfer函数的底层调用
 
	int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,   unsigned short flags, char read_write,   u8 command, int size, union i2c_smbus_data *data);    //smbus传输函数指针，SMBUS协议发送函数，i2c_smbus_xxx函数的底层调用
 
	u32 (*functionality) (struct i2c_adapter *);    /* 这个IIC适配器支持什么样的功能，比如支持SMBUS字节发送或读取操作,标志位为I2C_FUNC_SMBUS_BYTE_DATA */
};

总结：
I2C驱动设计的的主要对象是I2C总线、I2C设备、I2C驱动、I2C适配器
I2C总线用于管理I2C设备和I2C驱动
I2C设备描述了I2C设备的硬件信息
I2C驱动是I2C设备对应的驱动程序
I2C适配器是SOC上的I2C控制器，其定义了算法，可以向I2C硬件设备传输数据

2.1 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);//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首先会将设备添加到总线的设备链表中，然后遍历总线的驱动链表，判断设备和驱动是否匹配，如果匹配就调用驱动的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;
}

这里调用的就是最开始i2c_bus_type成员中设置的i2c_device_match函数，然后我们再分析i2c_device_match：

static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
    i2c_match_id(driver->id_table, client);
}

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函数去将驱动和设备进行匹配
再回到__device_attach函数，当完成匹配后就会执行driver_probe_device，继续分析该函数：

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)
{
  i2c_device_probe(dev);  
}

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

函数最后执行的是驱动的probe函数，也就是最开始我们再驱动注册时设置的驱动成员函数：

struct i2c_driver {
    int (*probe)(struct i2c_client *, const struct i2c_device_id *);    //当前匹配成功后执行函数，一般是申请资源，注册字符驱动
};

2.2 注册I2C驱动过程源码详解：

通过i2c_add_driver注册I2C驱动，该函数会指定驱动对应的总线为I2C总线，然后向总线注册驱动，基本的过程与I2C设备的注册一致，所以要先搞懂设备注册，驱动注册流程也就水到渠成，需要注意的下面第一段代码，即驱动结构体成员指定的各个函数，因为通过上面的源码分析我们知道驱动注册、注销最终会运行驱动的probe、remove相关函数：

static const struct i2c_device_id my_i2c_dev_id[] = {
	{ "my_i2c_dev", 0},  /* 设备名字 */
	{ }
};
 
static struct i2c_driver driver = {
	.driver = {
		.name	= "i2c", /* 这个名字不重要 */
        .owner = THIS_MODULE,
	},
	.probe		= my_i2c_drv_probe, /* 当匹配到i2c设备时调用 */
	.remove		= my_i2c_drv_remove, /* 当卸载i2c设备或驱动时调用 */
	.id_table	= my_i2c_dev_id, /* 这个结构体中的名字很重要 */
};

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

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);
}

2.3 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); //注册了适配器
}

在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); //调用适配器的算法
}

其中msgs结构体内容如下：

struct i2c_msg {
    __u16 addr;                 /* IIC设备的基地址，7位 */
    __u16 flags;               /*操作标志位*/
    __u16 len;                /* 读写数据的长度 */
    __u8 *buf;               /* 装有数据的缓冲区 */
    #define I2C_M_RD                0x0001        /* 设置了这个标志位表示本次通信i2c控制器是处于接收方，否则就是发送方 */
    #define I2C_M_TEN                0x0010        /* 设置了这个标志位表示从设备的地址是10bit */
    #define I2C_M_DMA_SAFE                0x0200        /* the buffer of this message is DMA safe */
    /* makes only sense in kernelspace */
    /* userspace buffers are copied anyway */
    #define I2C_M_RECV_LEN                0x0400        /* length will be first received byte */
    #define I2C_M_NO_RD_ACK                0x0800        /* 设置这个标志位表示在读操作中主机不用ACK */
    #define I2C_M_IGNORE_NAK        0x1000        /* 设置这个标志意味当前i2c_msg忽略I2C器件的ack和nack信号 */
    #define I2C_M_REV_DIR_ADDR        0x2000        /* if I2C_FUNC_PROTOCOL_MANGLING */
    #define I2C_M_NOSTART                0x4000        /* if I2C_FUNC_NOSTART */
    #define I2C_M_STOP                0x8000        /* if I2C_FUNC_PROTOCOL_MANGLING */
};

其他知识分享：
I2C总线基础详解链接