Linux I2C 驱动实验

已于 2023-06-26 22:43:25 修改
阅读量386 收藏 3
点赞数
分类专栏： Linux驱动开发 字符驱动框架 文章标签： linux 驱动开发 嵌入式硬件
于 2023-04-16 11:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51144400/article/details/130180662
版权

        本实验在 Linux 下开发 I2C 接口器件驱动，重点是学习 Linux 下的 I2C 驱动框架，按照指定的框架去编写 I2C 设备驱动。   

一、修改设备树

        在驱动编写之前需要在设备树文件下添加具体的设备到I2C1下，由于驱动的器件ap3216c使用的是I2C1，因此需要在I2C1下加载子节点。

&i2c1 { 
 	clock-frequency = <100000>; 
 	pinctrl-names = "default"; 
 	pinctrl-0 = <&pinctrl_i2c1>; 
 	status = "okay"; 
 
 	ap3216c@1e { 
 		compatible = "alientek,ap3216c"; 
 		reg = <0x1e>; 
 		}; 
 };


//I2C设备在设备树下挂载需要挂载到具体使用到的总线节点下

ap3216c 子节点，@后面的“1e”是 ap3216c 的器件地址；

设置 compatible 值为“alientek,ap3216c”；

reg 属性也是设置 ap3216c 器件地址的，因此 reg 设置为 0x1e。

设备树修改完成以后使用“make dtbs”重新编译一下，然后使用新的设备树启动 Linux 内

核。

/sys/bus/i2c/devices 目录下存放着所有 I2C 设备，如果设备树修改正确的话，会在

/sys/bus/i2c/devices 目录下看到一个名为“0-001e”的子目录；“0-001e”就是 ap3216c 的设备目录，“1e”就是 ap3216c 器件地址。进入0-001e 目录，可以看到“name”文件，name 文件就保存着此设备名字，在这里就是“ap3216c”。

二、AP3216C 驱动编写 

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/errno.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/mach/map.h>

#include <linux/cdev.h>
#include <linux/device.h>

#include <linux/of.h>
#include <linux/of_address.h>

#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
#include <linux/ioctl.h>
#include <linux/input.h>
#include <linux/i2c.h>
#include "ap3216c.h"

#define AP3216C_CNT 1
#define AP3216C_NAME "ap3216c"

#define KEYVALUE 0XFE
#define KEYNOVALUE 0

struct ap3216c_dev{
    int major;
    int minor;
    dev_t devid;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    void *private_data;
};

static struct ap3216c_dev ap3216c;
/*
 * @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)
{
	struct i2c_client *client=(struct i2c_client *)dev->private_data;
    struct i2c_msg msg[2];
    
    //msg[0]表示发送的要读取的寄存器的地址
    msg[0].addr=client->addr;/*从机地址*/
    msg[0].flags=0;/*表示发送*/
    msg[0].buf=&reg;/*要发送的数据，也就是寄存器的地址*/
    msg[0].len=1;/*要发送的数据长度*/

//msg[1]表示读取数据
    msg[1].addr=client->addr;
    msg[1].flags=I2C_M_RD;
    msg[1].buf=val;/*接收到从机发送的数据*/
    msg[1].len=len;/*要读取的寄存器的长度*/

	return i2c_transfer(client->adapter,msg,2);
}

/*
 * @description	: 向ap3216c多个寄存器写入数据
 * @param - dev:  ap3216c设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
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);
    msg.addr=client->addr;
    msg.flags=0;/*表示发送*/
    msg.buf=b;/*要发送的数据，也就是寄存器的地址*/
    msg.len=len+1;/*要发送的数据长度*/
    return i2c_transfer(client->adapter,&msg,1);
}

static u8 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 val)
{
    ap3216c_write_regs(dev, reg, &val, 1);
}

/*
 * @description	: 读取AP3216C的数据，读取原始数据，包括ALS,PS和IR, 注意！
 *				: 如果同时打开ALS,IR+PS的话两次数据读取的时间间隔要大于112.5ms
 * @param - ir	: ir数据
 * @param - ps 	: ps数据
 * @param - ps 	: als数据 
 * @return 		: 无。
 */
