04_iic子系统

鸭鸭打瞌睡

已于 2023-01-26 00:53:42 修改

阅读量1.1k

点赞数 1

分类专栏：各路子系统文章标签： linux

于 2023-01-23 23:51:52 首次发布

本文链接：https://blog.csdn.net/weixin_43898067/article/details/128751935

版权

各路子系统专栏收录该内容

8 篇文章 2 订阅

订阅专栏

总结

iic_client和iic_driver 加入iic总线的思想和paltform总线的玩法一样
把iic设备和驱动注册到iic总线中构造出字符设备驱动和设备节点供app进行操作
但是iic硬件设备是挂在iic控制器下面的所以iic控制器也会有自己的驱动和设备树节点厂家一般都会帮做好
我们写的iic_driver驱动程序控制iic硬件的时候直接使用iic总线提供的api 来控制iic适配器驱动程序从而控制硬件设备
在这里插入图片描述
详细介绍分两部分一个是iic设备驱动程序一个是iic控制器驱动介绍

iic控制器驱动

芯片的iic控制器抽象成一个iic_adapter (一般这个控制器的驱动和设备节点芯片厂商都帮创建好了)
iic_algotithm 也构建好了

linux 上电注册iic总线 drivers/i2c/i2c-core-base.c


static int __init i2c_init(void)
	bus_register(&i2c_bus_type); //很熟悉的总线注册
IIC总线匹配规则 也就是看总线上的.match函数
 - of_driver_match_device：设备树匹配方式
  - 比较 I2C 设备节点的 compatible 属性和 of_device_id 中的 compatible 属性

- acpi_driver_match_device ： ACPI 匹配方式
- i2c_match_id：i2c总线传统匹配方式
  - 比较 I2C设备名字和 i2c驱动的id_table->name 字段是否相等

构造iic_适配器设备树节点

下面用IIC1控制器来举例子
i2c1: i2c@21a0000 {
				#address-cells = <1>;
				#size-cells = <0>;
				compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c";
				reg = <0x21a0000 0x4000>;  //reg属性记录了IIC寄存器组的地址
				interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>;
				clocks = <&clks IMX6UL_CLK_I2C1>;
				status = "disabled";
			};

适配器的驱动与之匹配

这个就是厂商写的适配器驱动但只是在和设备树匹配后在
/sys/bus/platform/i2c/dev/目录 (这个目录还没查没有板子) 增加新的dev

plantform_driver.probe
	struct resource *res;
	void __iomem *base;
	of_device_id *of_id = of_match_device(i2c_imx_dt_ids,&pdev->dev);
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);//获取resource资源,放到设备树就是reg = <0x21a0000 0x4000>;
	base = devm_ioremap_resource(&pdev->dev, res);//对resource物理地址和虚拟地址映射,此时base记录了虚拟地址
	phy_addr = (dma_addr_t)res->start;//这里记录物理地址,直接从resource->start拿取
	i2c_imx = devm_kzalloc(&pdev->dev, sizeof(*i2c_imx), GFP_KERNEL);//分配内存
	i2c_imx->adapter.algo		= &i2c_imx_algo;//初始化运算器,用于直接操作硬件的代码
	ret = i2c_add_numbered_adapter(&i2c_imx->adapter);//在linux注册一个i2c_adap
	
