字符设备驱动开发
本章我们从Linux驱动开发中最基础的字符设备驱动开始，重点学习Linux下字符设备驱动开发框架。本章会以一个虚拟的设备为例，讲解如何进行字符设备驱动开发，以及如何编写测试APP来测试驱动工作是否正常，为以后的学习打下坚实的基础。
3 `4 T/ n. }! c  U( e+ j: ~
20.1 字符设备驱动简介
字符设备是Linux驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD等等都是字符设备，这些设备的驱动就叫做字符设备驱动。
在详细的学习字符设备驱动架构之前，我们先来简单的了解一下Linux下的应用程序是如何调用驱动程序的，Linux应用程序对驱动程序的调用如图20.1.1所示：
) ?' U; \- @! F8 s% r8 a: U7 q


" {- V0 p# S0 e0 T" e! D图20.1.1 Linux应用程序对驱动程序的调用流程
+ }' e+ T# X, }! p, R; |/ i在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库提供的，在Linux系统中，系统调用作为C库的一部分。当我们调用open函数的时候流程如图20.1.2所示：

$ g# H+ T1 F" {' p; A9 l, B3 T

. V) h& v% x$ _- x5 y图20.1.2 open函数调用流程
8 Q9 ?) W; ]& r, i% ^7 `' Q其中关于C库以及如何通过系统调用“陷入”到内核空间这个我们不用去管，我们重点关注的是应用程序和具体的驱动，应用程序使用到的函数在具体驱动程序中都有与之对应的函数，比如应用程序中调用了open这个函数，那么在驱动程序中也得有一个名为open的函数。每一个系统调用，在驱动中都有与之对应的一个驱动函数，在Linux内核文件 include/linux/fs.h中有个叫做file_operations的结构体，此结构体就是Linux内核驱动操作函数集合，内容如下所示：
- ?, Q2 z# ]: B; I6 X! L
# S3 |  Z6 Q- P7 @* |

1. 示例代码20.1.1 file_operations结构体
   
