MX6ULL学习笔记（十一）I2C设备驱动
前言
I2C 是很常用的一个串行通信接口，用于连接各种外设、传感器等器件，本章我们来学习一下如何在 Linux 下开发 I2C 接口器件驱动。本章以 I.MX6U-ALPHA 开发板上的 AP3216C 这个三合一环境光传感器为例，通过 AP3216C 讲解 一下如何编写 Linux 下的 I2C 设备驱动程序。
目录
前言
一、Linux I2C 驱动框架简介。
二、Linux I2C 驱动框架分析。
I2C 总线驱动
2. i2c_client -- 设备信息
3. i2c_driver -- 驱动内容
三、I2c相关API
1、I2C驱动注册函数。
2、I2C 设备驱动注销API。
3. I2C 设备寄存器读写函数
4.i2c_driver 的注册示例代码
四、MX6U 的 I2C 适配器驱动分析
五、设备驱动编写流程
1.I2C 设备信息描述
2.驱动内容的编写
六、具体设备树的修改
七、驱动代码的编写
八、测试代码的编写
九、使用测试
十、总结
一、Linux I2C 驱动框架简介
前面我们说过，linux内核驱动遵循分离与分层的思想,也就是Linux中的总线-驱动-设备模型，也就是常说的驱动分离，如图所示，那么i2c也不例外。
当向系统注册一个驱动时，总线会在右侧的设备中查找，看看有没有与之匹配的设备，有的话就将两者联系起来；当向系统中注册一个设备时，总线会在左侧的驱动中查找，看有没有与之匹配的驱动，有的话也联系起来。
下面三层是通过总线-设备-驱动模型融合到一起的I2C驱动。
这里可以看到，Linux 内核将 I2C 驱动分为两部分：
①、I2C 总线驱动，I2C 总线驱动就是 SOC 的 I2C 控制器驱动，也叫做I2C适配器驱动。
②、I2C 设备驱动，I2C 设备驱动就是针对具体的 I2C 设备而编写的驱动。
二、Linux I2C 驱动框架分析。
I2C 总线驱动
针对I2C总线，也有一个I2C总线的结构体即i2c_bus_type结构，结构体定义在 i2c-core.c 文件中，
此结构里面有一个匹配函数，i2c_device_match函数。
>>如果不使用设备树的话，i2c_device_match函数通过id_table(i2c_driver结构的成员，它表示能支持哪些设备)来比较dev与drv是否匹配，
具体方法是用id_table的name去比较，name分别是i2c_client结构和i2c_driver结构的成员。如果名字相同，就表示此驱动i2c_driver能支持这个设备i2c_client。id_table 是传统的、未使用设备树的设备匹配 ID 表。
>>如果使用设备树的话，需要设置 device_driver 的 of_match_table 成员变量，也就是驱动的兼容(compatible)属性。这里的匹配方法和id_table类似。
2. i2c_client -- 设备信息
已经知道，i2c_client 结构体定义在 include/linux/i2c.h 文件中，内容如下：
一个设备对应一个 i2c_client，每检测到一个 I2C 设备就会给这个 I2C 设备分配一个
i2c_client。这个结构体是注册i2c_client时加入的，不但要加入这些结构体，还会在总线的驱动链表中一个一个地比较drv即i2c_driver来判断是否有匹配的，如果匹配将调用drv里面的probe函数，匹配函数由总线提供；
一般这部分是不需要我们去初始化的，因为我们引入了设备树的时候，关于i2
C设备的信息就在设备树描述好了，在内核启动的时候会读取设备树，这时i2c_client就初始化好了，当我们去注册i2c_driver,就可以得到这个i2c_client结构体的信息了。
3. i2c_driver -- 驱动内容
i2c_driver 类似 platform_driver，是我们编写 I2C 设备驱动重点要处理的内容，i2c_driver 结构体定义在 include/linux/i2c.h 文件中，内容如下：
这个结构体是注册i2c_driver时加入的，不但要加入这些结构体，还会在总线的设备链表中一个一个地比较dev即比较i2c_client来判断是否有匹配的，如果匹配将调用drv里面的probe函数。
- 第170行，当 I2C设备和驱动匹配成功以后 probe函数就会执行，和platform驱动一样。
- 第188行，device_driver 驱动结构体，如果使用设备树的话，需要设置 device_driver 的 of_match_table 成员变量，也就是驱动的兼容(compatible)属性。
- 第 189 行，id_table 是传统的、未使用设备树的设备匹配 ID 表。
对于我们 I2C 设备驱动编写人来说，重点工作就是构建 i2c_driver，构建完成以后需要向 Linux 内核注册这个 i2c_driver。当设备和驱动匹配以后 i2c_driver 里面的 probe 函数就会执行，probe 函数里面所做的就 是字符设备驱动那一套了。
一般需要在 probe 函数里面初始化 I2C 设备，通过读写操作，对I2C 设备寄存器进行配置，就像在stm32的时候初始化oled屏幕的时候，进行的初始化一样。
三、I2c相关API
1、I2C驱动注册函数。
①i2c_driver 的注册函数为 int i2c_register_driver，此函数原型如下：
int i2c_register_driver(struct module *owner, struct i2c_driver *driver);函数参数和返回值含义如下：
- owner：一般为 THIS_MODULE。
- driver：要注册的 i2c_driver。
- 返回值：0，成功；负值，失败。
②封装过的i2c_driver注册函数
i2c_add_driver 就是对 i2c_register_driver 做了一个简单的封装，只有一个参数，就是要注册 的 i2c_driver。
#define i2c_add_driver(driver) \
i2c_register_driver(THIS_MODULE, driver)参数：
- driver：要注册的 i2c_driver。
- 返回值：0，成功；负值，失败。
2、I2C 设备驱动注销API。
①注销 I2C 设备驱动
将前面注册的 i2c_driver 从 Linux 内核中注销掉，需要用到 i2c_del_driver 函数，此函数原型如下：
void i2c_del_driver(struct i2c_driver *driver)函数参数和返回值含义如下：
driver：要注销的 i2c_driver。
3. I2C 设备寄存器读写函数
涉及到I2C 设备就必须要知道I2C的两个操作，读和写，必须能够对 I2C 设备寄存器进行读写操作，这样我们才能使用这个I2C设备，这里就要用到 i2c_transfer 函数了。
函数原型如下：
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)函数参数和返回值含义如下：
- adap：所使用的 I2C 适配器，i2c_client 会保存其对应的 i2c_adapter。
- msgs：I2C 要发送的一个或多个消息。
- num：消息数量，也就是 msgs 的数量。
- 返回值：负值，失败，其他非负值，发送的 msgs 数量。
4.i2c_driver 的注册示例代码
示例代码 61.1.2.4 i2c_driver 注册流程
/* 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);四、MX6U 的 I2C 适配器驱动分析
上面我们讲解了 Linux 下的 I2C 驱动框架，重点分为 I2C 适配器驱动和 I2C 设备驱动， 其中 I2C 适配器驱动就是 SOC 的 I2C 控制器驱动。I2C 设备驱动是需要用户根据不同的 I2C 设 备去编写，而 I2C 适配器驱动一般都是 SOC 厂商去编写的，比如NXP 就编写好了 I.MX6U 的 I2C 适配器驱动。在 imx6ull.dtsi 文件中找到 I.MX6U 的 I2C1 控制器节点，节点内容如下所示：
重点关注 i2c1 节点的 compatible 属性值，因为通过 compatible 属性值可以在 Linux 源码里 面找到对应的驱动文件。这里i2c1节点的compatible属性值有两个：“fsl,imx6ul-i2c”和“fsl,imx21- i2c”，在 Linux 源码中搜索这两个字符串即可找到对应的驱动文件。I.MX6U 的 I2C 适配器驱动 驱动文件为 drivers/i2c/busses/i2c-imx.c，在此文件中有如下内容：
I2C 适配器驱动 SOC 厂商已经替我们编写好了，所以这部分我们了解就好。
五、设备驱动编写流程
接下来来学习一下 I2C 设备驱动的详细编写流程，这部分才是我们要学习的重点。
按照分层的思想，在总线-驱动-设备模型中，总线部分，也就是I2C 适配器驱动这部分，SOC 厂商已经替我们编写好了，我们只需要完善设备信息描述和驱动内容的编写就好了，
1.I2C 设备信息描述
前面说过，在引入设备树之后，我们的设备信息描述，就统一使用在设备树下创建相应的节点就行了。比如 NXP 官方的 EVK 开发 板在 I2C1 上接了 mag3110 这个磁力计芯片，因此必须在 i2c1 节点下创建 mag3110 子节点，然 后在这个子节点内描述 mag3110 这个芯片的相关信息。打开 imx6ull-14x14-evk.dts 这个设备树 文件，然后找到如下内容：
&i2c1 {
clock-frequency = <100000>;
pinctrl-names = "default";
pinctrl-0 = <&pinctrl_i2c1>; status = "okay";
mag3110@0e {
compatible = "fsl,mag3110";
reg = <0x0e>;
position = <2>;
};
......
};第 7~11 行，向 i2c1 添加 mag3110 子节点，
第 7 行“mag3110@0e”是子节点名字，“@” 后面的“0e”就是 mag3110 的 I2C 器件地址。第 8 行设置 compatible 属性值为“fsl,mag3110”。
第 9 行的 reg 属性也是设置 mag3110 的器件地址的，因此值为 0x0e。I2C 设备节点的创建重点 是 compatible 属性和 reg 属性的设置，一个用于匹配驱动，一个用于设置器件地址。
2.驱动内容的编写
I2C 设备驱动首先要做的就是初始化 i2c_driver 并向 Linux 内核 注册。当设备和驱动匹配以后 i2c_driver 里面的 probe 函数就会执行，probe 函数里面所做的就是字符设备驱动那一套了。
一般需要在 probe 函数里面初始化 I2C 设备，要初始化 I2C 设备就使用函数，对I2C 设备寄存器进行读写操作。
接下来就是简单讲解一下驱动内容的编写
①首先还是得先定义一个驱动结构体，也就是上面说过的i2c_driver.
②建立完结构体就先来编写设备树匹配列表和传统匹配方式ID列表
③然后就是完善编写probe函数：函数原型：
static int ap3216c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)probe 函数里面所做的就 是字符设备驱动那一套了。创建设备号, 初始化cdev, 添加一个cdev, 创建设备类, 创建设备.
④、然后就是完善编写remove函数,函数原型：
static int ap3216c_remove(struct i2c_client *i2c)里面要做的也还是和字符设备那一套一样，删除设备，注销掉类和设备。
六、具体设备树的修改
1、IO 修改或添加
根据原理图，我们可以得知ap3216c的i2c两个引脚接在了UART4_TXD 和 UART4_RXD 这两个 IO，因此只需要设置 UART4_TXD 和 UART4_RXD 这两个 IO，NXP 其实已经将 他这两个 IO 设置好了，打开 imx6ull-alientek-emmc.dts，然后找到如下内容：
pinctrl_i2c1 就是 I2C1 的 IO 节点，这里将 UART4_TXD 和 UART4_RXD 这两个 IO 分别 复用为 I2C1_SCL 和 I2C1_SDA，电气属性都设置为 0x4001b8b0。
2、在 i2c1 节点追加 ap3216c 子节点
AP3216C 是连接到 I2C1 上的，因此需要在 i2c1 节点下添加 ap3216c 的设备子节点，在
imx6ull-alientek-emmc.dts 文件中找到 i2c1 节点，此节点添加后内容如下：
本来 i2c1 节点里面有mag3110 和 fxls8471 这两个 I2C 子节点，但是那是NXP官方的开发板自的，我们不需要就删除了，然后添加我们自己的节点就好了。
七、驱动代码的编写
①定义一个I2c驱动结构体
/*-------------------------------------------------------------------------*/
static struct i2c_driver ap3216c_driver = {
.driver = {
.name = "ap3216c",
.owner = THIS_MODULE,
.of_match_table = ap3216c_of_match,
},
.probe = ap3216c_probe,
.remove = ap3216c_remove,
.id_table =ap3216c_id ,
};
②建立完结构体就先来编写设备树匹配列表和传统匹配方式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 */ }
};③然后就是完善编写probe函数。
static int ap3216c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
/*1 创建设备号*/
if(ap3216cdev.major){
ap3216cdev.devid = MKDEV(ap3216cdev.major,0);
register_chrdev_region(ap3216cdev.devid,DEVICE_CNT,DEVICE_NAME);
}
else{
alloc_chrdev_region(&ap3216cdev.devid,0,DEVICE_CNT,DEVICE_NAME);
ap3216cdev.major = MAJOR(ap3216cdev.devid);
ap3216cdev.minor = MINOR(ap3216cdev.devid);
}
/* 2 初始化cdev*/
ap3216cdev.cdev.owner= THIS_MODULE;
cdev_init(&ap3216cdev.cdev,&ap3216cdev_fops);
/* 3、添加一个cdev */
cdev_add(&ap3216cdev.cdev,ap3216cdev.devid,DEVICE_CNT);
/*4 创建设备类*/
ap3216cdev.class = class_create(THIS_MODULE,DEVICE_NAME);
if(IS_ERR(ap3216cdev.class))
{
printk("ap3216cdev fail!\r\n");
return PTR_ERR(ap3216cdev.class);
}
/*5 创建设备*/
ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL, DEVICE_NAME);
if(IS_ERR(ap3216cdev.device))
{
printk("ap3216cdev fail!\r\n");
return PTR_ERR(ap3216cdev.device);
}
ap3216cdev.private_data = i2c;
printk("ap3216cdev init success!\r\n");
return 0;
}④然后就是完善编写remove函数：
static int ap3216c_remove(struct i2c_client *i2c)
{
printk("ap3216c_dev driver and device was matched!\r\n");
cdev_del(&ap3216cdev.cdev);
unregister_chrdev_region(ap3216cdev.devid,DEVICE_CNT);
device_destroy(ap3216cdev.class,ap3216cdev.devid);
class_destroy(ap3216cdev.class);
return 0;
}⑥编写自己的寄存器读写函数，方便使用。
虽然我们上面知道了，通过i2c_transfer函数可以实现对于I2C设备寄存器的读写，但是如果每次我们都一条一条的去进行参数的赋值，一条一条的去输入，会使得带阿米重复性太高，这里我们自己封装一下：
/*
* @description : 从ap3216c读取多个寄存器数据
* @param - dev: ap3216c设备
* @param - reg: 要读取的寄存器首地址
* @param - val: 读取到的数据
* @param - len: 要读取的数据长度
* @return : 操作结果
*/
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]为发送要读取的首地址 */
msg[0].addr = client->addr; /* ap3216c地址 */
msg[0].flags = 0; /* 标记为发送数据 */
msg[0].buf = ® /* 读取的首地址 */
msg[0].len = 1; /* reg长度*/
/* msg[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 len=%d\n",ret, reg, len);
ret = -EREMOTEIO;
}
return ret;
}
/*
* @description : 向ap3216c多个寄存器写入数据
* @param - dev: ap3216c设备
* @param - reg: 要写入的寄存器首地址
* @param - val: 要写入的数据缓冲区
* @param - len: 要写入的数据长度
* @return : 操作结果
*/
static int 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.buf = b; /* 要写入的数据缓冲区 */
msg.len = len + 1; /* 要写入的数据长度 */
return i2c_transfer(client->adapter, &msg, 1);
}
/*
* @description : 读取ap3216c指定寄存器值，读取一个寄存器
* @param - dev: ap3216c设备
* @param - reg: 要读取的寄存器
* @return : 读取到的寄存器值
*/
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{
u8 data = 0;
ap3216c_read_regs(dev, reg, &data, 1);
return data;
}
/*
* @description : 向ap3216c指定寄存器写入指定的值，写一个寄存器
* @param - dev: ap3216c设备
* @param - reg: 要写的寄存器
* @param - data: 要写入的值
* @return : 无
*/
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);
}
static void ap3216c_readdata(struct ap3216c_dev *dev)
{
int 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{
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);
}
}
⑦编写设备操作函数，open函数
static int ap3216cdev_open(struct inode *inode , struct file *file)
{
unsigned char value = 0;
file->private_data = &ap3216cdev;
/* 初始化AP3216C */
ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x04); /* 复位AP3216C */
mdelay(50); /* AP3216C复位最少10ms */
ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X03); /* 开启ALS、PS+IR */
value = ap3216c_read_reg(&ap3216cdev,AP3216C_SYSTEMCONG);
printk("AP3216C_SYSTEMCONG = %#x\r\n",value);
return 0;
}⑦编写设备操作函数，read函数
static ssize_t ap3216cdev_read(struct file *file, char __user *buf, size_t size, loff_t *ptr)
{
long err=0;
short data[3];
struct ap3216c_dev *dev = (struct ap3216c_dev *)file->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;
}⑧完整代码如下：
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ap3216creg.h"
#include
/************************函数定义-begin***********************************************/
static int ap3216cdev_release(struct inode *inode, struct file *file);
static ssize_t ap3216cdev_read(struct file *file, char __user *buf, size_t size, loff_t *ptr);
static ssize_t ap3216cdev_write(struct file *file, const char __user *buf, size_t size, loff_t *ptr);
static int ap3216cdev_open(struct inode *inode , struct file *file);
static int ap3216c_probe(struct i2c_client *i2c,const struct i2c_device_id *id);
static int ap3216c_remove(struct i2c_client *i2c);
/************************函数定义-end********************************************/
/************************宏定义-begin***********************************************/
#define DEVICE_NAME "ap3216c"
#define DEVICE_CNT 1
/************************宏定义-end********************************************/
/************************结构体定义-begin***********************************************/
/* ap3216c设备信息结构体 */
struct ap3216c_dev
{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
int major; /* 主设备号 */
int minor; /* 次设备号 */
struct device_node *nd; /* 设备节点 */
void *private_data; /* 私有数据 */
unsigned short ir, als, ps; /* 三个光传感器数据 */
};
struct ap3216c_dev ap3216cdev; /* led设备 */
/* 设备操作函数结构体 */
static const struct file_operations ap3216cdev_fops = {
.owner = THIS_MODULE,
.open = ap3216cdev_open,
.read = ap3216cdev_read,
.write = ap3216cdev_write,
.release = ap3216cdev_release
};
/*
* @description : 从ap3216c读取多个寄存器数据
* @param - dev: ap3216c设备
* @param - reg: 要读取的寄存器首地址
* @param - val: 读取到的数据
* @param - len: 要读取的数据长度
* @return : 操作结果
*/
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]为发送要读取的首地址 */
msg[0].addr = client->addr; /* ap3216c地址 */
msg[0].flags = 0; /* 标记为发送数据 */
msg[0].buf = ® /* 读取的首地址 */
msg[0].len = 1; /* reg长度*/
/* msg[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 len=%d\n",ret, reg, len);
ret = -EREMOTEIO;
}
return ret;
}
/*
* @description : 向ap3216c多个寄存器写入数据
* @param - dev: ap3216c设备
* @param - reg: 要写入的寄存器首地址
* @param - val: 要写入的数据缓冲区
* @param - len: 要写入的数据长度
* @return : 操作结果
*/
static int 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.buf = b; /* 要写入的数据缓冲区 */
msg.len = len + 1; /* 要写入的数据长度 */
return i2c_transfer(client->adapter, &msg, 1);
}
/*
* @description : 读取ap3216c指定寄存器值，读取一个寄存器
* @param - dev: ap3216c设备
* @param - reg: 要读取的寄存器
* @return : 读取到的寄存器值
*/
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{
u8 data = 0;
ap3216c_read_regs(dev, reg, &data, 1);
return data;
}
/*
* @description : 向ap3216c指定寄存器写入指定的值，写一个寄存器
* @param - dev: ap3216c设备
* @param - reg: 要写的寄存器
* @param - data: 要写入的值
* @return : 无
*/
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);
}
static void ap3216c_readdata(struct ap3216c_dev *dev)
{
int 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{
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 ap3216cdev_release(struct inode *inode, struct file *file)
{
return 0;
}
static ssize_t ap3216cdev_read(struct file *file, char __user *buf, size_t size, loff_t *ptr)
{
long err=0;
short data[3];
struct ap3216c_dev *dev = (struct ap3216c_dev *)file->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 ssize_t ap3216cdev_write(struct file *file, const char __user *buf, size_t size, loff_t *ptr)
{
return 0;
}
static int ap3216cdev_open(struct inode *inode , struct file *file)
{
unsigned char value = 0;
file->private_data = &ap3216cdev;
/* 初始化AP3216C */
ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0x04); /* 复位AP3216C */
mdelay(50); /* AP3216C复位最少10ms */
ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X03); /* 开启ALS、PS+IR */
value = ap3216c_read_reg(&ap3216cdev,AP3216C_SYSTEMCONG);
printk("AP3216C_SYSTEMCONG = %#x\r\n",value);
return 0;
}
static int ap3216c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
/*1 创建设备号*/
if(ap3216cdev.major){
ap3216cdev.devid = MKDEV(ap3216cdev.major,0);
register_chrdev_region(ap3216cdev.devid,DEVICE_CNT,DEVICE_NAME);
}
else{
alloc_chrdev_region(&ap3216cdev.devid,0,DEVICE_CNT,DEVICE_NAME);
ap3216cdev.major = MAJOR(ap3216cdev.devid);
ap3216cdev.minor = MINOR(ap3216cdev.devid);
}
/* 2 初始化cdev*/
ap3216cdev.cdev.owner= THIS_MODULE;
cdev_init(&ap3216cdev.cdev,&ap3216cdev_fops);
/* 3、添加一个cdev */
cdev_add(&ap3216cdev.cdev,ap3216cdev.devid,DEVICE_CNT);
/*4 创建设备类*/
ap3216cdev.class = class_create(THIS_MODULE,DEVICE_NAME);
if(IS_ERR(ap3216cdev.class))
{
printk("ap3216cdev fail!\r\n");
return PTR_ERR(ap3216cdev.class);
}
/*5 创建设备*/
ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL, DEVICE_NAME);
if(IS_ERR(ap3216cdev.device))
{
printk("ap3216cdev fail!\r\n");
return PTR_ERR(ap3216cdev.device);
}
ap3216cdev.private_data = i2c;
printk("ap3216cdev init success!\r\n");
return 0;
}
static int ap3216c_remove(struct i2c_client *i2c)
{
printk("ap3216c_dev driver and device was matched!\r\n");
cdev_del(&ap3216cdev.cdev);
unregister_chrdev_region(ap3216cdev.devid,DEVICE_CNT);
device_destroy(ap3216cdev.class,ap3216cdev.devid);
class_destroy(ap3216cdev.class);
return 0;
}
static const struct i2c_device_id ap3216c_id[]={
{ "alientek,ap3216c", 0 },
{ }
};
static const struct of_device_id ap3216c_of_match[] = {
{ .compatible = "alientek,ap3216c" },
{/* Sentinel */ }
};
/*-------------------------------------------------------------------------*/
static struct i2c_driver ap3216c_driver = {
.driver = {
.name = "ap3216c",
.owner = THIS_MODULE,
.of_match_table = ap3216c_of_match,
},
.probe = ap3216c_probe,
.remove = ap3216c_remove,
.id_table =ap3216c_id ,
};
static int __init ap3216c_init(void)
{
int ret = 0;
ret = i2c_add_driver(&ap3216c_driver);
return ret;
}
static void __exit ap3216c_exit(void)
{
i2c_del_driver(&ap3216c_driver);
}
module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("oudafa");
八、测试代码的编写
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "sys/ioctl.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include
#include
#include
#include
#include
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd;
char *filename;
unsigned short databuf[3];
unsigned short ir, als, ps;
int ret = 0;
if (argc != 2) {
printf("Error Usage!\r\n");
return -1;
}
filename = argv[1];
fd = open(filename, O_RDWR);
if(fd < 0) {
printf("can't open file %s\r\n", filename);
return -1;
}
while (1) {
ret = read(fd, databuf, sizeof(databuf));
if(ret == 0) { /* 数据读取成功 */
ir = databuf[0]; /* ir传感器数据 */
als = databuf[1]; /* als传感器数据 */
ps = databuf[2]; /* ps传感器数据 */
printf("ir = %d, als = %d, ps = %d\r\n", ir, als, ps);
}
usleep(200000); /*100ms */
}
close(fd); /* 关闭文件 */
return 0;
}
九、使用测试
这里就不对讲前面那些模块加载的了，之前讲过挺多次的了、流程也就是使用make命令，然后编译出.ko文件以及APP文件，然后复制到nfs挂载的目录下，使用insmod命令去加载模块。
当驱动模块加载成功以后使用 ap3216cApp 来测试，输入如下命令：
./ap3216cApp /dev/ap3216c测试 APP 会不断的从 AP3216C 中读取数据，然后输出到终端上，如图所示：
十、总结
通过上述分析，可以总结出一个设计驱动程序的方法，这个方法适用于Linux内核的各个版本：
- 1. 如果要设计I2C设备驱动，看 Documentation/i2c目录下的相关内核文档；I2C协议；处理器的I2C接口；掌握bus-dev-drv模型；掌握驱动程序设计相关知识。
- 2. 实现bus-dev-drv模型驱动。比如要先注册i2c_client，而内核文档中instantiating-devices(构造设备)文件就说明了方法。然后根据方法，搜索内核中对应的例子，模仿就可以 设计出需要的驱动；然后要注册i2c_driver，也是模仿其他如何设计即可。总之，Linux是非常庞大的系统，里面有很多例子可以参考的。
- 3. 理清思路，搞清楚框架中哪些工作是需要做的，哪些是不需要做的。