• 驱动开发day8

    head.h

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

    demo.c

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

    计时器

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. struct timer_list hw;
    9.  
    10. void mytime_hello(struct timer_list *timer)
    11. {
    12. 	printk("hello world\n");
    13.  
    14. 	mod_timer(timer, jiffies + 5*HZ);
    15. }
    16.  
    17. //入口函数，安装内核模块时执行
    18. static int __init mycdev_init(void)
    19. {	
    20. 	timer_setup(&hw, mytime_hello, 0);
    21. 	hw.expires = jiffies + 5*HZ;
    22. 	add_timer(&hw);
    23. 	return 0;
    24. }
    25.  
    26. //出口函数，卸载内核模块时执行
    27. static void __exit mycdev_exit(void)
    28. {	
    29. 	del_timer(&hw);
    30. }
    31.  
    32. //用于声明入口函数
    33. module_init(mycdev_init);
    34. //用于声明出口函数
    35. module_exit(mycdev_exit);
    36. //声明当前内核模块遵循GPL协议
    37. MODULE_LICENSE("GPL");

  • 相关阅读:
    简单配置linux防火墙
    VK1056B/C计算器，跑步机，电子秤LCD驱动方案，段码液晶显示芯片IC技术资料
    【2】CH347应用--在OpenOCD添加CH347-JTAG接口
    【操作系统】进程间的通信——消息队列
    公司电脑强制休眠的3种解决方案
    Debian 使用 systemd 自动挂载 Samba
    Jmeter入门
    TI AM335x继任者？AM6254性能解析
    计算机组成原理习题课第一章-3（唐朔飞）
    golang设置socket选项参数SO_LINGER、SO_SNDBUF
  • 原文地址：https://blog.csdn.net/zjt020305/article/details/134088800