【经验分享】i.MX6ULL开发：驱动开发1——字符设备开发模板

a1a1a21

之前的几篇文章（从i.MX6ULL嵌入式Linux开发1-uboot移植初探起)，介绍了嵌入式了Linux的系统移植（uboot、内核与根文件系统）以及使用MfgTool工具将系统烧写到板子的EMMC中。

本篇开始介绍嵌入式Linux驱动开发。

内容较多，先看目录：

Linux中的外设驱动可以分为三大类：字符设备驱动、块设备驱动和网络设备驱动。

• 字符设备驱动：字符设备是能够按照字节流（比如文件）进行读写操作的设备。字符设备最常见，从最简单的点灯到I2C、SPI、音频等都属于字符设备驱动
• 块设备驱动：以存储块为基础的设备驱动，如EMMC、NAND、SD卡等。对用户而言，字符设备与块设备的访问方式没有差别。
• 网络设备驱动：即网络驱动，它同时具有字符设备和块设备的特点，因为它是输入输出是有结构块的（报文，包，帧），但它的块的大小又不是固定的。
  
  

2 Linux驱动基本原理

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

比如最简单的点灯功能，会有/dev/led这样的驱动文件，应用程序使用open函数来打开文件/dev/led，如果要点亮或关闭led，那么就使用write函数写入开关值，如果要获取led的状态，就用read函数从驱动中读取相应的状态，使用完成以后使用close函数关闭/dev/led这个文件。

2.1 Linux软件分层结构

Linux软件从上到下可以分层4层结构，以控制LED为例：

• 应用层：应用程序使用库提供的open函数打开LED设备
• 库：库根据open函数传入的参数执行“swi”指令，进而引起CPU异常，进入内核
• 内核：内核的异常处理函数根据传入的参数找到对应的驱动程序，返回文件句柄给库，进而返回给应用层
• 应用层得到文件句柄后，使用库提供的write或ioctl发出控制指令
• 库根据write或ioctl函数传入的参数执行“swi”指令，进入内核
• 内核的异常处理函数根据传入的参数找到对应的驱动程序
• 驱动：驱动程序控制硬件，点亮LED
  
  

应用程序运行在用户空间，而Linux驱动属于内核的一部分，因此驱动运行于内核空间。当应用层通过open函数打开/dev/led 这个驱动时，因用户空间不能直接操作内核，因此会使用“系统调用”的方法来从用户空间“陷入”到内核空间，实现对底层驱动的操作。

比如应用程序调用了open这个函数，则在驱动程序中也应有一个对应的open的函数。

2.2 Linux内核驱动操作函数

每一个系统调用，在驱动中都有与之对应的一个驱动函数，在Linux内核文件include/linux/fs.h中有个file_operations结构体，就是Linux内核驱动操作函数集合：

1. struct file_operations {
   
2. struct module *owner;
   
3. loff_t (*llseek) (struct file *, loff_t, int);
   
4. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
   
5. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
   
6. ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
   
7. ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
   
8. int (*iterate) (struct file *, struct dir_context *);
   
9. unsigned int (*poll) (struct file *, struct poll_table_struct *);
   
10. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    
11. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    
12. int (*mmap) (struct file *, struct vm_area_struct *);
    
13. int (*mremap)(struct file *, struct vm_area_struct *);
    
14. int (*open) (struct inode *, struct file *);
    
15. int (*flush) (struct file *, fl_owner_t id);
    
16. int (*release) (struct inode *, struct file *);
    
17. int (*fsync) (struct file *, loff_t, loff_t, int datasync);
    
18. int (*aio_fsync) (struct kiocb *, int datasync);
    
19. int (*fasync) (int, struct file *, int);
    
20. /*省略若干行...*/
    
21. };

复制代码

其中有关字符设备驱动开发中常用的函数有：

