• 驱动开发4 使用字符设备驱动的分步实现编写LED驱动（LED亮灯）

    一、思维导图

    二、通过字符设备驱动的分步实现编写LED驱动，另外实现特备文件和设备的绑定

    应用程序 test.c

    1. #include
    2. #include
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include
    8. #include
    9. #include "head.h"
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     char buf[128]={0};
    14.     int a;
    15.     int fd=open("/dev/mycdev0",O_RDWR);
    16.     if(fd<0)
    17.     {
    18.         printf("打开设备文件失败\n");
    19.         exit(-1);
    20.     }
    21.     while(1)
    22.     {
    23.         //从终端读取
    24.         printf("请输入要实现的功能 ");
    25.         printf("0(关灯) 1(开灯)\n");
    26.         printf("请输入>");
    27.         scanf("%d",&a);
    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.     close(fd);
    39.     return 0;
    40. }

    头文件 head.h

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. typedef struct
    4. {
    5.     unsigned int MODER;
    6.     unsigned int OTYPER;
    7.     unsigned int OSPEEDR;
    8.     unsigned int PUPDR;
    9.     unsigned int IDR;
    10.     unsigned int ODR;
    11. }gpio_t;
    12. #define PHY_LED1_ADDR 0X50006000
    13. #define PHY_LED2_ADDR 0X50007000
    14. #define PHY_LED3_ADDR 0X50006000
    15. #define PHY_RCC_ADDR 0X50000A28
    16. // 构建开灯关灯的功能码
    17. #define LED_ON _IO('l', 1)
    18. #define LED_OFF _IO('l', 0)
    19. #endif

    驱动程序 mycdev.c

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

    Makefile

    1. modname ?= demo
    2. arch ?= arm
    3. ifeq ($(arch),arm)  #通过命令行传过来的架构决定怎么编译
    4. #KERBELDIR保存开发板内核源码路径
    5. KERNELDIR := /home/ubuntu/FSMP1A/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61
    6. else
    7. #保存UBUNTU内核源码路径
    8. KERNELDIR := /lib/modules/$(shell uname -r)/build
    9. endif
    10.  
    11. #PWD保存当前内核模块的路径
    12. PWD := $(shell pwd)
    13. all:
    14. #make modules是模块化编译命令
    15. #make -C $(KERNLEDIR) 执行make之前先切换到KERNELDIR对应的路径
    16. #M=$(PWD)表示进行模块化编译的路径是PWD保存的路径
    17. 	make -C $(KERNELDIR) M=$(PWD) modules
    18. clean:
    19. #编译清除
    20. 	make -C $(KERNELDIR) M=$(PWD) clean
    21. #将obj-m保存的文件单独链接为内核模块
    22. obj-m :=  $(modname).o

    效果实现

  • 相关阅读:
    8月更新 | Java on Azure Tooling
    电脑系统没有standard tcp/ip port端口的处理操作
    ElementUI validate 验证结果错误的问题解决过程
    2022 年首届钉钉杯大学生大数据挑战赛初赛的Baseline
    01 【版本控制和Git的安装介绍】
    Linux下安装Docker（centOS 8）
    一家公司做了两年软件测试，只会功能测试，现在已经感到危机感了，那如何摆脱困境呢？
    研究生总结
    Master PDF Editor v5.9.70便携版
    2017年网易校招Java面试题
  • 原文地址：https://blog.csdn.net/Smallxu_/article/details/133997194