• 驱动开发--字符设备驱动的实现

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

    通过对register_chrdev内部的实现过程进行分析，其实注册字符设备驱动的过程就是下面几步：

    1.分配struct cdev对象空间

    2.初始化struct cdev对象

    3.注册cdev对象

    完成上面的三步，就完成了字符设备驱动的注册。

    二、通过字符设备驱动分步注册方式编写LED驱动，完成设备文件和设备的绑定

    头文件

    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 
    20.

    测试文件

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    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. }
    72.

    驱动文件

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

  • 相关阅读:
    1002 A+B for Polynomials
    02、RocketMQ -- 应用场景、核心概念
    全是狠活！SpringBoot文档也太那个了，图文并茂详尽讲解
    java 多线程（）—— 线程同步=队列+锁
    PyTorch深度学习实战（15）——迁移学习
    使用CXF调用WSDL（二）
    Jmeter连接mysql数据库详细步骤
    CentOS Stream 9 配置静态 IP
    面试：Sqlite的线程、进程安全性
    Java封装
  • 原文地址：https://blog.csdn.net/m0_62774039/article/details/132864038