2. 1822    struct file_operations {
   
3. 1823        struct module *owner;
   ( z; D! d% x8 I" f( Z
4. 1824        loff_t (*llseek) (struct file *, loff_t, int);
   
5. 1825        ssize_t (*read) (struct file *, char __user *, size_t,
   6 x/ z) m0 _( p6 a8 e
6. loff_t *);
   / U2 H" j  @& a# w/ u& x5 W& q
7. 1826        ssize_t (*write) (struct file *, const char __user *,
   
8. size_t, loff_t *);
   " N0 J$ U/ E/ i( @
9. 1827        ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
   & c- Z& c+ K& S$ R( Q& u$ I5 i  c5 J4 G
10. 1828        ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    
11. 1829        int (*iopoll)(struct kiocb *kiocb, bool spin);
    
12. 1830        int (*iterate) (struct file *, struct dir_context *);
    - Y5 i  ~: j# [9 [8 q' w
13. 1831        int (*iterate_shared) (struct file *, struct dir_context *);
    7 X- |& }% V" p
14. 1832        __poll_t (*poll) (struct file *, struct poll_table_struct *);
    " ]' K. S( i+ b0 z
15. 1833        long (*unlocked_ioctl) (struct file *, unsigned int,
    2 E' ~. [4 [9 l0 Z0 V2 K$ U4 R9 p
16. unsigned long);
    
17. 1834        long (*compat_ioctl) (struct file *, unsigned int,
    
18. unsigned long);
    + e! |- {3 Y8 C* B+ R! G) I
19. 1835        int (*mmap) (struct file *, struct vm_area_struct *);
    - g8 n% ?# ]( {3 r, v1 [) U
20. 1836        unsigned long mmap_supported_flags;
    % g; b2 t8 Y' O8 h+ G
21. 1837        int (*open) (struct inode *, struct file *);
    2 U) E  a. H# h$ h8 ^5 ]1 D
22. 1838        int (*flush) (struct file *, fl_owner_t id);
    
23. 1839        int (*release) (struct inode *, struct file *);
    7 ?, \/ k5 E1 q: R2 {7 |! S
24. 1840        int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    
25. 1841        int (*fasync) (int, struct file *, int);
    5 h1 z2 P: G* j$ L, m( R8 s4 E/ R
26. 1842        int (*lock) (struct file *, int, struct file_lock *);
    
27. 1843        ssize_t (*sendpage) (struct file *, struct page *,
    
28. int, size_t, loff_t *, int);
    
29. 1844        unsigned long (*get_unmapped_area)(struct file *,
    
30. unsigned long, unsigned long, unsigned long, unsigned long);
    1 h8 U; j8 h9 B. z! D4 A
31. 1845        int (*check_flags)(int);
    " J! R! d) o: E$ F/ c5 r
32. 1846        int (*flock) (struct file *, int, struct file_lock *);
    9 x2 r, j/ [# x- ?' c# E
33. 1847        ssize_t (*splice_write)(struct pipe_inode_info *,
    , \! z9 [+ y8 \/ Z, e8 D
34. struct file *, loff_t *, size_t, unsigned int);
    $ \; {# S- [- u5 {+ q, G
35. 1848        ssize_t (*splice_read)(struct file *, loff_t *,
    
36. struct pipe_inode_info *, size_t, unsigned int);
    
37. 1849        int (*setlease)(struct file *, long, struct file_lock **,
    - `+ `4 c# G! j5 `( l3 M
38. void **);
    % v: D3 r8 K4 h8 R  y
39. 1850        long (*fallocate)(struct file *file, int mode, loff_t offset,
    
40. 1851                  loff_t len);
    + M1 }- ~+ D- M! l( V) a8 }' x  w
41. 1852        void (*show_fdinfo)(struct seq_file *m, struct file *f);
    
42. 1853    #ifndef CONFIG_MMU
    
43. 1854        unsigned (*mmap_capabilities)(struct file *);
    
44. 1855    #endif
    1 f4 f- t' S' f# x& C
45. 1856        ssize_t (*copy_file_range)(struct file *, loff_t,
    # U7 D3 B$ }+ T6 X
46. 1857                struct file *, loff_t, size_t, unsigned int);
    
47. 1858        loff_t (*remap_file_range)(struct file *file_in,
    . P- N. R, U% s: N
48. loff_t pos_in,
    ( n) m! D) z, Z  c& `4 y. u0 H
49. 1859                       struct file *file_out, loff_t pos_out,
    % ?4 m+ F* G: x5 e: c
50. 1860                       loff_t len, unsigned int remap_flags);
    4 R9 w: g# q) ]6 {; [
51. 1861        int (*fadvise)(struct file *, loff_t, loff_t, int);
    " A+ S6 A: i% N' Q
52. 1862    } __randomize_layout;

复制代码

简单介绍一下file_operation结构体中比较重要的、常用的函数：
第1823行，owner拥有该结构体的模块的指针，一般设置为THIS_MODULE。
第1824行，llseek函数用于修改文件当前的读写位置。
: M, X' e0 K1 c% R( F0 o# E第1825行，read函数用于读取设备文件。
6 O+ n7 {- t& r/ _! b第1826行，write函数用于向设备文件写入(发送)数据。
第1832行，poll是个轮询函数，用于查询设备是否可以进行非阻塞的读写。
0 j# a1 }6 i  g第1833行，unlocked_ioctl函数提供对于设备的控制功能，与应用程序中的ioctl函数对应。
" u. g' X9 z2 i" u2 L1 J# }' W7 t第1834行，compat_ioctl函数与unlocked_ioctl函数功能一样，区别在于在64位系统上，32位的应用程序调用将会使用此函数。在32位的系统上运行32位的应用程序调用的是unlocked_ioctl。
第1835行，mmap函数用于将将设备的内存映射到进程空间中(也就是用户空间)，一般帧缓冲设备会使用此函数，比如LCD驱动的显存，将帧缓冲(LCD显存)映射到用户空间中以后应用程序就可以直接操作显存了，这样就不用在用户空间和内核空间之间来回复制。
第1837行，open函数用于打开设备文件。
第1839行，release函数用于释放(关闭)设备文件，与应用程序中的close函数对应。
第1841行，fasync函数用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。
在字符设备驱动开发中最常用的就是上面这些函数，关于其他的函数大家可以查阅相关文档。我们在字符设备驱动开发中最主要的工作就是实现上面这些函数，不一定全部都要实现，但是像open、release、write、read等都是需要实现的，当然了，具体需要实现哪些函数还是要看具体的驱动要求。
, n! _2 D' A3 d* X4 E' ^! m4 D; L: E20.2 字符设备驱动开发步骤
上一小节我们简单的介绍了一下字符设备驱动，那么字符设备驱动开发都有哪些步骤呢？我们在学习裸机或者STM32的时候关于驱动的开发就是初始化相应的外设寄存器，在Linux驱动开发中肯定也是要初始化相应的外设寄存器，这个是毫无疑问的。只是在Linux驱动开发中我们需要按照其规定的框架来编写驱动，所以说学Linux驱动开发重点是学习其驱动框架。
1 B, S. ]5 M6 M2 P20.2.1 驱动模块的加载和卸载
Linux驱动有两种运行方式，第一种就是将驱动编译进Linux内核中，这样当Linux内核启动的时候就会自动运行驱动程序。第二种就是将驱动编译成模块(Linux下模块扩展名为.ko)，在Linux内核启动以后使用“modprobe”或者“insmod”命令加载驱动模块，本教程我们统一使用“modprobe”命令。在调试驱动的时候一般都选择将其编译为模块，这样我们修改驱动以后只需要编译一下驱动代码即可，不需要编译整个Linux代码。而且在调试的时候只需要加载或者卸载驱动模块即可，不需要重启整个系统。总之，将驱动编译为模块最大的好处就是方便开发，当驱动开发完成，确定没有问题以后就可以将驱动编译进Linux内核中，当然也可以不编译进Linux内核中，具体看自己的需求。
模块有加载和卸载两种操作，我们在编写驱动的时候需要注册这两种操作函数，模块的加载和卸载注册函数如下：
: k1 }# n4 @- L8 m/ a/ b4 ~module_init(xxx_init); //注册模块加载函数
; {2 M; ]: ?+ ]+ y3 Q+ H1 X% Y  P' V7 Tmodule_exit(xxx_exit); //注册模块卸载函数
module_init函数用来向Linux内核注册一个模块加载函数，参数xxx_init就是需要注册的具体函数，当使用“modprobe”命令加载驱动的时候，xxx_init这个函数就会被调用。module_exit函数用来向Linux内核注册一个模块卸载函数，参数xxx_exit就是需要注册的具体函数，当使用“rmmod”命令卸载具体驱动的时候xxx_exit函数就会被调用。字符设备驱动模块加载和卸载模板如下所示：
: Q: Z4 S$ B) F/ W
. r' h* y4 {+ I$ l

1. 示例代码20.2.1.1 字符设备驱动模块加载和卸载函数模板
   + A% J2 L6 I/ [4 h
2. 1  /* 驱动入口函数 */
   8 x" I7 D% L8 @+ J- W) T
3. 2  static int __init xxx_init(void)
   
4. 3  {
   * k$ i% R. K/ C+ W7 g" x
5. 4           /* 入口函数具体内容 */
   
6. 5           return 0;
   
7. 6  }
   
8. 7  
   
9. 8  /* 驱动出口函数 */
   
10. 9  static void __exit xxx_exit(void)
    
11. 10 {
    
12. 11          /* 出口函数具体内容 */
    
13. 12 }
    0 K3 F$ P9 B/ l1 p- d
14. 13
    
15. 14 /* 将上面两个函数指定为驱动的入口和出口函数 */
    
16. 15 module_init(xxx_init);
    
17. 16 module_exit(xxx_exit);

复制代码

义了个名为xxx_init的驱动入口函数，并且使用了“__init”来修饰。
第9行，定义了个名为xxx_exit的驱动出口函数，并且使用了“__exit”来修饰。
# Y1 V. B3 g2 k, `* ?- C6 F! z第15行，调用函数module_init来声明xxx_init为驱动入口函数，当加载驱动的时候xxx_init函数就会被调用。
第16行，调用函数module_exit来声明xxx_exit为驱动出口函数，当卸载驱动的时候xxx_exit函数就会被调用。
驱动编译完成以后扩展名为.ko，前面说了，有两种命令可以加载驱动模块：insmod和modprobe，insmod是最简单的模块加载命令，此命令用于加载指定的.ko模块，比如加载drv.ko这个驱动模块，命令如下：
insmod drv.ko
insmod命令不能解决模块的依赖关系，比如drv.ko依赖first.ko这个模块，就必须先使用insmod命令加载first.ko这个模块，然后再加载drv.ko这个模块。但是modprobe就不会存在这个问题，modprobe会分析模块的依赖关系，然后会将所有的依赖模块都加载到内核中，因此modprobe命令相比insmod要智能一些。modprobe命令主要智能在提供了模块的依赖性分析、错误检查、错误报告等功能，推荐使用modprobe命令来加载驱动。modprobe命令默认会去/lib/modules/目录中查找模块，比如本书使用的Linux kernel的版本号为5.4.31，因此modprobe命令默认会到/lib/modules/5.4.31这个目录中查找相应的驱动模块，一般自己制作的根文件系统中是不会有这个目录的，所以需要自己手动创建，这个我们在讲解buildroot构建根文件系统的时候已经说过了。
9 E+ q' H1 Q) D5 P. J驱动模块的卸载使用命令“rmmod”即可，比如要卸载drv.ko，使用如下命令即可：
rmmod drv.ko
也可以使用“modprobe -r”命令卸载驱动，比如要卸载drv.ko，命令如下：
; v! l8 Z! E1 z; t, Smodprobe -r drv
" ]0 j  C# Q2 ^/ j4 f/ c: J使用modprobe命令可以卸载掉驱动模块所依赖的其他模块，前提是这些依赖模块已经没有被其他模块所使用，否则就不能使用modprobe来卸载驱动模块。所以对于模块的卸载，还是推荐使用rmmod命令。
  |+ h; a4 w8 o$ S2 K20.2.2 字符设备注册与注销
& J, X: w9 D: q2 R* r: U* N对于字符设备驱动而言，当驱动模块加载成功以后需要注册字符设备，同样，卸载驱动模块的时候也需要注销掉字符设备。字符设备的注册和注销函数原型如下所示:

  @6 e/ K- X1 e- f' X( a% ?6 r

1. static inline int register_chrdev(unsigned int                         major,
     X1 j9 k: k# l9 x
2.                                                  const char                                 *name,
   
3.                                                  const struct file_operations         *fops)
   / M" w& u* W( O, {* E! l
4. 
   
5. static inline void unregister_chrdev(unsigned int                         major,
   
6.                                                          const char                         *name)

复制代码

register_chrdev函数用于注册字符设备，此函数一共有三个参数，这三个参数的含义如下：
major：主设备号，Linux下每个设备都有一个设备号，设备号分为主设备号和次设备号两部分，关于设备号后面会详细讲解。
7 w# K% {2 i! h' N; s4 |# D2 O. zname：设备名字，指向一串字符串。
. u2 H( O* M, s/ lfops：结构体file_operations类型指针，指向设备的操作函数集合变量。
unregister_chrdev函数用户注销字符设备，此函数有两个参数，这两个参数含义如下：
$ I2 h/ H! H( N9 x7 K  jmajor：要注销的设备对应的主设备号。
4 r" G3 R4 K( l. l8 V; Y& H4 pname：要注销的设备对应的设备名。
  @& {3 {2 X  U5 k- C一般字符设备的注册在驱动模块的入口函数xxx_init中进行，字符设备的注销在驱动模块的出口函数xxx_exit中进行。在示例代码20.2.1.1中字符设备的注册和注销，内容如下所示：

2 H3 T) E" k( ]6 A7 p* b

1. 示例代码20.2.2.1 加入字符设备注册和注销
   1 r' {+ p' F. `2 x+ B3 b( e
2. 1  static struct file_operations test_fops;
   , |6 [4 B4 ]/ j) [# J/ M
3. 2
   $ _9 h1 }. d6 Z3 B: H( c/ x7 h$ Y& J8 t
4. 3  /* 驱动入口函数 */
   * F$ V+ U9 i' h) a4 n5 n
5. 4  static int __init xxx_init(void)
   
6. 5  {
   
7. 6           /* 入口函数具体内容 */
   
8. 7           int retvalue = 0;
   
9. 8
     K7 d" X5 y- G" d; @
10. 9           /* 注册字符设备驱动 */
    
11. 10          retvalue = register_chrdev(200, "chrtest", &test_fops);
      n7 ~, G' A5 w
12. 11          if(retvalue < 0){
    
13. 12              /* 字符设备注册失败,自行处理 */
    3 l3 l( S" \! N$ q$ c
14. 13          }
    
15. 14          return 0;
    + ^: u* v, `: c# j; y8 x9 ~
16. 15 }
    / u/ ?; Q. `1 }, I0 G2 A
17. 16
    
18. 17 /* 驱动出口函数 */
    
19. 18 static void __exit xxx_exit(void)
    ) u& O6 D+ _) \) w- f+ J# l. H
20. 19 {
    2 ?& u" u2 n1 c6 r0 C% A
21. 20          /* 注销字符设备驱动 */
    , B: s8 U& c- U
22. 21          unregister_chrdev(200, "chrtest");
    * [4 h# H" O1 O
23. 22 }
    4 O/ r; i- x3 i; j/ Q3 e
24. 23
      R1 ?3 u7 e" q# `' m
25. 24 /* 将上面两个函数指定为驱动的入口和出口函数 */
    ; Q) O0 T' e( f8 ?5 ~
26. 25 module_init(xxx_init);
    
27. 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”可以查看当前已经被使用掉的设备号，如图20.2.2.1所示(限于篇幅原因，只展示一部分)：
& x4 @/ b, c7 h) g/ `/ s* m$ L
% `! V* \" Q+ e& P
1 {' _1 P9 [" T% l' ]
$ s0 |& k* w/ R9 y1 W8 l) [3 I图20.2.2.1 查看当前设备
4 Y8 u. }' ^6 E7 h& w, k在图20.2.2.1中可以列出当前系统中所有的字符设备和块设备，其中第1列就是设备对应的主设备号。200这个主设备号在我的开发板中并没有被使用，所以我这里就用了200这个主设备号。
7 \9 x% K4 o2 d" Y+ \第21行，调用函数unregister_chrdev注销主设备号为200的这个设备。
20.2.3 实现设备的具体操作函数
file_operations结构体就是设备的具体操作函数，在示例代码20.2.2.1中我们定义了file_operations结构体类型的变量test_fops，但是还没对其进行初始化，也就是初始化其中的open、release、read和write等具体的设备操作函数。本节我们就完成变量test_fops的初始化，设置好针对chrtest设备的操作函数。在初始化test_fops之前我们要分析一下需求，也就是要对chrtest这个设备进行哪些操作，只有确定了需求以后才知道我们应该实现哪些操作函数。假设对chrtest这个设备有如下两个要求：
# I4 f: q: V0 O1 L! F. n1、能够对chrtest进行打开和关闭操作
) ^& N0 m  e5 p0 D设备打开和关闭是最基本的要求，几乎所有的设备都得提供打开和关闭的功能。因此我们需要实现file_operations中的open和release这两个函数。
( |' m- d( M! u2 A! v2 E& d2、对chrtest进行读写操作
假设chrtest这个设备控制着一段缓冲区(内存)，应用程序需要通过read和write这两个函数对chrtest的缓冲区进行读写操作。所以需要实现file_operations中的read和write这两个函数。
需求很清晰了，修改示例代码20.2.2.1，在其中加入test_fops这个结构体变量的初始化操作，完成以后的内容如下所示：

6 e1 G. B/ ?  D. k# F

1. 示例代码20.2.3.1 加入设备操作函数
   ) W: Q9 ]' D& o
2. 1  /* 打开设备 */
   9 U+ h7 i0 O# c3 y1 t! s3 r
3. 2  static int chrtest_open(struct inode *inode, struct file *filp)
   
4. 3  {
   
5. 4           /* 用户实现具体功能 */
   
6. 5           return 0;
   
7. 6  }
   . I" T! h  p1 R0 V
8. 7  
   ! S5 J. G/ q! V# \: g$ F
9. 8  /* 从设备读取 */
   & @. j; D- p( w: R
10. 9  static ssize_t chrtest_read(struct file *filp, char __user *buf,     size_t cnt, loff_t *offt)
    
11. 10 {
    7 [! l! ^( Y# k, l
12. 11          /* 用户实现具体功能 */
    6 G1 U% B9 c% A" l
13. 12          return 0;
    
14. 13 }
    3 X5 }" i3 z$ e, ~% `, `3 c
15. 14
    
16. 15 /* 向设备写数据 */
    
17. 16 static ssize_t chrtest_write(struct file *filp,
    ; w% e; d6 o" c$ L. @
18. const char __user *buf,
    
19. size_t cnt, loff_t *offt)
    
20. 17 {
    + J6 C6 @% Q* R/ j) Q6 d
21. 18          /* 用户实现具体功能 */
    " S9 V7 r; {4 H) {! ^
22. 19          return 0;
    5 u. P" `, D7 y2 j9 m6 y/ b2 l- S
23. 20 }
    
24. 21
    
25. 22 /* 关闭/释放设备 */
    
26. 23 static int chrtest_release(struct inode *inode, struct file *filp)
    
27. 24 {
    
28. 25          /* 用户实现具体功能 */
    
29. 26          return 0;
    ( i7 H; y+ C  `$ b; l
30. 27 }
    
31. 28
    
32. 29 static struct file_operations test_fops = {
    
33. 30          .owner = THIS_MODULE,   
    
34. 31          .open = chrtest_open,
    
35. 32          .read = chrtest_read,
    ! N- D6 i8 l/ x
36. 33          .write = chrtest_write,
    
37. 34          .release = chrtest_release,
    . G( L( B& u# Q% J) K5 R
38. 35 };
    
39. 36
    0 [2 f0 a. u" G+ D! N! M  w8 W1 Y8 v2 f4 r
40. 37 /* 驱动入口函数 */
    5 W- B* D; Y# \& J4 d7 y. y9 c! W
41. 38 static int __init xxx_init(void)
    
42. 39 {
    
43. 40          /* 入口函数具体内容 */
    
44. 41          int retvalue = 0;
    " |4 N" o+ J- M8 k, s
45. 42
    
46. 43          /* 注册字符设备驱动 */
    
47. 44          retvalue = register_chrdev(200, "chrtest", &test_fops);
    , ]7 c  C; H  V% S
48. 45          if(retvalue < 0){
    $ C: n5 \; A/ E7 K& e. `+ U/ _
49. 46              /* 字符设备注册失败,自行处理 */
    ' a* b2 }& D. k# w
50. 47          }
    9 g5 G5 C6 E( C
51. 48          return 0;
    
52. 49 }
    
53. 50
    
54. 51 /* 驱动出口函数 */
    
55. 52 static void __exit xxx_exit(void)
      a+ d4 s- b/ t
56. 53 {
    " D4 z2 W9 {. q+ o) R
57. 54          /* 注销字符设备驱动 */
    
58. 55          unregister_chrdev(200, "chrtest");
    . B. |0 i6 V7 v$ ^
59. 56 }
    5 M* t$ z+ X' ?* p0 z! n9 y
60. 57
    % K4 I. J) x+ p: n& m
61. 58 /* 将上面两个函数指定为驱动的入口和出口函数 */
    $ P  e8 g/ `7 y0 y3 b
62. 59 module_init(xxx_init);
    $ K: B2 V1 s  R" d
63. 60 module_exit(xxx_exit);
    

复制代码

在示例代码20.2.3.1中我们一开始编写了四个函数：chrtest_open、chrtest_read、chrtest_write和chrtest_release。这四个函数就是chrtest设备的open、read、write和release操作函数。第29行~35行初始化test_fops的open、read、write和release这四个成员变量。
1 p7 n; z! u% D9 D20.2.4 添加LICENSE和作者信息
最后我们需要在驱动中加入LICENSE信息和作者信息，其中LICENSE是必须添加的，否则的话编译的时候会报错，作者信息可以添加也可以不添加。LICENSE和作者信息的添加使用如下两个函数：
MODULE_LICENSE() //添加模块LICENSE信息
MODULE_AUTHOR() //添加模块作者信息
: R: P" k) \9 Y最后给示例代码20.2.3.1加入LICENSE和作者信息，完成以后的内容如下：

1. 示例代码20.2.4.1 字符设备驱动最终的模板
   
2. 1  /* 打开设备 */
   4 C" q4 x8 {- Q* M: h
3. 2  static int chrtest_open(struct inode *inode, struct file *filp)
   & l* Q# {  W; x4 ~' `" j  H
4. 3  {
   2 v- j1 T4 d+ D1 G
5. 4           /* 用户实现具体功能 */
   0 F; N2 Z& ^& p0 d* [
6. 5           return 0;
   . Z' `* j2 A0 h+ g' \+ h0 u% S9 V
7. 6  }
   # K9 r5 M, O' O( a/ E+ Q- J+ \
8. ......
   , t/ F2 m) v1 N  X% C4 z+ X" U! F
9. 57
   
10. 58 /* 将上面两个函数指定为驱动的入口和出口函数 */
    2 z1 ~2 u5 }" O* \1 k, Y5 f
11. 59 module_init(xxx_init);
    4 G& g8 x& m+ Q  h7 [7 V
12. 60 module_exit(xxx_exit);
    # Q0 C7 J: t$ }8 J7 `: K- {  B! e
13. 61
    ! v, G8 D. I' X- c( \# a
14. 62 MODULE_LICENSE("GPL");
    
15. 63 MODULE_AUTHOR("zuozhongkai");

复制代码

第62行，LICENSE采用GPL协议。
' v9 U& g2 l4 ^: K第63行，添加作者名字。
% D0 x$ o# Q1 k; x7 {4 {5 ?至此，字符设备驱动开发的完整步骤就讲解完了，而且也编写好了一个完整的字符设备驱动模板，以后字符设备驱动开发都可以在此模板上进行。
# n! d+ A& p+ \6 J4 D  S8 G' r" [
20.3 Linux设备号
20.3.1 设备号的组成
为了方便管理，Linux中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备。Linux提供了一个名为dev_t的数据类型表示设备号，dev_t定义在文件include/linux/types.h里面，定义如下：
& z+ ^( }% R- \+ ^示例代码20.3.1.1 设备号dev_t
" Z" K; y, W4 C

1. 13 typedef __u32 __kernel_dev_t;
   
2. ......
   
3. 16 typedef __kernel_dev_t dev_t;

复制代码

可以看出dev_t是__u32类型的，而__u32定义在文件include/uapi/asm-generic/int-ll64.h里面，定义如下：
示例代码20.3.1.2 __u32类型
- U( S$ @  h+ V: g0 ?27 typedef unsigned int __u32;
: }& d/ N9 M* {4 l$ O综上所述，dev_t其实就是unsigned int类型，是一个32位的数据类型。这32位的数据构成了主设备号和次设备号两部分，其中高12位为主设备号，低20位为次设备号。因此Linux系统中主设备号范围为0~4095，所以大家在选择主设备号的时候一定不要超过这个范围。在文件include/linux/kdev_t.h中提供了几个关于设备号的操作函数(本质是宏)，如下所示：
示例代码20.3.1.3 设备号操作函数

0 l# _% k# Q$ z( M4 t/ Y  J

1. 7          #define MINORBITS            20
   
2. 8          #define MINORMASK            ((1U << MINORBITS) - 1)
   
3. 9  
   
4. 10        #define MAJOR(dev)           ((unsigned int) ((dev) >> MINORBITS))
   3 m  U5 m& w* Z* ]1 V& h2 q- |
5. 11        #define MINOR(dev)           ((unsigned int) ((dev) & MINORMASK))
   $ k# {" X: C$ }8 I2 m; x- M9 g$ c
6. 12         #define MKDEV(ma,mi)         (((ma) << MINORBITS) | (mi))

复制代码

第7行，宏MINORBITS表示次设备号位数，一共是20位。
第8行，宏MINORMASK表示次设备号掩码。
( ]# \' l$ ?( W' O! X第10行，宏MAJOR用于从dev_t中获取主设备号，将dev_t右移20位即可。
7 L3 w* y+ E& N8 w& {; R" Q第11行，宏MINOR用于从dev_t中获取次设备号，取dev_t的低20位的值即可。
9 Z  z) H* X, G& t第12行，宏MKDEV用于将给定的主设备号和次设备号的值组合成dev_t类型的设备号。
& M. }* d" w: H& x8 @; t20.3.2 设备号的分配
* d1 y% N3 G! S* ~4 p6 |% r3 v8 Q1、静态分配设备号
+ X* Z3 X2 h. R# _- U8 U+ f0 L1 k本小节讲的设备号分配主要是主设备号的分配。前面讲解字符设备驱动的时候说过了，注册字符设备的时候需要给设备指定一个设备号，这个设备号可以是驱动开发者静态指定的一个设备号，比如200这个主设备号。有一些常用的设备号已经被Linux内核开发者给分配掉了，具体分配的内容可以查看文档Documentation/devices.txt。并不是说内核开发者已经分配掉的主设备号我们就不能用了，具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号，使用“cat /proc/devices”命令即可查看当前系统中所有已经使用了的设备号。
4 K0 Z8 J8 |2 m% a# i( ?2、动态分配设备号
静态分配设备号需要我们检查当前系统中所有被使用了的设备号，然后挑选一个没有使用的。而且静态分配设备号很容易带来冲突问题，Linux社区推荐使用动态分配设备号，在注册字符设备之前先申请一个设备号，系统会自动给你一个没有被使用的设备号，这样就避免了冲突。卸载驱动的时候释放掉这个设备号即可，设备号的申请函数如下：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
函数alloc_chrdev_region用于申请设备号，此函数有4个参数：
dev：保存申请到的设备号。
. Q. W0 w, C0 Q0 c' v) dbaseminor：次设备号起始地址，alloc_chrdev_region可以申请一段连续的多个设备号，这些设备号的主设备号一样，但是次设备号不同，次设备号以baseminor为起始地址地址开始递增。一般baseminor为0，也就是说次设备号从0开始。
count：要申请的设备号数量。
0 P* _9 J. C$ ]; [4 F9 `9 M8 Jname：设备名字。
8 h7 u% O& P, p/ A/ g注销字符设备之后要释放掉设备号，设备号释放函数如下：
void unregister_chrdev_region(dev_t from, unsigned count)
" }- v2 H" U; Z1 Q/ o1 ~此函数有两个参数：
; ?6 F- n3 G, _from：要释放的设备号。
3 q+ w% {7 ?/ [count：表示从from开始，要释放的设备号数量。
8 ?4 k" A6 H; [* J20.4 chrdevbase字符设备驱动开发实验
- N# [/ _, y" d" \字符设备驱动开发的基本步骤我们已经了解了，本节我们就以chrdevbase这个虚拟设备为例，完整的编写一个字符设备驱动模块。chrdevbase不是实际存在的一个设备，是笔者为了方便讲解字符设备的开发而引入的一个虚拟设备。chrdevbase设备有两个缓冲区，一个读缓冲区，一个写缓冲区，这两个缓冲区的大小都为100字节。在应用程序中可以向chrdevbase设备的写缓冲区中写入数据，从读缓冲区中读取数据。chrdevbase这个虚拟设备的功能很简单，但是它包含了字符设备的最基本功能。
1 Z7 }( `% j# z' w20.4.1 实验程序编写
本实验对应的例程路径为：开发板光盘-> 1、Linux驱动例程-> 1_chrdevbase。
1 Y& ]/ K9 v( \$ m7 q: a应用程序调用open函数打开chrdevbase这个设备，打开以后可以使用write函数向chrdevbase的写缓冲区writebuf中写入数据(不超过100个字节)，也可以使用read函数读取读缓冲区readbuf中的数据操作，操作完成以后应用程序使用close函数关闭chrdevbase设备。
1、创建VSCode工程
, X& q6 T9 f; K$ ^/ t在Ubuntu中创建一个目录用来存放Linux驱动程序，比如我创建了一个名为Linux_Drivers的目录来存放所有的Linux驱动。在Linux_Drivers目录下新建一个名为1_chrdevbase的子目录来存放本实验所有文件，如图20.4.1.1所示：



" ~( O8 s2 e5 d! ~1 m" }图20.4.1.1 Linux实验程序目录
/ f( n( ^! t4 Z' e4 @0 N+ A在1_chrdevbase目录中新建VSCode工程，并且新建chrdevbase.c文件，完成以后1_chrdevbase目录中的文件如图20.4.1.2所示：
1 E1 ~7 F1 ~' ?' c4 ~


' t" ]/ V3 B0 b6 m- H, U. h6 _图20.4.1.2 1_chrdevbase目录文件
. [0 O& ^$ E# T. _( e5 m5 _1 J) d2、添加头文件路径
因为是编写Linux驱动，因此会用到Linux源码中的函数。我们需要在VSCode中添加Linux源码中的头文件路径。打开VSCode，按下“Crtl+Shift+P”打开VSCode的控制台，然后输入“C/C++: Edit configurations(JSON) ”，打开C/C++编辑配置文件，如图20.4.1.3所示：


5 i0 T: Y% `" y
' P" @4 k+ s8 N' b  R; C( Y图20.4.1.3 C/C++编辑配置文件
' o' _! [6 p; |9 j9 q" D打开以后会自动在.vscode目录下生成一个名为c_cpp_properties.json的文件，此文件默认内容如下所示：

# Z" t/ E$ k: ^

1. 示例代码20.4.1.1 c_cpp_properties.json文件原内容
   1 ~- U4 i4 m7 h' \7 g
2. 1  {
   ( w/ C# K+ m5 t5 F, A
3. 2      "configurations": [
   
4. 3          {
   
5. 4              "name": "Linux",
   
6. 5              "includePath": [
   
7. 6                  "${workspaceFolder}/**",
   
8. 7                  ],
   
9. 8              "defines": [],
   ( i5 ]; c7 l* l  F/ `, R
10. 9              "compilerPath": "/usr/bin/clang",
    4 I/ o1 O8 A5 f! u  O% t
11. 10             "cStandard": "c11",
    - n2 R2 d  f0 ~' D. k7 m
12. 11             "cppStandard": "c++17",
    6 k) i: r4 i# O. T
13. 12             "intelliSenseMode": "clang-x64"
    
14. 13         }
    
15. 14     ],
    . ~# @8 N) J6 d! Z
