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

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 //模块加载卸载函数
#include //内核头文件
#include //数据类型定义
#include //file_operations结构体
#include //class_create等函数
#include 
#include /*包含printk等操作函数*/
#include /*设备树操作相关的函数*/
#include /*gpio接口函数*/
#include 
#include /*platform device*/
#include  /*i2c相关api*/
#include  /*内核延时函数*/
#include  /*kmalloc、kfree函数*/
#include /*cdev_init cdev_add等函数*/
#include /*gpio接口函数*/
#include /*__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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include

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 //卸载驱动模块