INPUT

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <linux/irq.h>
#include <asm/io.h>
#include <mach/hardware.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/device.h>
#include <mach/gpio-nrs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/sched.h>
static DECLARE_WAIT_QUEUE_HEAD(yuyuq);
static struct class *input_class;
static struct class_device	*input_class_dev;
int major;
struct fasync_struct *  yuyu_queue;
struct input_dev *yuyu_input;
struct pin_desc{
 unsigned long pin;
 unsigned pin_val;

};
static struct pin_desc pin[4]={
  {S3C2410_GPG(0), 0x01},
  {S3C2410_GPG(3), 0x02},
  {S3C2410_GPG(5), 0x03},
  {S3C2410_GPG(6), 0x04},
};
static irqreturn_t yuyu_irq(int irq, void *dev_id)
{ 
	struct pin_desc* pin_la=(struct pin_desc *)dev_id;
	unsigned long val=pin_la->pin_val; 
	if(val)  
	{   

	  input_event(EV_KEY, val, 0);
	  input_sync(yuyu_input);
		 
	} 
	else  
	{   

	   input_event(EV_KEY,val, 1);
	   input_sync(yuyu_input);
	}  
	ev_press=1; 
	wake_up_interruptible(&yuyuq); 
	if(yuyu_queue) 
	{  
		  kill_fasync(&yuyu_queue, SIGIO, POLL_IN);
	}
	
	
	return IRQ_RETVAL(IRQ_HANDLED);

 }

	
	
static int yuyu_input_open(struct inode *inode, struct file *file)
{
    set_bit(EV_KEY, input_dev->evbit);
	set_bit(EV_REP, input_dev->evbit);
	set_bit( KEY_L, input_dev->keybit);
	set_bit(KEY_S,  input_dev->keybit);
	
   	for(i=0;i<4;i++)
	{	   
	  request_irq(pin[i].irq_val,  yuyu_irq, IRQF_TRIGGER_LOW , "K1", &pin[i]); 
	}
	return 0;
}
static ssize_t yuyu_input_read (struct file *file,  __user *buf, size_t size, loff_t * l_opps)
{
     if (size !=1)  
	 	return -EINVAL;
	 wait_event_interruptible(yuyuq, ev_press);  
	 copy_to_user(buf,& pin[i].pin_val, 1);  
	 ev_press=0;	
      return size;
}	
static int irq_drv_fsync (int fd, struct file *file, int mode)
{ 
  return fasync_helper( fd,  file, mode, &yuyu_queue);
}
static void yuyu_input_close(struct inode *inode, struct file *file)
{
      int i;
	 for(i=0;i<4;i++)	
	 {	   
	  	free_irq(pin[i].irq_val, &pin[i]);
	  }    
	  printk("the dev is close");  
      return 0;
}	
	
static struct file_operations input_drv_fops = {   	
	 .owner		= THIS_MODULE,    
     .open    =  yuyu_input_open,   
     .read =	yuyu_input_read,	
	 .release =  yuyu_input_close,	
	 
};

static int yuyu_input_init(void)
{ 	

  major = register_chrdev(0, "fifth_drv", &input_drv_fops);
  input_class=class_create(THIS_MODULE, "input_drv");
  input_class_dev= device_create(input_class, NULL, MKDEV(major, 0), NULL, "yuyuirq");
  input_register_device(yuyu_input->input);
  return 0;
}
static void yuyu_input_exit(void)
{ 
  unregister_chrdev(major, "fifth_drv");
  input_unregister_device(yuyu_input->input);
  device_destroy( input_class_dev, MKDEV(major, 0));
  class_destroy(input_class);
  return 0;
}
module_init(yuyu_input_init);
module_exit(yuyu_input_exit);
MODULE_LICENSE("GPL");