• owner：拥有该结构体的模块的指针，一般设置为THIS_MODULE。
• llseek函数：用于修改文件当前的读写位置。
• read函数：用于读取设备文件。
• write函数：用于向设备文件写入(发送)数据。
• poll函数：是个轮询函数，用于查询设备是否可以进行非阻塞的读写。
• unlocked_ioctl函数：提供对于设备的控制功能， 与应用程序中的 ioctl 函数对应。
• compat_ioctl函数：与 unlocked_ioctl功能一样，区别在于在 64 位系统上，32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。
• mmap函数：用于将将设备的内存映射到进程空间中(也就是用户空间)，一般帧缓冲设备会使用此函数， 比如 LCD 驱动的显存，将帧缓冲(LCD 显存)映射到用户空间中以后应用程序就可以直接操作显存了，这样就不用在用户空间和内核空间之间来回复制。
• open函数：用于打开设备文件。
• release函数：用于释放(关闭)设备文件，与应用程序中的 close 函数对应。
• fasync函数：用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。
• aio_fsync函数：与fasync功能类似，只是 aio_fsync 是异步刷新待处理的
  
  

2.3 Linux驱动运行方式

Linux 驱动有两种运行方式：

• 将驱动编译进Linux内核中， 这样当Linux内核启动的时候就会自动运行驱动程序。
• 将驱动编译成模块(扩展名为 .ko)， 在Linux内核启动以后使用“insmod”命令加载驱动模块。
  
  

在驱动开发阶段一般都将其编译为模块，不需要编译整个Linux代码，方便调试驱动程序。当驱动开发完成后，根据实际需要，可以选择是否将驱动编译进Linux内核中。

2.4 Linux设备号2.4.1 设备号的组成

Linux中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成。

• 主设备号：表示某一个具体的驱动
• 次设备号：表示使用这个驱动的各个设备
  
  

Linux 提供了名为dev_t的数据类型表示设备号，其本质是32位的unsigned int数据类型，其中高12位为主设备号，低20位为次设备号，因此Linux中主设备号范围为0~4095。

在文件include/linux/kdev_t.h中提供了几个关于设备号操作的宏定义：

1. #define MINORBITS     20
   
2. #define MINORMASK     ((1U << MINORBITS) - 1)
   
3. 
   
4. #define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS))
   
5. #define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK))
   
6. #define MKDEV(ma,mi)  (((ma) << MINORBITS) | (mi))

复制代码

1. MINORBITS：表示次设备号位数，一共20位
   
2. 
   
3. MINORMASK：表示次设备号掩码
   
4. 
   
5. MAJOR：用于从dev_t中获取主设备号，将dev_t右移20位即可
   
6. 
   
7. MINOR：用于从dev_t中获取次设备号，取dev_t的低20位的值即可
   
8. 
   
9. MKDEV：用于将给定的主设备号和次设备号的值组合成dev_t类型的设备号

复制代码

2.4.2 主设备号的分配

主设备号的分配包括静态分配和动态分配

• 静态分配需要手动指定设备号，并且要注意不能与已有的重复，一些常用的设备号已经被Linux内核开发者给分配掉了，使用“cat /proc/devices”命令可查看当前系统中所有已经使用了的设备号。
• 动态分配是在注册字符设备之前先申请一个设备号，系统会自动分配一个没有被使用的设备号， 这样就避免了冲突。在卸载驱动的时候释放掉这个设备号即可。
  
  

设备号的申请函数：

1. /*
   
2. * dev：保存申请到的设备号
   
3. * baseminor：次设备号起始地址，一般baseminor为0 (次设备号以baseminor为起始地址地址开始递)
   
4. * count：要申请的设备号数量
   
5. * name：设备名字
   
6. */
   
7. int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)

复制代码

设备号的释放函数：

1. /*
   
2. * from：要释放的设备号
   
3. * count：表示从from开始，要释放的设备号数量
   
4. */
   
5. void unregister_chrdev_region(dev_t from, unsigned count)

复制代码

3 字符设备驱动开发模板

3.1 加载与卸载

