Linux驱动开发十六.input系统——1.input_dev
我们在前面通过pin控制学习了LInux内核的GPIO和Pinctrl子系统。GPIO主要用作简单的引脚控制驱动，今天我们来了解一下一组新的子系统：input子系统。input子系统是Linux内核专门提出来处理按键、鼠标、键盘和触摸屏等输入设备的输入事件的。输入设备从本质上来说还是属于字符设备。input子系统就是将输入事件分隔开，用户只需要负责上报类似键值、坐标等信息，input的核心层负责处理这些事件。
input子系统
input子系统是Linux针对输入设备而创建的框架，借用正点原子教程上的图，input子系统将输入系统分解成下面的结构
最左边的部分是最底层的具体的输入设备，中间部分属于Linux的内核空间，分为驱动层和核心层。右边的属于用户态。这种结构就符合我们前面一直强调的驱动的分层，即不同的层级干不同的事情：
- 驱动层负责输入设备的具体驱动，比如按键、鼠标或触摸屏的具体驱动程序，然后向内核报告相关内容
- 核心层类似一个中间键，起到一个承上启下的作用，一边面向驱动提供接口，另一侧向内核报告输入内容。核心层还有个很重要的功能就是帮我们注册一个字符设备
- 事件层主要用来处理输入事件，同时也和用户态做数据交互。
我们这一章主要实现input子系统的驱动框架编写。
input驱动编写
input核心层
要写input驱动，我们可以先看一下内核里是怎么使用input核心层的(drivers/input/input.cinput.c)
直接拉倒最底，可以看见类似我们加载模块的一个函数的用法，调用了设备初始化的函数
sysbsys_initcall是一个分支预测用法的宏，大致作用和我们前面的module_init是一样的。看看上面input_init函数
直接截图比较好看，可以看下上面的函数中有个class_register注册了类，还有个register_chrdev_region创建了字符设备，并且创建字符设备的时候还可以看到定义的主设备号(INPUT_MAJOR，宏定义，路径为include/uapi/linux/major.h可以展开看到)。
#define INPUT_MAJOR 13
也就是创建的设备节点名称叫input，主设备号是13。这个过程和我们前面写的字符设备驱动框架内容差不多。创建的类在系统启动后会在sys/class路径下出现
里面就有一些可以让我们使用的输入设备，并且这个节点在系统启动以后会自动生成这个节点，
如上图所示，生成了input节点，并且主设备号就是13。这么说来，内核已经帮我们完成了input子系统的大致框架，我们要做的就是根据input子系统的要求来编写实际设备的驱动(input_dev)，然后注册到内核里就行了。
input_dev
在使用input子系统的时候我们需要注册一个input设备，内核中使用结构体input_dev来描述input设备(include/linux/input.h)
1 struct input_dev { 2 const char *name; 3 const char *phys; 4 const char *uniq; 5 struct input_id id; 6 7 unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; 8 9 unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; 10 unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; 11 unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; 12 unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; 13 unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; 14 unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; 15 unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; 16 unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; 17 unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; 18 19 unsigned int hint_events_per_packet; 20 21 unsigned int keycodemax; 22 unsigned int keycodesize; 23 void *keycode; 24 25 int (*setkeycode)(struct input_dev *dev, 26 const struct input_keymap_entry *ke, 27 unsigned int *old_keycode); 28 int (*getkeycode)(struct input_dev *dev, 29 struct input_keymap_entry *ke); 30 31 struct ff_device *ff; 32 33 unsigned int repeat_key; 34 struct timer_list timer; 35 36 int rep[REP_CNT]; 37 38 struct input_mt *mt; 39 40 struct input_absinfo *absinfo; 41 42 unsigned long key[BITS_TO_LONGS(KEY_CNT)]; 43 unsigned long led[BITS_TO_LONGS(LED_CNT)]; 44 unsigned long snd[BITS_TO_LONGS(SND_CNT)]; 45 unsigned long sw[BITS_TO_LONGS(SW_CNT)]; 46 47 int (*open)(struct input_dev *dev); 48 void (*close)(struct input_dev *dev); 49 int (*flush)(struct input_dev *dev, struct file *file); 50 int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); 51 52 struct input_handle __rcu *grab; 53 54 spinlock_t event_lock; 55 struct mutex mutex; 56 57 unsigned int users; 58 bool going_away; 59 60 struct device dev; 61 62 struct list_head h_list; 63 struct list_head node; 64 65 unsigned int num_vals; 66 unsigned int max_vals; 67 struct input_value *vals; 68 69 bool devres_managed; 70 };
这个input_dev的结构体比较大，不过还好的是内核源码给出了大部分成员的作用(就在结构体上面)
1 /** 2 * struct input_dev - represents an input device 3 * @name: name of the device 4 * @phys: physical path to the device in the system hierarchy 5 * @uniq: unique identification code for the device (if device has it) 6 * @id: id of the device (struct input_id) 7 * @propbit: bitmap of device properties and quirks 8 * @evbit: bitmap of types of events supported by the device (EV_KEY, 9 * EV_REL, etc.) 10 * @keybit: bitmap of keys/buttons this device has 11 * @relbit: bitmap of relative axes for the device 12 * @absbit: bitmap of absolute axes for the device 13 * @mscbit: bitmap of miscellaneous events supported by the device 14 * @ledbit: bitmap of leds present on the device 15 * @sndbit: bitmap of sound effects supported by the device 16 * @ffbit: bitmap of force feedback effects supported by the device 17 * @swbit: bitmap of switches present on the device 18 * @hint_events_per_packet: average number of events generated by the 19 * device in a packet (between EV_SYN/SYN_REPORT events). Used by 20 * event handlers to estimate size of the buffer needed to hold 21 * events. 22 * @keycodemax: size of keycode table 23 * @keycodesize: size of elements in keycode table 24 * @keycode: map of scancodes to keycodes for this device 25 * @getkeycode: optional legacy method to retrieve current keymap. 26 * @setkeycode: optional method to alter current keymap, used to implement 27 * sparse keymaps. If not supplied default mechanism will be used. 28 * The method is being called while holding event_lock and thus must 29 * not sleep 30 * @ff: force feedback structure associated with the device if device 31 * supports force feedback effects 32 * @repeat_key: stores key code of the last key pressed; used to implement 33 * software autorepeat 34 * @timer: timer for software autorepeat 35 * @rep: current values for autorepeat parameters (delay, rate) 36 * @mt: pointer to multitouch state 37 * @absinfo: array of &struct input_absinfo elements holding information 38 * about absolute axes (current value, min, max, flat, fuzz, 39 * resolution) 40 * @key: reflects current state of device's keys/buttons 41 * @led: reflects current state of device's LEDs 42 * @snd: reflects current state of sound effects 43 * @sw: reflects current state of device's switches 44 * @open: this method is called when the very first user calls 45 * input_open_device(). The driver must prepare the device 46 * to start generating events (start polling thread, 47 * request an IRQ, submit URB, etc.) 48 * @close: this method is called when the very last user calls 49 * input_close_device(). 50 * @flush: purges the device. Most commonly used to get rid of force 51 * feedback effects loaded into the device when disconnecting 52 * from it 53 * @event: event handler for events sent _to_ the device, like EV_LED 54 * or EV_SND. The device is expected to carry out the requested 55 * action (turn on a LED, play sound, etc.) The call is protected 56 * by @event_lock and must not sleep 57 * @grab: input handle that currently has the device grabbed (via 58 * EVIOCGRAB ioctl). When a handle grabs a device it becomes sole 59 * recipient for all input events coming from the device 60 * @event_lock: this spinlock is is taken when input core receives 61 * and processes a new event for the device (in input_event()). 62 * Code that accesses and/or modifies parameters of a device 63 * (such as keymap or absmin, absmax, absfuzz, etc.) after device 64 * has been registered with input core must take this lock. 65 * @mutex: serializes calls to open(), close() and flush() methods 66 * @users: stores number of users (input handlers) that opened this 67 * device. It is used by input_open_device() and input_close_device() 68 * to make sure that dev->open() is only called when the first 69 * user opens device and dev->close() is called when the very 70 * last user closes the device 71 * @going_away: marks devices that are in a middle of unregistering and 72 * causes input_open_device*() fail with -ENODEV. 73 * @dev: driver model's view of this device 74 * @h_list: list of input handles associated with the device. When 75 * accessing the list dev->mutex must be held 76 * @node: used to place the device onto input_dev_list 77 * @num_vals: number of values queued in the current frame 78 * @max_vals: maximum number of values queued in a frame 79 * @vals: array of values queued in the current frame 80 * @devres_managed: indicates that devices is managed with devres framework 81 * and needs not be explicitly unregistered or freed. 82 */
input_dev在使用以前必须先申请！申请过程是下面的函数
1 struct input_dev *input_allocate_device(void) 2 { 3 static atomic_t input_no = ATOMIC_INIT(-1); 4 struct input_dev *dev; 5 6 dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 7 if (dev) { 8 dev->dev.type = &input_dev_type; 9 dev->dev.class = &input_class; 10 device_initialize(&dev->dev); 11 mutex_init(&dev->mutex); 12 spin_lock_init(&dev->event_lock); 13 init_timer(&dev->timer); 14 INIT_LIST_HEAD(&dev->h_list); 15 INIT_LIST_HEAD(&dev->node); 16 17 dev_set_name(&dev->dev, "input%lu", 18 (unsigned long)atomic_inc_return(&input_no)); 19 20 __module_get(THIS_MODULE); 21 } 22 23 return dev; 24 }
申请好的input子设备在卸载时需要释放
void input_free_device(struct input_dev *dev)
有时间可以把这个input.c流程过一下，真的跟我们写的驱动流程差不多！
input_dev结构体
因为input_dev太大了，我们摘几个重要的部分讲一下，首先是下面这一段成员
unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
这几个内容我们要拆开看看
事件类型evbit
事件类型是个长整型，内核给我们指定了宏供我们使用
1 /* 2 * Event types 3 */ 4 #define EV_SYN 0x00 //同步 5 #define EV_KEY 0x01 //按键 6 #define EV_REL 0x02 //相对坐标，类似鼠标移动坐标 7 #define EV_ABS 0x03 //绝对坐标，类似触摸屏触摸坐标 8 #define EV_MSC 0x04 //杂项事 9 #define EV_SW 0x05 //开关 10 #define EV_LED 0x11 //LED 11 #define EV_SND 0x12 //声音 12 #define EV_REP 0x14 //重复，类似按键按下未释放 13 #define EV_FF 0x15 //压力 14 #define EV_PWR 0x16 //电源 15 #define EV_FF_STATUS 0x17 //压力状态 16 #define EV_MAX 0x1f //Todo 17 #define EV_CNT (EV_MAX+1) //计数器
从宏的定义名称可以看出来，EV就是event事件，后面大多数名称都可以根据实际名称推断出实际作用。我们下面要用按键作为input子系统的底层硬件，所以要将evbit的值设置为EV_KEY。
键值keybit
事件下面的几个成员是根据实际事件的类型使用的，如果我们使用了按键类型以后可以使用key_bit来指定按键对应的键值(include/uapi/linux/input.h)
/* * Keys and buttons * * Most of the keys/buttons are modeled after USB HUT 1.12 * (see http://www.usb.org/developers/hidpage). * Abbreviations in the comments: * AC - Application Control * AL - Application Launch Button * SC - System Control */ #define KEY_RESERVED 0 #define KEY_ESC 1 #define KEY_1 2 #define KEY_2 3 #define KEY_3 4 #define KEY_4 5 #define KEY_5 6 #define KEY_6 7 #define KEY_7 8 ......... #define BTN_TRIGGER_HAPPY34 0x2e1 #define BTN_TRIGGER_HAPPY35 0x2e2 #define BTN_TRIGGER_HAPPY36 0x2e3 #define BTN_TRIGGER_HAPPY37 0x2e4 #define BTN_TRIGGER_HAPPY38 0x2e5 #define BTN_TRIGGER_HAPPY39 0x2e6 #define BTN_TRIGGER_HAPPY40 0x2e7
有了上面的宏定义，我们可以把开发板上的按键模拟成键盘上随便一个按键，除了按键，还可以定义成不同的button效果。
我们这一章主要是将按键作为input的实际输入设备，所以后面那些type对应的事件就不再展开说了。在初始化input_dev的时候，主要就是要定义好evbit和keybit，如果需要连续按下效果还要在evbit里定义EV_REP。input_dev在初始化完成以后，要使用下面函数的向内核注册(最后要卸妆)
int __must_check input_register_device(struct input_dev *); void input_unregister_device(struct input_dev *);
input_dev初始化
input_dev是我们申请得到的，在申请以后需要按事件对其进行初始化，初始化有三种方法
1 static int __init xxx_init(void) 2 { 3 inputdev = input_allocate_device(); //申请input设备 4 5 inputdev->name = "keytest"; //设置input的name为keytest 6 7 /*初始化方法一*/ 8 __set_bit(EV_KEY,inputdev->evbit); //设置input事件类型为按键 9 __set_bit(EV_REP,inputdev->evbit); //允许input设备重复 10 __set_bit(KEY_0,inputdev->keybit); //设置按键为KEY_0 11 12 /*初始化方法二*/ 13 inputdev->evbit[0] = BIT_MASK(EV_KEY) | 14 BIT_MASK(EV_REP); 15 inputdev->keybit[BIT_WORD(KEY_0)] |= 16 BIT_MASK(KEY_0); 17 18 /*初始化方法三*/ 19 inputdev->evbit[0] = BIT_MASK(EV_KEY) | 20 BIT_MASK(EV_REP); 21 input_set_capability(inputdev, EV_KEY, KEY_0); 22 23 input_register_device(inputdev); //注册 24 }
上面就是初始化inputdev的三种方法，特别是第三种方法还用到一个新的函数input_set_capability，但是三种方法的效果是一样的。
事件上报
在向Linux内核注册完input_dev以后，我们还需要将输入事件上报给Linux内核，比如我们前面一直使用的按键，在按下按键后触发了中断，然后再中断中调用了定时器用来消抖，定时器溢出时进行按键实际的功能行为，在这里的行为就是向内核上报一个事件，告诉内核按键是否被按下，是哪个按键被按下等等。这个上报事件是input_event函数去处理的。
1 /** 2 * input_event() - report new input event 3 * @dev: device that generated the event 4 * @type: type of the event 5 * @code: event code 6 * @value: value of the event 7 * 8 * This function should be used by drivers implementing various input 9 * devices to report input events. See also input_inject_event(). 10 * 11 * NOTE: input_event() may be safely used right after input device was 12 * allocated with input_allocate_device(), even before it is registered 13 * with input_register_device(), but the event will not reach any of the 14 * input handlers. Such early invocation of input_event() may be used 15 * to 'seed' initial state of a switch or initial position of absolute 16 * axis, etc. 17 */ 18 void input_event(struct input_dev *dev, 19 unsigned int type, unsigned int code, int value) 20 { 21 unsigned long flags; 22 23 if (is_event_supported(type, dev->evbit, EV_MAX)) { 24 25 spin_lock_irqsave(&dev->event_lock, flags); 26 input_handle_event(dev, type, code, value); 27 spin_unlock_irqrestore(&dev->event_lock, flags); 28 } 29 }
函数的参数具体作用我们下面使用的时候会讲到
针对按键而言，还有一个函数是通过调用input_event来实现按键的事件上报。
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_KEY, code, !!value); }
重要点：在输入事件上报完成后，一定要用input_sync函数同步！！！
input模板编写
这次这个input驱动框架的编写我们使用前面那个带抖动消除的按键驱动的整体框架来实现。先把整个代码放出来吧
1 #include <linux/module.h> 2 #include <linux/kernel.h> 3 #include <linux/init.h> 4 #include <linux/fs.h> 5 #include <linux/uaccess.h> 6 #include <linux/io.h> 7 #include <linux/types.h> 8 #include <linux/cdev.h> 9 #include <linux/device.h> 10 #include <linux/of.h> 11 #include <linux/of_address.h> 12 #include <linux/of_irq.h> 13 #include <linux/gpio.h> 14 #include <linux/of_gpio.h> 15 #include <linux/irq.h> 16 #include <linux/interrupt.h> 17 #include <linux/input.h> 18 19 #define DEVICE_CNT 1 20 #define DEVICE_NAME "imx6ukey" 21 22 #define KEY_NUM 1 23 #define KEY0VALUE 0x01 24 #define INVALKEYS 0xFF 25 26 /** 27 * @brief 按键中断结构体 28 * 29 */ 30 struct irq_keydesc { 31 int gpio; //io编号 32 int irqnum; //中断号 33 unsigned char value; //键值 34 char name[10]; //按键名字 35 irqreturn_t (*handler)(int,void*); //中断处理函数 36 }; 37 38 /** 39 * @brief 设备结构体 40 * 41 */ 42 struct new_dev 43 { 44 45 struct device_node *dev_nd; 46 int dev_gpio; 47 48 struct irq_keydesc irqkey[KEY_NUM]; //按键描述数组 49 50 struct timer_list timer; //定时器 51 int timer_per; 52 53 struct input_dev *inputdev; //输入设备 54 55 }; 56 57 struct new_dev new_dev; 58 59 /** 60 * @brief 中断处理函数 61 * 62 */ 63 static irqreturn_t key0_handle_irq(int irq, void *dev_id) 64 { 65 int value = 0; 66 struct new_dev *dev = dev_id; 67 dev->timer.data = dev_id; 68 mod_timer(&dev->timer,jiffies + msecs_to_jiffies(10)); 69 return IRQ_HANDLED; 70 } 71 72 /** 73 * @brief 消抖定时处理函数 74 * 75 * @param arg 76 */ 77 timer_func(unsigned long arg){ 78 79 int value = 0; 80 struct new_dev *dev =(struct new_dev*)arg; 81 82 value = gpio_get_value(dev->irqkey[0].gpio); 83 84 /*上报按键值*/ 85 if(value == 0){ //按下 86 input_event(dev->inputdev,EV_KEY,KEY_0,1); 87 input_sync(dev->inputdev); 88 } 89 else if(value == 1){ //释放 90 input_event(dev->inputdev,EV_KEY,KEY_0,0); 91 input_sync(dev->inputdev); 92 } 93 } 94 95 static int dev_gpio_init(struct new_dev *dev) 96 { 97 int ret = 0; 98 int i = 0; 99 100 //搜索设备树节点 101 dev->dev_nd = of_find_node_by_path("/key"); 102 if(dev->dev_nd == NULL){ 103 printk("can't find device key\r\n"); 104 ret = -EINVAL; 105 goto fail_nd; 106 } 107 108 for(i=0;i<KEY_NUM;i++) 109 { 110 dev->irqkey[i].gpio = of_get_named_gpio(dev->dev_nd,"key-gpios",i); //多个按键获取 111 if(dev->irqkey[i].gpio<0){ 112 ret = -EINVAL; 113 goto fail_gpio_num; 114 } 115 ret = gpio_request(dev->irqkey[i].gpio,dev->irqkey[i].name); 116 if(ret){ 117 ret = -EBUSY; 118 goto fail_gpio_request; 119 } 120 gpio_direction_input(dev->irqkey[i].gpio); 121 dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio); //获取中断号 122 } 123 124 dev->irqkey[0].handler = key0_handle_irq; 125 dev->irqkey[0].value = KEY0VALUE; 126 127 for(i=0;i<KEY_NUM;i++){ 128 memset(dev->irqkey[i].name,0,sizeof(dev->irqkey[i].name)); 129 sprintf(dev->irqkey[i].name,"KEY%d",i); //将格式化数据写入字符串中 130 ret = request_irq(dev->irqkey[i].irqnum, //中断号 131 key0_handle_irq, //中断处理函数 132 IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING, //中断处理函数 133 dev->irqkey[i].name, //中断名称 134 dev //设备结构体 135 ); 136 if(ret){ 137 printk("irq %d request err\r\n",dev->irqkey[i].irqnum); 138 goto fail_irq; 139 } 140 } 141 //此处不设置定时值，防止定时器add后直接运行 142 init_timer(&dev->timer); 143 dev->timer.function = timer_func; 144 145 return 0; 146 fail_gpio_request: 147 fail_irq: 148 for(i=0; i<KEY_NUM;i++){ 149 gpio_free(dev->irqkey[i].gpio); 150 } 151 fail_gpio_num: 152 fail_nd: 153 return ret; 154 } 155 156 static int __init key_init(void) 157 { 158 int ret = 0; 159 160 /*GPIO初始化*/ 161 ret = dev_gpio_init(&new_dev); 162 if(ret<0){ 163 goto fail_gpio_init; 164 } 165 166 /*input_dev处理*/ 167 //申请input_dev 168 new_dev.inputdev = input_allocate_device(); 169 if(new_dev.inputdev == NULL){ 170 ret = -EINVAL; 171 goto fail_gpio_init; //申请失败，误操作 172 } 173 174 //input_dev初始化 175 new_dev.inputdev->name = DEVICE_NAME; 176 __set_bit(EV_KEY,new_dev.inputdev->evbit); //按键事件 177 __set_bit(EV_REP,new_dev.inputdev->evbit); //允许重复 178 __set_bit(KEY_0,new_dev.inputdev->keybit); //设置键值 179 180 //input_dev注册 181 ret = input_register_device(new_dev.inputdev); 182 if(ret){ 183 goto fail_input_register; 184 } 185 return ret; 186 187 fail_input_register: 188 input_free_device(new_dev.inputdev); 189 fail_gpio_init: 190 191 return ret; 192 } 193 194 static void __exit key_exit(void){ 195 int i = 0; 196 //释放中断 197 for(i=0;i<KEY_NUM;i++){ 198 free_irq(new_dev.irqkey[i].irqnum,&new_dev); 199 } 200 201 //释放GPIO 202 for(i=0;i<KEY_NUM;i++){ 203 gpio_free(new_dev.irqkey[i].gpio); 204 } 205 //释放定时器 206 del_timer_sync(&new_dev.timer); 207 208 //注销input_dev 209 input_unregister_device(new_dev.inputdev); 210 input_free_device(new_dev.inputdev); 211 212 } 213 214 module_init(key_init); 215 module_exit(key_exit); 216 MODULE_LICENSE("GPL"); 217 MODULE_AUTHOR("ZeqiZ");
首先我们可以看到，这个new_dev结构体和原先的比起来简化了好多，起码主从设备号、类、设备、cdev、按键状态的原子变量等成员都被删掉了，因为input子系统会帮我们自动创建设备节点。
在设备初始化函数key_init函数中，我们先对GPIO进行初始化，这个过程前面用过了很多次了，就不再说了。
174~178行是我们这一章节所讲的input_dev申请以及初始化
181~184行是将初始化的input_dev注册给内核。
整个驱动把文件操作集合也都删除了，因为这个input子系统是通过事件上报来处理具体信息的，这里在定时中断函数里调用了上报事件的函数，函数一共4个参数
input_event(dev->inputdev,EV_KEY,KEY_0,1); //按键按下 input_event(dev->inputdev,EV_KEY,KEY_0,0); //按键释放
可以看出来按键在按下和释放时调用函数所传递的参数只有最后一个不同，所以input_event函数的参数第一个就是input_dev对象，第二个就是input事件，在这里就是在初始化input_dev时候定义的EV_KEY，第三个参数是根据事件类型来定的，如果是按键事件就是键值，最后一个value就是当前按键是否被按下。
驱动测试
整个模板完成以后，就可以make生成ko文件，加载模块以后可以测试一下
可以看到，在没有加载模块前，/dev/input路径下只有2个文件，在加载完模块以后会有个新的文件event1(加载后生成的input2文件在卸载后重新加载会变成input3，不知道是不是哪个资源没释放)，这个event1就是对应我们的按键。那么怎么测试这个按键呢？要用到一个新的命令：hexdump
看看，打印出来了一堆信息，这个信息就是对应了input_event结构体。这个结构体在我们后面的章节会再分析。这个event1文件就是我们用户态程序要获取按键信息时所操作的对象。