16. 15     "version": 4
    
17. 16 }

复制代码

第5行的includePath表示头文件路径，需要将Linux源码里面的头文件路径添加进来，也就是我们前面移植的Linux源码中的头文件路径。添加头文件路径以后的c_cpp_properties.json的文件内容如下所示：
( t9 Q$ j' j, q0 z# L. k2 w, _

1. 示例代码20.4.1.2 添加头文件路径后的c_cpp_properties.json
   
2. 1  {
   ( c, I6 a4 K2 K
3. 2      "configurations": [
   , L' P2 B3 E$ z/ D
4. 3          {
   
5. 4              "name": "Linux",
   8 U; m/ s. |( A3 @$ w% m
6. 5              "includePath": [
   + z) ~, d  r" O
7. 6                  "${workspaceFolder}/**",
   
8. 7                  "/home/zuozhongkai/linux/atk-mp1/linux/my_linux/
   
9. linux-5.4.31/arch/arm/include",
   
10. 8                  "/home/zuozhongkai/linux/atk-mp1/linux/my_linux/
    ' d! D+ W3 M: u# U$ S/ _6 a) ]
11. linux-5.4.31/include",
    
12. 9                  "/home/zuozhongkai/linux/atk-mp1/linux/my_linux/
    
13. linux-5.4.31/arch/arm/include/generated"
    $ [4 A* S+ b* ~  C% h
14. 10             ],
    # Q6 }* W  v9 T( l$ _. E
15. 11             "defines": [],
    $ E6 S- ^! x7 g3 Y
16. 12             "compilerPath": "/usr/bin/gcc",
    
17. 13             "cStandard": "gnu11",
    
18. 14             "cppStandard": "gnu++14",
    5 Q! L. }: \" b0 w2 f
19. 15             "intelliSenseMode": "gcc-x64"
    ! F2 G; R+ G  f. K; E! A
20. 16         }
    3 z( t8 ^8 N8 m
21. 17     ],
    6 o: a% d* Z/ K( {$ Y: M8 m, d
22. 18     "version": 4
    
23. 19 }

复制代码

8 L* |. I+ |8 l7 {" P7 M& y9 E$ m第7~9行就是添加好的Linux头文件路径。分别是开发板所使用的Linux源码下的include、arch/arm/include和arch/arm/include/generated这三个目录的路径，注意，这里使用了绝对路径。
3、编写实验程序
工程建立好以后就可以开始编写驱动程序了，新建chrdevbase.c，然后在里面输入如下内容：

1. 示例代码20.4.1.3 chrdevbase.c文件
   : ?* u/ t, q) E% Y
2. 1   #include <linux/types.h>
   
3. 2   #include <linux/kernel.h>
   2 |9 d, \& c' e
4. 3   #include <linux/delay.h>
   
5. 4   #include <linux/ide.h>
   # Y( H9 {" L. }2 X
6. 5   #include <linux/init.h>
   
7. 6   #include <linux/module.h>
   
8. 7   /***************************************************************
   
9. 8   Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
   
10. 9   文件名         : chrdevbase.c
    3 h7 B4 H1 m+ l
11. 10  作者           : 正点原子
    
12. 11  版本           : V1.0
    ) `- T9 C7 f1 B6 m' O
13. 12  描述           : chrdevbase驱动文件。
    
14. 13  其他           : 无
    
15. 14  论坛           : <a href="http://www.openedv.com" target="_blank">www.openedv.com</a>
    1 F; C0 E3 q7 e0 ^
16. 15  日志           : 初版V1.0 2020/12/26 正点原子团队创建
    . n' F  U: R# [% q. n2 L5 Z
17. 16  ***************************************************************/
    
18. 17  
    
19. 18  #define CHRDEVBASE_MAJOR    200                             /* 主设备号                 */
    2 l8 B/ f. c' o/ v* i4 i" k6 B2 L
20. 19  #define CHRDEVBASE_NAME     "chrdevbase"            /* 设备名             */
    9 ?5 \8 Z' p4 y& W9 G- M
21. 20  
    
22. 21  static char readbuf[100];                                               /* 读缓冲区                 */
      `+ C% O3 X9 I: J2 S0 L
23. 22  static char writebuf[100];                                              /* 写缓冲区                 */
    
24. 23  static char kerneldata[] = {"kernel data!"};
    . T3 }3 O6 j0 Q
25. 24  
    
26. 25  /*
    
27. 26   * @description         : 打开设备
    
28. 27   * @param – inode        : 传递给驱动的inode
    4 {  y2 n$ W% _* S* B5 V
29. 28   * @param - filp         : 设备文件，file结构体有个叫做private_data的成员变量
    2 w! e$ h, N7 R. k! v
30. 29   *                    一般在open的时候将private_data指向设备结构体。
    
31. 30   * @return               : 0 成功;其他 失败
    2 J$ j+ {& X+ [4 c. I1 F
32. 31   */
    5 _' v& P4 ~; m) ~
33. 32  static int chrdevbase_open(struct inode *inode, struct file *filp)
    
34. 33  {
    ) L4 G6 M. z0 C4 |
35. 34      //printk("chrdevbase open!\r\n");
    ) t4 j# D$ S6 f9 F+ x+ y  {
36. 35      return 0;
    
37. 36  }
    
38. 37  
    
39. 38  /*
    
40. 39   * @description          : 从设备读取数据
    
41. 40   * @param - filp         : 要打开的设备文件(文件描述符)
    
42. 41   * @param - buf          : 返回给用户空间的数据缓冲区
    
43. 42   * @param - cnt          : 要读取的数据长度
    
44. 43   * @param - offt         : 相对于文件首地址的偏移
    
45. 44   * @return               : 读取的字节数，如果为负值，表示读取失败
    
46. 45   */
    
47. 46  static ssize_t chrdevbase_read(struct file *filp, char __user *buf,
    
48. size_t cnt, loff_t *offt)
    0 b0 z( x  l/ G" e* a
49. 47  {
    
50. 48      int retvalue = 0;
    
51. 49      
    $ b6 E+ Q) I' B6 t. r
52. 50      /* 向用户空间发送数据 */
    ' H; ]6 W& b' v( x4 j4 _
53. 51      memcpy(readbuf, kerneldata, sizeof(kerneldata));
    
54. 52      retvalue = copy_to_user(buf, readbuf, cnt);
    
55. 53      if(retvalue == 0){
      J2 w( U9 w2 z6 q# n; i! i; u
56. 54          printk("kernel senddata ok!\r\n");
    
57. 55      }else{
    
58. 56          printk("kernel senddata failed!\r\n");
    
59. 57      }
    : G5 Q* K7 O4 }( D1 |3 R
60. 58      
    
61. 59      //printk("chrdevbase read!\r\n");
    1 g; S! o; U* _0 |
62. 60      return 0;
    . A2 B% O( U0 l9 v# |& I  C/ y
63. 61  }
    
64. 62  
    
65. 63  /*
    8 d, W6 b5 n4 g2 o$ r
66. 64   * @description          : 向设备写数据
    - Y% L- d6 m! A- g, O  H. k0 P/ O
67. 65   * @param - filp         : 设备文件，表示打开的文件描述符
    
68. 66   * @param - buf          : 要写给设备写入的数据
    4 n$ p3 q9 W, ~: u" Y
69. 67   * @param - cnt          : 要写入的数据长度
    : P% g- \8 j7 S5 N" f# z2 V+ D
70. 68   * @param - offt         : 相对于文件首地址的偏移
    
71. 69   * @return                : 写入的字节数，如果为负值，表示写入失败
    . x/ B- \% S8 P, H9 K; j
72. 70   */
    . t5 R8 \- E; L9 l5 g
73. 71  static ssize_t chrdevbase_write(struct file *filp,
    + _' @/ u* s6 T
74. const char __user *buf,
    ( R; F, k3 b$ v# C" {
75. size_t cnt, loff_t *offt)
    7 u7 A# h# o$ x% o
76. 72  {
    6 W! `. B) S5 o1 e$ q% r6 r. g/ z
77. 73      int retvalue = 0;
    
78. 74      /* 接收用户空间传递给内核的数据并且打印出来 */
    
79. 75      retvalue = copy_from_user(writebuf, buf, cnt);
    " u* h* W# ^8 w* F
80. 76      if(retvalue == 0){
    
81. 77          printk("kernel recevdata:%s\r\n", writebuf);
    4 F5 V# \0 X5 G
82. 78      }else{
    8 q# }' f; z  f3 ^( Y6 W* r. l
83. 79          printk("kernel recevdata failed!\r\n");
    
84. 80      }
    6 A7 A! C7 M/ [# w1 o/ A7 J! i
85. 81      
    
86. 82      //printk("chrdevbase write!\r\n");
    
87. 83      return 0;
    0 N9 P; ^' O. }5 o, x( C
88. 84  }
    ; S4 X1 h1 x0 ?
89. 85  
    
90. 86  /*
    3 x; z, I- [; j. b: ~. v$ e$ Y" t
91. 87   * @description          : 关闭/释放设备
    
92. 88   * @param - filp         : 要关闭的设备文件(文件描述符)
    
93. 89   * @return               : 0 成功;其他 失败
    
94. 90   */
    
95. 91  static int chrdevbase_release(struct inode *inode,
    
96. struct file *filp)
    & t5 R/ n9 s" z) d$ V
97. 92  {
    - K- o  p5 O; {4 W8 s
98. 93      //printk("chrdevbase release！\r\n");
    
99. 94      return 0;
    4 u9 x1 H/ _  r, y, w+ c
100. 95  }
     
101. 96  
     7 c2 E$ ~4 x4 F! y; r6 B# o0 G, K: c) R; j
102. 97  /*
     / k# C; \! T  ?- W- i
103. 98   * 设备操作函数结构体
     & V- |* T- S% \+ H+ y9 I* [
104. 99   */
     
105. 100 static struct file_operations chrdevbase_fops = {
     
106. 101     .owner = THIS_MODULE,   
     " J' y) _6 o6 f8 i4 ^9 c
107. 102     .open = chrdevbase_open,
     
108. 103     .read = chrdevbase_read,
     * J( v/ o: p: S0 ]5 Q5 @
109. 104     .write = chrdevbase_write,
     
110. 105     .release = chrdevbase_release,
       X5 G) D6 T3 |, t
111. 106 };
     
112. 107
     2 |7 V" B1 I8 ?, `3 w' i
113. 108 /*
     & E4 n) A1 T, K% w# h- d8 g6 L( N
114. 109  * @description         : 驱动入口函数
     
115. 110  * @param               : 无
     , a0 c- \1 _& m: }- D" u' F! J
116. 111  * @return              : 0 成功;其他 失败
     
117. 112  */
     " ~4 h1 }; p* b4 Y8 R
118. 113 static int __init chrdevbase_init(void)
     
119. 114 {
     1 x! Z  Z, j$ ^* i  G4 X# R
120. 115     int retvalue = 0;
     2 ?% [9 ^* ?1 r( J5 m" ?6 U
121. 116
     
122. 117     /* 注册字符设备驱动 */
     
123. 118     retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME,
     
124. &chrdevbase_fops);
     
125. 119     if(retvalue < 0){
     % _" @+ L3 B7 g1 U' D
126. 120         printk("chrdevbase driver register failed\r\n");
     ! l6 ]2 Y% T- M4 k0 K
127. 121     }
     
128. 122     printk("chrdevbase_init()\r\n");
     - q! M- L: n" y, I. w
129. 123     return 0;
     
130. 124 }
     
131. 125
     . T/ C" ^3 v9 O# J; Z. u+ U8 [
132. 126 /*
       v9 e* j$ \; y1 A0 H
133. 127  * @description         : 驱动出口函数
     5 k# P: ]$ f4 D; u2 y, \: u" C
134. 128  * @param               : 无
     
135. 129  * @return              : 无
     
136. 130  */
     1 Z$ ?6 }- x4 z* f  F9 G
137. 131 static void __exit chrdevbase_exit(void)
     - b$ [9 P$ z# x8 [0 b
138. 132 {
       K. d  I" c/ h8 m/ q7 ^. q
139. 133     /* 注销字符设备驱动 */
     + F# }( `4 Z% U2 E! e" {
140. 134     unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
     1 ]4 H4 v3 O* V# ~* b5 X6 b% x. `
141. 135     printk("chrdevbase_exit()\r\n");
     
142. 136 }
     
143. 137
     
144. 138 /*
     
145. 139  * 将上面两个函数指定为驱动的入口和出口函数
     ) q& [0 e) I0 s
146. 140  */
     
147. 141 module_init(chrdevbase_init);
     
148. 142 module_exit(chrdevbase_exit);
     
149. 143
     
150. 144 /*
     
151. 145  * LICENSE和作者信息
     2 o  m2 b$ A" B
152. 146  */
     
153. 147 MODULE_LICENSE("GPL");
     0 O! U: l/ r8 G! d) g
154. 148 MODULE_AUTHOR("ALIENTEK");
     + |2 i/ }) e+ M9 R& ], K
