Linux i2c驱动框架分析 （一）
Linux i2c驱动框架分析 （二）
Linux i2c驱动框架分析 （三）
通用i2c设备驱动分析

i2c core

i2c核心（drivers/i2c/i2c-core.c）中提供了一组不依赖于硬件平台的接口函数，理解其中的主要函数非常关键，因为 I2C 总线驱动和设备驱动之间赖于i2c核心作为纽带。i2c核心中提供的主要函数如下。
（1）增加/删除i2c_adapter

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

（2）增加/删除i2c_driver

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

#define i2c_add_driver(driver) \
	i2c_register_driver(THIS_MODULE, driver)

（3）增加/删除i2c_client

struct i2c_client *i2c_new_device(struct i2c_adapter *adap, 
	struct i2c_board_info const *info);

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

void i2c_unregister_device(struct i2c_client *client)

（4）i2c传输、发送和接收

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
int i2c_master_send(const struct i2c_client *client, const char *buf,
			   int count);
int i2c_master_recv(const struct i2c_client *client, char *buf,
			   int count);

i2c_transfer()函数用于进行i2c适配器和i2c设备之间的一组消息交互，i2c_master_send()函数和i2c_master_recv()函数内部会调用i2c_transfer()函数分别完成一条写消息和一条读消息。

i2c_transfer()函数本身不具备驱动适配器物理硬件完成消息交互的能力，它只是寻找到i2c_adapter对应的i2c_algorithm，并使用 i2c_algorithm的master_xfer()函数真正驱动硬件流程。

在i2c_core.c中定义了一个总线类型i2c_bus_type：

struct bus_type i2c_bus_type = {
	.name		= "i2c",
	.match		= i2c_device_match,
	.probe		= i2c_device_probe,
	.remove		= i2c_device_remove,
	.shutdown	= i2c_device_shutdown,
};

这个i2c总线结构体管理着i2c设备与i2c驱动的匹配，删除等操作，i2c总线会调用i2c_device_match函数看i2c设备和i2c驱动是否匹配，如果匹配就调用i2c_device_probe函数，进而调用i2c驱动的probe函数。

i2c设备与驱动

Linux i2c设备驱动的模块加载与卸载

i2c设备驱动的模块加载函数通用的方法是进行通过I2C核心的 i2c_add_driver()函数添加 i2c_driver的工作，而在模块卸载函数中需要做相反的工作：通过i2c核心的i2c_del_driver()函数删除i2c_driver。

Linux i2c设备实例化的多种方法

这里只是介绍其中的几种方法。

1. 通过devicetree声明I2C设备
   在i2c控制器的节点里声明子节点，每个子节点代表一个i2c设备，如下图所示：
   

2. 显式实例化i2c设备
   通过i2c_new_device()或者i2c_new_probed_device()函数，创建并注册i2c_client。

3. 从用户空间实例化i2c设备
   Example:

//名字为eeprom，地址为0x50的i2c设备注册进内核，挂接在i2c控制器0上
echo eeprom 0x50 > /sys/bus/i2c/devices/i2c-0/new_device

驱动与设备的匹配

i2c驱动与设备的匹配是在注册驱动或设备时进行匹配的，下面以注册i2c驱动为例，分析匹配过程的细节。

注册i2c驱动：

#define i2c_add_driver(driver) \
	i2c_register_driver(THIS_MODULE, driver)


int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
	int res;

	/* Can't register until after driver model init */
	if (WARN_ON(!is_registered))
		return -EAGAIN;

	/* add the driver to the list of i2c drivers in the driver core */
	driver->driver.owner = owner;

	//设置所属总线为i2c_bus_type
	driver->driver.bus = &i2c_bus_type;

	INIT_LIST_HEAD(&driver->clients);

	//注册驱动
	res = driver_register(&driver->driver);
	if (res)
		return res;

	pr_debug("driver [%s] registered\n", driver->driver.name);

	/* 探测驱动的address_list列表中的设备地址是否存在，存在则注册设备 */
	i2c_for_each_dev(driver, __process_new_driver);

	return 0;
}

下面重点分析driver_register函数：

