IIC驱动框架

Linux内核将 I2C 驱动分为两部分：
①、 I2C 总线驱动， I2C 总线驱动就是 SOC 的 I2C 控制器驱动，也叫做 I2C 适配器驱动。
②、 I2C 设备驱动， I2C 设备驱动就是针对具体的 I2C 设备而编写的驱动。

IIC驱动也是借用platform思想，将设备和总线进行分离，但是IIC有自己的总线，所以就不用使用虚拟总线。

I2C 总线驱动重点是 I2C 适配器(也就是 SOC 的 I2C 接口控制器)驱动，这里要用到两个重要的数据结构： i2c_adapter 和 i2c_algorithm， Linux 内核将 SOC 的 I2C 适配器(控制器)抽象成 i2c_adapter， i2c_adapter 结构体定义在 include/linux/i2c.h 文件中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
498 struct i2c_adapter {
499 struct module *owner;
500 unsigned int class; /* classes to allow probing for */
501 const struct i2c_algorithm *algo; /* 总线访问算法 */
502 void *algo_data;
503
504 /* data fields that are valid for all devices */
505 struct rt_mutex bus_lock;
506
507 int timeout; /* in jiffies */
508 int retries;
509 struct device dev; /* the adapter device */
510
511 int nr;
512 char name[48];
513 struct completion dev_released;
514
515 struct mutex userspace_clients_lock;
516 struct list_head userspace_clients;
517
518 struct i2c_bus_recovery_info *bus_recovery_info;
519 const struct i2c_adapter_quirks *quirks;
520 };

i2c_algorithm 就是 I2C 适配器与 IIC 设备进行通信的方法。i2c_algorithm 结构体定义在 include/linux/i2c.h 文件中 

1
2
3
4
5
6
7
8
9
10
11
12
391 struct i2c_algorithm {
......
398 int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,int num);
399 //master_xfer 就是 I2C 适配器的传输函数，可以通过此函数来完成与 IIC 设备之间的通信。
400 int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,unsigned short flags, char read_write,
401 u8 command, int size, union i2c_smbus_data *data);
402 //smbus_xfer 就是 SMBUS 总线的传输函数
403
404 /* To determine what the adapter supports */
405 u32 (*functionality) (struct i2c_adapter *);
......
411 };

I2C 总线驱动，或者说 I2C 适配器驱动的主要工作就是初始化 i2c_adapter 结构体变量，然后设置 i2c_algorithm 中的 master_xfer 函数。完成以后通过 i2c_add_numbered_adapter或 i2c_add_adapter 这两个函数向系统注册设置好的 i2c_adapter，这两个函数的原型如下：

1
2
3
int i2c_add_adapter(struct i2c_adapter *adapter)//使用动态的总线号
int i2c_add_numbered_adapter(struct i2c_adapter *adap) //使用静态的总线号
void i2c_del_adapter(struct i2c_adapter * adap)//删除 I2C 适配器

I2C 设备驱动

I2C 描写设备驱动，类似platform，分为描述设备的i2c_client和描述驱动内容的i2c_driver

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
217 struct i2c_client {
218 unsigned short flags; /* 标志 */
219 unsigned short addr; /* 芯片地址， 7 位，存在低 7 位*/
......
222 char name[I2C_NAME_SIZE]; /* 名字 */
223 struct i2c_adapter *adapter; /* 对应的 I2C 适配器 */
224 struct device dev; /* 设备结构体 */
225 int irq; /* 中断 */
226 struct list_head detected;
......
230 };
//一个设备对应一个 i2c_client，每检测到一个 I2C 设备就会给这个 I2C 设备分配一个i2c_client。

