【Linux驱动开发】001 字符设备驱动开发

一、前言

本章会以一个虚拟的设备为例，讲解如何进行字符设备驱动开发，以及如何编写测试 APP 来测试驱动工作是否正常。

---

二、字符设备驱动简介

字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。

Linux 应用程序对驱动程序的调用流程如下：

在 Linux 中一切皆为文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。

  应用程序运行在用户空间，而 Linux 驱动属于内核的一部分，因此驱动运行于内核空间。

当我们在用户空间想要实现对内核的操作，比如使用 open 函数打开/dev/led 这个驱动，因为用户空间不能直接对内核进行操作（linux内核态和用户态（通俗易懂）_Kashine的博客-CSDN博客），因此必须使用一个叫做“系统调用”的方法来实现从用户空间“陷入”到内核空间（具体无需了解），这样才能实现对底层驱动的操作。

比如应用程序中调用了 open 这个函数，那么在驱动程序中也得有一个名为 open 的函数。在Linux 内核文件  include/linux/fs.h 中有个叫做 file_operations 的结构体，此结构体就是 Linux 内核驱动操作函数集合：

struct file_operations { 
 
    struct module *owner;//拥有该结构的模块的指针，一般为THIS_MODULES 
 
 
    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 (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的读取操作 
 
    ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);//初始化一个异步的写入操作 
 
    int (*readdir) (struct file *, void *, filldir_t);//仅用于读取目录，对于设备文件，该字段为NULL 
 
    unsigned int (*poll) (struct file *, struct poll_table_struct *); //轮询函数，判断目前是否可以进行非阻塞的读写或写入 
 
    int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); //执行设备I/O控制命令 
 
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); //不使用BLK文件系统，将使用此种函数指针代替ioctl 
 
    long (*compat_ioctl) (struct file *, unsigned int, unsigned long); //在64位系统上，32位的ioctl调用将使用此函数指针代替 
 
 
    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 *, struct dentry *, int datasync); //刷新待处理的数据 
 
    int (*aio_fsync) (struct kiocb *, int datasync); //异步刷新待处理的数据 
 
    int (*fasync) (int, struct file *, int); //通知设备FASYNC标志发生变化 
 
    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 **); 
 
};

---

三、字符设备驱动开发步骤

1、驱动模块的加载和卸载

Linux 驱动有两种运行方式：

1.将驱动编译进 Linux 内核中，这样当 Linux 内核启动的时候就会自动运行驱动程序。

2.将驱动编译成模块(Linux 下模块扩展名为.ko)，在Linux 内核启动以后使用“insmod”命令加载驱动模块。

总之，将驱动编译为模块最大的好处就是方便开发，当驱动开发完成，确定没有问题以后就可以将驱动编译进Linux 内核中。

驱动模块有加载和卸载两种操作，两种操作各自对应着对应的操作函数，使用下面的两个函数可以注册对应的操作函数。insmod命令加载驱动的时候，xxx_init就会执行，rmmod命令卸载驱动的时候，xxx_exit就会执行。

module_init(xxx_init);    //注册模块加载函数 xxx_init（模块入口函数）
module_exit(xxx_exit);    //注册模块卸载函数 xxx_exit（模块出口函数）

1  /* 驱动入口函数 */ 
   // __init修饰的变量或者函数会编译到专门的一个段里面去，这个段的数据和函数只有在kernel初始化的时候会被调用，以后一定不会被使用
2  static int __init xxx_init(void) 
3  { 
4     /* 入口函数具体内容 */ 
5     return 0; 
6  } 
7   
8  /* 驱动出口函数 */ 
9  static void __exit xxx_exit(void) 
10 { 
11    /* 出口函数具体内容 */ 
12 } 
13  
14 /* 将上面两个函数指定为驱动的入口和出口函数 */ 
15 module_init(xxx_init); 
16 module_exit(xxx_exit); 

模块加载命令：insmod 命令不能解决模块的依赖关系，modprobe 会分析模块的依赖关系，然后会将所有的依赖模块都加载到内核中，modprobe 命令相比 insmod 要智能一些。

模块卸载命令：rmmod或者modprobe -r 命令。前提是这些依赖模块已经没有被其他模块所使用，否则就不能使用 modprobe 来卸载驱动模块。推荐使用rmmod命令。

2、字符设备注册与注销 

对于字符设备驱动而言，当驱动模块加载成功以后需要注册字符设备，同样，卸载驱动模块的时候也需要注销掉字符设备。

static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops) 
static inline void unregister_chrdev(unsigned int major, const char *name) 

major：主设备号。

name：设备名字。

fops：结构体 file_operations 类型指针，指向设备的操作函数集合变量。 

一般字符设备的注册在驱动模块的入口函数 xxx_init 中进行，字符设备的注销在驱动模块的出口函数 xxx_exit 中进行。

1  static struct file_operations test_fops; 
2  
3  /* 驱动入口函数 */ 
4  static int __init xxx_init(void) 
5  { 
6     /* 入口函数具体内容 */ 
7     int retvalue = 0; 
8  
9     /* 注册字符设备驱动 */ 
10    retvalue = register_chrdev(200, "chrtest", &test_fops); 
11    if(retvalue < 0){ 
12        /* 字符设备注册失败,自行处理 */ 
13    } 
14    return 0; 
15 } 
16  
17 /* 驱动出口函数 */ 
18 static void __exit xxx_exit(void) 
19 { 
20    /* 注销字符设备驱动 */ 
21    unregister_chrdev(200, "chrtest"); 
22 } 
23  
24 /* 将上面两个函数指定为驱动的入口和出口函数 */ 
25 module_init(xxx_init); 
26 module_exit(xxx_exit); 

