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

    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开关的功能码，添加ioctl第三个参数int 
    17. #define LED_ON  _IOW('l',1,int)
    18. #define LED_OFF _IOW('l',0,int)
    19.  
    20. #endif

    cdev.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include "head.h"
    10. struct cdev *cdev;
    11. char kbuf[128]={0};
    12. unsigned int major=0;
    13. unsigned int minor=0;
    14. dev_t devno;
    15. module_param(major,uint,0664);//方便在命令行传递major的值
    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.  
    31. int mycdev_close(struct inode *inode, struct file *file)
    32. {
    33.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    34.     return 0;
    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 |= 1 << 10;
    46.                     //开灯
    47.                     break;
    48.                 case LED_OFF:
    49. 					vir_led1->ODR &= (~(1 << 10));
    50.                     //关灯
    51.                     break;                                
    52.             }
    53.             break;
    54.     case 1://控制LED2
    55.             switch(cmd)
    56.             {
    57.                 case LED_ON:
    58. 					vir_led2->ODR |= 1 << 10;
    59.                     //开灯
    60.                     break;
    61.                 case LED_OFF:
    62. 					vir_led2->ODR &= (~(1 << 10));
    63.                     //关灯
    64.                     break;                                
    65.             }
    66.             break;
    67.        case 2://控制LED3
    68.             switch(cmd)
    69.             {
    70.                 case LED_ON:
    71. 					vir_led3->ODR |= 1 << 8;
    72.                     //开灯
    73.                     break;
    74.                 case LED_OFF:
    75. 					vir_led3->ODR &= (~(1 << 8));
    76.                     //关灯
    77.                     break;                                
    78.             }
    79.             break;
    80.     }
    81.     return 0;
    82. }
    83.  
    84. // 定义一个操作方法结构体对象并且初始化
    85. struct file_operations fops = {
    86.     .open=mycdev_open,
    87.     .unlocked_ioctl = mycdev_ioctl,
    88.     .release=mycdev_close,
    89. };
    90.  
    91. int all_led_init(void)
    92. {
    93.  
    94. 	//进行相关寄存器的内存映射
    95. 	//GPIOE组寄存器内存映射
    96. 	vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    97. 	if (vir_led1 == NULL)
    98. 	{
    99. 		printk("物理内存映射失败%d\n", __LINE__);
    100. 		return -EFAULT;
    101. 	}
    102.  
    103. 	vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    104. 	if (vir_led2 == NULL)
    105. 	{
    106. 		printk("物理内存映射失败%d\n", __LINE__);
    107. 		return -EFAULT;
    108. 	}
    109.  
    110. 	vir_led3 = vir_led1;
    111.  
    112. 	vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    113. 	if (vir_rcc == NULL)
    114. 	{
    115. 		printk("物理内存映射失败%d\n", __LINE__);
    116. 		return -EFAULT;
    117. 	}
    118.  
    119. 	printk("寄存器内存映射成功\n");
    120.  
    121. 	//硬件寄存器的初始化
    122. 	//RCC使能
    123. 	(*vir_rcc) |= (0x3 << 4); //GPIOE(PE10 PE8)使能 GPIOF(PF10)使能
    124.  
    125. 	//设置PE10为输出模式 --> LED1
    126. 	(vir_led1->MODER) &= (~(0x3 << 20));
    127. 	(vir_led1->MODER) |= (0x1 << 20);
    128. 	//设置PF10为输出模式 --> LED2
    129. 	(vir_led2->MODER) &= (~(0x3 << 20));
    130. 	(vir_led2->MODER) |= (0x1 << 20);
    131. 	//设置PE8为输出模式 --> LED3
    132. 	(vir_led3->MODER) &= (~(0x3 << 16));
    133. 	(vir_led3->MODER) |= (0x1 << 16);
    134.  
    135. 	//默认LED1关灯
    136. 	(vir_led1->ODR) &= (~(0x1 << 10));
    137. 	//默认LED2关灯
    138. 	(vir_led2->ODR) &= (~(0x1 << 10));
    139. 	//默认LED1关灯
    140. 	(vir_led3->ODR) &= (~(0x1 << 8));
    141. 	printk("寄存器初始化成功\n");
    142.  
    143. 	return 0;
    144. }
    145.  
    146. static int __init mycdev_init(void)
    147. {
    148. 	int ret;
    149. 	//为字符设备驱动对象申请空间
    150. 	cdev = cdev_alloc();
    151. 	if(cdev==NULL)
    152. 	{
    153. 		printk("字符设备驱动对象申请空间失败\n");
    154. 		ret=-EFAULT;
    155. 		goto out1;
    156. 	}
    157. 	printk("申请对象空间成功\n");
    158. 	//初始化字符设备驱动对象
    159. 	cdev_init(cdev,&fops);
    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. 	}
    182. 	printk("申请设备号成功\n");
    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. 	all_led_init();
    193. 	cls=class_create(THIS_MODULE,"myled");
    194. 	if(IS_ERR(cls))
    195. 	{
    196. 		printk("向上提交目录失败\n");
    197. 		ret=-PTR_ERR(cls);
    198. 		goto out4;
    199. 	}
    200. 	printk("向上提交目录成功\n");
    201. 	//向上提交设备节点信息
    202. 	int i;
    203. 	for(i=0;i<3;i++)
    204. 	{
    205. 		dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    206. 		if(IS_ERR(dev))
    207. 		{
    208. 			printk("向上提交设备节点信息失败\n");
    209. 			ret=-PTR_ERR(dev);
    210. 			goto out5;
    211. 		}
    212. 	}
    213. 	printk("向上提交设备信息成功\n");
    214. 	
    215. 	return 0;
    216. out5:
    217. 	//释放前一次提交成功的设备信息
    218. 	for(--i;i>=0;i--)
    219. 	{
    220. 		device_destroy(cls,MKDEV(major,i));
    221. 	}
    222. 	class_destroy(cls);//释放目录
    223. out4:
    224. 	cdev_del(cdev);
    225. out3:
    226. 	unregister_chrdev_region(MKDEV(major,minor),3);
    227. out2:
    228. 	kfree(cdev);
    229. out1:
    230. 	return ret;
    231.  
    232. }
    233.  
    234. static void __exit mycdev_exit(void)
    235. {
    236. 	//释放节点信息
    237. 	int i;
    238. 	for(i=0;i<3;i++)
    239. 	{
    240. 		device_destroy(cls,MKDEV(major,i));
    241. 	}
    242. 	//销毁目录
    243. 	class_destroy(cls);
    244. 	//注销驱动对象
    245. 	cdev_del(cdev);
    246. 	//释放设备号
    247. 	unregister_chrdev_region(MKDEV(major,minor),3);
    248. 	//释放对象空间
    249. 	kfree(cdev);
    250. 	
    251. }
    252. module_init(mycdev_init);
    253. module_exit(mycdev_exit);
    254. 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 fd;
    16. 	while (1)
    17. 	{
    18. 		printf("请输入要控制的灯：0(LED1) 1(LED2) 2(LED3) >");
    19. 		scanf("%d", &a);
    20. 		switch (a)
    21. 		{
    22. 		case 0:
    23. 			fd = open("/dev/myled0", O_RDWR);
    24. 			if (fd < 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(fd, LED_OFF); //关灯
    35. 				break;
    36. 			case 1:
    37. 				ioctl(fd, LED_ON); //开灯
    38. 				break;
    39. 			}
    40. 			break;
    41.  
    42. 		case 1:
    43. 			fd = open("/dev/myled1", O_RDWR);
    44. 			if (fd < 0)
    45. 			{
    46. 				printf("设备文件打开失败\n");
    47. 				exit(-1);
    48. 			}
    49. 			printf("请输入对LED的控制命令：0(关灯) 1(开灯)  >");
    50. 			scanf("%d", &b);
    51. 			switch (b)
    52. 			{
    53. 			case 0:
    54. 				ioctl(fd, LED_OFF); //关灯
    55. 				break;
    56. 			case 1:
    57. 				ioctl(fd, LED_ON); //开灯
    58. 				break;
    59. 			}
    60. 			break;
    61.  
    62. 		case 2:
    63. 			fd = open("/dev/myled2", O_RDWR);
    64. 			if (fd < 0)
    65. 			{
    66. 				printf("设备文件打开失败\n");
    67. 				exit(-1);
    68. 			}
    69. 			printf("请输入对LED的控制命令：0(关灯) 1(开灯)  >");
    70. 			scanf("%d", &b);
    71. 			switch (b)
    72. 			{
    73. 			case 0:
    74. 				ioctl(fd, LED_OFF); //关灯
    75. 				break;
    76. 			case 1:
    77. 				ioctl(fd, LED_ON); //开灯
    78. 				break;
    79. 			}
    80. 			break;
    81. 		}
    82. 	}
    83.  
    84. 	close(fd);
    85.  
    86. 	return 0;
    87. }

  • 相关阅读:
    推荐计划为什么有效？需要推荐计划的10个原因
    图解｜从根上彻底理解MySQL的索引
    JSON和全局异常处理
    笔记-Python编码问题整理
    【探索Linux】—— 强大的命令行工具 P.26（网络编程套接字基本概念—— socket编程接口 | socket编程接口相关函数详细介绍 ）
    [AI]Python中的Restful
    【C语言】【排序算法】----- 归并排序
    哈工大机器人竞技队成立22年来4次获国际冠军
    IDE相关设置和插件
    实时即未来，大数据项目车联网之原始数据实时ETL任务消费数据策略【三】
  • 原文地址：https://blog.csdn.net/m0_59343476/article/details/132865832