161 struct i2c_driver {
162 unsigned int class;
163
164 /* Notifies the driver that a new bus has appeared. You should
165 * avoid using this, it will be removed in a near future.
166 */
167 int (*attach_adapter)(struct i2c_adapter *) __deprecated;
168
169 /* Standard driver model interfaces */
170 int (*probe)(struct i2c_client *, const struct i2c_device_id *);//当 I2C 设备和驱动匹配成功以后 probe 函数就会执行
171 int (*remove)(struct i2c_client *);
172
173 /* driver model interfaces that don't relate to enumeration */
174 void (*shutdown)(struct i2c_client *);
175
176 /* Alert callback, for example for the SMBus alert protocol.
177 * The format and meaning of the data value depends on the
178 * protocol.For the SMBus alert protocol, there is a single bit
179 * of data passed as the alert response's low bit ("event
180 flag"). */
181 void (*alert)(struct i2c_client *, unsigned int data);
182
183 /* a ioctl like command that can be used to perform specific
184 * functions with the device.
185 */
186 int (*command)(struct i2c_client *client, unsigned int cmd,void *arg);
187
188 struct device_driver driver;//使用设备树需要设置 device_driver 的of_match_table 成员变量
189 const struct i2c_device_id *id_table;//id_table 是传统的、未使用设备树的设备匹配 ID 表
190
191 /* Device detection callback for automatic device creation */
192 int (*detect)(struct i2c_client *, struct i2c_board_info *);
193 const unsigned short *address_list;
194 struct list_head clients;
195 };

i2c_driver 的注册示例代码如下 

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
/* i2c 驱动的 probe 函数 */
static int xxx_probe(struct i2c_client *client,const struct i2c_device_id *id)
{
/* 函数具体程序 */
	return 0;
}

/* i2c 驱动的 remove 函数 */
static int xxx_remove(struct i2c_client *client)
{
	/* 函数具体程序 */
	return 0;
}

/* 传统匹配方式 ID 列表 */
static const struct i2c_device_id xxx_id[] = {
	{"xxx", 0},
	{}//空
};

/* 设备树匹配列表 */
static const struct of_device_id xxx_of_match[] = {
	{ .compatible = "xxx" },
	{ /* Sentinel */ }
};

/* i2c 驱动结构体 */
static struct i2c_driver xxx_driver = {
	.probe = xxx_probe,
	.remove = xxx_remove,
	.driver = {
		.owner = THIS_MODULE,
		.name = "xxx",
		.of_match_table = xxx_of_match,
		},
 	.id_table = xxx_id,
};

 /* 驱动入口函数 */
static int __init xxx_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&xxx_driver);
	return ret;
}

 /* 驱动出口函数 */
static void __exit xxx_exit(void)
{
	i2c_del_driver(&xxx_driver);
}

module_init(xxx_init);
module_exit(xxx_exit);

I2C 设备和驱动匹配过程

I2C 设备和驱动的匹配过程是由 I2C 核心来完成的， drivers/i2c/i2c-core.c 就是 I2C 的核心
部分， I2C 核心提供了一些与具体硬件无关的 API 函数，比如前面讲过的：

i2c_adapter 注册/注销函数

1
2
3
int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
void i2c_del_adapter(struct i2c_adapter * adap)

i2c_driver 注册/注销函数

1
2
3
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
int i2c_add_driver (struct i2c_driver *driver)
void i2c_del_driver(struct i2c_driver *driver)

设备和驱动的匹配过程也是由 I2C 总线完成的，

I2C 总线的数据结构为 i2c_bus_type，定义在 drivers/i2c/i2c-core.c 文件， 

1
2
3
4
5
6
7
 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_device_match 这个函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
457 static int i2c_device_match(struct device *dev, struct device_driver *drv)
458 {
459 struct i2c_client *client = i2c_verify_client(dev);
460 struct i2c_driver *driver;
461
462 if (!client)
463 return 0;
464
465 /* Attempt an OF style match */
466 if (of_driver_match_device(dev, drv))
467 return 1;
468
469 /* Then ACPI style match */
470 if (acpi_driver_match_device(dev, drv))
471 return 1;
472
473 driver = to_i2c_driver(drv);
474 /* match on an id table if there is one */
475 if (driver->id_table)
476 return i2c_match_id(driver->id_table, client) != NULL;
477
478 return 0;
479 }

