linux驱动开发之i2c从设备驱动at24c02的编程

你的名字 2022-05-31 00:50 361阅读 0赞

编译从设备驱动编程的前奏：  
１，　将i2c core层和i2c adapter控制器层编译进内核  
make menuconfig  
Device Drivers —>  
<\*> I2C support —> // i2c-core.c  
I2C Hardware Bus support —>  
<\*> S3C2410 I2C Driver // i2c-adatper的驱动–i2c-s3c2410.c  
2， 为创建i2c client提供信息，内核就会根据信息自动创建i2c client  
在ubuntu中进入linux内核文件路径（/home/ubuntu/s5pv210/kernel/linux-3.0.8），vim arch/arm/mach-s5pv210/mach-smdkv210.c ，修改里面内容

//根据硬件原理图，将i2c client的信息填入到对应的数组
        // 硬件连接在第几个总线上，就填入对应的数组
            static struct i2c_board_info smdkv210_i2c_devs0[] __initdata = {
                { I2C_BOARD_INFO("at240c2", 0x50), // 参数1--表示用于和i2c driver进行匹配的名字--自定义--需要记住
                                                  //参数2--从设备地址--7bit--从芯片手册查询得到
                    // .type = "24c08", .addr = 0x50
                },     /* Samsung S524AD0XD1 */
                { I2C_BOARD_INFO("wm8580", 0x1b), },
            };
    
            static struct i2c_board_info smdkv210_i2c_devs1[] __initdata = {
                /* To Be Updated */
            };
    
            static struct i2c_board_info smdkv210_i2c_devs2[] __initdata = {
                /* To Be Updated */
                { I2C_BOARD_INFO("test", 0x2b), }, //这个用于测试---实际没有这个硬件
            };
    
        smdkv210_machine_init(void)//该函数在开机就自动执行
            |
            i2c_register_board_info(0, smdkv210_i2c_devs0,ARRAY_SIZE(smdkv210_i2c_devs0));
            i2c_register_board_info(1, smdkv210_i2c_devs1,ARRAY_SIZE(smdkv210_i2c_devs1));
            i2c_register_board_info(2, smdkv210_i2c_devs2,ARRAY_SIZE(smdkv210_i2c_devs2));

3.重新编译内核：make zImage  
4.更新内核：cp -raf arch/arm/boot/zImage /tftpboot/  
5.重启开发板，  
\[root@farsight devices\]\# pwd  
/sys/bus/i2c/devices  
\[root@farsight devices\]\# ls  
0-001b 0-0050 i2c-0 i2c-1 i2c-2  
\[root@farsight 0-0050\]\# pwd  
/sys/bus/i2c/devices/0-0050  
\[root@farsight 0-0050\]\# cat name  
at240c2

接下来编写i2c driver的驱动代码—at24c02驱动  
构建i2c\_driver，注册到总线中：  
|  
—probe(\*i2c\_client)  
|  
0, 记录匹配之后的i2c client  
1,申请主设备号  
2，创建设备节点  
3，实现fops  
4,根据实际情况去初始化从设备硬件

**驱动中涉及到的各种结构体：**

//描述了一个从设备的操作方法
    struct i2c_driver 
    {
        /* Standard driver model interfaces */
        int (*probe)(struct i2c_client *, const struct i2c_device_id *);
        int (*remove)(struct i2c_client *);
        struct device_driver driver;            //父类
        const struct i2c_device_id *id_table;   //用于和i2c client进行匹配的名字列表
    
    }
    //描述了一个从设备的信息---从设备地址，名字
    struct i2c_client { 
        unsigned short addr;            //7bit--从设备地址
        char name[I2C_NAME_SIZE];       //名字
        struct i2c_adapter *adapter;    // 指向创建自己的adapter
        struct i2c_driver *driver;      //指向匹配成功之后的i2c driver
        struct device dev;              //父类
    
    };
    //描述控制器， 比如编号，算法
    struct i2c_adapter { 
    
        const struct i2c_algorithm *algo; /* the algorithm to access the bus */
                            |
                            int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num);
        struct device dev;  //父类
    
        int nr;             //编号
        char name[48];
    
    };
    
    //传输的数据包 
    struct i2c_msg { 
        __u16 addr;  //数据包传输給那个从设备
        __u16 flags;//读还是写-- 1读，0写
        __u16 len;      /* msg length */
        __u8 *buf;      /* pointer to msg data */
    };
    
    
    i2c 子系统提供读写从设备的接口：
    
        i2c_master_recv(const struct i2c_client * client, char * buf, int count)
        i2c_master_send(const struct i2c_client * client, const char * buf, int count)
            |
            //重点学会用i2c_transfer
            int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