在编写驱动的时候需要注册模块加载和卸载这两种函数：

module_init(xxx_init);   //注册模块加载函数
module_exit(xxx_exit);   //注册模块卸载函数

• 用来向Linux内核注册一个模块加载函数，参数xxx_init就是需要注册的具体函数，当使用 “insmod” 命令加载驱动的时候，xxx_init这个函数就会被调用。
• 用来向Linux内核注册一个模块卸载函数，参数xxx_exit就是需要注册的具体函数，当使 用“rmmod”命令卸载具体驱动的时候 xxx_exit函数就会被调用。
  
  

字符设备驱动模块加载和卸载模板如下所示：

1. /* 驱动入口函数 */
   
2. static int __init xxx_init(void)
   
3. {
   
4. /*入口函数内容 */
   
5. return 0;
   
6. }
   
7. 
   
8. /* 驱动出口函数 */
   
9. static void __exit xxx_exit(void)
   
10. {
    
11. /*出口函数内容*/
    
12. }
    
13. 
    
14. /*指定为驱动的入口和出口函数 */
    
15. module_init(xxx_init);
    
16. module_exit(xxx_exit);

复制代码

驱动编译完成以后扩展名为.ko， 有两种命令可以加载驱动模块:

• ：最简单的模块加载命令，用于加载指定的.ko模块，此命令不能解决模块的依赖关系
• ：该命令会分析模块的依赖关系，将所有的依赖模块都加载到内核中，因此更智能
  modprobe 命令默认会去目录中查找模块（自制的根文件系统没有这个目录，需要手动创建）
  
  

卸载驱动也有两种命令：

• ：例如使用来卸载 drv.ko这一个模块
• ：该命令除了卸载指定的驱动，还卸载其所依赖的其他模块，若这些依赖模块还在被其它模块使用，就不能使用 modprobe来卸载驱动模块！！！
  
  

3.2 注册与注销

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

字符设备的注册函数原型如下所示:

1. /* func: register_chrdev 注册字符设备
   
2. * major:主设备号
   
3. * name:设备名字，指向一串字符串
   
4. * fops:结构体 file_operations 类型指针，指向设备的操作函数集合变量
   
5. */
   
6. static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)

复制代码

字符设备的注销函数原型如下所示:

1. /* func: unregister_chrdev 注销字符设备
   
2. * majo:要注销的设备对应的主设备号
   
3. * name:要注销的设备对应的设备名
   
4. */
   
5. static inline void unregister_chrdev(unsigned int major, const char *name)

复制代码

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

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

复制代码

注：选择没有被使用的主设备号，可输入命令“cat /proc/devices”来查看当前已经被使用掉的设备号

3.3 实现设备的具体操作函数

file_operations 结构体就是设备的具体操作函数。

假设对chrtest这个设备有如下两个要求：

• 能够实现打开和关闭操作：需要实现 file_operations 中的open和release这两个函数
• 能够实现进行读写操作：需要实现 file_operations 中的read和write这两个函数
  
  

首先是 打开(open)、读取(read)、写入(write)、释放(release) 4个基本操作

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

复制代码

然后是 驱动的入口(init)和出口(exit) 函数:

1. /*文件操作结构体*/
   
2. static struct file_operations test_fops = {
   
3. .owner = THIS_MODULE,
   
4. .open = chrtest_open,
   
5. .read = chrtest_read,
   
6. .write = chrtest_write,
   
7. .release = chrtest_release,
   
8. };
   
9. 
   
10. /*驱动入口函数*/
    
11. static int __init xxx_init(void)
    
12. {
    
13. /*入口函数具体内容*/
    
14. int retvalue = 0;
    
15. 
    
16.    /*注册字符设备驱动*/
    
17. retvalue = register_chrdev(200, "chrtest", &test_fops);
    
18. if(retvalue < 0)
    
19.    {
    
20. /*字符设备注册失败*/
    
21. }
    
22. return 0;
    
23. }
    
