• Linux学习第13天：嵌入式LinuxLED驱动开发：一字一符总见情

            在正式写这篇笔记前，有一个事情必须要说一下。昨天更新的基于API函数的字符设备驱动开发按照正常的教程来说应该在本笔记后一天更新才对。但是由于我一时的疏忽，跳过了本笔记。在昨天学习基于API函数的时候造成了一定程度的困扰。今天重翻教程的时候才发现昨天漏了一节，今天补上。从这件小小的事情上我也明白了一个道理，学习不可一蹴而，都要一步一个脚印按部就班的去学习，按照教程原本的顺序一点一点去查缺补漏。想着提高速度而跳过某些章节，而你忽略的这些问题肯定会以其他各种各样的形式迸发出来。算是正式笔记前的一个小小说明吧。

            这篇笔记主要介绍了嵌入式ARMLinuxLED驱动开发。LED灯的驱动作为第一个要学习的外设，也是第一个字符设备，主要内容包括LED灯驱动原理、驱动程序及测试程序的编写以及运行测试。

            本笔记的思维导图如下：

    一、Linux下LED灯驱动原理

            Linux下的任何外设驱动，最终都是要配置相应的硬件寄存器。本节要驱动的LED，对应的IO口为GPIO1_IO03.

    1.地址映射

            MMU：内存管理单元。主要功能有两点：

            a.完成虚拟空间到物理空间的映射；

            b.内存保护，设置好存储器的访问权限，设置虚拟存储空间的缓冲特性。

            关于a，可以用下图进行说明：

            物理内存和虚拟内存之间的相互转换的两个函数为ioremap和iounmap.

    1）、ioremap函数

            ioremap函数用于获取指定物理地址空间对应的虚拟地址空间。其定义如下：

    1. 1 #define ioremap(cookie,size) __arm_ioremap((cookie), (size),
    2. MT_DEVICE)
    3. 2 
    4. 3
    5. void __iomem * __arm_ioremap(phys_addr_t phys_addr, size_t size,
    6. unsigned int mtype)
    7. 4 {
    8. 5 return arch_ioremap_caller(phys_addr, size, mtype,
    9. __builtin_return_address(0));
    10. 6 }

            上述代码真正起作用的是函数_arm_ioremap,其参数及返回值含义如下：

            phys_addr:要映射给的物理起始地址。

            size:要映射的内存空间大小。

            mtype:ioremap的类型，选择MT_DEVICE.

            返回值：_iomem类型的指针，指向映射后的虚拟空间首地址。  

            假设要获取I.MX6ULL的IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03寄存器对应的虚拟地址，使用如下代码：

    1. #define SW_MUX_GPIO1_IO03_BASE (0X020E0068)//物理地址
    2. static void __iomem* SW_MUX_GPIO1_IO03;//虚拟地址
    3. SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);//32位----4字节

    2）、iounmap函数

            卸载驱动的时候，使用iounmap函数释放掉ioremap函数所做的映射，其函数原型如下：

    void iounmap (volatile void __iomem *addr)

            addr为要取消的虚拟地址空间首地址。

            假设要取消I.MX6ULL的IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03寄存器对应的地址映射，使用如下代码：

    iounmap(SW_MUX_GPIO1_IO03);

    2.I/O内存访问函数

            当外部寄存器或内存映射到IO空间时，称为I/O端口。【ARM下没有这个概念】

            当外部寄存器或内存映射到内存空间时，称为I/O内存。

            Linux内核建议使用一组操作函数来对映射后的内存进行读写操作，而不是直接通过指针访问这些地址。

    1）、读操作函数

            读操作函数有如下几个：

    1. 1 u8 readb(const volatile void __iomem *addr)
    2. 2 u16 readw(const volatile void __iomem *addr)
    3. 3 u32 readl(const volatile void __iomem *addr)

            以上三个函数分别对应8bit、16bit、32bit读操作。

            addr就是要读取写内存地址。

            返回值就是读取到的数据。

    2）、写操作函数

            写操作函数有如下几个：

    1. 1 void writeb(u8 value, volatile void __iomem *addr)
    2. 2 void writew(u16 value, volatile void __iomem *addr)
    3. 3 void writel(u32 value, volatile void __iomem *addr)

            以上三个函数分别对应8bit、16bit、32bit读操作。

           value是要写入的数值。

            addr就是要写入的地址。

    二、程序编写

    1.实验程序编写

            通过控制开发板上I.MX6ULL的GPIO1_IO03引脚，从而控制LED灯的亮灭。

    1）、LED灯驱动程序编写

    1. 1 #include 
    2. 2 #include 
    3. 3 #include 
    4. 4 #include 
    5. 5 #include 
    6. 6 #include 
    7. 7 #include 
    8. 8 #include 
    9. 9 #include 
    10. 10 #include 
    11. 11 #include 
    12. 12 /***************************************************************
    13. 13 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
    14. 14 文件名 : led.c
    15. 15 作者 : 左忠凯
    16. 16 版本 : V1.0
    17. 17 描述 : LED 驱动文件。
    18. 18 其他 : 无
    19. 19 论坛 : www.openedv.com
    20. 20 日志 : 初版 V1.0 2019/1/30 左忠凯创建
    21. 21 ***************************************************************/
    22. 22 #define LED_MAJOR 200 /* 主设备号 */
    23. 23 #define LED_NAME "led" /* 设备名字 */
    24. 24
    25. 25 #define LEDOFF 0 /* 关灯 */
    26. 26 #define LEDON 1 /* 开灯 */
    27. 27
    28. 28 /* 寄存器物理地址 */
    29. 29 #define CCM_CCGR1_BASE (0X020C406C)
    30. 30 #define SW_MUX_GPIO1_IO03_BASE (0X020E0068)
    31. 31 #define SW_PAD_GPIO1_IO03_BASE (0X020E02F4)
    32. 32 #define GPIO1_DR_BASE (0X0209C000)
    33. 33 #define GPIO1_GDIR_BASE (0X0209C004)
    34. 34
    35. 35 /* 映射后的寄存器虚拟地址指针 */
    36. 36 static void __iomem *IMX6U_CCM_CCGR1;
    37. 37 static void __iomem *SW_MUX_GPIO1_IO03;
    38. 38 static void __iomem *SW_PAD_GPIO1_IO03;
    39. 39 static void __iomem *GPIO1_DR;
    40. 40 static void __iomem *GPIO1_GDIR;
    41. 41
    42. 42 /*
    43. 43 * @description : LED 打开/关闭
    44. 44 * @param - sta : LEDON(0) 打开 LED， LEDOFF(1) 关闭 LED
    45. 45 * @return : 无
    46. 46 */
    47. 47 void led_switch(u8 sta)
    48. 48 {
    49. 49 u32 val = 0;
    50. 50 if(sta == LEDON) {
    51. 51 val = readl(GPIO1_DR);
    52. 52 val &= ~(1 << 3);
    53. 53 writel(val, GPIO1_DR);
    54. 54 }else if(sta == LEDOFF) {
    55. 55 val = readl(GPIO1_DR);
    56. 56 val|= (1 << 3);
    57. 57 writel(val, GPIO1_DR);
    58. 58 }
    59. 59 }
    60. 60
    61. 61 /*
    62. 62 * @description : 打开设备
    63. 63 * @param – inode : 传递给驱动的 inode
    64. 64 * @param - filp : 设备文件， file 结构体有个叫做 private_data 的成员变量
    65. 65 * 一般在 open 的时候将 private_data 指向设备结构体。
    66. 66 * @return : 0 成功;其他 失败
    67. 67 */
    68. 68 static int led_open(struct inode *inode, struct file *filp)
    69. 69 {
    70. 70 return 0;
    71. 71 }
    72. 72
    73. 73 /*
    74. 74 * @description : 从设备读取数据
    75. 75 * @param - filp : 要打开的设备文件(文件描述符)
    76. 76 * @param - buf : 返回给用户空间的数据缓冲区
    77. 77 * @param - cnt : 要读取的数据长度
    78. 78 * @param - offt : 相对于文件首地址的偏移
    79. 79 * @return : 读取的字节数，如果为负值，表示读取失败
    80. 80 */
    81. 81 static ssize_t led_read(struct file *filp, char __user *buf,
    82. size_t cnt, loff_t *offt)
    83. 82 {
    84. 83 return 0;
    85. 84 }
    86. 85
    87. 86 /*
    88. 87 * @description : 向设备写数据
    89. 88 * @param - filp : 设备文件，表示打开的文件描述符
    90. 89 * @param - buf : 要写给设备写入的数据
    91. 90 * @param - cnt : 要写入的数据长度
    92. 91 * @param - offt : 相对于文件首地址的偏移
    93. 92 * @return : 写入的字节数，如果为负值，表示写入失败
    94. 93 */
    95. 94 static ssize_t led_write(struct file *filp, const char __user *buf,
    96. size_t cnt, loff_t *offt)
    97. 95 {
    98. 96 int retvalue;
    99. 97 unsigned char databuf[1];
    100. 98 unsigned char ledstat;
    101. 99
    102. 100 retvalue = copy_from_user(databuf, buf, cnt);
    103. 101 if(retvalue < 0) {
    104. 102 printk("kernel write failed!\r\n");
    105. 103 return -EFAULT;
    106. 104 }
    107. 105
    108. 106 ledstat = databuf[0]; /* 获取状态值 */
    109. 107
    110. 108 if(ledstat == LEDON) {
    111. 109 led_switch(LEDON); /* 打开 LED 灯 */
    112. 110 } else if(ledstat == LEDOFF) {
    113. 111 led_switch(LEDOFF); /* 关闭 LED 灯 */
    114. 112 }
    115. 113 return 0;
    116. 114 }
    117. 115
    118. 116 /*
    119. 117 * @description : 关闭/释放设备
    120. 118 * @param – filp : 要关闭的设备文件(文件描述符)
    121. 119 * @return : 0 成功;其他 失败
    122. 120 */
    123. 121 static int led_release(struct inode *inode, struct file *filp)
    124. 122 {
    125. 123 return 0;
    126. 124 }
    127. 125
    128. 126 /* 设备操作函数 */
    129. 127 static struct file_operations led_fops = {
    130. 128 .owner = THIS_MODULE,
    131. 129 .open = led_open,
    132. 130 .read = led_read,
    133. 131 .write = led_write,
    134. 132 .release = led_release,
    135. 133 };
    136. 134
    137. 135 /*
    138. 136 * @description : 驱动出口函数
    139. 137 * @param : 无
    140. 138 * @return : 无
    141. 139 */
    142. 140 static int __init led_init(void)
    143. 141 {
    144. 142 int retvalue = 0;
    145. 143 u32 val = 0;
    146. 144
    147. 145 /* 初始化 LED */
    148. 146 /* 1、寄存器地址映射 */
    149. 147 IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
    150. 148 SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
    151. 149 SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
    152. 150 GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
    153. 151 GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);
    154. 152
    155. 153 /* 2、使能 GPIO1 时钟 */
    156. 154 val = readl(IMX6U_CCM_CCGR1);
    157. 155 val &= ~(3 << 26); /* 清除以前的设置 */
    158. 156 val |= (3 << 26); /* 设置新值 */
    159. 157 writel(val, IMX6U_CCM_CCGR1);
    160. 158
    161. 159 /* 3、设置 GPIO1_IO03 的复用功能，将其复用为
    162. 160 * GPIO1_IO03，最后设置 IO 属性。
    163. 161 */
    164. 162 writel(5, SW_MUX_GPIO1_IO03);
    165. 163
    166. 164 /* 寄存器 SW_PAD_GPIO1_IO03 设置 IO 属性 */
    167. 165 writel(0x10B0, SW_PAD_GPIO1_IO03);
    168. 166
    169. 167 /* 4、设置 GPIO1_IO03 为输出功能 */
    170. 168 val = readl(GPIO1_GDIR);
    171. 169 val &= ~(1 << 3); /* 清除以前的设置 */
    172. 170 val |= (1 << 3); /* 设置为输出 */
    173. 171 writel(val, GPIO1_GDIR);
    174. 172
    175. 173 /* 5、默认关闭 LED */
    176. 174 val = readl(GPIO1_DR);
    177. 175 val |= (1 << 3);
    178. 176 writel(val, GPIO1_DR);
    179. 177
    180. 178 /* 6、注册字符设备驱动 */
    181. 179 retvalue = register_chrdev(LED_MAJOR, LED_NAME, &led_fops);
    182. 180 if(retvalue < 0){
    183. 181 printk("register chrdev failed!\r\n");
    184. 182 return -EIO;
    185. 183 }
    186. 184 return 0;
    187. 185 }
    188. 186
    189. 187 /*
    190. 188 * @description : 驱动出口函数
    191. 189 * @param : 无
    192. 190 * @return : 无
    193. 191 */
    194. 192 static void __exit led_exit(void)
    195. 193 {
    196. 194 /* 取消映射 */
    197. 195 iounmap(IMX6U_CCM_CCGR1);
    198. 196 iounmap(SW_MUX_GPIO1_IO03);
    199. 197 iounmap(SW_PAD_GPIO1_IO03);
    200. 198 iounmap(GPIO1_DR);
    201. 199 iounmap(GPIO1_GDIR);
    202. 200
    203. 201 /* 注销字符设备驱动 */
    204. 202 unregister_chrdev(LED_MAJOR, LED_NAME);
    205. 203 }
    206. 204
    207. 205 module_init(led_init);
    208. 206 module_exit(led_exit);
    209. 207 MODULE_LICENSE("GPL");
    210. 208 MODULE_AUTHOR("zuozhongkai");

            在上述的代码中，关于LED初始化有以下几步：

            （1）寄存器地址映射。

            （2）使能GPIO1时钟。

            （3）设置GPIO1_IO03复用功能。

            （4）设置设置GPIO1_IO03输出功能。

            （5）默认关闭LED。

            （6）注册字符设备驱动。

    2）、测试程序APP编写

            led驱动加载成功以后，手动创建/dev/led节点，应用APP通过操作/dev/led文件来完成对LED设备的控制，向/dev/led写0表示关闭LED灯，写1表示打开LED灯。新建ledApp.c文件，其内容如下：

    1. 1 #include "stdio.h"
    2. 2 #include "unistd.h"
    3. 3 #include "sys/types.h"
    4. 4 #include "sys/stat.h"
    5. 5 #include "fcntl.h"
    6. 6 #include "stdlib.h"
    7. 7 #include "string.h"
    8. 8 /***************************************************************
    9. 9 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
    10. 10 文件名 : ledApp.c
    11. 11 作者 : 左忠凯
    12. 12 版本 : V1.0
    13. 13 描述 : LED 驱测试 APP。
    14. 14 其他 : 无
    15. 15 使用方法 ： ./ledtest /dev/led 0 关闭 LED
    16. 16 ./ledtest /dev/led 1 打开 LED
    17. 17 论坛 : www.openedv.com
    18. 18 日志 : 初版 V1.0 2019/1/30 左忠凯创建
    19. 19 ***************************************************************/
    20. 20
    21. 21 #define LEDOFF 0
    22. 22 #define LEDON 1
    23. 23
    24. 24 /*
    25. 25 * @description : main 主程序
    26. 26 * @param - argc : argv 数组元素个数
    27. 27 * @param - argv : 具体参数
    28. 28 * @return : 0 成功;其他 失败
    29. 29 */
    30. 30 int main(int argc, char *argv[])
    31. 31 {
    32. 32 int fd, retvalue;
    33. 33 char *filename;
    34. 34 unsigned char databuf[1];
    35. 35
    36. 36 if(argc != 3){
    37. 37 printf("Error Usage!\r\n");
    38. 38 return -1;
    39. 39 }
    40. 40
    41. 41 filename = argv[1];
    42. 42
    43. 43 /* 打开 led 驱动 */
    44. 44 fd = open(filename, O_RDWR);
    45. 45 if(fd < 0){
    46. 46 printf("file %s open failed!\r\n", argv[1]);
    47. 47 return -1;
    48. 48 }
    49. 49
    50. 50 databuf[0] = atoi(argv[2]); /* 要执行的操作：打开或关闭 */
    51. 51
    52. 52 /* 向/dev/led 文件写入数据 */
    53. 53 retvalue = write(fd, databuf, sizeof(databuf));
    54. 54 if(retvalue < 0){
    55. 55 printf("LED Control Failed!\r\n");
    56. 56 close(fd);
    57. 57 return -1;
    58. 58 }
    59. 59
    60. 60 retvalue = close(fd); /* 关闭文件 */
    61. 61 if(retvalue < 0){
    62. 62 printf("file %s close failed!\r\n", argv[1]);
    63. 63 return -1;
    64. 64 }
    65. 65 return 0;
    66. 66 }

            上述内容是对led的驱动文件最基本的打开、关闭、写操作等。

    三、运行测试

    1.编译驱动程序和测试程序

    1）、编译驱动程序

            用到的Makefile文件内容如下：

    1. 1 KERNELDIR := /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imxrel_imx_4.1.15_2.1.0_ga_alientek
    2. ......
    3. 4 obj-m := led.o
    4. ......
    5. 11 clean:
    6. 12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

    输入如下指令生成.ko模块文件。

    make -j32

    2）、编译测试程序

            用到如下指令：

    arm-linux-gnueabihf-gcc ledApp.c -o ledApp

            编译成功以后会得到ledApp这个应用程序。

    2.运行测试

            将编译出来的led.ko和ledApp这两个文件拷贝到rootfs/lib/modules/4.1.15目录中，重启开发板，进入到rootfs/lib/modules/4.1.15目录，输入如下命令加载led.ko驱动模块：

    1. depmod//第一次加载驱动时需要运行该命令
    2. modprobe led.ko//加载驱动

    创建/dev/led设备节点，命令如下：

    mknod /dev/led c 200 0

    之后，使用如下命令测试驱动是否正常：

    1. ./ledAPP /dev/led 1 //打开LED灯
    2.  
    3. ./ledAPP /dev/led 0//关闭LED灯

            观察LED的亮暗变化，判断驱动程序是否正常。

            最后一步，驱动卸载，使用如下指令：

    rmmod led.ko

          四、总结  

            总结一下，本笔记主要学习了ARMLinuxLED驱动开发的方式方法，介绍了通过类似裸机开发，通过控制寄存器从而使LED打开或关闭的方法。

    Linux版本号4.1.15   芯片MX6ULL

    本文为参考正点原子开发板配套教程整理而得，仅用于学习交流使用，不得用于商业用途。

  • 相关阅读:
    前端进击笔记第二十一节 如何搭建前端监控体系为业务排忧解难？
    洛谷千题详解 | P1018 [NOIP2000 提高组] 乘积最大【C++、Python、Java、pascal语言】
    Flink学习（七）-单词统计
    Spring 源码阅读 04：BeanFactory 初始化
    Java HashMap 实现线程安全
    Windows版本Node.js简单安装配置详细教程（小白入门必备）
    进程(详解)
    【图灵诸葛】jvm笔记
    关于面试题
    YOLOv5的Tricks | 【Trick11】在线模型训练可视化工具wandb(Weights & Biases)
  • 原文地址：https://blog.csdn.net/jiage987450/article/details/132839169