int driver_register(struct device_driver *drv)
{
	int ret;
	struct device_driver *other;

	BUG_ON(!drv->bus->p);

	//进行一些相关判断
	if ((drv->bus->probe && drv->probe) ||
	    (drv->bus->remove && drv->remove) ||
	    (drv->bus->shutdown && drv->shutdown))
		printk(KERN_WARNING "Driver '%s' needs updating - please use "
			"bus_type methods\n", drv->name);

	//查询是否含有同名驱动
	other = driver_find(drv->name, drv->bus);
	if (other) {
		printk(KERN_ERR "Error: Driver '%s' is already registered, "
			"aborting...\n", drv->name);
		return -EBUSY;
	}

	/* 把驱动插入到bus的驱动链表，这里涉及设备驱动模型相关知识
     *  在/sys/bus/i2c/drivers/目录下创建该驱动的sysfs目录，
     *  同时遍历bus的设备链表调用__driver_attach函数
     */
	ret = bus_add_driver(drv);
	if (ret)
		return ret;

	//增添属性相关
	ret = driver_add_groups(drv, drv->groups);
	if (ret) {
		bus_remove_driver(drv);
		return ret;
	}
	kobject_uevent(&drv->p->kobj, KOBJ_ADD);

	return ret;
}

__driver_attach：

static int __driver_attach(struct device *dev, void *data)
{
	struct device_driver *drv = data;
	int ret;


	/* 调用bus里的match函数进行匹配，对于i2c bus对应函数i2c_device_match
     * 匹配成功返回1
     */
	ret = driver_match_device(drv, dev);
	if (ret == 0) {
		/* no match */
		return 0;
	} else if (ret == -EPROBE_DEFER) {
		dev_dbg(dev, "Device match requests probe deferral\n");
		driver_deferred_probe_add(dev);
	} else if (ret < 0) {
		dev_dbg(dev, "Bus failed to match device: %d", ret);
		return ret;
	} /* ret > 0 means positive match */

	......
	
	//判断该设备是否已匹配了驱动
	if (!dev->driver)
		//会调到bus里的probe函数，对于i2c bus对应函数为i2c_device_probe(如果不存在则调用驱动的probe函数)
		driver_probe_device(drv, dev);
	device_unlock(dev);
	if (dev->parent)
		device_unlock(dev->parent);

	return 0;
}

分析i2c_device_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;

	//设备树匹配 
	if (of_driver_match_device(dev, drv))
		return 1;

	/* Then ACPI style match */
	if (acpi_driver_match_device(dev, drv))
		return 1;

	//id表匹配
	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;
}

有多种匹配方式，这里分析一下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) //比较name
			return id;
		id++;
	}
	return NULL;
}

如果匹配成功，driver_match_device函数返回1，之后会调到bus里的probe函数，对于i2c bus对应函数为i2c_device_probe：

static int i2c_device_probe(struct device *dev)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;
	int status;

	if (!client)
		return 0;

	......

	driver = to_i2c_driver(dev->driver);
	if (!driver->probe || !driver->id_table)
		return -ENODEV;

	......

	//调用驱动的probe函数
	status = driver->probe(client, i2c_match_id(driver->id_table, client));
	......
}

i2c驱动的探测功能

i2c驱动含有一个设备地址列表address_list：

struct i2c_driver {
	unsigned int class;
	......
	int (*detect)(struct i2c_client *, struct i2c_board_info *);
	const unsigned short *address_list;
	struct list_head clients;
};

在注册i2c驱动时，通过适配器，探测address_list中对应地址的设备是否存在，如果存在则注册i2c设备。

在注册i2c驱动时，会遍历i2c bus上的适配器，调用__process_new_driver函数：

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{
	int res;

	.....
	
	//可以得知i2c适配器也被当做一种设备插入到i2c bus的设备链表上
	i2c_for_each_dev(driver, __process_new_driver);

	return 0;
}

__process_new_driver：

static int __process_new_driver(struct device *dev, void *data)
{
	//判断是否为i2c适配器
	if (dev->type != &i2c_adapter_type)
		return 0;
	return i2c_do_add_adapter(data, to_i2c_adapter(dev));
}

