linux设备驱动归纳总结（五）：4.写个简单的LED驱动【转】

本文转载自：http://blog.chinaunix.net/uid-25014876-id-84693.html

linux设备驱动归纳总结（五）：4.写个简单的LED驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

在上面的章节的知识，已经能够实现个简单的LED驱动。居于前面操作LED的函数（5th_mm_2/3rd/test.c），我一步一步来修改。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、实现硬件操作函数

一般的，我写驱动的时候，我会先确定一些基本的硬件操作函数能够使用。如LED驱动我要实现三个操作：配置、开灯和关灯，所以我先要实现这几个硬件操作函数。

其实这些在我介绍IO内存时已经实现了（5th_mm_2/3rd/test.c），我只是稍作了一点修改，改了一下内存的数据类型，其实没什么大出入。

/*5th_mm_4/1st/test.c*/

1 #include

2 #include

3

4 #include

5 #include

6

7 unsigned long virt, phys;

8 unsigned long gpecon, gpedat, gpeup; //其实我就改了这里的数据类型，其实都是用来存放地址

9 unsigned long reg; //没有多大的影响。

10 struct resource *led_resource;

11

12 void s3c_led_config(void) //还将函数的名字改成好听点

13 {

14 reg = ioread32(gpecon);

15 reg &= ~(3 << 24);

16 reg |= (1 << 24);

17 iowrite32(reg, gpecon);

18

19 reg = ioread32(gpeup);

20 reg &= ~(3 << 12);

21 iowrite32(reg, gpeup);

22 }

23

24 void s3c_led_on(void)

25 {

26 reg = ioread32(gpedat);

27 reg &= ~(1 << 12);

28 iowrite32(reg, gpedat);

29 }

30

31 void s3c_led_off(void)

32 {

33 reg = ioread32(gpedat);

34 reg |= (1 << 12);

35 iowrite32(reg, gpedat);

36 }

37

38 void init_led_device(void)

39 {

40 phys = 0x56000000;

41 virt = (unsigned long)ioremap(phys, 0x0c);

42

43 gpecon = virt + 0x40;

44 gpedat = virt + 0x44;

45 gpeup = virt + 0x48;

46 }

47

48 static int __init test_init(void) //模块初始化函数

49 {

50 init_led_device();

51

52 led_resource = request_mem_region(phys, 0x0c, "LED_MEM");

53 if(NULL == led_resource){

54 printk("request mem error!\n");

55 return - ENOMEM;

56 }

57

58 s3c_led_config();

59 s3c_led_on();

60 printk("hello led!\n");

61 return 0;

62 }

63

64 static void __exit test_exit(void) //模块卸载函数

65 {

66 if(NULL != led_resource){

67 s3c_led_off();

68 iounmap((void *)virt);

69 release_mem_region(phys, 0x0c);

70 }

71 printk("bye\n");

72 }

73

74 module_init(test_init);

75 module_exit(test_exit);

76

77 MODULE_LICENSE("GPL");

78 MODULE_AUTHOR("xoao bai");

79 MODULE_VERSION("v0.1");

至于验证我就不做了，效果还是一样，加载模块灯亮，卸载模块灯灭。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、面向对象思想——定义一个LED的结构体

上面的函数中，一大堆的全局变量实在让人看起来不舒服。我在第三章字符设备的文中介绍过，把这些变量定义在一个结构体中，方便以后引用，如函数传参。

/*5th_mm_4/2nd/test.c*/

7 struct _led_t{

8 //hardware obb

9 unsigned long virt, phys;

10 unsigned long gpecon, gpedat, gpeup;

11 unsigned long reg;

12 struct resource *led_resource;

13

14 void (*config)(struct _led_t *); //这里把LED驱动的三个操作函数指针也放进去

15 void (*on)(struct _led_t *);

16 void (*off)(struct _led_t *);

17 };

根据上面定义的数据结构，我再修改一下1st目录的程序，就成了2nd目录中的函数。现在函数做了两步：

1）实现硬件的基本操作。

2）定义了一个面向对象数据类型。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、实现硬件设备初始化函数和注销函数

