• 嵌入式：驱动开发 Day7

    作业：基于GPIO子系统，编写LED的驱动程序和应用程序

    驱动程序：myled.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include "head.h"
    13.  
    14. struct cdev *cdev;
    15. unsigned int major = 0;
    16. unsigned int minor = 0;
    17. dev_t devno;
    18. module_param(major, uint, 0664); //方便命令行传递major的值
    19. struct class *cls;
    20. struct device *dev;
    21. struct device_node *dnode;
    22. struct gpio_desc *gpiono[3];
    23.  
    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.  
    37.     //设备文件和设备的绑定，根据次设备号决定打开的设备文件，根据打开的设备文件，控制相应的设备
    38.     switch (min)
    39.     {
    40.     case 0: //控制LED1
    41.         switch (cmd)
    42.         {
    43.         case LED_ON: //开灯
    44.             gpiod_set_value(gpiono[0], 1);
    45.             break;
    46.         case LED_OFF: //关灯
    47.             gpiod_set_value(gpiono[0], 0);
    48.             break;
    49.         }
    50.         break;
    51.     case 1: //控制LED2
    52.         switch (cmd)
    53.         {
    54.         case LED_ON: //开灯
    55.             gpiod_set_value(gpiono[1], 1);
    56.             break;
    57.         case LED_OFF: //关灯
    58.             gpiod_set_value(gpiono[1], 0);
    59.             break;
    60.         }
    61.         break;
    62.     case 2: //控制LED3
    63.         switch (cmd)
    64.         {
    65.         case LED_ON: //开灯
    66.             gpiod_set_value(gpiono[2], 1);
    67.             break;
    68.         case LED_OFF: //关灯
    69.             gpiod_set_value(gpiono[2], 0);
    70.             break;
    71.         }
    72.         break;
    73.     }
    74.     return 0;
    75. }
    76. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
    77. {
    78.  
    79.     return 0;
    80. }
    81.  
    82. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
    83. {
    84.  
    85.     return 0;
    86. }
    87.  
    88. int mycdev_close(struct inode *inode, struct file *file)
    89. {
    90.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    91.     return 0;
    92. }
    93.  
    94. //定义一个操作方法结构体对象并初始化
    95. struct file_operations fops = {
    96.     .open = mycdev_open,
    97.     .unlocked_ioctl = mycdev_ioctl,
    98.     .read = mycdev_read,
    99.     .write = mycdev_write,
    100.     .release = mycdev_close,
    101. };
    102.  
    103. static int __init mycdev_init(void)
    104. {
    105.     //解析LED的设备树节点
    106.     dnode = of_find_node_by_path("/myled");
    107.     if (dnode == NULL)
    108.     {
    109.         printk("解析设备树节点失败\n");
    110.         return -ENXIO;
    111.     }
    112.  
    113.     //申请gpio对象
    114.     int j;
    115.     char nodename[20];
    116.     for (j = 0; j < 3; j++)
    117.     {
    118.         sprintf(nodename, "led%d-gpio", j + 1);
    119.         gpiono[j] = gpiod_get_from_of_node(dnode, nodename, 0, GPIOD_OUT_LOW, NULL);
    120.         if (IS_ERR(gpiono[j]))
    121.         {
    122.             printk("申请gpiono%d失败\n", j);
    123.             goto out0;
    124.         }
    125.     }
    126.  
    127.     int ret;
    128.     //1.为字符设备驱动对象申请空间
    129.     cdev = cdev_alloc();
    130.     if (cdev == NULL)
    131.     {
    132.         printk("申请字符设备驱动对象空间失败\n");
    133.         ret = -EFAULT;
    134.         goto out1;
    135.     }
    136.     printk("申请字符设备驱动对象空间成功\n");
    137.  
    138.     //2.初始化字符设备驱动对象
    139.     cdev_init(cdev, &fops);
    140.     printk("初始化字符设备驱动对象成功\n");
    141.  
    142.     //3.申请设备号
    143.     if (major > 0) //静态指定设备号
    144.     {
    145.         ret = register_chrdev_region(MKDEV(major, minor), 3, "myled");
    146.         if (ret)
    147.         {
    148.             printk("静态申请设备号失败\n");
    149.             goto out2;
    150.         }
    151.     }
    152.     else if (major == 0)
    153.     { //动态申请设备号
    154.         ret = alloc_chrdev_region(&devno, minor, 3, "myled");
    155.         if (ret)
    156.         {
    157.             printk("动态申请设备号失败\n");
    158.             goto out2;
    159.         }
    160.         major = MAJOR(devno); //获取主设备号
    161.         minor = MINOR(devno); //获取次设备号
    162.     }
    163.     printk("申请设备号成功 major= %d\n", major);
    164.  
    165.     //4.注册字符设备驱动对象
    166.     ret = cdev_add(cdev, MKDEV(major, minor), 3);
    167.     if (ret)
    168.     {
    169.         printk("注册字符设备驱动对象失败\n");
    170.         goto out3;
    171.     }
    172.     printk("注册字符设备驱动对象成功\n");
    173.  
    174.     //向上提交目录信息
    175.     cls = class_create(THIS_MODULE, "myled");
    176.     if (IS_ERR(cls))
    177.     {
    178.         printk("向上提交目录失败\n");
    179.         ret = -PTR_ERR(cls);
    180.         goto out4;
    181.     }
    182.     printk("向上提交目录成功\n");
    183.  
    184.     //向上提交设备节点信息
    185.     int i;
    186.     for (i = 0; i < 3; i++)
    187.     {
    188.         dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    189.         if (IS_ERR(dev))
    190.         {
    191.             printk("向上提交设备节点信息失败\n");
    192.             ret = -PTR_ERR(dev);
    193.             goto out5;
    194.         }
    195.     }
    196.     printk("向上提交设备信息成功\n");
    197.     return 0;
    198.  
    199. out5:
    200.     //释放前一次提交成功的设备信息
    201.     for (--i; i >= 0; i--)
    202.     {
    203.         device_destroy(cls, MKDEV(major, i));
    204.     }
    205.     class_destroy(cls); //释放目录
    206. out4:
    207.     //注销字符设备驱动对象
    208.     cdev_del(cdev);
    209. out3:
    210.     //释放设备号
    211.     unregister_chrdev_region(MKDEV(major, minor), 3);
    212. out2:
    213.     //释放设备驱动对象空间
    214.     kfree(cdev);
    215. out1:
    216.     return ret;
    217. out0:
    218.     //释放前一次申请成功gpiono编号
    219.     for (--j; j >= 0; j--)
    220.     {
    221.         gpiod_put(gpiono[j]);
    222.     }
    223.     return -1;
    224. }
    225.  
    226. static void __exit mycdev_exit(void)
    227. {
    228.     int i;
    229.     //释放设备节点信息
    230.     for (i = 0; i < 3; i++)
    231.     {
    232.         device_destroy(cls, MKDEV(major, i));
    233.     }
    234.     //销毁目录
    235.     class_destroy(cls);
    236.     //注销字符设备驱动对象
    237.     cdev_del(cdev);
    238.     //释放设备号
    239.     unregister_chrdev_region(MKDEV(major, minor), 3);
    240.     //释放设备驱动对象空间
    241.     kfree(cdev);
    242.     //释放gpiono编号
    243.     for (i = 0; i < 3; i++)
    244.     {
    245.         gpiod_put(gpiono[i]);
    246.     }
    247. }
    248. module_init(mycdev_init);
    249. module_exit(mycdev_exit);
    250. MODULE_LICENSE("GPL");

    应用程序：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()
    12. {
    13. 	int a, b;
    14. 	char buf[128] = "";
    15. 	int fd1, fd2, fd3;
    16. 	while (1)
    17. 	{
    18. 		printf("请输入要控制的灯：0(LED1) 1(LED2) 2(LED3) >");
    19. 		scanf("%d", &a);
    20. 		switch (a)
    21. 		{
    22. 		case 0:
    23. 			fd1 = open("/dev/myled0", O_RDWR);
    24. 			if (fd1 < 0)
    25. 			{
    26. 				printf("设备文件打开失败\n");
    27. 				exit(-1);
    28. 			}
    29. 			printf("请输入对LED的控制命令：0(关灯) 1(开灯)  >");
    30. 			scanf("%d", &b);
    31. 			switch (b)
    32. 			{
    33. 			case 0:
    34. 				ioctl(fd1, LED_OFF); //关灯
    35. 				close(fd1);
    36. 				break;
    37. 			case 1:
    38. 				ioctl(fd1, LED_ON); //开灯
    39. 				close(fd1);
    40. 				break;
    41. 			}
    42. 			break;
    43.  
    44. 		case 1:
    45. 			fd2 = open("/dev/myled1", O_RDWR);
    46. 			if (fd2 < 0)
    47. 			{
    48. 				printf("设备文件打开失败\n");
    49. 				exit(-1);
    50. 			}
    51. 			printf("请输入对LED的控制命令：0(关灯) 1(开灯)  >");
    52. 			scanf("%d", &b);
    53. 			switch (b)
    54. 			{
    55. 			case 0:
    56. 				ioctl(fd2, LED_OFF); //关灯
    57. 				close(fd2);
    58. 				break;
    59. 			case 1:
    60. 				ioctl(fd2, LED_ON); //开灯
    61. 				close(fd2);
    62. 				break;
    63. 			}
    64. 			break;
    65.  
    66. 		case 2:
    67. 			fd3 = open("/dev/myled2", O_RDWR);
    68. 			if (fd3 < 0)
    69. 			{
    70. 				printf("设备文件打开失败\n");
    71. 				exit(-1);
    72. 			}
    73. 			printf("请输入对LED的控制命令：0(关灯) 1(开灯)  >");
    74. 			scanf("%d", &b);
    75. 			switch (b)
    76. 			{
    77. 			case 0:
    78. 				ioctl(fd3, LED_OFF); //关灯
    79. 				close(fd3);
    80. 				break;
    81. 			case 1:
    82. 				ioctl(fd3, LED_ON); //开灯
    83. 				close(fd3);
    84. 				break;
    85. 			}
    86. 			break;
    87. 		}
    88. 	}
    89.  
    90. 	close(fd1);
    91. 	close(fd2);
    92. 	close(fd3);
    93.  
    94. 	return 0;
    95. }

    头文件：head.h

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3.  
    4. //构建LED开关的功能码，不添加ioctl第三个参数
    5. #define LED_ON _IO('l', 1)
    6. #define LED_OFF _IO('l', 0)
    7.  
    8. #endif

    现象：

  • 相关阅读:
    设计模式-享元模式
    opencv安装成功之后运行代码还是出错
    021-Qt 配置GitHub Copilot
    MySQL日志管理、备份与恢复
    java8-Stream流常用API
    WMS仓储管理系统的功能有哪些？
    ElasticSearch的文档、字段、映射和高级查询
    CSDN编程竞赛 ——— 第十期
    论文篇 | 2020-Facebook-DERT ：利用transformers端到端的目标检测=＞翻译及理解（持续更新中）
    计算机网络——传输层の选择题整理
  • 原文地址：https://blog.csdn.net/jx4252/article/details/132993438