（二）Linux设备驱动的模块化编程

本系列导航
（一）初识Linux驱动
（二）Linux设备驱动的模块化编程
（三）写一个完整的Linux驱动程序访问硬件并写应用程序进行测试
（四）Linux设备驱动之多个同类设备共用一套驱动
（五）Linux设备驱动模型介绍
（六）Linux驱动子系统-I2C子系统
（七）Linux驱动子系统-SPI子系统
（八）Linux驱动子系统-PWM子系统
（九）Linux驱动子系统-Light子系统
（十）Linux驱动子系统-背光子系统
（十一）Linux驱动-触摸屏驱动

我们刚开始学习驱动，都是以模块的形式来编写驱动程序。

1. 什么是模块？

官方定义： 可在运行时添加到内核中的代码被称为“模块”。
释义： Linux设备驱动只有在Linux内核（可百度搜索释义）中才能工作，内核是驱动运行所依赖的环境（Linux内核中有驱动运行所需要的库等），所以驱动编译、运行有两种方式：一个是直接将驱动代码放入内核中，作为内核的一部分进行编译，然后Linux内核启动的时候，驱动也即运行；第二个是将驱动单独编译成一个模块，当Linux内核运行起来后，需要某个驱动的时候，再将对应的驱动模块添加到当前的Linux内核中，当不需要某个驱动的时候，可以从内核中将对应的驱动模块卸载掉。

2. 模块化编程有什么好处？

1）可以减小内核镜像的体积，因为模块本身不被编译到内核镜像里面。
2）可以在内核中添加或删除功能（模块化的形式）而不用重新编译内核（每一次从新编译内核很耗时）：
非模块化驱动编程过程： 编写驱动->编译内核（驱动放入内核代码中一起编译）->生成镜像烧写到硬件->如果驱动出现问题则从新回到第一步修改然后开始直到成功。
模块化驱动编程过程： 编写驱动->单独将驱动编译成一个模块->将模块下载到正在运行的硬件上并插入到内核中->如果有问题则回到步骤一从新开始，整个过程无需重新编译和烧写内核。

3. 写驱动模块和写普通的Linux应用程序有什么区别？

许多同学在刚开始写Linux驱动程序的时候不知道该怎么写，上来就是int main() {}，下面我就分析下我们要写的驱动模块和Linux应用程序的区别：

4. 如何写驱动模块？

模块的三要素：
1）版本声明

MODULE_LICENSE("GPL");

GPL：GNU通用公共许可证，如果不加版本声明，编译的时候会报错，关于这个声明的具体作用，可自行上网百度。
2）模块的加载函数也即模块的入口函数 – 相当于应用程序的main函数
模块的加载函数有两种写法，第一种写法，又叫缺省写法：

int init_module(void) {}

当加载这个模块的时候，会调用到这个模块的init_module函数执行。
缺点：当大家都采用这种写法时，内核中将会有太多的init_module, 使阅读时难以区分。
第二种写法，称为自定义写法，顾名思义，就是入口函数名字可以自己定义，如 ：

static int hello_init(void) {}

但是加载的时候，系统如何知道你这个自定义的函数就是入口函数呢？所以需要声明这个自定义函数就是入库函数，如下：

module_init(hello_init);

我们大多也都采用这种写法。
3）模块的卸载函数也即模块的出口函数
这个函数通常要做的是释放入口函数里面申请的资源。同上，也有两种写法，第一种缺省写法：

void cleanup_module(void) {}

第二种自定义函数写法，也就是我们常用的写法：

static void hello_exit(void) {}；
module_exit(hello_exit);

用sourceinsight或者vim编辑一个最简单的模块hello.c：

    #include <linux/kernel.h>
    #include <linux/module.h>
    
    static int hello_init(void)
    {
        printk("%s : %d\n", __func__, __LINE__);
    
        return 0;
    }
    
    static void hello_exit(void)
    {
        printk("%s : %d\n", __func__, __LINE__);
    }
    
    
    MODULE_LICENSE("GPL");
    module_init(hello_init);
    module_exit(hello_exit);

其中，包含的头文件是内核源码库里面的，这个在前面讲过。在模块的加载函数和卸载函数中我们加入了打印，通过打印我们能知道代码的执行过程。但是，注意这里用的打印是内核里面的printk，而不是用户空间的printf，printk时内核源码库提供的，这段代码最终也是运行在内核空间的。
如何编译这个模块：
因为有些同学想了解编译模块的Makefile具体是如何实现的，所以在这里我就给大家详解一下，如果不想了解，直接cp我的Makefile使用即可。
参考内核源码文档-> Documentation/kbuild/modules.txt，其中第二章，How to Build External Modules是我们要仔细阅读的：

To build external modules, you must have a prebuilt kernel available that contains the configuration and header files used in the build. Also, the kernel must have been built with modules enabled. If you are using a distribution kernel, there will be a package for the kernel you are running provided by your distribution.

