/*********************************************************************************
 *      Copyright:  (C)  2017 LingYun IoT Studio <www.iot-yun.com> 
 *                  All rights reserved.
 *
 *       Filename:  platdrv_led.c
 *    Description:  This is the common LED driver runs on S3C24XX.
 *                 
 *        Version:  1.0.0(10/27/2011~)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "10/27/2011 11:39:10 AM"
 *                 
 ********************************************************************************/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/version.h>

#include "platdev_led.h"

#define TIMER_TIMEOUT             40

#define PLATDRV_MAGIC             0x60
#define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)
#define LED_ON                    _IO (PLATDRV_MAGIC, 0x19)
#define LED_BLINK                 _IO (PLATDRV_MAGIC, 0x20)

static int dev_major = 0;

struct led_device
{
    struct s3c_led_platform_data    *data;
    struct cdev                     cdev;
    struct class                    *dev_class;
    struct timer_list               blink_timer;
} led_device;


void led_timer_handler(unsigned long data)
{ 
    int  i; 
    struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;

    for(i=0; i<pdata->nleds; i++) 
    { 
        if(ON == pdata->leds[i].status)
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
        }
        else
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
        }

        if(ENABLE == pdata->leds[i].blink )  /* LED should blink */
        {
            /* Switch status between 0 and 1 to turn LED ON or off */
            pdata->leds[i].status = pdata->leds[i].status ^ 0x01;  
        }

        mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);
    }
}


static int led_open(struct inode *inode, struct file *file)
{ 
    struct led_device *pdev ;
    struct s3c_led_platform_data *pdata;

    pdev = container_of(inode->i_cdev,struct led_device, cdev);
    pdata = pdev->data;

    file->private_data = pdata;

    return 0;
}


static int led_release(struct inode *inode, struct file *file)
{ 
    return 0;
}

static void print_led_help(void)
{
    printk("Follow is the ioctl() command for LED driver:\n");
    printk("Turn LED on command        : %u\n", LED_ON);
    printk("Turn LED off command       : %u\n", LED_OFF);
    printk("Turn LED blink command     : %u\n", LED_BLINK);
}

/* compatible with kernel version >=2.6.38*/
static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ 
    struct s3c_led_platform_data *pdata = file->private_data;

    switch (cmd)
    {
        case LED_OFF:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = OFF;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_ON:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = ON;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_BLINK:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].blink = ENABLE;
            pdata->leds[arg].status = ON;
            break;

        default: 
            printk("LED driver don't support ioctl command=%d\n", cmd); 
            print_led_help();
            return -EINVAL;

    }
    return 0;
}


static struct file_operations led_fops = { 
    .owner = THIS_MODULE, 
    .open = led_open, 
    .release = led_release, 
    .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/
};


static int s3c_led_probe(struct platform_device *dev)
{
    struct s3c_led_platform_data *pdata = dev->dev.platform_data; 
    int result = 0;
    int i;
    dev_t devno;

    /* Initialize the LED status */
    for(i=0; i<pdata->nleds; i++)
    {
         s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);
         if(ON == pdata->leds[i].status)
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
         }
         else
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
         }
    }

    /*  Alloc the device for driver */
    if (0 != dev_major) 
    { 
        devno = MKDEV(dev_major, 0); 
        result = register_chrdev_region(devno, 1, "led"); 
    } 
    else 
    { 
        result = alloc_chrdev_region(&devno, 0, 1, "led"); 
        dev_major = MAJOR(devno); 
    }

    /* Alloc for device major failure */ 
    if (result < 0) 
    { 
        printk("LED driver can't get major %d\n", dev_major); 
        return result; 
    }

    /* Initialize button structure and register cdev*/
    memset(&led_device, 0, sizeof(led_device));
    led_device.data = dev->dev.platform_data;
    cdev_init (&(led_device.cdev), &led_fops);
    led_device.cdev.owner  = THIS_MODULE;

    result = cdev_add (&(led_device.cdev), devno , 1); 
    if (result) 
    { 
        printk (KERN_NOTICE "error %d add led device", result ); 
        goto ERROR; 
    } 
    
    led_device.dev_class = class_create(THIS_MODULE, "led"); 
    if(IS_ERR(led_device.dev_class)) 
    { 
        printk("LED driver create class failure\n"); 
        result =  -ENOMEM; 
        goto ERROR; 
    }

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)     
    device_create(led_device.dev_class, NULL, devno, NULL, "led");
#else
    device_create (led_device.dev_class, NULL, devno, "led");
#endif

    /*  Initial the LED blink timer */
    init_timer(&(led_device.blink_timer));
    led_device.blink_timer.function = led_timer_handler;
    led_device.blink_timer.data = (unsigned long)pdata;
    led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;
    add_timer(&(led_device.blink_timer)); 

    printk("S3C led driver version 1.0.0 initiliazed.\n"); 

    return 0;
               

ERROR: 
    printk("S3C led driver version 1.0.0 install failure.\n"); 
    cdev_del(&(led_device.cdev)); 

    unregister_chrdev_region(devno, 1); 
    return result;

}

static int s3c_led_remove(struct platform_device *dev)
{
    dev_t devno = MKDEV(dev_major, 0);

    del_timer(&(led_device.blink_timer));

    cdev_del(&(led_device.cdev)); 
    device_destroy(led_device.dev_class, devno); 
    class_destroy(led_device.dev_class); 
    
    unregister_chrdev_region(devno, 1); 
    printk("S3C led driver removed\n" );

    return 0;
}


static struct platform_driver s3c_led_driver = { 
    .probe      = s3c_led_probe, 
    .remove     = s3c_led_remove, 
    .driver     = { 
        .name       = "s3c_led", 
        .owner      = THIS_MODULE, 
    },
};


static int __init platdrv_led_init(void)
{
   int       rv = 0;

   rv = platform_driver_register(&s3c_led_driver);
   if(rv)
   {
        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, rv); 
        return rv;
   }
   printk("Regist S3C LED Platform Driver successfully.\n");

   return 0;
}


static void platdrv_led_exit(void)
{
    printk("%s():%d remove LED platform drvier\n", __FUNCTION__,__LINE__);
    platform_driver_unregister(&s3c_led_driver);
}

module_init(platdrv_led_init);
module_exit(platdrv_led_exit);

module_param(dev_major, int, S_IRUGO);

MODULE_AUTHOR("GuoWenxue<guowenxue@gmail.com>");
MODULE_DESCRIPTION("FL2440 LED driver platform driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:s3c_platdrv_led");