这部分主要讲Linux字符设备驱动程序的结构，解释主要组成部分的编程方法。

字符设备

字符设备：指只能一个byte一个byte读写的设备，不能随机读写数据，要按先后顺序。字符设备是面向流的设备，常见字符设备有鼠标、键盘、串口、终端、LED灯。

块设备：指可以从设备的任意位置读取一定长度数据的设备。常见块设备有磁盘、硬盘、U盘、SD卡等。

每个字符设备或块设备，都在/dev目录下有一个对应的设备文件。Linux APP可以通过这些设备文件（又称设备节点），来使用驱动程序操作字符设备和块设备。

字符设备、字符设备驱动与用户空间访问该设备的程序三者之间的关系：

from Linux 字符设备驱动结构（一）—— cdev 结构体、设备号相关知识解析 | CSDN

Linux内核中，

• 使用cdev结构体描述字符设备；
• 通过成员dev_t定义设备号（主、次设备号），确定字符设备的唯一性；
• 通过成员file_operations定义字符设备驱动，为VFS（虚拟文件系统）提供接口函数，如open/close/read/write等。

Linux字符设备驱动中，

• 模块加载函数通过register_chrdev_region()或alloc_chrdev_region()，来静态或动态获取设备号；
• 通过cdev_init()建立cdev与file_opreations之间的连接，通过cdev_add()向系统添加一个cdev以完成注册；
• 模块卸载函数通过cdev_del()来注销cdev，通过unregister_chrdev_region()来释放设备号。

TIPS: register_chrdev 与 register_chrdev_region, alloc_chrdev_region有何区别？

register_chrdev 设备注册 + 设备号申请。register_chrdev_region和alloc_chrdev_region 设备号申请，设备注册由cdev_init + cdev_add完成。
register_chrdev() 支持一次注册一个设备，而且需要传入参数file_operations。默认写死注册的设备号范围0~255。释放字符设备时，使用unregister_chrdev()。但不必使用cdev_xxx系列操作。
register_chrdev_region() 支持一次注册多个设备号，不需要传入参数file_operations，在cdev_init()中绑定cdev与file_operations。释放设备号时，使用unregister_chrdev_region。register_chrdev_region需要搭配cdev_xxx系列操作使用。
alloc_chrdev_region() 与register_chrdev_region()的区别在于前者申请的设备号由系统决定，后者由调用者指定。

APP中访问设备驱动程序，

• 通过Linux系统调用，如open/close/read/write，调用file_operations中定义的接口函数。

Linux字符设备驱动结构

cdev结构体

Linux内核中，使用cdev结构体描述一个字符设备。cdev定义：

#include <linux/cdev.h>

struct cdev {
    struct kobject kobj;           /* 内嵌的kobject对象 */
    struct module *owner;          /* 所属模块 */
    struct file_operations *ops;   /* 文件操作结构体 */
    struct list_head list;
    dev_t dev;                     /* 设备号 */
    unsigned int count;            /* 该设备关联的设备编号的数量 */
};

cdev结构体的dev_t成员定义设备号（32bit），其中高12bit为主设备号，低20bit为次设备号。

如何获取主次设备号，或dev_t？

• 从dev_t获得主设备号和次设备号

MAJOR(dev_t dev); // 主设备号
MINOR(dev_t dev); // 次设备号

• 通过主设备号、次设备号生成dev_t

MKDEV(int major, int minor); // 生成dev_t, 包含主次设备号信息

这几个宏定义如下：

#include <linux/kdev_t.h>

#define MINORBITS    20
#define MINORMASK    ((1U << MINORBITS) - 1)

#define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS)) // 高12bit为主设备号
#define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK))  // 低20bit为次设备号
#define MKDEV(ma,mi)  (((ma) << MINORBITS) | (mi))

内核提供一组函数用于操作cdev结构体：

void cdev_init(struct cdev *, struct file_operations *);
struct cdev *cdev_alloc(void);
void cdev_put(struct cdev *p);
int  cdev_add(struct cdev *, dev_t, unsigned);
void cdev_del(struct cdev *);