24. 
    
25. /*驱动出口函数*/
    
26. static void __exit xxx_exit(void)
    
27. {
    
28. /*注销字符设备驱动*/
    
29. unregister_chrdev(200, "chrtest");
    
30. }
    
31. 
    
32. /*指定为驱动的入口和出口函数*/
    
33. module_init(xxx_init);
    
34. module_exit(xxx_exit);

复制代码

3.4 添加LICENSE和作者信息

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

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

复制代码

4 字符设备驱动开发实验

下面以正点原子提供的教程中的chrdevbase这个虚拟设备为例，完整的编写一个字符设备驱动模块。chrdevbase不是实际存在的一个设备，只是为了学习字符设备的开发的流程。

4.1 程序编写

需要分别编写驱动程序和应用程序。

注：为了区分两个程序的打印信息，在驱动程序的打印前都添加“[BSP]”标识，在应用程序的打印前都添加”[APP]“标识。

4.1.1 编写驱动程序

• 一些定义
  
  

1. #define CHRDEVBASE_MAJOR 200    /*主设备号*/
   
2. #define CHRDEVBASE_NAME  "chrdevbase"  /*设备名*/
   
3. 
   
4. static char readbuf[100];  /*读缓冲区*/
   
5. static char writebuf[100];  /*写缓冲区*/
   
6. static char kerneldata[] = {"kernel data!"}; /*内核驱动中的数据，用来测试应用程序读取该数据*/

复制代码

• 打开、关闭、读取、写入
  

1. /*
   
2. * @description  : 打开设备
   
3. * @param - inode  : 传递给驱动的inode
   
4. * @param - filp  : 设备文件，file结构体有个叫做private_data的成员变量
   
5. *        一般在open的时候将private_data指向设备结构体。
   
6. * @return    : 0 成功;其他 失败
   
7. */
   
8. static int chrdevbase_open(struct inode *inode, struct file *filp)
   
9. {
   
10. printk("[BSP] chrdevbase open!\n");
    
11. return 0;
    
12. }
    
13. 
    
14. /*
    
15. * @description  : 从设备读取数据
    
16. * @param - filp  : 要打开的设备文件(文件描述符)
    
17. * @param - buf  : 返回给用户空间的数据缓冲区
    
18. * @param - cnt  : 要读取的数据长度
    
19. * @param - offt  : 相对于文件首地址的偏移
    
20. * @return    : 读取的字节数，如果为负值，表示读取失败
    
21. */
    
22. static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    
23. {
    
24. int retvalue = 0;
    
25. 
    
26. /* 向用户空间发送数据 */
    
27. memcpy(readbuf, kerneldata, sizeof(kerneldata));
    
28. 
    
29. retvalue = copy_to_user(buf, readbuf, cnt);
    
30. if(retvalue == 0)
    
31.    {
    
32. printk("[BSP] kernel senddata ok!\n");
    
33. }
    
34.    else
    
35.    {
    
36. printk("[BSP] kernel senddata failed!\n");
    
37. }
    
38. 
    
39. printk("[BSP] chrdevbase read!\n");
    
40. return 0;
    
41. }
    
42. 
    
43. /*
    
44. * @description  : 向设备写数据
    
45. * @param - filp  : 设备文件，表示打开的文件描述符
    
46. * @param - buf  : 要写给设备写入的数据
    
47. * @param - cnt  : 要写入的数据长度
    
48. * @param - offt  : 相对于文件首地址的偏移
    
49. * @return    : 写入的字节数，如果为负值，表示写入失败
    
50. */
    
51. static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
    
52. {
    
53. int retvalue = 0;
    
54. 
    
55. /* 接收用户空间传递给内核的数据并且打印出来 */
    
56. retvalue = copy_from_user(writebuf, buf, cnt);
    
57. if(retvalue == 0)
    
58.    {
    
59. printk("[BSP] kernel recevdata:%s\n", writebuf);
    
60. }
    
61.    else
    
62.    {
    
63. printk("[BSP] kernel recevdata failed!\n");
    
64. }
    
65. 
    
66. printk("[BSP] chrdevbase write!\n");
    
67. return 0;
    
68. }
    