static const struct i2c_algorithm i2c_imx_algo = {  //运算器结构体
	.master_xfer	= i2c_imx_xfer,//产生IIC通讯时序,负责数据收发
	.functionality	= i2c_imx_func,//查询iic通信协议类型,iic通讯协议有一大类
};
	
	
.master_xfer
	result = i2c_imx_start(i2c_imx);//发送IIC的启动信号
	...
	for (i = 0; i < num; i++) {  //在for循环里面发送数据
		if (i == num - 1)
			is_lastmsg = true;
	result = i2c_imx_bus_busy(i2c_imx, 1);//判断当前iic总线是否忙
	if (msgs[i].flags & I2C_M_RD) //不忙判断当前信息需要读还是写
			result = i2c_imx_read(i2c_imx, &msgs[i], is_lastmsg);//这里真正控制IIC的寄存器进行发送读取
		else {
			if (i2c_imx->dma && msgs[i].len >= DMA_THRESHOLD)
				result = i2c_imx_dma_write(i2c_imx, &msgs[i]);
			else
				result = i2c_imx_write(i2c_imx, &msgs[i]);
		}

IIC核心函数和万能驱动!!! i2c-dev.c

iic适配器在上面probe后 iic_bus里面的dev有了新的适配器dev
万能驱动通过bus找到所有适配器dev 给这些适配注册字符设备 /proc/devcies
注册class 和device 再分配设备节点 /dev/xxx
具体如下

给每个i2c适配器生成设备文件,给app操作!!!
内核集成i2c_dev驱动模块，开机自动加载
为每个i2c_adapter生成一个设备文件，在用户空间通过该设备文件间接使用IIC核心函数收发数据
因为和适配器的驱动加载有先后问题
这个驱动注册i2c总线的通知函数，解决加载顺序问题

对于这个iic万能驱动程序的存在我的理解是
iic适配器创建出来,但是没有设备节点为了让iic适配器直接被应用程序调用所以使用了i2c-dev.c
给每个i2c适配器生成设备文件,给app操作
看看到底干了点什么把

i2c_dev_init()
	res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
		struct char_device_struct *cd; //构建字符设备结构体
		struct cdev *cdev;
		__register_chrdev(major, 0, 256, name, fops);
			__register_chrdev_region(major, baseminor, count, name);
		cdev = cdev_alloc(); //构建cdev 
		cdev->owner = fops->owner;
		cdev->ops = fops;
		kobject_set_name(&cdev->kobj, "%s", name); //这里看cdev继承kobj,并且给kobj名字,创建设备文件
		cdev_add()	
			//kobj_map结构体!!是用来管理设备号及其对应的设备的,kobj_map函数把指定的设备号加入到该数组
				用kobject对象,得到包含它的对象如cdev
			kobj_map(cdev_map, dev, count, NULL,exact_match, exact_lock, p);
		kobject_get(p->kobj.parent);
		
	从上面看 没有注册设备节点 只是创建了/proc
	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
	bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
	i2c_for_each_dev(NULL, i2cdev_attach_adapter); //i2cdev_attach_adapter 添加iic适配器就会执行的函数
		res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);  //从bus下面的链表的devices找bus_type=i2c_bus_type的 dev 
		

//看看增加了iic适配器就会执行的函数	
	这里不知道从哪来的 device *dev 很可疑
i2cdev_attach_adapter(struct device *dev, void *dummy)
	struct i2c_adapter *adap;
	struct i2c_dev *i2c_dev;
	if (dev->type != &i2c_adapter_type) //如果不是iic适配器返回0
			return 0;
	adap = to_i2c_adapter(dev);//从dev上面获取iic适配器
	i2c_dev = get_free_i2c_dev(adap); //给i2c_dev分配内存
	cdev_init(&i2c_dev->cdev, &i2cdev_fops);//把这个file_operation操作接口,记录在i2c_dev->cdev
	res = cdev_add(&i2c_dev->cdev, MKDEV(I2C_MAJOR, adap->nr), 1); //给这个设备指定设备号,之前分配的没有用,现在才开始用
													主设备没变,次设备号变成了适配器的编号,构造出/proc/device/xxx设备
	i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,MKDEV(I2C_MAJOR, adap->nr), NULL,"i2c-%d", adap->nr);//在i2c_dev_class创建新的目录
														//新目录下xxx/i2c-%d/dev同时记录属性文件 新目录名i2c-%d
															//有了属性文件,获取设备号,和file_operation
																//接着kset用kobj_uvevnt()通知用户空间创建设备节点

iic设备驱动程序

设备树构造dev

设备dev转化为dev节点在iic中转化为iic_client结构体
struct i2c_client
struct device dev; 继承了 struct device 符合linux驱动设备模型
linux根据IIC设备节点自动生成i2c_client节点

//iomuxc子节点
pinctrl_i2c1: i2c1grp {
        		fsl,pins = <
        			MX6UL_PAD_UART4_TX_DATA__I2C1_SCL 0x4001b8b0
        			MX6UL_PAD_UART4_RX_DATA__I2C1_SDA 0x4001b8b0
        		>;
        	}; 