1）cdev_init 初始化cdev成员，最重要的是建立cdev和file_operations之间的连接

源码：

/**
* 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);   /* 初始化list成员, 指向自身 */
    kobject_init(&cdev->kobj, &ktype_cdev_default); /* 初始化kobj成员 */
    cdev->ops = fops; /* 建立cdev和file_operations之间的连接 */
}

2）cdev_alloc 动态申请一个cdev内存

源码：

/**
* 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); /* 动态申请一个cdev内存, GFP_KERNEL: 无内存可用时可休眠 */
    if (p) {
        INIT_LIST_HEAD(&p->list);  /* 初始化list成员, 指向自身 */
        kobject_init(&p->kobj, &ktype_cdev_dynamic);  /* 初始化kobj成员 */
    }
    return p;
}

上面两个初始化函数，为何都没看到owner、dev、count 这3个成员的初始化？

对于owner成员，struct module类型对象，是内核对于一个模块的抽象。该成员在字符设备中可以体现该设备隶属于哪个模块，在驱动程序的编写中一般由用户显式初始化.owner = THIS_MODULE

对于dev和count成员，在cdev_add中才会赋值。

3）cdev_add 向内核添加一个cdev，完成字符设备的注册

这里需要提供参数dev（设备号）和count（该设备关联的设备编号的数量），直接赋值给cdev结构的dev和count成员。

/**
* 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); /* 将cdev放入cdev_map中 */
    if (error)
        return error;

    kobject_get(p->kobj.parent); /* 增加引用计数 */

    return 0;
}

4）cdev_del 从内核删除一个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);      /* 将dev从cdev_map中擦除 */
    kobject_put(&p->kobj);             /* 减少引用计数 */
}

static void cdev_unmap(dev_t dev, unsigned count)
{
    kobj_unmap(cdev_map, dev, count); /* 将dev从cdev_map中擦除 */
}

分配、释放设备号

分配设备号

调用cdev_add()向系统注册字符设备前，应先申请设备号。分配设备号有2种方法：

1）静态申请：register_chrdev_region

register_chrdev_region() 用于已知起始设备号的情况，向系统静态申请设备号（范围）。

要申请的设备号范围：[from, from + count)。

有些设备号已被Linux内核开发者分配掉了，具体分配内容可查看Documentation/devices.txt。

/**
* 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
alloc_chrdev_region() 用于设备号未知，向系统动态申请未被占用的设备号的情况。
得到的设备号会放入第一个参数dev中。alloc_chrdev_region相比register_chrdev_region，优点：alloc_chrdev_region会自动避开设备号重复的冲突。

/**
* 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;
}

检查：注册设备成功后，会在/proc/devices 添加字符设备名称。
因此，可以利用insmod命令加载设备驱动后，观察/proc/devices值，判断是否注册了设备。

# cat /proc/devices

释放设备号

在调用cdev_del()从系统注销字符设备后，unregister_chrdev_region()应该被调用以释放原先申请的设备号。

从系统反注册设备号，范围：[from, from + count)

/**
* 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); /* 下一个设备号dev_t */
        if (next > to)
            next = to;
        kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n)); /* 反注册单个设备号, 并释放空间 */
    }
}

file_operations结构体

file_operations 是设备驱动程序与APP交互的接口，其成员函数是字符设备驱动程序设计的主体，实际会在APP调用open/write/read/close等系统调用时被内核调用。

file_operations结构体定义：

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    int (*iterate) (struct file *, struct dir_context *);
    int (*iterate_shared) (struct file *, struct dir_context *);
    unsigned int (*poll) (struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    int (*mmap) (struct file *, struct vm_area_struct *);
    int (*open) (struct inode *, struct file *);
    int (*flush) (struct file *, fl_owner_t id);
    int (*release) (struct inode *, struct file *);
    int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    int (*fasync) (int, struct file *, int);
    int (*lock) (struct file *, int, struct file_lock *);
    ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    int (*check_flags)(int);
    int (*flock) (struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    int (*setlease)(struct file *, long, struct file_lock **, void **);
    long (*fallocate)(struct file *file, int mode, loff_t offset,
              loff_t len);
    void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
    unsigned (*mmap_capabilities)(struct file *);
#endif
    ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
            loff_t, size_t, unsigned int);
    int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
            u64);
    ssize_t (*dedupe_file_range)(struct file *, u64, u64, struct file *,
            u64);
};