分析驱动流程

当设备和驱动匹配成功以后 i2c_imx_probe 函数就会执行 ，由此分析i2c_imx_probe的执行函数。

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
971 static int i2c_imx_probe(struct platform_device *pdev)
972 {
973 	const struct of_device_id *of_id =
974 	of_match_device(i2c_imx_dt_ids, &pdev->dev);
975 	struct imx_i2c_struct *i2c_imx;
976 	struct resource *res;
977 	struct imxi2c_platform_data *pdata = dev_get_platdata(&pdev->dev);//获取成员变量
978 	void __iomem *base;
979 	int irq, ret;
980 	dma_addr_t phy_addr;
981
982 	dev_dbg(&pdev->dev, "<%s>\n", __func__);
983
984 	irq = platform_get_irq(pdev, 0);		//获取中断号
......
990 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);//从设备树获取寄存器物理基地址
991 	base = devm_ioremap_resource(&pdev->dev, res);
992 	if (IS_ERR(base))
993 		return PTR_ERR(base);
994
995 	phy_addr = (dma_addr_t)res->start;
996 	i2c_imx = devm_kzalloc(&pdev->dev, sizeof(*i2c_imx),GFP_KERNEL);//申请内存
997 	if (!i2c_imx)
998 		return -ENOMEM;
999
1000 	if (of_id)
1001 		i2c_imx->hwdata = of_id->data;
1002 	else
1003 		i2c_imx->hwdata = (struct imx_i2c_hwdata *)platform_get_device_id(pdev)->driver_data;
1004 
1005
1006 /* Setup i2c_imx driver structure */
1007 	strlcpy(i2c_imx->adapter.name, pdev->name,sizeof(i2c_imx->adapter.name));
1008 	i2c_imx->adapter.owner = THIS_MODULE;	//初始化i2c_adapter
1009 	i2c_imx->adapter.algo = &i2c_imx_algo;
1010 	i2c_imx->adapter.dev.parent = &pdev->dev;
1011 	i2c_imx->adapter.nr = pdev->id;
1012 	i2c_imx->adapter.dev.of_node = pdev->dev.of_node;
1013 	i2c_imx->base = base;
1014
1015 /* Get I2C clock */
1016 	i2c_imx->clk = devm_clk_get(&pdev->dev, NULL);
......
1022 	ret = clk_prepare_enable(i2c_imx->clk);
......
1027 /* Request IRQ */
1028 	ret = devm_request_irq(&pdev->dev, irq, i2c_imx_isr,IRQF_NO_SUSPEND, pdev->name, i2c_imx);//注册控制器中断
1029 	
......
1035 /* Init queue */
1036 	init_waitqueue_head(&i2c_imx->queue);
1037
1038 /* Set up adapter data */
1039 	i2c_set_adapdata(&i2c_imx->adapter, i2c_imx);
1040
1041 /* Set up clock divider */
1042 	i2c_imx->bitrate = IMX_I2C_BIT_RATE;//设置时钟频率
1043 	ret = of_property_read_u32(pdev->dev.of_node,"clock-frequency", &i2c_imx->bitrate);
1044 
1045 	if (ret < 0 && pdata && pdata->bitrate)
1046 		i2c_imx->bitrate = pdata->bitrate;
1047
1048 /* Set up chip registers to defaults */
1049 	imx_i2c_write_reg(i2c_imx->hwdata->i2cr_ien_opcode ^ I2CR_IEN,i2c_imx, IMX_I2C_I2CR);
1050 	
1051 	imx_i2c_write_reg(i2c_imx->hwdata->i2sr_clr_opcode, IMX_I2C_I2SR);
1052	/*设置I2CR和SR寄存器*/
1053 /* Add I2C adapter */
1054 	ret = i2c_add_numbered_adapter(&i2c_imx->adapter);//内核注册i2c_adapter
1055 	if (ret < 0) {
1056 		dev_err(&pdev->dev, "registration failed\n");
1057 		goto clk_disable;
1058 	}
1059
1060 /* Set up platform driver data */
1061 	platform_set_drvdata(pdev, i2c_imx);
1062 	clk_disable_unprepare(i2c_imx->clk);
......
1070 /* Init DMA config if supported */
1071 	i2c_imx_dma_request(i2c_imx, phy_addr);//设置了DMA
1072
1073 	return 0; /* Return OK */
1074
1075 	clk_disable:
1076 	clk_disable_unprepare(i2c_imx->clk);
1077 	return ret;
1078 }

