韦东山视频_第25课_字符设备驱动程序另一种写法

　　旧字符设备驱动程序的框架：

1、确定主设备号major;

2、构造file_operations

3、注册register_chrdev;

4、创建类和设备结点

这个框架有很大的弊端，弊端出现在注册函数register_chrdev上，其实现中有这么一句：

cd = __register_chrdev_region(major, 0, 256, name);

其向内核连续注册了256个此设备号，也就把major这个主设备号下的所有此设备号都占用了，而其实我们大部分情况下用不到这么多次设备号，造成了巨大的浪费。

于是有了这样两个函数：

①  register_chrdev_region(dev_t from, unsigned count, const char  *name)
②  alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char  *name)

register_chrdev_region函数的第一个参数dev_t from是一个unsigned型的数，高12位表示主设备号，低20位表示
次设备号。因此这个参数中包含了起始的次设备号。第二个参数unsigned count表示需要注册的连续的次设备号的个
数。最后一个参数表示设备或驱动的名字。在解释alloc_chrdev_region函数的参数之前先解释一下，这2个函数的区别和用法。register_chrdev_region这个函数在调用之前需要确定from这个参数的值，就是说设备号是已知的。而alloc_chrdev_region这个函数调用的时候不需要知道设备的设备号是多少，内核会动态分配一个给他。在
分配好了之后会把设备号写到设备号变量的地址，所以我们看到在调用alloc_chrdev_region这个函数的时候它的第一个参数是设备号变量的地址。alloc_chrdev_region它的第二个参数是起始次设备号，第三个参数是要注册的次设备号个数，最后一个是设备或驱动的名字。
这两个函数最终调用的都是__register_chrdev_region，同时需要跟cdev_init(struct cdev  *cdev, const struct
file_operations *fops)和 cdev_add(struct cdev *p, dev_t dev, unsigned count)来配合使用。这2个函数的功能在以前的字符设备驱动程序中是在register_chrdev这一个函数中完成的，在这里需要我们自己来调用。这样一来，register_chrdev这个函数就被完美的替代了。我们就可以通过控制注册的起始次设备号以及多少个次设备号，实现了用多少注册多少的目的。

字符设备驱动新框架：

1、确定主设备号

主设备号已知，
devid = MKDEV(major, 0);
register_chrdev_region(devid, HELLO_CNT, "hello");
主设备号未知，
alloc_chrdev_region(&devid, 0, HELLO_CNT, "hello");
major = MAJOR(devid);

2、构造file_operations

static struct file_operations hello_fops =

{
　　.owner = THIS_MODULE,
　　.open = hello_open,
};

3、注册

cdev_init(&hello_cdev, &hello_fops);
cdev_add(&hello_cdev, devid, HELLO_CNT);

4、创建类和设备

hello_class = class_create(THIS_MODULE, CLASS_NAME);

device_create(hello_class, NULL, MKDEV(hello_major, 0), NULL, DEV_NAME);

一个实例程序如下：

#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/system.h>
#include <asm/uaccess.h>
#include <linux/device.h>

#define HELLO_MAJOR    0    //预设的主设备号
#define START_MINOR    0    //起始次设备号
#define DEV_CNT        2    //要注册的设备数
#define DRV_CNT        2    //要注册的驱动数
#define DRIVER_NAME    "hello"    //驱动名
#define CLASS_NAME    "hello_drv"    //类名
#define DEV_NAME    "hello%d"    //设备名

static int hello_major = HELLO_MAJOR;

struct class *hello_class = NULL;

//字符设备结构体
struct hello_dev
{
    struct cdev cdev;    //cdev结构体
    void *private_data;    //私有数据
};

struct hello_dev *hello_devp;    //设备结构体指针

static int hello_open(struct inode *inode, struct file *file)
{
    printk("hello_open
");
    return 0;
}

//文件操作结构体
static const struct file_operations hello_fops = 
{
    .owner = THIS_MODULE,
    .open = hello_open,
    //.read = hello_read,
    //.write = hello_write,
    //.ioctl = hello_ioctl,
};

//设备驱动模块加载函数
int hello_init(void)
{
    int i, res;
    dev_t devno;

    //申请次设备号范围、主设备号
    if (hello_major)
    {
        devno = MKDEV(hello_major, START_MINOR);
        res = register_chrdev_region(devno, DEV_CNT * DRV_CNT, DRIVER_NAME);
    }
    else
    {
        res = alloc_chrdev_region(&devno, START_MINOR, DEV_CNT * DRV_CNT, DRIVER_NAME);
        hello_major = MAJOR(devno);
    }

    if (res < 0)
    {
        return res;
    }

    //动态申请设备结构体内存
    hello_devp = kmalloc(DRV_CNT * sizeof(struct hello_dev), GFP_KERNEL);
    if (hello_devp == NULL)
    {
        res = - ENOMEM;
        goto fail_malloc;
    }
    memset(hello_devp, 0, DRV_CNT * sizeof(struct hello_dev));

    for (i = 0; i < DRV_CNT; i++)
    {
        cdev_init(&hello_devp[i].cdev, &hello_fops);
        hello_devp[i].cdev.owner = THIS_MODULE;
        cdev_add(&hello_devp[i].cdev, MKDEV(hello_major, i * DEV_CNT), DEV_CNT);
    }

    //自动创建设备节点
    hello_class = class_create(THIS_MODULE, CLASS_NAME);
    
    for (i = 0; i < DEV_CNT * DRV_CNT; i++)
    {
        device_create(hello_class, NULL, MKDEV(hello_major, i), NULL, DEV_NAME, i);
    }
    
    return 0;

fail_malloc:
    unregister_chrdev_region(devno, DEV_CNT);
    return res;
}

//模块卸载函数
void hello_exit(void)
{
    int i;
    
    cdev_del(&hello_devp->cdev);
    kfree(hello_devp);
    unregister_chrdev_region(MKDEV(hello_major, 0), DEV_CNT * DRV_CNT);
    for (i = 0; i < DEV_CNT * DRV_CNT; i++)
    {
        device_destroy(hello_class, MKDEV(hello_major, i));
    }
    class_destroy(hello_class);
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lcm");

程序中，一个主设备号和一个次设备号共同对应一个设备节点，例子中有两个c_dev结构体，且对应同一个主设备号，每个c_dev结构体对应两个次设备号，即创建两个字符设备。