驱动框架入门——以LED为例[【转】

本文转载自;http://blog.csdn.net/oqqHuTu12345678/article/details/72783903

以下内容源于朱有鹏《物联网大讲堂》课程的学习，如有侵权，请告知删除。

 

一、什么是驱动框架？

 

1、驱动是谁写的？

（1）驱动开发工程师；

（2）内核维护者；

2、驱动编程协作要求

（1）接口标准化；

（2）内核开发者应该尽量降低驱动开发者难度；

3、到底什么是驱动框架？

（1）驱动框架

 

• 内核中驱动部分维护者，针对每个种类（比如LED、LCD、蜂鸣器等等）的设备，都设计有一套成熟的、标准的、典型的驱动实现；
• 它是把不同厂家的同类硬件驱动中相同的部分抽出来自己实现好，再把不同部分留出接口给具体的驱动开发工程师来实现。
• 降低了难度，也标准化。

（2）内核维护者在内核中设计了一些（统一管控系统资源的）体系

• 这些体系让内核能够（对资源在各个驱动之间的使用）统一协调和分配，保证整个内核的稳定健康运行。
• 譬如系统中所有的GPIO就属于系统资源，每个驱动模块如果要使用某个GPIO就要先调用特殊的接口先申请，申请到后使用，使用完后要释放。
• 又譬如中断号也是一种资源，驱动在使用前也必须去申请。
• 这体系也是驱动框架的组成部分。

（3）一些特定的接口函数、一些特定的数据结构，这些是驱动框架的直接表现。

 

二、内核驱动框架中LED的基本情况

 

1、相关文件

（1）drivers/leds目录

 

 

• 这个目录就是驱动框架规定的LED这种硬件的驱动应该待的地方。

 

（2）drivers/leds目录下有led-class.c和led-core.c

 

• 这两个文件加起来属于LED驱动框架的第一部分，这两个文件是内核开发者提供的，他们描述的是内核中所有厂家的不同LED硬件的相同部分的逻辑。

 

（3）此目录下有leds-xxxx.c

 

• 这个文件是LED驱动框架的第2部分，是由不同厂商的驱动工程师编写添加的；
• 厂商驱动工程师结合自己公司的硬件的不同情况来对LED进行操作，使用第一部分提供的接口来和驱动框架进行交互，最终实现驱动的功能。

 

2、九鼎移植的内核中led驱动

 

• 九鼎实际未使用内核推荐的led驱动框架；
• drivers/char/led/x210-led.c；

 

3、案例分析驱动框架的使用

（1）以leds-s3c24xx.c为例。

 

• leds-s3c24xx.c中通过调用led_classdev_register来完成LED驱动的注册，而led_classdev_register是在drivers/leds/led-class.c中定义的。
• 所以其实SoC厂商的驱动工程师是调用内核开发者在驱动框架中提供的接口来实现自己的驱动的。

 

（2）驱动框架的关键点

 

• 内核开发者提供了什么？
• 驱动开发者要完成什么？

 

4、典型的驱动开发行业现状

（1）内核开发者对驱动框架进行开发和维护、升级，对应led-class.c和led-core.c；

（2）SoC厂商的驱动工程师对设备驱动源码进行编写、调试，提供参考版本，对应leds-s3c24xx.c；（全志、三星、华为等芯片厂商）

（3）做产品的厂商的驱动工程师以SoC厂商提供的驱动源码为基础，来做移植和调试；

 

三、.初步分析led驱动框架源码

1、涉及到的文件

 

• led-core.c；（一些宏与头文件包含而已）
• led-class.c；

 

（1）分析发现，LED驱动框架中，内核开发者实现的部分主要是led-class.c；

（2）led-class.c其实就是一个内核模块（明显的特征是，有安装和卸载函数）

 

• 那么对led-class.c的分析应该从下往上，遵从对模块的基本分析方法。

 

（3）为什么LED驱动框架中，内核开发者实现的部分，要实现成一个模块？

 

• 因为内核开发者希望这个驱动框架是可以被装载/卸载的。
• 这样当内核使用者不需要这个驱动框架时可以完全去掉，需要时可以随时加上。

（4）led_init在/sys/class目录下创建“leds”这个类名；led_exit销毁“leds”这个类名。

 

2、subsys_initcall

 

（1）subsys_initcall是一个宏，定义在Linux/init.h中。

 

• 这个宏的功能是：将其声明的函数放到一个特定的段：.initcall4.init。

 

（2）分析module_init宏，可以看出它将函数放到了.initcall6.init段中。

• module_init
•       __initcall
•             device_initcall
•                  __define_initcall("6",fn,6)

 

（3）内核在启动过程中，需要按照顺序执行很多事情。内核如何实现按照先后顺序去做很多初始化操作？

 

• 内核的解决方案就是将内核启动时要调用的所有函数归类，然后每个类按照一定的次序去调用执行。
• 这些分类名就叫.initcalln.init，n的值从1到8。
• 内核开发者在编写内核代码时只要将函数设置合适的级别，链接的时候，这些函数就会被放入特定的段，内核启动时再按照（内核链接脚本中指定的）段顺序去依次执行各个段即可。内核链接脚本（编译之后才有）在arch/arm/kernel/vmlinux.lds中。

 

（4）经过分析可以看出，subsys_initcall和module_init的作用是一样的，只不过前者所声明的函数要比后者在内核启动时的执行顺序更早。

 

3、led_class_attrs

 

（1）什么是attribute？

 

• 对应将来/sys/class/leds/目录里的内容，一般是文件和文件夹。
• 这些文件其实就是sysfs开放给应用层的一些操作接口（非常类似于/dev/目录下的那些设备文件，对这些设备文件的操作API，对应file_operations里面的函数）。

 

（2）attribute有什么用？

 

• 让应用程序可以通过/sys/class/leds/目录下面的属性文件来操作驱动进而操作硬件设备。

 

（3）attribute其实是另一条驱动实现的路线（不再有c_dev相关的函数操作），有区别于之前讲的file_operations那条线。

 

 

4、led_classdev_register设备注册函数

 

 

• led_classdev_register函数创建一个属于leds这个类的一个设备，其实就是去注册一个设备。
• 这个函数是led驱动框架中，内核开发者提供给SoC厂家驱动开发者的一个注册驱动的接口。
• 当使用led驱动框架去编写驱动的时候，这个led_classdev_register函数的作用类似于之前使用file_operations方式去注册字符设备驱动时的register_chrdev函数。
• 之前使用file_operations方式时，在sys/class目录下创建一个类，然后再创建属于这个类的一个设备。

5、led_classdev结构体

 

• 在leds.h文件中

 

 

四、在内核中添加或去除某个驱动

1、去除九鼎移植的LED驱动

（1）九鼎移植的驱动（在应用层的接口）在/sys/devices/platform/x210-led/目录下，有led1、led2、led3、led4四个设备文件，各自管理一个led。

 

• echo 1 > led1可以点亮其中的led1；

 

（2）要去掉九鼎自己移植的led驱动，要在make menucofig中去掉选择项，然后重新make得到zImage，然后重启时启动这个新的zImage即可。

 

• 新的内核启动后，如果/sys/devices/platform/目录下已经没有了x210-led这个目录，就说明我们去掉这个驱动成功了。

 

（3）为什么make menuconfig就能去掉这个驱动？

 

• 理解make menuconfig的功能。

 

2、添加led驱动框架支持

当前内核中没有LED驱动框架，要去添加它。（/sys/class目录下没有此类，因此要去添加此类）

 

• 主要是menuconfig的操作。

 

3、sysfs中的内容分析

4、后续展望：完成leds-x210.c

五、基于驱动框架写led驱动1

1、分析

（1）参考哪里？  drivers/leds/leds-s3c24xx.c文件

（2）关键点？led_classdev_register函数

2、动手写led驱动模块

代码如下

注意设备注册函数、设备注销函数

 

[cpp]  view plain  copy

 

1. #include <linux/module.h>     // module_init  module_exit  
2. #include <linux/init.h>           // __init   __exit  
3. #include <linux/fs.h>  
4. #include <linux/leds.h>  
5. #include <mach/regs-gpio.h>  
6. #include <mach/gpio-bank.h>  
7. #include <linux/io.h>  
8. #include <linux/ioport.h>  
9.   
10.   
11.   
12. #define GPJ0CON     S5PV210_GPJ0CON  
13. #define GPJ0DAT     S5PV210_GPJ0DAT  
14.   
15. static struct led_classdev mydev;           // 定义结构体变量  
16.   
17.   
18. // 这个函数就是要去完成具体的硬件读写任务的  
19. static void s5pv210_led_set(struct led_classdev *led_cdev,enum led_brightness value)  
20. {  
21.     printk(KERN_INFO "s5pv210_led_set\n");  
22.       
23.     // 在这里根据用户设置的值来操作硬件  
24.     // 用户设置的值就是value  
25.     if (value == LED_OFF)  
26.     {  
27.         // 用户给了个0，希望LED灭  
28.         writel(0x11111111, GPJ0CON);  
29.         writel(((1<<3) | (1<<4) | (1<<5)), GPJ0DAT);  
30.     }  
31.     else  
32.     {  
33.         // 用户给的是非0，希望LED亮  
34.         writel(0x11111111, GPJ0CON);  
35.         writel(((0<<3) | (0<<4) | (0<<5)), GPJ0DAT);  
36.     }  
37. }  
38.   
39.   
40. static int __init s5pv210_led_init(void)  
41. {  
42.     // 用户insmod安装驱动模块时会调用该函数  
43.     // 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备  
44.     int ret = -1;  
45.       
46.     mydev.name = "myled";//设备的名字  
47.     mydev.brightness = 255;   
48.     mydev.brightness_set = s5pv210_led_set;  
49.       
50.     ret = led_classdev_register(NULL, &mydev);  
51.     if (ret < 0) {  
52.         printk(KERN_ERR "led_classdev_register failed\n");  
53.         return ret;  
54.     }  
55.       
56.     return 0;  
57. }  
58.   
59. static void __exit s5pv210_led_exit(void)  
60. {  
61.     led_classdev_unregister(&mydev);  
62. }  
63.   
64.   
65. module_init(s5pv210_led_init);  
66. module_exit(s5pv210_led_exit);  
67.   
68. // MODULE_xxx这种宏作用是用来添加模块描述信息  
69. MODULE_LICENSE("GPL");                          // 描述模块的许可证  
70. MODULE_AUTHOR("aston <1264671872@qq.com>");       // 描述模块的作者  
71. MODULE_DESCRIPTION("s5pv210 led driver");       // 描述模块的介绍信息  
72. MODULE_ALIAS("s5pv210_led");                    // 描述模块的别名信息  

 

 

六、基于驱动框架写led驱动2

1、代码实践

（1）调试

（2）分析

 

 

 

• 我们写的驱动确实工作了，被加载了，/sys/class/leds/目录下确实多出来了一个表示设备的文件夹。
• 文件夹里面有相应的操控led硬件的2个属性brightness和max_brightness。
• led-class.c中brightness方法有一个show方法和store方法，这两个方法对应用户在/sys/class/leds/myled/brightness目录下直接去读写这个文件时实际执行的代码。
• 当我们show brightness时，实际就会执行led_brightness_show函数。
• 当我们echo 1 > brightness时，实际就会执行led_brightness_store函数。

（3）show方法实际要做的就是读取LED硬件信息，然后把硬件信息返回

• 因此show方法和store方法会去操控硬件；
• 但是led-class.c文件又属于驱动框架中的文件，它本身无法直接读取具体硬件，因此在show和store方法中使用函数指针的方式调用了struct led_classdev结构体中的相应的读取/写入硬件信息的方法。

（4）struct led_classdev结构体中的实际用来读写硬件信息的函数，就是我们自己写的驱动文件leds-s5pv210.c中要提供的。

 

2、添加硬件操作

 

七、基于驱动框架写led驱动3

1、在驱动中将4个LED分开

（1）好处

 

• 驱动层实现对各个LED设备的独立访问，并向应用层展示出4个操作接口led1、led2、led3、led4，这样应用层可以完全按照自己的需要对LED进行控制。
• 驱动的设计理念：不要对最终需求功能进行假定（不能假定用户进行什么操作，比如是几个led一起操作还是一个操作而已？），而应该只是直接的对硬件的操作。
• 有一个概念就是：机制和策略的问题。在硬件操作上驱动只应该提供机制（具体实现）而不是策略（方法、主意、解决方案）。策略由应用程序来做。

 

（2）如何实现

 

[cpp]  view plain  copy

 

1. #include <linux/module.h>     // module_init  module_exit  
2. #include <linux/init.h>           // __init   __exit  
3. #include <linux/fs.h>  
4. #include <linux/leds.h>  
5. #include <mach/regs-gpio.h>  
6. #include <mach/gpio-bank.h>  
7. #include <linux/io.h>  
8. #include <linux/ioport.h>  
9.   
10.   
11.   
12. #define GPJ0CON     S5PV210_GPJ0CON  
13. #define GPJ0DAT     S5PV210_GPJ0DAT  
14.   
15. static struct led_classdev mydev1;          // 定义结构体变量  
16. static struct led_classdev mydev2;          // 定义结构体变量  
17. static struct led_classdev mydev3;          // 定义结构体变量  
18.   
19. // 这个函数就是要去完成具体的硬件读写任务的  
20. static void s5pv210_led1_set(struct led_classdev *led_cdev,  
21.                 enum led_brightness value)  
22. {  
23.     printk(KERN_INFO "s5pv210_led1_set\n");  
24.       
25.     writel(0x11111111, GPJ0CON);  
26.       
27.     // 在这里根据用户设置的值来操作硬件  
28.     // 用户设置的值就是value  
29.     if (value == LED_OFF)  
30.     {  
31.         // 用户给了个0，希望LED灭  
32.         //writel(0x11111111, GPJ0CON);  
33.         // 读改写三部曲  
34.         writel((readl(GPJ0DAT) | (1<<3)), GPJ0DAT);  
35.     }  
36.     else  
37.     {  
38.         // 用户给的是非0，希望LED亮  
39.         //writel(0x11111111, GPJ0CON);  
40.         writel((readl(GPJ0DAT) & ~(1<<3)), GPJ0DAT);  
41.     }  
42. }  
43.   
44. static void s5pv210_led2_set(struct led_classdev *led_cdev,  
45.                 enum led_brightness value)  
46. {  
47.     printk(KERN_INFO "s5pv2102_led_set\n");  
48.       
49.     writel(0x11111111, GPJ0CON);  
50.       
51.     // 在这里根据用户设置的值来操作硬件  
52.     // 用户设置的值就是value  
53.     if (value == LED_OFF)  
54.     {  
55.         // 用户给了个0，希望LED灭  
56.         //writel(0x11111111, GPJ0CON);  
57.         // 读改写三部曲  
58.         writel((readl(GPJ0DAT) | (1<<4)), GPJ0DAT);  
59.     }  
60.     else  
61.     {  
62.         // 用户给的是非0，希望LED亮  
63.         //writel(0x11111111, GPJ0CON);  
64.         writel((readl(GPJ0DAT) & ~(1<<4)), GPJ0DAT);  
65.     }  
66. }  
67.   
68. static void s5pv210_led3_set(struct led_classdev *led_cdev,  
69.                 enum led_brightness value)  
70. {  
71.     printk(KERN_INFO "s5pv210_led3_set\n");  
72.       
73.     writel(0x11111111, GPJ0CON);  
74.       
75.     // 在这里根据用户设置的值来操作硬件  
76.     // 用户设置的值就是value  
77.     if (value == LED_OFF)  
78.     {  
79.         // 用户给了个0，希望LED灭  
80.         //writel(0x11111111, GPJ0CON);  
81.         // 读改写三部曲  
82.         writel((readl(GPJ0DAT) | (1<<5)), GPJ0DAT);  
83.     }  
84.     else  
85.     {  
86.         // 用户给的是非0，希望LED亮  
87.         //writel(0x11111111, GPJ0CON);  
88.         writel((readl(GPJ0DAT) & ~(1<<5)), GPJ0DAT);  
89.     }  
90. }  
91.   
92.   
93. static int __init s5pv210_led_init(void)  
94. {  
95.     // 用户insmod安装驱动模块时会调用该函数  
96.     // 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备  
97.     int ret = -1;  
98.       
99.     // led1  
100.     mydev1.name = "led1";  
101.     mydev1.brightness = 255;      
102.     mydev1.brightness_set = s5pv210_led1_set;  
103.       
104.     ret = led_classdev_register(NULL, &mydev1);  
105.     if (ret < 0) {  
106.         printk(KERN_ERR "led_classdev_register failed\n");  
107.         return ret;  
108.     }  
109.       
110.     // led2  
111.     mydev2.name = "led2";  
112.     mydev2.brightness = 255;      
113.     mydev2.brightness_set = s5pv210_led2_set;  
114.       
115.     ret = led_classdev_register(NULL, &mydev2);  
116.     if (ret < 0) {  
117.         printk(KERN_ERR "led_classdev_register failed\n");  
118.         return ret;  
119.     }  
120.       
121.     // led3  
122.     mydev3.name = "led3";  
123.     mydev3.brightness = 255;      
124.     mydev3.brightness_set = s5pv210_led3_set;  
125.       
126.     ret = led_classdev_register(NULL, &mydev3);  
127.     if (ret < 0) {  
128.         printk(KERN_ERR "led_classdev_register failed\n");  
129.         return ret;  
130.     }  
131.       
132.     return 0;  
133. }  
134.   
135. static void __exit s5pv210_led_exit(void)  
136. {  
137.     led_classdev_unregister(&mydev1);  
138.     led_classdev_unregister(&mydev2);  
139.     led_classdev_unregister(&mydev3);  
140. }  
141.   
142.   
143. module_init(s5pv210_led_init);  
144. module_exit(s5pv210_led_exit);  
145.   
146. // MODULE_xxx这种宏作用是用来添加模块描述信息  
147. MODULE_LICENSE("GPL");                          // 描述模块的许可证  
148. MODULE_AUTHOR("aston <1264671872@qq.com>");       // 描述模块的作者  
149. MODULE_DESCRIPTION("s5pv210 led driver");       // 描述模块的介绍信息  
150. MODULE_ALIAS("s5pv210_led");                    // 描述模块的别名信息  

 

2、和leds-s3c24xx.c的不同

3、gpiolib引入

（1）一个事实：很多硬件都要用到GPIO，GPIO会复用；

（2）如果同一个GPIO被2个驱动同时控制了，就会出现bug；

（3）内核提供gpiolib来统一管理系统中所有GPIO；

 

• 某个驱动需要用到GPIO时，需要申请，被许可后才可以使用，使用完后释放，其他驱动才能使用该GPIO。
• 建议性的，希望都用gpiolib。

 

（4）gpiolib体系，属于驱动框架的一部分。

 

八、linux内核的gpiolib学习1

1、gpiolib学习重点（主线）

（1）主线一：gpiolib的建立过程；

 

• 体系是如何建立的？

 

（2）主线二：gpiolib的使用方法：申请、使用、释放

（3）主线三：gpiolib的架构：涉及哪些目录的哪些文件

2、gpiolib的学习方法

（1）以一条主线进去，坚持主线；

（2）中途遇到杂碎知识，彻底搞定之，然后继续主线；

（3）随时做笔记以加深理解和记忆；

（4）学习途中注意架构思想，提升自己大脑的空间复杂度；

3、主线1：gpiolib的建立

找到目标函数

 

• smdkc110_map_io这个函数在静态映射中曾经经过。
•       s5pv210_gpiolib_init函数，是gpiolib初始化的函数。

 

 

九、linux内核的gpiolib学习2

 

1、struct s3c_gpio_chip

（1）在文件gpio-core.h文件中

 

• 此结构体是一个GPIO端口的抽象，这个结构体的一个变量就可以完全的描述一个IO端口。

 

（2）端口和IO口是两个概念

 

• S5PV210有很多个IO口（160个左右），这些IO口首先被分成N个端口（port group），然后每个端口中又包含了M个IO口。
• 譬如GPA0是一个端口，里面包含了8个IO口，我们一般记作：GPA0_0（或GPA0.0）、GPA0_1……

 

（3）内核中为每个GPIO分配了一个编号，编号是一个数字（譬如一共有160个IO时编号就可以从1到160连续分布），编号可以让程序很方便的去识别每一个GPIO。

2、s5pv210_gpio_4bit[ ]数组

 

• 一个结构体数组，数组中包含了很多个struct s3c_gpio_chip类型的变量
• 填充了结构体中chip这个元素，这个元素是struct gpio_chip类型的，因此进一步细化为填充struct gpio_chip类型中的元素。其他元素好像没有太深入。

 

 

十、linux内核的gpiolib学习3

 

1、S5PV210_GPA0宏

这个宏的返回值是GPA0端口的某一个IO口的基础编号值，传参是这个IO口在GPA0端口中的局部编号。

2、samsung_gpiolib_add_4bit_chips函数

 

• 进行gpiolib的注册；
• 接收的参数是当前文件中定义好的结构体数组s5pv210_gpio_4bit（2个参数分别是数组名和数组元素个数）；
• 此结构体数组，包含了当前系统中所有的IO端口的信息。
• 包含：端口的名字、端口中所有GPIO的编号、端口操作寄存器组的虚拟地址基地址、端口中IO口的数量、端口上下拉等模式的配置函数、端口中的IO口换算其对应的中断号的函数（此时不用再查看原理图）。

 

 

 

十一、linux内核的gpiolib学习4

 

1、几个问题

（1）哪个目录的哪个文件？

（2）函数名中为什么有个4bit？

 

• 三星的CPU中2440的CON寄存器是2bit对应一个IO口，而6410和210以及之后的系列中CON寄存器是4bit对应1个IO口。
• 所以gpiolib在操作2440和210的CON寄存器时是不同的。

 

 

2、函数调用关系

 

 

• samsung_gpiolib_add_4bit_chips
•        samsung_gpiolib_add_4bit
•        s3c_gpiolib_add
• samsung_gpiolib_add_4bit内部没有做gpiolib的注册工作，而是在做填充，填充的是每一个GPIO被设置成输入模式/输出模式的操作方法。

 

十二、linux内核的gpiolib学习5_6

 

1、s3c_gpiolib_add

 

（1）首先检测并完善chip的direction_input/direction_ouput/set/get这4个方法；

（2）然后调用gpiochip_add方法进行真正的注册操作。

 

• 这个注册就是将（我们的封装了一个GPIO端口的所有信息的）chip结构体变量，挂接到内核（gpiolib模块定义的一个）gpio_desc数组中的某一个格子中。

 

2、从驱动框架角度再来分析一下gpiolib

（1）截至目前（gpiochip_add方法）已经搞清楚了gpiolib的建立工程，即主线一。

 

• 但是这只是整个gpiolib建立的一部分，是厂商驱动工程师负责的那一部分；
• 还有另一部分是内核开发者提供的驱动框架的那一部分，即第2条主线。（第一条起始见八3）

 

（2）drivers/gpio/gpiolib.c这个文件中所有的函数构成了第2部分，也就是内核开发者写的gpiolib框架部分。

 

• gpiochip_add：是框架开出来的接口，给厂商驱动工程师用（针对某个开发板GPIO的情况，对内核进行一定的修改，注册），用于向内核注册gpiolib。（标记有多少组端口，属性细节等，让内核知道具体的GPIO信息。）
• gpio_request：是框架开出来的接口，给使用gpiolib来编写自己的驱动的驱动工程师用的，驱动中要想使用某一个gpio，就必须先调用gpio_request接口来向内核的gpiolib部分申请，得到允许后才可以去使用这个gpio。
• gpio_free：对应gpio_request，用来释放申请后用完了的gpio。
• gpio_request_one/gpio_request_array：这两个是gpio_request的变种。
• gpiochip_is_requested：接口用来判断某一个gpio是否已经被申请了
• gpio_direction_input/gpio_direction_output：接口用来设置GPIO为输入/输出模式，注意该函数内部实际并没有对硬件进行操作，只是通过chip结构体变量的函数指针，调用了（将来SoC厂商的驱动工程师写的）真正地操作硬件、实现gpio设置成输出模式的那个函数。
• 以上的接口属于一类，是给写其他驱动并且用到了gpiolib的人使用的，剩下的函数是gpiolib内部自己的一些功能实现的代码。

 

 

十三、linux内核的gpiolib学习7

 

 

1、gpiolib的attribute部分

（1）CONFIG_GPIO_SYSFS

 

• 在内核中很多实现方式，都是通过宏来配置的；
• 在.config文件有，则必然在menuconfig中有。

 

（2）GPIO的attribute演示

 

• 一般能cat，不能写。

 

 

 

 

2、能够cat的相关代码分析

（1）gpiolib_sysfs_init：在/sys/class里定义了gpio这个类

（2）gpiochip_export

（3）sysfs_create_group用来创建许多attribute

 

十四、使用gpiolib完成led驱动

1、流程分析

（1）第1步：使用gpio_request申请要使用的一个GPIO；

（2）第2步：gpio_direction_input/gpio_direction_output 设置输入/输出模式；

（3）第3步：设置输出值gpio_set_value  获取IO口值gpio_get_value。

 

2、代码实践

（1）在led1上编写代码测试通过；

（2）扩展支持led2和led3、led4，可以分开注册，也可以使用gpio_request_array去一次注册；

（3）学习linux中查看gpio使用情况的方法

 

 

 

• 内核中提供了虚拟文件系统debugfs，里面有一个gpio文件，提供了gpio的使用信息（诸如谁被使用了，谁没有被使用）。
• 使用方法：mount -t debugfs debugfs /tmp，然后cat /tmp/gpio即可得到gpio的所有信息，使用完后umount /tmp卸载掉debugfs

 

（4）代码（驱动申请LED1资源而已）

 

[cpp]  view plain  copy

 

1. #include <linux/module.h>     // module_init  module_exit  
2. #include <linux/init.h>           // __init   __exit  
3. #include <linux/fs.h>  
4. #include <linux/leds.h>  
5. #include <mach/regs-gpio.h>  
6. #include <mach/gpio-bank.h>  
7. #include <linux/io.h>  
8. #include <linux/ioport.h>  
9. #include <mach/gpio.h>  
10.   
11.   
12. #define GPIO_LED1   S5PV210_GPJ0(3)  
13. #define GPIO_LED2   S5PV210_GPJ0(4)  
14. #define GPIO_LED3   S5PV210_GPJ0(5)  
15.   
16. #define X210_LED_OFF    1           // X210中LED是正极接电源，负极节GPIO  
17. #define X210_LED_ON     0           // 所以1是灭，0是亮  
18.   
19.   
20. static struct led_classdev mydev1;          // 定义结构体变量  
21. static struct led_classdev mydev2;          // 定义结构体变量  
22. static struct led_classdev mydev3;          // 定义结构体变量  
23.   
24. // 这个函数就是要去完成具体的硬件读写任务的  
25. static void s5pv210_led1_set(struct led_classdev    *led_cdev,enum led_brightness    value)  
26. {  
27.     printk(KERN_INFO "s5pv210_led1_set\n");  
28.       
29.     //writel(0x11111111, GPJ0CON);  
30.       
31.     // 在这里根据用户设置的值来操作硬件  
32.     // 用户设置的值就是value  
33.     if (value == LED_OFF)  
34.     {  
35.         // 用户给了个0，希望LED灭  
36.         //writel(0x11111111, GPJ0CON);  
37.         // 读改写三部曲  
38.         //writel((readl(GPJ0DAT) | (1<<3)), GPJ0DAT);  
39.         gpio_set_value(GPIO_LED1, X210_LED_OFF);  
40.     }  
41.     else  
42.     {  
43.         // 用户给的是非0，希望LED亮  
44.         //writel(0x11111111, GPJ0CON);  
45.         //writel((readl(GPJ0DAT) & ~(1<<3)), GPJ0DAT);  
46.         gpio_set_value(GPIO_LED1, X210_LED_ON);  
47.     }  
48. }  
49.   
50. static void s5pv210_led2_set(struct led_classdev *led_cdev,  
51.                 enum led_brightness value)  
52. {  
53.     printk(KERN_INFO "s5pv2102_led_set\n");  
54.       
55.     //writel(0x11111111, GPJ0CON);  
56.       
57.     // 在这里根据用户设置的值来操作硬件  
58.     // 用户设置的值就是value  
59.     if (value == LED_OFF)  
60.     {  
61.         // 用户给了个0，希望LED灭  
62.         //writel(0x11111111, GPJ0CON);  
63.         // 读改写三部曲  
64.         //writel((readl(GPJ0DAT) | (1<<4)), GPJ0DAT);  
65.     }  
66.     else  
67.     {  
68.         // 用户给的是非0，希望LED亮  
69.         //writel(0x11111111, GPJ0CON);  
70.         //writel((readl(GPJ0DAT) & ~(1<<4)), GPJ0DAT);  
71.     }  
72. }  
73.   
74. static void s5pv210_led3_set(struct led_classdev *led_cdev,  
75.                 enum led_brightness value)  
76. {  
77.     printk(KERN_INFO "s5pv210_led3_set\n");  
78.       
79.     //writel(0x11111111, GPJ0CON);  
80.       
81.     // 在这里根据用户设置的值来操作硬件  
82.     // 用户设置的值就是value  
83.     if (value == LED_OFF)  
84.     {  
85.         // 用户给了个0，希望LED灭  
86.         //writel(0x11111111, GPJ0CON);  
87.         // 读改写三部曲  
88.         //writel((readl(GPJ0DAT) | (1<<5)), GPJ0DAT);  
89.     }  
90.     else  
91.     {  
92.         // 用户给的是非0，希望LED亮  
93.         //writel(0x11111111, GPJ0CON);  
94.         //writel((readl(GPJ0DAT) & ~(1<<5)), GPJ0DAT);  
95.     }  
96. }  
97.   
98.   
99. static int __init s5pv210_led_init(void)  
100. {  
101.     // 用户insmod安装驱动模块时会调用该函数  
102.     // 该函数的主要任务就是去使用led驱动框架提供的设备注册函数来注册一个设备  
103.     int ret = -1;  
104.       
105.     // 在这里去申请驱动用到的各种资源，当前驱动中就是GPIO资源  
106.     if (gpio_request(GPIO_LED1, "led1_gpj0.3")) //这里是申请失败  
107.     {  
108.         printk(KERN_ERR "gpio_request failed\n");  
109.     }   
110.     else //申请成功后  
111.     {  
112.         // 设置为输出模式，并且默认输出1让LED灯灭  
113.         gpio_direction_output(GPIO_LED1, 1);  
114.     }  
115.       
116.       
117.       
118.     // led1  
119.     mydev1.name = "led1";  
120.     mydev1.brightness = 0;    
121.     mydev1.brightness_set = s5pv210_led1_set;  
122.       
123.     ret = led_classdev_register(NULL, &mydev1);  
124.     if (ret < 0) {  
125.         printk(KERN_ERR "led_classdev_register failed\n");  
126.         return ret;  
127.     }  
128.       
129.     // led2  
130.     mydev2.name = "led2";  
131.     mydev2.brightness = 0;    
132.     mydev2.brightness_set = s5pv210_led2_set;  
133.       
134.     ret = led_classdev_register(NULL, &mydev2);  
135.     if (ret < 0) {  
136.         printk(KERN_ERR "led_classdev_register failed\n");  
137.         return ret;  
138.     }  
139.       
140.     // led3  
141.     mydev3.name = "led3";  
142.     mydev3.brightness = 0;    
143.     mydev3.brightness_set = s5pv210_led3_set;  
144.       
145.     ret = led_classdev_register(NULL, &mydev3);  
146.     if (ret < 0) {  
147.         printk(KERN_ERR "led_classdev_register failed\n");  
148.         return ret;  
149.     }  
150.       
151.     return 0;  
152. }  
153.   
154. static void __exit s5pv210_led_exit(void)  
155. {  
156.     led_classdev_unregister(&mydev1);  
157.     led_classdev_unregister(&mydev2);  
158.     led_classdev_unregister(&mydev3);  
159.       
160.     gpio_free(GPIO_LED1);  
161. }  
162.   
163.   
164. module_init(s5pv210_led_init);  
165. module_exit(s5pv210_led_exit);  
166.   
167. // MODULE_xxx这种宏作用是用来添加模块描述信息  
168. MODULE_LICENSE("GPL");                          // 描述模块的许可证  
169. MODULE_AUTHOR("aston <1264671872@qq.com>");       // 描述模块的作者  
170. MODULE_DESCRIPTION("s5pv210 led driver");       // 描述模块的介绍信息  
171. MODULE_ALIAS("s5pv210_led");                    // 描述模块的别名信息  

 

十五、将驱动添加到内核中

1、驱动的存在形式

（1）野生，优势是方便调试开发，所以在开发阶段都是这种；

（2）家养，优势可以在内核配置时make menuconfig决定内核怎么编译，方便集成。比如DM9000已经集成在内核中了，可以在menuconfig时配置。

 

2、驱动开发的一般步骤

（1）以模块的形式在外部编写、调试；

（2）将调试好的驱动代码集成到kernel中

 

3、实践

（1）关键点：Kconfig、Makefile、make menuconfig

（2）操作步骤

 

• 第1步：将写好的驱动源文件放入内核源码中正确的目录下；比如led的驱动，应该放在/drivers/leds/目录下；
• 第2步：/drivers/leds/目录下，在Makefile中添加相应的依赖；
• 第3步：在Kconfig中添加相应的配置项；（因为make menuconfig的原理是读取Kconfig中的信息，这里要显示对应的配置项目，则需要添加相应内容）
• 第4步：make menuconfig；（以y为示例，此时会被编译进去；若以M，则不会被编译进去，而是被编译成单独的模块；若以N，则不被编译。）

第2步：

第3步：

第4步：

选择y之后，保存，然后在.config文件中会有如下的宏

结果如下：

十六、目录和文件结构

mach-s5pv210/gpiolib.c s5pv210_gpiolib_init

mach-s5pv210/include/mach/gpio.h #define S5PV210_GPA0(_nr)(S5PV210_GPIO_A0_START + (_nr))

arch/arm/plat-samsung/gpiolib.c 里面是210/6410这种4bit CON寄存器类型的操作方法

arch/arm/plat-samsung/gpio.c 里面是24XX这种2bit CON寄存器类型的操作方法

drivers/gpio/gpiolib.c 里面是内核开发者提供的gpiolib的驱动框架部