设备驱动中cdev(kernel-4.7)

linux系统将设备分为3类：字符设备、块设备、网络设备

1、字符设备：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。
2、块设备：是指可以从设备的任意位置读取一定长度数据的设备。块设备包括硬盘、磁盘、U盘和SD卡等。

每一个字符设备或块设备都在/dev目录下对应一个设备文件。
linux用户程序通过设备文件（或称设备节点）来使用驱动程序操作字符设备和块设备。

字符设备

字符设备的核心结构体是cdev，该结构体定义在include/linux/cdev.h中：

struct cdev {    struct kobject kobj;    // 内嵌的kobject对象     struct module *owner;    // 所属模块    const struct file_operations *ops;    // 文件操作结构体    struct list_head list;   //linux内核所维护的链表指针    dev_t dev;               //设备号    unsigned int count;    //设备数目};

其中dev_t是专为设备号定义的数据类型，dev为设备号，设备号中包含了主设备号和次设备号。一个字符设备或块设备都有一个主设备号和一个次设备号。主设备号用来标识与设备文件相连的驱动程序，用来反映设备类型。次设备号被驱动程序用来辨别操作的是哪个设备，用来区分同类型的设备。

在内核中，dev_t用来保存设备编号，包括主设备号和次设备号。dev_t是一个32位的数，其中12位用来表示主设备号，其余20位用来标识次设备号。
通过dev_t获取主设备号和次设备号使用下面的宏：

#define MINORBITS   20#define MINORMASK   ((1U << MINORBITS) - 1)#define MAJOR(dev)  ((unsigned int) ((dev) >> MINORBITS))//获得主设备号#define MINOR(dev)  ((unsigned int) ((dev) & MINORMASK)) //获得次设备号#define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))   //由主次设备号得到设备号 

对于字符设备的访问是通过文件系统中的设备名称进行的。它们通常位于/dev目录下。如下：

xxx@ubuntu:~$ ls -l /dev/  total 0  brw-rw----  1 root disk        7,   0  12月 25 10:34 loop0  brw-rw----  1 root disk        7,   1  12月 25 10:34 loop1  brw-rw----  1 root disk        7,   2  12月 25 10:34 loop2  crw-rw-rw-  1 root tty         5,   0  12月 25 12:48 tty  crw--w----  1 root tty         4,   0  12月 25 10:34 tty0  crw-rw----  1 root tty         4,   1  12月 25 10:34 tty1  crw--w----  1 root tty         4,  10  12月 25 10:34 tty10  

其中b代表块设备，c代表字符设备。对于普通文件来说，使用命令ls -l会列出文件的长度，而对于设备文件来说，上面的7,5,4等代表的是对应设备的主设备号，而后面的0,1,2,10等则是对应设备的次设备号。主设备号标识设备对应的驱动程序，也就是说1个主设备号对应一个驱动程序。当然，现在也有多个驱动程序共享主设备号的情况。而次设备号由内核使用，用于确定/dev下的设备文件对应的具体设备。举一个例子，虚拟控制台和串口终端有驱动程序4管理，而不同的终端分别有不同的次设备号。

cdev初始化

静态初始化

/** * cdev_init() - initialize a cdev structure * @cdev: the structure to initialize * @fops: the file_operations for this device * * Initializes @cdev, remembering @fops, making it ready to add to the * system with cdev_add(). */void cdev_init(struct cdev *cdev, const struct file_operations *fops){    memset(cdev, 0, sizeof *cdev);    INIT_LIST_HEAD(&cdev->list);    kobject_init(&cdev->kobj, &ktype_cdev_default);    cdev->ops = fops;}

动态初始化：

/** * cdev_alloc() - allocate a cdev structure * * Allocates and returns a cdev structure, or NULL on failure. */struct cdev *cdev_alloc(void){    struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);    if (p) {        INIT_LIST_HEAD(&p->list);        kobject_init(&p->kobj, &ktype_cdev_dynamic);    }    return p;}

cdev设备注册

cdev设备注册过程中为设备提供了两种分配设备号的方式：

1、指定主设备号

/** * register_chrdev_region() - register a range of device numbers * @from: the first in the desired range of device numbers; must include *        the major number. * @count: the number of consecutive device numbers required * @name: the name of the device or driver. * * Return value is zero on success, a negative error code on failure. */int register_chrdev_region(dev_t from, unsigned count, const char *name){    struct char_device_struct *cd;    dev_t to = from + count;    dev_t n, next;    for (n = from; n < to; n = next) {        next = MKDEV(MAJOR(n)+1, 0);        if (next > to)            next = to;        cd = __register_chrdev_region(MAJOR(n), MINOR(n),                   next - n, name);        if (IS_ERR(cd))            goto fail;    }    return 0;fail:    to = n;    for (n = from; n < to; n = next) {        next = MKDEV(MAJOR(n)+1, 0);        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));    }    return PTR_ERR(cd);}

