【IMX6ULL驱动开发学习】10.Linux I2C驱动实战：AT24C02驱动设计流程

最新推荐文章于 2024-02-20 12:16:31 发布
最新推荐文章于 2024-02-20 12:16:31 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： Linux驱动开发 文章标签： 驱动开发 学习 linux 嵌入式硬件 交互
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43460230/article/details/132454796
版权

前情回顾：【IMX6ULL驱动开发学习】09.Linux之I2C框架简介和驱动程序模板_阿龙还在写代码的博客-CSDN博客

目录

一、修改设备树（设备树用来指定引脚资源）

二、编写驱动

2.1 i2c_drv_read

2.2 i2c_drv_write

2.3 完整驱动程序

三、上机测试

一、修改设备树（设备树用来指定引脚资源）

  • 放在哪个I2C控制器下面
  • AT24C02的I2C设备地址（查看芯片手册 0x50）
  • compatible属性：用来寻址驱动程序

修改设备树：在内核目录下 vi  arch/arm/boot/dts/100ask_imx6ull-14x14.dts 

&i2c1 {
    clock-frequency = <100000>;
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_i2c1>;
    status = "okay";

    at24c02 { 
       compatible = "100ask,i2cdev";
       reg = <0x50>;//设备地址 查看芯片手册
    };  
};

at24c02节点会转换成i2c_client，i2c_client里有个adpater，即i2c_client.adpater。i2c_client.adpater将指向一个i2c控制器，i2c控制器与&i2c1节点对应，即&i2c1就是一个i2c控制器，内核里对&i2c1这个i2c控制器已经编写好了驱动程序。

二、编写驱动

在I2C驱动框架的基础上对i2c_drv_read和i2c_drv_write函数修改

2.1 i2c_drv_read

实现读AT24C02的0地址数据需要完成一下步骤：

  • 初始化i2c_msg

  • 发起一次写操作: 把0发给AT24C02, 表示要从0地址读数据

  • 发起一次读操作: 得到数据

/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t i2c_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	int err;
	unsigned char *kern_buf;
	struct i2c_msg msgs[2];

	/* 从0读取size字节 */

	kern_buf = kmalloc(size, GFP_KERNEL);

	/* 初始化i2c_msg 
	 * 1. 发起一次写操作: 把0发给AT24C02, 表示要从0地址读数据
	 * 2. 发起一次读操作: 得到数据
	 */
	msgs[0].addr  = g_client->addr; //设备树里记录了设备地址：0x50
	msgs[0].flags = 0;              //flags为0：写操作 
	msgs[0].buf   = kern_buf;		//取得数据
	kern_buf[0]   = 0; 				//buf里第一个字节表示设备存储空间地址，把地址数据0发给设备
	msgs[0].len   = 1;				//发送长度为1，即 发送一个字节数据0给设备

	msgs[1].addr  = g_client->addr;
	msgs[1].flags = I2C_M_RD;  		//读操作
	msgs[1].buf   = kern_buf;		//读到的数据保存在kern_buf里
	msgs[1].len   = size;			//读size个数据

	//函数由内核提供
	err = i2c_transfer(g_client->adapter, msgs, 2);

	/* copy_to_user  */
	err = copy_to_user(buf, kern_buf, size);

	kfree(kern_buf);
	
	return size;
}

2.2 i2c_drv_write

AT24C02一页只有8个字节内存，故写入多数据需要循环写入

实现AT24C02的0地址起的读数据需要完成一下步骤：

  • 初始化i2c_msg

  • 发起一次写操作：把地址发给AT24C02, 表示要从该地址读数据

  • 地址偏移并继续写