设备添加驱动

以ap3216c设备为例子

在节点i2c1中添加设备的节点

1
2
3
4
5
6
7
8
9
10
11
12
&i2c1 {
	clock-frequency = <100000>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;
	status = "okay";

	ap3216c@1e{			//ap3216芯片设备添加的节点
		compatible = "alientek,ap3216c";
		reg = <0x1e>;
	};

};

编写ap3216c的设备驱动

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/gpio.h>
#include <linux/errno.h>
#include <linux/io.h>
#include <linux/fs.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/cdev.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/i2c.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include "ap3216creg.h"

#define AP3216C_CNT 1
#define AP3216C_NAME    "ap3216c"

struct ap3216c_dev{
    dev_t devid;
    int major;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node *node;
    void *private_data;
    unsigned short ir,als,ps;

};
static struct ap3216c_dev ap3216cdev;
static int ap3216c_read_regs(struct ap3216c_dev *dev, u8 reg, void *val, int len)
{
    int ret;
    struct i2c_msg msg[2];
    struct i2c_client *client = (struct i2c_client *)dev->private_data;
    msg[0].addr = client->addr; //ap3216c地址
    msg[0].flags = 0;   //标记为发送数据
    msg[0].buf = &reg; //读取首地址
    msg[0].len = 1;     //数据长度

    msg[1].addr = client->addr;			/* ap3216c地址 */
    msg[1].flags = I2C_M_RD;		/* 标记为读取数据*/
    msg[1].buf = val;			/* 读取数据缓冲区 */
    msg[1].len = len;			/* 要读取的数据长度*/    

    ret = i2c_transfer(client->adapter, msg, 2);
    if(ret == 2)
    {
        ret = 0;
    }else {
        printk("i2c rd failed=%d reg = %06x led = %d\n", ret, reg, len);
        ret = -EREMOTEIO;
    }
    return ret;

}
static s32 ap3216c_write_regs(struct ap3216c_dev *dev, u8 reg, u8 *buf, u8 len)
{
    u8 b[256];
    struct i2c_msg msg;
    struct i2c_client *client = (struct i2c_client *) dev-> private_data;
    b[0] = reg ;    //寄存器首地址
    memcpy(&b[1], buf, len);    //写入的数据拷贝进入数组b里
    msg.addr = client-> addr;   //ap3216c地址
    msg.flags = 0;  //  标记为写数据   
    msg.len = len + 1; //数据长度
    msg.buf = b;//写入数据缓冲区

    return i2c_transfer(client->adapter, &msg, 1);
}
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{
    u8 data = 0;

    ap3216c_read_regs(dev, reg, &data, 1);
    return data;

}
static void ap3216c_write_reg(struct ap3216c_dev *dev, u8 reg, u8 data)
{
    u8 buf = 0;
    buf = data;
    ap3216c_write_regs(dev, reg, &buf,1);

}
void ap3216c_readdata(struct ap3216c_dev *dev)
{
    unsigned char i =0;
    unsigned char buf[6];

    /* 循环读取所有传感器数据 */
     for(i = 0; i < 6; i++)
    {
        buf[i] = ap3216c_read_reg(dev, AP3216C_IRDATALOW + i);
    }

    if(buf[0] & 0X80) /* IR_OF 位为 1,则数据无效 */
        dev->ir = 0;
    else /* 读取 IR 传感器的数据 */
        dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03);

    dev->als = ((unsigned short)buf[3] << 8) | buf[2];/* ALS 数据 */

    if(buf[4] & 0x40) /* IR_OF 位为 1,则数据无效 */
        dev->ps = 0;
    else /* 读取 PS 传感器的数据 */
        dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F);
    
}
static int ap3216c_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &ap3216cdev;
    ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x04);
    mdelay(50);
    ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x03);
    return 0;
}
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t cnt,loff_t *off)
{
    short data[3];
    long err = 0;

    struct ap3216c_dev *dev = (struct ap3216c_dev *)filp->private_data;
    ap3216c_readdata(dev);

    data[0] = dev->ir;
    data[1] = dev->als;
    data[2] = dev->ps;
    err = copy_to_user(buf, data,sizeof(data));
    return 0;
}
static int ap3216c_release(struct inode *inode,struct file *filp)
{
    return 0;
}