从设备驱动at24c02的程序：at24\_e2prom\_i2c\_drv.c

#include <linux/init.h>
    #include <linux/module.h>
    #include <linux/i2c.h>
    #include <linux/miscdevice.h>
    #include <linux/slab.h>
    #include <linux/fs.h>
    
    #include <asm/uaccess.h>
    
    //设计一个驱动针对不同的设备的不同数据(私有)
    struct e2prom_private{
        char *name; //描述
        int size;   //容量
        int version;//版本
    };
    
    int at24_i2c_e2prom_open (struct inode *inode, struct file *filp)
    {
        printk("------%s--------\n", __FUNCTION__);
        //一般也是做初始化
    
        return 0;
    }
    
    //设计一个全局的设备对象
    struct i2c_e2prom_global{
        struct i2c_client *client;//描述了一个从设备的信息---从设备地址，名字
        struct e2prom_private *private;
        struct miscdevice i2c_misc;
    };
    
    
    
    //全局的指针
    struct i2c_e2prom_global *at24_dev;
    
    //i2c_master_recv(const struct i2c_client * client, char * buf, int count);
    int at24_i2c_recv(const struct i2c_client * client, char * buf, int count)
    {
        int ret;
        struct i2c_adapter *adapter = client->adapter;//描述控制器， 比如编号，算法
    
        struct i2c_msg msg;//传输的数据包 
    
        msg.addr = client->addr;//数据包传输給哪个从设备
        msg.flags = I2C_M_RD; //读还是写-- 1读，0写
        msg.len = count;//数据大小bytes
        msg.buf = buf;
    
        //参数1--适配器，来自于client
        //参数2--传输的消息体--数据包
        //参数3--消息体的个数
        //返回值--正确为消息的个数，错误为负数
        //i2c_transfer(struct i2c_adapter * adap, struct i2c_msg * msgs, int num)
        ret = i2c_transfer(adapter,  &msg,  1);
    
        return ret==1?count:ret;
    
    }
    
    //重写类似于i2c_master_send/i2c_master_recv的方法
    int at24_i2c_send(struct i2c_client *client,char *buf, int count)
    {
        int ret;
        //i2c_adapter描述控制器，比如编号，算法
        struct i2c_adapter *adapter = client->adapter;
    
        struct i2c_msg msg;
        msg.addr = client->addr;
        msg.buf = buf;
        msg.flags = 0;
        msg.len = count;
    
        //参数1--适配器，来自于client
        //参数2--传输的消息体--数据包
        //参数3--消息体的个数
        ret = i2c_transfer(adapter, &msg, 1);
    
        return ret==1?count:ret;
    }
    
    ssize_t at24_i2c_e2prom_read (struct file *filp, char __user *buf, size_t count, loff_t *fops)
    {
        printk("------%s--------\n", __FUNCTION__);
        int ret;
    
        //简单的参数判断
        if(count <0 || count > at24_dev->private->size)
            return -EINVAL;
    
        //动态的分配一个空间，用于存放从硬件获取到的数据
        char *temp = kzalloc(count, GFP_KERNEL);
    
        //i2c_master_recv(const struct i2c_client * client, char * buf, int count);
        //i2c_master_send(const struct i2c_client * client, const char * buf, int count);
        // 1，从硬件中获取数据
        ret = at24_i2c_recv(at24_dev->client,  temp,  count);
        if(ret < 0)
        {
            printk("at24_i2c_recv error\n");
            goto err_free;
        }
    
    
        // 2， 将数据传递给用户
        ret = copy_to_user(buf, temp, count);
        if(ret > 0)
            {
                printk("copy to user error\n");
                ret = -EFAULT;
                goto err_free;
    
            }
        kfree(temp);
    
        return count;
    err_free:
        kfree(temp);
        return ret;
    
    }
    
    ssize_t at24_i2c_e2prom_write (struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
    {
        printk("------%s--------\n", __FUNCTION__);
        int ret;
        //简单的参数判断
        if(count < 0 || count > at24_dev->private->size)
                return -EINVAL;
    
    
        //动态的分配一个空间
        char *temp = kzalloc(count, GFP_KERNEL);
    
        // 1,从用户空间得到数据
        ret = copy_from_user(temp, buf, count);
        if(ret > 0)
        {
            printk("copy_from_user error\n");
            ret = -EFAULT;
            goto err_free;
        }   
    
        // 2, 将数据写入到硬件
        ret =at24_i2c_send(at24_dev->client,  temp,  count);
        if(ret < 0)
        {
            printk("at24_i2c_send error\n");
            goto err_free;
        }
    
        kfree(temp);
    
        return count;
    
    err_free:
        kfree(temp);
        return ret;
    }
    
    
    
    int at24_i2c_e2prom_close (struct inode *inode, struct file *flip)
    {
        printk("------%s--------\n", __FUNCTION__);
        return 0;   
    }
    
    
    
    const struct file_operations at24_i2c_fops = {
        .open = at24_i2c_e2prom_open,
        .read = at24_i2c_e2prom_read,
        .write = at24_i2c_e2prom_write,
        .release = at24_i2c_e2prom_close,
    };
    
    int at24_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)//为什么是id
    {
        printk("-------%s-------\n",__FUNCTION__);
    
        printk("client name = %s\n", id->name);//
        struct e2prom_private *p = (struct e2prom_private *)id->driver_data;
    
        printk("name descriptoin : %s \n", p->name);
        printk("size : %d \n", p->size);
        printk("verison : 0x%x \n", p->version);
    
        at24_dev = kzalloc(sizeof(struct i2c_e2prom_global), GFP_KERNEL);//GFP_KERNEL
    
        //记录当前匹配之后的i2c client
        at24_dev->client = client;
        at24_dev->private = (struct e2prom_private *)id->driver_data;
    
        //实现fops
        at24_dev->i2c_misc.fops = &at24_i2c_fops;
        at24_dev->i2c_misc.minor = 199;           //MISC_DYNAMIC_MINOR,
        at24_dev->i2c_misc.name = "i2c_e2prom"; //指定设备节点的名字 /dev/i2c_e2prom
    
        //注册一个混杂设备驱动，函数里面已经封装了申请设备号，创建设备文件等过程
        misc_register(&at24_dev->i2c_misc);
    
        // 4,根据实际情况去初始化从设备硬件---at24 上电就可以工作
    
        return 0;
    
    }
    
    int at24_i2c_remove(struct i2c_client *client)
    {
        printk("------%s--------\n", __FUNCTION__);
        misc_deregister(&at24_dev->i2c_misc);
        kfree(at24_dev);
    
        return 0;
    }
    
    
    struct e2prom_private c02_private = {
        .name = "at240c02 in test LZH",
        .size = 256,
        .version = 0x1234,
    };
    
    struct e2prom_private c04_private = {
        .name = "at240c04 in test LZH",
        .size = 512,
        .version = 0x4444,
    };
    
    struct e2prom_private c08_private = {
        .name = "at240c08 in test LZH",
        .size = 2014,
        .version = 0x4321,
    };
    
    //名字必须与内核中的arch/arm/mach-s5pv210/mach-smdkv210.c中i2c_board_info结构体对应 
    const struct i2c_device_id at24_i2c_id_table[] = {
        {
       "at240c2",(unsigned long)&c02_private},//注意
        {
       "at240c4",(unsigned long)&c04_private},
        {
       "at240c8",(unsigned long)&c08_private},
    
    };
    
    //描述了一个从设备的操作方法
    struct i2c_driver at24_i2c_drv = {
        .probe = at24_i2c_probe,
        .remove = at24_i2c_remove,
        .driver = {                     //父类，一定要初始化
            .name = "at24_drv_LZH",     //该名字不会用于进行匹配#
        },                              //主要的作用是用来产生一个文件 /sys/bus/i2c/drivers/at24_drv
        .id_table = at24_i2c_id_table,  //用于和i2c client进行匹配的名字列表
    };
    
    static int __init at24_drv_init(void)
    {
        //注册一个i2c driver
        return i2c_add_driver(&at24_i2c_drv);
    
    }
    
    static void __exit at24_drv_exit(void)
    {
        i2c_del_driver(&at24_i2c_drv);
    }
    
    module_init(at24_drv_init);
    module_exit(at24_drv_exit);
    
    MODULE_LICENSE("GPL");