//在i2c控制器下新增 设备节点    
&i2c1{
	clock-frequency = <100000>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;
	status = "okay";
	
	i2c_mpu6050@68 {
	        	compatible = "fire,i2c_mpu6050";
	        	reg = <0x68>;
	        	status = "okay";
	 };
};




```c
struct i2c_client {
	unsigned short flags;		/* div., see below		*/
	unsigned short addr;		/* 7位地址	*/

	char name[I2C_NAME_SIZE];
	struct i2c_adapter *adapter;	/* the adapter we sit on	*/
	struct device dev;		/* 继承了 struct device 符合linux驱动设备模型		*/
	int init_irq;			/* irq set at initialization	*/
	int irq;			/* irq issued by device		*/
	struct list_head detected;
#if IS_ENABLED(CONFIG_I2C_SLAVE)
	i2c_slave_cb_t slave_cb;	/* callback for slave mode	*/
#endif
};

设备驱动


#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/i2c.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/device.h>

#include <linux/platform_device.h>

#include "i2c_mpu6050.h"

/*------------------字符设备内容----------------------*/
#define DEV_NAME "I2C1_mpu6050"
#define DEV_CNT (1)

/*定义 led 资源结构体，保存获取得到的节点信息以及转换后的虚拟寄存器地址*/
static dev_t mpu6050_devno;				 //定义字符设备的设备号
static struct cdev mpu6050_chr_dev;		 //定义字符设备结构体chr_dev
struct class *class_mpu6050;			 //保存创建的类
struct device *device_mpu6050;			 // 保存创建的设备
struct device_node *mpu6050_device_node; //rgb_led的设备树节点结构体

/*------------------IIC设备内容----------------------*/
struct i2c_client *mpu6050_client = NULL; //保存mpu6050设备对应的i2c_client结构体，匹配成功后由.prob函数带回。

/*通过i2c 向mpu6050写入数据
*mpu6050_client：mpu6050的i2c_client结构体。
*address, 数据要写入的地址，
*data, 要写入的数据
*返回值，错误，-1。成功，0  
*/
static int i2c_write_mpu6050(struct i2c_client *mpu6050_client, u8 address, u8 data)
{
	int error = 0;
	u8 write_data[2];
	struct i2c_msg send_msg; //要发送的数据结构体

	/*设置要发送的数据*/
	write_data[0] = address;
	write_data[1] = data;

	/*发送 iic要写入的地址 reg*/
	send_msg.addr = mpu6050_client->addr; //mpu6050在 iic 总线上的地址
	send_msg.flags = 0;					  //标记为发送数据
	send_msg.buf = write_data;			  //写入的首地址
	send_msg.len = 2;					  //reg长度

	/*执行发送*/
	error = i2c_transfer(mpu6050_client->adapter, &send_msg, 1);
	if (error != 1)
	{
		printk(KERN_DEBUG "\n i2c_transfer error \n");
		return -1;
	}
	return 0;
}

/*通过i2c 向mpu6050写入数据
*mpu6050_client：mpu6050的i2c_client结构体。
*address, 要读取的地址，
*data，保存读取得到的数据
*length，读长度
*返回值，错误，-1。成功，0
*/
static int i2c_read_mpu6050(struct i2c_client *mpu6050_client, u8 address, void *data, u32 length)
{
	int error = 0;
	u8 address_data = address;
	struct i2c_msg mpu6050_msg[2];
	/*设置读取位置msg*/
	mpu6050_msg[0].addr = mpu6050_client->addr; //mpu6050在 iic 总线上的地址
	mpu6050_msg[0].flags = 0;					//标记为发送数据
	mpu6050_msg[0].buf = &address_data;			//写入的首地址
	mpu6050_msg[0].len = 1;						//写入长度

	/*设置读取位置msg*/
	mpu6050_msg[1].addr = mpu6050_client->addr; //mpu6050在 iic 总线上的地址
	mpu6050_msg[1].flags = I2C_M_RD;			//标记为读取数据
	mpu6050_msg[1].buf = data;					//读取得到的数据保存位置
	mpu6050_msg[1].len = length;				//读取长度

	error = i2c_transfer(mpu6050_client->adapter, mpu6050_msg, 2);

	if (error != 2)
	{
		printk(KERN_DEBUG "\n i2c_read_mpu6050 error \n");
		return -1;
	}
	return 0;
}

/*初始化i2c
*返回值，成功，返回0。失败，返回 -1
*/
static int mpu6050_init(void)
{
	int error = 0;
	/*配置mpu6050*/
	error += i2c_write_mpu6050(mpu6050_client, PWR_MGMT_1, 0X00);
	error += i2c_write_mpu6050(mpu6050_client, SMPLRT_DIV, 0X07);
	error += i2c_write_mpu6050(mpu6050_client, CONFIG, 0X06);
	error += i2c_write_mpu6050(mpu6050_client, ACCEL_CONFIG, 0X01);

	if (error < 0)
	{
		/*初始化错误*/
		printk(KERN_DEBUG "\n mpu6050_init error \n");
		return -1;
	}
	return 0;
}

/*字符设备操作函数集，open函数实现*/
static int mpu6050_open(struct inode *inode, struct file *filp)
{
	// printk("\n mpu6050_open \n");

	/*向 mpu6050 发送配置数据，让mpu6050处于正常工作状态*/
	mpu6050_init();
	return 0;
}

/*字符设备操作函数集，.read函数实现*/
static ssize_t mpu6050_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
{
	char data_H;
	char data_L;
	int error;
	short mpu6050_result[6]; //保存mpu6050转换得到的原始数据

	// printk("\n mpu6050_read \n");
	
	i2c_read_mpu6050(mpu6050_client, ACCEL_XOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, ACCEL_XOUT_L, &data_L, 1);
	mpu6050_result[0] = data_H << 8;
	mpu6050_result[0] += data_L;

	i2c_read_mpu6050(mpu6050_client, ACCEL_YOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, ACCEL_YOUT_L, &data_L, 1);
	mpu6050_result[1] = data_H << 8;
    mpu6050_result[1] += data_L;

	i2c_read_mpu6050(mpu6050_client, ACCEL_ZOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, ACCEL_ZOUT_L, &data_L, 1);
	mpu6050_result[2] = data_H << 8;
	mpu6050_result[2] += data_L;

	i2c_read_mpu6050(mpu6050_client, GYRO_XOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, GYRO_XOUT_L, &data_L, 1);
	mpu6050_result[3] = data_H << 8;
	mpu6050_result[3] += data_L;

	i2c_read_mpu6050(mpu6050_client, GYRO_YOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, GYRO_YOUT_L, &data_L, 1);
	mpu6050_result[4] = data_H << 8;
	mpu6050_result[4] += data_L;

	i2c_read_mpu6050(mpu6050_client, GYRO_ZOUT_H, &data_H, 1);
	i2c_read_mpu6050(mpu6050_client, GYRO_ZOUT_L, &data_L, 1);
	mpu6050_result[5] = data_H << 8;
	mpu6050_result[5] += data_L;


	// printk("AX=%d, AY=%d, AZ=%d \n",(int)mpu6050_result[0],(int)mpu6050_result[1],(int)mpu6050_result[2]);
	// printk("GX=%d, GY=%d, GZ=%d \n \n",(int)mpu6050_result[3],(int)mpu6050_result[4],(int)mpu6050_result[5]);

	/*将读取得到的数据拷贝到用户空间*/
	error = copy_to_user(buf, mpu6050_result, cnt);

	if(error != 0)
	{
		printk("copy_to_user error!");
		return -1;
	}
	return 0;
}

/*字符设备操作函数集，.release函数实现*/
static int mpu6050_release(struct inode *inode, struct file *filp)
{
	// printk("\n mpu6050_release \n");
	
	/*向mpu6050发送命令，使mpu6050进入关机状态*/
	return 0;
}

/*字符设备操作函数集*/
static struct file_operations mpu6050_chr_dev_fops =
	{
		.owner = THIS_MODULE,
		.open = mpu6050_open,
		.read = mpu6050_read,
		.release = mpu6050_release,
};

/*----------------平台驱动函数集-----------------*/
static int mpu6050_probe(struct i2c_client *client, const struct i2c_device_id *id)
{

	int ret = -1; //保存错误状态码

	printk(KERN_EMERG "\t  match successed  \n");
	/*---------------------注册 字符设备部分-----------------*/

	//采用动态分配的方式，获取设备编号，次设备号为0，
	//设备名称为rgb-leds，可通过命令cat  /proc/devices查看
	//DEV_CNT为1，当前只申请一个设备编号
	ret = alloc_chrdev_region(&mpu6050_devno, 0, DEV_CNT, DEV_NAME);
	if (ret < 0)
	{
		printk("fail to alloc mpu6050_devno\n");
		goto alloc_err;
	}

	//关联字符设备结构体cdev与文件操作结构体file_operations
	mpu6050_chr_dev.owner = THIS_MODULE;
	cdev_init(&mpu6050_chr_dev, &mpu6050_chr_dev_fops);

	// 添加设备至cdev_map散列表中
	ret = cdev_add(&mpu6050_chr_dev, mpu6050_devno, DEV_CNT);
	if (ret < 0)
	{
		printk("fail to add cdev\n");
		goto add_err;
	}

	/*创建类 */
	class_mpu6050 = class_create(THIS_MODULE, DEV_NAME);

	/*创建设备 DEV_NAME 指定设备名，*/
	device_mpu6050 = device_create(class_mpu6050, NULL, mpu6050_devno, NULL, DEV_NAME);
	mpu6050_client = client;
	return 0;

add_err:
	// 添加设备失败时，需要注销设备号
	unregister_chrdev_region(mpu6050_devno, DEV_CNT);
	printk("\n error! \n");
alloc_err:

	return -1;
}


static int mpu6050_remove(struct i2c_client *client)
{
	/*删除设备*/
	device_destroy(class_mpu6050, mpu6050_devno);	  //清除设备
	class_destroy(class_mpu6050);					  //清除类
	cdev_del(&mpu6050_chr_dev);						  //清除设备号
	unregister_chrdev_region(mpu6050_devno, DEV_CNT); //取消注册字符设备
	return 0;
}



/*定义ID 匹配表*/
static const struct i2c_device_id gtp_device_id[] = {
	{"fire,i2c_mpu6050", 0},
	{}};

/*定义设备树匹配表*/
static const struct of_device_id mpu6050_of_match_table[] = {
	{.compatible = "fire,i2c_mpu6050"},
	{/* sentinel */}};

/*定义i2c总线设备结构体*/
struct i2c_driver mpu6050_driver = {
	.probe = mpu6050_probe,
	.remove = mpu6050_remove,
	.id_table = gtp_device_id,
	.driver = {
		.name = "fire,i2c_mpu6050",
		.owner = THIS_MODULE,
		.of_match_table = mpu6050_of_match_table,
	},
};

/*
*驱动初始化函数
*/
static int __init mpu6050_driver_init(void)
{
	int ret;
	pr_info("mpu6050_driver_init\n");
	ret = i2c_add_driver(&mpu6050_driver);
	return ret;
}

/*
*驱动注销函数
*/
static void __exit mpu6050_driver_exit(void)
{
	pr_info("mpu6050_driver_exit\n");
	i2c_del_driver(&mpu6050_driver);
}

module_init(mpu6050_driver_init);
module_exit(mpu6050_driver_exit);

MODULE_LICENSE("GPL");

鸭鸭打瞌睡

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
04_iic子系统

iic_client和iic_driver 加入iic总线的思想和paltform总线的玩法一样把iic设备和驱动注册到iic总线中构造出字符设备驱动和设备节点供app进行操作但是iic硬件设备是挂在iic控制器下面的所以iic控制器也会有自己的驱动和设备树节点厂家一般都会帮做好我们写的iic_driver驱动程序控制iic硬件的时候使用iic总线提供的api 来控制iic硬件设备详细介绍分两部分一个是iic驱动程序一个是iic控制器驱动介绍。
复制链接

扫一扫