1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct i2c_adapter {
	struct module *owner;
	unsigned int id;
	unsigned int class;		  /* classes to allow probing for */
	const struct i2c_algorithm *algo; /* the algorithm to access the bus */
	void *algo_data;

	/* data fields that are valid for all devices	*/
	struct rt_mutex bus_lock;

	int timeout;			/* in jiffies */
	int retries;
	struct device dev;		/* the adapter device */

	int nr;
	char name[48];
	struct completion dev_released;
	struct list_head userspace_clients;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct i2c_algorithm {
	/* If an adapter algorithm can't do I2C-level access, set master_xfer
	   to NULL. If an adapter algorithm can do SMBus access, set
	   smbus_xfer. If set to NULL, the SMBus protocol is simulated
	   using common I2C messages */
	/* master_xfer should return the number of messages successfully
	   processed, or a negative value on error */
	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);

	/* To determine what the adapter supports */
	u32 (*functionality) (struct i2c_adapter *);
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct i2c_msg {
	__u16 addr;	/* 从机在I2C总线上的地址*/
	__u16 flags;	/* 消息特征的标志 */

//下面的宏定义就是消息特征的标志
#define I2C_M_TEN		0x0010	/* this is a ten bit chip address */
#define I2C_M_RD		0x0001	/* read data, from slave to master */
#define I2C_M_NOSTART		0x4000	/* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_REV_DIR_ADDR	0x2000	/* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK	0x1000	/* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK		0x0800	/* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN		0x0400	/* length will be first received byte */

	__u16 len;		/* 消息数据长度，单位是字节 */
	__u8 *buf;		/* 指向存放消息数据的缓冲区 */
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
struct i2c_driver {
	unsigned int class;

	int (*attach_adapter)(struct i2c_adapter *);
	int (*detach_adapter)(struct i2c_adapter *);

	/* Standard driver model interfaces */
	int (*probe)(struct i2c_client *, const struct i2c_device_id *);
	int (*remove)(struct i2c_client *);

	/* driver model interfaces that don't relate to enumeration  */
	void (*shutdown)(struct i2c_client *);
	int (*suspend)(struct i2c_client *, pm_message_t mesg);
	int (*resume)(struct i2c_client *);

	void (*alert)(struct i2c_client *, unsigned int data);
	int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
	struct device_driver driver;
	const struct i2c_device_id *id_table;
	
	/* Device detection callback for automatic device creation */
	int (*detect)(struct i2c_client *, struct i2c_board_info *);
	const unsigned short *address_list;
	struct list_head clients;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
struct i2c_client {
	unsigned short flags;		/* div., see below		*/
	unsigned short addr;		/* chip address - NOTE: 7bit	*/
					/* addresses are stored in the	*/
					/* _LOWER_ 7 bits		*/
	char name[I2C_NAME_SIZE];
	struct i2c_adapter *adapter;	/* the adapter we sit on	*/
	struct i2c_driver *driver;	/* and our access routines	*/
	struct device dev;		/* the device structure		*/
	int irq;			/* irq issued by device		*/
	struct list_head detected;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
//适配器上要支持的I2C设备信息，将来要传给驱动程序
struct i2c_board_info {
	char		type[I2C_NAME_SIZE];	//用于和驱动匹配的名字
	unsigned short	flags;
	unsigned short	addr;	//设备在I2C总线上的地址
	void		*platform_data;	//要传给I2C总线上对应驱动的数据
	struct dev_archdata	*archdata;
#ifdef CONFIG_OF
	struct device_node *of_node;
#endif
	int		irq;	//将使用的中断号
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//i2c-core.c
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,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);

static const struct i2c_device_id dummy_id[] = {
	{ "dummy", 0 },
	{ },
};

static struct i2c_driver dummy_driver = {
	.driver.name	= "dummy",
	.probe		= dummy_probe,
	.remove		= dummy_remove,
	.id_table	= dummy_id,
};

static int __init i2c_init(void)
{
	int retval;

	//注册I2C总线
	retval = bus_register(&i2c_bus_type);
	if (retval)
		return retval;
		
	//向I2C总线注册一个名字为dummy的驱动，这个驱动没什么实际的功能，空实现的驱动
	retval = i2c_add_driver(&dummy_driver);
	if (retval)
		goto class_err;
	return 0;

class_err:
	bus_unregister(&i2c_bus_type);
	return retval;
}

static void __exit i2c_exit(void)
{
	//删除dummy驱动
	i2c_del_driver(&dummy_driver);
	//卸载I2C总线
	bus_unregister(&i2c_bus_type);
}

/* We must initialize early, because some subsystems register i2c drivers
 * in subsys_initcall() code, but are linked (and initialized) before i2c.
 */
postcore_initcall(i2c_init);
module_exit(i2c_exit);

1
2
3
4
5
6
7
8
9
10
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,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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)
{
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;

	if (!client)
		return 0;
	
	//利用container_of宏获取到I2C驱动结构体
	driver = to_i2c_driver(drv);
	
	/* 比较驱动id_table中是否有名字能和client匹配上 */
	if (driver->id_table)
		return i2c_match_id(driver->id_table, client) != NULL;

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
static int i2c_device_probe(struct device *dev)
{
	//利用container_of宏获取到I2C设备结构体
	struct i2c_client	*client = i2c_verify_client(dev);
	struct i2c_driver	*driver;
	int status;

	if (!client)
		return 0;

	//利用container_of宏获取到I2C驱动结构体
	driver = to_i2c_driver(dev->driver);
	if (!driver->probe || !driver->id_table)
		return -ENODEV;
		
	// 把I2C设备驱动和I2C设备绑定，将来可以互相查找到对方
	client->driver = driver;
	if (!device_can_wakeup(&client->dev))
		device_init_wakeup(&client->dev,
					client->flags & I2C_CLIENT_WAKE);
	dev_dbg(dev, "proben");

	//调用I2C驱动的probe函数
	status = driver->probe(client, i2c_match_id(driver->id_table, client));
	if (status) {
		client->driver = NULL;
		i2c_set_clientdata(client, NULL);
	}
	return status;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*
* 	busnum：适配器的编号，就是struct i2c_board_info结构体注册到哪个适配器驱动上
*	info：要注册的struct i2c_board_info结构体
*	len：注册的struct i2c_board_info结构体个数
*/

int __init i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned len)
{
	int status;

	down_write(&__i2c_board_lock);

	/* 动态的总线编号必须在静态的总线编号之后，动态总线编号永远比静态总线编号大一 */
	if (busnum >= __i2c_first_dynamic_bus_num)
		__i2c_first_dynamic_bus_num = busnum + 1;

	//为每一个struct i2c_board_info构建一个对应的struct i2c-devinfo结构体
	//并挂接到__i2c_board_list链表
	for (status = 0; len; len--, info++) {
		struct i2c_devinfo	*devinfo;

		devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
		if (!devinfo) {
			pr_debug("i2c-core: can't register boardinfo!n");
			status = -ENOMEM;
			break;
		}

		devinfo->busnum = busnum;	//对应适配器的编号
		devinfo->board_info = *info;
		list_add_tail(&devinfo->list, &__i2c_board_list);
	}

	up_write(&__i2c_board_lock);

	return status;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
static int i2c_register_adapter(struct i2c_adapter *adap)
{
	······

	//初始化锁和队列
	rt_mutex_init(&adap->bus_lock);
	INIT_LIST_HEAD(&adap->userspace_clients);

	/* 设置默认超时时间为1s */
	if (adap->timeout == 0)
		adap->timeout = HZ;

	//设置adap设备的名字
	dev_set_name(&adap->dev, "i2c-%d", adap->nr);
	
	adap->dev.bus = &i2c_bus_type;	//设备注册到I2C总线上
	adap->dev.type = &i2c_adapter_type;	//设备类型是i2c_adapter_type
	
	//向内核注册adap
	res = device_register(&adap->dev);

	/* 和已经注册的struct i2c_board_info结构体通过适配器编号进行匹配，匹配上就产生struct client结构体 */
	if (adap->nr < __i2c_first_dynamic_bus_num)
		i2c_scan_static_board_info(adap);

	/* 新注册了adap适配器，通知I2C总线上已经注册的I2C驱动 */
	mutex_lock(&core_lock);
	dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,
				 __process_new_adapter);
	mutex_unlock(&core_lock);

	······
}

1
2
3
4
5
i2c_register_adapter();
	i2c_scan_static_board_info();
		i2c_new_device();
			device_register(&client->dev);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
	struct i2c_devinfo	*devinfo;

	down_read(&__i2c_board_lock);
	
	//__i2c_board_list是保存struct i2c-devinfo结构体的链表，在i2c_register_board_info()函数中提到
	//遍历__i2c_board_list链表，当i2c-devinfo结构体的适配器编号和adapter的编号相等，就调用i2c_new_device()函数
	list_for_each_entry(devinfo, &__i2c_board_list, list) {
		if (devinfo->busnum == adapter->nr
				&& !i2c_new_device(adapter,
						&devinfo->board_info))
			dev_err(&adapter->dev,
				"Can't create device at 0x%02xn",
				devinfo->board_info.addr);
	}
	
	up_read(&__i2c_board_lock);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
	struct i2c_client	*client;
	int			status;

	······
	
	//分配struct i2c_client内存
	client = kzalloc(sizeof *client, GFP_KERNEL);
	if (!client)
		return NULL;

	//保存对应的适配器结构体
	client->adapter = adap;

	//struct i2c_board_info结构体要传给I2C总线上对应驱动的数据
	client->dev.platform_data = info->platform_data;

	if (info->archdata)
		client->dev.archdata = *info->archdata;

	//struct i2c_board_info结构体保存的信息赋值给struct client
	client->flags = info->flags;
	client->addr = info->addr;
	client->irq = info->irq;
	strlcpy(client->name, info->type, sizeof(client->name));

	/* 检测i2c_board_info结构体传递的设备在I2C总线上的从地址是否符合要求 */
	status = i2c_check_client_addr_validity(client);
	if (status) {
		dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hxn",
			client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
		goto out_err_silent;
	}

	/* 检测i2c_board_info结构体传递的设备在I2C总线上的从地址是否已经被注册 */
	status = i2c_check_addr_busy(adap, client->addr);
	if (status)
		goto out_err;

	//client在内核中也是一个设备，初始化内置的设备结构体
	client->dev.parent = &client->adapter->dev;
	client->dev.bus = &i2c_bus_type;	//设备类型
	client->dev.type = &i2c_client_type;	//设备所属的总线

	//client的名字
	dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
		     client->addr);

	//向I2C总线注册client设备		 
	status = device_register(&client->dev);
	
	······
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
		     void *data, int (*fn)(struct device_driver *, void *))
{
	struct klist_iter i;
	struct device_driver *drv;
	int error = 0;

	if (!bus)
		return -EINVAL;

	//遍历bus总线上已经注册的驱动，调用fn匹配函数将驱动和data进行匹配
	klist_iter_init_node(&bus->p->klist_drivers, &i,
			     start ? &start->p->knode_bus : NULL);
	while ((drv = next_driver(&i)) && !error)
		error = fn(drv, data);
	klist_iter_exit(&i);
	return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//I2C驱动和适配器adapter进行匹配
static int i2c_do_add_adapter(struct i2c_driver *driver,
			      struct i2c_adapter *adap)
{
	/* Detect supported devices on that bus, and instantiate them */
	i2c_detect(adap, driver);

	/* 如果I2C驱动定义了attach_adapter方法，就调用 */
	if (driver->attach_adapter) {
		/* We ignore the return code; if it fails, too bad */
		driver->attach_adapter(adap);
	}
	return 0;
}

//根据内核通用驱动，利用container_of宏得到struct i2c_driver驱动结构体
#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)

static int __process_new_adapter(struct device_driver *d, void *data)
{
	return i2c_do_add_adapter(to_i2c_driver(d), data);
}