• 驱动day8

    驱动代码：

    1.  
    2. #include <linux/init.h>
    3. #include <linux/module.h>
    4. #include <linux/of.h>
    5. #include <linux/of_gpio.h>
    6. #include <linux/gpio.h>
    7. #include<linux/fs.h>
    8. #include<linux/io.h>
    9. #include <linux/uaccess.h>
    10. #include <linux/timer.h>
    11. #include <linux/device.h>
    12. #include <linux/cdev.h>
    13. #include <linux/slab.h>
    14. #include"head.h"
    15. struct device_node *dnode;
    16. struct gpio_desc *gpiono;
    17. struct gpio_desc *gpiono1;
    18. struct gpio_desc *gpiono2;
    19. struct timer_list mytimer;
    20. unsigned int major=0;
    21. unsigned int minor=0;
    22. struct cdev *mychdev;
    23. struct class *cls;
    24. struct device *dev;
    25. dev_t devno;
    26. int mycdev_open(struct inode *inode, struct file *file)
    27. {
    28.     int min=MINOR(inode->i_rdev);//获取打开的的文件的次设备号
    29.     file->private_data= (void *)min;
    30.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    31.     return 0;
    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.                     gpiod_set_value(gpiono,1);
    43.                     break;
    44.                 case LED_OFF: //关灯
    45.                     gpiod_set_value(gpiono,0);
    46.                     break;
    47.             }
    48.             break;
    49.         case 1:  //控制LED2
    50.             switch(cmd)
    51.             {
    52.                 case LED_ON:  //开灯
    53.                     gpiod_set_value(gpiono1,1);
    54.                     break;
    55.                 case LED_OFF: //关灯
    56.                     gpiod_set_value(gpiono1,0);
    57.                     break;
    58.             }
    59.             break;
    60.         case 2:  //控制LED3
    61.             switch(cmd)
    62.             {
    63.                 case LED_ON:  //开灯
    64.                     gpiod_set_value(gpiono2,1);
    65.                     break;
    66.                 case LED_OFF: //关灯
    67.                     gpiod_set_value(gpiono2,0);
    68.                     break;
    69.             }
    70.             break;
    71.     }
    72.      printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    73.     return 0;
    74. }
    75. int mycdev_close(struct inode *inode, struct file *file)
    76. {
    77.     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    78.     return 0;
    79. }
    80. //定义操作方法结构体变量并赋值
    81. struct file_operations fops = {
    82.  
    83.     .open = mycdev_open,
    84.     .unlocked_ioctl = mycdev_ioctl,
    85.     .release = mycdev_close,
    86. };
    87. int k=0;
    88.  
    89. void mytimer_function(struct timer_list *timer)
    90. {
    91. 	k++;
    92. 	if(k%5==0)
    93. 	{
    94. 		printk("hello world");
    95. 	}
    96. 	mod_timer(timer,jiffies+HZ);
    97. }
    98.  
    99. //入口函数
    100. static int __init mydev_init(void)
    101. {
    102. 	
    103. 	dnode=of_find_node_by_path("/myled");
    104. 	if(dnode==NULL)
    105. 	{
    106. 		printk("解析设备树节点失败\n");
    107. 		return -1;
    108. 	}
    109. 	//获取LED1 GPIO编号
    110. 	gpiono=gpiod_get_from_of_node(dnode,"led-gpios",0,GPIOD_OUT_LOW,NULL);
    111. 	gpiono1=gpiod_get_from_of_node(dnode,"led-gpios",1,GPIOD_OUT_LOW,NULL);
    112. 	gpiono2=gpiod_get_from_of_node(dnode,"led-gpios",2,GPIOD_OUT_LOW,NULL);
    113. 	
    114.     //初始化定时器对象
    115. 	timer_setup(&mytimer,mytimer_function,0);
    116. 	mytimer.expires=jiffies+HZ;
    117. 	//注册定时器
    118. 	add_timer(&mytimer);
    119.     
    120. 	int ret;
    121.     //1.申请一个对象空间cdev_alloc
    122.     mychdev=cdev_alloc();
    123.     if(mychdev == NULL)
    124.     {
    125.         printk("申请字符设备驱动对象失败\n");
    126.         ret = -EFAULT;
    127.         goto out1;
    128.     }
    129.     printk("申请字符设备驱动对象成功\n");
    130.     //2.初始化对象cdev_init
    131.     cdev_init(mychdev,&fops);
    132.     //3.申请设备号  register_chrdev_region()/alloc_chrdev_region()
    133.     if(major == 0)
    134.     {
    135.         ret = alloc_chrdev_region(&devno,minor,3,"burger");
    136.         if(ret)
    137.         {
    138.             printk("动态申请设备号失败\n");
    139.             goto out2;
    140.         }
    141.         major=MAJOR(devno);
    142.         minor=MINOR(devno);
    143.     }
    144.     else
    145.     {
    146.         ret = register_chrdev_region(MKDEV(major,minor),3,"burger");
    147.         if(ret)
    148.         {
    149.             printk("静态申请设备号失败\n");
    150.             goto out2;
    151.         }
    152.     }
    153.     printk("申请设备号成功\n");
    154.     //4.注册驱动对象  cdev_add
    155.     ret = cdev_add(mychdev,MKDEV(major,minor),3);
    156.     if(ret)
    157.     {
    158.         printk("注册字符设备驱动对象失败\n");
    159.         goto out3;
    160.     }
    161.     printk("注册字符设备驱动对象成功\n");
    162.     //5.向上提交目录  class_create
    163.     cls=class_create(THIS_MODULE,"burger");
    164.     if(IS_ERR(cls))
    165.     {
    166.         printk("向上提交目录失败\n");
    167.         goto out4;
    168.     }
    169.     printk("向上提交目录成功\n");
    170.     //6.向上提交设备节点信息  device_create
    171.     int i;  //向上提交三次设备节点信息
    172.     for(i=0;i<3;i++)
    173.     {
    174.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"burger%d",i);
    175.         if(IS_ERR(dev))
    176.         {
    177.             printk("向上提交节点失败\n");
    178.             goto out5;
    179.         }
    180.     }
    181.      printk("向上提交节点成功\n");
    182. 	return 0;
    183. out5:
    184.     for(--i;i>=0;i--)
    185.     {
    186.         device_destroy(cls,MKDEV(major,i));
    187.     }
    188.     class_destroy(cls);
    189. out4:
    190.     cdev_del(mychdev);
    191. out3:
    192.     unregister_chrdev_region(MKDEV(major,minor),3);
    193. out2:
    194.     kfree(mychdev);
    195. out1:
    196.     return ret;
    197. }
    198. //出口函数
    199. static void __exit mydev_exit(void)
    200. {
    201. 	//灭灯
    202. 	gpiod_set_value(gpiono,0);
    203. 	gpiod_set_value(gpiono1,0);
    204. 	gpiod_set_value(gpiono2,0);
    205. 	//注销定时器
    206. 	del_timer(&mytimer);
    207. 	//释放GPIO信号
    208. 	gpiod_put(gpiono);
    209. 	gpiod_put(gpiono1);
    210. 	gpiod_put(gpiono2);
    211. 	    //注销字符设备驱动
    212.     int i;
    213.     for(i=0;i<3;i++)
    214.     {
    215.         device_destroy(cls,MKDEV(major,i));
    216.     }
    217.     class_destroy(cls);
    218.     cdev_del(mychdev);
    219.     unregister_chrdev_region(MKDEV(major,minor),3);
    220.     kfree(mychdev);
    221. }
    222. //声明入口函数
    223. module_init(mydev_init);
    224. //声明出口函数
    225. module_exit(mydev_exit);
    226. MODULE_LICENSE("GPL");

    应用程序代码：

    1. #include <stdlib.h>
    2. #include <stdio.h>
    3. #include <sys/types.h>
    4. #include <sys/stat.h>
    5. #include <sys/ioctl.h>
    6. #include <fcntl.h>
    7. #include <unistd.h>
    8. #include <string.h>
    9. #include "head.h"
    10.  
    11. int main(int argc, char const *argv[])
    12. {
    13.     int a,b,fd;
    14.     while(1)
    15.     {
    16.         fd=-1;
    17.         //从终端读取
    18.         printf("请输入要实现的功能 ");
    19.         printf("1(关灯) 0(开灯)\n");
    20.         printf("请输入>");
    21.         scanf("%d",&a);
    22.         printf("请选择要控制的灯：1（LED1）2(LED2) 3(LED3)\n");
    23.         printf("请输入>");
    24.         scanf("%d",&b);
    25.         switch(b)
    26.         {
    27.             case 1:
    28.                 fd=open("/dev/burger0",O_RDWR);
    29.                 if(a == 0)
    30.                 {   
    31.                    ioctl(fd,LED_ON,&b);
    32.                     break;
    33.                 }
    34.                 else
    35.                 {
    36.                     ioctl(fd,LED_OFF,&b);
    37.                     break;
    38.                 }
    39.             case 2:
    40.                 fd=open("/dev/burger1",O_RDWR);
    41.                 if(a == 0)
    42.                 {   
    43.                    ioctl(fd,LED_ON,&b);
    44.                     break;
    45.                 }
    46.                 else
    47.                 {
    48.                     ioctl(fd,LED_OFF,&b);
    49.                     break;
    50.                 }
    51.             case 3:
    52.                 fd=open("/dev/burger2",O_RDWR);
    53.                 if(a == 0)
    54.                 {   
    55.                    ioctl(fd,LED_ON,&b);
    56.                     break;
    57.                 }
    58.                 else
    59.                 {
    60.                     ioctl(fd,LED_OFF,&b);
    61.                     break;
    62.                 }
    63.         }
    64.         close(fd);
    65.     }
    66.     close(fd);
    67.     return 0;
    68. }

    头文件：

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__ 
    3.  
    4. // 构建开灯关灯的功能码
    5. #define LED_ON _IOW('l', 1,int)
    6. #define LED_OFF _IOW('l', 0,int)
    7. #endif

    实验结果：

  • 相关阅读:
    【周末读书】认知驱动：做成一件对他人很有用的事
    文件传输协议
    使用 Helm3 部署 Loki
    autodl服务器中YOLOx训练自己数据集
    动态SQL+分页
    差分约束学习笔记
    Shell脚本中2＞&1、＞、＞＞等符号到底是什么含义
    haproxy
    PostgreSql学习（基于菜鸟课程）
    4核16G服务器价格腾讯云PK阿里云
  • 原文地址：https://blog.csdn.net/cecillq/article/details/134088973