分享一个char驱动的实例

一、程序代码

基于缓冲区的char驱动例子

=============================

char_test01.c

该例子支持单缓冲区，支持ioctl
ioctl命令需要写用户态的测试程序buf01.c

=========================================================

/**************************

 * char驱动的测试例子1

 * 驱动采用内核的缓冲区作为设备，用户态可以用echo或cat读写设备文件，字符串存储在缓冲区中；

 * 本驱动支持一个缓冲区硬件

 * 用户态可以通过read/write/ioctl来访问设备

 * Author: yhd

 * Date: 2016-05-11

 **************************/

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/uaccess.h> //copy_to_user

#include <linux/cdev.h> //cdev，用于注册

#include <linux/proc_fs.h>

//定义硬件需要的信息

//为了保证驱动选择的设备号唯一，驱动应选一个没人用的主设备号，可以让内核帮助选一个，还可以查看文件/proc/devices，找一个没人用的

#define DEF_MAJOR    50

#define DEF_SIZE    100

//定义ioctl命令号(32位)

//#define MEM_RESET    101    //清空缓冲区

//#define MEM_RESIZE    102    //设置缓冲区大小

#define MEM_TYPE    'M'

#define MEM_RESET    _IO(MEM_TYPE, 1)

#define MEM_RESIZE    _IOW(MEM_TYPE, 2, int)

//如果一个驱动支持多个硬件，每个硬件都会有自己的信息，包括各自的地址，设备号等；

//驱动应该定义一个私有结构体，用于存储每个硬件各自的数据

//如果驱动只支持一个硬件，则可以不必定义

struct mem_priv {

    char *start;  //缓冲区的基地址

    int buf_size; //缓冲区的大小

    int wp;          //缓冲区的写偏移

    dev_t dev_id; //设备号

    struct cdev mem_cdev; //用于向VFS注册

};

//定义私有结构体的全局变量

static struct mem_priv dev;

//定义char驱动的各个操作函数

//当用户态open文件时调用

//需要分析一下设备有哪些操作必须在open中完成，如果没有，直接返回0

static int

mem_open(struct inode *inode, struct file *filp)

{

    return 0;

}

//当用户态close文件时调用

//完成的工作和open相反

static int

mem_release(struct inode *inode, struct file *filp)

{

    return 0;

}

//当用户态read时调用，返回缓冲区的内容。如：

//ret = read(fd, buf, 10);

//内核的read函数增加了一个参数，用于获取或设置文件内部的偏移

static ssize_t

mem_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)

{

    size_t cnt = min(count, (size_t)(dev.wp-*f_pos));

    if (0==cnt)

        return 0;

    //copy_to_user(to,from,cnt)

    if (copy_to_user(buf,dev.start+*f_pos,cnt))

        return -EFAULT;

    //更新读指针f_pos

    *f_pos += cnt;

    return cnt;

}

//当用户态write时调用，将数据写入缓冲区。如：

//ret = write(fd, "hello", 5);

static ssize_t

mem_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)

{

    size_t cnt = min(count, (size_t)(dev.buf_size-dev.wp));

    if (0 == cnt)

        return 0;

    //copy_from_user(to,from,cnt)

    if (copy_from_user(dev.start+dev.wp,buf,cnt))

        return -EFAULT;

    //更新wp

    dev.wp += cnt;

    return cnt;

}

//当用户态用ioctl向设备发命令时调用

//ret = ioctl(fd, 命令号);

//ret = ioctl(fd, 命令号, 命令参数);

static long

mem_ioctl(struct file *filp, unsigned int req, unsigned long arg)

{

    char *tmp;

    switch (req) {

    case MEM_RESET:

        memset(dev.start, 0, dev.buf_size);

        dev.wp = 0;

        break;

    case MEM_RESIZE: //释放旧缓冲区，分配新的

        tmp = (char *)kzalloc(arg, GFP_KERNEL);

        if (!tmp)

            return -ENOMEM;

        dev.buf_size = arg;

        dev.wp = 0;

        kfree(dev.start);

        dev.start = tmp;

        break;

    default:

        printk("Cannot support ioctl %#x\n", req);

        return -1;

    }

    return 0;

}

//声明并初始化file_operations

static struct file_operations mem_fops = {

    .owner = THIS_MODULE,

    .open = mem_open,

    .release = mem_release,

    .read = mem_read,

    .write = mem_write,

    .unlocked_ioctl = mem_ioctl,

};

static int __init my_init(void)

{

    //1.分配并初始化缓冲区

    dev.buf_size = DEF_SIZE;

    dev.start = (char *)kzalloc(dev.buf_size, GFP_KERNEL);

    if (!dev.start)

        return -ENOMEM;

    dev.wp = 0;

    //2.分配设备号（MAJOR+MINOR）

    dev.dev_id = MKDEV(DEF_MAJOR, 0);

    //3.将选好的设备号和file_ops一起注册到VFS

    //将信息封装到cdev结构体中，然后注册

    cdev_init(&dev.mem_cdev, &mem_fops);

    cdev_add(&dev.mem_cdev, dev.dev_id, 1);

    return 0;

}

static void __exit my_exit(void)

{

    cdev_del(&dev.mem_cdev);

    kfree(dev.start);

}

module_init(my_init);

module_exit(my_exit);

MODULE_AUTHOR("YHD");

MODULE_LICENSE("GPL");

===========

makefile

obj-m:=char_test01.o

KERNELDIR:=/lib/modules/3.19.0-25-generic/build    

PWD:=$(shell pwd)

modules:                                                                                         

    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:

    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install

===========

二、测试验证

============================================================

/***********************

 * 用户态的测试例子

 * $>./user01 /dev/abc0 reset|resize 1000

 * 可以对缓冲区执行reset或resize命令

 * Author: zht

 * Date: 2016-05-11

 ***********************/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

//命令号应该来自于驱动

#define MEM_TYPE    'M'

#define MEM_RESET    _IO(MEM_TYPE, 1)

#define MEM_RESIZE    _IOW(MEM_TYPE, 2, int)

int main(void)

{

    int fd, value, ret;

    char buf[100];

    //2.打开设备文件

    fd = open("/dev/yhd", O_RDWR);

    if (fd<0) {

        printf("Open /dev/yhd error\n");

        exit(1);

    }

    ret = ioctl(fd, MEM_RESET);

    if(ret < 0 )

    {

        printf("itcol error\n");

        exit(1);

        

    }

    ret = write(fd,"hello",5);

    if(ret <0)

    {

        printf("write error\n");

        exit(1);

    }

    //sleep(3);

    ret = write(fd,"asdfg",5);

    if(ret <0)

    {

        printf("write error\n");

        exit(1);

    }

    //ret = ioctl(fd, MEM_RESET);

    ret = read(fd,buf,15);

    if(ret <0)

    {

        printf("write error\n");

        exit(1);

    }

    printf("buf=%s\n",buf);

   close(fd);

    return 0;

}

============================================

需要在dev下创建

mknod  /dev/yhd c 50 0 

生成设备节点，测试两次write 后 ，read buf，看看是否fops×是否可以自动记录

测试结果

buf=helloasdfg