字符设备驱动概述

参考文档：https://www.jianshu.com/p/9845594783d4
https://blog.csdn.net/zqixiao_09/article/details/50839042?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
https://blog.csdn.net/kai_zone/article/details/80459334

一. 字符设备驱动基础
1.什么是驱动

驱动就是对底层硬件设备的操作进行封装，并向上层提供函数接口。

2.设备分类
linux系统将设备分为3类：字符设备、块设备、网络设备。
字符设备：
指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后顺序。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。

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

网络设备：
网络设备可以是一个硬件设备,如网卡; 但也可以是一个纯粹的软件设备, 比如回环接口(lo).一个网络接口负责发送和接收数据报文。

3.字符设备驱动工作原理

在linux的世界里一切皆文件，所有的硬件设备操作到应用层都会被抽象成文件的操作。我们知道如果应用层要访问硬件设备，它必定要调用到硬件对应的驱动程序。Linux内核有那么多驱动程序，应用怎么才能精确的调用到底层的驱动程序呢？

必须知道的知识：

(1) 在Linux文件系统中，每个文件都用一个struct inode结构体来描述，这个结构体记录了这个文件的所有信息，例如文件类型，访问权限等。

(2) 在linux操作系统中，每个驱动程序在应用层的/dev目录或者其他如/sys目录下都会有一个文件与之对应。

(3) 在linux操作系统中, 每个驱动程序都有一个设备号。

(4) 在linux操作系统中，每打开一次文件，Linux操作系统会在VFS层分配一个struct file结构体来描述打开的文件。

(1) 当open函数打开设备文件时，可以根据设备文件对应的struct inode结构体描述的信息，可以知道接下来要操作的设备类型（字符设备还是块设备），还会分配一个struct file结构体。

(2) 根据struct inode结构体里面记录的设备号，可以找到对应的驱动程序。这里以字符设备为例。在Linux操作系统中每个字符设备都有一个struct cdev结构体。此结构体描述了字符设备所有信息，其中最重要的一项就是字符设备的操作函数接口。

(3) 找到struct cdev结构体后，linux内核就会将struct cdev结构体所在的内存空间首地址记录在struct inode结构体i_cdev成员中，将struct cdev结构体中的记录的函数操作接口地址记录在struct file结构体的f_ops成员中。

(4) 任务完成，VFS层会给应用返回一个文件描述符（fd）。这个fd是和struct file结构体对应的。接下来上层应用程序就可以通过fd找到struct file，然后在struct file找到操作字符设备的函数接口file_operation了。

其中，cdev_init和cdev_add在驱动程序的入口函数中就已经被调用，分别完成字符设备与file_operation函数操作接口的绑定，和将字符驱动注册到内核的工作。

二. 字符设备驱动模型

1.设备描述结构
在任何一种驱动模型中，设备都会用内核中的一种结构来描述。字符设备在内核中使用 struct cdev 来描述。

struct cdev {
    struct kobject kobj;
    struct module *owner;   //一般为THIS_MODULE, 该成员可以防止设备的方法正在被使用时，设备所在模块被卸载。
    const struct file_operations *ops;   //设备操作集
    struct list_head list;
    dev_t dev;  //设备号
    unsigned int count; //设备数
};

内核给出的操作struct cdev结构的接口主要有以下几个:
a – void cdev_init(struct cdev *, const struct file_operations *);

其源代码如代码清单如下：

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

该函数主要对struct cdev结构体做初始化，最重要的就是建立cdev 和 file_operations之间的连接。
(1) 将整个结构体清零；

(2) 初始化list成员使其指向自身；

(3) 初始化kobj成员；

(4) 初始化ops成员；

b – int cdev_add(struct cdev *p, dev_t dev, unsigned count);

   该函数向内核注册一个struct cdev结构，即正式通知内核由struct cdev *p代表的字符设备已经可以使用了。

当然这里还需提供两个参数：

(1)第一个设备号 dev，

(2)和该设备关联的设备编号的数量。

这两个参数直接赋值给struct cdev 的dev成员和count成员。

c – void cdev_del(struct cdev *p)；

 该函数向内核注销一个struct cdev结构，即正式通知内核由struct cdev *p代表的字符设备已经不可以使用了。

 从上述的接口讨论中，我们发现对于struct cdev的初始化和注册的过程中，我们需要提供几个东西

(1) struct file_operations结构指针；

(2) dev设备号；

(3) count次设备号个数。

但是我们依旧不明白这几个值到底代表着什么，而我们又该如何去构造这些值！

2.设备号

