基于gpio完成LED灯的注册，应用测试

小白选手–c

已于 2023-07-11 19:09:06 修改

阅读量145

点赞数

文章标签：驱动开发

于 2023-07-11 19:07:18 首次发布

本文链接：https://blog.csdn.net/m0_59681498/article/details/131667265

版权

led灯 1秒亮一秒灭

#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include<linux/of.h>
#include<linux/gpio.h>
#include<linux/timer.h>
/*myleds{
   led1=<&qpioe 10 0>
   led2=<&qpiof 10 0>
   led3=<&qpioe 8 0>
}
*/
struct device_node *dnode;
struct gpio_desc *gpiono;
struct timer_list mytimer;//定义定时器对象
//定义定时器处理函数
void mytimer_func(struct timer_list *timer)
{
    static int led_state =0;//led 0表示灭 1 表示亮
    led_state =!led_state;//切换状态
    //设置led的状态
    gpiod_set_value(gpiono,led_state);
     //再次启动定时器
     mod_timer(timer,jiffies+HZ);
}
static int __init mycdev_init(void)
{
   int ret;
    //解析led灯的设备树节点
      dnode=of_find_node_by_path("/myleds");
      if(dnode==NULL)
      {
        printk("解析设备树节点失败\n");
        return -ENXIO;
      }
      printk("解析设备树节点成功\n");
      //根据设备树节点解析led1gpio编号
      gpiono=gpiod_get_from_of_node(dnode,"led1",0,GPIOD_OUT_LOW,NULL);
      if(IS_ERR(gpiono))
      {

        printk("gpio编号解析失败\n");
      }
      printk("解析成功=%d\n",gpiono);
       //设置管脚输出高电平，亮灯
       gpiod_set_value(gpiono,1);
       //初始化定时器对象
       mytimer.expires=jiffies+HZ;
       timer_setup(&mytimer,mytimer_func,0);
       //将定时器对象注册进内核
       add_timer(&mytimer);
       return 0;
}
static void __exit mycdev_exit(void)
{
   //灭灯
  gpiod_set_value(gpiono,0);
  //释放gpio编号
  gpiod_put(gpiono);
   //删除定时器 
  del_timer(&mytimer);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led.c

#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/io.h>
#include<linux/device.h>
#include <linux/uaccess.h>
#include <linux/of_gpio.h>
#include<linux/of.h>
#include<linux/gpio.h>
#include<linux/cdev.h>
#include "head.h"
struct class *cls;
struct device *dev;
char kbuf[128]={0};
struct cdev *cdev;
dev_t devno;
unsigned int major = 500;
unsigned int minor = 0;
struct device_node *dnode;
struct gpio_desc *gpiono1;
struct gpio_desc *gpiono2;
struct gpio_desc *gpiono3;
int mycdev_open (struct inode *inode, struct file *file)
{
   
   printk("%s %s %d\n",__FILE__,__func__,__LINE__);
   return 0;
}


long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{

   switch(cmd)
   {
      case LED_ON://开灯
         switch(arg)
         {
        case 1:
        gpiod_set_value(gpiono1,1);
        break;
         case 2:
        gpiod_set_value(gpiono2,1);
        break;
        case 3:
        gpiod_set_value(gpiono3,1);
        break;
         }
         break;
        case LED_OFF:
        switch(arg)
        {
         case 1:
        gpiod_set_value(gpiono1,0);
        break;
        case 2:
        gpiod_set_value(gpiono2,0);
        break;
        case 3:
        gpiod_set_value(gpiono3,0);
        break;
        }
        break;
   }

   return 0;
}
int mycdev_close (struct inode *inode , struct file * file)
{
   
     printk("%s %s %d\n",__FILE__,__func__,__LINE__);
   return 0;
}
struct file_operations fops=
{
   .open=mycdev_open,
   .unlocked_ioctl=mycdev_ioctl,
   .release=mycdev_close,

};

static int __init mycdev_init(void)
{
  int ret, i;
  // 1.分配字符设备驱动对象空间 cdev_alloc
  cdev = cdev_alloc();
  if (cdev == NULL)
  {
    printk("申请字符设备驱动对象空间失败\n");
    ret = -EFAULT;
    goto out1;
  }
  printk("字符设备驱动对象申请成功\n");
  // 2.字符设备驱动对象部分初始化 cdev_init
  cdev_init(cdev, &fops);

  // 3.申请设备号 register_chrdev_region/alloc_chrdev_region
  if (major > 0) // 静态申请设备号
  {
    ret = register_chrdev_region(MKDEV(major, minor), 3, "led");
    if (ret)
    {
      printk("静态指定设备号失败\n");
      goto out2;
    }
  }
  else // 动态申请设备号
  {
    ret = alloc_chrdev_region(&devno, minor, 3, "led");
    if (ret)
    {
      printk("动态申请设备号失败\n");
      goto out2;
    }
    major = MAJOR(devno); // 根据设备号得到主设备号
    minor = MINOR(devno); // 根据设备号得到次设备号
  }
  printk("申请设备号成功\n");
  // 4.注册字符设备驱动对象 cdev_add()
  ret = cdev_add(cdev, MKDEV(major, minor), 3);

  if (ret)
  {
    printk("注册字符设备驱动对象失败\n");
    goto out3;
  }
  printk("注册字符设备驱动对象成功\n");

  // 5.向上提交目录
  cls = class_create(THIS_MODULE, "led");
  if (IS_ERR(cls))
  {
    printk("向上提交目录失败\n");
    return -PTR_ERR(cls);
    goto out4;
  }
  printk("向上提交目录成功\n");
  // 6.向上提交设备节点
  for (i = 0; i < 3; i++)
  {
    dev = device_create(cls, NULL, MKDEV(major, i), NULL, "led%d", i);
    if (IS_ERR(dev))
    {
      printk("向上提交节点信息失败\n");
      ret = -PTR_ERR(dev);
      goto out5;
    }
  }
  printk("向上提交设备节点信息成功\n");
  //解析led灯的设备树节点
      dnode=of_find_node_by_path("/myleds");
      if(dnode==NULL)
      {
        printk("解析设备树节点失败\n");
        return -ENXIO;
      }
      printk("解析设备树节点成功\n");
      //根据设备树节点解析led1gpio编号
      gpiono1=gpiod_get_from_of_node(dnode,"led1",0,GPIOD_OUT_LOW,NULL);
      if(IS_ERR(gpiono1))
      {

        printk("gpio编号解析失败\n");
      }
      printk("解析成功=%d\n",gpiono1);
      gpiono2=gpiod_get_from_of_node(dnode,"led2",0,GPIOD_OUT_LOW,NULL);
      if(IS_ERR(gpiono2))
      {

        printk("gpio编号解析失败\n");
      }
      printk("解析成功=%d\n",gpiono2);
        gpiono3=gpiod_get_from_of_node(dnode,"led3",0,GPIOD_OUT_LOW,NULL);
      if(IS_ERR(gpiono3))
      {

        printk("gpio编号解析失败\n");
      }
      printk("解析成功=%d\n",gpiono3);
       return 0;
out5:
  for (--i; i >= 0; i--)
  {
    // 销毁上面提交的设备信息
    device_destroy(cls, MKDEV(major, i));
  }
  class_destroy(cls);
out4:
  cdev_del(cdev);
out3:
  unregister_chrdev_region(MKDEV(major, minor), 3);
out2:
  kfree(cdev);
out1:
  return ret;
}
static void __exit mycdev_exit(void)
{
  // 销毁设备信息 device_destroy
  int i;
  for (i = 0; i < 3; i++)
  {
    device_destroy(cls, MKDEV(major, i));
  }
  // 销毁目录 class_destroy
  class_destroy(cls);
  // 注销对象 cdev_del()
  cdev_del(cdev);
  // 释放设备号 unregister_chrdev_region()
  unregister_chrdev_region(MKDEV(major, minor), 3);
  // 释放对象空间
  kfree(cdev);

  //释放gpio编号
  gpiod_put(gpiono1);
  gpiod_put(gpiono2);
  gpiod_put(gpiono3);
  //灭灯
  gpiod_set_value(gpiono1,0);
  gpiod_set_value(gpiono2,0);
  gpiod_set_value(gpiono3,0);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

head.h'

#ifndef __HEAD_H__
#define __HEAD_H__
#define RCC_MP_AHB4ENSETR 0x50000A28 // 封装 GPIOE GPIOF，RCC外设对应寄存器

typedef struct GPIO
{
     unsigned int MODER;
     unsigned int OTYPER;
     unsigned int OSPEEDR;
     unsigned int PUPDR;
     unsigned int IDR;
     unsigned int ODR;

} gpio_t;
#define GPIOE 0x50006000
#define GPIOF 0x50007000
#define LED_ON  _IOW('l',1,int)//开灯
#define LED_OFF _IOW('l',0,int)//关灯
#endif

test.c

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include "head.h"
int main(int argc, char const *argv[])
{
    int a,b;
    char buf[128] = {0};
    int fd = open("/dev/led0", O_RDWR);
    
    if (fd < 0)
    {
        printf("打开失败\n");
        exit(-1);
    }
    
 while (1)
    {
        printf("请选择要实现的功能");
        printf("请输入控制命令--LED1:1开灯 0:关灯");
        scanf("%d",&a);
        printf("1(LED1) 2(LED2) 3(LED3)");
        scanf("%d",&b);
        if(a==1)//开灯
        {
            ioctl(fd,LED_ON,b);
        }else if(a==0)//关灯
        {
            ioctl(fd,LED_OFF,b);
        }
     
    }

    close(fd);
    return 0;
}