2、系统自动分配主设备号

/** * alloc_chrdev_region() - register a range of char device numbers * @dev: output parameter for first assigned number * @baseminor: first of the requested range of minor numbers * @count: the number of minor numbers required * @name: the name of the associated device or driver * * Allocates a range of char device numbers.  The major number will be * chosen dynamically, and returned (along with the first minor number) * in @dev.  Returns zero or a negative error code. */int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,            const char *name){    struct char_device_struct *cd;    cd = __register_chrdev_region(0, baseminor, count, name);    if (IS_ERR(cd))        return PTR_ERR(cd);    *dev = MKDEV(cd->major, cd->baseminor);    return 0;}

cdev注销

与上述两个分配设备号对应的注销设备号的函数如下

/** * unregister_chrdev_region() - unregister a range of device numbers * @from: the first in the range of numbers to unregister * @count: the number of device numbers to unregister * * This function will unregister a range of @count device numbers, * starting with @from.  The caller should normally be the one who * allocated those numbers in the first place... */void unregister_chrdev_region(dev_t from, unsigned count){    dev_t to = from + count;    dev_t n, next;    for (n = from; n < to; n = next) {        next = MKDEV(MAJOR(n)+1, 0);        if (next > to)            next = to;        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));    }}

添加字符设备cdev

/** * cdev_add() - add a char device to the system * @p: the cdev structure for the device * @dev: the first device number for which this device is responsible * @count: the number of consecutive minor numbers corresponding to this *         device * * cdev_add() adds the device represented by @p to the system, making it * live immediately.  A negative error code is returned on failure. */int cdev_add(struct cdev *p, dev_t dev, unsigned count){    int error;    p->dev = dev;    p->count = count;    error = kobj_map(cdev_map, dev, count, NULL,             exact_match, exact_lock, p);    if (error)        return error;    kobject_get(p->kobj.parent);    return 0;}

删除字符设备cdev

/** * cdev_del() - remove a cdev from the system * @p: the cdev structure to be removed * * cdev_del() removes @p from the system, possibly freeing the structure * itself. */void cdev_del(struct cdev *p){    cdev_unmap(p->dev, p->count);    kobject_put(&p->kobj);}

字符设备是3大类设备（字符设备、块设备、网络设备）中较简单的一类设备，其驱动程序中完成的主要工作是初始化、添加和删除cdev结构体，申请和释放设备号，以及填充file_operation结构体中操作函数，并实现file_operations结构体中的read()、write()、ioctl()等重要函数。
如图所示为cdev结构体、file_operations和用户空间调用驱动的关系。

字符设备驱动程序实例分析：
memdev.h

#ifndef _MEMDEV_H_#define _MEMDEV_H_#ifndef MEMDEV_MAJOR#define MEMDEV_MAJOR 251   /*预设的mem的主设备号*/#endif#ifndef MEMDEV_NR_DEVS#define MEMDEV_NR_DEVS 2    /*设备数*/#endif#ifndef MEMDEV_SIZE#define MEMDEV_SIZE 4096#endif/*mem设备描述结构体*/struct mem_dev                                     {                                                          char *data;                        unsigned long size;       };#endif /* _MEMDEV_H_ */

memdev.c