155. 149 MODULE_INFO(intree, "Y");
     5 J3 _' v; s1 t1 [. f' t

复制代码

第32~36行，chrdevbase_open函数，当应用程序调用open函数的时候此函数就会调用。本例程中我们没有做任何工作，只是输出一串字符，用于调试。这里使用了printk来输出信息，而不是printf！因为在Linux内核中没有printf这个函数。printk相当于printf的孪生兄妹，printf运行在用户态，printk运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用printk这个函数。不同之处在于，printk可以根据日志级别对消息进行分类，一共有8个消息级别，这8个消息级别定义在文件include/linux/kern_levels.h里面，定义如下：
2 G/ j6 E1 s# b0 g2 t* @0 @+ u+ r7 \

1. #define KERN_SOH                "\001"        
   
2. #define KERN_EMERG                KERN_SOH "0"        /* 紧急事件，一般是内核崩溃                         */
   
3. #define KERN_ALERT                KERN_SOH "1"        /* 必须立即采取行动                                         */
   6 N6 U2 u  _! ]- n
4. #define KERN_CRIT                KERN_SOH "2"        /* 临界条件，比如严重的软件或硬件错误*/
   8 O/ \8 F; L& @, y* q, ^5 x
5. #define KERN_ERR                KERN_SOH "3"        /* 错误状态，一般设备驱动程序中使用
   * Q' A, _+ q# m9 B. g) o& T7 z
