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

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

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){

70iounmap((void

*)led->virt);

71release_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

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

85my_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

106ret

= 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。

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

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

七、总结

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

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

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

3)定义硬件初始化操作

4)实现字符设备注册

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

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

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

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

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

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx