Linux INPUT子系统实验

本实验进行的是当按键按下，上报按键值，是在中断函数的基础上改写的。

驱动程序：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/errno.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/mach/map.h>

#include <linux/cdev.h>
#include <linux/device.h>

#include <linux/of.h>
#include <linux/of_address.h>

#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/timer.h>
#include <linux/ioctl.h>
#include <linux/input.h>

#define INPUTKEY_CNT 1
#define INPUTKEY_NAME "key"

#define KEYVALUE 0XFE
#define KEYNOVALUE 0


/*按键结构体*/
struct irq_keydesc{
    int key_gpio;/*IO编号*/
    int irqnum;/*中断号*/
    unsigned char value;/*键值*/
    irqreturn_t (*handler)(int, void *);	/* 中断服务函数 */
};

/*设备结构体*/
struct key_dev {
    int major;
    int minor;
    struct device_node * bl_nd1;/*设备节点*/
    struct timer_list timer;/*定义一个定时器*/
    unsigned long timerperiod;/*定义一个周期*/
    struct irq_keydesc irq_keydesc;/*按键结构体*/
    struct tasklet_struct tasklet;
    struct input_dev *inputdev;		/* input结构体 */
};

struct key_dev key;

/* @description		: 中断服务函数，开启定时器，延时10ms，
 *				  	  定时器用于按键消抖。
 * @param - irq 	: 中断号 
 * @param - dev_id	: 设备结构。
 * @return 			: 中断执行结果
 */
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    int value=0;
    struct key_dev *dev=dev_id; 
    tasklet_schedule(&key.tasklet);
    return IRQ_HANDLED;
}

static void key_tasklet(unsigned long data)
{
    struct key_dev *dev=(struct key_dev *)data;
    dev->timer.data=data;
    mod_timer(&key.timer,jiffies+msecs_to_jiffies(20));/*开启定时器*/
}


/*定时器回调函数*/
void timer_function(unsigned long t)
{  
    struct key_dev *dev=(struct key_dev * )t;
    static int sta=0;
    int value=0;
    //dev->timerperiod=1000;
    unsigned long period;
    value = gpio_get_value(dev->irq_keydesc.key_gpio); 	/* 读取IO值 */
	
    if(value == 0){ 						/* 按下按键 */
        /* 上报按键值 */
		//input_event(dev->inputdev, EV_KEY, KEY_0, 1);
		input_report_key(dev->inputdev, dev->irq_keydesc.value, 1);/* 最后一个参数表示按下还是松开，1为按下，0为松开 */
		input_sync(dev->inputdev);	
	}
	else{ 									/* 按键松开 */
	    input_report_key(dev->inputdev, dev->irq_keydesc.value, 0);/* 最后一个参数表示按下还是松开，1为按下，0为松开 */
		input_sync(dev->inputdev);	
	}
    //mod_timer(&key.timer,jiffies+msecs_to_jiffies(period));
    //printk("jiffies=%#x\n",jiffies);
}

/*按键初始化*/
static int irqkey_init(void)
{
    int ret=0;
    /*获取设备节点*/
    key.bl_nd1=of_find_node_by_path("/key");
    if(key.bl_nd1==NULL)
    {
        printk("of_find_node_by_path failed\r\n");
        ret = -EINVAL;
        goto fail_nd;
    }
    /*获取设备cd-gpio属性的第一个GPIO编号*/
    key.irq_keydesc.key_gpio=of_get_named_gpio(key.bl_nd1,"cd-gpio",0);
    if(key.irq_keydesc.key_gpio<0)
    {
        printk("of_get_named_gpio failed\r\n");
        ret = -EINVAL;
        goto fail_naned;
}

    /*申请一个GPIO管脚*/
    ret=gpio_request(key.irq_keydesc.key_gpio,"cd-gpio");
    if(ret==0){
        printk("gpio_requests success\n");
    }

    /*将GPIO设置为输出，默认输出高电平*/
    ret=gpio_direction_input(key.irq_keydesc.key_gpio);
    if(ret<0)
    {
        printk("gpio_direction_input failed\n");
        ret = -EINVAL;
        goto fail_input;
    }

    /*获取中断号*/
    key.irq_keydesc.irqnum = gpio_to_irq(key.irq_keydesc.key_gpio);

    /*按键中断初始化*/
    key.irq_keydesc.handler = key0_handler;
    key.irq_keydesc.value = KEY_0;

    ret = request_irq(key.irq_keydesc.irqnum, key.irq_keydesc.handler, 
		                 IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "irqkey", &key);
		if(ret < 0){
			printk("irq %d request failed!\r\n", key.irq_keydesc.irqnum);
			ret = -EFAULT;
            goto fail_irq;
        }

        /*初始化tasklet*/
        tasklet_init(&key.tasklet,key_tasklet,(unsigned long)&key);


        /*初始化定时器*/
        init_timer(&key.timer);
        key.timer.function=timer_function;
        //timerled.timer.expires=jiffies+msecs_to_jiffies(1000);
        key.timer.data=(unsigned long)&key;

    return 0;
    
    fail_irq:
    fail_input:
         gpio_free(key.irq_keydesc.key_gpio);    
    fail_naned:
    fail_nd:
        return ret;
}

