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

た入场券 2022-04-23 10:56 263阅读 0赞

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 <linux/module.h>

2 \#include <linux/init.h>

3

4 \#include <asm/io.h>

5 \#include <linux/ioport.h>

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内存映射等操作，前面的函数写得很零散，这里我整理了一下：

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

2）当卸载模块时，需要进行一些硬件注销操作，使用函数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

<kernel>\[led\_driver\_\_init\]major\[253\], minor\[0\] //申请成功的设备号

<kernel>\[led\_driver\_\_init\]hello led!

\[root: 4th\]\# rmmod test

<kernel>\[led\_driver\_\_exit\]bye

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

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

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

1、首先要定义命令：

/\*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 \*/

2、接着实现文件操作结构体中的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 \};

3、接着实现应用层函数：

1 \#include <stdio.h>

2 \#include <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5 \#include <strings.h>

6 \#include <sys/ioctl.h>

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

<kernel>\[led\_driver\_\_init\]major\[253\], minor\[0\]

<kernel>\[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

<kernel>\[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 <sys/types.h>

3 \#include <sys/stat.h>

4 \#include <fcntl.h>

5 \#include <strings.h>

6 \#include <sys/ioctl.h>

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

<kernel>\[led\_driver\_\_init\]major\[253\], minor\[0\]

<kernel>\[led\_driver\_\_init\]hello led!

\[root: 6th\]\# mknod /dev/led\_driver c 253 0

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

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

<kernel>\[s3c\_led\_open\]led busy! //灭灯进程无法打开设备文件，返回错误

open: Device or resource busy

\[root: 6th\]\# rmmod led\_driver

<kernel>\[led\_driver\_\_exit\]bye

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

七、总结

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

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

2）定义面向对象数据结构

3）定义硬件初始化操作

4）实现字符设备注册

5）实现ioctl等字符设备操作

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

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

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

发表评论取消回复

表情：

评论列表（有 0 条评论，263人围观）

还没有评论，来说两句吧...

相关阅读

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

た入场券/ 2022年04月23日 10:56/ 0 赞/ 264 阅读

相关 linux设备驱动归纳总结（五）：3.操作硬件——IO静态映射

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

约定不等于承诺〃/ 2022年04月23日 10:56/ 0 赞/ 203 阅读

相关 linux设备驱动归纳总结（五）：2.操作硬件——IO内存

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

矫情吗；*/ 2022年04月23日 10:56/ 0 赞/ 217 阅读

相关 linux设备驱动归纳总结（三）：4.ioctl的实现

一、ioctl的简介：虽然在文件操作结构体"struct file\_operations"中有很多对应的设备操作函数，但是有些命令是实在找不到对应的操作函数。如CD-RO

旧城等待，/ 2022年03月20日 19:26/ 0 赞/ 292 阅读

相关 linux设备驱动归纳总结（十二）：简单的数码相框

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

冷不防/ 2022年03月19日 03:58/ 0 赞/ 210 阅读

相关 linux设备驱动归纳总结（十一）：写个简单的看门狗驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

墨蓝/ 2022年03月19日 03:58/ 0 赞/ 313 阅读

相关 linux设备驱动归纳总结（九）：1.platform总线的设备和驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

雨点打透心脏的1/2处/ 2022年03月19日 03:56/ 0 赞/ 342 阅读

相关 linux设备驱动归纳总结（八）：4.总线热插拔

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

忘是亡心i/ 2022年03月19日 03:56/ 0 赞/ 266 阅读

相关 linux设备驱动归纳总结（八）：2.总线、设备和驱动的关系

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

雨点打透心脏的1/2处/ 2022年03月19日 03:54/ 0 赞/ 258 阅读

相关 linux设备驱动归纳总结（八）：1.总线、设备和驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

悠悠/ 2022年03月19日 03:54/ 0 赞/ 476 阅读