输入子系统--按键驱动

---

一、输入子系统

linux输入子系统（linux input subsystem）从上到下由三层实现，分别为：事件层（EventHandler）、核心层（InputCore）和设备驱动层。

设备驱动层：主要实现对硬件设备的读写访问，中断设置，并把硬件产生的事件转换为核心层定义的规范提交给事件处理层。
核心层：为设备驱动层提供了规范和接口。设备驱动层只要关心如何驱动硬件并获得硬件数据（例如按下的按键数据），然后调用核心层提供的接口，核心层会自动把数据提交给事件处理层。
事件处理层：则是用户编程的接口（设备节点），并处理驱动层提交的数据处理。

input driver -> Input core -> Event handler -> userspace

架构分析参考: https://blog.csdn.net/yetaibing1990/article/details/82753515

二、设备申请与成员赋值

1.申请设备空间

struct input_dev *input_allocate_device(void)
返回设备结构体指针
inputdev = input_allocate_device();

2.设备结构体赋值

inputdev->name = "key_input";

3.设置设备事件

set_bit(EV_KEY, inputdev->evbit);
函数功能将EV_KEY赋给inputdev->evbit   让设备支持按键事件

set_bit(code, inputdev->keybit);
设置设备的键值

4.gpio与gpio中断

略

三、注册设备

int input_register_device(struct input_dev *dev)

input_register_device(inputdev);
将设备注册到内核 使得再sys/class/input下产生设备节点

四、注销设备

void input_unregister_device(struct input_dev *dev)
注销设备
input_unregister_device(inputdev);

五、按键驱动实现

需要使用gpio中断(中断上半部)+工作队列(中断下半部)

大致过程：按键按下产生按键中断在中断服务函数里实现操作、并将事件上报input_report_key和事件同步input_sync一起才可以使用户层获得信息
再schedule_work 进行按键释放的检测 、检测到再上报事件和同步事件

使用工作队列相当于你个内核线程去完成中断任务中事件比较长的工作，中断中不能进行阻塞，这之间起到一个平衡

加载驱动后可以通过/dev/input/eventx 进行设备的访问

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/delay.h>
#include <linux/bcd.h>
#include <linux/capability.h>
#include <linux/rtc.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>

#include <../arch/arm/mach-mx28/mx28_pins.h>

#include <linux/input.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/delay.h>


#include <mach/pinctrl.h>
#include <linux/hrtimer.h>
#include <linux/jiffies.h>
#include <../arch/arm/mach-mx28/regs-pinctrl.h>
#include <../include/mach/regs-timrot.h>
#include <../include/mach/regs-timrot.h>
#include <../include/mach/regs-icoll.h>
#include <asm/io.h>

struct imx28x_key_struct {
	int no;
	int key_code;  /* 按键能产生的键值*/
	int gpio;  /* 按键连接的 GPIO */
	struct work_struct work;  /* 按键的工作队列  */
};

struct input_dev *inputdev;

struct imx28x_key_struct keys_list[] ={
	{.no=0, .key_code = KEY_DOWN, .gpio = MXS_PIN_TO_GPIO(PINID_LCD_D17)},
	{.no=1, .key_code = KEY_LEFT, .gpio = MXS_PIN_TO_GPIO(PINID_LCD_D18)},
	{.no=2, .key_code = KEY_ENTER, .gpio = MXS_PIN_TO_GPIO(PINID_SSP0_DATA4)},
	{.no=3, .key_code = KEY_RIGHT, .gpio = MXS_PIN_TO_GPIO(PINID_SSP0_DATA5)},
	{.no=4, .key_code = KEY_UP, .gpio = MXS_PIN_TO_GPIO(PINID_SSP0_DATA6)}
};

static void imx28x_scankeypad(struct work_struct *_work)
{
	struct imx28x_key_struct *key_tmp = container_of(_work, struct imx28x_key_struct, work);  //可以通过结构体的成员找到结构体的地址，即通过孩子找父亲
	int gpio = key_tmp->gpio;
	int code = key_tmp->key_code;
	
	if(!gpio_get_value (gpio))
	{
		mdelay(10);
	}
	input_report_key(inputdev, code, 0);
	input_sync(inputdev);
	
}