主要成员：

• llseek() 用来修改一个文件的当前读写位置，并将新位置返回，出错时，函数返回一个负值。
• read() 用来从设备中读取数据，成功时函数返回读取的字节数，出错时返回一个负值。对应用户空间read(2)。
• write() 向设备发送数据，成功时函数返回写入的字节数。如果未被实现，当用户进行write()系统调用时，将得到-EINVAL返回值。对应用户空间write(2)。

read和write返回0，暗示end-of-line（EOF）。

• unlocked_ioctl() 提供设备相关控制命令的实现（不是读，也不是写），成功时返回一个非负值。对应用户空间fcntl(2)应。
• mmap() 将设备内存映射到进程的虚拟地址空间，如果设备驱动未实现该函数，用户调用mmap()系统调用时返回-ENODEV。对应用户空间mmap(2)。与mmap对应的是unmap。
• open() 打开设备，用于初始化设备状态。用户空间调用open(2)时，设备驱动的open()被调用。驱动程序可以不实现该函数，设备打开操作永远成功。与open对应的是release。
• release() 释放设备资源。如果open()中有申请系统资源，则可以在release()中释放。对应用户空间close(2)。
• poll() 用于询问设备是否可以被非阻塞地立即读写。当询问的条件未触发时，用户空间进行select()和poll()系统调用将引起进程阻塞。
• aio_read()/aio_write() 分别对与文件描述符对应的设备进行异步读、写操作。设备实现这2个函数后，用户空间可以对该设备文件描述符执行SYS_io_setup、SYS_io_submit、SYS_io_getevents、SYS_io_destroy等系统调用进行读写。

字符设备驱动的组成

Linux中，字符设备驱动组成：字符设备驱动模块加载、卸载函数，字符设备驱动的file_operations结构体的成员函数。

字符设备驱动模块的加载、卸载函数

加载函数应该实现：1）设备号的申请；2）cdev的注册。

卸载函数应该实现：1）设备号的释放；2）cdev的注销。

典型的设备结构体、模块加载函数、卸载函数代码形式：

/* 设备结构体
struct xxx_dev_t = {
    struct cdev cdev;
    ...
} xxx_dev;
 */
/* 设备驱动模块加载函数 */
static init __init xxx_init(void)
{
    ...
    cdev_init(&xxx_dev.cdev, &xxx_fops);          /* 初始化cdev */
    xxx_dev.cdev.owner = THIS_MODULE;
    /* 获得字符设备号 */
    if (xxx_major) {
        register_chrdev_region(xxx_dev_no, 1, DEV_NAME);
    } else {
        alloc_chrdev_region(&xxx_dev_no, 0, 1, DEV_NAME);
    }

    ret = cdev_add(&xxx_dev.cdev, xxx_dev_no, 1); /* 注册设备 */
    ...
}

/* 设备驱动模块卸载函数 */
static void __exit xxx_exit(void)
{
    unregister_chrdev_region(xxx_dev_no, 1);     /* 释放占用的设备号 */
    cdev_del(&xxx_dev.cdev);                     /* 注销设备 */
}

字符设备驱动的file_operations结构体的成员函数

file_operations的成员函数是字符设备驱动跟内核虚拟文件系统的接口，是用户空间对Linux进行系统调用最终的落实者。大多数字符设备驱动会实现read()/write/ioctl()。

典型字符设备驱动代码形式：

/* 读设备
 * filp: 文件结构指针
 * buf: 用户空间内存地址, 在内核空间不能直接读写
 * count: 要读的字节数
 * f_pos: 读的位置相对于文件开头的偏移
 */
