OK6410 按键输入子系统

转自：http://blog.163.com/allegro_tyc/blog/static/33743768201182652713278/

按键输入子系统驱动程序

#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/device.h>

#include <linux/gpio.h> 
#include <plat/gpio-cfg.h>
#include <mach/gpio-bank-n.h>
#include <mach/map.h>
  
static struct input_dev *button_dev; 
static irqreturn_t buttons_interrupt(int irq, void *dummy);
static int button_open(struct input_dev *dev);
static void button_close(struct input_dev *dev); 
struct button_irq_desc {
     int irq;          
     int number;         
     char *name;      
};

static struct button_irq_desc button_irqs [] = {
      {IRQ_EINT(0), 0, "KEY0"},
      {IRQ_EINT(1), 1, "KEY1"},
      {IRQ_EINT(2), 2, "KEY2"},
      {IRQ_EINT(3), 3, "KEY3"},
      {IRQ_EINT(4), 4, "KEY4"},
      {IRQ_EINT(5), 5, "KEY5"},
};

static int button_open(struct input_dev *dev)
{
      int i;
      int err = 0;
    
      set_irq_type(IRQ_EINT(0), IRQ_TYPE_EDGE_BOTH);  
      set_irq_type(IRQ_EINT(1), IRQ_TYPE_EDGE_BOTH);  
      set_irq_type(IRQ_EINT(2), IRQ_TYPE_EDGE_BOTH);  
      set_irq_type(IRQ_EINT(3), IRQ_TYPE_EDGE_BOTH);  
      set_irq_type(IRQ_EINT(4), IRQ_TYPE_EDGE_BOTH);  
      set_irq_type(IRQ_EINT(5), IRQ_TYPE_EDGE_BOTH);
    
      for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++)
  {
    if (button_irqs[i].irq < 0) 
      continue;
          err = request_irq(button_irqs[i].irq, buttons_interrupt, IRQF_SAMPLE_RANDOM, 
                          button_irqs[i].name, (void *)&button_irqs[i]);
          if (err)
               break;
      } 
      if (err) 
  {
          i--;
          for (; i >= 0; i--) 
    {
      if (button_irqs[i].irq < 0) 
        continue;
      disable_irq(button_irqs[i].irq);
              free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);
          }
          return -EBUSY;
      } 
      return 0;
} 
static void button_close(struct input_dev *dev)
{
      int i; 
      for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) 
  {
    if (button_irqs[i].irq < 0)
      continue;
    disable_irq(button_irqs[i].irq);
    free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);
      } 
} 
static irqreturn_t buttons_interrupt(int irq, void *dummy)
{
  input_report_key(button_dev, KEY_UP, !(readl(S3C64XX_GPNDAT)&(1<<0)));
  input_report_key(button_dev, KEY_DOWN, !(readl(S3C64XX_GPNDAT)&(1<<1)));
  input_report_key(button_dev, KEY_RIGHT, !(readl(S3C64XX_GPNDAT)&(1<<2)));
  input_report_key(button_dev, KEY_LEFT, !(readl(S3C64XX_GPNDAT)&(1<<3)));
  input_report_key(button_dev, KEY_1, !(readl(S3C64XX_GPNDAT)&(1<<4)));
  input_report_key(button_dev, KEY_2, !(readl(S3C64XX_GPNDAT)&(1<<5)));
 input_sync(button_dev);
  return IRQ_HANDLED;
} 
static int __init button_init(void)
{
  int error;
 struct input_dev *input_dev;
  printk("smdk6410 my_keyboard module start/n");  
      input_dev = input_allocate_device();  
  if(!input_dev)  
  {  
    printk(KERN_ERR "Unable to allocate the input device!!/n");  
    return -ENOMEM;  
  }  
  button_dev = input_dev;  
 
  set_bit(EV_KEY, button_dev->evbit);
  set_bit(KEY_UP, button_dev->keybit);
  set_bit(KEY_DOWN, button_dev->keybit);
  set_bit(KEY_RIGHT, button_dev->keybit);
  set_bit(KEY_LEFT, button_dev->keybit);
  set_bit(KEY_1, button_dev->keybit);
  set_bit(KEY_2, button_dev->keybit);
 
  button_dev->name = "buttons_tyc";
  button_dev->dev.init_name = "input_tyc";
 
  button_dev->open = button_open;
  button_dev->close = button_close;
 
  printk("input device has allocated/n");
 
  error = input_register_device(button_dev);
  if (error)
  {
    printk(KERN_ERR "button.c: Failed to register device\n");
    input_free_device(button_dev);
    return error;
  }
  printk("register device has success\n");
  return 0; 
} 
static void __exit button_exit(void)
{
     input_unregister_device(button_dev); 
} 
module_init(button_init);
module_exit(button_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("modelsim");

 

按键输入子系统测试程序

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <linux/input.h> 
int main(void)
{
 int fd;
 int key_value,i=0,count; 
 struct input_event ev_key;
 fd = open("/dev/input/event0", 666);
 if (fd < 0) 
 {
  perror("open device buttons");
  exit(1);
 } 
 for (;;) 
 {
  count = read(fd,&ev_key,sizeof(struct input_event)); 
  for(i=0; i<(int)count/sizeof(struct input_event); i++)
  if(EV_KEY==ev_key.type)
   printf("type:%d,code:%d,value:%d\n", ev_key.type,ev_key.code,ev_key.value); 
  if(EV_SYN==ev_key.type)
   printf("syn event\n\n");
 } 
 close(fd);
 return 0;
}