Linux驱动入门（三）Led驱动

原文：https://dandelioncloud.cn/article/details/1454352899043295234

Linux驱动入门系列

Linux驱动入门（一）字符设备驱动基础

Linux驱动入门（二）操作硬件

Linux驱动入门（三）Led驱动

Linux驱动入门（四）非阻塞方式实现按键驱动

Linux驱动入门（五）阻塞方式实现按键驱动

Linux驱动入门（六）poll机制实现按键驱动

Linux驱动入门（七）使用定时器消除按键抖动

Linux驱动入门（三）Led驱动

文章目录

• Linux驱动入门（三）Led驱动
• • 一、注册字符设备驱动
  • 二、操作硬件
  • • 2.1 控制led
    • 2.2 通用方式实现
    • 2.3 gpiolib实现
  • 三、源码
  • • 3.1 通用方式实现
    • 3.2 gpiolib实现
  • 四、测试

目的：实现一个led驱动，应用层写入1led亮，写0led灭

一、注册字符设备驱动

led驱动是一个字符设备驱动，编写led驱动首先要注册字符设备，生成设备节点，然后再是完善文件操作集合

关于如何注册字符设备和生成设备字节，在Linux驱动入门（一）字符设备驱动基础中讲得比较详细了，这里给出代码

1. #include <linux/module.h>
2. #include <linux/init.h>
3. #include <linux/fs.h>
4. #include <linux/cdev.h>
5. #include <linux/slab.h>
6. #include <linux/device.h>
8. #include <asm/io.h>
9. #include <asm/uaccess.h>
11. static dev_t dev_id;
12. static struct cdev *led_dev;
13. static struct class *led_class;
15. int led_open(struct inode *inode, struct file *file)
16. {
18. /* 设置gpio */
20. return 0;
21. }
23. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
24. {
26. int val, ret;
28. /* 从用户空间拷贝数据 */
29. ret = copy_from_user(&val, data, sizeof(val));
31. if(val == 0)
32. {
34. /* 熄灭led */
35. }
36. else if(val == 1)
37. {
39. /* 点亮 */
40. }
42. return 0;
43. }
45. static struct file_operations led_fops = {
47. .owner = THIS_MODULE,
48. .open = led_open,
49. .write = led_write,
50. };
52. static __init int led_init(void)
53. {
55. /* 申请设备号 */
56. alloc_chrdev_region(&dev_id, 1, 1, "led");
58. /* 分配字符设备 */
59. led_dev = cdev_alloc();
61. /* 设置字符设备 */
62. cdev_init(led_dev, &led_fops);
64. /* 注册字符设备 */
65. cdev_add(led_dev, dev_id, 1);
67. /* 创建设备节点 */
68. led_class = class_create(THIS_MODULE, "led"); //创建类
69. device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
71. return 0;
72. }
74. static __exit void led_exit(void)
75. {
77. /* 注销设备节点 */
78. device_destroy(led_class, dev_id);
79. class_destroy(led_class);
81. /* 注销字符设备 */
82. cdev_del(led_dev);
83. kfree(led_dev);
85. /* 注销注册的设备号 */
86. unregister_chrdev_region(dev_id, 1);
87. }
89. module_init(led_init);
90. module_exit(led_exit);
92. MODULE_LICENSE("GPL");

编译上面的驱动程序，加载模块，就会生成/dev/led设备节点，这是我们led驱动的基本框架，我们还要在led_open、led_write中操作硬件

从上面代码中可以看到，在led_open中去设置gpio，在led_write中，如果写1就点亮led，写0就熄灭led

这里介绍一个知识点，用户空间和内核空间不能通过指针直接访问，必须使用内核提供的函数

从用户空间到内核空间使用

1. static inline long copy_from_user(void *to,
2. const void __user * from, unsigned long n)

从内核空间到用户空间使用

1. static inline long copy_to_user(void __user *to,
2. const void *from, unsigned long n)

此时还未涉及到操作硬件，下面来具体介绍如何在驱动程序中去操作led

二、操作硬件

2.1 控制led

下面开始来介绍如何去操作led

首先打开开发板的原理图，找到led，如下

这里我要操作nLED1，发现其有GPJ0_3引脚控制，当GPJ0_3引脚高电平，led被点亮，当GPJ0_3引脚为低电平，led被熄灭

下面查看芯片的datasheet，看如何控制GPJ0_3引脚的高低电平

找到了两个相关的寄存器GPJ0CON和GPJ0DAT

从图中可以看到GPJ0CON寄存器的地址为0xE020_0240，该寄存器32位有效，其中GPJ0CON[3]（12-15位）设置引脚的功能