6. KERN_ERR报告硬件错误              */
   
7. #define KERN_WARNING        KERN_SOH "4"        /* 警告信息，不会对系统造成严重影响        */
   
8. #define KERN_NOTICE        KERN_SOH "5"        /* 有必要进行提示的一些信息                        */
   6 I8 L6 k! h- h/ j& ^  n
9. #define KERN_INFO                KERN_SOH "6"        /* 提示性的信息                                                 */
   0 t$ B5 Q1 s; H" b' B! M7 q! u( ]
10. #define KERN_DEBUG                KERN_SOH "7"        /* 调试信息                                                        */

复制代码

9 C2 t$ I  M* P4 g+ ?$ n' M一共定义了8个级别，其中0的优先级最高，7的优先级最低。如果要设置消息级别，参考如下示例：
printk(KERN_EMERG “gsmi: Log Shutdown Reason\n”);
上述代码就是设置“gsmi: Log Shutdown Reason\n”这行消息的级别为KERN_EMERG。在具体的消息前面加上KERN_EMERG就可以将这条消息的级别设置为KERN_EMERG。如果使用printk的时候不显式的设置消息级别，那么printk将会采用默认级别MESSAGE_LOGLEVEL_DEFAULT。
在include/linux/printk.h中有个宏CONSOLE_LOGLEVEL_DEFAULT，定义如下：

