firefly-led{

    //匹配内容

    compatible = "firefly,led";

    //led引脚及有效电平

    led-work = <&gpio8 GPIO_A2 GPIO_ACTIVE_LOW>;

    status = "okay";

};

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/uaccess.h>

#include <linux/proc_fs.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/gpio.h>

#include <linux/miscdevice.h>

#include <linux/of_gpio.h>

#include <linux/of_platform.h>

#include <linux/platform_device.h>

#include <linux/of.h>

#include <linux/of_gpio.h>

#define DEBUG

#ifdef DEBUG

#define LED_DBG(fmt,arg...)        do{\

                                    printk("<LED-DEBUG> [%d]"fmt"\n", __LINE__, ##arg);\

                                }while()

#else

#define LED_DBG(fmt,arg...)

#endif

struct led_data {

    int work_pin;        //led引脚

    int work_status;        //led状态

    int work_enable;    //led使能电平

};

struct led_data *led_info;

static int led_drv_open(struct inode *inode, struct file *filp)

{

    LED_DBG("--%s()--", __func__);

    return ;

}

static int led_drv_release(struct inode *inode, struct file *filp)

{

    LED_DBG("--%s()--", __func__);

    return ;

}

static ssize_t led_drv_read(struct file *filp, char __user *buf, size_t len, loff_t *pos)

{

    int ret;

    LED_DBG("--%s()--", __func__);

    ret = copy_to_user(buf, &(led_info->work_status), len);

    if(ret > )

    {

        LED_DBG("copy to user failed.");

        return ret;

    }

    return len;

}

static ssize_t led_drv_write(struct file *filp, const char __user *buf, size_t len, loff_t *pos)

{

    int on;

    int ret;

    LED_DBG("--%s()--", __func__);

    ret = copy_from_user(&on, buf, len);

    if(ret > )

    {

        LED_DBG("copy from user failed.");

        return ret;

    }

    gpio_direction_output(led_info->work_pin, !on);

    led_info->work_status = on;

    return ret;

}

//上层没添加此函数api

static long led_drv_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

    LED_DBG("--%s()--", __func__);

    return ;

}

struct file_operations led_fops = {

    .owner = THIS_MODULE,

    .open = led_drv_open,

    .release = led_drv_release,

    .write = led_drv_write,

    .read = led_drv_read,

    .unlocked_ioctl = led_drv_ioctl,

};

//注册为杂项设备

struct miscdevice led_dev =

{

    .minor  =   MISC_DYNAMIC_MINOR,

    .fops   =   &led_fops,

    .name   =   "firefly_leds",

};  

static int led_drv_probe(struct platform_device *pdev)

{

    int ret = -;

    enum of_gpio_flags work_flags;

    struct device_node *led_node = pdev->dev.of_node;

    LED_DBG("--%s()--", __func__);

    led_info = kzalloc(sizeof(struct led_data), GFP_KERNEL);

    if(led_info == NULL)

    {

        LED_DBG("Alloc GFP_KERNEL memory failed.");

        return -ENOMEM;

    }

    //从dts中获取led的引脚，和有效电平

    led_info->work_pin = of_get_named_gpio_flags(led_node, "led-work", , &work_flags);

    if(!gpio_is_valid(led_info->work_pin))

    {

        LED_DBG("Work pin is invaild.");

        ret = -ENODEV;

        goto dev_fail;

    }

    led_info->work_enable = (work_flags == OF_GPIO_ACTIVE_LOW) ?  : ;

    ret = gpio_request(led_info->work_pin, "work_led");

    if(ret < )

    {

        LED_DBG("Work led request failed.");

        goto dev_fail;

    }

    gpio_direction_output(led_info->work_pin, !(led_info->work_enable));

    led_info->work_status = ;

    misc_register(&led_dev);

    return ;

request_fail:

    gpio_free(led_info->work_pin);

dev_fail:

    kfree(led_info);

    return ret;

}

static int led_drv_remove(struct platform_device *pdev)

{

    misc_deregister(&led_dev);

    LED_DBG("--%s()--", __func__);

    gpio_free(led_info->work_pin);

    kfree(led_info);

}

int led_drv_suspend(struct device *dev)

{

    LED_DBG("--%s()--", __func__);

    return ;

}

int led_drv_resume(struct device *dev)

{

    LED_DBG("--%s()--", __func__);

    return ;

}

//suspend和resume暂时没调试成功

const struct dev_pm_ops led_pm_ops = {

    .suspend = led_drv_suspend,

    .resume = led_drv_resume,

};

static const struct of_device_id of_gpio_leds_match[] = {

    {.compatible = "firefly,led", },

    {},

};

static struct platform_driver led_drv = {

    .probe = led_drv_probe,

    .remove = led_drv_remove,

    .driver = {

        .name = "leds",

        .owner = THIS_MODULE,

        .pm = &led_pm_ops,

        .of_match_table = of_match_ptr(of_gpio_leds_match),

    },

};

module_platform_driver(led_drv);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("AaronLee");

obj-$(CONFIG_FIREFLY_RK3288_LEDS)                += leds.o

menu "Firefly Device Options"

config FIREFLY_RK3288_LEDS

    bool "select firefly rk3288 leds"

    default y

endmenu

CONFIG_FIREFLY_RK3288_LEDS=y

/dev/firefly_leds            system        system