应用程序：at24\_app.c

#include <linux/i2c-dev.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/ioctl.h>
    #include <fcntl.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    #define I2C_SLAVE 0x0703
    
    void print_usage(char *str)
    {
        printf("%s r : read at24c02 addresss 0\n", str);
        printf("%s w val : write at24c02 addresss 0\n", str);
    }
    
    int main(int argc,char **argv)
    {
        int fd;
        unsigned char val;//字节
    
        char register_addr = 0x08; /* Device register to access 片内地址*/
        int  res;
        char wbuf[10];
        char rbuf[10];
    
        if (argc < 2)
        {
            print_usage(argv[0]);
            exit(1);
        }
    
        /*打开设备文件*/
        fd = open("/dev/i2c_e2prom", O_RDWR);
        if (fd < 0) 
        {
            perror("open failed");
            exit(1);
        }
        if (strcmp(argv[1], "r") == 0)
        {
            if (write(fd, &register_addr, 1)!=1) 
            {
                perror("write failed");
                exit(1);
            }
    
            if (read(fd, rbuf, 5) != 5)
            {
                perror("read failed");
                exit(1);
            } else {
                printf("rbuf[%d] =0x%x\n",0,rbuf[0]);
                printf("rbuf[%d] =0x%x\n",1,rbuf[1]);
                printf("rbuf[%d] =0x%x\n",2,rbuf[2]);
                printf("rbuf[%d] =0x%x\n",3,rbuf[3]);
                printf("rbuf[%d] =0x%x\n",4,rbuf[4]);
    
            }   
    
        }
        else if ((strcmp(argv[1], "w") == 0) && (argc == 3))
        {
            // ./test w 0x99
            val = strtoul(argv[2], NULL, 0);        
    
            wbuf[0] = register_addr; // 片内地址0x08
            wbuf[1] = val;
            wbuf[2] = 0x2b;
            wbuf[3] = 0x3b;
            wbuf[4] = 0x4b;
            wbuf[5] = 0x5b;
    
            if (write(fd, wbuf, 6)!=6) 
            {
                perror("write failed");
                exit(1);
            }             
            printf("write data ok!\n");
    
        }
    
        close(fd);
        return 0;
    }

**在s5pv210开发板上运行的**

![这里写图片描述][SouthEast]  
![这里写图片描述][SouthEast 1]  
并且写入的数据，掉电不丢失。（因为存储到e2prom里面）  
程序文件夹：链接：[https://pan.baidu.com/s/1mjFLjoW][https_pan.baidu.com_s_1mjFLjoW] 密码：5kzf

[SouthEast]: /images/20220531/93cd8ff160bf43e9accecc298e3d7382.png
[SouthEast 1]: /images/20220531/7e6801a33c7149d1b6ab47c337e0a5f3.png
[https_pan.baidu.com_s_1mjFLjoW]: https://pan.baidu.com/s/1mjFLjoW