#include <linux/module.h>  #include <linux/types.h>  #include <linux/fs.h>  #include <linux/errno.h>  #include <linux/mm.h>  #include <linux/sched.h>  #include <linux/init.h>  #include <linux/cdev.h>  #include <asm/io.h>  #include <asm/uaccess.h>  #include <linux/timer.h>  #include <asm/atomic.h>  #include <linux/slab.h>  #include <linux/device.h>  #include "memdev.h"static mem_major = MEMDEV_MAJOR;module_param(mem_major, int, S_IRUGO);struct mem_dev *mem_devp; /*设备结构体指针*/struct cdev cdev; /*文件打开函数*/int mem_open(struct inode *inode, struct file *filp){    struct mem_dev *dev;    /*获取次设备号*/    int num = MINOR(inode->i_rdev);    if (num >= MEMDEV_NR_DEVS)             return -ENODEV;    dev = &mem_devp[num];    /*将设备描述结构指针赋值给文件私有数据指针*/    filp->private_data = dev;    return 0; }/*文件释放函数*/int mem_release(struct inode *inode, struct file *filp){  return 0;}/*读函数*/static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos){  unsigned long p =  *ppos;        /*记录文件指针偏移位置*/    unsigned int count = size;    /*记录需要读取的字节数*/   int ret = 0;    /*返回值*/    struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/  /*判断读位置是否有效*/  if (p >= MEMDEV_SIZE)    /*要读取的偏移大于设备的内存空间*/      return 0;  if (count > MEMDEV_SIZE - p)     /*要读取的字节大于设备的内存空间*/     count = MEMDEV_SIZE - p;  /*读数据到用户空间:内核空间->用户空间交换数据*/    if (copy_to_user(buf, (void*)(dev->data + p), count))  {    ret =  - EFAULT;  }  else  {    *ppos += count;    ret = count;    printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);  }  return ret;}/*写函数*/static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos){  unsigned long p =  *ppos;  unsigned int count = size;  int ret = 0;  struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/  /*分析和获取有效的写长度*/  if (p >= MEMDEV_SIZE)    return 0;  if (count > MEMDEV_SIZE - p)    /*要写入的字节大于设备的内存空间*/    count = MEMDEV_SIZE - p;  /*从用户空间写入数据*/  if (copy_from_user(dev->data + p, buf, count))    ret =  - EFAULT;  else  {    *ppos += count;      /*增加偏移位置*/      ret = count;      /*返回实际的写入字节数*/     printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);  }  return ret;}/* seek文件定位函数 */static loff_t mem_llseek(struct file *filp, loff_t offset, int whence){     loff_t newpos;          switch(whence) {      case 0: /* SEEK_SET */       /*相对文件开始位置偏移*/         newpos = offset;           /*更新文件指针位置*/        break;      case 1: /* SEEK_CUR */        newpos = filp->f_pos + offset;            break;      case 2: /* SEEK_END */        newpos = MEMDEV_SIZE -1 + offset;        break;      default: /* can't happen */        return -EINVAL;    }    if ((newpos<0) || (newpos>MEMDEV_SIZE))        return -EINVAL;    filp->f_pos = newpos;    return newpos;}/*文件操作结构体*/static const struct file_operations mem_fops ={  .owner = THIS_MODULE,  .llseek = mem_llseek,  .read = mem_read,  .write = mem_write,  .open = mem_open,  .release = mem_release,};/*设备驱动模块加载函数*/static int memdev_init(void){  int result;  int i;  dev_t devno = MKDEV(mem_major, 0);   /* 申请设备号，当xxx_major不为0时，表示静态指定；当为0时，表示动态申请*/   /* 静态申请设备号*/  if (mem_major)    result = register_chrdev_region(devno, 2, "memdev");  else  /* 动态分配设备号 */  {    result = alloc_chrdev_region(&devno, 0, 2, "memdev");    mem_major = MAJOR(devno);    /*获得申请的主设备号*/  }    if (result < 0)    return result; /*初始化cdev结构，并传递file_operations结构指针*/   cdev_init(&cdev, &mem_fops);      cdev.owner = THIS_MODULE;    /*指定所属模块*/  cdev.ops = &mem_fops;  /* 注册字符设备 */  cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);  /* 为设备描述结构分配内存*/  mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);  if (!mem_devp)    /*申请失败*/  {    result =  - ENOMEM;    goto fail_malloc;  }  memset(mem_devp, 0, sizeof(struct mem_dev));  /*为设备分配内存*/  for (i=0; i < MEMDEV_NR_DEVS; i++)   {        mem_devp[i].size = MEMDEV_SIZE;        mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);        memset(mem_devp[i].data, 0, MEMDEV_SIZE);  }  return 0;  fail_malloc:   unregister_chrdev_region(devno, 1);  return result;}/*模块卸载函数*/static void memdev_exit(void){  cdev_del(&cdev);   /*注销设备*/  kfree(mem_devp);     /*释放设备结构体内存*/  unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/}MODULE_AUTHOR("David");MODULE_LICENSE("GPL");module_init(memdev_init);module_exit(memdev_exit);

应用程序测试：
app-mem.c

#include <stdio.h>int main(){    FILE *fp0 = NULL;    char Buf[4096];    /*初始化Buf*/    strcpy(Buf,"Mem is char dev!");    printf("BUF: %s\n",Buf);    /*打开设备文件*/    fp0 = fopen("/dev/memdev0","r+");    if (fp0 == NULL)    {        printf("Open Memdev0 Error!\n");        return -1;    }    /*写入设备*/    fwrite(Buf, sizeof(Buf), 1, fp0);        /*重新定位文件位置（思考没有该指令，会有何后果)*/    fseek(fp0,0,SEEK_SET);        /*清除Buf*/    strcpy(Buf,"Buf is NULL!");    printf("BUF: %s\n",Buf);            /*读出设备*/    fread(Buf, sizeof(Buf), 1, fp0);        /*检测结果*/    printf("BUF: %s\n",Buf);       return 0;    }

测试：
1)cat /proc/devices看看有哪些编号已经被使用，我们选一个没有使用的设备号xxx。
2)挂载驱动模块：insmod memdev.ko
3)通过”mknod /dev/memdev0 c xxx 0“命令创建”/dev/memdev0“设备节点。
4)交叉编译app-mem.c文件，下载并执行：

#./app-memMem is char dev!