#ifndef _IOCTL_H_

#define _IOCTL_H_

typedef struct

{

       unsigned long size;

       unsigned int buff[128];

} __attribute__((packed)) ioctl_info;

#define             IOCTL_MAGIC         'g'

#define             LED_ON              _IO( IOCTL_MAGIC, 0)

#define             LED_OFF             _IO( IOCTL_MAGIC, 1)

#define             LED_TIMER           _IOW( IOCTL_MAGIC, 2 , ioctl_info )

#define             GET_LED_TIME        _IOR( IOCTL_MAGIC, 3 , ioctl_info )

#define             IOCTL_MAXNR         4

  #endif  // _IOCTL_H_

#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/version.h>

#include <linux/fs.h>

#include <linux/sched.h>

#include <linux/interrupt.h>

#include <linux/wait.h>

#include <linux/irq.h>

#include <linux/ioport.h>

#include <linux/slab.h>

#include <linux/poll.h>

#include <linux/proc_fs.h>

#include <linux/workqueue.h>

#include <linux/time.h>

#include <linux/timer.h>

#include <linux/poll.h>

#include <asm/system.h>

#include <asm/uaccess.h>

#include <asm/ioctl.h>

#include <asm/unistd.h>

#include <asm/io.h>

#include <asm/irq.h>

#include <asm/gpio.h>

#include <asm/mach/arch.h>

#include <plat/gpio-cfg.h>

#include "ioctl-gpio-int.h"

#include "ioctl.h"

#define IOCTL_DEV_NAME                  "dev_ioctl"

#define IOCTL_DEV_MAJOR                 241

#define TIME_STEP                       (HZ*2)

#define LED_GPIO_DATA_REGISTER                0x7F008184

#define LED0                            (1<<2)

#define LED1                            (1<<3)

#define LED2                            (1<<4)

#define LED                             ((1<<2)|(1<<3)|(1<<4))

#define PAGE_SIZES                      0x1000

#define DATA_SIZE                       0x1000

u32 led_time;

DECLARE_WAIT_QUEUE_HEAD( WaitQueue_Read );

typedef struct

{

       struct timer_list   timer;

       unsigned long       led;

       u8                  flag;

} __attribute__ ((packed)) KERNEL_TIMER_MANAGER;

KERNEL_TIMER_MANAGER       *ptrmng                    = NULL;

static unsigned int        ReadQ_timet_Count   = 0;

volatile u32                *led_data;

void kerneltimer_led(unsigned long arg);

void kerneltimer_registertimer(KERNEL_TIMER_MANAGER *pdata, unsigned long timeover)

{

       init_timer(&(pdata->timer));

       pdata->timer.expires       = get_jiffies_64( ) + timeover;

       pdata->timer.data   = (unsigned long) pdata;

       pdata->timer.function      = kerneltimer_led;

       add_timer(&(pdata->timer));

}

void kerneltimer_led(unsigned long arg)

{

       KERNEL_TIMER_MANAGER *pdata = NULL;

       if(arg)

       {

             pdata = (KERNEL_TIMER_MANAGER *) arg;

             *led_data  = (*led_data)^LED;

             kerneltimer_registertimer(pdata, led_time);

       }

}

int ioctl_open(struct inode *inode, struct file *filp)

{

       ptrmng = kmalloc(sizeof(KERNEL_TIMER_MANAGER), GFP_KERNEL);

       if(ptrmng == NULL) return -ENOMEM;

       memset(ptrmng, 0, sizeof(KERNEL_TIMER_MANAGER));

       return 0;

}

int ioctl_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)

{

       ioctl_info   ctrl_info;

       int          size;

       if(_IOC_TYPE(cmd) != IOCTL_MAGIC)

       {

             printk("magic err\n");

              return -EINVAL;

       }

       if(_IOC_NR(cmd) >= IOCTL_MAXNR)

       {

             printk("NR err\n");

              return -EINVAL;

       }

       size = _IOC_SIZE(cmd);

       switch(cmd)

       {

       case LED_ON :

             *led_data  = 0;

             break;

       case LED_OFF:

             if(ptrmng != NULL)

             {

                    del_timer(&(ptrmng->timer));

             }

             *led_data  = LED;

             break;

       case LED_TIMER:

             if(ptrmng != NULL)

             {

                    del_timer(&(ptrmng->timer));

             }

             copy_from_user ((void *)&ctrl_info, (const void *)arg, size);

             led_time = ctrl_info.buff[0];

             kerneltimer_registertimer(ptrmng, led_time);

             break;

       case GET_LED_TIME:

             ctrl_info.buff[0] = led_time;

             ctrl_info.size = 1;

             copy_to_user((const void *)arg,(void *)&ctrl_info, size);

             break;

       }

}

int ioctl_release(struct inode *inode, struct file *filp)

{

       if(ptrmng != NULL)

       {

             del_timer(&(ptrmng->timer));

             kfree(ptrmng);

       }

       return 0;

}

struct file_operations ioctl_fops =

{

             .owner       = THIS_MODULE,

             .open        = ioctl_open,

             .ioctl       = ioctl_ioctl,

             .release     = ioctl_release,

};

int ioctl_init( void )

{

       int result;

       led_data = ioremap(LED_GPIO_DATA_REGISTER, PAGE_SIZES);

       result = register_chrdev(IOCTL_DEV_MAJOR,IOCTL_DEV_NAME,&ioctl_fops);

       if( result < 0)

             return result;

       return 0;

}

void ioctl_exit( void )

{

       iounmap( led_data );

       unregister_chrdev(IOCTL_DEV_MAJOR, IOCTL_DEV_NAME);

}

module_init( ioctl_init );

module_exit( ioctl_exit );

MODULE_LICENSE("Dual BSD/GPL");