• 【无标题】

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

    用户层程序app

    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("打开文件%d成功\n",a-1);
    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("打开文件%d成功\n",a-1);
    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("打开文件%d成功\n",a-1);
    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_OF);
    62. 				break;
    63. 			default:
    64. 				printf("请输入'0'或'1'\n");
    65. 		}
    66. 		close(fd);
    67. 		printf("关闭文件%d\n",a-1);		
    68. 	}
    69. 	
    70. 	return 0;
    71. }

    驱动程序

    1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/fs.h>
    4. #include <linux/uaccess.h>
    5. #include <linux/compiler.h>
    6. #include <linux/io.h>
    7. #include <linux/device.h>
    8. #include <linux/slab.h>
    9. #include <linux/cdev.h>
    10. #include "head.h"
    11. unsigned int major;
    12. struct class *cls;
    13. struct device *dev;
    14. char kbuf[128] = "";
    15. unsigned int *vir_modere;
    16. unsigned int *vir_moderf;
    17. unsigned int *vir_rcc;
    18. unsigned int *vir_odre;
    19. unsigned int *vir_odrf;
    20. struct cdev *cdev;
    21. unsigned int major = 240;
    22. unsigned int minor = 0;
    23. struct class *cls;
    24. struct device *dev;
    25.  
    26. int ret;
    27. dev_t devno;
    28.  
    29. int mycdev_open(struct inode *inode, struct file *file)
    30. {
    31. 	int num=MINOR(inode->i_rdev);
    32. 	file->private_data=(void*)num;
    33.  
    34. 	printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    35. 	return 0;
    36. }
    37. ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
    38. {
    39. 	
    40. 	printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    41. 	return 0;
    42. }
    43. ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
    44. {
    45. 	
    46. 	printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    47. 	return 0;
    48. }
    49. int mycdev_close(struct inode *inode, struct file *file)
    50. {
    51. 	printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    52. 	return 0;
    53. }
    54. long myled_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    55. {
    56. 	int num=(int)file->private_data;
    57. 	switch(num)
    58. 	{
    59. 		case 0://控制LED1
    60. 			switch(cmd) 
    61. 			{
    62. 				case LED_ON:
    63. 					(*vir_odre) |= (0x1 << 10);
    64. 					break;
    65. 				case LED_OF:
    66. 					(*vir_odre) &= (~(0x1 << 10));
    67. 			}
    68. 			break;
    69. 		case 1://控制LED2
    70. 			switch(cmd) 
    71. 			{
    72. 				
    73. 				case LED_ON:
    74. 					(*vir_odrf) |= (0x1 << 10);
    75. 					break;
    76. 				case LED_OF:
    77. 					(*vir_odrf) &= (~(0x1 << 10));
    78. 			}
    79. 			break;
    80. 		case 2://控制LED3
    81. 			switch(cmd) 
    82. 			{
    83. 				
    84. 				case LED_ON:
    85. 					(*vir_odre) |= (0x1 << 8);
    86. 					break;
    87. 				case LED_OF:
    88. 					(*vir_odre) &= (~(0x1 << 8));
    89. 			}
    90. 	}
    91. 	return 0;
    92. }
    93. struct file_operations fops = {
    94. 	.open = mycdev_open,
    95. 	.read = mycdev_read,
    96. 	.write = mycdev_write,
    97. 	.release = mycdev_close,
    98. 	.unlocked_ioctl=myled_ioctl,
    99. };
    100. int led_init(void)
    101. {
    102. 	vir_rcc = ioremap(LED_RCC, 4);
    103. 	if (vir_rcc == NULL)
    104. 	{
    105. 		printk("物理映射失败%d\n", __LINE__);
    106. 	}
    107. 	vir_modere = ioremap(LED_MODERE, 4);
    108. 	if (vir_rcc == NULL)
    109. 	{
    110. 		printk("物理映射失败%d\n", __LINE__);
    111. 	}
    112. 	vir_moderf = ioremap(LED_MODERF, 4);
    113. 	if (vir_rcc == NULL)
    114. 	{
    115. 		printk("物理映射失败%d\n", __LINE__);
    116. 	}
    117. 	vir_odre = ioremap(LED_ODRE, 4);
    118. 	if (vir_rcc == NULL)
    119. 	{
    120. 		printk("物理映射失败%d\n", __LINE__);
    121. 	}
    122. 	vir_odrf = ioremap(LED_ODRF, 4);
    123. 	if (vir_rcc == NULL)
    124. 	{
    125. 		printk("物理映射失败%d\n", __LINE__);
    126. 	}
    127.  
    128. 	// rcc使能
    129. 	(*vir_rcc) |= (0x1 << 4);
    130. 	(*vir_rcc) |= (0x1 << 5);
    131. 	// moder设置输出模式
    132. 	// led1，PE10
    133. 	(*vir_modere) &= (~(0x3 << 20));
    134. 	(*vir_modere) |= (0x1 << 20);
    135. 	// led2，PF10
    136. 	(*vir_moderf) &= (~(0x3 << 20));
    137. 	(*vir_moderf) |= (0x1 << 20);
    138. 	// led3，PE8
    139. 	(*vir_modere) &= (~(0x3 << 16));
    140. 	(*vir_modere) |= (0x1 << 16);
    141. 	// 设置默认为关灯
    142. 	(*vir_odre) &= (~(0x1 << 10));
    143. 	(*vir_odrf) &= (~(0x1 << 10));
    144. 	(*vir_odre) &= (~(0x1 << 8));
    145. 	return 0;
    146. }
    147. static int __init mycdev_init(void)
    148. {
    149. 	// 字符设备驱动注册
    150. 	/*	major = register_chrdev(0,"mychrdev",&fops);
    151. 		if(major < 0)
    152. 		{
    153. 			printk("字符设备驱动注册失败\n");
    154. 			return major;
    155. 		}
    156. 		printk("字符设备驱动注册成功%d\n",major);
    157. 	*/
    158. 	// 申请空间
    159. 	cdev = cdev_alloc();
    160. 	if (cdev == NULL)
    161. 	{
    162. 		printk("空间申请失败\n");
    163. 		ret = -EFAULT;
    164. 		goto out1;
    165. 	}
    166. 	printk("申请空间成功\n");
    167. 	// 字符设备初始化
    168. 	cdev_init(cdev, &fops);
    169. 	if (major > 0)
    170. 	{
    171. 		// 静态申请设备号
    172. 		ret = register_chrdev_region(MKDEV(major,minor), 3, "myled");
    173. 		if (ret)
    174. 		{
    175. 			printk("静态指定设备号失败\n");
    176. 			goto out2;
    177. 		}
    178. 	}
    179. 	else
    180. 	{
    181. 		// 动态申请设备号
    182. 		ret = alloc_chrdev_region(&devno, minor, 3, "myled");
    183. 		if (ret)
    184. 		{
    185. 			printk("动态申请设备号失败\n");
    186. 			// 释放空间
    187. 			goto out2;
    188. 		}
    189. 	
    190. 		// 获取主次设备号，因为静态动态申请不一样，在下面注册中要用到设备号
    191. 		major = MAJOR(devno); // 主设备号
    192. 		minor = MINOR(devno); // 次设备号
    193. 	}
    194. 	printk("申请设备号成功\n");
    195. 	// 注册驱动
    196. 	ret = cdev_add(cdev, MKDEV(major, minor), 3);
    197. 	if (ret)
    198. 	{
    199. 		printk("注册字符设备驱动对象\n");
    200. 		goto out3;
    201. 	}
    202. 	printk("注册字符设备驱动对象成功");
    203. 	// 进行映射
    204. 	led_init();
    205. 	// 向上提交目录信息
    206. 	cls = class_create(THIS_MODULE, "myled");
    207. 	if (IS_ERR(cls))
    208. 	{
    209. 		printk("向上提供目录\n");
    210. 		ret = -PTR_ERR(cls);
    211. 		goto out4;
    212. 	}
    213. 	printk("向上提交目录成功\n");
    214. 	//向上提交节点信息
    215. 	int i;
    216. 	for (i = 0; i < 3; i++)
    217. 	{
    218. 		dev = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
    219. 		if (IS_ERR(dev))
    220. 		{
    221. 			printk("向上提交设备节点信息失败\n");
    222. 			ret = -PTR_ERR(dev);
    223. 			goto out5;
    224. 		}
    225. 		printk("向上提交设备节点信息成功\n");
    226. 	}
    227. 	return 0;
    228. out5:
    229. 	for(--i;i>=0;i--)
    230. 	{
    231. 	device_destroy(cls, MKDEV(major, i));
    232. 	}
    233. 	class_destroy(cls);
    234. out4:
    235. 	cdev_del(cdev);
    236. out3:
    237. 	unregister_chrdev_region(MKDEV(major, minor), 3);
    238. out2:
    239. 	kfree(cdev);
    240. out1: return ret;
    241. }
    242.  
    243. static void __exit mycdev_exit(void)
    244. {
    245. 	// unregister_chrdev(major,"mychrdev");
    246. 	int i;
    247. 	for(i=0;i<3;i++)
    248. 	{
    249. 		device_destroy(cls,MKDEV(major,i));
    250. 	}
    251. 	class_destroy(cls);
    252. 	cdev_del(cdev);
    253. 	unregister_chrdev_region(MKDEV(major,minor),3);
    254. 	kfree(cdev);
    255. 	
    256. 	iounmap(vir_rcc);
    257. 	iounmap(vir_modere);
    258. 	iounmap(vir_moderf);
    259. 	iounmap(vir_odre);
    260. 	iounmap(vir_odrf);
    261. }
    262.  
    263. module_init(mycdev_init);
    264. module_exit(mycdev_exit);
    265. MODULE_LICENSE("GPL");

    头文件

    1. #ifndef __H__
    2. #define __H__
    3. #define LED_MODERE 0X50006000
    4. #define LED_MODERF 0X50007000
    5. #define LED_ODRE   0X50006014
    6. #define LED_ODRF   0X50007014
    7. #define LED_RCC   0X50000A28
    8. #define LED_ON  _IO('l',1)
    9. #define LED_OF  _IO('l',0)
    10.  
    11.  
    12. #endif

  • 相关阅读:
    【juc】countdownlatch实现并发网络请求
    100106. 元素和最小的山形三元组 I
    Babylonjs学习笔记(六)——贴图的使用
    精益求精：Android应用体积优化的终极指南
    可视化业务流程监控，是解决方案更是运维之道！
    Python循环控制
    前端技能树，面试复习—— 模拟题+真题系列（2）: 单例模式 | 大文件上传 | SSR 原理 | 收集依赖 | HOOK 原理 | Worker 等等
    05【原型设计模式】
    发现一个舔狗神器，Python真的太厉害了，自动下载妹子视频...
    TCP的三次握手和四次挥手
  • 原文地址：https://blog.csdn.net/Kukuderener/article/details/132863881