ssize_t xxx_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
    ...
    copy_to_user(buf, ..., ...); /* 将数据从内核空间拷贝到用户空间 */
    ...
}

/* 写设备 */
ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
{
    ...
    copy_from_user(.... buf, ...); /* 将数据从用户空间拷贝到内核空间 */
    ...
}

/* ioctl函数 */
long xxx_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    ...
    switch(cmd) {
    case XXX_CMD1:
        ...
        break;
    case XXX_CMD2:
        ...
        break;
    default:
        /* 不支持的命令 */
        return -ENOTTY;
    }
    return 0;
}

copy_to_user和copy_from_user

注：用户空间不能直接访问内核空间的内存，所以要借助copy_to_user()将数据从内核空间拷贝到用户空间；
同样地，内核空间不能直接访问用户空间的内存，所以借助copy_from_user()将数据从用户空间拷贝到内核空间。

#include <linux/uaccess.h>

/* 用户 -> 内核 */
unsigned long copy_from_user(void *to, const void __user *from, unsigned long n);
/* 内核 -> 用户 */
unsigned long copy_to_user(void __user *to, const void *from, unsigned long n);
注：函数返回不能被复制的字节数。如果完全复制成功，返回0；如果失败，返回负值。

其源码如下：

unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
{
    if (likely(access_ok(VERIFY_READ, from, n))) /* 检查地址的合法性, from起始地址, 长度n */
        n = __copy_from_user(to, from, n);       /* 数据拷贝, 但不做地址合法性检查 */
    else
        memset(to, 0, n);
    return n;
}

unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)
{
    if (likely(access_ok(VERIFY_WRITE, to, n))) /* 检查地址的合法性, to起始地址, 长度n */
        n = __copy_to_user(to, from, n);        /* 数据拷贝, 但不做地址合法性检查 */
    return n;
}

likely：是宏定义，常用于编译器优化，告诉编译器分支大概率会发生。
access_ok(type, addr, size)：内核空间可以访问用户空间的缓冲区，但访问之前需要用access_ok检查其合法性，以确定传入的缓冲区地址的确术语用户空间。

如果要复制的内存是简单类型，如char、int、long等，则可以使用简单的put_user()和get_user()。

int val;                    /* 内核空间变量 */
...
get_user(val, (int* ) arg); /* 用户 -> 内核, arg 是用户空间地址 */
...
put_user(val, (int* ) arg); /* 内核 -> 用户, arg 是用户空间地址 */

copy_from_user函数中的__user宏是什么？
该宏表明背后的指针指向用户空间，实际上更多地充当了代码注释的功能。

#ifdef __CHECKER__
# define __user __attribute__((noderef, address_space(1)))
#else
# define __user
#endif

put_user和get_user

put_user(), get_user() 也有另外一个版本：__put_user(), __get_user()。区别在于__put_user()不用access_ok()检查地址的合法性，而put_user()会。通常，在调用__put_user()之前，会手动检查用户空间缓冲区。
get_user()和__get_user() 关系类似。

I/O控制函数unlocked_ioctl

I/O控制函数的cmd参数为事先定义的I/O控制命令，arg为对应于命令的参数。例如，对于串行设备，如果SET_BAUDRATE是设置波特率的命令，那arg就应该是波特率值。

字符设备驱动文件操作file_operations

字符设备驱动文件操作，通过定义file_operations实例，并将具体设备驱动函数赋值给file_operations成员来完成。

struct file_operations xxx_fops = {
    .owner = THIS_MODULE,
    .read = xxx_read,
    .write = xxx_write,
    .unlocked_ioctl = xxx_ioctl,
};

通过模块加载函数中调用cdev_init(&xxx_dev.cdev, &xxx_fops) 为cdev和fops建立连接。

参考

[1]宋宝华. Linux设备驱动开发详解[M]. 人民邮电出版社, 2010.
[2] https://blog.csdn.net/zqixiao_09/article/details/50839042