static irqreturn_t imx28x_key_intnerrupt(int irq, void *dev_id)
{
	int i =   *(int *)dev_id;
	int gpio,code;

	code = keys_list[i].key_code;
	gpio = keys_list[i].gpio;

	if(gpio_get_value(gpio))
	{
		return IRQ_HANDLED;
	}

	input_report_key(inputdev, code, 1);   //上报事件和数据
	input_sync(inputdev);					//同步上报  ，必须，否则用户层接受不到上报事件和数据 
	
	schedule_work(&(keys_list[i].work));   //类似于唤醒工作队列
		
	return IRQ_HANDLED;
}

static int __devinit iMX28x_key_init(void)
{
	int i;
	int code,gpio;
	int irq_no,ret;
	
	inputdev = input_allocate_device();//申请设备空间
	if(!inputdev)
	{
		return -ENOMEM;
	}
	inputdev->name = "lyc--key_input";
	
	set_bit(EV_KEY, inputdev->evbit);  //设置按键事件
	for(i=0;i<sizeof(keys_list)/sizeof(keys_list[0]);i++)
	{
		code = keys_list[i].key_code;
		gpio = keys_list[i].gpio;

		set_bit(code, inputdev->keybit); //设置键值
		INIT_WORK(&(keys_list[i].work),imx28x_scankeypad); //动态申请工作队列
		
		gpio_free(gpio);
		ret = gpio_request(gpio, "key_gpio");
		if(ret)
		{
			printk("gpio: %d request fail",gpio);
			return -EBUSY;
		}
		irq_no = gpio_to_irq(gpio);
		gpio_direction_input(gpio);          
		set_irq_type(irq_no, IRQF_TRIGGER_FALLING);

		ret = request_irq(irq_no, imx28x_key_intnerrupt,IRQF_DISABLED , "imx28x_key", &keys_list[i].no);
		if(ret)
		{
			printk("request irq faile %d!\n", irq_no);
			return -EBUSY;
		}
		
	}
	input_register_device(inputdev);         //申请输入系统子设备
	printk("EasyARM-i.MX28x key driver up \n");
	return 0;
}

static void __exit iMX28x_key_exit(void)
{
	int i = 0;
	int irq_no;

	input_unregister_device(inputdev);   //注销输入系统子设备
	for(i=0;i<sizeof(keys_list)/sizeof(keys_list[0]);i++)
	{
		irq_no = gpio_to_irq(keys_list[i].gpio);
		free_irq(irq_no, NULL);
		gpio_free(keys_list[i].gpio);
	}
	printk("EasyARM-i.MX28x key driver remove \n");
}

module_exit(iMX28x_key_exit);
module_init(iMX28x_key_init);

MODULE_LICENSE("Dual BSD/GPL");

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

./key_main  /dev/input/event0
*/
int main (int argc, char * argv[])
{
	int fd,count;
	struct input_event input_event_value;
	char input_type[20];

	if (argc !=2 ) {
                printf("usage : input_type /dev/input/eventX\n");
                return 0;
        }

	fd = open (argv[1], O_RDWR);
	if (fd < 0) {
		printf ("open %s failed\n", argv[1]);
		exit(0);
	}

	while(1) {							
		count=read(fd, &input_event_value, sizeof(struct input_event));
		if (count < 0) {
			printf("read iput device event error \n");
			return -1;
		}

		switch(input_event_value.type) {
		case EV_SYN:
			strcpy(input_type, "SYNC");
			break;
		case EV_REL:
			strcpy(input_type, "REL");
			break;
		case EV_ABS:
			strcpy(input_type, "ABS");
			break;
		case EV_KEY:
			strcpy(input_type, "KEY");
			if(input_event_value.code == 0x18 && input_event_value.value ==1)
			{
				//
			}
			if(input_event_value.code == 0x18 && input_event_value.value ==0)
			{
				
			}
			if(input_event_value.code == 0x19 && input_event_value.value ==1)
			{
				
			}
			break;
		default:
			printf("even type unkown \n");
			return -1;
		}

		printf("time:%ld.%ld",input_event_value.time.tv_sec,input_event_value.time.tv_usec);
		printf(" type:%s code:%d value:%d\n",input_type,input_event_value.code,input_event_value.value);
	}
	close(fd);
	
	return 0;
}