69. 
    
70. /*
    
71. * @description  : 关闭/释放设备
    
72. * @param - filp  : 要关闭的设备文件(文件描述符)
    
73. * @return    : 0 成功;其他 失败
    
74. */
    
75. static int chrdevbase_release(struct inode *inode, struct file *filp)
    
76. {
    
77. printk("[BSP] chrdevbase release！\n");
    
78. return 0;
    
79. }

复制代码

• 驱动加载与注销
  
  

1. /*
   
2. * 设备操作函数结构体
   
3. */
   
4. static struct file_operations chrdevbase_fops = {
   
5. .owner = THIS_MODULE,
   
6. .open = chrdevbase_open,
   
7. .read = chrdevbase_read,
   
8. .write = chrdevbase_write,
   
9. .release = chrdevbase_release,
   
10. };
    
11. 
    
12. /*
    
13. * @description : 驱动入口函数
    
14. * @param   : 无
    
15. * @return   : 0 成功;其他 失败
    
16. */
    
17. static int __init chrdevbase_init(void)
    
18. {
    
19. int retvalue = 0;
    
20. 
    
21. /* 注册字符设备驱动 */
    
22. retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops);
    
23. if(retvalue < 0)
    
24.    {
    
25. printk("[BSP] chrdevbase driver register failed\n");
    
26. }
    
27. printk("[BSP] chrdevbase init!\n");
    
28. return 0;
    
29. }
    
30. 
    
31. /*
    
32. * @description : 驱动出口函数
    
33. * @param   : 无
    
34. * @return   : 无
    
35. */
    
36. static void __exit chrdevbase_exit(void)
    
37. {
    
38. /* 注销字符设备驱动 */
    
39. unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
    
40. printk("[BSP] chrdevbase exit!\n");
    
41. }
    
42. 
    
43. /*将上面两个函数指定为驱动的入口和出口函数*/
    
44. module_init(chrdevbase_init);
    
45. module_exit(chrdevbase_exit);

复制代码

• 最后的LIENSE与作者
  

1. /*LICENSE和作者信息*/
   
2. MODULE_LICENSE("GPL");
   
3. MODULE_AUTHOR("zuozhongkai & xxpcb"); //本篇的程序代码在“正点原子”左大神提供的代码上进行修改

复制代码

4.1.2 编写应用程序

这里把程序截取为3段分析，首先看开头：

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. static char usrdata[] = {"usr data!"}; /*应用程序中的数据，用于测试通过驱动访问写入内核*/
   
10. 
    
11. int main(int argc, char *argv[])
    
