4.2 字符设备驱动之 字符设备的注册(第二种注册字符设备的方法) ----编写访问内核缓存的设备驱动

demo.c

/* head file */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/slab.h>

#define DEVNAME "scull"//设备名:内存设备scull
#define CNT 200//创建次设备的数目

#define SZ 512

static unsigned int major = 0;
static unsigned int minor = 0;
static dev_t devnum;//定义字符设备名变量！是字符设备号吧！！！

struct scull_t { //定义对应字符设备的结构体
    char *kbuf;  /*指向用户要访问的内核空间的一块内存的地址*/
    size_t sz; //内核层数据大小
    struct cdev cdev;
}*sculls;   //struct scull_t *sculls;
    
static int mill_open (struct inode *inodp, struct file *filp)
{
    //求该字符设备的结构体的地址，用于一套驱动多个设备
    filp->private_data = container_of(inodp->i_cdev, struct scull_t, cdev);    
    
    return 0;
}

static ssize_t 
mill_read (struct file *filp, char __user *buf, size_t cnt, loff_t *fpos)
{
    struct scull_t *ptr = filp->private_data;//定义指向该结构体的一个指针
    
    if (cnt == 0) { //用户层传下来数据字节数为0
        return cnt;    //错误返回
    }    

    if (!ptr->sz) { //内核没有读到自己内存空间数据立即返回错误负值（无阻塞）
        return -EINVAL;
    }    

    cnt = min(cnt, ptr->sz);//得出用户层需要读取的数据字节数（比如512个字节）和内核实际字节数的最小值
    //读操作：将内核空间ptr->kbuf上的数据传递cnt（从用户层传下来的）个到用户层buf
    if (copy_to_user(buf, ptr->kbuf, cnt)) {
        return -EINVAL;
    }
    
    //后面挪到前面去读
    memmove(ptr->kbuf, ptr->kbuf + cnt, ptr->sz - cnt);
    ptr->sz -= cnt;//更新内核指定空间区域的数据字节数/每读一次减一次cnt个字节（比如512个字节）

    return cnt;//返回从内核读取的数据字节数
}

static ssize_t 
mill_write (struct file *filp, const char __user *buf, size_t cnt, loff_t *fpos)
{
    struct scull_t *ptr = filp->private_data;

    if (cnt == 0) { //从内核层传下来要写的数据字节数为0/不对了。。。
        return cnt;    //返回0个/错误返回
    }    

    if (ptr->sz == SZ) { //若内核层内存空间数据等于SZ，则满了，不能写了。。
        return -EINVAL;
    }    

    cnt = min(cnt, SZ- ptr->sz);//得出用户层需要写的数据字节数（比如512个字节）和内核实际字节数的最小值

    //写操作：从用户层传递数据到内核指定空间
    if  (copy_from_user(ptr->kbuf+ptr->sz, buf, cnt)) {
        return -EINVAL;
    }

    ptr->sz += cnt;//更新内核层内存空间数据字节数
    //ptr->sz = ptr->sz + cnt;

    return cnt;
}

static int mill_release (struct inode *inodp, struct file *filp)
{

    return 0;
}

static struct file_operations fops = { //驱动函数集
    .owner         = THIS_MODULE,    
    .open          = mill_open,
    .read          = mill_read,
    .write        = mill_write,
    .release    = mill_release,
};


/* driver module entry */
static int __init demo_init(void)
{
    int ret;
    int i;

    /*首先*/
    if (!major) {
        //第二种申请设备号方法：内核自动（动态）申请设备号
        ret = alloc_chrdev_region(&devnum, minor, CNT, DEVNAME);
        major = MAJOR(devnum);
    }else {
        devnum = MKDEV(major, minor);
        //注册字符设备驱动
        ret = register_chrdev_region(devnum, CNT, DEVNAME);
    }

    if (ret < 0) {
        return -EINVAL;
    }

    //给struct scull_t 申请空间
    sculls = kzalloc(CNT*sizeof(*sculls), GFP_KERNEL);
    if (NULL == sculls) {
        ret = -ENOMEM; //申请失败返回-ENOMEM
        goto error0;//跳到去执行移除字符设备驱动
    }

    /*其次*/
    //给每个次设备申请地址空间
    for (i = 0; i < CNT; ++i) {
        sculls[i].kbuf = kzalloc(SZ, GFP_KERNEL);
        if (NULL == sculls[i].kbuf) {
            ret = -ENOMEM;//申请失败返回-ENOMEM
            goto error1;//
        }

        cdev_init(&sculls[i].cdev, &fops);//字符设备次设备初始化
        ret = cdev_add(&sculls[i].cdev, devnum+i, CNT);//增加200个次设备/
        if (ret < 0) {
            kfree(sculls[i].kbuf);//最后释放一次第200个次设备的空间
            goto error1;
        }
    }    

    return 0;

error1:
    //释放所有199个次设备之前的空间
    while (i--) {
        kfree(sculls[i].kbuf);
        cdev_del(&sculls[i].cdev);//删除所有200个次设备
    }
    //释放大的struct scull_t 结构体之前的空间
    kfree(sculls);

error0: 
    //移除之前注册的字符设备驱动
    unregister_chrdev_region(devnum, CNT);
    
    return ret;
}

module_init(demo_init);

/* driver module exit */
static void __exit demo_exit(void)
{
    int i;
    //移除驱动模块时：释放所有次设备之前的空间
    for (i = 0; i < CNT; ++i) {
        kfree(sculls[i].kbuf);
        cdev_del(&sculls[i].cdev);
    }
    //释放大的struct scull_t 结构体之前的空间
    kfree(sculls);
    //移除之前注册的字符设备驱动
    unregister_chrdev_region(devnum, CNT);
}
module_exit(demo_exit);

/* driver module description */
MODULE_LICENSE("GPL");

MODULE_AUTHOR("millet9527");
MODULE_VERSION("millet plus 18");
MODULE_DESCRIPTION("example for driver module arch");

makefile

obj-m    := demo.o

KERNEL    := /linux-3.5

all:
    make -C $(KERNEL) M=`pwd`
clean:
    make -C $(KERNEL) M=`pwd` clean
    

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

write.c

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <assert.h>

#define LEN 512

int main(int argc, char **argv)
{
    int ret;

    if (argc !=  3) {
        fprintf(stderr, "Usage: %s devfile file\n", argv[0]);
        exit(1);
    }

    int fd_dev = open(argv[1], O_WRONLY | O_NDELAY);
    assert(fd_dev > 0);

    int fd_file = open(argv[2], O_RDONLY | O_NDELAY);
    assert(fd_file > 0);

    char buf[LEN];
    ret = read(fd_file, buf, LEN);//
    assert(ret > 0);

    ret = write(fd_dev, buf, ret);//写
    assert(ret >= 0);

    return 0;
}

read.c

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <assert.h>

#define LEN 512

int main(int argc, char **argv)
{
    int ret;

    if (argc !=  2) {
        fprintf(stderr, "Usage: %s devfile\n", argv[0]);
        exit(1);
    }

    int fd = open(argv[1], O_RDONLY | O_NDELAY);//非阻塞型读取方式
    assert(fd > 0);

    char buf[LEN];

    ret = read(fd, buf, LEN);//只读512个字节
    assert(fd > 0);

    buf[ret] = '\0';//读完了，读到的字节数据末尾加'\0'
    printf("%s\n", buf);

    return 0;
}

makefile

 CC=arm-linux-gcc