//一页只有8个字节 循环写
static ssize_t i2c_drv_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
	int err;
	unsigned char kern_buf[9];
	struct i2c_msg msgs[1];
	int len;
	unsigned char addr = 0;

	/* 把size字节的数据写入地址0 */

	//kern_buf = kmalloc(size+1, GFP_KERNEL);

	while (size > 0)
	{
		if (size > 8)
			len = 8;
		else
			len = size;

		size -= len;

		/* copy_from_user  */
		err = copy_from_user(kern_buf+1, buf, len);
		buf += len;


		/* 初始化i2c_msg 
		* 1. 发起一次写操作: 把0发给AT24C02, 表示要从0地址读数据
		* 2. 发起一次读操作: 得到数据
		*/
		msgs[0].addr  = g_client->addr;
		msgs[0].flags = 0;  /* 写操作 */
		msgs[0].buf   = kern_buf;
		kern_buf[0]   = addr;  // 写AT24C02的地址，从0开始写，buf里第一个字节表示设备存储空间地址
		msgs[0].len   = len+1;
		addr += len;

		err = i2c_transfer(g_client->adapter, msgs, 1);

		mdelay(20);//写一页需要时间约10ms，烧写一页数据需等待
	}

	//kfree(kern_buf);
	
	return size;    
}

2.3 完整驱动程序

i2c_drv.c

#include "asm/uaccess.h"
#include "linux/delay.h"
#include "linux/i2c.h"
#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>

/* 主设备号                                                                 */
static int major = 0;
static struct class *my_i2c_class;

static struct i2c_client *g_client;

static DECLARE_WAIT_QUEUE_HEAD(gpio_wait);
struct fasync_struct *i2c_fasync;


/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t i2c_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
	int err;
	unsigned char *kern_buf;
	struct i2c_msg msgs[2];

	/* 从0读取size字节 */

	kern_buf = kmalloc(size, GFP_KERNEL);

	/* 初始化i2c_msg 
	 * 1. 发起一次写操作: 把0发给AT24C02, 表示要从0地址读数据
	 * 2. 发起一次读操作: 得到数据
	 */
	msgs[0].addr  = g_client->addr; //设备树里记录了设备地址：0x50
	msgs[0].flags = 0;              //flags为0：写操作 
	msgs[0].buf   = kern_buf;		//取得数据
	kern_buf[0]   = 0; 				//buf里第一个字节表示设备存储空间地址，把地址数据0发给设备
	msgs[0].len   = 1;				//发送长度为1，即 发送一个字节数据0给设备

	msgs[1].addr  = g_client->addr;
	msgs[1].flags = I2C_M_RD;  		//读操作
	msgs[1].buf   = kern_buf;		//读到的数据保存在kern_buf里
	msgs[1].len   = size;			//读size个数据

	//函数由内核提供
	err = i2c_transfer(g_client->adapter, msgs, 2);

	/* copy_to_user  */
	err = copy_to_user(buf, kern_buf, size);

	kfree(kern_buf);
	
	return size;
}

//一页只有8个字节 循环写
static ssize_t i2c_drv_write(struct file *file, const char __user *buf, size_t size, loff_t *offset)
{
	int err;
	unsigned char kern_buf[9];
	struct i2c_msg msgs[1];
	int len;
	unsigned char addr = 0;

	/* 把size字节的数据写入地址0 */

	//kern_buf = kmalloc(size+1, GFP_KERNEL);

	while (size > 0)
	{
		if (size > 8)
			len = 8;
		else
			len = size;

		size -= len;

		/* copy_from_user  */
		err = copy_from_user(kern_buf+1, buf, len);
		buf += len;


		/* 初始化i2c_msg 
		* 1. 发起一次写操作: 把0发给AT24C02, 表示要从0地址读数据
		* 2. 发起一次读操作: 得到数据
		*/
		msgs[0].addr  = g_client->addr;
		msgs[0].flags = 0;  /* 写操作 */
		msgs[0].buf   = kern_buf;
		kern_buf[0]   = addr;  // 写AT24C02的地址，从0开始写，buf里第一个字节表示设备存储空间地址
		msgs[0].len   = len+1;
		addr += len;

		err = i2c_transfer(g_client->adapter, msgs, 1);

		mdelay(20);//写一页需要时间约10ms，烧写一页数据需等待
	}

	//kfree(kern_buf);
	
	return size;    
}