在对硬件进程操作（配置，开灯、关灯）之前，需要先进行IO内存映射等操作，前面的函数写得很零散，这里我整理了一下：

）当插入模块时，需要进行一些内存映射等设备初始化操作，使用函数init_led_device。

）当卸载模块时，需要进行一些硬件注销操作，使用函数eixt_led_device。

接下来就要封装这两个函数：

/*5th_mm_4/3rd/test.c */

45 int init_led_device(struct _led_t *led)

46 {

47 led->phys = 0x56000000; //1指定物理地址

48

49 led->led_resource = request_mem_region(led->phys, 0x0c, "LED_MEM");

50 if(NULL == led->led_resource){ //2申请内存区域

51 return - 1;

52 }

53

54 led->virt = (unsigned long)ioremap(led->phys, 0x0c); //3内存映射

55

56 led->gpecon = led->virt + 0x40; //4指定寄存器地址

57 led->gpedat = led->virt + 0x44;

58 led->gpeup = led->virt + 0x48;

59

60 led->config = s3c_led_config; //5将操作函数也放进结构体成员

61 led->on = s3c_led_on;

62 led->off = s3c_led_off;

63

64 return 0;

65 }

66

67 void exit_led_device(struct _led_t *led)

68 {

69 if(NULL != led->led_resource){

70 iounmap((void *)led->virt);

71 release_mem_region(led->phys, 0x0c);

72 }

73 }

74

75 struct _led_t my_led;

76

77 static int __init test_init(void) //模块初始化函数

78 {

79 if (-1 == init_led_device(&my_led)){ //加载模块时就调用init_led_device

80 printk("request mem error!\n");

81 return - ENOMEM;

82 }

83

84 my_led.config(&my_led); //这里调用操作函数是多于了，我迟点会放在ioctl中

85 my_led.on(&my_led); //这里只不过加载时候灯亮一下，让我知道加载成功

86 printk("hello led!\n");

87 return 0;

88 }

89

90 static void __exit test_exit(void) //模块卸载函数

91 {

92 my_led.off(&my_led);

93 exit_led_device(&my_led); //卸载时调用exit_led_device

94 printk("bye\n");

95 }

至于验证我就不做了，效果还是一样，加载模块灯亮，卸载模块灯灭。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、实现字符设备的申请，即模块与内核的接口

需要实现ioctl功能，首先要这个设备需要先注册，使用字符设备注册的知识：

字符设备注册三步曲：

/*5th_mm_4/4th/test.c*/

18 struct _led_t{

19 //hardware obb

20 unsigned long virt, phys;

21 unsigned long gpecon, gpedat, gpeup;

22 unsigned long reg;

23 struct resource *led_resource;

24

25 void (*config)(struct _led_t *);

26 void (*on)(struct _led_t *);

27 void (*off)(struct _led_t *);

28

29 //kernel oob

30 dev_t devno; //往结构体添加了两个成员

31 struct cdev led_cdev;

32 };

。。。。。。

90 struct _led_t my_led;

91 struct file_operations s3c_led_fops = {

92 //暂时还是空的

93 };

94

95 static int __init led_driver__init(void) //模块初始化函数

96 {

97 int ret;

98

99 ret = init_led_device(&my_led);

100 if (ret){

101 P_DEBUG("request mem error!\n");

102 ret = - ENOMEM;

103 goto err0;

104 }

105

106 ret = alloc_chrdev_region(&my_led.devno, 0, 1, "s3c_led_driver"); //1申请cdev

107 if (ret){

108 P_DEBUG("alloc chrdev failed!\n");

109 goto err1;

110 }

111 P_DEBUG("major[%d], minor[%d]\n", MAJOR(my_led.devno), MINOR(my_led.devno));

112

113 cdev_init(&my_led.led_cdev, &s3c_led_fops); //2初始化cdev

114

115 ret = cdev_add(&my_led.led_cdev, my_led.devno, 1); //3添加cdev

116 if (ret){

117 P_DEBUG("cdev_add failed!\n");

118 goto err2;

119 }

120

121 my_led.config(&my_led);

122 my_led.on(&my_led);

123 P_DEBUG("hello led!\n");

124 return 0;

125

126 err2:

127 unregister_chrdev_region(my_led.devno, 1);

128 err1:

129 exit_led_device(&my_led);

130 err0:

131 return ret;

132 }