大概意思就是说如果你想编译一个外部模块，那么你必须要有一个提前编译过的并且有效的内核，这个内核里面包括编译模块所需要的头文件等，并且这个内核中的module属性选项被enable（Make menuconfig可以配置的）。或者如果你用的是一个工作的内核，比如你在一个ubuntu系统（Linux内核+图形库等的组合）上面编译模块，那么这个系统会提供一些package，我们刚开始学习，不涉及具体的硬件，就先在一个Ubuntu的内核中编译运行我们的模块。
Makefile 语法：

Command Syntax
The command to build an external module is:
       $ make -C <path_to_kernel_src> M=$PWD            
       //-C <path_to_kernel_src>因为编译需要内核库，所以这个选择指定内核源码路径，编译的时候就知道去哪找那些依赖的库。
       //-M 指定你当前要编译的源码所在的路径
    
build against the running kernel use:
       $ make -C /lib/modules/`uname -r`/build M=$PWD  
       //这个就是我们说的，当我们要依靠一个正在运行的Ubuntu的内核进行编译和运行，那么这个kernel路径该如何选择呢？这就是ubuntu中内核库的绝对路径
    
Creating a Kbuild File for an External Module
       obj-m := <module_name>.o                        
       //obj-m指定你最终要生成的产物是module模块，<module_name>.o表示你要生成<module_name>这个模块需要依赖<module_name>.o, 中间的编译环节有内核的kbuild系统来完成的。

所以最终的Makefile写法如下（#为注释）：

#定义一些变量，增加代码的阅读性和扩展性
#`uname -r`这种写法就是执行uname -r这个shell命令，从而构造这个绝对路径，因为每个人的计算机的绝对路径都不一样，这样提高通用性，对于我的主机，这个路径相当于/lib/modules/4.4.0-31-generic/build
KERNEL_PATH := /lib/modules/`uname -r`/build
PWD := $(shell pwd)

#这个名字表示:要生产的模块的名字，最终会生成hello.ko
MODULE_NAME := hello
   
#表示要生成hello.ko要依靠中间文件hello.o  kbuild系统会将源码hello.c编译成hello.o
obj-m := $(MODULE_NAME).o
   
#当执行make命令默认会寻找第一个目标，即all
all:
	$(MAKE) -C $(KERNEL_PATH) M=$(PWD)
   
#执行make clean要执行的操作，将编译生成的中间文件删掉
clean:
	rm -rf .*.cmd *.o *.mod.c *.order *.symvers  *.ko

保存为Makefile文件，最后将Makefile文件和hello.c放入同一个文件夹，然后执行make进行编译会生成最终的模块hello.ko。

5. 如何验证这个模块？ – 模块相关的命令

插入或者加载一个模块

sudo insmod hello.ko

在包含有hello.ko的目录执行这个命令，就会将这个hello模块插入到你当前运行的内核（ubuntu系统或者开发板）中，并且执行你的入口函数hello_init，这时有些同学会发现，执行完插入模块的命令后，没有执行printk打印，其实是执行了，只不过是打印到了缓存里面，我们需要用下面的命令查看打印信息：
查看printk打印信息：
dmesg //查看系统从开机到当前时刻由printk输出到缓存的所有log
sudo dmesg -c //查看显示log信息，并将整个缓存清除掉
sudo dmesg -C //不显示log信息，将整个缓存清除掉
看到log信息后，如何确认模块是否真正插入成功？
查询内核中插入的所有模块：
lsmod //如何显示的模块太多，我们可以通过lsmod | grep hello 这个命令来查看是否有hello这个模块。

当我不需要这个模块时，如何从内核中将这个模块卸载掉？
卸载模块：
sudo rmmod hello //注意，模块名字时hello，那么执行这个卸载命令的时候，就会执行我们的卸载函数hello_exit，通过dmesg可以看到对应的log，通过lsmod可以发现没有hello这个模块了。

有同学看到打印信息后会有个疑问，为什么卸载模块的时候，竟然有hello_init的log，这个地方我解释下，前面说过，printk是把打印信息输出到缓存中，也就是说，每次执行dmesg的时候，是将整个缓存的log都打印出来了，所以hello_init这个log是执行insmod加载模块的时候打印的。
查看模块信息：
modinfo hello.ko

最后再说一个细节，如果把再我电脑上编译的hello.ko拿到你的Ubuntu下能运行吗？这个是肯定不行的，通过modinfo命令，我们可以看到这个模块所依赖的内核版本信息，一个模块只能运行在编译这个模块对应的那个内核环境中。

6. 模块传递参数

顾名思义，就是在系统启动或者加载模块的时候，为参数指定相应的值，在驱动程序里，参数的用法如同全局变量，这样可以使模块具有更大的灵活性以及扩展性。
例如下面的例子：
给xxx.ko对应的驱动程序里面的path传递"/lib/module/firmware/xxx.bin"这个字符串

insmod xxx.ko   path="/lib/module/firmware/xxx.bin"

驱动程序需按照以下步骤实现：
（1）定义接收参数的变量，并初始化

static int intarg = 100；

（2）module_param(参数名,参数类型,参数读/写权限)来声明intarg这个参数可以用来接收外部传入

module_param(intarg, int ,0600)；

（3）可选：

MODULE_PARM_DESC (intarg, "A integer");

这样声明后，通过modinfo可查看相应的信息
（4）执行insmod命令时传递参数

sudo insmod hello.ko  intarg=200