基于gpio子系统完成led灯驱动的注册

利用定时器让led1一秒亮一秒灭，同时应用程序可以操作led1,led2,led3的亮灭

test.c

#include<stdlib.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include<unistd.h>
#include<string.h>
//#include "head.h"

#define LED_ON _IO('l',1)   //开灯
#define LED_OFF _IO('l',0)  //关灯
int main(int argc, char const *argv[])
{
    while(1)
    {
    printf("请选择您控制的led灯\n");
    printf("1:led1  2:led2  3:led3\n");
    int flags;
    scanf("%d",&flags);
    int fd;
    switch(flags)
    {
        case 1:
        fd= open("/dev/myled0",O_RDWR);
        break;
        case 2:
        fd= open("/dev/myled1",O_RDWR);
        break;
        case 3:
        fd= open("/dev/myled2",O_RDWR);
        break;  
    }
    if(fd<0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    while(1)
    {
        //从终端读取
        printf("请输入您要执行的操作\n");
        printf("0(关灯) 1(开灯) 2(退出)\n");
        printf("请输入>");
        scanf("%d",&flags);
        //向设备文件中写
        if (flags == 1)
        {
            ioctl(fd, LED_ON);
        }
        else if(flags == 0)
        {
            ioctl(fd, LED_OFF);
        }
        else if(flags == 2)
        {
            break;
        }
    }
    close(fd);
    }
}

myled.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/io.h>
#include <linux/timer.h>
#include <linux/cdev.h>
#include "head.h"
#define LED_ON _IO('l',1)   //开灯
#define LED_OFF _IO('l',0)  //关灯
struct cdev *cdev;//字符设备驱动对象

struct device_node * dnode;
//unsigned int gpionum;
struct gpio_desc *gpionum1;//led1 的gpio对象
struct gpio_desc *gpionum2;//led2 的gpio对象
struct gpio_desc *gpionum3;//led3 的gpio对象
struct timer_list mytimer;//定时器对象
unsigned int major = 500;  //主设备号
unsigned int minor = 0;    //次设备号
dev_t devnum; //设备号
struct class *cls;
struct device *dev;
int mycdev_open (struct inode *inode, struct file *file)
{
    unsigned int aaa = MINOR(inode->i_rdev);
     //led1写了定时器控制，一秒亮一秒灭，这里如果判断用户想要控制led1
    //就关闭定时器
    if(aaa == 0)
    {
        gpiod_set_value(gpionum1,0);
        del_timer(&mytimer);
    }
    file->private_data = (void *)aaa;
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl (struct file *file, unsigned int cmd, unsigned long arg)
{
    unsigned int aaa = (int)file->private_data;
    switch(aaa)
    {
        case 0:
        //控制led1的逻辑
       
        switch (cmd)
        {
        case LED_ON:
            gpiod_set_value(gpionum1,1);
            break;
        case LED_OFF:
            gpiod_set_value(gpionum1,0);
        break;
        }
        break;
        case 1:
        //控制led2的逻辑
        switch (cmd)
        {
        case LED_ON:
            gpiod_set_value(gpionum2,1);
            break;
        case LED_OFF:
            gpiod_set_value(gpionum2,0);
        break;
        }
        break;
        case 2:
        //控制led3的逻辑
        switch (cmd)
        {
        case LED_ON:
            gpiod_set_value(gpionum3,1);
            break;
        case LED_OFF:
            gpiod_set_value(gpionum3,0);
        break;
        }
        break;
    }

    return 0;
}
int mycdev_close (struct inode *inode, struct file *file)
{
    return 0;
}
//驱动操作方法结构体指针
const struct file_operations fop=
{
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
static void my_timer_func(struct timer_list *timer)
{
    //定时器函数中只操控led1的亮灭
    //亮转灭，灭转亮
    int flags = gpiod_get_value(gpionum1);
    if(flags)
    {
        gpiod_set_value(gpionum1,0);
    }
    else
    {
         gpiod_set_value(gpionum1,1);
    }
    
    //再次启用定时器
    mod_timer(timer,jiffies+HZ);
}
static int __init mycdev_init(void)
{
    int i;
    int ret;
    //为字符设备驱动对象申请空间
    cdev = cdev_alloc(); 
    if(cdev == NULL)
    {
        printk("申请字符设备驱动对象空间失败\n");
        ret = -EFAULT;
         goto out1;
    }
    //初始化字符设备驱动
    cdev_init(cdev,&fop);

    //申请设备号-----动态申请
    ret = alloc_chrdev_region(&devnum,minor,3,"myled");
    if(ret)
    {
        printk("动态申请设备号失败\n");
        goto out2;
    }
    major = MAJOR(devnum);// 根据设备号得到主设备号
    minor = MINOR(devnum);
    printk("动态申请设备号成功\n,major = %d",major);

    //注册设备驱动对象
    ret = cdev_add(cdev,MKDEV(major,minor),3);
    if(ret)
    {
        printk("注册设备驱动对象失败\n");
        goto out3;
    }
    //向上提交目录
    cls = class_create(THIS_MODULE,"myled");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=-PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");
    //向上提交设备节点信息
    for(i = 0; i < 3; i++)
    {
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"myled%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");
    gpionum1 = gpiod_get_from_of_node(dnode,"led1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpionum1))
    {
        printk("申请gpio编号失败\n");
        return -PTR_ERR(gpionum1);
    }
    gpionum2 = gpiod_get_from_of_node(dnode,"led2",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpionum2))
    {
        printk("申请gpio编号失败\n");
        return -PTR_ERR(gpionum2);
    }
    gpionum3 = gpiod_get_from_of_node(dnode,"led3",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpionum3))
    {
        printk("申请gpio编号失败\n");
        return -PTR_ERR(gpionum3);
    }
    
    
    //初始化定时器对象
    mytimer.expires = jiffies+HZ;
    timer_setup(&mytimer,my_timer_func,0);
    add_timer(&mytimer);

    //根据设备树节点解析led1 gpio编号
    /*gpionum = of_get_named_gpio(dnode,"led1",0);
    if(gpionum < 0)
    {
        printk("gpio编号解析失败\n");
    }
    printk("gpio编号解析成功,gpionum = %d\n",gpionum);
    //申请gpio编号
    ret = gpio_request(gpionum,NULL);
    if(ret < 0)
    {
        printk("申请gpio编号失败\n");
        return ret;
    }
    //设置led1管脚为输出
    gpio_direction_output(gpionum,0);
    //设置管脚输出高电平，亮灯
    gpio_set_value(gpionum,1);*/
    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)
{
    int i;
    for(i =0; i < 3; i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    //注销对象
    cdev_del(cdev);
    unregister_chrdev_region(MKDEV(major,minor),3);
    kfree(cdev);
    /*gpio_set_value(gpionum,0);
    //释放gpio编号
    gpio_free(gpionum);*/
    //灭灯
    gpiod_set_value(gpionum1,0);
    gpiod_set_value(gpionum2,0);
    gpiod_set_value(gpionum3,0);
    //注销gpio信息
    gpiod_put(gpionum1);
    gpiod_put(gpionum2);
    gpiod_put(gpionum3);
    //释放定时器对象
    del_timer(&mytimer);

}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");