static int __init keey_init(void)
{
    
    int ret=0;
    printk("1111111\r\n");
    ret = irqkey_init();
    if(ret==0){
        printk("irqkey_init success\r\n");
    }else{
        return ret;
    }
    /* 申请input_dev */
	key.inputdev = input_allocate_device();
    if(key.inputdev==NULL){
        ret=-EINVAL;
        printk("key.inputdev failed\r\n");
    }
	key.inputdev->name = INPUTKEY_NAME;

	/* 初始化input_dev，设置产生哪些事件 */
	__set_bit(EV_KEY, key.inputdev->evbit);	/* 设置产生按键事件          */
	__set_bit(EV_REP, key.inputdev->evbit);	/* 重复事件，比如按下去不放开，就会一直输出信息 		 */

	/* 初始化input_dev，设置产生哪些按键 */
	__set_bit(KEY_0, key.inputdev->keybit);	

    /*注册inputdev*/
    ret=input_register_device(key.inputdev);
    if(ret){
        goto fail_input_register;
    }
    fail_input_register:
        input_free_device(key.inputdev);
    return 0;
    
}

static void __exit keey_exit(void)
{
    del_timer(&key.timer);
    gpio_free(key.irq_keydesc.key_gpio);
    free_irq(key.irq_keydesc.irqnum,&key);

/* 释放input_dev */
	input_unregister_device(key.inputdev);
	input_free_device(key.inputdev); 
    printk("exit\n");
    printk("exit\n");
}

/*模块的加载与卸载*/
module_init(keey_init);
module_exit(keey_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("liuchuanqiang");

程序说明：
1、程序执行过程：按键按下时，发生中断，中断服务函数执行，调用key_tasklet()函数开启定时器，并在 timer_function()函数中上报按键值；

2、综上所述，input_dev 注册过程如下： 

①、使用 input_allocate_device 函数申请一个 input_dev。

②、初始化 input_dev 的事件类型以及事件值。

③、使用 input_register_device 函数向 Linux 系统注册前面初始化好的 input_dev。

④、卸载input驱动的时候需要先使用input_unregister_device函数注销掉注册的input_dev，然后使用 input_free_device 函数释放掉前面申请的 input_dev。

应用程序：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <linux/input.h>

/*
argc:应用程序参数个数
argv[]:具体的参数内容，字符串形式，这个函数中的第一个参数内容./keyAPP；
       第二个参数内容filename;
执行文件格式：
    ./inputkeyAPP /dev/input/event1
*/


#define KEYVALUE 0XFE
#define KEYNOVALUE 0


static struct input_event inputevent;

int main(int argc,char *argv[])
{
    int ret=0;
    int fd=0;
    char *filename;
    int num;
    filename=argv[1];//一个字符串的声明

    printf("filename=%s\n",filename);
    if(argc!=2)
    {
        printf("error\n");
        return -1;
    }
    //打开文件
    fd=open(filename, O_RDWR);
    //判断有没有打开成功
    if(fd<0)
    {
        printf("open failed\r\n");
        return -1;
    }

    while(1){
        ret=read(fd,&inputevent,sizeof(inputevent));
        if(ret<0){
            printf("数据读取失败\r\n");

        }else{
            switch(inputevent.type){
                case EV_KEY:
                    printf("EV_KEY事件\r\n");
                    if (inputevent.code < BTN_MISC) { /* 键盘键值 */
						printf("key %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
					} else {
						printf("button %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
					}
                    break;
                case EV_REL:
					break;
				case EV_ABS:
					break;
				case EV_MSC:
					break;
				case EV_SW:
					break;
                case EV_SYN:
                    printf("EV_SYN事件\r\n");
                    break;    
            } 
        }   
    }
    

//关闭文件
        ret=close(fd);
        if(ret<0)
        {
            printf("close failed\r\n");
            return -1;
        }
   
    return 0;
}

程序说明：

1. 、INPUT子系统驱动程序上报信息时，是通过input_event结构体进行的。我们只要读取static struct input_event inputevent;该结构体变量中的内容就可以对使用应用程序对驱动程序读取。

     2、input_event结构体内容如下：
        struct input_event {

                struct timeval time;

                __u16 type;

                __u16 code;

                __s32 value;

                 };