i2c_do_add_adapter：

static int i2c_do_add_adapter(struct i2c_driver *driver,
			      struct i2c_adapter *adap)
{
	/* 探测 */
	i2c_detect(adap, driver);

	/* 这是老式的探测方法，已不推荐使用 */
	if (driver->attach_adapter) {
		dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
			 driver->driver.name);
		dev_warn(&adap->dev,
			 "Please use another way to instantiate your i2c_client\n");
		/* We ignore the return code; if it fails, too bad */
		driver->attach_adapter(adap);
	}
	return 0;
}

i2c_detect：

static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
{
	const unsigned short *address_list;
	struct i2c_client *temp_client;
	int i, err = 0;
	int adap_id = i2c_adapter_id(adapter);

	address_list = driver->address_list;

	//如果驱动未提供detect函数和address_list，直接返回
	if (!driver->detect || !address_list)
		return 0;

	/* Warn that the adapter lost class based instantiation */
	if (adapter->class == I2C_CLASS_DEPRECATED) {
		dev_dbg(&adapter->dev,
			"This adapter dropped support for I2C classes and won't auto-detect %s devices anymore. "
			"If you need it, check 'Documentation/i2c/instantiating-devices' for alternatives.\n",
			driver->driver.name);
		return 0;
	}

	/* Stop here if the classes do not match */
	if (!(adapter->class & driver->class))
		return 0;

	/* 创建一个临时的i2c_client，用于帮助探测 */
	temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
	if (!temp_client)
		return -ENOMEM;
	temp_client->adapter = adapter;

	for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
		dev_dbg(&adapter->dev,
			"found normal entry for adapter %d, addr 0x%02x\n",
			adap_id, address_list[i]);
		temp_client->addr = address_list[i];
		//设置好临时的i2c_client后，探测设备地址
		err = i2c_detect_address(temp_client, driver);
		if (unlikely(err))
			break;
	}

	kfree(temp_client);
	return err;
}

i2c_detect_address：

static int i2c_detect_address(struct i2c_client *temp_client,
			      struct i2c_driver *driver)
{
	struct i2c_board_info info;
	struct i2c_adapter *adapter = temp_client->adapter;
	int addr = temp_client->addr;
	int err;

	/* 检查addr是否有效 */
	err = i2c_check_7bit_addr_validity_strict(addr);
	if (err) {
		dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
			 addr);
		return err;
	}

	/* 检查addr是否与挂在适配器上的设备的地址相同 */
	if (i2c_check_addr_busy(adapter, addr))
		return 0;

	/* 向地址为addr的设备发送信号，可是否有回应 */
	if (!i2c_default_probe(adapter, addr))
		return 0;

	/* Finally call the custom detection function */
	memset(&info, 0, sizeof(struct i2c_board_info));
	info.addr = addr;

	/* 程序执行到这里，说明存在地址为addr的设备，调用驱动的detect函数
   * 在驱动的detect函数中，要初始化i2c_board_info->type，即i2c设备的name
   */
	err = driver->detect(temp_client, &info);
	if (err) {
		/* -ENODEV is returned if the detection fails. We catch it
		   here as this isn't an error. */
		return err == -ENODEV ? 0 : err;
	}

	/* 检查name是否初始化 */
	if (info.type[0] == '\0') {
		dev_err(&adapter->dev,
			"%s detection function provided no name for 0x%x\n",
			driver->driver.name, addr);
	} else {
		struct i2c_client *client;

		/* Detection succeeded, instantiate the device */
		if (adapter->class & I2C_CLASS_DEPRECATED)
			dev_warn(&adapter->dev,
				"This adapter will soon drop class based instantiation of devices. "
				"Please make sure client 0x%02x gets instantiated by other means. "
				"Check 'Documentation/i2c/instantiating-devices' for details.\n",
				info.addr);

		dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
			info.type, info.addr);

		//增添新的i2c设备
		client = i2c_new_device(adapter, &info);
		if (client)
			//把i2c设备插入驱动的clients链表
			list_add_tail(&client->detected, &driver->clients);
		else
			dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
				info.type, info.addr);
	}
	return 0;
}