devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

韦东山imx6ull，设备树电亮LED灯，课后作业笔记_imx6ull韦东山led点灯

作者：2023面试高手 | 2024-06-08 06:51:23

赞

踩

imx6ull韦东山led点灯

此博客仅记录Linux学习路上的问题，以及总结，以供复习。

欢迎留下更有用的知识，或者学习方法，感谢！

1、总结3种写驱动程序的方法

1.1 资源和驱动放在同一文件下

比较容易理解，和单片机直接操作寄存器一样。

1.2 使用platform_device和platform_driver来完成，分离思想

其中device中指定要用到的资源，resources数组中有引脚，名字等

  1. static struct platform_device board_A_led_dev = {
  2.         .name = "100ask_led",
  3.         .num_resources = ARRAY_SIZE(resources),
  4.         .resource = resources,
  5.         .dev = {
  6.                 .release = led_dev_release,
  7.          },
  8. };

dirver是更低一层的驱动，里面的名字要与device中匹配，probe函数在匹配完成后会被调用，多个设备会调用多次，remove函数在卸载时被调用。

  1. static struct platform_driver chip_demo_gpio_driver = {
  2.     .probe      = chip_demo_gpio_probe,
  3.     .remove     = chip_demo_gpio_remove,
  4.     .driver     = {
  5.         .name   = "100ask_led",
  6.     },
  7. };

在此基础上写好各自驱动的入口出口函数。

1.3 使用设备树

使用设备树之后，相当于不用我们自己去写资源，而是写一个有关资源的dts文件，然后内核去里面取出设备资源，然后driver再去匹配，只要编写dirver就可以。

  1. static struct platform_driver chip_demo_gpio_driver = {
  2.     .probe      = chip_demo_gpio_probe,
  3.     .remove     = chip_demo_gpio_remove,
  4.     .driver     = {
  5.         .name   = "100ask_led",
  6.         .of_match_table = ask100_leds, //想要支持设备树的话，加上这个
  7.     },
  8. };

这里使用设备树要加上match_table，告诉内核。probe和remove函数和1.2一样，匹配之后自动调用。

dts文件中只要加上设备，格式有点像json字符的格式，首先要写好compatible，这个参数是和driver中的of_match_table对应的，值要相同，匹配的时候首先就去匹配这个值。

2、主要代码

  把课后作业的点灯加到了最底层，直接操作硬件。

  /sys/bus/platform/driver  这个目录是im6ull看注册进内核的driver，与别的芯片有区别

board.c

  1.  
  2. #include <linux/module.h>
  3.  
  4. #include <linux/fs.h>
  5. #include <linux/errno.h>
  6. #include <linux/miscdevice.h>
  7. #include <linux/kernel.h>
  8. #include <linux/major.h>
  9. #include <linux/mutex.h>
  10. #include <linux/proc_fs.h>
  11. #include <linux/seq_file.h>
  12. #include <linux/stat.h>
  13. #include <linux/init.h>
  14. #include <linux/device.h>
  15. #include <linux/tty.h>
  16. #include <linux/kmod.h>
  17. #include <linux/gfp.h>
  18. #include <linux/platform_device.h>
  19.  
  20. #include "led_resource.h"
  21.  
  22.  
  23. static void led_dev_release(struct device *dev)
  24. {
  25. }
  26.  
  27. static struct resource resources[] = {
  28.         {
  29.                 .start = GROUP_PIN(5,3),
  30.                 .flags = RESOURCE_IRQ,
  31.                 .name = "100ask_led_pin",
  32.         },
  33. 		{
  34. 				.start = GROUP_PIN(5,8),
  35. 				.flags = IORESOURCE_IRQ,
  36. 				.name = "100ask_led_pin",
  37. 		},
  38. };
  39.  
  40.  
  41. static struct platform_device board_A_led_dev = {
  42. 		.name = "100ask_led",
  43. 		.num_resources = ARRAY_SIZE(resources),
  44. 		.resource = resources,
  45. 		.dev = {
  46. 				.release = led_dev_release,
  47. 		 },
  48. };
  49.  
  50. static int __init led_dev_init(void)
  51. {
  52. 	int err;
  53. 	
  54. 	err = platform_device_register(&board_A_led_dev);	
  55. 	
  56. 	return 0;
  57. }
  58.  
  59. static void __exit led_dev_exit(void)
  60. {
  61. 	platform_device_unregister(&board_A_led_dev);
  62. }
  63.  
  64. module_init(led_dev_init);
  65. module_exit(led_dev_exit);
  66.  
  67. MODULE_LICENSE("GPL");
  68.