static const struct file_operations ap3216c_ops = {
    .owner = THIS_MODULE,
    .read = ap3216c_read,
    .open = ap3216c_open,
    .release = ap3216c_release,

};
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	/* 1、构建设备号 */
	if (ap3216cdev.major) {
		ap3216cdev.devid = MKDEV(ap3216cdev.major, 0);
		register_chrdev_region(ap3216cdev.devid, AP3216C_CNT, AP3216C_NAME);
	} else {
		alloc_chrdev_region(&ap3216cdev.devid, 0, AP3216C_CNT, AP3216C_NAME);
		ap3216cdev.major = MAJOR(ap3216cdev.devid);
	}

	/* 2、注册设备 */
	cdev_init(&ap3216cdev.cdev, &ap3216c_ops);
	cdev_add(&ap3216cdev.cdev, ap3216cdev.devid, AP3216C_CNT);

	/* 3、创建类 */
	ap3216cdev.class = class_create(THIS_MODULE, AP3216C_NAME);
	if (IS_ERR(ap3216cdev.class)) {
		return PTR_ERR(ap3216cdev.class);
	}

	/* 4、创建设备 */
	ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL, AP3216C_NAME);
	if (IS_ERR(ap3216cdev.device)) {
		return PTR_ERR(ap3216cdev.device);
	}

	ap3216cdev.private_data = client;

	return 0;
}

/*
 * @description     : i2c驱动的remove函数，移除i2c驱动的时候此函数会执行
 * @param - client 	: i2c设备
 * @return          : 0，成功;其他负值,失败
 */
static int ap3216c_remove(struct i2c_client *client)
{
	/* 删除设备 */
	cdev_del(&ap3216cdev.cdev);
	unregister_chrdev_region(ap3216cdev.devid, AP3216C_CNT);

	/* 注销掉类和设备 */
	device_destroy(ap3216cdev.class, ap3216cdev.devid);
	class_destroy(ap3216cdev.class);
	return 0;
}

/* 传统匹配方式ID列表 */
static const struct i2c_device_id ap3216c_id[] = {
	{"alientek,ap3216c", 0},  
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id ap3216c_of_match[] = {
	{ .compatible = "alientek,ap3216c" },
	{ /* Sentinel */ }
};

/* i2c驱动结构体 */	
static struct i2c_driver ap3216c_driver = {
	.probe = ap3216c_probe,
	.remove = ap3216c_remove,
	.driver = {
			.owner = THIS_MODULE,
		   	.name = "ap3216c",
		   	.of_match_table = ap3216c_of_match, 
		   },
	.id_table = ap3216c_id,
};
		   
/*
 * @description	: 驱动入口函数
 * @param 		: 无
 * @return 		: 无
 */
static int __init ap3216c_init(void)
{
	int ret = 0;

	ret = i2c_add_driver(&ap3216c_driver);
	return ret;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit ap3216c_exit(void)
{
	i2c_del_driver(&ap3216c_driver);
}

/* module_i2c_driver(ap3216c_driver) */

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");