Linux内核中使用 dev_t 类型来定义设备号，dev_t这种类型其实质为32位的unsigned int，其中高12位为主设备号，低20位为次设备号.

问1：如果知道主设备号，次设备号，怎么组合成dev_t类型?
答: dev_t dev = MKDEV(主设备号，次设备号)
问2: 如何从dev_t中分解出主设备号?
答: 主设备号 = MAJOR(dev_t dev)
问3: 如何从dev_t中分解出次设备号？
答: 次设备号 = MINOR(dev_t dev)

设备号的申请
静态申请：
开发者自己选择一个数字作为主设备号，然后通过函数 register_chrdev_region 向内核申请使用。缺点：如果申请使用的设备号已经被内核中的其他驱动使用了，则申请失败。

动态分配
使用 alloc_chrdev_region 由内核分配一个可用的主设备号。优点：因为内核已经知道哪些设备号被使用了，所以不会导致分配到已经被使用到的设备号。

设备号的注销
不论使用何种方法分配设备号，都应该在驱动退出时，使用 unregister_chrdev_region 函数释放这些设备号。

2.编写字符设备驱动
写出一个字符设备驱动一般需要以下几步：

（1）分配设备号
（2）分配一个file_operation结构体；
（3）设置file_operation结构体；
（4）初始化及注册 cdev
（5）入口（模块加载）；
（6） 出口（卸载函数）；

示例：

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/slab.h>

struct cdev cdev; 
dev_t devno;

/* inode:结构表示具体的文件;
   file:结构体用来追踪文件在运行时的状态信息。*/
static int first_drv_open(struct inode *inode, struct file *filp)
{
    printk("@debug -----> first_drv_open! \n");      //打印
    return 0;
}

/*file:为目标文件结构体指针;
  buffer:为要写入文件的信息缓冲区，
  count:为要写入信息的长度;
  ppos:为当前的偏移位置，这个值通常是用来判断写文件是否越界*/
static ssize_t first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
   printk("@debug -----> first_drv_write！\n");      //打印
   return 0;
}

 static struct file_operations first_drv_fops = {
    .owner  =   THIS_MODULE,     //被使用时阻止模块被卸载
    .open   =   first_drv_open,      
    .write   =   first_drv_write,   
};

/*4写first_drv_init入口函数来调用这个register_chrdev()注册函数*/
int first_drv_init(void)
{
    /*初始化cdev结构*/
    cdev_init(&cdev, &first_drv_fops);
    
    /* 注册字符设备 */
    alloc_chrdev_region(&devno, 0, 2, "first_drv");
    cdev_add(&cdev, devno, 2);
    return 0;
}

void first_drv_exit(void)
{
    cdev_del(&cdev);   /*注销设备*/
    unregister_chrdev_region(devno, 2); /*释放设备号*/
}

/*module_init修饰入口函数*/
module_init(first_drv_init);
/*module_exit修饰出口函数*/
module_exit(first_drv_exit);

/*许可证声明, 描述内核模块的许可权限，如果不声明LICENSE，
模块被加载时，将收到内核被污染 （kernel tainted）的警告。*/
MODULE_LICENSE( "GPL v2" );

3.创建设备文件

1）手动创建
参考：Linux下手动创建设备节点

2）自动创建设备节点
对于每个设备，如果都需要这样手动创建的话，那也太麻烦了。

可以使用自动创建设备节点，Linux有udev、mdev的机制，然后udev机制会通过class类来找到相应类的驱动设备来自动创建设备节点 (前提需要有udev)。

在驱动初始化的代码里调用class_create(…)为该设备创建一个class，再为每个设备调用device_create(…)创建对应的设备。

(1)首先创建一个class设备类，然后在class类下，创建一个class_device，即类下面创建类的设备;

static struct class *firstdrv_class;               //创建一个class类
static struct class_device   *firstdrv_class_devs; //创建类的设备

(2)在first_drv_init入口函数中添加:

//创建类,它会在sys/class目录下创建firstdrv_class这个类
firstdrv_class= class_create(THIS_MODULE,"firstdrv");  
 
//创建类设备,会在sys/class/firstdrv_class类下创建xyz设备,
//然后udev通过这个自动创建/dev/first_drv这个设备节点,     
firstdrv_class_devs=device_create(firstdrv_class,NULL,MKDEV(major,0),NULL,"first_drv");

(3)在first_drv_exit出口函数中添加:

 device_unregister(firstdrv_class_devs);      //注销类设备,与class_device_create对应
 class_destroy(firstdrv_class);  //注销类,与class_create对应

这样，就不需要再mknod了。