133

134 static void __exit led_driver__exit(void) //模块卸载函数

135 {

136 my_led.off(&my_led);

137

138 unregister_chrdev_region(my_led.devno, 1); //卸载是注销cdev结构

139 exit_led_device(&my_led);

140 P_DEBUG("bye\n");

141 }

这里就可以验证一下了：

[root: 4th]# insmod test.ko

[led_driver__init]major[253], minor[0] //申请成功的设备号

[led_driver__init]hello led!

[root: 4th]# rmmod test

[led_driver__exit]bye

既然设备申请成功，接下来就是要实现系统调用接口了。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五、实现系统调用对应的函数ioctl

在这里，我需要实现的内容是，在应用层使用ioctl系统调用，可以操作LED配置、打开和关闭。接下来实现文件操作结构体中的ioctl。

、首先要定义命令：

/*5th_mm_4/5th/led_ioctl.h*/

1 #ifndef _LED_H

2 #define _LED_H

3

4 #define LED_MAGIC 'x'

5 #define LED_CONF _IO(LED_MAGIC, 0)

6 #define LED_ON _IO(LED_MAGIC, 1)

7 #define LED_OFF _IO(LED_MAGIC, 2)

8

9 #endif /* _LED_H */

、接着实现文件操作结构体中的ioctl：

/*5th_mm_4/5th/led_driver.c */ //这里我把文件的名字改了

92 int s3c_led_ioctl(struct inode *node, struct file *filp, unsigned int cmd, unsign ed long args)

93 {

94 int ret;

95 struct _led_t *dev = container_of(node->i_cdev, struct _led_t, led_cdev);

96 switch(cmd){

97 case LED_CONF:

98 dev->config(dev);

99 break;

100 case LED_ON:

101 dev->on(dev);

102 break;

103 case LED_OFF:

104 dev->off(dev);

105 break;

106 default:

107 P_DEBUG("unknow cmd!\n");

108 ret = - EINVAL;

109 goto err0;

110 }

111 return 0;

112

113 err0:

114 return ret;

115 }

116

117 struct _led_t my_led;

118 struct file_operations s3c_led_fops = {

119 .ioctl = s3c_led_ioctl, //一定要加上。打开和关闭操作我不实现，使用默认的

120 };

、接着实现应用层函数：

1 #include

2 #include

3 #include

4 #include

5 #include

6 #include

7

8 #include "led_ioctl.h"

9

10 int main(int argc, char *argv[])

11 {

12 int fd;

13 fd = open("/dev/led_driver", O_RDWR);

14 if(fd < 0){

15 perror("open");

16 return -1;

17 }

18

19 ioctl(fd, LED_CONF);

20

21 if(!strncasecmp("on", argv[1], 3))

22 ioctl(fd, LED_ON);

23

24 if(!strncasecmp("off", argv[1], 3))

25 ioctl(fd, LED_OFF);

26

27

28 return 0;

29 }

验证一下：

[root: 5th]# insmod led_driver.ko

[led_driver__init]major[253], minor[0]

[led_driver__init]hello led!

[root: 5th]# mknod /dev/led_driver c 253 0

[root: 5th]# ./app on //亮灯

[root: 5th]# ./app off //灭灯

[root: 5th]# rmmod led_driver

[led_driver__exit]bye

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

六、使用信号量

其实在单处理器非抢占内核下，是没有必要使用到内核同步机制的，这里使用信号量来限制只能同时一个进程打开并操作led设备文件。实现的方法就是在打开的时候使用信号量：

/*5th_mm_4/6th/led_driver.c*/