chip_demo_gpio.c

  1. #include <linux/module.h>
  2.  
  3. #include <linux/fs.h>
  4. #include <linux/errno.h>
  5. #include <linux/miscdevice.h>
  6. #include <linux/kernel.h>
  7. #include <linux/major.h>
  8. #include <linux/mutex.h>
  9. #include <linux/proc_fs.h>
  10. #include <linux/seq_file.h>
  11. #include <linux/stat.h>
  12. #include <linux/init.h>
  13. #include <linux/device.h>
  14. #include <linux/tty.h>
  15. #include <linux/kmod.h>
  16. #include <linux/gfp.h>
  17. #include <linux/platform_device.h>
  18. #include <linux/of.h>
  19. #include <asm/io.h>
  20. #include "led_opr.h"
  21. #include "leddrv.h"
  22. #include "led_resource.h"
  23.  
  24. static int g_ledpins[100];
  25. static int g_ledcnt = 0;
  26.  
  27. static volatile unsigned int *CCM_CCGR1; //0x020C4000 + 0x6C
  28. static volatile unsigned int *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3; //0x02290000 + 0x14
  29. static volatile unsigned int *GPIO5_GDIR;
  30. static volatile unsigned int *GPIO5_DR;
  31.  
  32. static int board_demo_led_init (int which) /* 初始化LED, which-哪个LED */       
  33. {   
  34.     //printk("%s %s line %d, led %d\n", __FILE__, __FUNCTION__, __LINE__, which);
  35.     int val;
  36.     printk("init gpio: group %d, pin %d\n", GROUP(g_ledpins[which]), PIN(g_ledpins[which]));
  37.     switch(GROUP(g_ledpins[which]))
  38.     {
  39.         case 5:
  40.         {
  41.             printk("init pin of group 5 ...\n");
  42.             if(!CCM_CCGR1)//虚拟地址映射，没映射ccm是空指针，会进入
  43.             {
  44.                 CCM_CCGR1 = ioremap(0x020C4000 + 0x6C,4); //0x020C4000 + 0x6C
  45.                 IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 = ioremap(0x02290000 + 0x14,4); //0x02290000 + 0x14
  46.                 GPIO5_GDIR = ioremap(0x020AC004,4);
  47.                 GPIO5_DR = ioremap(0x020AC000,4);
  48.             }
  49.             //使能gpio  
  50.             *CCM_CCGR1 |= (3<<30);
  51.             //设置引脚为gpio  先清0  再去设置位0101
  52.             val = *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 ;
  53.             val&= ~(0xf);
  54.             val|= (5);
  55.             *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 = val;	
  56.             
  57.             //设置哪一个组输入输出
  58.             *GPIO5_GDIR |= (1<<3);
  59.             break;
  60.         }
  61.         case 1:
  62.         {
  63.             printk("init pin of group 1 ...\n");
  64.             break;
  65.         }
  66.         case 2:
  67.         {
  68.             printk("init pin of group 2 ...\n");
  69.             break;
  70.         }
  71.         case 3:
  72.         {
  73.             printk("init pin of group 3 ...\n");
  74.             break;
  75.         }
  76.     }
  77.     
  78.     return 0;
  79. }
  80.  
  81. static int board_demo_led_ctl (int which, char status) /* 控制LED, which-哪个LED, status:1-亮,0-灭 */
  82. {
  83.     //printk("%s %s line %d, led %d, %s\n", __FILE__, __FUNCTION__, __LINE__, which, status ? "on" : "off");
  84.     printk("set led %s: group %d, pin %d\n", status ? "on" : "off", GROUP(g_ledpins[which]), PIN(g_ledpins[which]));
  85.  
  86.     switch(GROUP(g_ledpins[which]))
  87.     {
  88.         case 5:
  89.         {
  90.             printk("set pin of group 0 ...\n");
  91.             if(status == 0) //输出高电平
  92.             *GPIO5_DR |= (1<<3);
  93.             else if (status == 1)//输出低电平
  94.             {
  95.                 *GPIO5_DR &= ~(1<<3);
  96.             }
  97.             break;
  98.         }
  99.         case 1:
  100.         {
  101.             printk("set pin of group 1 ...\n");
  102.             break;
  103.         }
  104.         case 2:
  105.         {
  106.             printk("set pin of group 2 ...\n");
  107.             break;
  108.         }
  109.         case 3:
  110.         {
  111.             printk("set pin of group 3 ...\n");
  112.             break;
  113.         }
  114.     }
  115.  
  116.     return 0;
  117. }
  118.  
  119. static struct led_operations board_demo_led_opr = {
  120.     .init = board_demo_led_init,
  121.     .ctl  = board_demo_led_ctl,
  122. };
  123.  
  124. struct led_operations *get_board_led_opr(void)
  125. {
  126.     return &board_demo_led_opr;
  127. }
  128.  
  129. static int chip_demo_gpio_probe(struct platform_device *pdev)
  130. {
  131.     struct device_node *np;
  132.     int err = 0;
  133.     int led_pin;
  134.  
  135.     np = pdev->dev.of_node;
  136.     if (!np)//节点不存在
  137.         return -1;
  138.  
  139.     err = of_property_read_u32(np, "pin", &led_pin);//从节点np中读取pin属性，保存在led_pin中
  140.     
  141.     g_ledpins[g_ledcnt] = led_pin;
  142.     led_class_create_device(g_ledcnt);
  143.     g_ledcnt++;
  144.         
  145.     return 0;
  146.     
  147. }
  148.  
  149. static int chip_demo_gpio_remove(struct platform_device *pdev)
  150. {
  151.     int i = 0;
  152.     int err;
  153.     struct device_node *np;
  154.     int led_pin;
  155.  
  156.     np = pdev->dev.of_node;
  157.     if (!np)
  158.         return -1;
  159.  
  160.     err = of_property_read_u32(np, "pin", &led_pin);
  161.  
  162.     for (i = 0; i < g_ledcnt; i++)
  163.     {
  164.         if (g_ledpins[i] == led_pin)
  165.         {
  166.             led_class_destroy_device(i);
  167.             g_ledpins[i] = -1;//销毁之后，讲pin设置为-1
  168.             break;
  169.         };
  170.     }
  171.  
  172.     for (i = 0; i < g_ledcnt; i++)
  173.     {
  174.         if (g_ledpins[i] != -1)
  175.             break;
  176.     }
  177.  
  178.     if (i == g_ledcnt)
  179.         g_ledcnt = 0;//每一项都是-1（每一个都销毁了） 重新将索引值设为0
  180.     
  181.     return 0;
  182. }
  183.  
  184. static const struct of_device_id ask100_leds[] = {
  185.     { .compatible = "100as,leddrv" },
  186.     { },
  187. };
  188.  
  189. static struct platform_driver chip_demo_gpio_driver = {
  190.     .probe      = chip_demo_gpio_probe,
  191.     .remove     = chip_demo_gpio_remove,
  192.     .driver     = {
  193.         .name   = "100ask_led",
  194.         .of_match_table = ask100_leds, //想要支持设备树的话，加上这个
  195.     },
  196. };
  197.  
  198. static int __init chip_demo_gpio_drv_init(void)
  199. {
  200.     int err;
  201.     
  202.     err = platform_driver_register(&chip_demo_gpio_driver); 
  203.     register_led_operations(&board_demo_led_opr);
  204.     
  205.     return 0;
  206. }
  207.  
  208. static void __exit lchip_demo_gpio_drv_exit(void)
  209. {
  210.     platform_driver_unregister(&chip_demo_gpio_driver);
  211. }
  212.  
  213. module_init(chip_demo_gpio_drv_init);
  214. module_exit(lchip_demo_gpio_drv_exit);
  215.  
  216. MODULE_LICENSE("GPL");
  217.

dts

  1. #define GROUP_PIN(g,p) ((g<<16) | (p))
  2.  
  3. / {
  4. 	100ask_led@0 {
  5. 		compatible = "100as,leddrv";
  6. 		pin = <GROUP_PIN(5, 3)>;//这里只要跟文件中对的上就行，实际还是操作硬件的
  7. 	};
  8.  
  9. 	100ask_led@1 {
  10. 		compatible = "100as,leddrv";
  11. 		pin = <GROUP_PIN(5, 8)>;
  12. 	};
  13.  
  14. };

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/688828
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号