void ap3216c_readdata(unsigned short *ir, unsigned short *ps, unsigned short *als)
{
    unsigned char buf[6];
    unsigned char i;

	/* 循环读取所有传感器数据 */
    for(i = 0; i < 6; i++)	
    {
        buf[i] = ap3216c_read_reg(&ap3216c, AP3216C_IRDATALOW + i);	
    }
	
    if(buf[0] & 0X80) 	/* IR_OF位为1,则数据无效 */
		*ir = 0;					
	else 				/* 读取IR传感器的数据   		*/
		*ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
	
	*als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
	
    if(buf[4] & 0x40)	/* IR_OF位为1,则数据无效 			*/
		*ps = 0;    													
	else 				/* 读取PS传感器的数据    */
		*ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 	
}

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int ap3216c_open(struct inode *inode, struct file *filp)
{
	//filp->private_data = &ap3216c; /* 设置私有数据 */
    printk("xiongxiao open\r\n");
    u8 data;
    /*初始化ap3216c*/
    ap3216c_write_reg(&ap3216c, AP3216C_SYSTEMCONG, 0X04);	/* 复位AP3216C 	*/
	mdelay(50);					/* AP33216C复位至少10ms */
	ap3216c_write_reg(&ap3216c, AP3216C_SYSTEMCONG, 0X03);	/* 开启ALS、PS+IR */
	data = ap3216c_read_reg(&ap3216c, AP3216C_SYSTEMCONG);	/* 读取刚刚写进去的0X03 */
    printk("%d\r\n",data);

	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    short data[3];
	long err = 0;

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

    unsigned short ir, ps, als;
    ap3216c_readdata(&ir, &ps, &als);
    data[0] = ir;
	data[1] = als;
	data[2] = ps;
	err = copy_to_user(buf, data, sizeof(data));
    printk("xiongxiao read\r\n");

	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int ap3216c_release(struct inode *inode, struct file *filp)
{
    printk("xiongxiao release\r\n");
	return 0;
}

/* 设备操作函数 */
static struct file_operations ap3216c_fops = {
	.owner = THIS_MODULE,
	.open = ap3216c_open,
	.read = ap3216c_read,
	.release = ap3216c_release,
};

/*传统的匹配表*/
static struct i2c_device_id ap3216c_id[]={
    {"alientek,ap3216c",0},
    {}
};

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

static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{ 
int ret=0;

    /*搭建字符设备驱动框架*/
    /* 注册字符设备驱动 */
	/* 1、创建设备号 */
    ap3216c.major=0;
	if (ap3216c.major) {		/*  定义了设备号 */
		ap3216c.devid = MKDEV(ap3216c.major, 0);
		register_chrdev_region(ap3216c.devid, AP3216C_CNT, AP3216C_NAME);
	} else {						/* 没有定义设备号 */
		alloc_chrdev_region(&ap3216c.devid, 0, AP3216C_CNT, AP3216C_NAME);	/* 申请设备号 */
		ap3216c.major = MAJOR(ap3216c.devid);	/* 获取分配号的主设备号 */
		ap3216c.minor = MINOR(ap3216c.devid);	/* 获取分配号的次设备号 */
	}
	printk("ap3216c major=%d,minor=%d\r\n",ap3216c.major, ap3216c.minor);	
	
	/* 2、初始化cdev */
	ap3216c.cdev.owner = THIS_MODULE;
	cdev_init(&ap3216c.cdev, &ap3216c_fops);
	
	/* 3、添加一个cdev */
	cdev_add(&ap3216c.cdev, ap3216c.devid, AP3216C_CNT);

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

	/* 5、创建设备 */
	ap3216c.device = device_create(ap3216c.class, NULL, ap3216c.devid, NULL, AP3216C_NAME);
	if (IS_ERR(ap3216c.device)) {
		return PTR_ERR(ap3216c.device);
	}
    ap3216c.private_data=client;	/*将此函数的第一个参数 client 传递给 ap3216cdev 的 private_data 成员变量*/
    return 0;
}

static int ap3216c_remove(struct i2c_client *client)
{
    /* 注销字符设备驱动 */
	cdev_del(&ap3216c.cdev);/*  删除cdev */
	unregister_chrdev_region(ap3216c.devid, AP3216C_CNT); /* 注销设备号 */

	device_destroy(ap3216c.class, ap3216c.devid);
	class_destroy(ap3216c.class);
    return 0;
}

struct i2c_driver ap3216c_driver={
    .probe=ap3216c_probe,
    .remove=ap3216c_remove,
    .driver={
        .name="ap3216c",
        .owner=THIS_MODULE,
        .of_match_table=of_match_ptr(ap3216c_of_match),
    },   
    .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("liuchuanqiang");

程序说明：

  1. ap3216c_read_regs从ap3216c器件中读取数据，这是驱动程序中调用的最终函数。该函数通过i2c_transfer函数与I2C主控制器驱动进行相联系。
  2. ap3216c_write_regs向ap3216c器件中写入数据。

     3. ap3216c_read_reg 函数用于读取 AP3216C 的指定寄存器数据，用于一个寄存器的数据读  取；ap3216c_write_reg 函数用于向 AP3216C 的指定寄存器写入数据，用于一个寄存器的数据写操作。

    4. ap3216c_readdata读取 AP3216C 的 PS、ALS 和 IR 等传感器原始数据值。

    5. ap3216c_probe 函数，当 I2C 设备和驱动匹配成功以后此函数就会执行，和platform 驱动框架一样。此函数前面都是标准的字符设备注册代码，最后面会将此函数的第一个参数 client 传递给 ap3216cdev 的 private_data 成员变量。

    6. ap3216c_id 匹配表，i2c_device_id 类型。用于传统的设备和驱动匹配，也就是没有使用设备树的时候。

    7. ap3216c_of_match 匹配表，of_device_id 类型，用于设备树设备和驱动匹 配。这里只写了一个 compatible 属性，值为“alientek,ap3216c”。

        8、i2c_add_driver(&ap3216c_driver);向Linux内核注册ap3216c_driver；

        9、i2c_del_driver(&ap3216c_driver);向Linux内核注销ap3216c_driver。

三、编写测试 APP

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <linux/input.h>

/*
argc:应用程序参数个数
argv[]:具体的参数内容，字符串形式，这个函数中的第一个参数内容./ap3216cAPP；
       第二个参数内容filename;
执行文件格式：
    ./ap3216cAPP /dev/ap3216c
*/

int main(int argc,char *argv[])
{
    int ret=0;
    int fd=0;
    char *filename;
    unsigned short databuf[3];
    unsigned short ir,als,ps;
    filename=argv[1];//一个字符串的声明

    printf("filename=%s\r\n",filename);
    if(argc!=2)
    {
        printf("error\n");
        return -1;
    }
    //打开文件
    fd=open(filename, O_RDWR);
    //判断有没有打开成功
    if(fd<0)
    {
        printf("open failed\r\n");
        return -1;
    }
    //read(fd,&data,sizeof(data));


    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); /*200ms */
    }
    

//关闭文件
        ret=close(fd);
        if(ret<0)
        {
            printf("close failed\r\n");
            return -1;
        }
   
    return 0;
}

        ap3216cApp.c 文件内容很简单，就是在 while 循环中不断的读取 AP3216C 的设备文件，从而得到 ir、als 和 ps 这三个数据值，然后将其输出到终端上。