#define CONSOLE_LOGLEVEL_DEFAULT  CONFIG_CONSOLE_LOGLEVEL_DEFAULT
- n8 p5 T  A% C$ ?! z9 T( \& m" K# s        MESSAGE_LOGLEVEL_DEFAULT和CONFIG_CONSOLE_LOGLEVEL_DEFAULT是通过内核图形化界面配置的，配置路径如下：
3 o! E, x- N' F! E0 o

1. -> Kernel hacking              
   ) z2 ?2 [6 S* m& }# o/ |) Q
2.         -> printk and dmesg options
   
3.                 -> (7) Default console loglevel (1-15)           //设置默认终端消息级别
   
4.                 -> (4) Default message log level (1-7)           //设置默认消息级别

复制代码

“Default console loglevel”就是用来设置CONSOLE_LOGLEVEL_DEFAULT的值，“Default message log level”设置CONFIG_MESSAGE_LOGLEVEL_DEFAULT的值。默认如图20.4.1.1所示：

- O+ e' T5 m9 s
2 ^9 M/ m) i0 C# l3 g9 G
图20.4.1.1 内核消息配置
' z! T/ \, k) _1 a图20.4.1.1可以看出，默认为CONSOLE_LOGLEVEL_DEFAULT默认为7。所以红CONSOLE_LOGLEVEL_DEFAULT的值默认也为7，MESSAGE_LOGLEVEL_DEFAULT默认值为4。CONSOLE_LOGLEVEL_DEFAULT控制着哪些级别的消息可以显示在控制台上，此宏默认为7，意味着只有优先级高于7的消息才能显示在控制台上。
' ^. B$ j; Q/ Q4 U, P这个就是printk和printf的最大区别，可以通过消息级别来决定哪些消息可以显示在控制台上。默认消息级别为4，4的级别比7高，所示直接使用printk输出的信息是可以显示在控制台上的。
参数filp有个叫做private_data的成员变量，private_data是个void指针，一般在驱动中将private_data指向设备结构体，设备结构体会存放设备的一些属性。
- K# \; P1 G) {$ G第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)
! c: b0 ^: S" A- j, U参数to表示目的，参数from表示源，参数n表示要复制的数据长度。如果复制成功，返回值为0，如果复制失败则返回负数。
# T9 r. u3 W4 ^8 _1 y5 x第71~84行，chrdevbase_write函数，应用程序调用write函数向设备写数据的时候此函数就会执行。参数buf就是应用程序要写入设备的数据，也是用户空间的内存，参数cnt是要写入的数据长度，参数offt是相对文件首地址的偏移。第75行通过函数copy_from_user将buf中的数据复制到写缓冲区writebuf中，因为用户空间内存不能直接访问内核空间的内存，所以需要借助函数copy_from_user将用户空间的数据复制到writebuf这个内核空间中。
! F8 q; v! p7 w第91~95行，chrdevbase_release函数，应用程序调用close关闭设备文件的时候此函数会执行，一般会在此函数里面执行一些释放操作。如果在open函数中设置了filp的private_data成员变量指向设备结构体，那么在release函数最终就要释放掉。
( {# b# n* ~9 U) o第100~106行，新建chrdevbase的设备文件操作结构体chrdevbase_fops，初始化chrdevbase_fops。
第113~124行，驱动入口函数chrdevbase_init，第118行调用函数register_chrdev来注册字符设备。
- J1 j  W: H0 z+ X' Q第131~136行，驱动出口函数chrdevbase_exit，第134行调用函数unregister_chrdev来注销字符设备。
! t8 q+ B, N( E* n第141~142行，通过module_init和module_exit这两个函数来指定驱动的入口和出口函数。
第147~148行，添加LICENSE和作者信息。
' f9 p! k" R1 `第149行是为了欺骗内核，给本驱动添加intree标记，如果不加就会有“loading out-of-tree module taints kernel.”这个警告
20.4.2 编写测试APP
1、C库文件操作基本函数
编写测试APP就是编写Linux应用，需要用到C库里面和文件操作有关的一些函数，比如open、read、write和close这四个函数。
# Q2 w. ?2 Z5 T; s- s①、open函数
open函数原型如下：
+ L1 ?' s. a$ ^int open(const char *pathname, int flags)
open函数参数含义如下：
2 l  N' t. |6 i# F5 Zpathname：要打开的设备或者文件名。
flags：文件打开模式，以下三种模式必选其一：
7 \7 l! w% S# y. e' nO_RDONLY 只读模式
" z* n  u. c* [& i2 n5 JO_WRONLY 只写模式
# B4 c( f. ]% M) d  `7 u+ r5 Z* IO_RDWR　　 读写模式
因为我们要对chrdevbase这个设备进行读写操作，所以选择O_RDWR。除了上述三种模式以外还有其他的可选模式，通过逻辑或来选择多种模式：
O_APPEND　　 每次写操作都写入文件的末尾
O_CREAT　　 如果指定文件不存在，则创建这个文件
6 [8 a) R; ~2 n( MO_EXCL　　 如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
/ J/ K9 E6 ~& O( t9 n; S4 aO_TRUNC　　 如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
2 F8 O( t. a$ D: E2 PO_NOCTTY　　 如果路径名指向终端设备，不要把这个设备用作控制终端。
O_NONBLOCK 如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O设置为非阻塞
: p0 u1 l+ m$ x3 o* mO_DSYNC　　 等待物理 I/O 结束后再 write。在不影响读取新写入的数据的前提
* ]$ n9 q/ {. L# Z' T" t7 r下，不等待文件属性更新。
O_RSYNC　　 read 等待所有写入同一区域的写操作完成后再进行。
O_SYNC　　 等待物理 I/O 结束后再 write，包括更新文件属性的 I/O。
; d2 w0 Z5 |: K返回值：如果文件打开成功的话返回文件的文件描述符。
' N1 d2 L; ^$ y. h在Ubuntu中输入“man 2 open”即可查看open函数的详细内容，如图20.4.2.1所示：


) {3 Q2 b8 M7 N5 Z
, b- F5 W3 _1 K+ ?5 s8 n$ T4 r6 u# m3 T图20.4.2.1 open函数帮助信息
②、read函数
4 Z: ?/ Z& f( Q' G( F# Bread函数原型如下：
! h( U. [1 Z; x% e+ bssize_t read(int fd, void *buf, size_t count)
3 ^) b( ]) q7 F, B; cread函数参数含义如下：
9 |% O$ k5 P8 r5 F' zfd：要读取的文件描述符，读取文件之前要先用open函数打开文件，open函数打开文件成功以后会得到文件描述符。
buf：数据读取到此buf中。
count：要读取的数据长度，也就是字节数。
返回值：读取成功的话返回读取到的字节数；如果返回0表示读取到了文件末尾；如果返回负值，表示读取失败。在Ubuntu中输入“man 2 read”命令即可查看read函数的详细内容。
③、write函数
) Z5 m' f+ s( V! s% hwrite函数原型如下：
ssize_t write(int fd, const void *buf, size_t count);
write函数参数含义如下：
7 t# s0 h) k2 Cfd：要进行写操作的文件描述符，写文件之前要先用open函数打开文件，open函数打开文件成功以后会得到文件描述符。
4 n+ N0 w' F5 m' P" Cbuf：要写入的数据。
- Q' d  \' J4 s7 qcount：要写入的数据长度，也就是字节数。
+ y7 |3 N- A% N3 v  t) p. J& s返回值：写入成功的话返回写入的字节数；如果返回0表示没有写入任何数据；如果返回负值，表示写入失败。在Ubuntu中输入“man 2 write”命令即可查看write函数的详细内容。
/ L- X; {1 K9 }7 x+ P0 F8 {④、close函数
7 j7 L; y/ }# e* dclose函数原型如下：
/ D3 [2 S, U, ]# ?) }3 Eint close(int fd);
close函数参数含义如下：
fd：要关闭的文件描述符。
' t/ v( S5 o  Y7 J9 d/ S9 l; I返回值：0表示关闭成功，负值表示关闭失败。在Ubuntu中输入“man 2 close”命令即可查看close函数的详细内容。
! w: B( P* \( Q2、编写测试APP程序
驱动编写好以后是需要测试的，一般编写一个简单的测试APP，测试APP运行在用户空间。测试APP很简单通过输入相应的指令来对chrdevbase设备执行读或者写操作。在1_chrdevbase目录中新建chrdevbaseApp.c文件，在此文件中输入如下内容：
/ H* m1 E$ Y* J9 X( r/ i: K) h
7 m8 x: {9 k9 @$ a% X

1. 示例代码20.4.2.1 chrdevbaseApp.c文件
   5 ?3 N9 ^& W3 x# x( C# Q' }
2. 1  #include "stdio.h"
   6 E* Y0 c7 n  p: j3 E
3. 2  #include "unistd.h"
   $ f  b9 a) ]1 @! f
4. 3  #include "sys/types.h"
   
5. 4  #include "sys/stat.h"
   ! W2 h. p( w! i1 S# l
6. 5  #include "fcntl.h"
   
7. 6  #include "stdlib.h"
   ) g3 Q$ \; j1 Q0 u& @4 r3 K
8. 7  #include "string.h"
   
9. 8  /***************************************************************
   
10. 9  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
    
11. 10 文件名     : chrdevbaseApp.c
    7 `- U" C3 B9 |9 r5 q6 b* c4 F
12. 11 作者       : 正点原子
    
13. 12 版本       : V1.0
    . c0 B/ v2 u: Q
14. 13 描述       : chrdevbase驱测试APP。
    4 D. |  D4 }* y; \) G: D
15. 14 其他       : 使用方法：./chrdevbaseApp /dev/chrdevbase <1>|<2>
    - e  f4 ^% v: U$ i: s) q
16. 15              argv[2] 1:读文件
    
17. 16              argv[2] 2:写文件      
    + m: s" K$ _6 y( c
18. 17 论坛       : <a href="http://www.openedv.com" target="_blank">www.openedv.com</a>
    " M: ]8 G, ], c. x0 _, Q
19. 18 日志       : 初版V1.0 2019/1/30 正点原子团队创建
    5 Z- Q8 W! s% B( ?
20. 19 ***************************************************************/
    / y% M" }* A: }& @& O2 U" m" [% l" Q
21. 20
    5 ~; o5 [4 N* C& l5 e- L" F: J6 ]
22. 21 static char usrdata[] = {"usr data!"};
    & {# @: D" g/ s8 @1 L( B- K. t
23. 22
    
24. 23 /*
    3 \% ~) `& B( w4 ~+ u7 m
25. 24  * @description          : main主程序
    
26. 25  * @param - argc          : argv数组元素个数
    
27. 26  * @param - argv          : 具体参数
    $ [- p6 Q! G1 q
28. 27  * @return                : 0 成功;其他 失败
    
29. 28  */
    0 A4 e' }% I  E, j# T
30. 29 int main(int argc, char *argv[])
    " Y0 S; K/ B2 O% |) q
31. 30 {
    
32. 31          int fd, retvalue;
    
33. 32          char *filename;
    6 a* L2 o  q) c, H8 Q
34. 33          char readbuf[100], writebuf[100];
    
35. 34
    
36. 35          if(argc != 3){
    
37. 36              printf("Error Usage!\r\n");
    
38. 37              return -1;
    
39. 38          }
    
40. 39
    
41. 40          filename = argv[1];
    0 c  k2 g6 n: A3 Z( O. n
42. 41
    
43. 42          /* 打开驱动文件 */
    1 H) Q6 b# D; d- K& h
44. 43          fd  = open(filename, O_RDWR);
    ) S$ L0 p- R( z  r( b
45. 44          if(fd < 0){
    : e. r  n/ e% Q: F
46. 45              printf("Can't open file %s\r\n", filename);
    ; l! p* Q& ^( E0 ^6 W9 X
47. 46              return -1;
    ' x8 Z/ |' o) Z# h! `
48. 47          }
    
49. 48
    , C2 O& h' x$ h9 \) d2 F+ D: T* v5 y
50. 49          if(atoi(argv[2]) == 1){ /* 从驱动文件读取数据 */
    
51. 50              retvalue = read(fd, readbuf, 50);
    
52. 51              if(retvalue < 0){
    8 X4 X1 x; z8 Y
53. 52                         printf("read file %s failed!\r\n", filename);
    
54. 53              }else{
    & ~' p& G5 N$ ^& U& f6 Y
55. 54                         /*  读取成功，打印出读取成功的数据 */
    
56. 55                          printf("read data:%s\r\n",readbuf);
    
57. 56              }        
    
58. 57          }
    
59. 58
    
60. 59          if(atoi(argv[2]) == 2){
    
61. 60              /* 向设备驱动写数据 */
    
62. 61              memcpy(writebuf, usrdata, sizeof(usrdata));
    , I8 c& H# ]# h$ D' J# T( Q6 U
63. 62              retvalue = write(fd, writebuf, 50);
    
64. 63              if(retvalue < 0){
    
65. 64                          printf("write file %s failed!\r\n", filename);
    ; z$ j. J4 W% }$ S3 Z
66. 65              }
    * |% B( \4 o9 c& q) \( B! W9 }# p
67. 66          }
    
68. 67
    & |# T3 j' M' {* Q" O
69. 68          /* 关闭设备 */
    
70. 69          retvalue = close(fd);
    
71. 70          if(retvalue < 0){
    
72. 71              printf("Can't close file %s\r\n", filename);
    & ]0 Z5 e, L" i4 B" @' y; B: d* F% G+ E
73. 72              return -1;
    
74. 73          }
    
75. 74
    
76. 75          return 0;
    9 ^0 J" F3 i: x4 Q8 |. b2 x
77. 76 }

复制代码

第21行，数组usrdata是测试APP要向chrdevbase设备写入的数据。
: i3 Y1 g4 H1 i第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]保存着设备名字。
, {8 T! g% a, W0 z第43行，调用C库中的open函数打开设备文件：/dev/chrdevbase。
. @4 n' R+ H' m; ~( q第49行，判断argv[2]参数的值是1还是2，因为输入命令的时候其参数都是字符串格式的，因此需要借助atoi函数将字符串格式的数字转换为真实的数字。
% \9 P0 P9 @6 j% w, E" J& @0 r; a3 ]第50行，当argv[2]为1的时候表示要从chrdevbase设备中读取数据，一共读取50字节的数据，读取到的数据保存在readbuf中，读取成功以后就在终端上打印出读取到的数据。
第59行，当argv[2]为2的时候表示要向chrdevbase设备写数据。
第69行，对chrdevbase设备操作完成以后就关闭设备。
2 _; m8 j8 E: g* r" AchrdevbaseApp.c内容还是很简单的，就是最普通的文件打开、关闭和读写操作。
20.4.3 编译驱动程序和测试APP
. l8 K) [' L) }: o2 P1、编译驱动程序
5 I' G# P+ f2 C首先编译驱动程序，也就是chrdevbase.c这个文件，我们需要将其编译为.ko模块，创建Makefile文件，然后在其中输入如下内容：
2 u% u8 W4 [" q5 o$ ~
7 D! K: a& E  f

1. 示例代码20.4.3.1 Makefile文件
   
2. 1  KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31
   & @  b  X$ |2 e% s6 v, ?( O1 T0 |( U
3. 2  CURRENT_PATH := $(shell pwd)
   - d$ k; ]/ z9 x$ r  X) P3 ?+ m0 S% {
4. 3  obj-m := chrdevbase.o
   # Q0 y/ {4 H/ C6 L% U
5. 4  
   
6. 5  build: kernel_modules
   
7. 6  
   
8. 7  kernel_modules:
   
9. 8           $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
   
10. 9  clean:
    
11. 10          $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

1 S8 b5 u0 Z  X5 E/ F; c第1行，KERNELDIR表示开发板所使用的Linux内核源码目录，使用绝对路径，大家根据自己的实际情况填写即可。
第2行，CURRENT_PATH表示当前路径，直接通过运行“pwd”命令来获取当前所处路径。
4 ]/ h3 j/ P' u- K% x+ X第3行，obj-m表示将chrdevbase.c这个文件编译为chrdevbase.ko模块。
# n# h/ D9 A; p- t  n3 \第8行，具体的编译命令，后面的modules表示编译模块，-C表示将当前的工作目录切换到指定目录中，也就是KERNERLDIR目录。M表示模块源码目录，“make modules”命令中加入M=dir以后程序会自动到指定的dir目录中读取模块的源码并将其编译为.ko文件。
3 J( |; x6 |9 f5 ~# |Makefile编写好以后输入“make”命令编译驱动模块，编译过程如图20.4.3.1所示：

2 N3 |5 Q  g. d4 m6 ?& Z7 _
9 ~2 k; c& M- {" @6 d
; ?, `# @; `2 `) T, z* A1 q1 x1 T5 u# |1 H图20.4.3.1 驱动模块编译过程
编译成功以后就会生成一个叫做chrdevbaes.ko的文件，此文件就是chrdevbase设备的驱动模块。至此，chrdevbase设备的驱动就编译成功。
2、编译测试APP
测试APP比较简单，只有一个文件，因此就不需要编写Makefile了，直接输入命令编译。因为测试APP是要在ARM开发板上运行的，所以需要使用arm-linux-gnueabihf-gcc来编译，输入如下命令：
* H' v0 s3 Q8 Earm-none-linux-gnueabihf-gcc chrdevbaseApp.c -o chrdevbaseApp
5 y1 N# Z- a$ `* k: I, `: m编译完成以后会生成一个叫做chrdevbaseApp的可执行程序，输入如下命令查看chrdevbaseAPP这个程序的文件信息：
* {% B; i+ {# |$ f+ a1 Xfile chrdevbaseApp
结果如图20.4.3.2所示：


! `* u& H3 F9 C8 y
图20.4.3.2 chrdevbaseAPP文件信息
从图20.4.3.2可以看出，chrdevbaseAPP这个可执行文件是32位LSB格式，ARM版本的，因此chrdevbaseAPP只能在ARM芯片下运行。
1 b9 y1 X$ b7 c4 B/ x6 `20.4.4 运行测试
1、加载驱动模块
7 l  x: v6 Y6 S6 J) ^9 N驱动模块chrdevbase.ko和测试软件chrdevbaseAPP都已经准备好了，接下来就是运行测试。为了方便测试，Linux系统选择通过TFTP从网络启动，并且使用NFS挂载网络根文件系统。确保uboot中bootcmd环境变量的值为：
  d3 v: @) C" j+ t3 m! s/ ^tftp c2000000 uImage;tftp c4000000 stm32mp157d-atk.dtb;bootm c2000000 - c4000000
bootargs环境变量的值为：
  q; H- K+ [  R$ `, xconsole=ttySTM0,115200 root=/dev/nfs nfsroot=192.168.1.249:/home/zuozhongkai/linux/nfs/rootfs,proto=tcp rw ip=192.168.1.250:192.168.1.249:192.168.1.1:255.255.255.0::eth0ff
6 m  ?' R) u* t1 p8 a, R1 P$ i. [: a设置好以后启动Linux系统，检查开发板根文件系统中有没有“/lib/modules/5.4.31”这个目录，如果没有的话自行创建。因为是通过NFS将Ubuntu中的rootfs(第十八章制作好的buildroot根文件系统)目录挂载为根文件系统，所以可以很方便的将chrdevbase.ko和chrdevbaseAPP复制到rootfs/lib/modules/5.4.31目录中，命令如下：
3 A3 k, t9 o3 Gsudo cp chrdevbase.ko chrdevbaseApp /home/zuozhongkai/linux/nfs/rootfs/lib/modules/4.1.15/ -f
拷贝完成以后就会在开发板的/lib/modules/5.4.31目录下存在chrdevbase.ko和chrdevbaseAPP这两个文件，如图20.4.4.1所示：


3 j0 w! w- H) {3 N  \6 }
图20.4.4.1 驱动和测试文件
; I6 R) ]; R# a输入如下命令加载chrdevbase.ko驱动文件：
5 b, g+ c6 P9 ^0 V' n. l# nmodprobe chrdevbase.ko
& t$ ]7 S, J& r0 v( v. j& c* x9 j或
* d/ [0 L* m& @( y+ E7 Q$ Winsmod chrdevbase.ko
如果使用modprobe加载驱动的话，可能会出现如图20.4.4.2或图20.4.4.3所示的提示：


- ?3 v4 d2 g1 d  E
图20.4.4.2 找不到“modules.dep”文件
2 i! @3 Q6 o9 S* Q* M+ o/ N
: h/ M* l% \8 Y! C& p& Z8 p

3 d7 C( ?/ C; d% p图20.4.4.3 找不到“chrdevbase.ko”文件
! I( F  c  U6 Y图20.4.4.2和图20.4.4.3分别提示找不到“moudules.dep”和“chrdevbase.ko”，产生这两个错误的原因都是一样的。modprobe命令会在“/lib/modules/5.4.31”目录下解析modules.dep文件，modules.dep文件里面保存了要加载的.ko模块，我们不用手动创建modules.dep这个文件，直接输入depmod命令即可自动生成modules.dep，有些根文件系统可能没有depmod这个命令，如果没有这个命令就只能重新配置busybox，使能此命令，然后重新编译busybox。输入“depmod”命令以后会自动生成modules.alias、modules.symbols和modules.dep等等一些modprobe所需的文件，如图20.4.4.4所示：



% P; |9 u: F. f# Z6 T# X) {5 O图20.4.4.4 depmod命令执行结果
3 g  b# I$ U8 t8 U4 J* b重新使用modprobe加载chrdevbase.ko，结果如图20.4.4.5所示：


+ l2 x# ?' i# X; A
. B2 d" D. \" A图20.4.4.5 驱动加载成功
从图20.4.4.5可以看到“chrdevbase init！”这一行，这一行正是chrdevbase.c中模块入口函数chrdevbase_init输出的信息，说明模块加载成功！
6 L" y: ^# U$ i6 F# B注意：用modprobe这个命令加载模块不用加‘.ko’，加了的话可能报会图20.4.4.3所示错误，所以建议大家在使用modprobe命令加载驱动模块的时候不用加模块名字后面的“.ko”后缀。
输入“lsmod”命令即可查看当前系统中存在的模块，结果如图20.4.4.6所示：
% T8 n& d( i4 P* i


0 d2 Z1 _- s2 M& U图20.4.4.6 当前系统中的模块
从图20.4.4.6可以看出，当前系统只有“chrdevbase”这一个模块。输入如下命令查看当前系统中有没有chrdevbase这个设备：
cat /proc/devices
结果如图20.4.4.7所示：

7 U& w* S. w% h5 l9 f( W. c
( g+ `5 \* }- ?0 P, r- K3 N
0 K  d8 g1 O9 T: Q3 [$ R" R7 e图20.4.4.7 当前系统设备
) \8 u' T$ v7 K' U9 g" P6 s从图20.4.4.7可以看出，当前系统存在chrdevbase这个设备，主设备号为200，跟我们设置的主设备号一致。
4 d2 I9 E: d: q2、创建设备节点文件
驱动加载成功需要在/dev目录下创建一个与之对应的设备节点文件，应用程序就是通过操作这个设备节点文件来完成对具体设备的操作。输入如下命令创建/dev/chrdevbase这个设备节点文件：
- R# G' c8 L2 h: d5 X1 ?mknod /dev/chrdevbase c 200 0
' L% f% J2 r& S# F! E" s其中“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个字符设备，“200”是设备的主设备号，“0”是设备的次设备号。创建完成以后就会存在/dev/chrdevbase这个文件，可以使用“ls /dev/chrdevbase -l”命令查看，结果如图20.4.4.8所示：


6 f6 m. O1 s0 R9 J( c$ O
图20.4.4.8 /dev/chrdevbase文件
如果chrdevbaseAPP想要读写chrdevbase设备，直接对/dev/chrdevbase进行读写操作即可。相当于/dev/chrdevbase这个文件是chrdevbase设备在用户空间中的实现。前面一直说Linux下一切皆文件，包括设备也是文件，现在大家应该是有这个概念了吧？
3、chrdevbase设备操作测试
一切准备就绪，接下来就是“大考”的时刻了。使用chrdevbaseApp软件操作chrdevbase这个设备，看看读写是否正常，首先进行读操作，输入如下命令：
( S9 u. f, |- G4 }' [2 @./chrdevbaseApp /dev/chrdevbase 1
( b1 u- v2 S. F# ?6 v" P$ W. y结果如图20.4.4.9所示：
: x+ G* ?5 }6 S

• 关闭
• [url=]上传图片[/url]
• [url=]网络图片[/url]
  

upload
: O  T3 Y0 t6 p$ J6 Y
& t2 c& @) G9 E+ b: |5 q

  S3 X+ I1 K" S0 o! ~$ v& `- Q7 C


图20.4.4.9 读操作结果
从图20.4.4.9可以看出，首先输出“kernel senddata ok!”这一行信息，这是驱动程序中chrdevbase_read函数输出的信息，因为chrdevbaseAPP使用read函数从chrdevbase设备读取数据，因此chrdevbase_read函数就会执行。chrdevbase_read函数向chrdevbaseAPP发送“kernel data!”数据，chrdevbaseAPP接收到以后就打印出来，“read data:kernel data!”就是chrdevbaseAPP打印出来的接收到的数据。说明对chrdevbase的读操作正常，接下来测试对chrdevbase设备的写操作，输入如下命令：
./chrdevbaseApp /dev/chrdevbase 2
9 q$ M) Z* r+ A; v. J7 v) r结果如图20.4.4.10所示：
+ a4 a: {" R" U' c: m5 @& C  E
( }; C+ b* M* ?4 R  e
  i2 E: d7 i% K* p( @* N
图20.4.4.10 写操作结果
只有一行“kernel recevdata:usr data!”，这个是驱动程序中的chrdevbase_write函数输出的。chrdevbaseAPP使用write函数向chrdevbase设备写入数据“usr data!”。chrdevbase_write函数接收到以后将其打印出来。说明对chrdevbase的写操作正常，既然读写都没问题，说明我们编写的chrdevbase驱动是没有问题的。
4、卸载驱动模块
" t3 P# }, S7 f6 n" [如果不再使用某个设备的话可以将其驱动卸载掉，比如输入如下命令卸载掉chrdevbase这个设备：
rmmod chrdevbase
8 r' @( l0 o+ Q( C# L3 r, j4 W卸载以后使用lsmod命令查看chrdevbase这个模块还存不存在，结果如图20.4.4.11所示：
3 q. R* n4 k- G# S

! T( v3 k! H; N# N% I( {
8 G8 v/ Q' I) o* K. q图20.4.4.11 系统中当前模块
从图20.4.4.11可以看出，此时系统已经没有任何模块了，chrdevbase这个模块也不存在了，说明模块卸载成功。
3 Y" z' k; x" e" D至此，chrdevbase这个设备的整个驱动就验证完成了，驱动工作正常。本章我们详细的讲解了字符设备驱动的开发步骤，并且以一个虚拟的chrdevbase设备为例，带领大家完成了第一个字符设备驱动的开发，掌握了字符设备驱动的开发框架以及测试方法，以后的字符设备驱动实验基本都以此为蓝本。
- u) K! v4 |! s————————————————
3 H6 U/ ~: W: k! Z; U+ k' {; B版权声明：正点原子
% l# T* `# q* W, G. t
+ G1 t5 U/ Z1 K2 `6 Q! i