• 【Linux驱动开发】点亮一个LED的三种字符设备驱动框架

    目录

    硬件原理图分析 

    GPIO3_IO03的引脚配置及原理分析

    1、 寄存器映射版本

     led.c

    2、设备树版本

    led.c

    imx6ull-alientek-emmc.dts

    3、pinctrl、gpio子系统版本

    led.c

    imx6ull-alientek-emmc.dts

    三个字符驱动版本都通用的LED点灯应用程序App.c

    Makefile工程管理器源码

    实验现象

    总结

    三种驱动框架分别为：

    ①寄存器映射版本

    ②设备树版本

    ③pinctrl、gpio子系统版本

    应用程序可共用同一个

    CPU：NXP的I.MX6ULL,基于ARM Cortex-A7架构；

    开发板：正点原子I.MX6U-ALPHA；

    linux内核：linux-4.1.15‘；

    硬件原理图分析 

     

            板子的LED0接到了GPIO3_IO03引脚上，当GPIO3_IO03输出为低电平（0）时二极管导通LED0就会被点亮；当GPIO3_IO03输出为高电平（1）时二极管截止LED0就会熄灭；

     （一个小小的建议：初学者一定要养成多动手翻看参考手册和原理图的习惯，这样今后的学习过程更容易举一反三）

    GPIO3_IO03的引脚配置及原理分析

    <1>使能 GPIO1时钟

    将寄存器CCM_CCGR1（物理地址：0x020C406C）的 bit27 和 bit26 这两个位，置成11；

     

    <2>设置 GPIO1_IO03的复用功能为GPIO模式

    往寄存器IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03中写入0x5即可，对应下图中的ALT5

    <3>配置 GPIO1_IO03 的电气属性

    往寄存器“IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO03"写入0x10B0(前十六位为： 0001 0000 1011 0000）;

    设置 IO的上下拉、速度等等。

    0x10B0(前十六位 0001 0000 1011 0000）的含义​​​​​​

    <4>设置GPIO1_IO03作为输出功能

    把寄存器 GPIO1_GDIR 的 bit3 置 1 ，表示GPIO作输出

    <5>控制GPIO1_IO03输出电平

    向 GPIO1_DR寄存器的 bit3 写入0即可控制 GPIO1_IO03输出低电平（开灯），写入1即可控制 GPIO1_IO03输出高电平（熄灯）

    1、 寄存器映射版本

     led.c

    1. /*
    2.  * @Author: imysy_22
    3.  * @Description: led灯字符型驱动程序寄存器映射版本
    4.  * @Date: 2022-10-17 12:46:27
    5.  * @LastEditTime: 2022-10-17 00:00:09
    6.  * @FilePath: /undefined/home/imysy22/IMX6U/rootfs/home/root/MyDrivers/2_led_chrdev/common_version/led.c
    7.  */
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17.  
    18. #define DevName "Mychr_led"
    19.  
    20. static int DevMajor = 11;
    21. static int DevMinor = 0;
    22.  
    23. /* 要点亮一个led灯所要操作的寄存器地址 */
    24. #define CCM_CCGR1_BASE 0x020C406C
    25. #define SW_MUX_GPIO1_IO03_BASE 0x020E0068
    26. #define SW_PAD_GPIO1_IO03_BASE 0x020E02F4
    27. #define GPIO1_DR_BASE 0x0209C000
    28. #define GPIO1_GDIR_BASE 0x0209C004
    29.  
    30. /* 寄存器物理地址映射的虚拟地址 */
    31. static void __iomem *IMX6U_CCM_CCGR1;
    32. static void __iomem *SW_MUX_GPIO1_IO03;
    33. static void __iomem *SW_PAD_GPIO1_IO03;
    34. static void __iomem *GPIO1_DR;
    35. static void __iomem *GPIO1_GDIR;
    36.  
    37. /**
    38.  * @description: 初始化、配置好寄存器
    39.  */
    40. static void led_ioremap(void)
    41. {
    42.     unsigned long RegVal = 0;
    43.  
    44.     /* 1、把寄存器的物理地址映射到虚拟地址 */
    45.     IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);   //4代表4个字节，4x8=32位寄存器
    46.     SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
    47.     SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
    48.     GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
    49.     GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);
    50.  
    51.     /* 2、开启GPIO1的时钟 */
    52.     RegVal = readl(IMX6U_CCM_CCGR1);
    53.     RegVal &= ~(0x3 << 26);
    54.     RegVal |= (0x3 << 26);
    55.     writel(RegVal, IMX6U_CCM_CCGR1);
    56.  
    57.     /* 3、把GPIO1_IO3复用成gpio */
    58.     writel(0x5, SW_MUX_GPIO1_IO03);
    59.  
    60.     /* 4、设置io属性 */
    61.     writel(0x10B0, SW_PAD_GPIO1_IO03);
    62.  
    63.     /* 5、配置成输出功能 */
    64.     RegVal = readl(GPIO1_GDIR);
    65.     RegVal &= ~(0x1 << 3);
    66.     RegVal |= (0x1 << 3);
    67.     writel(RegVal, GPIO1_GDIR);
    68.  
    69.     /* 6、默认输出高电平，关闭led */
    70.     RegVal = readl(GPIO1_DR);
    71.     RegVal &= ~(0x1 << 3);
    72.     RegVal |= (0x1 << 3);
    73.     writel(RegVal, GPIO1_DR);
    74. }   
    75.  
    76. static void led_on(void)
    77. {
    78.     unsigned long RegVal = 0;
    79.  
    80.     RegVal = readl(GPIO1_DR);
    81.     RegVal &= ~(0x1 << 3);
    82.     writel(RegVal, GPIO1_DR);
    83.  
    84. }
    85.  
    86. static void led_off(void)
    87. {
    88.     unsigned long RegVal = 0;
    89.  
    90.     RegVal = readl(GPIO1_DR);
    91.     RegVal |= (0x1 << 3);
    92.     writel(RegVal, GPIO1_DR);
    93.  
    94. }
    95.  
    96. struct led_dev {
    97.     struct cdev mdev;
    98.  
    99.     struct class *pcls;
    100.     struct device *pdev;
    101. };
    102.  
    103. struct led_dev gmydev;
    104.  
    105. /**
    106.  * @description: 
    107.  * @param {inode} *pnode
    108.  * @param {file} *pfile     设备文件，file结构体有个叫做private_data的成员变量,一般在open的时候将private_data指向设备结构体。
    109.  * @return {*}
    110.  */
    111. static int chr_led_open(struct inode *pnode,struct file *pfile)
    112. {
    113.     pfile->private_data = (void *) (container_of(pnode->i_cdev, struct led_dev, mdev)); //设置私有数据，后续可以直接找到gmydev的地址
    114.  
    115.     return 0;
    116. }
    117.  
    118. static int chr_led_release(struct inode *pnode,struct file *pfile)
    119. {
    120.  
    121.     return 0;
    122. }
    123.  
    124. static ssize_t chr_led_write(struct file *pfile,const char __user *puser,size_t size,loff_t *p_pos)
    125. {
    126.     int ret = 0;
    127.     char buf[1] = {0};
    128.     unsigned char led_state;
    129.  
    130.     if((ret = copy_from_user(buf, puser, size)))
    131.     {
    132.         printk("copy_from_user failed...\n");
    133.         return -1;
    134.     }
    135.  
    136.     led_state = buf[0];
    137.  
    138.     if(led_state == 0)
    139.     {
    140.         led_on();   //低电平开灯
    141.     }
    142.  
    143.     if(led_state == 1)
    144.     {
    145.         led_off();  //高电平关灯
    146.     }
    147.  
    148.     return 1;
    149. }
    150.  
    151.  
    152. struct file_operations myops = {
    153.     .owner = THIS_MODULE,
    154.     .open = chr_led_open,
    155.     .release = chr_led_release,
    156.     .write = chr_led_write,
    157. };
    158.  
    159. static int __init chr_led_init(void)
    160. {
    161.     int ret = 0;
    162.     dev_t devno = MKDEV(DevMajor, DevMinor);
    163.  
    164.     led_ioremap();  //配置好寄存器
    165.  
    166.     ret = register_chrdev_region(devno, 1, DevName);
    167.     if(ret)
    168.     {
    169.         ret = alloc_chrdev_region(&devno, DevMinor, 1, DevName);
    170.         if(ret)
    171.         {
    172.             printk("register failed...\n");
    173.             return -1;
    174.         }
    175.  
    176.         DevMajor = MAJOR(devno);
    177.     }
    178.  
    179.     cdev_init(&gmydev.mdev, &myops);
    180.  
    181.     gmydev.mdev.owner = THIS_MODULE;
    182.     cdev_add(&gmydev.mdev, devno, 1);
    183.  
    184.     gmydev.pcls = class_create(THIS_MODULE, DevName);
    185.     if(IS_ERR(gmydev.pcls))
    186.     {
    187.         printk("class_create failed...\n");
    188.         cdev_del(&gmydev.mdev);
    189.         unregister_chrdev_region(devno, 1);
    190.         
    191.         return -1;
    192.     }
    193.  
    194.     gmydev.pdev = device_create(gmydev.pcls, NULL, devno, NULL, DevName);
    195.     if(gmydev.pdev == NULL)
    196.     {
    197.         printk("device_create failed...\n");
    198.         class_destroy(gmydev.pcls);
    199.         cdev_del(&gmydev.mdev);
    200.         unregister_chrdev_region(devno, 1);
    201.         
    202.         return -1;
    203.     }
    204.  
    205.     printk("New character device(%d:%d) added successfully.\n", DevMajor, DevMinor);    
    206.  
    207.     return 0;
    208. }
    209.  
    210. static void __exit chr_led_exit(void)
    211. {
    212.     dev_t devno = MKDEV(DevMajor, DevMinor);
    213.     
    214.     /* 取消映射 */
    215.     iounmap(IMX6U_CCM_CCGR1);
    216.     iounmap(SW_MUX_GPIO1_IO03);
    217.     iounmap(SW_PAD_GPIO1_IO03);
    218.     iounmap(GPIO1_DR);
    219.     iounmap(GPIO1_GDIR);
    220.  
    221.     device_destroy(gmydev.pcls, devno);
    222.     class_destroy(gmydev.pcls);
    223.  
    224.     cdev_del(&gmydev.mdev); 
    225.  
    226.     unregister_chrdev_region(devno, 1);
    227. }
    228.  
    229. module_init(chr_led_init);
    230. module_exit(chr_led_exit);
    231.  
    232. MODULE_LICENSE("GPL");
    233. MODULE_AUTHOR("imysy_22-2022.10.17");

    2、设备树版本

    led.c

    1. /*
    2.  * @Author: imysy_22
    3.  * @Description: led灯字符型驱动程序设备树版本
    4.  * @Date: 2022-10-16 15:37:01
    5.  * @LastEditTime: 2022-10-18 17:31:31
    6.  * @FilePath: /undefined/home/imysy22/IMX6U/rootfs/home/root/MyDrivers/2_led_chrdev/device_tree_version/led.c
    7.  */
    8.  
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23.  
    24. #define DevName "Mychr_led"
    25.  
    26. //static int gmydev.major = 13;
    27. //static int gmydev.minor = 0;
    28.  
    29. static void __iomem *IMX6U_CCM_CCGR1;
    30. static void __iomem *SW_MUX_GPIO1_IO03;
    31. static void __iomem *SW_PAD_GPIO1_IO03;
    32. static void __iomem *GPIO1_DR;
    33. static void __iomem *GPIO1_GDIR;
    34.  
    35. struct led_dev {
    36.     int major;
    37.     int minor;
    38.     dev_t devno;
    39.  
    40.     struct cdev mdev;
    41.  
    42.     struct class *pcls;
    43.     struct device *pdev;
    44.  
    45.     struct device_node *pnd;
    46.     struct property *proper;
    47. };
    48.  
    49. struct led_dev gmydev;
    50.  
    51. /**
    52.  * @description: 初始化、配置好寄存器
    53.  */
    54. static void led_ioremap(struct led_dev gmydev, u32 *RegData);
    55. static void led_on(void);
    56. static void led_off(void);
    57.  
    58.  
    59. /**
    60.  * @description: 
    61.  * @param {inode} *pnode
    62.  * @param {file} *pfile     设备文件，file结构体有个叫做private_data的成员变量,一般在open的时候将private_data指向设备结构体。
    63.  * @return {*}
    64.  */
    65. static int chr_led_open(struct inode *pnode,struct file *pfile)
    66. {
    67.     pfile->private_data = (void *) (container_of(pnode->i_cdev, struct led_dev, mdev));
    68.  
    69.     return 0;
    70. }
    71.  
    72. static int chr_led_release(struct inode *pnode,struct file *pfile)
    73. {
    74.  
    75.     return 0;
    76. }
    77.  
    78. static ssize_t chr_led_write(struct file *pfile,const char __user *puser,size_t size,loff_t *p_pos)
    79. {
    80.     int ret = 0;
    81.     char buf[1] = {0};
    82.     unsigned char led_state;
    83.  
    84.     if((ret = copy_from_user(buf, puser, size)))
    85.     {
    86.         printk("copy_from_user failed...\n");
    87.         return -1;
    88.     }
    89.  
    90.     led_state = buf[0];
    91.  
    92.     if(led_state == 0)
    93.     {
    94.         led_on();   //低电平开灯
    95.     }
    96.  
    97.     if(led_state == 1)
    98.     {
    99.         led_off();  //高电平关灯
    100.     }
    101.  
    102.     return 1;
    103. }
    104.  
    105.  
    106. struct file_operations myops = {
    107.     .owner = THIS_MODULE,
    108.     .open = chr_led_open,
    109.     .release = chr_led_release,
    110.     .write = chr_led_write,
    111. };
    112.  
    113. static int __init chr_led_init(void)
    114. {
    115.     int ret = 0;
    116.     const char *str;
    117.     u32 RegData[14] = {0};
    118.     unsigned char i = 0;
    119.  
    120.     /* 获取设备树中的属性数据 */
    121.     
    122.     /* 1、获取设备节点：alpha-led */
    123.     if((gmydev.pnd = of_find_node_by_path("/alpha-led")) == NULL)
    124.     {
    125.         printk("of_find_node_by_path failed...\n");
    126.         return -EINVAL;
    127.     }
    128.  
    129.     /* 2、获取compatible属性内容 */
    130.     if((gmydev.proper = of_find_property(gmydev.pnd, "atkalpha-led", NULL)) == NULL)
    131.     {
    132.         printk("of_find_property failed...\n");
    133.         //return -1;
    134.     }
    135.  
    136.     /* 3、获取status属性内容 */
    137.     if((ret = of_property_read_string(gmydev.pnd, "status", &str)) < 0)
    138.     {
    139.         printk("of_property_read_string failed...\n");
    140.         //return -1;
    141.     }
    142.  
    143.     printk("status = %s\n", str);
    144.  
    145.     /* 4、获取reg属性内容 */
    146.  
    147.     if((ret = of_property_read_u32_array(gmydev.pnd, "reg", RegData, 10)) < 0)
    148.     {
    149.         printk("of_property_read_u32_array failed...\n");
    150.         //return -1;
    151.     }
    152.  
    153.     
    154.     printk("reg data :\n");
    155.  
    156.     for(i = 0;i < 10; i++)
    157.         printk("%#x ", RegData[i]);
    158.  
    159.     printk("\n");
    160.  
    161.     /* static void led_ioremap(void)函数 */
    162.     led_ioremap(gmydev, RegData);
    163.     
    164.     gmydev.major = 13;
    165.     gmydev.minor = 0;
    166.     gmydev.devno = MKDEV(gmydev.major, gmydev.minor);
    167.  
    168.     ret = register_chrdev_region(gmydev.devno, 1, DevName);
    169.     if(ret)
    170.     {
    171.         ret = alloc_chrdev_region(&gmydev.devno, gmydev.minor, 1, DevName);
    172.         if(ret)
    173.         {
    174.             printk("register failed...\n");
    175.             return -1;
    176.         }
    177.  
    178.         gmydev.major = MAJOR(gmydev.devno);
    179.         gmydev.minor = MINOR(gmydev.devno);
    180.     }
    181.  
    182.     cdev_init(&gmydev.mdev, &myops);
    183.  
    184.     gmydev.mdev.owner = THIS_MODULE;
    185.     cdev_add(&gmydev.mdev, gmydev.devno, 1);
    186.  
    187.     gmydev.pcls = class_create(THIS_MODULE, DevName);
    188.     if(IS_ERR(gmydev.pcls))
    189.     {
    190.         printk("class_create failed...\n");
    191.         cdev_del(&gmydev.mdev);
    192.         unregister_chrdev_region(gmydev.devno, 1);
    193.         
    194.         return -1;
    195.     }
    196.  
    197.     gmydev.pdev = device_create(gmydev.pcls, NULL, gmydev.devno, NULL, DevName);
    198.     if(gmydev.pdev == NULL)
    199.     {
    200.         printk("device_create failed...\n");
    201.         class_destroy(gmydev.pcls);
    202.         cdev_del(&gmydev.mdev);
    203.         unregister_chrdev_region(gmydev.devno, 1);
    204.         
    205.         return -1;
    206.     }
    207.  
    208.     printk("New character device(%d:%d) added successfully.\n", gmydev.major, gmydev.minor);    
    209.  
    210.     return 0;
    211. }
    212.  
    213. static void __exit chr_led_exit(void)
    214. {
    215.     /* 取消映射 */
    216.     iounmap(IMX6U_CCM_CCGR1);
    217.     iounmap(SW_MUX_GPIO1_IO03);
    218.     iounmap(SW_PAD_GPIO1_IO03);
    219.     iounmap(GPIO1_DR);
    220.     iounmap(GPIO1_GDIR);
    221.  
    222.     device_destroy(gmydev.pcls, gmydev.devno);
    223.     class_destroy(gmydev.pcls);
    224.  
    225.     cdev_del(&gmydev.mdev); 
    226.  
    227.     unregister_chrdev_region(gmydev.devno, 1);
    228. }
    229.  
    230. static void led_ioremap(struct led_dev gmydev, u32 *RegData)
    231. {
    232.     unsigned long RegVal = 0;
    233.  
    234.     /* 1、把寄存器的物理地址映射到虚拟地址 */
    235. #if 1
    236.     IMX6U_CCM_CCGR1 = ioremap(RegData[0], RegData[1]);   //4代表4个字节，4x8=32位寄存器
    237.     SW_MUX_GPIO1_IO03 = ioremap(RegData[2], RegData[3]);
    238.     SW_PAD_GPIO1_IO03 = ioremap(RegData[4], RegData[5]);
    239.     GPIO1_DR = ioremap(RegData[6], RegData[7]);
    240.     GPIO1_GDIR = ioremap(RegData[8], RegData[9]);
    241. #else
    242.     IMX6U_CCM_CCGR1 = of_ioremap(RegData[0], RegData[1]);   //4代表4个字节，4x8=32位寄存器
    243.     SW_MUX_GPIO1_IO03 = of_ioremap(RegData[2], RegData[3]);
    244.     SW_PAD_GPIO1_IO03 = of_ioremap(RegData[4], RegData[5]);
    245.     GPIO1_DR = of_ioremap(RegData[6], RegData[7]);
    246.     GPIO1_GDIR = of_ioremap(RegData[8], RegData[9]);
    247. #endif
    248.     /* 2、开启GPIO1的时钟 */
    249.     RegVal = readl(IMX6U_CCM_CCGR1);
    250.     RegVal &= ~(0x3 << 26);
    251.     RegVal |= (0x3 << 26);
    252.     writel(RegVal, IMX6U_CCM_CCGR1);
    253.  
    254.     /* 3、把GPIO1_IO3复用成gpio */
    255.     writel(0x5, SW_MUX_GPIO1_IO03);
    256.  
    257.     /* 4、设置io属性 */
    258.     writel(0x10B0, SW_PAD_GPIO1_IO03);
    259.  
    260.     /* 5、配置成输出功能 */
    261.     RegVal = readl(GPIO1_GDIR);
    262.     RegVal &= ~(0x1 << 3);
    263.     RegVal |= (0x1 << 3);
    264.     writel(RegVal, GPIO1_GDIR);
    265.  
    266.     /* 6、默认输出高电平，关闭led */
    267.     RegVal = readl(GPIO1_DR);
    268.     RegVal &= ~(0x1 << 3);
    269.     RegVal |= (0x1 << 3);
    270.     writel(RegVal, GPIO1_DR);
    271. }
    272.  
    273. static void led_on(void)
    274. {
    275.     unsigned long RegVal = 0;
    276.  
    277.     RegVal = readl(GPIO1_DR);
    278.     RegVal &= ~(0x1 << 3);
    279.     writel(RegVal, GPIO1_DR);
    280.  
    281. }
    282.  
    283. static void led_off(void)
    284. {
    285.     unsigned long RegVal = 0;
    286.  
    287.     RegVal = readl(GPIO1_DR);
    288.     RegVal |= (0x1 << 3);
    289.     writel(RegVal, GPIO1_DR);
    290.  
    291. }
    292.  
    293. module_init(chr_led_init);
    294. module_exit(chr_led_exit);
    295.  
    296. MODULE_LICENSE("GPL");
    297. MODULE_AUTHOR("imysy_22-2022.10.16");

    imx6ull-alientek-emmc.dts

    需要在 “ / ” 根节点下增加一个“alpha-led”子节点

    1. alpha-led {		/* LED第一代：《设备树版》 */
    2. 	#address-cells = <1>;	/* 用于描述子节点的地址信息，即reg属性中，地址信息占几个uint32 */
    3. 	#size-cells = <1>;		/* 地址长度占几个u32，单位为u32（4字节） */
    4. 	compatible = "atkalpha-led";
    5. 	status = "okey";
    6. 	reg = <	0X020C406C 0X04 /* CCM_CCGR1_BASE */
    7. 			0X020E0068 0X04	/* SW_MUX_GPIO1_IO03_BASE */
    8. 			0X020E02F4 0X04	/* SW_PAD_GPIO1_IO03_BASE */
    9. 			0X0209C000 0X04	/* GPIO1_DR_BASE */
    10. 			0X0209C004 0X04	/* GPIO1_GDIR_BASE */
    11. 		>;
    12. };

    3、pinctrl、gpio子系统版本

    led.c

    1. /*
    2.  * @Author: imysy_22
    3.  * @Description: led灯字符型驱动程序pinctrl_gpio子系统版本
    4.  * @Date: 2022-10-18 23:12:03
    5.  * @LastEditTime: 2022-10-18 23:48:27
    6.  * @FilePath: /undefined/home/imysy22/IMX6U/Linux_Drivers/2_led_chrdev/pinctrl_gpio_version/led.c
    7.  */
    8.  
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23.  
    24. #define DevName "gpioled"
    25.  
    26. struct gpioled_dev {
    27.     int major;
    28.     int minor;
    29.     int led_gpio;   /* led所使用的gpio编号 */
    30.     dev_t devno;
    31.  
    32.     struct cdev mdev;
    33.  
    34.     struct class *pcls;
    35.     struct device *pdev;
    36.  
    37.     struct device_node *pnd;
    38.     struct property *proper;
    39.  
    40. };
    41.  
    42. struct gpioled_dev gmydev;
    43.  
    44. static void led_on(struct file *pfile);
    45. static void led_off(struct file *pfile);
    46.  
    47. /**
    48.  * @description: 
    49.  * @param {inode} *pnode
    50.  * @param {file} *pfile     设备文件，file结构体有个叫做private_data的成员变量,一般在open的时候将private_data指向设备结构体。
    51.  * @return {*}
    52.  */
    53. static int chr_led_open(struct inode *pnode,struct file *pfile)
    54. {
    55.     pfile->private_data = (void *) (container_of(pnode->i_cdev, struct gpioled_dev, mdev));
    56.  
    57.     return 0;
    58. }
    59.  
    60. static int chr_led_release(struct inode *pnode,struct file *pfile)
    61. {
    62.  
    63.     return 0;
    64. }
    65.  
    66. static ssize_t chr_led_write(struct file *pfile,const char __user *puser,size_t size,loff_t *p_pos)
    67. {
    68.     int ret = 0;
    69.     char buf[1] = {0};
    70.     unsigned char led_state;
    71.  
    72.     if((ret = copy_from_user(buf, puser, size)))
    73.     {
    74.         printk("copy_from_user failed...\n");
    75.         return -1;
    76.     }
    77.  
    78.     led_state = buf[0];
    79.  
    80.     if(led_state == 0)
    81.     {
    82.         led_on(pfile);   //低电平开灯
    83.     }
    84.  
    85.     if(led_state == 1)
    86.     {
    87.         led_off(pfile);  //高电平关灯
    88.     }
    89.  
    90.     return 1;
    91. }
    92.  
    93.  
    94. struct file_operations myops = {
    95.     .owner = THIS_MODULE,
    96.     .open = chr_led_open,
    97.     .release = chr_led_release,
    98.     .write = chr_led_write,
    99. };
    100.  
    101. static int __init chr_led_init(void)
    102. {
    103.     int ret = 0;
    104.  
    105.     /* 
    106.         获取设备树中的属性数据 
    107.             前面操作设备树节点这几步操作和设备树版本的不一样
    108.     */
    109.     
    110.     /* 1、获取设备节点：gpioled */
    111.     if((gmydev.pnd = of_find_node_by_path("/gpioled")) == NULL)
    112.     {
    113.         printk("of_find_node_by_path failed...\n");
    114.         return -EINVAL;
    115.     }
    116.  
    117.     /* 2、获取gpio子系统中设备树中的gpio的电气属性，并得到Led所使用的GPIO编号 */
    118.     if((gmydev.led_gpio = of_get_named_gpio(gmydev.pnd, "led-gpio", 0)) < 0)
    119.     {
    120.         printk("of_get_named_gpio failed...\n");
    121.         return -EINVAL;
    122.     }
    123.  
    124.     printk("led-gpio num = %d\n", gmydev.led_gpio);
    125.  
    126.     /* 3、设置GPIO1_IO03为输出，并输出高电平，默认熄灭led灯 */
    127.     if((ret = gpio_direction_output(gmydev.led_gpio, 1)) < 0)
    128.     {
    129.         printk("gpio_direction_output failed...\n");
    130.         return -EINVAL;
    131.     }
    132.  
    133.     printk("**LED0 initialzation successed***\n");
    134.     
    135.     /* 注册设备流程和设备树版本的LED一样 */
    136.  
    137.     gmydev.major = 14;
    138.     gmydev.minor = 0;
    139.     gmydev.devno = MKDEV(gmydev.major, gmydev.minor);
    140.  
    141.     ret = register_chrdev_region(gmydev.devno, 1, DevName);
    142.     if(ret)
    143.     {
    144.         ret = alloc_chrdev_region(&gmydev.devno, gmydev.minor, 1, DevName);
    145.         if(ret)
    146.         {
    147.             printk("register failed...\n");
    148.             return -1;
    149.         }
    150.  
    151.         gmydev.major = MAJOR(gmydev.devno);
    152.         gmydev.minor = MINOR(gmydev.devno);
    153.     }
    154.  
    155.     cdev_init(&gmydev.mdev, &myops);
    156.  
    157.     gmydev.mdev.owner = THIS_MODULE;
    158.     cdev_add(&gmydev.mdev, gmydev.devno, 1);
    159.  
    160.     gmydev.pcls = class_create(THIS_MODULE, DevName);
    161.     if(IS_ERR(gmydev.pcls))
    162.     {
    163.         printk("class_create failed...\n");
    164.         cdev_del(&gmydev.mdev);
    165.         unregister_chrdev_region(gmydev.devno, 1);
    166.         
    167.         return -1;
    168.     }
    169.  
    170.     gmydev.pdev = device_create(gmydev.pcls, NULL, gmydev.devno, NULL, DevName);
    171.     if(gmydev.pdev == NULL)
    172.     {
    173.         printk("device_create failed...\n");
    174.         class_destroy(gmydev.pcls);
    175.         cdev_del(&gmydev.mdev);
    176.         unregister_chrdev_region(gmydev.devno, 1);
    177.         
    178.         return -1;
    179.     }
    180.  
    181.     printk("New character device(%d:%d) added successfully.\n", gmydev.major, gmydev.minor);    
    182.  
    183.     return 0;
    184. }
    185.  
    186. static void __exit chr_led_exit(void)
    187. {
    188.     device_destroy(gmydev.pcls, gmydev.devno);
    189.     class_destroy(gmydev.pcls);
    190.  
    191.     cdev_del(&gmydev.mdev); 
    192.  
    193.     unregister_chrdev_region(gmydev.devno, 1);
    194. }
    195.  
    196. static void led_on(struct file *pfile)
    197. {
    198.     struct gpioled_dev *pmydev = pfile->private_data;
    199.  
    200.     gpio_set_value(pmydev->led_gpio, 0);
    201.  
    202. }
    203.  
    204. static void led_off(struct file *pfile)
    205. {
    206.     struct gpioled_dev *pmydev = pfile->private_data;
    207.  
    208.     gpio_set_value(pmydev->led_gpio, 1);
    209. }
    210.  
    211. module_init(chr_led_init);
    212. module_exit(chr_led_exit);
    213.  
    214. MODULE_LICENSE("GPL");
    215. MODULE_AUTHOR("imysy_22-2022.10.16");

    imx6ull-alientek-emmc.dts

    在" / "根节点外部的 iomuxc 节点的“imx6ul-evk”子节点下创建一个名为“pinctrl_led”子子节点（套娃）

    1. pinctrl_led: ledgrp {		/* LED第二代：《pinctrl和gpio子系统版》 */
    2. 	fsl,pins = <
    3. 		MX6UL_PAD_GPIO1_IO03__GPIO1_IO03	0x10B0
    4. 	>;
    5. };

    其中，MX6UL_PAD_GPIO1_IO03__GPIO1_IO03这个宏的定义在文件arch/arm/boot/dts/imx6ul-pinfunc.h中。

    再在" / "根节点内部创建一个“gpioled”节点

    1. gpioled {
    2. 	#address-cells = <1>;
    3. 	#size-cells = <1>;
    4. 	compatible = "atkalpha-gpioled";
    5. 	pinctrl-names = "default";
    6. 	pinctrl-0 = <&pinctrl_led>;
    7. 	led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
    8. 	status = "okey";
    9. };

    添加完后，一定不要忘记检查PIN是否正被其他外设使用！！！

    在设备树中搜索“ GPIO1_IO03 ”，如果有别的设备节点在也在使用这个PIN的话，屏蔽它

    pinctrl_tsc节点是TSC(电阻触摸屏接口)的pinctrl节点，从第480行可以看出，默认情况下GPIO1_IO03作为了TSC外设的PIN。所以我们需要将第480行屏蔽掉!和C语言一样，在要屏蔽的内容前后加上“/*”和“*/”符号即可。实际上我们目前并不会用到这个节点，所以我干脆把它的PIN全屏蔽了。

    编译设备树

     进入Linux顶层源码目录，生成imx6ull-alientek-emmc.dts并重启开发板时加载这个新的设备树

    正确的现象：/proc/device-tree目录下生成了我们的“ gpioled ”文件，进入文件后会自动生成我们之前在设备树里 “gpioled” 节点中的'#address-cells'  compatible  led-gpio  name  pinctrl-0  pinctrl-names  '#size-cells'  status属性

    三个字符驱动版本都通用的LED点灯应用程序App.c

    第32行的open函数需根据不同的驱动程序申请的字符设备名字不同进行修改

    1. /*
    2.  * @Author: imysy_22
    3.  * @Description: 三个字符驱动版本都统用的LED点灯应用程序
    4.  * @Date: 2022-10-17 12:46:27
    5.  * @LastEditTime: 2022-10-17 14:15:19
    6.  * @FilePath: /undefined/home/imysy22/IMX6U/Linux_Drivers/2_led_chrdev/common_version/App.c
    7.  */
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15.  
    16. int main(int argc, const char *argv[])
    17. {
    18.     int fd = -1;
    19.     int ret;
    20.     unsigned char led_state[1];
    21.     
    22.     /* 低电平点灯，高电平熄灭 */
    23.     if(argc != 2)
    24.     {
    25.         printf("*********************************************\n");
    26.         printf("* Please input : ./App 0-led_on / 1-led_off *\n");
    27.         printf("*********************************************\n");
    28.  
    29.         return -1;
    30.     }
    31.  
    32.     if((fd = open("/dev/Mychr_led", O_WRONLY)) < 0)
    33.     {
    34.         perror("open");
    35.         return -1;
    36.     }
    37.  
    38.     printf("***open success***\n\n\n");
    39.  
    40.     led_state[0] = atoi(argv[1]);
    41.  
    42.     /* 如果是点灯 */
    43.     if(led_state[0] == 0)
    44.     {
    45.         if((ret = write(fd, led_state, 1)) < 0)
    46.         {
    47.             perror("write");
    48.         }
    49.  
    50.         printf("Led is ON!\n");
    51.     }
    52.     else if(led_state[0] == 1)
    53.     {
    54.         if((ret = write(fd, led_state, 1)) < 0)
    55.         {
    56.             perror("write");
    57.         }
    58.  
    59.         printf("Led is OFF!\n");
    60.     }
    61.     else
    62.     {
    63.         printf("You can only input 0 or 1!\n");
    64.         close(fd);
    65.         return -1;
    66.     }
    67.     
    68.     close(fd);
    69.  
    70.     return 0;
    71. }

    Makefile工程管理器源码

    1.  
    2. CONFIG_MODULE_SIG=n		#加了这一行就不会报错：signature and/or required key missing - tainting kernel
    3. ifeq ($(KERNELRELEASE),)
    4.  
    5. ifeq ($(ARCH),arm)
    6. KERNELDIR ?= /home/imysy22/IMX6U/linux-imx-rel_imx_4.1.15_2.1.0_ga
    7. CC = /home/imysy22/LicheePi/buildroot-2017.08.1/output/host/bin/arm-linux-gnueabihf-gcc
    8. else
    9. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
    10. endif
    11. PWD := $(shell pwd)
    12.  
    13. modules:
    14. 	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
    15. modules_install:
    16. 	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install
    17. clean:
    18. 	rm -rf *.o *.ko .*.cmd *.mod.* modules.order Module.symvers .tmp_versions
    19.  
    20. else
    21.  
    22. obj-m += led.o
    23.  
    24. endif

    实验现象

    三个模块的实验现象都差不多，只不过insmod led.ko后printk打印的内容不一样而已

    # ./App 0    //低电平点亮

    # ./App 1    //高电平熄灭

    总结

         ☆ * .  ☆      
       . ∧＿∧   ∩ * ☆      
    * ☆ ( `∀‘)/ .      
     . ⊂   ノ* ☆          
    ☆ * (つ ノ .☆
       (ノ

    哈哈用超级复杂的方法点亮led灯，虽然这个实验现象非常low，但是用三种不同的驱动框架来点灯还是着实学不到了不少啊！！！ 

  • 相关阅读:
    List集合的对象传输的两种方式
    简单选择排序（数据结构）
    2023/10/30-LED灯驱动开发
    Spring、MyBatis、Druid、MySQL不使用事务执行SQL语句分析
    常用的英文缩写总结，专业术语
    REVERSE-COMPETITION-HWS-5TH-2022
    CloudCompare中CCCoreLib模块介绍
    【AI视野·今日NLP 自然语言处理论文速览 第五十五期】Mon, 16 Oct 2023
    Linux学习记录——사 权限与工具
    小学数学深度教学论文
  • 原文地址：https://blog.csdn.net/imysy_22_/article/details/127399319