• linux驱动开发--day4（字符设备驱动注册内部流程、及实现备文件和设备的绑定下LED灯实验）

    一、字符设备驱动注册的内部过程

    1.分配struct cdev对象空间

    2.初始化struct cdev对象

    3.注册cdev对象

    二、注册字符设备驱动分步实现

    1.分配字符设备驱动对象

    2.字符设备驱动对象初始化

    3.设备号的申请

    4.根据申请的设备号和驱动对象注册驱动

    三、open函数回调驱动中操作方法open的路线

    1.应用层打开文件系统中的存在文件，会有inode号，且系统内核中就会存在一个inode对象（struct inode）保存文件相关信息

    2.inode对象里字符设备结构体成员（struct cdev）里，有操作方法结构体成员（struct file_operations *ops）

    3.操作方法结构体中会调用VFS(虚拟文件系统层)中sys_open()得到文件描述符，申请file对象并填充，根据路线再回调驱动中的open操作方法

    四、通过文件描述符回调驱动操作的路线

    1.因为文件描述符依赖进程存在，只要进程加载到系统上，系统内核就存在task_struct对象描述进程信息

    2.在进程里打开一个文件，内核就会存在一个struct file对象，用于保存打开文件的信息

    3.struct file对象的成员里fd_array数组保存的每个成员是打开的文件的相关信息

    4.数组每个成员都是struct file类型，存储的是打开文件的相关信息，里面有操作方法结构体（驱动中的操作方法）去驱使硬件实现特定功能

    任务：

    通过字符设备驱动分步注册方式编写LED驱动，完成设备文件和设备的绑定
    cdev)_led.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<linux/io.h>
    9. #include"head.h"
    10.  
    11. struct cdev* cdev;
    12. unsigned int major=0;
    13. unsigned int minor=0;
    14. dev_t devno;
    15. module_param(major,uint,0664);
    16. struct class* cls;
    17. struct device* dev;
    18. gpio_t *vir_led1;
    19. gpio_t *vir_led2;
    20. gpio_t *vir_led3;
    21. unsigned int *vir_rcc;
    22. //封装操作的方法
    23. int mycdev_open(struct inode *inode, struct file *file)
    24. {
    25.     int min=MINOR(inode->i_rdev);
    26.     file->private_data=(void *)min;
    27.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    28.     return 0;
    29. }
    30. long mydev_ioctl(struct file* file,unsigned int cmd,unsigned long arg)
    31. {
    32.     int min=(int)file->private_data;
    33.     switch(min)
    34.     {
    35.         case 0: //控制LED1
    36.             switch(cmd)
    37.             {
    38.                 case LED_ON:  //开灯
    39.                     vir_led1->ODR |= 1<<10;
    40.                     break;
    41.                 case LED_OFF: //关灯
    42.                     vir_led1->ODR &= (~(1<<10));
    43.                     break;
    44.             }
    45.             break;
    46.         case 1:  //控制LED2
    47.             switch(cmd)
    48.             {
    49.                 case LED_ON:  //开灯
    50.                     vir_led2->ODR |= 1<<10;
    51.                     break;
    52.                 case LED_OFF: //关灯
    53.                     vir_led2->ODR &= (~(1<<10));
    54.                     break;
    55.             }
    56.             break;
    57.         case 2:  //控制LED3
    58.             switch(cmd)
    59.             {
    60.                 case LED_ON:  //开灯
    61.                     vir_led3->ODR |= 1<<8;
    62.                     break;
    63.                 case LED_OFF: //关灯
    64.                     vir_led3->ODR &= (~(1<<8));
    65.                     break;
    66.             }
    67.             break;
    68.     }
    69.     return 0;
    70. }
    71.  
    72. int mycdev_close(struct inode *inode, struct file *file)
    73. {
    74.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    75.     return 0;
    76. }
    77.  
    78. //定义操作方法结构体变量并赋值
    79. struct file_operations fops={
    80.  
    81.     .open=mycdev_open,
    82.     .unlocked_ioctl=mydev_ioctl,
    83.     .release=mycdev_close,
    84. };
    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.  
    129. static int __init mycdev_init(void)
    130. {
    131.      int ret;
    132.     //为字符设备驱动对象申请空间
    133.     cdev=cdev_alloc();
    134.     if(cdev==NULL)
    135.     {
    136.         printk("字符设备驱动对象申请空间失败\n");
    137.         ret=-EFAULT;
    138.         goto out1;
    139.     }
    140.     printk("申请对象空间成功\n");
    141.     //初始化字符设备驱动对象
    142.     cdev_init(cdev,&fops);
    143.     //申请设备号
    144.     if(major>0)//静态指定设备号
    145.     {
    146.         ret=register_chrdev_region(MKDEV(major,minor),3,"myled");
    147.         if(ret)
    148.         {
    149.             printk("静态申请设备号失败\n");
    150.             goto out2;
    151.         }
    152.     }
    153.     else if(major==0)//动态申请设备号
    154.     {
    155.         ret=alloc_chrdev_region(&devno,minor,3,"myled");
    156.         if(ret)
    157.         {
    158.             printk("动态申请设备号失败\n");
    159.             goto out2;
    160.         }
    161.         major=MAJOR(devno);//获取主设备号
    162.         minor=MINOR(devno);//获取次设备号
    163.  
    164.     }
    165.     printk("申请设备号成功\n");
    166.     //注册字符设备驱动对象
    167.     ret=cdev_add(cdev,MKDEV(major,minor),3);
    168.     if(ret)
    169.     {
    170.         printk("注册字符设备驱动对象失败\n");
    171.         goto out3;
    172.     }
    173.     printk("注册字符设备驱动对象成功\n");
    174.  
    175.     //寄存器映射以及初始化
    176.     all_led_init();
    177.  
    178.     //向上提交目录信息
    179.     cls=class_create(THIS_MODULE,"myled");
    180.     if(IS_ERR(cls))
    181.     {
    182.         printk("向上提交目录失败\n");
    183.         ret=-PTR_ERR(cls);
    184.         goto out4;
    185.     }
    186.     printk("向上提交目录成功\n");
    187.     //向上提交设备节点信息
    188.     int i;
    189.     for(i=0;i<3;i++)
    190.     {
    191.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    192.         if(IS_ERR(dev))
    193.         {
    194.             printk("向上提交设备节点信息失败\n");
    195.             ret=-PTR_ERR(dev);
    196.             goto out5;
    197.         }
    198.     }
    199.     printk("向上提交设备信息成功\n");
    200.     return 0;
    201. out5:
    202.     //释放前一次提交成功的设备信息
    203.     for(--i;i>=0;i--)
    204.     {
    205.         device_destroy(cls,MKDEV(major,i));
    206.     }
    207.     class_destroy(cls);//释放目录
    208. out4:
    209.     cdev_del(cdev);
    210. out3:
    211.     unregister_chrdev_region(MKDEV(major,minor),3);
    212. out2:
    213.     kfree(cdev);
    214. out1:
    215.     return ret;
    216.  
    217.  
    218.  
    219. }
    220. static void __exit mycdev_exit(void)
    221. {
    222.     //取消地址映射
    223.     iounmap(vir_led1);
    224.     iounmap(vir_led2);
    225.     iounmap(vir_rcc);
    226.     //释放节点信息
    227.     int i;
    228.     for(i=0;i<3;i++)
    229.     {
    230.         device_destroy(cls,MKDEV(major,i));
    231.     }
    232.     //销毁目录
    233.     class_destroy(cls);
    234.     //注销驱动对象
    235.     cdev_del(cdev);
    236.     //释放设备号
    237.     unregister_chrdev_region(MKDEV(major,minor),3);
    238.     //释放对象空间
    239.     kfree(cdev);
    240.  
    241. }
    242. module_init(mycdev_init);
    243. module_exit(mycdev_exit);
    244. 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 <sys/ioctl.h>
    9. #include "head.h"
    10. int main(int argc, const char *argv[])
    11. {
    12. 	char buf[128] = "";
    13. 	int a;
    14. 	int fd;
    15. 	while (1)
    16. 	{
    17. 	printf("请选择要打开的灯(1,2,3)\n");
    18. 	scanf(" %d", &a);
    19. 	switch (a)
    20. 	{
    21. 	case 1:
    22. 		fd = open("/dev/myled0", O_RDWR);
    23. 		if (fd < 0)
    24. 		{
    25. 			printf("设备文件打开失败\n");
    26. 			exit(-1);
    27. 		}
    28. 		printf("打开文件myled0成功\n");
    29. 		break;
    30. 	case 2:
    31. 		fd = open("/dev/myled1", O_RDWR);
    32. 		if (fd < 0)
    33. 		{
    34. 			printf("设备文件打开失败\n");
    35. 			exit(-1);
    36. 		}
    37. 		printf("打开文件myled1成功\n");
    38. 		break;
    39. 	case 3:
    40. 		fd = open("/dev/myled2", O_RDWR);
    41. 		if (fd < 0)
    42. 		{
    43. 			printf("设备文件打开失败\n");
    44. 			exit(-1);
    45. 		}
    46. 		printf("打开文件myled2成功\n");
    47. 		break;
    48. 		default:
    49. 			printf("请输入范围内的数\n");
    50. 	}
    51. 	
    52. 		int b;
    53. 		printf("请开灯关灯(0/1)\n");
    54. 		scanf(" %d",&b);
    55. 		switch(b)
    56. 		{
    57. 			case 1:
    58. 				ioctl(fd,LED_ON);
    59. 				break;
    60. 			case 0:
    61. 				ioctl(fd,LED_OFF);
    62. 				break;
    63. 			default:
    64. 				printf("请输入'0'或'1'\n");
    65. 		}
    66. 		close(fd);
    67. 		printf("关闭文件\n");		
    68. 	}
    69. 	
    70. 	return 0;
    71. }
    head.h:
    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__ 
    3. typedef struct{
    4.     unsigned int MODER;
    5.     unsigned int OTYPER;
    6.     unsigned int OSPEEDR;
    7.     unsigned int PUPDR;
    8.     unsigned int IDR;
    9.     unsigned int ODR;
    10. }gpio_t;
    11. #define PHY_LED1_ADDR 0X50006000
    12. #define PHY_LED2_ADDR    0X50007000
    13. #define PHY_LED3_ADDR 0X50006000
    14. #define PHY_RCC_ADDR    0X50000A28
    15.  
    16. //构建LED开关功能码
    17. #define LED_ON _IO('l',1)
    18. #define LED_OFF _IO('l',0)
    19. #endif
    测试现象：

  • 相关阅读:
    springboot 引入nacos
    【计算机视觉（CV）】基于高层API实现宝石分类
    【java学习—八】==操作符与equals方法（2）
    网络编程与HTTP协议
    4创建iSCSI共享存储
    VoIP Push 在海外音视频业务中的应用
    【HDU No. 4902】 数据结构难题 Nice boat
    GMSL自学笔记
    react设置代理
    【服务器数据恢复】RAID6中3块磁盘离线崩溃的数据恢复案例
  • 原文地址：https://blog.csdn.net/m0_72852022/article/details/132858507