• 驱动开发---基于gpio子系统编写LED灯的驱动

    一、GPIO子系统相关API

    1.解析GPIO相关的设备树节点

    1. struct device_node *of_find_node_by_path(const char *path)
    2. 功能：根据设备树节点路径解析设备树节点信息
    3. 参数：
    4. path：设备树所在的节点路径   /mynode@0X12345678
    5. 返回值：成功返回目标节点首地址，失败返回NULL

    2.根据解析的GPIO相关节点信息获取GPIO编号

    1. #include
    2. int of_get_named_gpio(struct device_node *np,const char *propname, int index)
    3. 功能：获取GPIO编号
    4. 参数：
    5.     np:设备树节点指针
    6.     proname:gpio编号信息对应到的键名
    7.     index:管脚在这个属性键值对中的索引号
    8. 返回值：成功返回GPIO编号，失败返回错误码

    3.向内核申请要使用的GPIO编号

    1. #include
    2. int gpio_request(unsigned gpio, const char *label)
    3. 功能：申请GPIO编号
    4. 参数：
    5.     gpio:要申请的GPIO编号
    6.     label:标签，填NULL
    7. 返回值：成功返回0，失败返回错误码
    1. int gpio_direction_input(unsigned gpio)
    2. 功能：将gpio编号对应的gpio管脚设置为输入
    3. 参数：
    4.     gpio：gpio编号
    5. 返回值:成功返回0，失败返回错误码
    1. int gpio_direction_output(unsigned gpio, int value)
    2. 功能：将gpio编号对应的gpio管脚设置为是输出
    3. 参数：
    4.     gpio:gpio编号
    5.     value:默认的输出值  （1）输出高电平  （0）输出低电平
    6. 返回值：成功返回0，失败返回错误码
    1. void gpio_set_value(unsigned gpio, int value)
    2. 功能：设置gpio编号对应的gpio管脚 输出高低电平
    3. 参数：
    4.     gpio:gpio编号
    5.     value:默认的输出值  （1）输出高电平  （0）输出低电平
    6. 返回值：无 
    1. int gpio_get_value(unsigned gpio)
    2. 功能：获取gpio编号对应到的GPIO引脚状态值
    3. 参数：
    4. gpio:gpio编号
    5. 返回值：1（高电平）  0（低电平状态）
    1. void gpio_free(unsigned gpio)
    2. 功能：释放GPIO编号
    3. 参数：要释放的gpio编号

    二、添加LED的设备树节点信息

    在stm32mp157a-fsmp1a.dts文件的根节点中添加如下内容

    1. myled{
    2.     led1-gpio=<&gpioe 10 0>;//10表示使用的gpioe第几个管脚  0，表示gpio默认属性
    3.     led2-gpio=<&gpiof 10 0>;
    4.     led3-gpio=<&gpioe 8 0>;
    5. };

    三、基于gpio子系统编写LED灯的驱动

    1.头文件

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__ 
    3. typedef struct{
    4.     unsigned int MODER;
    5.     unsigned int OTYPER;
    6.     unsigned int OSPEEDR;
    7.     unsigned int PUPDR;
    8.     unsigned int IDR;
    9.     unsigned int ODR;
    10. }gpio_t;
    11. #define PHY_LED1_ADDR 0X50006000
    12. #define PHY_LED2_ADDR    0X50007000
    13. #define PHY_LED3_ADDR 0X50006000
    14. #define PHY_RCC_ADDR    0X50000A28
    15.  
    16. //构建LED开关的功能码
    17. #define LED_ON _IO('l',1)
    18. #define LED_OFF _IO('l',0)
    19. #endif

    2.测试文件

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    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("打开文件myled0成功\n");
    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("打开文件myled1成功\n");
    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("打开文件myled2成功\n");
    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_OFF);
    62. 				break;
    63. 			default:
    64. 				printf("请输入'0'或'1'\n");
    65. 		}
    66. 		close(fd);
    67. 		printf("关闭文件\n");		
    68. 	}
    69. 	
    70. 	return 0;
    71. }

    3.驱动文件

    1. #include 
    2. #include 
    3. #include
    4. #include 
    5. #include 
    6. #include 
    7. #include
    8. #include
    9. #include 
    10. #include 
    11. #include 
    12. #include "head.h"
    13.  
    14. struct cdev *cdev;
    15. char kbuf[128]={0};
    16. unsigned int major=0;
    17. unsigned int minor=0;
    18. dev_t devno;
    19. module_param(major,uint,0664);//方便在命令行传递major的值
    20. struct class*cls;
    21. struct device *dev;
    22.  
    23. gpio_t *vir_led1;
    24. gpio_t *vir_led2;
    25. gpio_t *vir_led3;
    26. unsigned int *vir_rcc;
    27. struct device_node *dnode;
    28. struct gpio_desc *gpiono1;
    29. struct gpio_desc *gpiono2; 
    30. struct gpio_desc *gpiono3;  
    31.  
    32. int mycdev_open(struct inode *inode, struct file *file)
    33. {
    34. 	int min=MINOR(inode->i_rdev);//根据打开的文件对应的设备号获取次设备号
    35.     file->private_data=(void *)min;
    36.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    37.     return 0;
    38. }
    39.  
    40. long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    41. {
    42. 	int min=(int)file->private_data;
    43.    
    44. 	switch(min)
    45. 	{
    46. 	case 0://控制LED1
    47. 		switch (cmd)
    48. 		{
    49. 		case LED_ON: // 开灯
    50. 			gpiod_set_value(gpiono1,1);
    51. 			break;
    52. 		case LED_OFF://关灯
    53. 			gpiod_set_value(gpiono1,0);
    54. 			break;
    55. 		}
    56. 		break;
    57.  
    58. 	case 1://控制LED2
    59.       
    60. 		switch (cmd)
    61. 		{
    62.             case LED_ON: // 开灯
    63. 			gpiod_set_value(gpiono2,1);
    64. 			break;
    65. 		case LED_OFF://关灯
    66. 			gpiod_set_value(gpiono2,0);
    67. 			break;
    68. 		}
    69. 		break;
    70. 	case 2://控制LED3
    71.        
    72. 		switch (cmd)
    73. 		{
    74.             case LED_ON: // 开灯
    75. 			gpiod_set_value(gpiono3,1);
    76. 			break;
    77. 		case LED_OFF://关灯
    78. 			gpiod_set_value(gpiono3,0);
    79. 			break;
    80. 		}
    81. 		break;
    82.     }
    83.     return 0;
    84. }
    85. int mycdev_close(struct inode *inode, struct file *file)
    86. {
    87.     printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    88.     return 0;
    89. }
    90.  
    91. // 定义操作方法结构体变量并赋值
    92. struct file_operations fops = {
    93.  
    94.     .open = mycdev_open,
    95.     .unlocked_ioctl = mycdev_ioctl,
    96.     .release = mycdev_close,
    97. };
    98.  
    99. int all_led_init(void)
    100. {
    101.     // 寄存器地址的映射
    102.     vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    103.     if (vir_led1 == NULL)
    104.     {
    105.         printk("ioremap filed：%d\n", __LINE__);
    106.         return -ENOMEM;
    107.     }
    108.     vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    109.     if (vir_led2 == NULL)
    110.     {
    111.         printk("ioremap filed：%d\n", __LINE__);
    112.         return -ENOMEM;
    113.     }
    114.     vir_led3 = vir_led1;
    115.     vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    116.     if (vir_rcc == NULL)
    117.     {
    118.         printk("ioremap filed：%d\n", __LINE__);
    119.         return -ENOMEM;
    120.     }
    121.     printk("物理地址映射成功\n");
    122.     // 寄存器的初始化
    123.     // rcc
    124.     (*vir_rcc) |= (0X3 << 4);
    125.     // led1
    126.     vir_led1->MODER &= (~(3 << 20));
    127.     vir_led1->MODER |= (1 << 20);
    128.     vir_led1->ODR &= (~(1 << 10));
    129.     // led2
    130.     vir_led2->MODER &= (~(3 << 20));
    131.     vir_led2->MODER |= (1 << 20);
    132.     vir_led2->ODR &= (~(1 << 10));
    133.     // led3
    134.     vir_led3->MODER &= (~(3 << 16));
    135.     vir_led1->MODER |= (1 << 16);
    136.     vir_led1->ODR &= (~(1 << 8));
    137.     printk("寄存器初始化成功\n");
    138.  
    139.     return 0;
    140. }
    141.  
    142. static int __init mycdev_init(void)
    143. {
    144.      int ret;
    145.     //为字符设备驱动对象申请空间
    146.     cdev=cdev_alloc();
    147.     if(cdev==NULL)
    148.     {
    149.         printk("字符设备驱动对象申请空间失败\n");
    150.         ret=-EFAULT;
    151.         goto out1;
    152.     }
    153.     printk("申请对象空间成功\n");
    154.     //初始化字符设备驱动对象
    155.     cdev_init(cdev,&fops);
    156.     //申请设备号
    157.     if(major>0)//静态指定设备号
    158.     {
    159.         ret=register_chrdev_region(MKDEV(major,minor),3,"myled");
    160.         if(ret)
    161.         {
    162.             printk("静态申请设备号失败\n");
    163.             goto out2;
    164.         }
    165.     }
    166.     else if(major==0)//动态申请设备号
    167.     {
    168.         ret=alloc_chrdev_region(&devno,minor,3,"myled");
    169.         if(ret)
    170.         {
    171.             printk("动态申请设备号失败\n");
    172.             goto out2;
    173.         }
    174.         major=MAJOR(devno);//获取主设备号
    175.         minor=MINOR(devno);//获取次设备号
    176.  
    177.     }
    178.     printk("申请设备号成功\n");
    179.     //注册字符设备驱动对象
    180.     ret=cdev_add(cdev,MKDEV(major,minor),3);
    181.     if(ret)
    182.     {
    183.         printk("注册字符设备驱动对象失败\n");
    184.         goto out3;
    185.     }
    186.     printk("注册字符设备驱动对象成功\n");
    187. 	
    188. 	//寄存器映射及初始化
    189. 	all_led_init();
    190.  
    191.     //向上提交目录信息
    192.     cls=class_create(THIS_MODULE,"myled");
    193.     if(IS_ERR(cls))
    194.     {
    195.         printk("向上提交目录失败\n");
    196.         ret=-PTR_ERR(cls);
    197.         goto out4;
    198.     }
    199.     printk("向上提交目录成功\n");
    200.     //向上提交设备节点信息
    201.     int i;
    202.     for(i=0;i<3;i++)
    203.     {
    204.         dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
    205.         if(IS_ERR(dev))
    206.         {
    207.             printk("向上提交设备节点信息失败\n");
    208.             ret=-PTR_ERR(dev);
    209.             goto out5;
    210.         }
    211.     }
    212.     printk("向上提交设备信息成功\n");
    213.      //解析LED的设备树节点
    214.     dnode=of_find_node_by_path("/myled");
    215.     if(dnode==NULL)
    216.     {
    217.         printk("解析设备树节点失败\n");
    218.         return -ENXIO;
    219.     }
    220.     printk("解析GPIO信息成功\n");
    221.     gpiono1=gpiod_get_from_of_node(dnode,"led1-gpio",0,GPIOD_OUT_LOW,NULL);
    222.         if(IS_ERR(gpiono1))
    223.         {
    224.             printk("申请gpio对象失败\n");
    225.             return -ENXIO;
    226.         }
    227.         printk("申请gpio信息对象成功\n");
    228.  
    229.     gpiono2=gpiod_get_from_of_node(dnode,"led2-gpio",0,GPIOD_OUT_LOW,NULL);
    230.         if(IS_ERR(gpiono2))
    231.         {
    232.             printk("申请gpio对象失败\n");
    233.             return -ENXIO;
    234.         }
    235.         printk("申请gpio信息对象成功\n");
    236.     gpiono3=gpiod_get_from_of_node(dnode,"led3-gpio",0,GPIOD_OUT_LOW,NULL);
    237.         if(IS_ERR(gpiono3))
    238.         {
    239.             printk("申请gpio对象失败\n");
    240.             return -ENXIO;
    241.         }
    242.         printk("申请gpio信息对象成功\n");
    243.  
    244.  
    245.  
    246.  
    247.     return 0;
    248. out5:
    249.     //释放前一次提交成功的设备信息
    250.     for(--i;i>=0;i--)
    251.     {
    252.         device_destroy(cls,MKDEV(major,i));
    253.     }
    254.     class_destroy(cls);//释放目录
    255. out4:
    256.     cdev_del(cdev);
    257. out3:
    258.     unregister_chrdev_region(MKDEV(major,minor),3);
    259. out2:
    260.     kfree(cdev);
    261. out1:
    262.     return ret;
    263. }
    264. static void __exit mycdev_exit(void)
    265. {
    266.     //释放对象指针
    267.     gpiod_put(gpiono1);
    268.     gpiod_put(gpiono2);
    269.     gpiod_put(gpiono3);
    270.     /*销毁设备节点信息*/
    271.     int i;
    272.     for (i = 0; i < 3; i++)
    273.     {
    274.         device_destroy(cls, MKDEV(major, i));
    275.     }
    276.     // 销毁目录信息
    277.     class_destroy(cls);
    278. 	//注销驱动对象
    279.     cdev_del(cdev);
    280.     //释放设备号
    281.     unregister_chrdev_region(MKDEV(major,minor),3);
    282.     //释放对象空间
    283.     kfree(cdev);
    284.     // 取消地址映射
    285.     iounmap(vir_led1);
    286.     iounmap(vir_led2);
    287.     iounmap(vir_rcc);
    288. }
    289. module_init(mycdev_init);
    290. module_exit(mycdev_exit);
    291. MODULE_LICENSE("GPL");

    4.Makefile

    1. modname?=demo  #给定一个默认的模块名
    2. arch?=arm #给定一个架构的模块名
    3. ifeq ($(arch),arm)#判断要编译的架构进而使用不同的Makefile规则进行编译
    4. #定义变量存放内核源码顶层路径
    5. KERNELDIR:= /home/ubuntu/FSMP1A/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61 #用于编译生成ARM架构的模块
    6. else
    7. KERNELDIR := /lib/modules/$(shell uname -r)/build  #用于生成x86架构的模块
    8. endif
    9.  
    10. #定义变量保存模块化编译的文件的路径
    11. PWD:= $(shell pwd)
    12. all:
    13. #make modules是模块化编译的命令
    14. #make -C $(KERNELDIR)表示读取KERNELDIR路径下的Makefile进行make编译
    15. #M=$(PWD)指定模块化编译的路径
    16. 	make -C $(KERNELDIR) M=$(PWD) modules
    17. clean: #编译清除
    18. 	make -C $(KERNELDIR) M=$(PWD) clean
    19.  
    20. obj-m:=$(modname).o  #指定将demo.o独立链接生成内核模块文件

    5.测试

    1.make arch=arm modname=myled

    2.arm-linux-gnueabihf-gcc main.c

    3.cp a.out ~/nfs/rootfs

    4.cp myled.ko ~/nfs/rootfs

     6.测试结果

  • 相关阅读:
    本地虚拟机centos7通过docker安装主从redis3.2
    搭建git私人仓库
    【排序24：俄罗斯套娃信封问题】（动态规划 / 二维最长公共子序列 / 基于二分查找的动态规划）
    【黑马程序员】mysql进阶再进阶篇笔记
    Going Deeper With Convolution(GoogLeNet的理解)
    plv8-使用JavaScript编写存储过程，初体验
    推荐大家一个比较好用的接口测试工具
    【Tools】了解人工通用智能 (AGI)：未来的智能体
    芒果YOLOv8改进106：卷积Conv篇：DO-DConv卷积提高性能涨点，使用over-parameterized卷积层提高CNN性能
    多御安全浏览器宝藏功能全新升级，建议低调使用
  • 原文地址：https://blog.csdn.net/m0_62774039/article/details/132993673