12. {
    
13.         int fd, retvalue;
    
14.         char *filename;
    
15.         char readbuf[100], writebuf[100];
    
16. 
    
17.         if(argc != 3)
    
18.     {
    
19.                 printf("[APP] Error Usage!\n");
    
20.                 return -1;
    
21.         }
    
22. 
    
23.     //参数1是驱动的文件名，用来指定驱动的位置
    
24.         filename = argv[1];
    
25. 
    
26.         //【1】打开驱动文件
    
27.         fd  = open(filename, O_RDWR);
    
28.         if(fd < 0)
    
29.     {
    
30.                 printf("[APP] Can't open file %s\n", filename);
    
31.                 return -1;
    
32.         }
    
33.     printf("[APP] open file: '%s' success\n", filename);

复制代码

主要是一些头文件和main函数入口，调用main函数时需要传入2个参数（实际是3个参数，函数名本身是默认的第0个参数，不需要手动指定），具体作用为：

• 参数0：argv[0]，函数名本身，这里不作用途
• 参数1：argv[1]，filename，这里不作用途
• 参数2：argv[2]，自定义的操作参数，下面函数会讲到，1为从驱动文件中读取，2为向驱动文件中写入数据
• 再来看具体操作：
• 1. //【2】从驱动文件读取数据
     
  2.         if(atoi(argv[2]) == 1)//参数1表示【读取】内核中的数据
     
  3.     {
     
  4.                 retvalue = read(fd, readbuf, 50);
     
  5.                 if(retvalue < 0)
     
  6.         {
     
  7.                         printf("[APP] read file '%s' failed!\n", filename);
     
  8.                 }
     
  9.         else
     
  10.         {
      
  11.                         /* 读取成功，打印出读取成功的数据 */
      
  12.                         printf("[APP] read data:%s\n",readbuf);
      
  13.                 }
      
  14.         }
      
  15.     //【3】向设备驱动写数据
      
  16.         if(atoi(argv[2]) == 2)//参数2表示向内核中【写入】数据
      
  17.     {
      
  18.                 memcpy(writebuf, usrdata, sizeof(usrdata));
      
  19.                 retvalue = write(fd, writebuf, 50);
      
  20.                 if(retvalue < 0)
      
  21.         {
      
  22.                         printf("[APP] write file %s failed!\n", filename);
      
  23.                 }
      
  24.         else
      
  25.         {
      
  26.             printf("[APP] write data:'%s' to file ok\n", writebuf);
      
  27.         }
      
  28.         }

  复制代码
  最后是关闭设备：
  
  

1. //【4】关闭设备
   
2.         retvalue = close(fd);
   
3.         if(retvalue < 0)
   
4.     {
   
5.                 printf("[APP] Can't close file %s\n", filename);
   
6.                 return -1;
   
7.         }
   
8.         printf("[APP] close file ok\r\n");
   
9. 
   
10.         return 0;
    
11. }

复制代码

4.2 程序编译

4.2.1 编译驱动程序

编译驱动，即编译chrdevbase.c这个文件为.ko 模块，使用Makefile来编译，先创建Makefile：

1. KERNELDIR := /home/xxpcb/myTest/imx6ull/kernel/nxp_kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga
   
2. CURRENT_PATH := $(shell pwd)
   
3. obj-m := chrdevbase.o
   
4. 
   
5. build: kernel_modules
   
6. 
   
7. kernel_modules:
   
8.         $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
   
9. clean:
   
10.         $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

各行含义：

• KERNELDIR：开发板所使用的Linux内核源码目录
• CURRENT_PATH：当前路径，通过运行“pwd”命令获取
• obj-m：将 chrdevbase.c 这个文件编译为chrdevbase.ko模块
• 具体的编译命令：后面的modules表示编译模块，-C 表示切换工作目录到KERNERLDIR目录，M表示模块源码目录
  
  

输入“make”命令即可编译，编译后会出现许多编译文件

注：若直接make编译报如下错误，是因为kernel中没有指定编译器和架构，使用了默认的x86平台编译报错。

修改Kernel工程的顶层Makefile，直接定义ARCH和CROSS_COMPILE 这两个的变量值为 arm 和 arm-linux-gnueabihf-

(内核篇的介绍见：i.MX6ULL嵌入式Linux开发3-Kernel移植)

4.2.2 编译应用程序

编译应用程序不需要内核文件参与，只有一个文件就能编译，因此直接输入指令进行编译：

arm-linux-gnueabihf-gcc chrdevbaseAPP.c -o chrdevbaseAPP

编译会生chrdevbaseAPP，它是32位LSB格式的ARM版本可执行文件

4.3 测试

上一篇文章（i.MX6ULL嵌入式Linux开发6-系统烧写到eMMC与遇到的坑！）已经实现了系统移植的打包烧录工作，系统已经烧录的EMMC中了。这次我们就直接在这个基础上进行实验。

4.3.1 创建驱动模块目录