20 struct _led_t{

21 //hardware obb

22 unsigned long virt, phys;

23 unsigned long gpecon, gpedat, gpeup;

24 unsigned long reg;

25 struct resource *led_resource;

26

27 void (*config)(struct _led_t *);

28 void (*on)(struct _led_t *);

29 void (*off)(struct _led_t *);

30

31 //kernel oob

32 dev_t devno;

33 struct cdev led_cdev;

34 struct semaphore led_sem; //非抢占下，其实单纯使用一个标志flag来实现也行，

35 }; //文件打开减一，关闭加一，flag不为零时可打开。

。。。。。。。。

63 int init_led_device(struct _led_t *led)

64 {

65 led->phys = 0x56000000;

66

67 led->led_resource = request_mem_region(led->phys, 0x0c, "LED_MEM");

68 if(NULL == led->led_resource){

69 return - 1;

70 }

71

72 led->virt = (unsigned long)ioremap(led->phys, 0x0c);

73

74 led->gpecon = led->virt + 0x40;

75 led->gpedat = led->virt + 0x44;

76 led->gpeup = led->virt + 0x48;

77

78 led->config = s3c_led_config;

79 led->on = s3c_led_on;

80 led->off = s3c_led_off;

81

82 sema_init(&led->led_sem, 1);

83

84 return 0;

85 }

。。。。。。。

120 int s3c_led_open (struct inode *node, struct file *filp)

121 {

122 struct _led_t *dev = container_of(node->i_cdev, struct _led_t, led_cdev);

123 filp->private_data = dev;

124

125 if (down_trylock(&dev->led_sem)){ //获得锁

126 P_DEBUG("led busy!\n");

127 return - EBUSY;

128 }

129

130 return 0;

131 }

132

133 int s3c_led_release (struct inode *node, struct file *filp)

134 {

135 struct _led_t *dev = filp->private_data;

136 up(&dev->led_sem); //释放锁

137 return 0;

138 }

139

140

141 struct _led_t my_led;

142 struct file_operations s3c_led_fops = {

143 .ioctl = s3c_led_ioctl,

144 .open = s3c_led_open,

145 .release = s3c_led_release,

146 };

为了验证，修改一下应用程序，使程序陷入死循环不退出：

/*5th_mm_4/6th/app.c*/

2 #include

3 #include

4 #include

5 #include

6 #include

7

8 #include "led_ioctl.h"

9

10 int main(int argc, char *argv[])

11 {

12 int fd;

13 fd = open("/dev/led_driver", O_RDWR);

14 if(fd < 0){

15 perror("open");

16 return -1;

17 }

18

19 ioctl(fd, LED_CONF);

20

21 if(!strncasecmp("on", argv[1], 3))

22 ioctl(fd, LED_ON);

23

24 if(!strncasecmp("off", argv[1], 3))

25 ioctl(fd, LED_OFF);

26

27 while(1)

28 {

29 ;

30 }

31

32 close(fd);

33 return 0;

34 }

也来验证一下：

[root: 6th]# insmod led_driver.ko

[led_driver__init]major[253], minor[0]

[led_driver__init]hello led!

[root: 6th]# mknod /dev/led_driver c 253 0

[root: 6th]# ./app on & //后台开灯

[root: 6th]# ./app off //在灭灯

[s3c_led_open]led busy! //灭灯进程无法打开设备文件，返回错误

open: Device or resource busy

[root: 6th]# rmmod led_driver

[led_driver__exit]bye

这样，一个简单的LED驱动就实现了，大家也可以尝试将my_led结构体通过kmalloc来申请，我只是觉得这个结构体占用的空间不多，就把这个步骤免了。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

七、总结

上面的驱动我是按以下顺序写的：

）实现硬件操作config,on.off

）定义面向对象数据结构

）定义硬件初始化操作

）实现字符设备注册

）实现ioctl等字符设备操作

）实现信号量限制打开文件个数

上面介绍了我写驱动函数的步骤，其实最先的步骤应该是定义面向对象的数据结构，在开始实现其他的函数操作，只不过我之前已经将部分的硬件操作函数写好了，所以就稍稍改了前三步的步骤。接下来总结一下：

顺序不是一成不变的，但无论怎么写，也要按照从底层到上层，逐个逐个往上封装。

当然，这个驱动只是我结合了之前学的知识写的，内核中的驱动不可能这么简单，

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx