firefly-rk3288j开发板–linux I2C实验之eeprom驱动

1 准备工作

开发板：aio-rk3288j
SDK版本：rk3288_linux_release_20210304
下载工具：Linux_Upgrade_Tool_v2.1
内核版本：4.4.194
文件系统：buildroot
Ubuntu版本：18.04
交叉编译工具：gcc version 6.3.1 20170404

2 硬件原理图

2.1 开发板I2C接口

2.2 EEPROM模块原理图

3 修改设备树文件

3.1 驱动参数配置

I2C 的参数配置最主要就是 I2C 频率的配置，可配 I2C frequency 除了与芯片有关外，主要是由 I2C SCL rise time 决定的，因为 I2C 协议标准里面对上升沿和下降沿时间有规定要求特别是上升沿时间，如果超过了协议规定的最大值，则 I2C 通讯可能失败，下面是协议里面规定的最大最小值范围，下图表示了二者之间的关系：

上升沿 Tr 和下降沿 Tf，需要用示波器测量，参考下面示图：

3.2 配置DTS

设备树文件位于内核kernel/arch/arm/boot/dts目录下，我们需要打开rk3288.dtsi、rk3288-linux.dtsi、rk3288-firefly-port.dtsi、rk3288-firefly-aio.dtsi.对于i2c设备只需要打开rk3288-firefly-aio.dtsi文件，添加i2c4设备节点：

&i2c4 {status = "okay";//i2c-scl-rising-time-ns = <400>;//i2c-scl-falling-time-ns = <20>;clock-frequency = <100000>;at24c64: at24c64@50 {compatible = "firefly,24c64";reg = <0x50>;};
};