static unsigned int i2c_drv_poll(struct file *fp, poll_table * wait)
{
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	poll_wait(fp, &gpio_wait, wait);
	//return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
	return 0;
}

static int i2c_drv_fasync(int fd, struct file *file, int on)
{
	if (fasync_helper(fd, file, on, &i2c_fasync) >= 0)
		return 0;
	else
		return -EIO;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations i2c_drv_fops = {
	.owner	 = THIS_MODULE,
	.read    = i2c_drv_read,
	.write   = i2c_drv_write,
	.poll    = i2c_drv_poll,
	.fasync  = i2c_drv_fasync,
};


static int i2c_drv_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	// struct device_node *np = client->dev.of_node;
	// struct i2c_adapter *adapter = client->adapter;

	/* 记录client */
	g_client = client;

	/* 注册字符设备 */
	/* 注册file_operations 	*/
	major = register_chrdev(0, "100ask_i2c", &i2c_drv_fops);  /* /dev/gpio_desc */

	my_i2c_class = class_create(THIS_MODULE, "100ask_i2c_class");
	if (IS_ERR(my_i2c_class)) {
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		unregister_chrdev(major, "100ask_i2c");
		return PTR_ERR(my_i2c_class);
	}

	device_create(my_i2c_class, NULL, MKDEV(major, 0), NULL, "myi2c"); /* /dev/myi2c */
	
	return 0;
}

static int i2c_drv_remove(struct i2c_client *client)
{
	/* 反注册字符设备 */
	device_destroy(my_i2c_class, MKDEV(major, 0));
	class_destroy(my_i2c_class);
	unregister_chrdev(major, "100ask_i2c");

	return 0;
}

static const struct of_device_id myi2c_dt_match[] = {
	{ .compatible = "100ask,i2cdev" },
	{},
};

//必须有这个，不然装载驱动不成功
static const struct i2c_device_id at24c02_ids[] = {
	{ "xxxxyyy",	(kernel_ulong_t)NULL },
	{ /* END OF LIST */ }
};
static struct i2c_driver my_i2c_driver = {
	.driver = {
		   .name = "100ask_i2c_drv",
		   .owner = THIS_MODULE,
		   .of_match_table = myi2c_dt_match,
	},
	.probe = i2c_drv_probe,
	.remove = i2c_drv_remove,
	.id_table = at24c02_ids,
};


static int __init i2c_drv_init(void)
{
	/* 注册i2c_driver */
	return i2c_add_driver(&my_i2c_driver);
}

static void __exit i2c_drv_exit(void)
{
	/* 反注册i2c_driver */
	i2c_del_driver(&my_i2c_driver);
}

/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */

module_init(i2c_drv_init);
module_exit(i2c_drv_exit);

MODULE_LICENSE("GPL");

三、上机测试

  • 在/home/book/100ask_imx6ull-sdk/Linux-4.9.88目录下重新编译设备树：make dtbs
  • 复制到单板上，如下：
PC:
cp arch/arm/boot/dts/100ask_imx6ull-14x14.dtb ~/nfs_rootfs/
 
开发板:
mount -t nfs -o nolock,vers=3 192.168.5.11:/home/book/nfs_rootfs /mnt
cp /mnt/100ask_imx6ull-14x14.dtb  /boot
reboot
  • 进入系统固件目录下查看cd /sys/firmware/devicetree/base/

  • 在系统 总线 i2c 设备下面查看是否有这个设备

 

 有这个设备，但没有对应驱动程序

  • 挂载网络文件系统：mount -t nfs -o nolock,vers=3 192.168.5.11:/home/book/nfs_rootfs /mnt
  • 装载驱动程序：insmod i2c_drv.ko
  • 查看对应设备节点：ls /dev/myi2c -l  

  • 查看用法、测试驱动程序 

 

 成功读出数据！

 

 

 

