• 驱动开发，stm32mp157a开发板的led灯控制实验(再优化)，使用ioctl函数，通过字符设备驱动分步注册方式编写LED驱动，完成设备文件和设备的绑定

     1.实验目的

            编写LED灯的驱动，在应用程序中编写控制LED灯亮灭的代码逻辑实现LED灯功能的控制；

     

     2. LED灯相关寄存器分析

     

    LED1->PE10 LED1亮灭：

    RCC寄存器[4]->1 0X50000A28

    GPIOE_MODER[21:20]->01 (输出) 0X50006000

    GPIOE_ODR[10]->1(输出高电平) 0（输出低电平）0X50006014

    LED2->PF10 LED2亮灭：

    RCC寄存器[5]->1 0X50000A28

    GPIOE_MODER[21:20]->01 (输出) 0X50006000

    GPIOE_ODR[10]->1(输出高电平) 0（输出低电平）0X50006014

    LED3->PE8 LED3亮灭：

    RCC寄存器[4]->1 0X50000A28

    GPIOE_MODER[17:16]->01 (输出) 0X50006000

    GPIOE_ODR[8]->1(输出高电平) 0（输出低电平）0X50006014

    GPIOE_OTYPER默认为00

    GPIOE_PUPDR默认为0

    GPIOE_OSPEEDR默认为00

     

     3.字符设备驱动内部注册过程 

    • 分配struct cdev对象空间
    • 初始化struct cdev对象
    • 设备号的申请（静态/动态申请）

    • 注册cdev对象

     

     4.编写代码

    ---Makefile---工程管理文件

    1. modname?=demo
    2. arch?=arm
    3. ifeq ($(arch),arm)
    4. KERNELDIR:= /home/ubuntu/FSMP1A/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61 #编译生成ARM架构
    5. else
    6. KERNELDIR:=/lib/modules/$(shell uname -r)/build #编译生成X86架构
    7. endif
    8.  
    9. PWD:=$(shell pwd) #模块化编译文件路径
    10. all:
    11. 	make -C $(KERNELDIR) M=$(PWD) modules
    12. clean:
    13. 	make -C $(KERNELDIR) M=$(PWD) clean
    14.  
    15. obj-m:=$(modname).o

    ---head.h---头文件

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3.  
    4. typedef struct
    5. {
    6.     unsigned int MODER;
    7.     unsigned int OTYPER;
    8.     unsigned int OSPEEDR;
    9.     unsigned int PUPDR;
    10.     unsigned int IDR;
    11.     unsigned int ODR;   
    12. }gpio_t;
    13.  
    14. //LED1和LED3寄存器地址
    15. #define LED1_ADDR 0x50006000
    16. #define LED2_ADDR 0x50007000
    17. #define LED3_ADDR 0x50006000
    18. #define RCC_ADDR 0x50000A28
    19.  
    20. //构建LED开关功能码,不添加ioctl第三个参数
    21. #define LED_ON _IO('l',1)
    22. #define LED_OFF _IO('l',0)
    23.  
    24.  
    25. #endif

    ---cdev.c---驱动程序

    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/cdev.h>
    4. #include <linux/fs.h>
    5. #include <linux/device.h>
    6. #include <linux/uaccess.h>
    7. #include <linux/slab.h>
    8. #include "head.h"
    9. #include <linux/io.h>
    10.  
    11. struct cdev *cdev = NULL;
    12. unsigned major = 0;
    13. unsigned minor = 0;
    14. module_param(major, uint, 0664); // 方便再命令行传递major的值
    15. dev_t devno;
    16. struct class *cls;
    17. struct device *dev;
    18. char kbuf[128] = {0};
    19. gpio_t *vir_led1;
    20. gpio_t *vir_led2;
    21. gpio_t *vir_led3;
    22. unsigned int *vir_rcc;
    23.  
    24. // 封装操作方法
    25. int mycdev_open(struct inode *inode, struct file *file)
    26. {
    27.     // 设备文件和设备的绑定
    28.     // 根据打开的文件对应的设备号获取 次设备号
    29.     int min = MINOR(inode->i_rdev);
    30.     file->private_data = (void *)min;
    31.  
    32.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    33.     return 0;
    34. }
    35.  
    36. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    37. {
    38.     int min = (int)file->private_data;
    39.     switch (min)
    40.     {
    41.     case 0: // 控制LED1
    42.         switch (cmd)
    43.         {
    44.         case LED_ON: // 开灯
    45.             vir_led1->ODR |= (0x1 << 10);
    46.             break;
    47.         case LED_OFF: // 关灯
    48.             vir_led1->ODR &= (~(0x1 << 10));
    49.             break;
    50.         }
    51.         break;
    52.  
    53.     case 2: // 控制LED2
    54.         switch (cmd)
    55.         {
    56.         case LED_ON: // 开灯
    57.             vir_led2->ODR |= (0x1 << 10);
    58.             break;
    59.         case LED_OFF: // 关灯
    60.             vir_led2->ODR &= (~(0x1 << 10));
    61.             break;
    62.         }
    63.         break;
    64.  
    65.     case 3: // 控制LED3
    66.         switch (cmd)
    67.         {
    68.         case LED_ON: // 开灯
    69.             vir_led3->ODR |= (0x1 << 8);
    70.             break;
    71.         case LED_OFF: // 关灯
    72.             vir_led3->ODR &= (~(0x1 << 8));
    73.             break;
    74.         }
    75.         break;
    76.     }
    77.  
    78.     return 0;
    79. }
    80.  
    81. int mycdev_close(struct inode *inode, struct file *file)
    82. {
    83.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    84.     return 0;
    85. }
    86.  
    87. struct file_operations fops = {
    88.     .open = mycdev_open,
    89.     .unlocked_ioctl = mycdev_ioctl,
    90.     .release = mycdev_close,
    91. };
    92.  
    93. // 相关寄存器地址映射及初始化
    94. int all_led_init(void)
    95. {
    96.     // 相关寄存器的内存映射
    97.     vir_led1 = ioremap(LED1_ADDR, sizeof(gpio_t));
    98.     if (vir_led1 == NULL)
    99.     {
    100.         printk("物理内存映射失败%d\n", __LINE__);
    101.         return -ENOMEM;
    102.     }
    103.  
    104.     vir_led2 = ioremap(LED2_ADDR, sizeof(gpio_t));
    105.     if (vir_led2 == NULL)
    106.     {
    107.         printk("物理内存映射失败%d\n", __LINE__);
    108.         return -ENOMEM;
    109.     }
    110.  
    111.     vir_led3 = vir_led1;
    112.  
    113.     vir_rcc = ioremap(RCC_ADDR, 4);
    114.     if (vir_rcc == NULL)
    115.     {
    116.         printk("物理内存映射失败%d\n", __LINE__);
    117.         return -ENOMEM;
    118.     }
    119.     printk("寄存器内存映射成功\n");
    120.  
    121.     // 硬件寄存器的初始化
    122.     (*vir_rcc) |= (0x3 << 4);
    123.  
    124.     // LED1
    125.     vir_led1->MODER &= (~(0x3 << 20));
    126.     vir_led1->MODER |= (0x1 << 20);
    127.     vir_led1->ODR &= (~(0x1 << 10));
    128.  
    129.     // LED2
    130.     vir_led2->MODER &= (~(0x3 << 20));
    131.     vir_led2->MODER |= (0x1 << 20);
    132.     vir_led2->ODR &= (~(0x1 << 10));
    133.  
    134.     // LED3
    135.     vir_led3->MODER &= (~(0x3 << 16));
    136.     vir_led3->MODER |= (0x1 << 16);
    137.     vir_led3->ODR &= (~(0x1 << 8));
    138.  
    139.     printk("寄存器初始化成功\n");
    140.     return 0;
    141. }
    142.  
    143.  
    144. static int __init mycdev_init(void)
    145. {
    146.     int ret;
    147.     // 分配字符设备驱动对象空间
    148.     cdev = cdev_alloc();
    149.     if (cdev == NULL)
    150.     {
    151.         printk("字符设备驱动对象申请空间失败\n");
    152.         ret = -EFAULT;
    153.         goto out1;
    154.     }
    155.     printk("字符设备驱动对象申请空间成功\n");
    156.  
    157.     // 字符设备驱动对象初始化
    158.     cdev_init(cdev, &fops);
    159.  
    160.     // 设备号的申请
    161.     if (major > 0) // 静态指定设备号
    162.     {
    163.         ret = register_chrdev_region(MKDEV(major, minor), 3, "myled");
    164.         if (ret)
    165.         {
    166.             printk("静态申请设备号失败\n");
    167.             goto out2;
    168.         }
    169.     }
    170.     else if (major == 0) 动态申请设备号
    171.     {
    172.         ret = alloc_chrdev_region(&devno, minor, 3, "myled");
    173.         if (ret)
    174.         {
    175.             printk("静态申请设备号失败\n");
    176.             goto out2;
    177.         }
    178.         major = MAJOR(devno);
    179.         minor = MINOR(devno);
    180.     }
    181.     printk("申请设备号成功\n");
    182.  
    183.     // 注册字符设备驱动对象
    184.     ret = cdev_add(cdev, MKDEV(major, minor), 3);
    185.     if (ret)
    186.     {
    187.         printk("注册字符设备驱动对象失败\n");
    188.         goto out3;
    189.     }
    190.     printk("注册字符设备驱动对象成功\n");
    191.  
    192.      相关寄存器地址映射及初始化
    193.     all_led_init();
    194.  
    195.     // 向上提交目录信息
    196.     cls = class_create(THIS_MODULE, "myled");
    197.     if (IS_ERR(cls))
    198.     {
    199.         printk("向上提交目录信息失败\n");
    200.         ret = -PTR_ERR(cls);
    201.         goto out4;
    202.     }
    203.     printk("向上提交目录信息成功\n");
    204.  
    205.     // 向上提交设备节点信息
    206.     int i;
    207.     for (i = 0; i < 3; i++)
    208.     {
    209.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    210.         if (IS_ERR(dev))
    211.         {
    212.             printk("向上提交设备节点信息失败\n");
    213.             ret = -PTR_ERR(dev);
    214.             goto out5;
    215.         }
    216.     }
    217.     printk("向上提交设备节点信息成功\n");
    218.  
    219.     return 0;
    220. out5:
    221.     // 释放前一次提交的设备信息
    222.     for (--i; i >= 0; i--)
    223.     {
    224.         device_destroy(cls, MKDEV(major, i));
    225.     }
    226.     class_destroy(cls); // 释放目录信息
    227. out4:
    228.     cdev_del(cdev);
    229. out3:
    230.     unregister_chrdev_region(MKDEV(major, minor), 3);
    231. out2:
    232.     kfree(cdev);
    233. out1:
    234.     return ret;
    235. }
    236.  
    237. static void __exit mycdev_exit(void)
    238. {
    239.     // 释放节点信息
    240.     int i;
    241.     for (i = 0; i < 3; i++)
    242.     {
    243.         device_destroy(cls, MKDEV(major, i));
    244.     }
    245.     // 销毁目录
    246.     class_destroy(cls);
    247.     // 注销驱动对象
    248.     cdev_del(cdev);
    249.     // 释放申请的设备号和设备资源
    250.     unregister_chrdev_region(MKDEV(major, minor), 3);
    251.     // 释放字符设备驱动对象空间
    252.     kfree(cdev);
    253.  
    254.     // 取消物理内存的映射
    255.     iounmap(vir_led1);
    256.     iounmap(vir_led2);
    257.     iounmap(vir_rcc);
    258. }
    259. module_init(mycdev_init);
    260. module_exit(mycdev_exit);
    261. MODULE_LICENSE("GPL");

    ---test.c---应用程序测试程序

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/stat.h>
    4. #include <fcntl.h>
    5. #include <unistd.h>
    6. #include <stdlib.h>
    7. #include <string.h>
    8. #include "head.h"
    9. #include <sys/ioctl.h>
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     int a;
    14.     char buf[128] = {0};
    15.     int fd = open("/dev/myled0", O_RDWR);
    16.  
    17.     if (fd < 0)
    18.     {
    19.         printf("设备文件打开失败\n");
    20.         exit(-1);
    21.     }
    22.     while (1)
    23.     {
    24.         printf("请输入对LED灯的控制：1(开灯) 0(关灯)>> ");
    25.         scanf("%d",&a);
    26.         getchar();
    27.  
    28.         switch (a)
    29.         {
    30.         case 1:
    31.             ioctl(fd, LED_ON); // 第三个参数为指针
    32.             break;
    33.         case 0:
    34.             ioctl(fd, LED_OFF);
    35.             break;
    36.         }
    37.     }
    38.  
    39.     close(fd);
    40.  
    41.     return 0;
    42. }

     

    5.测试现象

             int fd = open("/dev/myled0", O_RDWR);

            测试程序中只打开一个设备文件，对应LED1的次设备号，所以只控制LED1灯的亮灭

  • 相关阅读:
    Nifi01概念
    微信小程序分享、转发朋友、分享朋友圈使用整理
    css3的attr函数使用，加载unicode矢量图标
    机器学习算法 —— 1. K近邻算法
    容错限流框架之Hystrix上
    Flask学习笔记（七）
    专属程序员的浪漫七夕
    AUGMENTING LOGICAL REASONING CAPABILITIES WITH LARGE LANGUAGE MODELS
    3D数字孪生：从3D数据采集到3D内容分析
    Linux--socket编程--服务端代码
  • 原文地址：https://blog.csdn.net/weixin_46260677/article/details/132864440