Linux驱动入门Led驱动

Posted 2023-04-22 MaxBruce

原文：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)
18. /* 设置gpio */
20. return 0;
23. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
26. int val, ret;
28. /* 从用户空间拷贝数据 */
29. ret = copy_from_user(&val, data, sizeof(val));
31. if(val == 0)
34. /* 熄灭led */
36. else if(val == 1)
39. /* 点亮 */
42. return 0;
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)
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;
74. static __exit void led_exit(void)
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);
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)
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;
37. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
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) //熄灭
51. writel(cfg | (1<<3), gpj0_dat);
53. else if(val == 1) //点亮
56. writel(cfg & ~(1<<3), gpj0_dat);
58. else
59. return -1;
61. return 0;
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)
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;
97. static __exit void led_exit(void)
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);
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)
21. gpio_direction_output(S5PV210_GPJ0(3), 1);
23. return 0;
26. ssize_t led_write(struct file *file, const char __user *data, size_t size, loff_t *loff)
29. int val, ret;
31. /* 从用户空间拷贝数据 */
32. ret = copy_from_user(&val, data, sizeof(val));
34. if(val == 0) //熄灭
37. gpio_set_value(S5PV210_GPJ0(3), 1);
39. else if(val == 1) //点亮
42. gpio_set_value(S5PV210_GPJ0(3), 0);
44. else
45. return -1;
47. return 0;
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)
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;
82. static __exit void led_exit(void)
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));
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[])
13. int val;
14. int fd;
16. if(argc != 2)
19. printf("Usage: %s <on|off>\\n", argv[0]);
20. return -1;
23. fd = open(LED_DEV, O_RDWR);
24. if(fd < 0)
27. printf("failed to open %s\\n", LED_DEV);
28. return -1;
31. if(!strcmp(argv[1], "on"))
32. val = 1;
33. else if(!strcmp(argv[1], "off"))
34. val = 0;
35. else
38. printf("Usage: %s <on|off>\\n", argv[0]);
39. return -1;
42. write(fd, &val, sizeof(val));
44. close(fd);
46. return 0;

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

执行led_test on，led被点亮

执行led_test off，led被熄灭

第7章：LED驱动的实现原理

本章完成了一个真正意义上的 Linux 驱动。该 Linux 驱动用来控 制开发版上的 4个 LED 小灯。也就是说通过向 Linux 驱动发送数据可以控制 LED 小灯的开关。为 了方便称呼这个驱动，本书及后面的章节都将其称为 LED 驱动。

 

虽然 LED 驱动并不复杂，只是控制 了 4个 LED，＂但 LED 驱动已经包括了 Linux 驱动所有必要的部分 一个完整的 Linux 驱动主要由 内部处理和与硬件交互降部分组成。其中内部处理主要是指 Linux 驱动的装载、卸载、与设备文件 相关的动作处理（读写设备文件、向设备文件发送 νo命令等动作〉以及业务逻辑等。与硬件交互 主要是指通过iowrite32、 . ioread32 等函数与硬件中的寄存器进行数据交互。 -Linux 驱动在不同平台 的移植也是处理这两部分。如果在不同 Lin肌 肉核版本之间的移植，主要是移植第 1 部分（ Linux 驱动的内部处理，一般 Linux 内核版本相差较大时， Linu叉’内核的 APl 会有很大差别〉，如果在不同硬件平台的移植，主要是移植第 2部分。

 

 编写LED驱动：

测试LED驱动之前需要用USB数据线连接开发板，然后打开电源，成功启动之后，执行build.sh脚本文件编译和安装LED驱动，顺利则会自动连接

如果有多个设备文件将会在后来使用，则要通过指针变量cdev.list.prev和cdev.list.next指针变量连接，从而形成双向链接。

在创建设备文件时要注意：

Device_count表示建立设备文件的个数

Alloc_chrdv_region函数的第2个参数表示分配的起始设备号。

卸载Linux驱动的设备文件，需要依次调用device_destory、class_destory和unregister_chrdev_region方法

ARM控制LED的有三个寄存器，三个寄存器在内存中都有虚拟地址，向这些地址写入数据后，处理器会使用算法将虚拟地址映射为物理地址，并根据物理地址将数据写入相应的硬件端口。

驱动的设备文件。

控制LED有两种方式：

通过字符串控制LED—>file_operation.write

通过I/O命令控制LED—>file_operation.ioctl

LED驱动的模块参数

Moule_param_array(name,type,nump,perm)宏定义为LINUX驱动指定数组形式的模块参数。Name表示参数名，type表示数组元素的数据类型，nump表示存储数组长度的变量的指针，perm表示参数文件的访问权限。

 

编写测试I/O控制命令的通用程序，与设备文件交互的方式：直接写入字符串数据和I/O控制命令。直接向设备文件写入数据可以使用命令行方式来完成，也可以通过write函数来完成，但I/O命令只能通过ioctl发出。

一个完整的Linux驱动主要是由内部处理和硬件交互两部分组成，其中内部处理主要是指Linux驱动的装载、卸载、与设备文件相关的动作处理以及业务逻辑、与硬件交互主要是指通过函数与硬件中的寄存器进行数据交互