[字符设备]input子系统实现key驱动

---key.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/mm.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <asm/io.h>
#include <asm/module.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/input.h>

struct input_dev *devp;

struct key_irq_desc
{
    int irq;
    int pin;
    int pin_value;
    int no;
    char *name;
};

static struct key_irq_desc key_irq_table[] =
{
    {IRQ_EINT8 , S3C2410_GPG(0) , S3C2410_GPG0_EINT8  , 0, "KEY0"},
    {IRQ_EINT11, S3C2410_GPG(3) , S3C2410_GPG3_EINT11 , 1, "KEY1"},
    {IRQ_EINT13, S3C2410_GPG(5) , S3C2410_GPG5_EINT13 , 2, "KEY2"},
    {IRQ_EINT14, S3C2410_GPG(6) , S3C2410_GPG6_EINT14 , 3, "KEY3"},
    {IRQ_EINT15, S3C2410_GPG(7) , S3C2410_GPG7_EINT15 , 4, "KEY4"},
    {IRQ_EINT19, S3C2410_GPG(11), S3C2410_GPG11_EINT19, 5, "KEY5"},
};

static irqreturn_t s3c2440_key_interrupt(int irq, void *dev_id)
{
    int i = *(int *)dev_id;
    if (!s3c2410_gpio_getpin(key_irq_table[i].pin))
    {
        switch(i)
        {
            case 0:
                input_report_key(devp, KEY_0, 1);
                break;
            case 1:
                input_report_key(devp, KEY_1, 1);
                break;
            case 2:
                input_report_key(devp, KEY_2, 1);
                break;
            case 3:
                input_report_key(devp, KEY_3, 1);
                break;
            case 4:
                input_report_key(devp, KEY_4, 1);
                break;
            case 5:
                input_report_key(devp, KEY_5, 1);
                break;
        }
        input_sync(devp);
    }
    return IRQ_RETVAL(IRQ_HANDLED);
}
static int s3c2440_key_setup_irq(void)
{
    int i;
    for (i = 0; i < sizeof(key_irq_table)/sizeof(key_irq_table[0]); ++i)
    {
        if (key_irq_table[i].irq < 0)
            continue;
        if (request_irq(key_irq_table[i].irq, s3c2440_key_interrupt, IRQ_TYPE_EDGE_BOTH, key_irq_table[i].name, (void *)&key_irq_table[i].no))
        {
            printk(KERN_ERR "allocate irq fail%d\n", i);
            return -EBUSY;
        }
    }
    return 0;
}

static void s3c2440_key_free_irq(void)
{
    int i;
    for (i = 0; i < sizeof(key_irq_table)/sizeof(key_irq_table[0]); ++i)
        free_irq(key_irq_table[i].irq, &key_irq_table[i].no);
}

static int __init s3c2440_key_init(void)
{
    int i, err;

    for (i = 0; i < sizeof(key_irq_table)/sizeof(key_irq_table[0]); ++i)
        s3c2410_gpio_setpin(key_irq_table[i].pin, key_irq_table[i].pin_value);
    if (s3c2440_key_setup_irq())
        return -EBUSY;
    devp = input_allocate_device();
    if (!devp)
    {
        printk(KERN_ERR "allocate input_dev fail!\n");
        err = -ENOMEM;
        goto fail_free_irq;
    }
    devp->name = "s3c2440_key_input";

    //set_bit(EV_KEY, devp->evbit);
    devp->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY);
    set_bit(KEY_0,  devp->keybit);
    set_bit(KEY_1,  devp->keybit);
    set_bit(KEY_2,  devp->keybit);
    set_bit(KEY_3,  devp->keybit);
    set_bit(KEY_4,  devp->keybit);
    set_bit(KEY_5,  devp->keybit);

    if ((err = input_register_device(devp)))
    {
        printk(KERN_ERR "register input_dev fail\n");
        goto fail_free_dev;
    }
    return 0;

fail_free_dev:
    input_free_device(devp);
fail_free_irq:
    s3c2440_key_free_irq();
    return err;
}


static void __exit s3c2440_key_exit(void)
{
    input_unregister_device(devp);
    input_free_device(devp);
    s3c2440_key_free_irq();
}


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Domod");
module_init(s3c2440_key_init);
module_exit(s3c2440_key_exit);

--app-key.c

#include "keydev.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/input.h>


int main(int argc, char **argv)
{
    int count, i;
    int fd;
    struct input_event ev_key;
    fd = open("/dev/event1", 0);
    if (fd < 0)
    {
        perror("open device key!");
        exit(1);
    }
    while (1)
    {
        count = read(fd, &ev_key, sizeof(struct input_event));
        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");
    }
    close(fd);
    return 0;
}

--Makefile

ifneq ($(KERNELRELEASE),)

obj-m := key.o

else

KDIR := /home/domod/arm/kernel/src/linux-2.6.32.2
all:
    make -C $(KDIR) M=$(PWD) modules ARCH=arm CROSS_COMPILE=arm-linux-
app:
    arm-linux-gcc app-key.c -o key
clean:
    rm -f *.ko *.o *.mod.o *.mod.c *.symvers  modul*


endif