GPJ0DAT寄存器的地址为0xE0020_0244，该寄存器8位有效，其中GPJ0DAT[3]（第3位）控制引脚的高低电平

那么想要设置引脚的高低电平可以这样做

1. GPJ0CON |= 1<<12; //配置GPJ0_3为输出状态
3. GPJ0DAT |= 1<<3; //输出高电平
4. GPJ0DAT &= ~(1<<3); //输出低电平

从而达到控制led亮灭的目的

在Linux驱动入门（二）操作硬件中详细地讲解了如何去操作硬件，分别有通用方法和使用gpiolib的方法，下面将介绍这两种方法

2.2 通用方式实现

使用通用的方法来设置gpio高低电平

首先找到寄存器的物理地址

1. #define GPJ0CON_PHY_ADDR 0xE0200240
2. #define GPJ0DAT_PHY_ADDR 0xE0200244

然后映射物理地址

1. static volatile unsigned int *gpj0_con = NULL;
2. static volatile unsigned int *gpj0_dat = NULL;
4. gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
5. gpj0_dat = gpj0_con+1;

配置引脚的功能

1. unsigned int cfg;
3. /* 将GPIO设置为输出模式 */
4. cfg = readl(gpj0_con);
5. writel(cfg | (1<<12), gpj0_con);

设置引脚高低电平

1. /* 高电平 */
2. cfg = readl(gpj0_dat);
3. writel(cfg | (1<<3), gpj0_dat);
5. /* 低电平 */
6. cfg = readl(gpj0_dat);
7. writel(cfg & ~(1<<3), gpj0_dat);

取消地址映射

1. iounmap(gpj0_con);

稍后将给出驱动源码

2.3 gpiolib实现

使用gpiolib可以不用直接操作寄存器，这就变得非常简单了

申请gpio

1. gpio_request(S5PV210_GPJ0(3), "led");

设置gpio为输出模式

1. gpio_direction_output(S5PV210_GPJ0(3), 1);

设置gpio的高低电平

1. gpio_set_value(S5PV210_GPJ0(3), 1); //高电平
2. gpio_set_value(S5PV210_GPJ0(3), 0); //低电平

三、源码

3.1 通用方式实现

1. #include <linux/module.h>
2. #include <linux/init.h>
3. #include <linux/fs.h>
4. #include <linux/cdev.h>
5. #include <linux/slab.h>
6. #include <linux/device.h>
8. #include <asm/io.h>
9. #include <asm/uaccess.h>
11. #define GPJ0CON_PHY_ADDR 0xE0200240
12. #define GPJ0DAT_PHY_ADDR 0xE0200244
14. static dev_t dev_id;
15. static struct cdev *led_dev;
16. static struct class *led_class;
18. static volatile unsigned int *gpj0_con = NULL;
19. static volatile unsigned int *gpj0_dat = NULL;
21. int led_open(struct inode *inode, struct file *file)
22. {
24. unsigned int cfg;
26. /* 将GPIO设置为输出模式 */
27. cfg = readl(gpj0_con);
28. writel(cfg | (1<<12), gpj0_con);
30. /* 熄灭led */
31. cfg = readl(gpj0_dat);
32. writel(cfg | (1<<3), gpj0_dat);
34. return 0;
35. }
37. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
38. {
40. int val, ret;
41. unsigned int cfg;
43. /* 从用户空间拷贝数据 */
44. ret = copy_from_user(&val, data, sizeof(val));
46. cfg = readl(gpj0_dat);
48. if(val == 0) //熄灭
49. {
51. writel(cfg | (1<<3), gpj0_dat);
52. }
53. else if(val == 1) //点亮
54. {
56. writel(cfg & ~(1<<3), gpj0_dat);
57. }
58. else
59. return -1;
61. return 0;
62. }
64. static struct file_operations led_fops = {
66. .owner = THIS_MODULE,
67. .open = led_open,
68. .write = led_write,
69. };
71. static __init int led_init(void)
72. {
74. /* 申请设备号 */
75. alloc_chrdev_region(&dev_id, 1, 1, "led");
77. /* 分配字符设备 */
78. led_dev = cdev_alloc();
80. /* 设置字符设备 */
81. cdev_init(led_dev, &led_fops);
83. /* 注册字符设备 */
84. cdev_add(led_dev, dev_id, 1);
86. /* 创建设备节点 */
87. led_class = class_create(THIS_MODULE, "led"); //创建类
88. device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
90. /* 映射物理地址 */
91. gpj0_con = (volatile unsigned int *)ioremap(GPJ0CON_PHY_ADDR, 8);
92. gpj0_dat = gpj0_con+1;
94. return 0;
95. }
97. static __exit void led_exit(void)
98. {
100. /* 注销设备节点 */
101. device_destroy(led_class, dev_id);
102. class_destroy(led_class);
104. /* 注销字符设备 */
105. cdev_del(led_dev);
106. kfree(led_dev);
108. /* 注销注册的设备号 */
109. unregister_chrdev_region(dev_id, 1);
111. /* 注销映射的地址 */
112. iounmap(gpj0_con);
113. }
115. module_init(led_init);
116. module_exit(led_exit);
118. MODULE_LICENSE("GPL");