行者甲
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux下的i2c
hqb_newfarmer的博客
03-21 1062
i2c驱动
Jetson TX2 进行I2C实验
05-24
总结，进行Jetson TX2的I2C实验需要对I2C协议、Linux内核驱动以及相关工具有一定的了解。通过实验，你不仅可以掌握如何在嵌入式平台上使用I2C通信，还能深入了解Jetson TX2的硬件资源和Linux系统操作。不断实践和...
Linux之I2C驱动
风间琉璃的博客
09-28 4541
在 Linux 内核中 I2C 的体系结构分为 3 个部分：①： I2C 核心提供了I2C 总线驱动和设备驱动的注册、 注销方法②： I2C 总线驱动是对I2C 硬件体系结构中适配器端的实现， 适配器可由CPU 控制， 甚至可以直接集成在 CPU 内部。I2C 总线驱动就是 SOC 的，也叫做。③： I2C 设备驱动是对，设备一般挂接在受 CPU 控制的 I2C 适配器上， 通过 I2C 适配器与 CPU 交换数据。
Linux--IIC驱动编程实验
最新发布
qq_47258284的博客
05-06 1029
对于I2C主机驱动，一旦编写完成就不需要再做修改，其他的I2C设备直接调用主机驱动提供的 API函数完成读写操作即可。这个正好符合Linux的驱动分离与分层的思想，因此Linux内核也将 I2C驱动分为两部分：①、I2C总线驱动，I2C总线驱动就是SOC的I2C控制器驱动，也叫做I2C适配器驱动。②、I2C设备驱动，I2C设备驱动就是针对具体的I2C设备而编写的驱动。
Linux设备驱动之I2C驱动
Priscilla_cola的博客
09-03 2059
该结构体也是Linux系统定义的，厂商写好I2C的通信函数以后，把这个结构体中的函数指针指向自己写好的函数。SoC厂商一般会根据自己的I2C控制器的特点，把Linux提供的这个i2c_adapter结构体进行二次封装，形成自己SoC特有的I2C控制器的结构体描述，而不是直接使用i2c_adapter来描述自己的I2C控制器。，这个核心层提供了我们上述说的i2c主机驱动的注册函数，注销函数，i2c设备驱动的注册与注销函数，以及I2C通信方法（不同的SoC厂商会实现自己的I2C通信方法，然后覆盖），还有。
Linux内核的I2C驱动框架详解
cumtchw
07-31 4691
目录1 I2C驱动整体框架图 2 I2C控制器2.1 I2C控制器设备--I2C控制器在内核中也被看做一个设备2.2 i2c控制器驱动程序2.3 platform_driver结构体中的probe函数做了什么2.3.1 疑问： i2cdev_notifier_call函数哪里来的2.3.2 疑问：为什么有两个probe2.3.3 疑问：of_i2c_register_devices(adap);和bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_n
Linux驱动之i2c驱动示例
uunubt的专栏
10-11 3538
驱动层是设备的IO的驱动程序。一条是时钟线，一条是数据线，两条数据线都要接4.7K的上拉电阻，空闲的时候处于高电平。​ 其中i2c_client相当于设备数中的i2c结点的信息，i2c_adapter相当于设备树中i2c总线上挂在的设备的信息。​ 主机发送起始位S信号，发送i2c从机的地址，发送写位，ACK1，写入从机的寄存器的8位数据，然后循环写数据，最后从机ACK2应答，并且主机发送停止位信号。在编写I2C驱动中我们一般是要对寄存器的数据进行读操作，因此就需要首先写入从设备地址，读取寄存器的数据。
linux的i2c驱动
12-28
linux模拟I2C驱动代码，用GPIO模拟的程序。实验成功
Linux增加字符设备驱动实验
05-11
本实验旨在帮助你理解如何为Linux添加一个新的字符设备驱动，以实现简单的"Hello World"输出。以下是关于这个实验的详细过程和相关知识点。 1. **字符设备驱动概述**： - 字符设备驱动是针对一次性读写或流式传输...
firefly-rk3288j开发板--linux I2C实验之eeprom驱动，包含驱动源码、测试app
06-10
适用用于linux内核驱动学习，参考
i2c.rar_44b0_i2c linux_linux i2c
09-21
"I2c"文件可能是具体的实验代码、配置文件或者日志，用于演示如何在Linux内核中注册I2C设备，如何编写I2C驱动，以及如何通过用户空间应用程序与I2C设备交互。这些文件可能包括Makefile、驱动源码、设备树配置、测试...
Linux设备驱动之IIC驱动
chengwei_peng
09-22 1967
Linux I2C框架介绍
Linux应用开发基础知识——I2C应用编程(十二)
妄北y
11-23 3767
I2C（Inter-IntegratedCircuitBUS）是集成电路总线，是目前应用最广泛的总线之一，最初由PHILIPS（现为NXP）设计。它使用多主从架构，主要用于连接低速周边设备。I2C总线在硬件物理层包括两条线：一条数据线（SDA）和一条时钟线（SCL）。所有设备都连接在这两条线上。
I2C协议调试总结
rosir_zhong的博客
02-19 4689
1 协议总结 开始：在SCL为高期间，SDA由高变低 结束：在SCL为高期间，SDA由低变高 应答：时钟脉冲９期间释放数据线，SCL为高期间，SDA读入为低电平 传输：在SCL为低电平期间，允许SDA变化，SCL变为高电平后，SDA必须稳定 写：设备地址+写控制字节 OK?--->内部寄存器地址 OK?---->写入数据 读：设备地址+写控制字节 OK?--->内部寄存器地址 OK?---->设备地址+读控制字节 OK?--->读入数据　 写控制字节为0，读控制字节为1 2.
Linux驱动学习—I2C总线
suifen_的博客
01-14 1326
I2C是很常见的一种总线协议，I2C是NXP公司设计的，I2C使用两条线在主控制器和从机之间进行数据通信。一条是SCL（串行时钟线），另外一条是SDA(串行数据线)，因为I2C这两条数据线是开漏输出的，所以需要接上拉电阻，总线空闲的时候SCL和SDA处于高电平。I2C总线标准模式下速度可以达到100Kb/s,快速模式下可以达到400kb/s。
Linux驱动：I2C驱动看这一篇就够了
让技术没有门槛
06-15 3167
I2C协议是在开发中使用非常频繁的一种协议，相信大家在学习单片机的时候经常会用到支持I2C协议的模块，I2C 总线仅仅使用 SCL、SDA 这两根信号线就实现了设备之间的数据交互，极大地简化了对硬件资源和 PCB 板布线空间的占用。因此，I2C 总线被非常广泛地应用在 EEPROM、实时钟、小型 LCD 等设备与 CPU 的接口中。但是与裸机开发不同的是在 Linux 系统中，I2C 驱动由 3 部分组成，即I2C 核心I2C 总线驱动和I2C 设备驱动。
《Linux驱动：I2C驱动看这一篇就够了》
qq_40709487的博客
10-20 4524
通常来说为某个特定的IIC设备去构建IIC设备驱动、针对平台硬件资源构建IIC适配器便是IIC驱动相关开发所需要做的工作，IIC核心相关、IIC总线驱动相关的部分，系统中一般已经存在。构建IIC设备驱动一般需要做的工作设置struct i2c_driver结构体，提供attach_adapter、detach_client接口。
Linux内核i2c驱动详解
yzw_yy的博客
08-20 1357
接下来，函数会处理设备的唤醒属性，如果设备设置了I2C_CLIENT_WAKE标志，则尝试获取设备的唤醒中断号，并设置设备的唤醒中断号。最后，函数会根据驱动的probe_new(新的驱动程序模型接口，有助于无缝删除当前probe（）的，更常用的是未使用的第二个参数)或probe函数来执行设备的探测操作，并返回相应的状态。在ACPI风格的匹配方式中，驱动程序通过与系统的ACPI表进行交互来获取设备的信息，并根据设备的特征进行匹配。设备节点的属性可以包含设备的厂商ID、设备ID、设备类型等信息。
Linux学习第39天：Linux I2C 驱动实验（三）：哥俩好
11-10 132
本节笔记主要学习试验程序的编写及运行测试。其中试验程序的编写主要包括修改设备树、AP3216驱动编写及编写测试APP。作为本节重点内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值