要注意的一点就是，需要选择没有被使用的主设备号，输入命令“cat /proc/devices”可以查看当前已经被使用掉的设备号。

3、实现设备的具体操作函数

file_operations 结构体就是设备的具体操作函数，我们上面进行了定义但没有进行初始化（也就是没有初始化open、close等函数）。

1  /* 打开设备 */ 
   // 具体的函数参数类型详见上面的结构体中函数声明
   // 内核使用inode结构体在内核内部表示一个文件。
   // file结构体指示一个已经打开的文件（设备对应于设备文件）
2  static int chrtest_open(struct inode *inode, struct file *filp) 
3  { 
4     /* 用户实现具体功能 */ 
5     return 0; 
6  } 
7   
8  /* 从设备读取 */ 
9  static ssize_t chrtest_read(struct file *filp, char __user *buf,     
size_t cnt, loff_t *offt) 
10 { 
11    /* 用户实现具体功能 */ 
12    return 0; 
13 } 
14  
15 /* 向设备写数据 */ 
16 static ssize_t chrtest_write(struct file *filp,  
const char __user *buf,  
size_t cnt, loff_t *offt) 
17 { 
18    /* 用户实现具体功能 */ 
19    return 0; 
20 } 
21  
22 /* 关闭/释放设备 */ 
23 static int chrtest_release(struct inode *inode, struct file *filp) 
24 { 
25    /* 用户实现具体功能 */ 
26    return 0; 
27 } 
28  
29 static struct file_operations test_fops = { 
30    .owner = THIS_MODULE,    
31    .open = chrtest_open, 
32    .read = chrtest_read, 
33    .write = chrtest_write, 
34    .release = chrtest_release, 
35 }; 
36  
37 /* 驱动入口函数 */ 
38 static int __init xxx_init(void) 
39 { 
40    /* 入口函数具体内容 */ 
41    int retvalue = 0; 
42  
43    /* 注册字符设备驱动 */ 
44    retvalue = register_chrdev(200, "chrtest", &test_fops); 
45    if(retvalue < 0){ 
46        /* 字符设备注册失败,自行处理 */ 
47    } 
48    return 0; 
49 } 
50  
51 /* 驱动出口函数 */ 
52 static void __exit xxx_exit(void) 
53 { 
54    /* 注销字符设备驱动 */ 
55    unregister_chrdev(200, "chrtest"); 
56 } 
57  
58 /* 将上面两个函数指定为驱动的入口和出口函数 */ 
59 module_init(xxx_init); 
60 module_exit(xxx_exit); 

4、添加LICENSE和作者信息

LICENSE 是必须添加的，否则的话编译的时候会报错，作者信息可以添加也可以不添加。

MODULE_LICENSE()    //添加模块 LICENSE 信息 
MODULE_AUTHOR()   //添加模块作者信息 

1  /* 打开设备 */ 
2  static int chrtest_open(struct inode *inode, struct file *filp) 
3  { 
4     /* 用户实现具体功能 */ 
5     return 0; 
6  } 
...... 
57  
58 /* 将上面两个函数指定为驱动的入口和出口函数 */ 
59 module_init(xxx_init); 
60 module_exit(xxx_exit); 
61 
62 MODULE_LICENSE("GPL"); // GPL协议：（通用公共许可证）：一种授权，任何人有权取得、修改、重新发布自由软件的权力
63 MODULE_AUTHOR("kashine"); 

---

四、Linux设备号

1、设备号的组成

为了方便管理，Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备。

设备号的数据类型是dev_t，如下所示，dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。高 12 位为主设备号，低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095。

// include/linux/types.h
12 typedef __u32 __kernel_dev_t; 
...... 
15 typedef __kernel_dev_t dev_t; 


// include/uapi/asm-generic/int-ll64.h
36 typedef unsigned int __u32; 

有关设备号的操作函数：

// include/linux/kdev_t.h
6   #define MINORBITS     20 // 次设备号位数
7   #define MINORMASK     ((1U << MINORBITS) - 1) // 次设备号掩码
8   
9   #define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS)) // 获取主设备号
10  #define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK)) // 获取次设备号
11  #define MKDEV(ma,mi)  (((ma) << MINORBITS) | (mi)) // 于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号

2、设备号的分配

本小节讲的设备号分配主要是主设备号的分配。

🙊 静态分配设备号

驱动开发者静态的指定一个设备号，需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用的。

并不是说内核开发者已经分配掉的主设备号我们就不能用了，具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号。

🙊 动态分配设备号 

系统自动分配一个没有被使用的设备号，避免了冲突。

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name) 

dev：保存申请到的设备号。

baseminor：次设备号起始地址

count：要申请的设备号数量。 

name：设备名字。 

注销字符设备之后要释放掉设备号： 

void unregister_chrdev_region(dev_t from, unsigned count) 

from：要释放的设备号。 

count：表示从 from 开始，要释放的设备号数量。 

---

五、参考内容

正点原子驱动开发指南