加载驱动模块，使用的modprobe命令，会从特定的目录下寻找文件。比如开发板使用的是4.1.15版的Linux内核 ，则是“/lib/modules/4.1.15”这个目录，这个目录一般是没有的，需要根据Linux内核的版本自己创建。

注意这是开发板的文件系统中的路径，可以通过串口连接进入开发板，通过linux指令创建该目录。

4.3.2 发送文件到开发板(TFTP传输)

此次测试首先需要将ubuntu中编译的文件传输到板子中运行，怎么传输呢？可以使用TFTP传输服务。

在之前的文章（i.MX6ULL嵌入式Linux开发2-uboot移植实践）中已经介绍了如何在ubuntu中搭建TFTP服务器。

搭建好TFTP服务后，开始传输文件到开发板具体的传输步骤为：

• 开发板连接网线，与ubuntu虚拟机处于同一局域网内
• 确保ubuntu已安装的TFTP服务，并设置了TFTP服务文件夹
• 将ubuntu中编译好的文件复制到ubuntu的TFTP服务文件夹中！！！
  mv chrdevbaseAPP ~/myTest/tftpboot/ mv chrdevbase.ko ~/myTest/tftpboot/
  注：编译完程序，在传输到板子之前，一定要记得把文件先复制到TFTP文件夹中，否则板子获取到的可能是TFTP文件夹中的旧文件。
• 开发板的串口中通过如下指令来将ubuntu中的文件传输到开发板中
  cd /lib/modules/4.1.15   /*确保在要下载文件的目录中，若已在，则忽略*/ tftp -g -r chrdevbaseAPP 192.168.5.101 /*获取chrdevbaseAPP文件*/ tftp -g -r chrdevbase.ko 192.168.5.101 /*获取chrdevbase.ko文件*/
  这里的代表get，即下载文件，代表remote file，即远程主机的文件名，然后是要下载的文件名，最后的远程主机ubuntu的IP地址。
  输入该指令后，可以看到文件传输进度，如下图：
  
  
  

4.3.3 开始测试

驱动文件chrdevbase.ko和应用文件chrdevbaseAPP传输到板子中的/lib/modules/4.1.15目录后，就可以测试了。

首先使用命令来加载驱动，然后使用查看当前的驱动（只有一个我们刚加载的字符驱动），再使用使用指令查看devices 信息，确认系统中是否已经列举了该设备，3条指令如下：

insmod chrdevbase.ko  lsmod cat /proc/devices

具体是输出信息：

可以看出，系统中存在chrdevbase设备，主设备号为程序中设定的200。

驱动加载后，还要在/dev目录下创建一个对应的设备节点文件（应用程序就是通过该节点文件实现对设备的操作）。

输入如下2条命令创建/dev/chrdevbase这个设备节点文件，并查看结果：

mknod /dev/chrdevbase c 200 0  ls /dev/chrdevbase -l

至此，字符设备驱动已经加载完成，可以测试我们的应用程序了，也就是读和写：

按照上面程序的设定，1是读，2是写：

./chrdevbaseAPP /dev/chrdevbase 1   ./chrdevbaseAPP /dev/chrdevbase 2

• 先来看“读测试”，注意要给chrdevbaseAPP可执行的权限，否则无法运行。
• 
  
  

图中下部是程序输出信息，但似乎只有BSP驱动程序的的输出，没有APP应用程序的输出，应该是内核打印printk与应用的打印printf冲突了，导致APP的打印被挤掉了。

• 再来看“写测试''，同样也是只有BSP的打印
  
  

4.3.4 打印冲突问题规避

对于打印冲突问题，我们可以先在每个printf前后加个sleep(1)的1秒延时，这样可以先避免打印冲突。

增加延时后再次测试，打印正常：

测试完，最后是rmmod命令卸载模块：

5 总结

本篇介绍了嵌入式Linux驱动开发中的基础驱动——字符驱动开发的基本模式，使用了一个虚拟的字符设备驱动进行测试，了解驱动程序与应用程序之间的调用关系。

阅读全文