clock-frequency：默认 frequency 为 100k 可不配置，其它 I2C 频率需要配置，最大可配置频率由 i2c- scl-rising-time-ns 决定；例如配置 400k，clock-frequency=<400000>。
i2c-scl-rising-time-ns：SCL 上升沿时间由硬件决定，改变上拉电阻可调节该时间，需通过示波器量测，参考上图；例如测得 SCL 上升沿 400ns，i2c-scl-rising-time-ns=<400>。(默认可以不配置，但必须保证当前的上升沿时间不能超过所配置频率下的 I2C 标准所定义的最大上升沿时间)
i2c-scl-falling-time-ns: SCL 下降沿时间, 一般不变, 等同于 i2c-sda-falling-time-ns。(默认也可以不配置）
编译内核，输入如下命令
./build.sh kernel
./build.sh updateimg

4 API函数

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
int i2c_master_recv(const struct i2c_client *client, char *buf, int count)

5 AT24C64驱动编写

#include <linux/module.h>//模块加载卸载函数
#include <linux/kernel.h>//内核头文件
#include <linux/types.h>//数据类型定义
#include <linux/fs.h>//file_operations结构体
#include <linux/device.h>//class_create等函数
#include <linux/ioctl.h>
#include <linux/kernel.h>/*包含printk等操作函数*/
#include <linux/of.h>/*设备树操作相关的函数*/
#include <linux/gpio.h>/*gpio接口函数*/
#include <linux/of_gpio.h>
#include <linux/platform_device.h>/*platform device*/
#include <linux/i2c.h> /*i2c相关api*/
#include <linux/delay.h> /*内核延时函数*/
#include <linux/slab.h> /*kmalloc、kfree函数*/
#include <linux/cdev.h>/*cdev_init cdev_add等函数*/
#include <asm/gpio.h>/*gpio接口函数*/
#include <asm/uaccess.h>/*__copy_from_user 接口函数*/#define  DEVICE_NAME     "eeprom"
#define  DEVICE_SIZE     256  typedef struct
{struct device_node *node;//设备树节点struct cdev cdev;//定义一个cdev结构体struct class *class;//创建一个at24cxx类struct device *device;//创建一个at24cxx设备 该设备是需要挂在at24cxx类下面的int major;//主设备号dev_t  dev_id;struct i2c_client   *client; /*适配器 probe函数中会填充此变量*//*使用SMBUS协议方式读写*/int use_smbus;int use_smbus_write;struct mutex lock;
}at24xx_typdef;static at24xx_typdef at24cxx_dev;//定义一个AT24Cxx设备
static unsigned char io_limit = 128; /*一次最多读取128字节*/
static unsigned char write_timeout = 25;/*i2c通信超时时间*/
static unsigned char at24cxx_page_size = 8;/*at24cxx 每页8字节*/static ssize_t at24_eeprom_read(at24xx_typdef *at24, char *buf,unsigned offset, size_t count)
{struct i2c_msg msg[2];u8 msgbuf[2];struct i2c_client *client;unsigned long timeout, read_time;int status, i;memset(msg, 0, sizeof(msg));/*获取设备信息*/client = at24->client;if (count > io_limit)count = io_limit;if (at24->use_smbus) {/* Smaller eeproms can work given some SMBus extension calls */if (count > I2C_SMBUS_BLOCK_MAX)count = I2C_SMBUS_BLOCK_MAX;} else {i = 0;msgbuf[i++] = offset;/*读取首地址*//* msg[0]为发送要读取的首地址 */msg[0].addr = client->addr;msg[0].buf = msgbuf;msg[0].len = i;/* msg[1]读取数据 */msg[1].addr = client->addr;msg[1].flags = I2C_M_RD;msg[1].buf = buf;        /* 读取数据缓冲区*/msg[1].len = count;      /* 读取数据长度 */}/*超时时间设置为write_timeout毫秒*/timeout = jiffies + msecs_to_jiffies(write_timeout);do {read_time = jiffies;if (at24->use_smbus) /*使用SMBUS协议*/{status = i2c_smbus_read_i2c_block_data_or_emulated(client, offset,count, buf);} else /*普通I2C协议*/{status = i2c_transfer(client->adapter, msg, 2);if (status == 2)status = count;}if (status == count)return count;/* REVISIT: at HZ=100, this is sloooow */msleep(1);} while (time_before(read_time, timeout));   return -ETIMEDOUT;
}static ssize_t at24_eeprom_write(at24xx_typdef *at24,  char *buf,unsigned offset, size_t count)
{struct i2c_client *client;struct i2c_msg msg;ssize_t status = 0;unsigned long timeout, write_time;int i = 0;/*获取设备信息*/client = at24->client;/* 最大写入数据是1页 */if (count > at24cxx_page_size)count = at24cxx_page_size;/*msg.buf申请内存*/msg.buf = kmalloc(count+2,GFP_KERNEL);if(!msg.buf)return -ENOMEM;/* 不使用SMBUS协议  需要填充msg */if (!at24->use_smbus) {msg.addr = client->addr;msg.flags = 0;           /*标记为写数据*/msg.buf[i++] = offset;   /*写的起始地址*/memcpy(&msg.buf[i], buf, count);msg.len = i + count;     /*写数据的长度*/}timeout = jiffies + msecs_to_jiffies(write_timeout);do {write_time = jiffies;if (at24->use_smbus_write) {switch (at24->use_smbus_write) {case I2C_SMBUS_I2C_BLOCK_DATA:status = i2c_smbus_write_i2c_block_data(client,offset, count, buf);break;case I2C_SMBUS_BYTE_DATA:status = i2c_smbus_write_byte_data(client,offset, buf[0]);break;}if (status == 0)status = count;} else {status = i2c_transfer(client->adapter, &msg, 1);if (status == 1)status = count;}if (status == count){kfree(msg.buf);return count;}               /* REVISIT: at HZ=100, this is sloooow */msleep(1);} while (time_before(write_time, timeout));kfree(msg.buf);return -ETIMEDOUT;
}static int at24cxx_open(struct inode *inode, struct file *filp)
{/*使用普通I2C模式读写*/  at24cxx_dev.use_smbus = 0;at24cxx_dev.use_smbus_write = 0; filp->private_data = &at24cxx_dev;  printk("open at24cxx success\n");return 0;
}static int at24cxx_release(struct inode* inode ,struct file *filp)
{return 0;
}static int at24cxx_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{   int ret = -EINVAL;char *buffer;/*缓冲区*/unsigned char pages;/*页数*/unsigned char num;/*不足一页剩下的字节数*/unsigned char pos = filp->f_pos;/*写入的地址*/int i = 0; at24xx_typdef *dev = (at24xx_typdef *)filp->private_data;printk("w_count = %d w_pos = %d\n",count,pos);buffer =(char *)kmalloc(count,GFP_KERNEL);if (!buffer)return -ENOMEM;pages = count / at24cxx_page_size;num = count % at24cxx_page_size;/*将需要写入的数据拷贝到内核空间的缓冲区*/ret = copy_from_user((void *)buffer,buf,count);mutex_lock(&dev->lock);for(i = 0; i < pages; i++){ret = at24_eeprom_write(dev,&buffer[i*at24cxx_page_size],pos,at24cxx_page_size);if(ret < 0) {printk("at24cxx write error\n");kfree(buffer);return ret;}pos += 8;}if(num){   ret = at24_eeprom_write(dev,&buffer[i*at24cxx_page_size],pos,num);if(ret < 0) {printk("at24cxx write error\n");kfree(buffer);return ret;}}   mutex_unlock(&dev->lock);    /*释放缓冲区内存*/kfree(buffer);return 0;
}static ssize_t at24cxx_read(struct file *filp,char __user *buf, size_t count,loff_t *f_pos)
{int ret = -EINVAL;char *buffer;/*数据缓存区*/unsigned char pos = filp->f_pos; /*读取位置*/at24xx_typdef *dev = (at24xx_typdef *)filp->private_data;  printk("r_count = %d  r_pos = %d\n",count,pos);buffer =(char *)kmalloc(count,GFP_KERNEL);if(!buffer)return -ENOMEM;mutex_lock(&dev->lock);ret = at24_eeprom_read(dev,buffer,pos,count);if(ret < 0 ){printk("at24cxx read error\n");kfree(buffer);return ret;}/*将读取到的数据返回用户层*/ret = copy_to_user(buf,(void *)buffer,ret);mutex_unlock(&dev->lock);/*释放缓冲区内存*/kfree(buffer);return 0;
}loff_t at24cxx_llseek(struct file *file, loff_t offset, int whence)
{loff_t ret,pos,oldpos;oldpos = file->f_pos;switch (whence) {case SEEK_SET:pos = offset; break;case SEEK_CUR:pos = oldpos + offset;break;case SEEK_END:pos = DEVICE_SIZE - offset;break;  default:printk("cmd not supported\n");break;}if(pos < 0 || pos > DEVICE_SIZE){   printk("error: pos > DEVICE_SIZE !\n");ret = -EINVAL;return ret;}file->f_pos = pos;ret = offset;   return ret;
}static struct file_operations at24cxx_fops={.owner      = THIS_MODULE,.open       = at24cxx_open,.write      = at24cxx_write,.read       = at24cxx_read,.release    = at24cxx_release,.llseek      = at24cxx_llseek,
};static int at24cxx_probe(struct i2c_client *client,const struct i2c_device_id *id)
{int ret = -1;const char *string = NULL;at24xx_typdef *dev = &at24cxx_dev;printk("at24cxx probe!\n"); /*获取设备节点*/at24cxx_dev.node = of_find_node_by_path("/i2c@ff160000/at24c64@50");if(at24cxx_dev.node == NULL){printk("find node by path fialed!\r\n"); return -1;}/*读取at24cxx设备节点的compatible属性值*/ret = of_property_read_string(at24cxx_dev.node,"compatible",&string);if(ret == 0){printk("%s\n",string);}/*申请设备号*/alloc_chrdev_region(&at24cxx_dev.dev_id,0,1,DEVICE_NAME);/*初始化一个cdev*/cdev_init(&at24cxx_dev.cdev,&at24cxx_fops);/*向cdev中添加一个设备*/cdev_add(&at24cxx_dev.cdev,at24cxx_dev.dev_id,1);/*创建一个eeprom_class类*/at24cxx_dev.class = class_create(THIS_MODULE, "eeprom_class");if(at24cxx_dev.class == NULL){printk("class_create failed\r\n");return -1;}/*在eeprom_class类下创建一个eeprom_class设备*/at24cxx_dev.device = device_create(at24cxx_dev.class, NULL, at24cxx_dev.dev_id, NULL, DEVICE_NAME);/*每个设备都会分配一个client*/at24cxx_dev.client = client;printk("slave address is %x\n",client->addr);mutex_init(&dev->lock);return  0;
}static int at24cxx_remove(struct i2c_client *client)
{  printk("at24cxx remove!\n"); /*删除at24cxx类*/cdev_del(&at24cxx_dev.cdev);/*释放at24cxx设备号*/unregister_chrdev_region(at24cxx_dev.dev_id, 1);/*注销at24cxx设备*/device_destroy(at24cxx_dev.class, at24cxx_dev.dev_id);/*注销at24cxx类*/class_destroy(at24cxx_dev.class);return 0;
}static const struct of_device_id at24cxx_of_match[] = {{.compatible = "firefly,24c64"},{},
};static const struct i2c_device_id at24cxx_id[] = {{ "xxxx", 0 },{},
};static struct i2c_driver at24cxx_driver = {.driver = {.owner = THIS_MODULE,.name = "firefly,24c64",.of_match_table = at24cxx_of_match,},.probe = at24cxx_probe,.remove  = at24cxx_remove,  .id_table    = at24cxx_id,
};static int __init at24cxx_init(void)
{return i2c_add_driver(&at24cxx_driver);
}static void at24cxx_exit(void)
{i2c_del_driver(&at24cxx_driver);printk("module exit ok\n");
}module_init(at24cxx_init);
module_exit(at24cxx_exit);MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("at24cxx driver");
MODULE_AUTHOR("lsjml2022");

6 编写测试App

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <limits.h>
#include <asm/ioctls.h>
#include <time.h>
#include <pthread.h>
#include<string.h>void print_data(const char *title, char *dat,int count)
{int i = 0; printf(title);for(i = 0; i < count; i++) {printf(" 0x%x", dat[i]);}printf("\n");
}int main(int argc, char *argv[])
{int fd,i,ret;int count = 128;char offset = 0;char writebuf[128],readbuf[128];/*判断传入的参数是否合法*/if(argc != 2){printf("Usage:error!\n");return -1;}/*解析传入的参数*/offset =atoi(argv[1]);printf("offset = %d\n",offset);/*打开设备文件*/fd = open("/dev/eeprom",O_RDWR);if(fd < 0){printf("open eeprom fail fd = %d\n",fd); close(fd);return fd;}/*缓存数组赋值*/memset(writebuf, 0xaa, sizeof(writebuf));/*写入数据*/ lseek(fd,offset, SEEK_SET);ret = write(fd, writebuf, sizeof(writebuf));if(ret < 0){printf("write to at24c64 error\n");close(fd);return ret;}/*打印数据*/print_data("write to at24c64:", writebuf, count);/*读取数据*/ret = lseek(fd,offset,SEEK_SET);printf("lseek = %d\n",ret);memset(readbuf, 0, sizeof(readbuf));ret = read(fd, readbuf,  count);if(ret < 0){printf("read from at24c64 error\n");close(fd);return ret;}/*打印数据*/print_data("read from at24c64:",readbuf,count);/*比较写入数据与读出数据是否一致*/ret = memcmp(readbuf, writebuf,  count);if(ret){printf("Writing data is different from reading data...\n");}else{printf("Write data is the same as read data...\n");}close(fd);return 0;
}

7 编译驱动程序和测试APP

7.1 编译驱动程序

KDIR:=/rk3288_linux/rk3288_linux_release_20220607/kernel
obj-m:=at24c64.o
PWD:=$(shell pwd)
all:$(MAKE) -C $(KDIR) M=$(PWD)
clean:rm -rf *.ko *.order *.symvers *.cmd *.o *.mod.c *.tmp_versions .*.cmd .tmp_versions

输入如下命令编译出驱动模块文件：
make -j8

编译成功后会生成一个.ko文件拷贝到开发板上并加载

7.2 编译测试App

输入如下命令编译测试 eepromApp.c 这个测试程序：
arm-linux-gnueabihf-gcc eepromApp.c -o eepromApp
编译成功以后就会生成 eepromApp 这个应用程序

7.3 运行测试

编译出来的.ko 和 eepromApp 这两个文件拷贝到/lib/modules/4.4.194目录中，重启开发板，进入目录/lib/modules/4.4.194中输入加载.ko驱动模块：
insmod at24c64.ko

驱动加载成功以后就可以使用eepromApp软件来测试驱动是否正常，输入如下命令：
./eepromApp /dev/eeprom

rmmod at24c64.ko //卸载驱动模块