阿龙还在写代码
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
05-21
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
迅为imx6ull驱动程序配套资料.zip
06-23
迅为imx6ull驱动程序配套资料.zip
[imx6ull]I2C协议-SHT20温湿度采样
qq_52836452的博客
03-25 1192
I2C 总线在空闲时SDA和SCL都处于高电平状态(由上拉电阻拉成高电平)，当主设备要开始一次I2C通信时就发送一个START(S)信号，这个起始位就可以告诉所有I2C 从机，主设备需要开始进行 I2C 通信了；当主机往I2C总线上传输器件的地址时，所有的从机接受到了这个地址后与自己的地址相比较，如果相同则发送一个应答ACK信号，不相同则不发送 应答信号，当主机收到了应答信号后表示建立连接成功，而未收到则表示寻址失败（可以在总线时序的第九个时钟时的电平高低进行判断）。
IMX6ULL裸机开发之硬件IIC分析及配置过程
qq_43940175的博客
04-21 1288
裸机配置硬件I2C 关于I2C的具体介绍，可以参考我的另一篇文章 STM32之IIC详细解析 IMX6U的硬件I2C特性 兼容标准I2C总线； 软件可配置64个不同的串行时钟频率； 软件可选的应答信号； start/end信号生成和检测； 重复start信号生成； 确认位生成； 总线busy检测。 I2C的两种模式 标准模式：在该模式下I2C传输速率可达100kb/s； 高速模式：在该模式下I2C传输速率可达400kb/s； 外部引脚MAP IMX6U有4组IIC，这里举个例子，另外的参考《IMX6
在imx6ull接入ov2640
qq_41170580的博客
07-05 1096
ov2640模组：imx6ull摄像头模块接口注意两个引脚：CSI_PWDN，CSI_RESET，在ov2640的datasheet中关于上电顺序有如下说明ov2640正常上电时，Reset引脚应该为高， PDWN为低电平。问题1:摄像头一直没有枚举成功，i2cdetect扫不到该ic，最终定位的原因为PDWN引脚的电平不对；实际测量PDWN引脚，电压为1.5v，理论上为低电平，具体2640的ic怎么处理的不得而知。
IMX6ULL I2C框架
weixin_41791581的博客
02-22 705
本节来看I2C驱动框架，题目叫IMX6ULL I2C框架，不是imx特有的i2c驱动框架，只是借着IMX6ULL的平台来分析linux内核中的I2C驱动框架， 在Linux内核中，把I2C分为I2c总线、设备、驱动，实现了分层的概念，那么，在内核中，I2C总线抽象为一个结构体叫做I2c_adapter，一个i2c_adapter就是平台上一个真实的物理I2C i2c_adapter 来看一下I2C框架中最重要的i2c_adapter结构体的内容 其中重要的成员是struct i2c_algori
设备树下的LED驱动实验
lengyuefeng212的博客
08-04 360
文章目录一、设备树LED驱动原理二、硬件原理图分析三、实验程序编写1.修改设备树文件2.LED灯驱动程序编写3.编写测试APP四、运行测试 一、设备树LED驱动原理 我们使用设备树来向 Linux 内核传递相关的寄存器物理地址，Linux 驱动文件使用上一章讲解的 OF函数从设备树中获取所需的属性值，然后使用获取到的属性值来初始化相关的 IO。 ①、在 imx6ull-luatao-emmc.dts 文件中创建相应的设备节点。 ②、编写驱动程序，获取设备树中的相关属性值。 ③、使用获取到的有关属性值来初始
Linux驱动开发(使用I2C总线设备驱动模型编写AT24C02驱动程序)
m0_49476241的博客
06-07 1188
本篇文章将讲解如何使用I2C总线设备驱动模型编写AT24C02驱动程序。本篇文章主要讲解了i2C总线设备驱动模型编写AT24C02驱动程序，这里大家主要需要掌握的就是i2C总线设备驱动这个模型，只要掌握好了这个模型那么剩下的就是裸机的操作了。
51单片机使用AT24C02
m0_49476241的博客
03-14 3531
AT24C02是Atmel公司推出的一款串行EEPROM存储器。它具有2K位存储单元，可以存储256个8位字节数据，采用2线串行接口（I2C总线接口），支持多主机系统，工作电压范围为1.8V至5.5V。AT24C02具有低功耗、非易失性、可重写、高可靠性等特点，广泛应用于工业控制、仪器仪表、消费电子等领域。在工程开发中我们将经常使用到AT24C02保存我们需要的数据。应用：AT24C02常用于各种嵌入式系统、智能卡、控制器等设备中，用于存储关键性数据，如系统参数、密钥等。
imx6ull——I2C驱动
ljh5930的博客
02-27 1355
SCL 为高电平，SDA 出现下降沿:起始位SCL 位高电平，SDA出现上升沿:停止位主机——从机地址（ack）——寄存器地址（ack）——数据（ack）重点：先是写，因为要写入从机让从机知道主机要读，再是读主机——从机地址（写）（ack）——寄存器地址（ack）——从机地址（读）（ack）从机——发送数据（主机发送no ack）1-7位放要访问的从机地址I2c频率不能随便分，只能选。
AT24C02的读写操作
热门推荐
zbl12345678910的博客
05-09 1万+
AT24C02的读写操作 **说明：**最近我在做基于EEPROM存储器24c02存储的电子锁时遇到了一些问题：每次向24C02写入数据的时候没出现什么问题，可以正常写入。但是每次读取24C02却总是出现错误。 通过查找网上的各种资料，发现这个问题很多小伙伴都有遇到，但是楼下的评论不是说时序有问题就是说函数有问题，却没有具体的指出来到底哪里有问题。 下面我就以我的I2C驱动24C02为例来说说我是如何解决24C02数据读取问题的。 关于24c02的资料我觉得这篇博客写的比较详细，我这里就不花时间了（而且感觉
2_led_IMX6ULL、Linux驱动开发_源码
10-04
IMX6ULL芯片，LINUX驱动LED实例
正点原子imx6ull linux驱动开发指南 第38章 busybox制作的根文件系统
03-20
完全按照《I.MX6U 嵌入式 Linux 驱动开发指南 V1.5》中第38章中的教程制作，并且测试正常运行。
正点原子imx6ull 嵌入式驱动开发 0.96oled屏幕驱动源码
最新发布
04-20
正点原子imx6ull 嵌入式驱动开发 0.96oled屏幕驱动源码
移植ov5640摄像头到imx6ull开发板（一）
qq_55389904的博客
08-28 1748
ov5640摄像头驱动是基于v4l2框架进行编写，这样应用层才能提供对应的接口函数。ov5640摄像头驱动中的主要工作：1.初始化Linux内核提供有关v4l2驱动框架的结构体2.通过i2c协议读写寄存器，配置摄像头3.提供应用层ioctl对应的函数以上便是我对ov5640摄像头驱动代码的一些理解和分析，如果存在错误，希望大家指正。
I.MX6ULL_Linux_驱动篇(41)platform设备驱动框架
weixin_41252596的博客
07-31 158
我们在前面几章编写的设备驱动都非常的简单，都是对IO进行最简单的读写操作。像I2C、SPI、 LCD 等这些复杂外设的驱动就不能这么去写了， Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，在这个思路下诞生了我们将来最常打交道的platform 设备驱动，也叫做平台设备驱动。本章我们就来学习一下 Linux 下的驱动分离与分层，以及 platform 框架下的设备驱动该如何编写。
详解AT24CXX驱动开发（linux platform tree - i2c应用）
mftang的博客
02-20 1347
本文以AT24C02为例，对该类型芯片做全面剖析，详细介绍该芯片的硬件特性和软件设计方面的方法和技巧，其中包括单字节的读和写，连续字节的读写方法、以I2C波形分析。并且在linux平台上，使用I2C接口，编写一个实用案例，实现该芯片的驱动程序。并使用逻辑分析仪工具，详尽解析其工作的波形。
开发板 集成下载器 jtag_迅为i.MX6ULL开发板原理图分析介，重点是 LVDS 接口是 RGB 信号通过芯片 GM8285C转换， HDMI 接口是 RGB 接口通过 Sil9022A 转换
二进制模----细微行动改变影响世界
02-18 963
https://blog.csdn.net/weixin_40002846/article/details/110261490
i.MX6ULL开发板【终结者】硬件资源说明
mucheni的博客
03-30 1980
1.1初识 L i.MX6ULL 终结者开发板 终结者开发板 迅为i.MX6ULL 终结者开发板硬件资源非常丰富，几乎将 i.MX6ULL 芯片的所有资源都扩展引出到底板上了， 底板提供了丰富的外设接口，开发板的尺寸是 190mm*125mm，充分考虑了人性化设计，整体显得十分大 气。 I.MX6ULL 终结者底板板载资源如下： 1.邮票孔核心板接口，支持迅为电子的 i.MX6UL/i.MX6...
写一个mx6ull 的linux 24c02 驱动
05-27
下面是一个简单的 MX6ULL Linux 24C02 EEPROM 驱动框架，仅供参考： ```c #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/i2c.h> #include <linux/device.h> #include <linux/err.h> #define EEPROM_ADDR 0x50 #define EEPROM_PAGE_SIZE 8 /* MX6ULL 24C02 EEPROM 驱动数据结构体 */ struct mx6ull_eeprom { struct i2c_client *client; u8 *buffer; }; /* MX6ULL 24C02 EEPROM 驱动读函数 */ static int mx6ull_eeprom_read(struct i2c_client *client, u16 addr, u8 *buffer, u32 count) { struct i2c_msg msg[2]; u8 addr_buf[2]; int ret; addr_buf[0] = addr >> 8; addr_buf[1] = addr & 0xFF; msg[0].addr = client->addr; msg[0].flags = 0; msg[0].len = 2; msg[0].buf = addr_buf; msg[1].addr = client->addr; msg[1].flags = I2C_M_RD; msg[1].len = count; msg[1].buf = buffer; ret = i2c_transfer(client->adapter, msg, 2); if (ret == 2) return 0; return -EIO; } /* MX6ULL 24C02 EEPROM 驱动写函数 */ static int mx6ull_eeprom_write(struct i2c_client *client, u16 addr, const u8 *buffer, u32 count) { struct i2c_msg msg; u8 *buf; int ret, wrote = 0; buf = kmalloc(EEPROM_PAGE_SIZE + 2, GFP_KERNEL); if (!buf) return -ENOMEM; while (count > 0) { u32 chunk_size = min_t(u32, count, EEPROM_PAGE_SIZE); buf[0] = addr >> 8; buf[1] = addr & 0xFF; memcpy(&buf[2], buffer + wrote, chunk_size); msg.addr = client->addr; msg.flags = 0; msg.len = chunk_size + 2; msg.buf = buf; ret = i2c_transfer(client->adapter, &msg, 1); if (ret != 1) { kfree(buf); return -EIO; } msleep(5); addr += chunk_size; wrote += chunk_size; count -= chunk_size; } kfree(buf); return 0; } /* MX6ULL 24C02 EEPROM 驱动读取函数 */ static ssize_t mx6ull_eeprom_read_from_eeprom(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct mx6ull_eeprom *eeprom = file->private_data; int ret; if (*ppos + count > 256) return -EINVAL; mutex_lock(&eeprom->client->dev.mutex); ret = mx6ull_eeprom_read(eeprom->client, *ppos, eeprom->buffer, count); if (ret == 0) { if (copy_to_user(buf, eeprom->buffer, count)) ret = -EFAULT; else *ppos += count; } mutex_unlock(&eeprom->client->dev.mutex); return ret; } /* MX6ULL 24C02 EEPROM 驱动写入函数 */ static ssize_t mx6ull_eeprom_write_to_eeprom(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { struct mx6ull_eeprom *eeprom = file->private_data; int ret; if (*ppos + count > 256) return -EINVAL; if (copy_from_user(eeprom->buffer, buf, count)) return -EFAULT; mutex_lock(&eeprom->client->dev.mutex); ret = mx6ull_eeprom_write(eeprom->client, *ppos, eeprom->buffer, count); if (ret == 0) *ppos += count; mutex_unlock(&eeprom->client->dev.mutex); return ret; } /* MX6ULL 24C02 EEPROM 驱动文件操作结构体 */ static const struct file_operations mx6ull_eeprom_fops = { .owner = THIS_MODULE, .read = mx6ull_eeprom_read_from_eeprom, .write = mx6ull_eeprom_write_to_eeprom, }; /* MX6ULL 24C02 EEPROM 驱动设备树匹配列表 */ static const struct of_device_id mx6ull_eeprom_of_match[] = { { .compatible = "fsl,imx6ull-eeprom", }, {}, }; MODULE_DEVICE_TABLE(of, mx6ull_eeprom_of_match); /* MX6ULL 24C02 EEPROM 驱动 I2C 设备 ID 列表 */ static const struct i2c_device_id mx6ull_eeprom_id[] = { { "mx6ull-eeprom", 0 }, {}, }; MODULE_DEVICE_TABLE(i2c, mx6ull_eeprom_id); /* MX6ULL 24C02 EEPROM 驱动匹配函数 */ static int mx6ull_eeprom_driver_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mx6ull_eeprom *eeprom; struct device *dev; int ret; /* 分配 MX6ULL 24C02 EEPROM 驱动数据结构体 */ eeprom = devm_kzalloc(&client->dev, sizeof(struct mx6ull_eeprom), GFP_KERNEL); if (!eeprom) return -ENOMEM; /* 初始化 MX6ULL 24C02 EEPROM 驱动数据结构体 */ eeprom->client = client; eeprom->buffer = kmalloc(EEPROM_PAGE_SIZE, GFP_KERNEL); if (!eeprom->buffer) return -ENOMEM; /* 注册 MX6ULL 24C02 EEPROM 驱动文件节点 */ dev = &client->dev; if (!devm_create_file(dev, &dev_attr_eeprom)) { dev_err(dev, "failed to create sysfs entry\n"); return -ENOMEM; } /* 注册 MX6ULL 24C02 EEPROM 驱动文件操作结构体 */ ret = alloc_chrdev_region(&eeprom->devno, 0, 1, "mx6ull-eeprom"); if (ret < 0) return ret; cdev_init(&eeprom->cdev, &mx6ull_eeprom_fops); eeprom->cdev.owner = THIS_MODULE; ret = cdev_add(&eeprom->cdev, eeprom->devno, 1); if (ret < 0) goto out_unregister_region; device_create(mx6ull_eeprom_class, NULL, eeprom->devno, NULL, "mx6ull-eeprom"); i2c_set_clientdata(client, eeprom); return 0; out_unregister_region: unregister_chrdev_region(eeprom->devno, 1); return ret; } /* MX6ULL 24C02 EEPROM 驱动移除函数 */ static int mx6ull_eeprom_driver_remove(struct i2c_client *client) { struct mx6ull_eeprom *eeprom = i2c_get_clientdata(client); device_destroy(mx6ull_eeprom_class, eeprom->devno); cdev_del(&eeprom->cdev); unregister_chrdev_region(eeprom->devno, 1); kfree(eeprom->buffer); return 0; } /* MX6ULL 24C02 EEPROM 驱动 I2C 设备结构体 */ static struct i2c_driver mx6ull_eeprom_driver = { .driver = { .name = "mx6ull-eeprom", .of_match_table = mx6ull_eeprom_of_match, }, .probe = mx6ull_eeprom_driver_probe, .remove = mx6ull_eeprom_driver_remove, .id_table = mx6ull_eeprom_id, }; module_i2c_driver(mx6ull_eeprom_driver); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Your Name"); MODULE_DESCRIPTION("MX6ULL 24C02 EEPROM Driver"); ``` 当然，以上代码只是一个简单的框架，具体的实现还需要根据具体的硬件平台和 24C02 EEPROM 来进行相应的修改和实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿龙还在写代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值