3.2 gpiolib实现

1. #include <linux/module.h>
2. #include <linux/init.h>
3. #include <linux/fs.h>
4. #include <linux/cdev.h>
5. #include <linux/slab.h>
6. #include <linux/device.h>
7. #include <linux/gpio.h>
9. #include <asm/io.h>
10. #include <asm/uaccess.h>
12. #include <mach/gpio.h>
14. static dev_t dev_id;
15. static struct cdev *led_dev;
16. static struct class *led_class;
18. int led_open(struct inode *inode, struct file *file)
19. {
21. gpio_direction_output(S5PV210_GPJ0(3), 1);
23. return 0;
24. }
26. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
27. {
29. int val, ret;
31. /* 从用户空间拷贝数据 */
32. ret = copy_from_user(&val, data, sizeof(val));
34. if(val == 0) //熄灭
35. {
37. gpio_set_value(S5PV210_GPJ0(3), 1);
38. }
39. else if(val == 1) //点亮
40. {
42. gpio_set_value(S5PV210_GPJ0(3), 0);
43. }
44. else
45. return -1;
47. return 0;
48. }
50. static struct file_operations led_fops = {
52. .owner = THIS_MODULE,
53. .open = led_open,
54. .write = led_write,
55. };
57. static __init int led_init(void)
58. {
60. /* 申请设备号 */
61. alloc_chrdev_region(&dev_id, 1, 1, "led");
63. /* 分配字符设备 */
64. led_dev = cdev_alloc();
66. /* 设置字符设备 */
67. cdev_init(led_dev, &led_fops);
69. /* 注册字符设备 */
70. cdev_add(led_dev, dev_id, 1);
72. /* 创建设备节点 */
73. led_class = class_create(THIS_MODULE, "led"); //创建类
74. device_create(led_class, NULL, dev_id, NULL, "led"); //创建设备节点
76. /* 申请gpio */
77. gpio_request(S5PV210_GPJ0(3), "led");
79. return 0;
80. }
82. static __exit void led_exit(void)
83. {
85. /* 注销设备节点 */
86. device_destroy(led_class, dev_id);
87. class_destroy(led_class);
89. /* 注销字符设备 */
90. cdev_del(led_dev);
91. kfree(led_dev);
93. /* 注销注册的设备号 */
94. unregister_chrdev_region(dev_id, 1);
96. gpio_free(S5PV210_GPJ0(3));
97. }
99. module_init(led_init);
100. module_exit(led_exit);
102. MODULE_LICENSE("GPL");

四、测试

将上面两个驱动程序中任意一个保存为led_drv.c

下面是一个Makefile

1. KERN_DIR = /work/linux/kernel
3. all:
4. make -C $(KERN_DIR) M=`pwd` modules
6. clean:
7. make -C $(KERN_DIR) M=`pwd` modules clean
8. rm -rf modules.order
10. obj-m += led_drv.o

修改你的内核源码树，执行make，生成led_drv.ko，通过insmod led_drv.ko加载模块

此时将生成/dev/led的设备节点

测试应用程序

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <unistd.h>
6. #include <string.h>
8. #define LED_DEV "/dev/led"
10. int main(int argc, char* argv[])
11. {
13. int val;
14. int fd;
16. if(argc != 2)
17. {
19. printf("Usage: %s <on|off>\n", argv[0]);
20. return -1;
21. }
23. fd = open(LED_DEV, O_RDWR);
24. if(fd < 0)
25. {
27. printf("failed to open %s\n", LED_DEV);
28. return -1;
29. }
31. if(!strcmp(argv[1], "on"))
32. val = 1;
33. else if(!strcmp(argv[1], "off"))
34. val = 0;
35. else
36. {
38. printf("Usage: %s <on|off>\n", argv[0]);
39. return -1;
40. }
42. write(fd, &val, sizeof(val));
44. close(fd);
46. return 0;
47. }

将此应用程序保存为led_test.c，编译arm-linux-gcc -o led_test led_test.c

执行led_test on，led被点亮

执行led_test off，led被熄灭