本章我们从 Linux 驱动开发中最基础的字符设备驱动开始，重点学习 Linux 下字符设备驱动开发框架。本章会以一个虚拟的设备为例，讲解如何进行字符设备驱动开发，以及如何编写测试 APP 来测试驱动工作是否正常，为以后的学习打下坚实的基础。
字符设备驱动简介
字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。
在详细的学习字符设备驱动架构之前，我们先来简单的了解一下 Linux 下的应用程序是如何调用驱动程序的，Linux 应用程序对驱动程序的调用如下图所示：
关于用户态和内核态的问题，参考：
Linux常问面试问题之——用户态与内核态、用户态访问内核态资源的方式、用户态到内核态的切换_用户态函数可以访问核心态内存吗-CSDN博客
在 Linux 中一切皆为文件，驱动加载成功以后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。比如现在有个叫做/dev/led 的驱动文件，此文件是 led 灯的驱动文件。应用程序使用 open 函数来打开文件/dev/led，使用完成以后使用 close 函数关闭/dev/led 这个文件。open和 close 就是打开和关闭 led 驱动的函数，如果要点亮或关闭 led，那么就使用 write 函数来操作，也就是向此驱动写入数据，这个数据就是要关闭还是要打开 led 的控制参数。如果要获取led 灯的状态，就用 read 函数从驱动中读取相应的状态。
应用程序运行在用户空间，而 Linux 驱动属于内核的一部分，因此驱动运行于内核空间。
当我们在用户空间想要实现对内核的操作，比如使用 open 函数打开/dev/led 这个驱动，因为用户空间不能直接对内核进行操作，因此必须使用一个叫做“系统调用”的方法来实现从用户空间“陷入”到内核空间，这样才能实现对底层驱动的操作。open、close、write 和 read 等这些函数都是系统调用。
其中关于 C 库以及如何通过系统调用“陷入”到内核空间这个我们不用去管，我们重点关注的是应用程序和具体的驱动，应用程序使用到的函数在具体驱动程序中都有与之对应的函数，比如应用程序中调用了 open 这个函数，那么在驱动程序中也得有一个名为 open 的函数（注意，名称并不一定非要一模一样）。每一 个系统调用，在驱动中都有与之对应的一个驱动函数，在 Linux 内核文件 include/linux/fs.h 中 有个叫做 file_operations 的结构体，此结构体就是 Linux 内核驱动操作函数集合，内容如下所示：
1588 struct file_operations { 1589 struct module *owner; 1590 loff_t (*llseek) (struct file *, loff_t, int); 1591 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); 1592 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); 1593 ssize_t (*read_iter) (struct kiocb *, struct iov_iter *); 1594 ssize_t (*write_iter) (struct kiocb *, struct iov_iter *); 1595 int (*iterate) (struct file *, struct dir_context *); 1596 unsigned int (*poll) (struct file *, struct poll_table_struct *); 1597 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); 1598 long (*compat_ioctl) (struct file *, unsigned int, unsigned long); 1599 int (*mmap) (struct file *, struct vm_area_struct *); 1600 int (*mremap)(struct file *, struct vm_area_struct *); 1601 int (*open) (struct inode *, struct file *); 1602 int (*flush) (struct file *, fl_owner_t id); 1603 int (*release) (struct inode *, struct file *); 1604 int (*fsync) (struct file *, loff_t, loff_t, int datasync); 1605 int (*aio_fsync) (struct kiocb *, int datasync); 1606 int (*fasync) (int, struct file *, int); 1607 int (*lock) (struct file *, int, struct file_lock *); 1608 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); 1609 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); 1610 int (*check_flags)(int); 1611 int (*flock) (struct file *, int, struct file_lock *); 1612 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int); 1613 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int); 1614 int (*setlease)(struct file *, long, struct file_lock **, void**); 1615 long (*fallocate)(struct file *file, int mode, loff_t offset, loff_t len); 1617 void (*show_fdinfo)(struct seq_file *m, struct file *f); 1618 #ifndef CONFIG_MMU 1619 unsigned (*mmap_capabilities)(struct file *); 1620 #endif 1621 };简单介绍一下 file_operation 结构体中比较重要的、常用的函数：
第 1589 行，owner 拥有该结构体的模块的指针，一般设置为 THIS_MODULE。
第 1590 行，llseek 函数用于修改文件当前的读写位置。
第 1591 行，read 函数用于读取设备文件。
第 1592 行，write 函数用于向设备文件写入(发送)数据。
第 1596 行，poll 是个轮询函数，用于查询设备是否可以进行非阻塞的读写。
第 1597 行，unlocked_ioctl 函数提供对于设备的控制功能，与应用程序中的 ioctl 函数对应。
第 1598 行，compat_ioctl 函数与 unlocked_ioctl 函数功能一样，区别在于在 64 位系统上，32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。
第 1599 行，mmap 函数用于将设备的内存映射到进程空间中(也就是用户空间)，一般帧缓冲设备会使用此函数，比如 LCD 驱动的显存，将帧缓冲(LCD 显存)映射到用户空间中以后应用程序就可以直接操作显存了，这样就不用在用户空间和内核空间之间来回复制。
第 1601 行，open 函数用于打开设备文件。
第 1603 行，release 函数用于释放(关闭)设备文件，与应用程序中的 close 函数对应（这两个名字完全不像，所以要注意对应关系，别搞错了）。
第 1604 行，fasync 函数用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。
第 1605 行，aio_fsync 函数与 fasync 函数的功能类似，只是 aio_fsync 是异步刷新待处理的数据。
在字符设备驱动开发中最常用的就是上面这些函数，关于其他的函数大家可以查阅相关文档。我们在字符设备驱动开发中最主要的工作就是实现上面这些函数，不一定全部都要实现，但是像 open、release、write、read 等都是需要实现的，当然了，具体需要实现哪些函数还是要看具体的驱动要求。
！！！！！！这其实就是函数指针的应用，这里定义了通用的函数指针，操作系统调用的也是这些通用的指针变量，但是具体这个指针要指向什么函数，需要我们自己来实现，并赋值给这些指针变量。
字符设备驱动开发步骤
上一小节我们简单的介绍了一下字符设备驱动，那么字符设备驱动开发都有哪些步骤呢？
我们在学习裸机或者 STM32 的时候关于驱动的开发就是初始化相应的外设寄存器，在 Linux 驱动开发中肯定也是要初始化相应的外设寄存器，这个是毫无疑问的。只是在 Linux 驱动开发中我们需要按照其规定的框架来编写驱动，所以说学 Linux 驱动开发重点是学习其驱动框架。
驱动模块的加载和卸载
Linux 驱动有两种运行方式，第一种就是将驱动编译进 Linux 内核中，这样当 Linux 内核启动的时候就会自动运行驱动程序。第二种就是将驱动编译成模块(Linux 下模块扩展名为.ko)，在Linux 内核启动以后使用“insmod”命令加载驱动模块。
难怪menuconfig时，有个tristate三态类型，其中一种就是M，将模块编译成ko模块
在调试驱动的时候一般都选择将其编译为模块，这样我们修改驱动以后只需要编译一下驱动代码即可，不需要编译整个 Linux 代码。而且在调试的时候只需要加载或者卸载驱动模块即可，不需要重启整个系统。总之，将驱动编译为模块最大的好处就是方便开发，当驱动开发完成，确定没有问题以后就可以将驱动编译进Linux 内核中，当然也可以不编译进 Linux 内核中，具体看自己的需求。
模块有加载和卸载两种操作，我们在编写驱动的时候需要注册这两种操作函数，模块的加载和卸载注册函数如下：
module_init(xxx_init);//注册模块加载函数 module_exit(xxx_exit);//注册模块卸载函数module_init 函数用来向 Linux 内核注册一个模块加载函数，参数 xxx_init 就是需要注册的具体函数，当使用“insmod”命令加载驱动的时候，xxx_init 这个函数就会被调用。module_exit()函数用来向 Linux 内核注册一个模块卸载函数，参数 xxx_exit 就是需要注册的具体函数，当使用“rmmod”命令卸载具体驱动的时候 xxx_exit 函数就会被调用。字符设备驱动模块加载和卸载模板如下所示：
第 2 行，定义了个名为 xxx_init 的驱动入口函数，并且使用了“__init”来修饰。
第 9 行，定义了个名为 xxx_exit 的驱动出口函数，并且使用了“__exit”来修饰。
第 15 行，调用函数 module_init 来声明 xxx_init 为驱动入口函数，当加载驱动的时候 xxx_init函数就会被调用。
第16行，调用函数module_exit来声明xxx_exit为驱动出口函数，当卸载驱动的时候xxx_exit函数就会被调用。
上面说了，如果编译成单独模块（扩展名为.ko），就需要手动加载和卸载驱动模块。
有两种命令可以加载驱动模块：insmod和modprobe，insmod是最简单的模块加载命令，此命令用于加载指定的.ko 模块，比如加载 drv.ko 这个驱动模块，命令如下：
insmod drv.koinsmod 命令不能解决模块的依赖关系，比如 drv.ko 依赖 first.ko 这个模块，就必须先使用insmod 命令加载 first.ko 这个模块，然后再加载 drv.ko 这个模块。但是 modprobe 就不会存在这个问题，modprobe 会分析模块的依赖关系，然后会将所有的依赖模块都加载到内核中，因此modprobe 命令相比 insmod 要智能一些。modprobe 命令主要智能在提供了模块的依赖性分析、错误检查、错误报告等功能，推荐使用 modprobe 命令来加载驱动。modprobe 命令默认会去/lib/modules/<kernel-version>目录中查找模块，比如本书使用的 Linux kernel 的版本号为 4.1.15，因此 modprobe 命令默认会到/lib/modules/4.1.15 这个目录中查找相应的驱动模块，一般自己制作的根文件系统中是不会有这个目录的，所以需要自己手动创建。
驱动模块的卸载使用命令“rmmod”即可，比如要卸载 drv.ko，使用如下命令即可：
rmmod drv.ko也可以使用“modprobe -r”命令卸载驱动，比如要卸载 drv.ko，命令如下：
modprobe -r drv.ko使用 modprobe 命令可以卸载掉驱动模块所依赖的其他模块，前提是这些依赖模块已经没有被其他模块所使用，否则就不能使用 modprobe 来卸载驱动模块。所以对于模块的卸载，还是推荐使用 rmmod 命令。
如果和内核一起编译，就不用手动加载和卸载了。
字符设备注册与注销
加载是将整个驱动加载到操作系统的管理之中，但是，具体的驱动功能，还需要我们进行注册。
对于字符设备驱动而言，当驱动模块加载成功以后需要注册字符设备，同样，卸载驱动模块的时候也需要注销掉字符设备。字符设备的注册和注销函数原型如下所示:
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)register_chrdev 函数用于注册字符设备，此函数一共有三个参数，这三个参数的含义如下：
major：主设备号，Linux 下每个设备都有一个设备号，设备号分为主设备号和次设备号两部分，关于设备号后面会详细讲解。
name：设备名字，指向一串字符串。
fops：结构体 file_operations 类型指针，指向设备的操作函数集合变量。
unregister_chrdev 函数用户注销字符设备，此函数有两个参数，这两个参数含义如下：
major：要注销的设备对应的主设备号。
name：要注销的设备对应的设备名。
一般字符设备的注册在驱动模块的入口函数 xxx_init 中进行，字符设备的注销在驱动模块的出口函数 xxx_exit 中进行。在示例代码 40.2.2.1 中字符设备的注册和注销，内容如下所示：
示例代码 40.2.2.1 加入字符设备注册和注销 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);第 1 行，定义了一个 file_operations 结构体变量 test_fops，test_fops 就是设备的操作函数集合，只是此时我们还没有初始化 test_fops 中的 open、release 等这些成员变量，所以这个操作函数集合还是空的。
第 10 行，调用函数 register_chrdev 注册字符设备，主设备号为 200，设备名字为“chrtest”，设备操作函数集合就是第 1 行定义的 test_fops。要注意的一点就是，选择没有被使用的主设备号，输入命令“cat /proc/devices”可以查看当前已经被使用掉的设备号，如图 40.2.2.1 所示(限于篇幅原因，只展示一部分)：
在图 40.2.2.1 中可以列出当前系统中所有的字符设备和块设备，其中第 1 列就是设备对应的主设备号。200 这个主设备号在我的开发板中并没有被使用，所以我这里就用了 200 这个主设备号。第 21 行，调用函数 unregister_chrdev 注销主设备号为 200 的这个设备。
实现设备的具体操作函数
file_operations 结构体就是设备的具体操作函数，在示例代码 40.2.2.1 中我们定义了file_operations结构体类型的变量test_fops，但是还没对其进行初始化，也就是初始化其中的open、release、read 和 write 等具体的设备操作函数。本小节我们就完成变量 test_fops 的初始化，设置好针对 chrtest 设备的操作函数。在初始化 test_fops 之前我们要分析一下需求，也就是要对 chrtest这个设备进行哪些操作，只有确定了需求以后才知道我们应该实现哪些操作函数。假设对 chrtest这个设备有如下两个要求：
1、能够对 chrtest 进行打开和关闭操作
设备打开和关闭是最基本的要求，几乎所有的设备都得提供打开和关闭的功能。因此我们需要实现 file_operations 中的 open 和 release 这两个函数。
2、对 chrtest 进行读写操作
假设 chrtest 这个设备控制着一段缓冲区(内存)，应用程序需要通过 read 和 write 这两个函数对 chrtest 的缓冲区进行读写操作。所以需要实现 file_operations 中的 read 和 write 这两个函数。
需求很清晰了，修改示例代码 40.2.2.1，在其中加入 test_fops 这个结构体变量的初始化操作，完成以后的内容如下所示：
示例代码 40.2.3.1 加入设备操作函数 1 /* 打开设备 */ 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);在示例代码 40.2.3.1 中我们一开始编写了四个函数：chrtest_open、chrtest_read、chrtest_write和 chrtest_release。这四个函数就是 chrtest 设备的 open、read、write 和 release 操作函数。第 29行~35 行初始化 test_fops 的 open、read、write 和 release 这四个成员变量。
关于这些操作函数的一些补充
Linux驱动层其实可以看做符合Linux框架的裸机程序，我们在驱动层按照裸机开发的大体思路来获取数据，并将数据保存在某个缓存里面，之后在应用层去获取这个缓存里的数据，就类似于之前在裸机里另外起个线程，去读循环缓冲区里的数据。
一般需要实现的是open/read/write/release/ioctl/poll等函数，这些函数在结构体file_operations里面以函数指针的形式被调用，我们来了解下这几个常用函数的参数含义。
参考：
Linux字符设备驱动file_operations - GreenHand# - 博客园 (cnblogs.com)
注意，应用层的系统调用和驱动层的对应函数的参数并不是完全一致，因为并不是直接调用。参考：Linux系统调用过程详解：应用程序调用驱动过程_应用程序调用驱动函数-CSDN博客
int (*open) (struct inode * inode , struct file * filp ) ;
(inode 为文件节点,这个节点只有一个，无论用户打开多少个文件，都只是对应着一个inode结构；但是filp就不同，只要打开一个文件，就对应着一个file结构体，file结构体通常用来追踪文件在运行时的状态信息）
尽管这常常是对设备文件进行的第一个操作, 不要求驱动声明一个对应的方法. 如果这个项是 NULL, 设备打开一直成功, 但是你的驱动不会得到通知.与open()函数对应的是release()函数。
ssize_t (*read) (struct file * filp, char __user * buffer, size_t size , loff_t * p);
(指针参数 filp 为进行读取信息的目标文件，指针参数buffer 为对应放置信息的缓冲区（即用户空间内存地址），参数size为要读取的信息长度，参数 p 为读的位置相对于文件开头的偏移，在读取信息后，这个指针一般都会移动，移动的值为要读取信息的长度值）
这个函数用来从设备中获取数据。在这个位置的一个空指针导致 read 系统调用以 -EINVAL("Invalid argument") 失败。一个非负返回值代表了成功读取的字节数( 返回值是一个 "signed size" 类型, 常常是目标平台本地的整数类型).
注意，参数里的buffer是指向用户层数据的指针。前面有__user修饰符，这就表明这个buffer指针是指向用户空间的内存。
ssize_t (*write) (struct file * filp, const char __user * buffer, size_t count, loff_t * ppos);
(参数filp为目标文件结构体指针，buffer为要写入文件的信息缓冲区，count为要写入信息的长度，ppos为当前的偏移位置，这个值通常是用来判断写文件是否越界）
发送数据给设备.。如果 NULL, -EINVAL 返回给调用 write 系统调用的程序. 如果非负, 返回值代表成功写的字节数。
注意，参数里的buffer是指向用户层数据的指针。前面有__user修饰符，这就表明这个buffer指针是指向用户空间的内存。
(注：默认情况下，这个操作和上面的对文件进行读的操作均为阻塞操作）
int (*release) (struct inode *, struct file *);
release ()函数当最后一个打开设备的用户进程执行close()系统调用的时候，内核将调用驱动程序release()函数：
void release(struct inode inode,struct file *file),release函数的主要任务是清理未结束的输入输出操作，释放资源，用户自定义排他标志的复位等。在文件结构被释放时引用这个操作。如同 open, release 可以为 NULL。
int (*ioctl) (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
(inode 和 filp 指针是对应应用程序传递的文件描述符 fd 的值, 和传递给 open 方法的相同参数.cmd 参数从用户那里不改变地传下来, 并且可选的参数 arg 参数以一个 unsigned long 的形式传递, 不管它是否由用户给定为一个整数或一个指针.如果调用程序不传递第 3 个参数, 被驱动操作收到的 arg 值是无定义的.因为类型检查在这个额外参数上被关闭, 编译器不能警告你如果一个无效的参数被传递给 ioctl, 并且任何关联的错误将难以查找.）
ioctl 系统调用提供了发出设备特定命令的方法(例如格式化软盘的一个磁道, 这不是读也不是写). 另外, 几个 ioctl 命令被内核识别而不必引用 fops 表.如果设备不提供 ioctl 方法, 对于任何未事先定义的请求(-ENOTTY, "设备无这样的 ioctl"), 系统调用返回一个错误。
unsigned int (*poll) (struct file *, struct poll_table_struct *);
(这是一个设备驱动中的轮询函数，第一个参数为file结构指针，第二个为轮询表指针）
这个函数返回设备资源的可获取状态，即POLLIN，POLLOUT，POLLPRI，POLLERR，POLLNVAL等宏的位“或”结果。每个宏都表明设备的一种状态，如：POLLIN（定义为0x0001）意味着设备可以无阻塞的读，POLLOUT（定义为0x0004）意味着设备可以无阻塞的写。
(poll 方法是 3 个系统调用的后端: poll, epoll, 和 select, 都用作查询对一个或多个文件描述符的读或写是否会阻塞.poll 方法应当返回一个位掩码指示是否非阻塞的读或写是可能的, 并且, 可能地, 提供给内核信息用来使调用进程睡眠直到 I/O 变为可能. 如果一个驱动的 poll 方法为 NULL, 设备假定为不阻塞地可读可写。
(这里通常将设备看作一个文件进行相关的操作，而轮询操作的取值直接关系到设备的响应情况，可以是阻塞操作结果，同时也可以是非阻塞操作结果）
准确来说，open和release函数是在打开设备和关闭设备时要干的事情，open时，内核会找到对应的设备文件并打开，然后调用open函数进行一些自定义操作，如果不需要做什么，open可以为空，此时，设备文件也是打开的，不要以为open里没做什么设备就没打开了，设备文件的打开是由内核进行的，并会向用户空间返回一个可操作的文件描述符。
struct inode * inode
参考：Linux文件系统 struct inode 结构体解析-CSDN博客
inode包含了文件系统各种对象（文件、目录、块设备文件、字符设备文件等）的元数据。每个文件和目录在文件系统中都有一个唯一的索引节点号（Inode number），用于标识和引用该文件或目录。索引节点号在文件系统中是唯一的，通过它可以准确地找到对应的索引节点。
索引节点对象（struct inode）代表着一个具体的文件。索引节点对象在Linux内核中表示所有内核操作文件或目录所需的信息。对于类Unix风格的文件系统，这些信息直接从磁盘上的inode读取。
struct file * filp
参考：Linux文件系统 struct file 结构体解析-CSDN博客
Linux--struct file结构体 - Sophie_h - 博客园 (cnblogs.com)
struct file 是 Linux 内核中的一个重要数据结构，用于表示进程打开的文件，struct file是已经打开的文件在内存中的表示，存储与文件操作和状态相关的信息。
struct file（file结构体）： struct file结构体定义在include/linux/fs.h中定义。
struct file { /* * fu_list becomes invalid after file_free is called and queued via * fu_rcuhead for RCU freeing */ union { struct list_head fu_list; struct rcu_head fu_rcuhead; } f_u; struct path f_path; #define f_dentry f_path.dentry #define f_vfsmnt f_path.mnt const struct file_operations *f_op; atomic_t f_count; unsigned int f_flags; mode_t f_mode; loff_t f_pos; struct fown_struct f_owner; unsigned int f_uid, f_gid; struct file_ra_state f_ra; unsigned long f_version; #ifdef CONFIG_SECURITY void *f_security; #endif /* needed for tty driver, and maybe others */ void *private_data; #ifdef CONFIG_EPOLL /* Used by fs/eventpoll.c to link all the hooks to this file */ struct list_head f_ep_links; spinlock_t f_ep_lock; #endif /* #ifdef CONFIG_EPOLL */ struct address_space *f_mapping; };文件结构体代表一个打开的文件，系统中的每个打开的文件在内核空间都有一个关联的 struct file。
它由内核在打开文件时创建，并传递给在文件上进行操作的任何函数。在文件的所有实例都关闭后，内核释放这个数据结构。在内核创建和驱动源码中，
struct file的指针通常被命名为file或filp。其有两个非常重要的字段：文件描述符和缓冲区。
文件描述符fd：
fd只是一个小整数，在open时产生。起到一个索引的作用，进程通过PCB中的文件描述符表找到该fd所指向的文件指针filp。
文件描述符的操作(如: open)返回的是一个文件描述符,内核会在每个进程空间中维护一个文件描述符表, 所有打开的文件都将通过此表中的文件描述符来引用; 而流(如: fopen)返回的是一个FILE结构指针, FILE结构是包含有文件描述符的，FILE结构函数可以看作是对fd直接操作的系统调用的封装, 它的优点是带有I/O缓存。
struct file 的其他重要成员有：.
1.
mode_t f_mode; 文件模式确定文件是可读的或者是可写的(或者都是), 通过位FMODE_READ 和FMODE_WRITE. 你可能想在你的 open 或者 ioctl 函数中检查这个成员的读写许可, 但是不需要检查读写许可, 因为内核在调用你的方法之前检查. 当文件还没有为那种存取而打开时读或写的企图被拒绝, 驱动甚至不知道这个情况.
2.
loff_t f_pos; 当前读写位置. loff_t 在所有平台都是 64 位( 在 gcc 术语里是 long long ). 驱动可以读这个值,如果它需要知道文件中的当前位置, 但是正常地不应该改变它; 读和写应当使用它们作为最后参数而收到的指针来更新一个位置, 代替直接作用于 filp->f_pos. 这个规则的一个例外是在 llseek 方法中, 它的目的就是改变文件位置.
3.
unsigned int f_flags; 这些是文件标志, 例如 O_RDONLY, O_NONBLOCK, 和 O_SYNC. 驱动应当检查O_NONBLOCK 标志来看是否是请求非阻塞操作; 其他标志很少使用. 特别地，应当检查读/写许可, 使用 f_mode 而不是f_flags. 所有的标志在头文件<linux/fcntl.h> 中定义.
4.
struct file_operations *f_op; 和文件关联的操作. 内核安排指针作为它的open 实现的一部分, 接着读取它当它需要分派任何的操作时. filp->f_op 中的值从不由内核保存为后面的引用; 这意味着你可改变你的文件关联的文件操作, 在你返回调用者之后新方法会起作用. 例如, 关联到主编号 1 (/dev/null, /dev/zero, 等等)的 open 代码根据打开的次编号来替代 filp->f_op 中的操作. 这个做法允许实现几种行为, 在同一个主编号下而不必在每个系统调用中引入开销. 替换文件操作的能力是面向对象编程的"方法重载"的内核对等体。
5.
void *private_data; open 系统调用设置这个指针为 NULL，在为驱动调用 open 方法之前你可自由使用这个成员或者忽略它；你可以使用这个成员来指向分配的数据，但是接着你必须
记住在内核销毁文件结构之前，在 release 方法中释放那个内存。private_data 是一个有用的资源，在系统调用间保留状态信息，我们大部分例子模块都使用它。
6.
struct dentry *f_dentry，关联到文件的目录入口( dentry )结构，设备驱动编写者正常地不需要关心 dentry 结构，除了作为 filp->f_dentry->d_inode 存取 inode 结构。
添加 LICENSE 和作者信息
最后我们需要在驱动中加入 LICENSE 信息和作者信息，其中 LICENSE 是必须添加的，否则的话编译的时候会报错，作者信息可以添加也可以不添加。LICENSE 和作者信息的添加使用如下两个函数：
MODULE_LICENSE()//添加模块 LICENSE 信息 MODULE_AUTHOR()//添加模块作者信息最后给示例代码 40.2.3.1 加入 LICENSE 和作者信息，完成以后的内容如下：
第 62 行，LICENSE 采用 GPL 协议。 第 63 行，添加作者名字。
这个其实就是要声明Linux要遵循的开源协议。
参考：各种开源协议介绍 | 菜鸟教程 (runoob.com)
虽然Linux是开源，但是开源也要遵循一些协议的。
至此，字符设备驱动开发的完整步骤就讲解完了，而且也编写好了一个完整的字符设备驱动模板，以后字符设备驱动开发都可以在此模板上进行。
Linux 设备号
设备号的组成
为了方便管理，Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动（被使用者），次设备号表示使用这个驱动的各个设备（使用者）。
Linux 提供了一个名为 dev_t 的数据类型表示设备号，dev_t 定义在文件include/linux/types.h 里面，定义如下：
可以看出 dev_t 是__u32 类型的，而__u32 定义在文件 include/uapi/asm-generic/int-ll64.h 里面，定义如下：
综上所述，dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号，低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095，所以大家在选择主设备号的时候一定不要超过这个范围。在文件 include/linux/kdev_t.h 中提供了几个关于设备号的操作函数(本质是宏)，如下所示：
设备号的分配
1、静态分配设备号
本小节讲的设备号分配主要是主设备号的分配。前面讲解字符设备驱动的时候说过了，注册字符设备的时候需要给设备指定一个设备号，这个设备号可以是驱动开发者静态的指定一个设备号，比如选择 200 这个主设备号。有一些常用的设备号已经被 Linux 内核开发者给分配掉了，具体分配的内容可以查看文档 Documentation/devices.txt。并不是说内核开发者已经分配掉的主设备号我们就不能用了，具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号，使用“cat /proc/devices”命令即可查看当前系统中所有已经使用了的设备号。
2、动态分配设备号
静态分配设备号需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用的。而且静态分配设备号很容易带来冲突问题，Linux 社区推荐使用动态分配设备号，在注册字符设备之前先申请一个设备号，系统会自动给你一个没有被使用的设备号，这样就避免了冲突。卸载驱动的时候释放掉这个设备号即可，设备号的申请函数如下：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)函数 alloc_chrdev_region 用于申请设备号，此函数有 4 个参数：
dev：保存申请到的设备号。
baseminor：次设备号起始值，alloc_chrdev_region 可以申请一段连续的多个设备号，这些设备号的主设备号一样，但是次设备号不同，次设备号以 baseminor 为起始值开始递增。一般 baseminor 为 0，也就是说次设备号从 0 开始。
count：要申请的设备号数量。
name：设备名字。
注销字符设备之后要释放掉设备号，设备号释放函数如下：
void unregister_chrdev_region(dev_t from, unsigned count)此函数有两个参数：
from：要释放的设备号。
count：表示从 from 开始，要释放的设备号数量。
我们暂时先以静态分配设备号为例讲解。
字符设备驱动开发实验
字符设备驱动开发的基本步骤我们已经了解了，本节我们就以 chrdevbase 这个虚拟设备为例，完整的编写一个字符设备驱动模块。chrdevbase 不是实际存在的一个设备，是笔者为了方便讲解字符设备的开发而引入的一个虚拟设备。chrdevbase 设备有两个缓冲区，一个为读缓冲区，一个为写缓冲区，这两个缓冲区的大小都为 100 字节。在应用程序中可以向 chrdevbase 设备的写缓冲区中写入数据，从读缓冲区中读取数据。chrdevbase 这个虚拟设备的功能很简单，但是它包含了字符设备的最基本功能。
注意，读写的内存区域还是要我们在驱动里实现的，而不是凭空出现的，也不是内核给出的，我们在应用层使用系统调用来读写，驱动层也要支持读写才行，也要有内存区域可以读写才行。
工程建立好以后就可以开始编写驱动程序了，新建 chrdevbase.c ，然后在里面输入如下内容：示例代码 40.4.1.3 chrdevbase.c 文件 1 #include <linux/types.h> 2 #include <linux/kernel.h> 3 #include <linux/delay.h> 4 #include <linux/ide.h> 5 #include <linux/init.h> 6 #include <linux/module.h> 7 /*************************************************************** 8 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 9 文件名 : chrdevbase.c 10 作者 : 左忠凯 11 版本 : V1.0 12 描述 : chrdevbase 驱动文件。 13 其他 : 无 14 论坛 : www.openedv.com 15 日志 : 初版 V1.0 2019/1/30 左忠凯创建 16 ***************************************************************/ 17 18 #define CHRDEVBASE_MAJOR 200 /* 主设备号 */ 19 #define CHRDEVBASE_NAME "chrdevbase" /* 设备名 */ 20 21 static char readbuf[100]; /* 读缓冲区 */ 22 static char writebuf[100]; /* 写缓冲区 */ 23 static char kerneldata[] = {"kernel data!"}; 24 25 /* 26 * @description : 打开设备 27 * @param – inode : 传递给驱动的 inode 28 * @param - filp : 设备文件，file 结构体有个叫做 private_data 的成员变量 29 * 一般在 open 的时候将 private_data 指向设备结构体。 30 * @return : 0 成功;其他 失败 31 */ 32 static int chrdevbase_open(struct inode *inode, struct file *filp) 33 { 34 //printk("chrdevbase open!\r\n"); 35 return 0; 36 } 37 38 /* 39 * @description : 从设备读取数据 40 * @param - filp : 要打开的设备文件(文件描述符) 41 * @param - buf : 返回给用户空间的数据缓冲区 42 * @param - cnt : 要读取的数据长度 43 * @param - offt : 相对于文件首地址的偏移 44 * @return : 读取的字节数，如果为负值，表示读取失败 45 */ 46 static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 47 { 48 int retvalue = 0; 49 50 /* 向用户空间发送数据 */ 51 memcpy(readbuf, kerneldata, sizeof(kerneldata)); 52 retvalue = copy_to_user(buf, readbuf, cnt); 53 if(retvalue == 0){ 54 printk("kernel senddata ok!\r\n"); 55 }else{ 56 printk("kernel senddata failed!\r\n"); 57 } 58 59 //printk("chrdevbase read!\r\n"); 60 return 0; 61 } 62 63 /* 64 * @description : 向设备写数据 65 * @param - filp : 设备文件，表示打开的文件描述符 66 * @param - buf : 要写给设备写入的数据 67 * @param - cnt : 要写入的数据长度 68 * @param - offt : 相对于文件首地址的偏移 69 * @return : 写入的字节数，如果为负值，表示写入失败 70 */ 71 static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 72 { 73 int retvalue = 0; 74 /* 接收用户空间传递给内核的数据并且打印出来 */ 75 retvalue = copy_from_user(writebuf, buf, cnt); 76 if(retvalue == 0){ 77 printk("kernel recevdata:%s\r\n", writebuf); 78 }else{ 79 printk("kernel recevdata failed!\r\n"); 80 } 81 82 //printk("chrdevbase write!\r\n"); 83 return 0; 84 } 85 86 /* 87 * @description : 关闭/释放设备 88 * @param - filp : 要关闭的设备文件(文件描述符) 89 * @return : 0 成功;其他 失败 90 */ 91 static int chrdevbase_release(struct inode *inode, struct file *filp) 92 { 93 //printk("chrdevbase release！\r\n"); 94 return 0; 95 } 96 97 /* 98 * 设备操作函数结构体 99 */ 100 static struct file_operations chrdevbase_fops = { 101 .owner = THIS_MODULE, 102 .open = chrdevbase_open, 103 .read = chrdevbase_read, 104 .write = chrdevbase_write, 105 .release = chrdevbase_release, 106 }; 107 108 /* 109 * @description : 驱动入口函数 110 * @param : 无 111 * @return : 0 成功;其他 失败 112 */ 113 static int __init chrdevbase_init(void) 114 { 115 int retvalue = 0; 116 117 /* 注册字符设备驱动 */ 118 retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops); 119 if(retvalue < 0){ 120 printk("chrdevbase driver register failed\r\n"); 121 } 122 printk("chrdevbase_init()\r\n"); 123 return 0; 124 } 125 126 /* 127 * @description : 驱动出口函数 128 * @param : 无 129 * @return : 无 130 */ 131 static void __exit chrdevbase_exit(void) 132 { 133 /* 注销字符设备驱动 */ 134 unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME); 135 printk("chrdevbase_exit()\r\n"); 136 } 137 138 /* 139 * 将上面两个函数指定为驱动的入口和出口函数 140 */ 141 module_init(chrdevbase_init); 142 module_exit(chrdevbase_exit); 143 144 /* 145 * LICENSE 和作者信息 146 */ 147 MODULE_LICENSE("GPL"); 148 MODULE_AUTHOR("zuozhongkai");应用程序调用 open 函数打开 chrdevbase 这个设备，打开以后可以使用 write 函数向chrdevbase 的写缓冲区writebuf 中写入数据(不超过 100 个字节)，也可以使用 read 函数读取读缓冲区 readbuf 中的数据操作，操作完成以后应用程序使用 close 函数关闭 chrdevbase 设备。
第 32~36 行，chrdevbase_open 函数，当应用程序调用 open 函数的时候此函数就会调用，本例程中我们没有做任何工作，只是输出一串字符，用于调试（驱动层没有做任何用户性的事情，应用层也要open来获取文件描述符）。这里使用了 printk 来输出信息，而不是 printf！因为在 Linux 内核中没有 printf 这个函数。printk 相当于 printf 的孪生兄妹，printf运行在用户态，printk 运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用printk 这个函数。
参数 filp 有个叫做 private_data 的成员变量，private_data 是个 void 指针，一般在驱动中将private_data 指向设备结构体，设备结构体会存放设备的一些属性。
第 46~61 行，chrdevbase_read 函数，应用程序调用 read 函数从设备中读取数据的时候此函数会执行。参数 buf 是用户空间的内存，读取到的数据存储在 buf 中，参数 cnt 是要读取的字节数，参数 offt 是相对于文件首地址的偏移。kerneldata 里面保存着用户空间要读取的数据，第 51行先将 kerneldata 数组中的数据拷贝到读缓冲区 readbuf 中，第 52 行通过函数 copy_to_user 将readbuf 中的数据复制到参数 buf 中。因为内核空间不能直接操作用户空间的内存，因此需要借助 copy_to_user 函数来完成内核空间的数据到用户空间的复制。copy_to_user 函数原型如下：static inline long copy_to_user(void __user *to, const void *from, unsigned long n) 参数 to 表示目的，参数 from 表示源，参数 n 表示要复制的数据长度。如果复制成功，返回值为 0，如果复制失败则返回负数。
第 71~84 行，chrdevbase_write 函数，应用程序调用 write 函数向设备写数据的时候此函数就会执行。参数 buf 就是应用程序要写入设备的数据，也是用户空间的内存，参数 cnt 是要写入的数据长度，参数 offt 是相对文件首地址的偏移。第 75 行通过函数 copy_from_user 将 buf 中的数据复制到写缓冲区 writebuf 中，因为用户空间内存不能直接访问内核空间的内存，所以需要借助函数 copy_from_user 将用户空间的数据复制到 writebuf 这个内核空间中。
第 91~95 行，chrdevbase_release 函数，应用程序调用 close 关闭设备文件的时候此函数会执行，一般会在此函数里面执行一些释放操作。如果在 open 函数中设置了 filp 的 private_data成员变量指向设备结构体，那么在 release 函数最终就要释放掉。
第 100~106 行，新建 chrdevbase 的设备文件操作结构体 chrdevbase_fops，初始化chrdevbase_fops。
第 113~124 行，驱动入口函数 chrdevbase_init，第 118 行调用函数 register_chrdev 来注册字符设备。
第 131~136 行，驱动出口函数 chrdevbase_exit，第 134 行调用函数 unregister_chrdev 来注销字符设备。
第 141~142 行，通过 module_init 和 module_exit 这两个函数来指定驱动的入口和出口函数。
第 147~148 行，添加 LICENSE 和作者信息。
第 21 行，数组 usrdata 是测试 APP 要向 chrdevbase 设备写入的数据。
第 35 行，判断运行测试 APP 的时候输入的参数是不是为 3 个，main 函数的 argc 参数表示参数数量，argv[]保存着具体的参数，如果参数不为 3 个的话就表示测试 APP 用法错误。比如，现在要从 chrdevbase 设备中读取数据，需要输入如下命令：./chrdevbaseApp /dev/chrdevbase 1
上述命令一共有三个参数“./chrdevbaseApp”、“/dev/chrdevbase”和“1”，这三个参数分别对应 argv[0]、argv[1]和 argv[2]。第一个参数表示运行 chrdevbaseAPP 这个软件，第二个参数表示测试APP要打开/dev/chrdevbase这个设备。第三个参数就是要执行的操作，1表示从chrdevbase中读取数据，2 表示向 chrdevbase 写数据。
第 40 行，获取要打开的设备文件名字，argv[1]保存着设备名字。
第 43 行，调用 C 库中的 open 函数打开设备文件：/dev/chrdevbase。
第 49 行，判断 argv[2]参数的值是 1 还是 2，因为输入命令的时候其参数都是字符串格式的，因此需要借助 atoi 函数将字符串格式的数字转换为真实的数字。
第 50 行，当 argv[2]为 1 的时候表示要从 chrdevbase 设备中读取数据，一共读取 50 字节的数据，读取到的数据保存在 readbuf 中，读取成功以后就在终端上打印出读取到的数据。
第 59 行，当 argv[2]为 2 的时候表示要向 chrdevbase 设备写数据。
第 69 行，对 chrdevbase 设备操作完成以后就关闭设备。
chrdevbaseApp.c 内容还是很简单的，就是最普通的文件打开、关闭和读写操作。
更多待补充。。。。。。
函数copy_from_user()和copy_to_user()
参考：
编译内核函数copy_from_user()和copy_to_user()_内核态拷贝到用户态函数 头文件-CSDN博客
初步解析内核函数copy_to_user和copy_from_user_copy to user-CSDN博客
copy_from_user(rwbuf, buf, count);【作用】：从用户空间复制到内核空间
copy_to_user( buf, rwbuf, count);【作用】：从内核空间复制到用户空间
【头文件】：
#include <linux/uaccess.h> // copy_to_user() & copy_from_user
【参数】：
rwbuf：这个是（内核空间中的）模块文件中的数组
buf：这个是（用户空间中）调用时传入的参数
count：数组长度
记忆：
都是将第二个数组的值赋值给第一个参数
rwbuf←buf就是从用户态到内核态，这是from_user；buf←rwbuf就是从内核态到用户态，这是to_user；
自己写的驱动文件怎么和linux内核关联起来？
这里面其实分为两个部分，一个是驱动文件，一个是应用文件；
如果驱动是独立的模块，那么就编译成.ko之后放到文件系统特定的目录下，然后将新的文件系统烧录到开发板，在开发板中加载驱动模块，然后在dev下生成一个设备文件，提供给应用程序来操作；至于应用文件，其实就是一个可执行程序，也是放到文件系统中，但是对路径没有特别的要求，只需要能找到这个可执行文件，然后./appname执行即可，这个和常规的c文件编译后执行是一样的。
这里，要区分驱动程序和应用程序。
将驱动文件编译成.ko模块的时候，执行make，报错
cc1: error: code model kernel does not support PIC mode
我的第一感觉就是没有指定交叉编译工具链。
于是，就指定了交叉编译工具链
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -j12果然有用
参考：make 工具如何指定编译工具链_makefile指定交叉编译器-CSDN博客
之后多了好多文件，其中就有个.ko文件
也就是我们要的模块文件。
开发板加载驱动时，报错
insmod: can't insert 'chrdevbase.ko': No such file or directory
明明已经有了该文件
为啥？
看看是不是设备号重复了
cat /proc/devices
可以看到，没有与200这个设备号重复的。明明有，却没有找到，而且我也没有设置PATH环境变量，那就很有可能是要自己进入到对应的目录下去执行。试一下
果然如此。那这样的话，我为啥非要放在/lib/modules/4.1.15目录下？随便放个目录不就行了？反正都要进入该目录里执行加载命令。insmod应该是能在任何目录下执行的，应该是路径名有问题。
貌似也没错，就是4.1.15搞不懂为啥，还是说insmod只能进入到对应目录后才能执行？待明确。
小结
以上我们将驱动源码编译成单独的.ko模块，然后放在根文件的特定目录下并烧录到开发板中，接着在开发板上使用insmod手动去加载驱动，驱动加载时会进行初始化，初始化里面会注册字符驱动，其中包括驱动的设备号、驱动的名字，以及对应的操作函数
这样，模块加载之后设备就会被注册到内核中。
要注意，虽然注册了设备，但是并不会自动在/dev下生成对应的设备文件，还需要我们手动去生成，使用如下命令：
mknod /dev/chrdevbase c 200 0其中“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个字符设备，“200”是设备的主设备号，“0”是设备的次设备号。创建完成以后就会存在/dev/chrdevbase 这个文件。
这里设备节点的名字并不一定要和设备驱动的名字一致吧？待确认。关键是要和对应的设备号匹配。
框架应用：Linux LED驱动开发
学习基本框架之后，我们就开始编写第一个真正的 Linux 字符设备驱动。在 I.MX6U-ALPHA 开发板上有一个 LED 灯，本章我们就来学习一下如何编写 Linux 下的 LED 灯驱动。
Linux 下 LED 灯驱动原理
Linux 下的任何外设驱动，最终都是要配置相应的硬件寄存器。所以本章的 LED 灯驱动最终也是对 I.MX6ULL 的 IO 口进行配置，与裸机实验不同的是，在 Linux 下编写驱动要符合 Linux的驱动框架。
I.MX6U-ALPHA 开发板上的 LED 连接到 I.MX6ULL 的 GPIO1_IO03 这个引脚上，因此本章实验的重点就是编写 Linux 下 I.MX6UL 引脚控制驱动。
地址映射
在编写驱动之前，我们需要先简单了解一下 MMU 这个神器，MMU 全称叫做 Memory Manage Unit，也就是内存管理单元。在老版本的 Linux 中要求处理器必须有 MMU，但是现在Linux 内核已经支持无 MMU 的处理器了。MMU 主要完成的功能如下：
①、完成虚拟空间到物理空间的映射。
②、内存保护，设置存储器的访问权限，设置虚拟存储空间的缓冲特性。
我们重点来看一下第①点，也就是虚拟空间到物理空间的映射，也叫做地址映射。首先了解两个地址概念：虚拟地址(VA,Virtual Address)、物理地址(PA，PhyscicalAddress)。对于 32 位的处理器来说，虚拟地址范围是 2^32=4GB，我们的开发板上有 512MB 的 DDR3，这 512MB 的内存就是物理内存，经过 MMU 可以将其映射到整个 4GB 的虚拟空间，如图 41.1.1 所示：
物理内存只有 512MB，虚拟内存有 4GB，那么肯定存在多个虚拟地址映射到同一个物理地址上去，虚拟地址范围比物理地址范围大的问题处理器自会处理，这里我们不要去深究，因为MMU 是很复杂的一个东西。
Linux 内核启动的时候会初始化 MMU，设置好内存映射，设置好以后 CPU 访问的都是虚拟地址。比如I.MX6ULL的GPIO1_IO03引脚的复用寄存器IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03 的地址为 0X020E0068。如果没有开启 MMU 的话直接向 0X020E0068 这个寄存器地址写入数据就可以配置 GPIO1_IO03 的复用功能。现在开启了 MMU，并且设置了内存映射，因此就不能直接向 0X020E0068 这个地址写入数据了。我们必须得到 0X020E0068 这个物理地址在 Linux 系统里面对应的虚拟地址，这里就涉及到了物理内存和虚拟内存之间的转换，需要用到两个函数：ioremap 和 iounmap。
1、ioremap 函数
ioremap 函数用于获取指定物理地址空间对应的虚拟地址空间，定义在arch/arm/include/asm/io.h 文件中，定义如下：
ioremap 是个宏，有两个参数：cookie 和 size，真正起作用的是函数__arm_ioremap，此函数有三个参数和一个返回值，这些参数和返回值的含义如下：
phys_addr：要映射的物理起始地址。
size：要映射的内存空间大小。
mtype：ioremap 的类型，可以选择 MT_DEVICE、MT_DEVICE_NONSHARED、MT_DEVICE_CACHED 和 MT_DEVICE_WC，ioremap 函数选择 MT_DEVICE。
返回值：__iomem 类型的指针，指向映射后的虚拟空间首地址。
假如我们要获取 I.MX6ULL 的 IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03 寄存器对应的虚拟地址，使用如下代码即可：
#define SW_MUX_GPIO1_IO03_BASE (0X020E0068) static void __iomem* SW_MUX_GPIO1_IO03; SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);宏 SW_MUX_GPIO1_IO03_BASE 是寄存器物理地址，SW_MUX_GPIO1_IO03 是映射后的虚拟地址。对于 I.MX6ULL 来说一个寄存器是 4 字节(32 位)的，因此映射的内存长度为 4。
映射完成以后直接对 SW_MUX_GPIO1_IO03 进行读写操作即可。
2、iounmap 函数
卸载驱动的时候需要使用 iounmap 函数释放掉 ioremap 函数所做的映射，iounmap 函数原型如下：
iounmap 只有一个参数 addr，此参数就是要取消映射的虚拟地址空间首地址。假如我们现在要取消掉 IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03 寄存器的地址映射，使用如下代码即可：
iounmap(SW_MUX_GPIO1_IO03);从这里我们可以知道，linux并不直接操作物理地址，而是需要先将物理地址映射到成虚拟地址，然后linux再操作虚拟地址，而单片机中，都是直接操作的物理地址，要将二者作区分。
I/O 内存访问函数
使用 ioremap 函数将寄存器的物理地址映射到虚拟地址以后，我们就可以直接通过指针访问这些地址，但是 Linux 内核不建议这么做，而是推荐使用一组操作函数来对映射后的内存进行读写操作。
1、读操作函数
读操作函数有如下几个：
示例代码 41.1.2.1 读操作函数
u8 readb(const volatile void __iomem *addr) u16 readw(const volatile void __iomem *addr) u32 readl(const volatile void __iomem *addr)readb、readw 和 readl 这三个函数分别对应 8bit、16bit 和 32bit 读操作，参数 addr 就是要读取写内存地址，返回值就是读取到的数据。
2、写操作函数
写操作函数有如下几个：
示例代码 41.1.2.2 写操作函数
void writeb(u8 value, volatile void __iomem *addr) void writew(u16 value, volatile void __iomem *addr) void writel(u32 value, volatile void __iomem *addr)writeb、writew 和 writel 这三个函数分别对应 8bit、16bit 和 32bit 写操作，参数 value 是要写入的数值，addr 是要写入的地址。
LED 灯驱动程序编写
工程创建好以后新建 led.c 文件，此文件就是 led 的驱动文件，在 led.c 里面输入如下内容：
示例代码 41.3.1.1 led.c 驱动文件代码 1 #include <linux/types.h> 2 #include <linux/kernel.h> 3 #include <linux/delay.h> 4 #include <linux/ide.h> 5 #include <linux/init.h> 6 #include <linux/module.h> 7 #include <linux/errno.h> 8 #include <linux/gpio.h> 9 #include <asm/mach/map.h> 10 #include <asm/uaccess.h> 11 #include <asm/io.h> 12 /*************************************************************** 13 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 14 文件名 : led.c 15 作者 : 左忠凯 16 版本 : V1.0 17 描述 : LED 驱动文件。 18 其他 : 无 19 论坛 : www.openedv.com 20 日志 : 初版 V1.0 2019/1/30 左忠凯创建 21 ***************************************************************/ 22 #define LED_MAJOR 200 /* 主设备号 */ 23 #define LED_NAME "led" /* 设备名字 */ 24 25 #define LEDOFF 0 /* 关灯 */ 26 #define LEDON 1 /* 开灯 */ 27 28 /* 寄存器物理地址 */ 29 #define CCM_CCGR1_BASE (0X020C406C) 30 #define SW_MUX_GPIO1_IO03_BASE (0X020E0068) 31 #define SW_PAD_GPIO1_IO03_BASE (0X020E02F4) 32 #define GPIO1_DR_BASE (0X0209C000) 33 #define GPIO1_GDIR_BASE (0X0209C004) 34 35 /* 映射后的寄存器虚拟地址指针 */ 36 static void __iomem *IMX6U_CCM_CCGR1; 37 static void __iomem *SW_MUX_GPIO1_IO03; 38 static void __iomem *SW_PAD_GPIO1_IO03; 39 static void __iomem *GPIO1_DR; 40 static void __iomem *GPIO1_GDIR; 41 42 /* 43 * @description : LED 打开/关闭 44 * @param - sta : LEDON(0) 打开 LED，LEDOFF(1) 关闭 LED 45 * @return : 无 46 */ 47 void led_switch(u8 sta) 48 { 49 u32 val = 0; 50 if(sta == LEDON) { 51 val = readl(GPIO1_DR); 52 val &= ~(1 << 3); 53 writel(val, GPIO1_DR); 54 }else if(sta == LEDOFF) { 55 val = readl(GPIO1_DR); 56 val|= (1 << 3); 57 writel(val, GPIO1_DR); 58 } 59 } 60 61 /* 62 * @description : 打开设备 63 * @param – inode : 传递给驱动的 inode 64 * @param - filp : 设备文件，file 结构体有个叫做 private_data 的成员变量 65 * 一般在 open 的时候将 private_data 指向设备结构体。 66 * @return : 0 成功;其他 失败 67 */ 68 static int led_open(struct inode *inode, struct file *filp) 69 { 70 return 0; 71 } 72 73 /* 74 * @description : 从设备读取数据 75 * @param - filp : 要打开的设备文件(文件描述符) 76 * @param - buf : 返回给用户空间的数据缓冲区 77 * @param - cnt : 要读取的数据长度 78 * @param - offt : 相对于文件首地址的偏移 79 * @return : 读取的字节数，如果为负值，表示读取失败 80 */ 81 static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 82 { 83 return 0; 84 } 85 86 /* 87 * @description : 向设备写数据 88 * @param - filp : 设备文件，表示打开的文件描述符 89 * @param - buf : 要写给设备写入的数据 90 * @param - cnt : 要写入的数据长度 91 * @param - offt : 相对于文件首地址的偏移 92 * @return : 写入的字节数，如果为负值，表示写入失败 93 */ 94 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 95 { 96 int retvalue; 97 unsigned char databuf[1]; 98 unsigned char ledstat; 99 100 retvalue = copy_from_user(databuf, buf, cnt); 101 if(retvalue < 0) { 102 printk("kernel write failed!\r\n"); 103 return -EFAULT; 104 } 105 106 ledstat = databuf[0]; /* 获取状态值 */ 107 108 if(ledstat == LEDON) { 109 led_switch(LEDON); /* 打开 LED 灯 */ 110 } else if(ledstat == LEDOFF) { 111 led_switch(LEDOFF); /* 关闭 LED 灯 */ 112 } 113 return 0; 114 } 115 116 /* 117 * @description : 关闭/释放设备 118 * @param – filp : 要关闭的设备文件(文件描述符) 119 * @return : 0 成功;其他 失败 120 */ 121 static int led_release(struct inode *inode, struct file *filp) 122 { 123 return 0; 124 } 125 126 /* 设备操作函数 */ 127 static struct file_operations led_fops = { 128 .owner = THIS_MODULE, 129 .open = led_open, 130 .read = led_read, 131 .write = led_write, 132 .release = led_release, 133 }; 134 135 /* 136 * @description : 驱动入口函数 137 * @param : 无 138 * @return : 无 139 */ 140 static int __init led_init(void) 141 { 142 int retvalue = 0; 143 u32 val = 0; 144 145 /* 初始化 LED */ 146 /* 1、寄存器地址映射 */ 147 IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4); 148 SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4); 149 SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4); 150 GPIO1_DR = ioremap(GPIO1_DR_BASE, 4); 151 GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4); 152 153 /* 2、使能 GPIO1 时钟 */ 154 val = readl(IMX6U_CCM_CCGR1); 155 val &= ~(3 << 26); /* 清除以前的设置 */ 156 val |= (3 << 26); /* 设置新值 */ 157 writel(val, IMX6U_CCM_CCGR1); 158 159 /* 3、设置 GPIO1_IO03 的复用功能，将其复用为 160 * GPIO1_IO03，最后设置 IO 属性。 161 */ 162 writel(5, SW_MUX_GPIO1_IO03); 163 164 /* 寄存器 SW_PAD_GPIO1_IO03 设置 IO 属性 */ 165 writel(0x10B0, SW_PAD_GPIO1_IO03); 166 167 /* 4、设置 GPIO1_IO03 为输出功能 */ 168 val = readl(GPIO1_GDIR); 169 val &= ~(1 << 3); /* 清除以前的设置 */ 170 val |= (1 << 3); /* 设置为输出 */ 171 writel(val, GPIO1_GDIR); 172 173 /* 5、默认关闭 LED */ 174 val = readl(GPIO1_DR); 175 val |= (1 << 3); 176 writel(val, GPIO1_DR); 177 178 /* 6、注册字符设备驱动 */ 179 retvalue = register_chrdev(LED_MAJOR, LED_NAME, &led_fops); 180 if(retvalue < 0){ 181 printk("register chrdev failed!\r\n"); 182 return -EIO; 183 } 184 return 0; 185 } 186 187 /* 188 * @description : 驱动出口函数 189 * @param : 无 190 * @return : 无 191 */ 192 static void __exit led_exit(void) 193 { 194 /* 取消映射 */ 195 iounmap(IMX6U_CCM_CCGR1); 196 iounmap(SW_MUX_GPIO1_IO03); 197 iounmap(SW_PAD_GPIO1_IO03); 198 iounmap(GPIO1_DR); 199 iounmap(GPIO1_GDIR); 200 201 /* 注销字符设备驱动 */ 202 unregister_chrdev(LED_MAJOR, LED_NAME); 203 } 204 205 module_init(led_init); 206 module_exit(led_exit); 207 MODULE_LICENSE("GPL"); 208 MODULE_AUTHOR("zuozhongkai");第 22~26 行，定义了一些宏，包括主设备号、设备名字、LED 开/关宏。
第 29~33 行，本实验要用到的寄存器宏定义。
第 36~40 行，经过内存映射以后的寄存器地址指针。
第 47~59 行，led_switch 函数，用于控制开发板上的 LED 灯亮灭，当参数 sta 为 LEDON(1)的时候打开 LED 灯，sta 为 LEDOFF(0)的时候关闭 LED 灯。
第 68~71 行，led_open 函数，为空函数，可以自行在此函数中添加相关内容，一般在此函数中将设备结构体作为参数 filp 的私有数据(filp->private_data)。
第 81~84 行，led_read 函数，为空函数，如果想在应用程序中读取 LED 的状态，那么就可以在此函数中添加相应的代码，比如读取 GPIO1_DR 寄存器的值，然后返回给应用程序。
第 94~114 行，led_write 函数，实现对 LED 灯的开关操作，当应用程序调用 write 函数向led 设备写数据的时候此函数就会执行。首先通过函数 copy_from_user 获取应用程序发送过来的操作信息(打开还是关闭 LED)，最后根据应用程序的操作信息来打开或关闭 LED 灯。
第 121~124 行，led_release 函数，为空函数，可以自行在此函数中添加相关内容，一般关闭设备的时候会释放掉 led_open 函数中添加的私有数据。
第 127~133 行，设备文件操作结构体 led_fops 的定义和初始化。
第 140~185 行，驱动入口函数 led_init，此函数实现了 LED 的初始化工作，147~151 行通过ioremap 函数获取物理寄存器地址映射后的虚拟地址，得到寄存器对应的虚拟地址以后就可以完成相关初始化工作了。比如使能 GPIO1 时钟、设置 GPIO1_IO03 复用功能、配置 GPIO1_IO03的属性等等。最后，最重要的一步！使用 register_chrdev 函数注册 led 这个字符设备。
第 192~202 行，驱动出口函数 led_exit，首先使用函数 iounmap 取消内存映射，最后使用函数 unregister_chrdev 注销 led 这个字符设备。
第 205~206 行，使用 module_init 和 module_exit 这两个函数指定 led 设备驱动加载和卸载函数。
第 207~208 行，添加 LICENSE 和作者信息。
编写测试 APP，led 驱动加载成功以后手动创建/dev/led 节点，应用 APP 通过操作/dev/led文件来完成对 LED 设备的控制。向/dev/led 文件写 0 表示关闭 LED 灯，写 1 表示打开 LED 灯。
新建 ledApp.c 文件，在里面输入如下内容：
示例代码 41.3.2.1 ledApp.c 文件代码 1 #include "stdio.h" 2 #include "unistd.h" 3 #include "sys/types.h" 4 #include "sys/stat.h" 5 #include "fcntl.h" 6 #include "stdlib.h" 7 #include "string.h" 8 /*************************************************************** 9 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 10 文件名 : ledApp.c 11 作者 : 左忠凯 12 版本 : V1.0 13 描述 : LED 驱测试 APP。 14 其他 : 无 15 使用方法 ：./ledtest /dev/led 0 关闭 LED 16 ./ledtest /dev/led 1 打开 LED 17 论坛 : www.openedv.com 18 日志 : 初版 V1.0 2019/1/30 左忠凯创建 19 ***************************************************************/ 20 21 #define LEDOFF 0 22 #define LEDON 1 23 24 /* 25 * @description : main 主程序 26 * @param - argc : argv 数组元素个数 27 * @param - argv : 具体参数 28 * @return : 0 成功;其他 失败 29 */ 30 int main(int argc, char *argv[]) 31 { 32 int fd, retvalue; 33 char *filename; 34 unsigned char databuf[1]; 35 36 if(argc != 3){ 37 printf("Error Usage!\r\n"); 38 return -1; 39 } 40 41 filename = argv[1]; 42 43 /* 打开 led 驱动 */ 44 fd = open(filename, O_RDWR); 45 if(fd < 0){ 46 printf("file %s open failed!\r\n", argv[1]); 47 return -1; 48 } 49 50 databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */ 51 52 /* 向/dev/led 文件写入数据 */ 53 retvalue = write(fd, databuf, sizeof(databuf)); 54 if(retvalue < 0){ 55 printf("LED Control Failed!\r\n"); 56 close(fd); 57 return -1; 58 } 59 60 retvalue = close(fd); /* 关闭文件 */ 61 if(retvalue < 0){ 62 printf("file %s close failed!\r\n", argv[1]); 63 return -1; 64 } 65 return 0; 66 }
其实，手动指定设备号以及手动注册设备节点的方式肯定是比较落后的，linux对此不断优化。
Linux新字符设备驱动框架
字符设备驱动开发重点是使用 register_chrdev 函数注册字符设备，当不再使用设备的时候就使用 unregister_chrdev 函数注销字符设备，驱动模块加载成功以后还需要手动使用 mknod 命令创建设备节点。register_chrdev 和 unregister_chrdev 这两个函数是老版本驱动使用的函数，现在新的字符设备驱动已经不再使用这两个函数，而是使用Linux内核推荐的新字符设备驱动API函数。接下来我们就来学习一下如何编写新字符设备驱动，并且在驱动模块加载的时候自动创建设备节点文件。
其实，对于自定义的驱动函数，如果想要用老版本的方式也是可以的。只是不推荐。
自动分配和释放设备号
使用 register_chrdev 函数注册字符设备的时候只需要给定一个主设备号即可，但是这样会带来两个问题：
①、需要我们事先确定好哪些主设备号没有使用。
②、会将一个主设备号下的所有次设备号都使用掉，比如现在设置 LED 这个主设备号为200，那么 0~1048575(2^20-1)这个区间的次设备号就全部都被 LED 一个设备分走了。这样太浪费次设备号了！一个 LED 设备肯定只能有一个主设备号，一个次设备号。
解决这两个问题最好的方法就是要使用设备号的时候向 Linux 内核申请，需要几个就申请几个，由 Linux 内核分配设备可以使用的设备号。这个就是我们上面讲解的设备号的分配，如果没有指定设备号的话就使用如下函数来申请设备号：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)如果给定了设备的主设备号和次设备号就使用如下所示函数来注册设备号即可：
int register_chrdev_region(dev_t from, unsigned count, const char *name)参数 from 是要申请的起始设备号，也就是给定的设备号；参数 count 是要申请的数量，一般都是1个；参数 name 是设备名字。
这里面需要注意，自定义的设备号需要注册，向系统申请的不用再注册。
注销字符设备之后要释放掉设备号，不管是通过alloc_chrdev_region函数还是 register_chrdev_region 函数申请的设备号，统一使用如下释放函数：
void unregister_chrdev_region(dev_t from, unsigned count)新字符设备驱动下，设备号分配示例代码如下：
示例代码 42.1.1.1 新字符设备驱动下设备号分配 1 int major; /* 主设备号 */ 2 int minor; /* 次设备号 */ 3 dev_t devid; /* 设备号 */ 4 5 if (major) { /* 定义了主设备号 */ 6 devid = MKDEV(major, 0); /* 大部分驱动次设备号都选择 0*/ 7 register_chrdev_region(devid, 1, "test"); 8 } else { /* 没有定义设备号 */ 9 alloc_chrdev_region(&devid, 0, 1, "test"); /* 申请设备号 */ 10 major = MAJOR(devid); /* 获取分配号的主设备号 */ 11 minor = MINOR(devid); /* 获取分配号的次设备号 */ 12 }这里要捋一捋，如果我已经指定了主设备号和次设备号，那么，就可以合起来生成一个设备号，之后，向系统注册这个设备号，让系统知道；如果是向系统申请的设备号，系统本身就已经知道了这个设备号，不需要我再主动上报了，我从系统获取设备号之后，再从中获取主设备号和次设备号以备用。
这就是这段程序的含义。
第 1~3 行，定义了主/次设备号变量 major 和 minor，以及设备号变量 devid。
第 5 行，判断主设备号 major 是否有效，在 Linux 驱动中一般给出主设备号的话就表示这个设备的设备号已经确定了，因为次设备号基本上都选择 0，这算个 Linux 驱动开发中约定俗成的一种规定了。
第 6 行，如果 major 有效的话就使用 MKDEV 来构建设备号，次设备号选择 0。
第 7 行，使用 register_chrdev_region 函数来注册设备号。
第 9~11 行，如果 major 无效，那就表示没有给定设备号。此时就要使用 alloc_chrdev_region函数来申请设备号。设备号申请成功以后使用 MAJOR 和 MINOR 来提取出主设备号和次设备号，当然了，第 10 和 11 行提取主设备号和次设备号的代码可以不要。
如果要注销设备号的话，使用如下代码即可：
unregister_chrdev_region(devid, 1);/* 注销设备号 */注销设备号的代码很简单。
新的字符设备注册方法
在 Linux 新的驱动框架中，中使用 cdev 结构体表示一个字符设备，cdev 结构体在 include/linux/cdev.h 文件中的定义如下：
在 cdev 中有两个重要的成员变量：ops 和 dev，这两个就是字符设备文件操作函数集合file_operations 以及设备号 dev_t。编写字符设备驱动之前需要定义一个 cdev 结构体变量，这个变量就表示一个字符设备，如下所示：
struct cdev test_cdev;cdev_init 函数
定义好 cdev 变量以后就要使用 cdev_init 函数对其进行初始化，cdev_init 函数原型如下：
void cdev_init(struct cdev *cdev, const struct file_operations *fops)参数 cdev 就是要初始化的 cdev 结构体变量，参数 fops 就是字符设备文件操作函数集合。
使用 cdev_init 函数初始化 cdev 变量的示例代码如下：
示例代码 42.1.2.2 cdev_init 函数使用示例代码 1 struct cdev testcdev; 2 3 /* 设备操作函数 */ 4 static struct file_operations test_fops = { 5 .owner = THIS_MODULE, 6 /* 其他具体的初始项 */ 7 }; 8 9 testcdev.owner = THIS_MODULE; 10 cdev_init(&testcdev, &test_fops); /* 初始化 cdev 结构体变量 */初始化时主要是关联操作函数。
cdev_add 函数
cdev_add 函数用于向 Linux 系统添加字符设备(cdev 结构体变量)，首先使用 cdev_init 函数完成对 cdev 结构体变量的初始化，然后使用 cdev_add 函数向 Linux 系统添加这个字符设备。
cdev_add 函数原型如下：
int cdev_add(struct cdev *p, dev_t dev, unsigned count)参数 p 指向要添加的字符设备(cdev 结构体变量)，参数 dev 就是设备所使用的设备号，参数 count 是要添加的设备数量。完善示例代码，加入 cdev_add 函数，内容如下所示：
示例代码 42.1.2.2 cdev_add 函数使用示例 1 struct cdev testcdev; 2 3 /* 设备操作函数 */ 4 static struct file_operations test_fops = { 5 .owner = THIS_MODULE, 6 /* 其他具体的初始项 */ 7 }; 8 9 testcdev.owner = THIS_MODULE; 10 cdev_init(&testcdev, &test_fops); /* 初始化 cdev 结构体变量 */ 11 cdev_add(&testcdev, devid, 1); /* 添加字符设备 */示例代码 42.1.2.2 就是新的注册字符设备代码段，Linux 内核中大量的字符设备驱动都是采用这种方法向 Linux 内核添加字符设备。如果在加上示例代码 42.1.1.1 中分配设备号的程序，那么就它们一起实现的就是函数 register_chrdev 的功能。
cdev_del 函数
卸载驱动的时候一定要使用 cdev_del 函数从 Linux 内核中删除相应的字符设备，cdev_del函数原型如下：
void cdev_del(struct cdev *p)参数 p 就是要删除的字符设备。如果要删除字符设备，参考如下代码：
cdev_del(&testcdev); /* 删除 cdev */cdev_del 和 unregister_chrdev_region(释放设备号) 这两个函数合起来的功能相当于 unregister_chrdev 函数。
注意，以上是新的字符设备的注册方法。注册的时候需要设备号，设备号也可以用新的方法来获得。那么接下来，我们继续学习怎么自动创建设备节点文件。
自动创建设备节点
在前面的 Linux 驱动实验中，当我们使用 modprobe 加载驱动程序以后还需要使用命令“mknod”手动创建设备节点。本节就来讲解一下如何实现自动创建设备节点，在驱动中实现自动创建设备节点的功能以后，使用 modprobe 加载驱动模块成功的话就会自动在/dev 目录下创建对应的设备文件。
mdev 机制
udev 是一个用户程序，在 Linux 下通过 udev 来实现设备文件的创建与删除，udev 可以检测系统中硬件设备状态，可以根据系统中硬件设备状态来创建或者删除设备文件。比如使用modprobe 命令成功加载驱动模块以后就自动在/dev 目录下创建对应的设备节点文件,使用rmmod 命令卸载驱动模块以后就删除掉/dev 目录下的设备节点文件。使用 busybox 构建根文件系统的时候，busybox 会创建一个 udev 的简化版本—mdev，所以在嵌入式 Linux 中我们使用mdev 来实现设备节点文件的自动创建与删除，Linux 系统中的热插拔事件也由 mdev 管理，在/etc/init.d/rcS 文件中如下语句：
echo /sbin/mdev > /proc/sys/kernel/hotplug上述命令设置热插拔事件由 mdev 来管理，关于 udev 或 mdev 更加详细的工作原理这里就不详细探讨了，我们重点来学习一下如何通过 mdev 来实现设备文件节点的自动创建与删除。
总结来说就是：mdev是busybox 提供的一个工具，在嵌入式系统中，相当于简化版的udev，作用是：在系统启动、热插拔和动态加载驱动程序时，自动创建设备节点。文件系统中的/dev目录下的设备节点都是由mdev创建的。在加载驱动过程中，根据驱动程序，在/dev下自动创建设备节点。
原理参考：【linux kernel】mdev详解-CSDN博客
其实创建节点最后还是调用
mknod
创建和删除类
自动创建设备节点的工作是在驱动程序的入口函数中完成的，一般在 cdev_add 函数后面添加自动创建设备节点相关代码。首先要创建一个 class 类，class 是个结构体，定义在文件include/linux/device.h 里面。
class 指的是设备类（device classes），是对于设备的高级抽象。但 实际上 class 也是一个结构体，只不过 class 结构体在声明时是按照类的思想来组织其成员的。运用 class，可以让用户空间的程序根据自己要处理的事情来调用设备，而不是根据设备被接入到系统的方式或设备的工作原理来调用。class 结构体的原型和相关描述可以在 linux-4.3/include/linux/device.h 中找到，内容如下：
struct class { const char *name; // 类名称 struct module *owner; // 类所属的模块，比如 usb模块、led模块等 struct class_attribute *class_attrs; // 类所添加的属性 const struct attribute_group **dev_groups; // 类所包含的设备所添加的属性 struct kobject *dev_kobj; // 用于标识 类所包含的设备属于块设备还是字符设备 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); // 用于在设备发出 uevent 消息时添加环境变量 char *(*devnode)(struct device *dev, umode_t *mode); // 设备节点的相对路径名 void (*class_release)(struct class *class); // 类被释放时调用的函数 void (*dev_release)(struct device *dev); // 设备被释放时调用的函数 int (*suspend)(struct device *dev, pm_message_t state); // 设备休眠时调用的函数 int (*resume)(struct device *dev); // 设备被唤醒时调用的函数 const struct kobj_ns_type_operations *ns_type; const void *(*namespace)(struct device *dev); const struct dev_pm_ops *pm; // 用于电源管理的函数 struct subsys_private *p; // 指向 class_private 结构的指针 };一个 struct class 结构体类型变量对应一个类，内核提供了class_create() 函数，可以用它来创建一个类，这个类存放于 sysfs 下面。 一旦创建了类，再调用 device_create() 函数在 /dev 目录下创建相应的设备节点。
class_create 是类创建函数，class_create 是个宏定义，内容如下：
示例代码 42.2.1.1 class_create 函数 1 #define class_create(owner, name) \ 2 ({ \ 3 static struct lock_class_key __key; \ 4 __class_create(owner, name, &__key); \ 5 }) 6 7 struct class *__class_create(struct module *owner, const char *name, 8 struct lock_class_key *key)根据上述代码，将宏 class_create 展开以后内容如下：
struct class *class_create (struct module *owner, const char *name)class_create 一共有两个参数，参数 owner 一般为 THIS_MODULE，参数 name 是类名字。
返回值是个指向结构体 class 的指针，也就是创建的类。
卸载驱动程序的时候需要删除掉类，类删除函数为 class_destroy，函数原型如下：
void class_destroy(struct class *cls);参数 cls 就是要删除的类。
创建设备
上一小节创建好类以后还不能实现自动创建设备节点，我们还需要在这个类下创建一个设备。使用 device_create 函数在类下面创建设备，device_create 函数原型如下：
device_create 是个可变参数函数，参数 class 就是设备要创建哪个类下面；参数 parent 是父设备，一般为 NULL，也就是没有父设备；参数 devt 是设备号；参数 drvdata 是设备可能会使用的一些数据，一般为 NULL；参数 fmt 是设备名字，如果设置 fmt=xxx 的话，就会生成/dev/xxx这个设备文件。返回值就是创建好的设备。
同样的，卸载驱动的时候需要删除掉创建的设备，设备删除函数为 device_destroy，函数原型如下：
void device_destroy(struct class *class, dev_t devt)参数 class 是要删除的设备所处的类，参数 devt 是要删除的设备号。
这里有三个名称需要区分：
- 模块的名字；
- 设备驱动的名字；
- 设备节点的名字；
三者并不一定要一样。
模块的名字对应的是.ko文件的名字
设备驱动的名字对应的是注册设备驱动时取的名字
设备节点的名字是手动生成设备节点或者自动生成设备节点时取的名字。
不要搞混了。
参考示例
在驱动入口函数里面创建类和设备，在驱动出口函数里面删除类和设备，参考示例如下：
示例代码 42.2.3.1 创建/删除类/设备参考代码 1 struct class *class; /* 类 */ 2 struct device *device; /* 设备 */ 3 dev_t devid; /* 设备号 */ 4 5 /* 驱动入口函数 */ 6 static int __init led_init(void) 7 { 8 /* 创建类 */ 9 class = class_create(THIS_MODULE, "xxx"); 10 /* 创建设备 */ 11 device = device_create(class, NULL, devid, NULL, "xxx"); 12 return 0; 13 } 14 15 /* 驱动出口函数 */ 16 static void __exit led_exit(void) 17 { 18 /* 删除设备 */ 19 device_destroy(newchrled.class, newchrled.devid); 20 /* 删除类 */ 21 class_destroy(newchrled.class); 22 } 23 24 module_init(led_init); 25 module_exit(led_exit);总结就是，为了能够自动创建设备，先要创建一个class类，然后基于class在该类下创建一个设备节点，创建设备节点时指定设备节点的名称，并通过设备号关联对应的字符设备。
设置文件私有数据
每个硬件设备都有一些属性，比如主设备号(dev_t)，类(class)、设备(device)、开关状态(state) 等等，在编写驱动的时候你可以将这些属性全部写成变量的形式，如下所示：
示例代码 42.3.1 变量形式的设备属性 dev_t devid; /* 设备号 */ struct cdev cdev; /* cdev */ struct class *class; /* 类 */ struct device *device; /* 设备 */ int major; /* 主设备号 */ int minor; /* 次设备号 */这样写肯定没有问题，但是这样写不专业！对于一个设备的所有属性信息我们最好将其做成一个结构体。编写驱动 open 函数的时候将设备结构体作为私有数据添加到设备文件中，如下所示：示例代码 42.3.2 设备结构体作为私有数据 /* 设备结构体 */ 1 struct test_dev{ 2 dev_t devid; /* 设备号 */ 3 struct cdev cdev; /* cdev */ 4 struct class *class; /* 类 */ 5 struct device *device; /* 设备 */ 6 int major; /* 主设备号 */ 7 int minor; /* 次设备号 */ 8 }; 9 10 struct test_dev testdev; 11 12 /* open 函数 */ 13 static int test_open(struct inode *inode, struct file *filp) 14 { 15 filp->private_data = &testdev; /* 设置私有数据 */ 16 return 0; 17 }在 open 函数里面设置好私有数据以后，在 write、read、close 等函数中直接读取private_data 即可得到设备结构体。
这个结构体是自定义的，其实就是我们自己将某个设备的信息给封装起来。
注意，虽然是在open里设置私有数据，但是这些数据其实在初始化以及注册设备的时候就已经设置好了，open只是在用户调用时触发执行。
对于设备的属性和行为我们最好用结构体来封装起来，这是一种面向对象的思想。
新字符设备驱动实验
本章实验在上一章实验的基础上完成，重点是使用了新的字符设备驱动、设置了文件私有数据、添加了自动创建设备节点相关内容。
工程创建好以后新建 newchrled.c 文件，在 newchrled.c 里面输入如下内容：
示例代码 42.5.1.1 newchrled.c 文件 1 #include <linux/types.h> 2 #include <linux/kernel.h> 3 #include <linux/delay.h> 4 #include <linux/ide.h> 5 #include <linux/init.h> 6 #include <linux/module.h> 7 #include <linux/errno.h> 8 #include <linux/gpio.h> 9 #include <linux/cdev.h> 10 #include <linux/device.h> 11 #include <asm/mach/map.h> 12 #include <asm/uaccess.h> 13 #include <asm/io.h> 14 15 /*************************************************************** 16 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 17 文件名 : newchrled.c 18 作者 : 左忠凯 19 版本 : V1.0 20 描述 : LED 驱动文件。 21 其他 : 无 22 论坛 : www.openedv.com 23 日志 : 初版 V1.0 2019/6/27 左忠凯创建 24 ***************************************************************/ 25 #define NEWCHRLED_CNT 1 /* 设备号个数 */ 26 #define NEWCHRLED_NAME "newchrled" /* 名字 */ 27 #define LEDOFF 0 /* 关灯 */ 28 #define LEDON 1 /* 开灯 */ 29 30 /* 寄存器物理地址 */ 31 #define CCM_CCGR1_BASE (0X020C406C) 32 #define SW_MUX_GPIO1_IO03_BASE (0X020E0068) 33 #define SW_PAD_GPIO1_IO03_BASE (0X020E02F4) 34 #define GPIO1_DR_BASE (0X0209C000) 35 #define GPIO1_GDIR_BASE (0X0209C004) 36 37 /* 映射后的寄存器虚拟地址指针 */ 38 static void __iomem *IMX6U_CCM_CCGR1; 39 static void __iomem *SW_MUX_GPIO1_IO03; 40 static void __iomem *SW_PAD_GPIO1_IO03; 41 static void __iomem *GPIO1_DR; 42 static void __iomem *GPIO1_GDIR; 43 44 /* newchrled 设备结构体 */ 45 struct newchrled_dev{ 46 dev_t devid; /* 设备号 */ 47 struct cdev cdev; /* cdev */ 48 struct class *class; /* 类 */ 49 struct device *device; /* 设备 */ 50 int major; /* 主设备号 */ 51 int minor; /* 次设备号 */ 52 }; 53 54 struct newchrled_dev newchrled; /* led 设备 */ 55 56 /* 57 * @description : LED 打开/关闭 58 * @param - sta : LEDON(0) 打开 LED，LEDOFF(1) 关闭 LED 59 * @return : 无 60 */ 61 void led_switch(u8 sta) 62 { 63 u32 val = 0; 64 if(sta == LEDON) { 65 val = readl(GPIO1_DR); 66 val &= ~(1 << 3); 67 writel(val, GPIO1_DR); 68 }else if(sta == LEDOFF) { 69 val = readl(GPIO1_DR); 70 val|= (1 << 3); 71 writel(val, GPIO1_DR); 72 } 73 } 74 75 /* 76 * @description : 打开设备 77 * @param – inode : 传递给驱动的 inode 78 * @param - filp : 设备文件，file 结构体有个叫做 private_data 的成员变量 79 * 一般在 open 的时候将 private_data 指向设备结构体。 80 * @return : 0 成功;其他 失败 81 */ 82 static int led_open(struct inode *inode, struct file *filp) 83 { 84 filp->private_data = &newchrled; /* 设置私有数据 */ 85 return 0; 86 } 87 88 /* 89 * @description : 从设备读取数据 90 * @param - filp : 要打开的设备文件(文件描述符) 91 * @param - buf : 返回给用户空间的数据缓冲区 92 * @param - cnt : 要读取的数据长度 93 * @param – offt : 相对于文件首地址的偏移 94 * @return : 读取的字节数，如果为负值，表示读取失败 95 */ 96 static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) 97 { 98 return 0; 99 } 100 101 /* 102 * @description : 向设备写数据 103 * @param – filp : 设备文件，表示打开的文件描述符 104 * @param - buf : 要写给设备写入的数据 105 * @param - cnt : 要写入的数据长度 106 * @param – offt : 相对于文件首地址的偏移 107 * @return : 写入的字节数，如果为负值，表示写入失败 108 */ 109 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt) 110 { 111 int retvalue; 112 unsigned char databuf[1]; 113 unsigned char ledstat; 114 115 retvalue = copy_from_user(databuf, buf, cnt); 116 if(retvalue < 0) { 117 printk("kernel write failed!\r\n"); 118 return -EFAULT; 119 } 120 121 ledstat = databuf[0]; /* 获取状态值 */ 122 123 if(ledstat == LEDON) { 124 led_switch(LEDON); /* 打开 LED 灯 */ 125 } else if(ledstat == LEDOFF) { 126 led_switch(LEDOFF); /* 关闭 LED 灯 */ 127 } 128 return 0; 129 } 130 131 /* 132 * @description : 关闭/释放设备 133 * @param – filp : 要关闭的设备文件(文件描述符) 134 * @return : 0 成功;其他 失败 135 */ 136 static int led_release(struct inode *inode, struct file *filp) 137 { 138 return 0; 139 } 140 141 /* 设备操作函数 */ 142 static struct file_operations newchrled_fops = { 143 .owner = THIS_MODULE, 144 .open = led_open, 145 .read = led_read, 146 .write = led_write, 147 .release = led_release, 148 }; 149 150 /* 151 * @description : 驱动入口函数 152 * @param : 无 153 * @return : 无 154 */ 155 static int __init led_init(void) 156 { 157 u32 val = 0; 158 159 /* 初始化 LED */ 160 /* 1、寄存器地址映射 */ 161 IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4); 162 SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4); 163 SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4); 164 GPIO1_DR = ioremap(GPIO1_DR_BASE, 4); 165 GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4); 166 167 /* 2、使能 GPIO1 时钟 */ 168 val = readl(IMX6U_CCM_CCGR1); 169 val &= ~(3 << 26); /* 清楚以前的设置 */ 170 val |= (3 << 26); /* 设置新值 */ 171 writel(val, IMX6U_CCM_CCGR1); 172 173 /* 3、设置 GPIO1_IO03 的复用功能，将其复用为 174 * GPIO1_IO03，最后设置 IO 属性。 175 */ 176 writel(5, SW_MUX_GPIO1_IO03); 177 178 /* 寄存器 SW_PAD_GPIO1_IO03 设置 IO 属性 */ 179 writel(0x10B0, SW_PAD_GPIO1_IO03); 180 181 /* 4、设置 GPIO1_IO03 为输出功能 */ 182 val = readl(GPIO1_GDIR); 183 val &= ~(1 << 3); /* 清除以前的设置 */ 184 val |= (1 << 3); /* 设置为输出 */ 185 writel(val, GPIO1_GDIR); 186 187 /* 5、默认关闭 LED */ 188 val = readl(GPIO1_DR); 189 val |= (1 << 3); 190 writel(val, GPIO1_DR); 191 192 /* 注册字符设备驱动 */ 193 /* 1、创建设备号 */ 194 if (newchrled.major) { /* 定义了设备号 */ 195 newchrled.devid = MKDEV(newchrled.major, 0); 196 register_chrdev_region(newchrled.devid, NEWCHRLED_CNT, NEWCHRLED_NAME); 197 } else { /* 没有定义设备号 */ 198 alloc_chrdev_region(&newchrled.devid, 0, NEWCHRLED_CNT, NEWCHRLED_NAME); /* 申请设备号 */ 199 newchrled.major = MAJOR(newchrled.devid); /* 获取主设备号 */ 200 newchrled.minor = MINOR(newchrled.devid); /* 获取次设备号 */ 201 } 202 printk("newcheled major=%d,minor=%d\r\n",newchrled.major, newchrled.minor); 203 204 /* 2、初始化 cdev */ 205 newchrled.cdev.owner = THIS_MODULE; 206 cdev_init(&newchrled.cdev, &newchrled_fops); 207 208 /* 3、添加一个 cdev */ 209 cdev_add(&newchrled.cdev, newchrled.devid, NEWCHRLED_CNT); 210 211 /* 4、创建类 */ 212 newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME); 213 if (IS_ERR(newchrled.class)) { 214 return PTR_ERR(newchrled.class); 215 } 216 217 /* 5、创建设备 */ 218 newchrled.device = device_create(newchrled.class, NULL, newchrled.devid, NULL, NEWCHRLED_NAME); 219 if (IS_ERR(newchrled.device)) { 220 return PTR_ERR(newchrled.device); 221 } 222 223 return 0; 224 } 225 226 /* 227 * @description : 驱动出口函数 228 * @param : 无 229 * @return : 无 230 */ 231 static void __exit led_exit(void) 232 { 233 /* 取消映射 */ 234 iounmap(IMX6U_CCM_CCGR1); 235 iounmap(SW_MUX_GPIO1_IO03); 236 iounmap(SW_PAD_GPIO1_IO03); 237 iounmap(GPIO1_DR); 238 iounmap(GPIO1_GDIR); 239 240 /* 注销字符设备 */ 241 cdev_del(&newchrled.cdev);/* 删除 cdev */ 242 unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT); 243 244 device_destroy(newchrled.class, newchrled.devid); 245 class_destroy(newchrled.class); 246 } 247 248 module_init(led_init); 249 module_exit(led_exit); 250 MODULE_LICENSE("GPL"); 251 MODULE_AUTHOR("zuozhongkai");第 25 行，宏 NEWCHRLED_CNT 表示设备数量，在申请设备号或者向 Linux 内核添加字符设备的时候需要设置设备数量，一般我们一个驱动一个设备，所以这个宏为 1。
第 26 行，宏 NEWCHRLED_NAME 表示设备名字，本实验的设备名为“newchrdev”，为了方便管理，所有使用到设备名字的地方统一使用此宏，当驱动加载成功以后就生成/dev/newchrled 这个设备文件。
第 44~52 行，创建设备结构体 newchrled_dev。
第 54 行，定义一个设备结构体变量 newchrdev，此变量表示 led 设备。
第 82~86 行，在 led_open 函数中设置文件的私有数据 private_data 指向 newchrdev。
第 194~221 行，根据前面讲解的方法在驱动入口函数 led_init 中申请设备号、添加字符设备、创建类和设备。本实验我们采用动态申请设备号的方法，第 202 行使用 printk 在终端上显示出申请到的主设备号和次设备号。
第 241~245 行，根据前面讲解的方法，在驱动出口函数 led_exit 中注销字符新设备、删除类和设备。
总体来说 newchrled.c 文件中的内容不复杂，LED 灯驱动部分的程序和上一章一样。重点就是使用了新的字符设备驱动方法。
新字符设备驱动框架的主要优化是：自动获取设备号+自动注册设备节点。
看下这个设备结构体封装：
这个结构体里面有三类信息
第一类是用来自动生成设备节点使用的，包括devid major minor；
第二类是新的注册设备节点使用的，先初始化cdev，再添加；
第三类就是自动生成设备节点使用的，包括class和device，设备要绑定在一个类下面，然后通过deviceid和具体的驱动绑定；
扫一扫
973
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
