（转载）linux 输入子系统
Linux输入子系统将输入驱动抽象为三层：事件处理层、核心层、设备驱动层。应用程序只需要跟事件处理层打交道，不需要察觉设备的变化。核心层是负责管理输入设备，并将消息在事件处理层和设备驱动层之间传递。
由于事件处理和设备驱动的分离，使得应用程序读取输入信息的接口固定不变就可以适应新的同类输入设备。
表示事件处理层的数据结构是struct input_handler，每个handler代表一种处理事件的方式，允许多个handler共存。代表设备驱动层的数据结构是struct input_dev。input_dev和handler可以建立连接，连接它们的就是struct input_handle。核心层一般被称为input core。
1.1 重要的数据结构
在输入子系统的设备驱动中，最重要的数据结构是struct input_dev，如程序清单 1.1所示。需要完成的大部分工作都是围绕着它来的，它是驱动的主体。每个struct input_dev代表一个输入设备。
程序清单 1.1 struct input_dev成员介绍
/* include/linux/input.h */
struct input_dev {
const char *name; /*设备名 */
const char *phys;
const char *uniq;
struct input_id id; /*用于匹配事件处理层handler */
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)]; /* led */
unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; /* beep */
unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
unsigned int keycodemax; /*支持的按键值的个数 */
unsigned int keycodesize; /*每个键值的字节数 */
void *keycode; /*存储按键值的数组首地址 */
int (*setkeycode)(struct input_dev *dev, int scancode, int keycode); /* 修改键值的函数，可选 */
int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode); /* 获取扫描码的键值，可选 */
struct ff_device *ff;
unsigned int repeat_key; /*最近一次按键值，用于连击 */
struct timer_list timer; /*自动连击计时器 */
int sync; /*最后一次同步后没有新的事件置1*/
int abs[ABS_MAX + 1]; /* 当前各个坐标的值 */
int rep[REP_MAX + 1]; /*自动连击的参数 */
unsigned long key[BITS_TO_LONGS(KEY_CNT)]; /*反映当前按键状态的位图 */
unsigned long led[BITS_TO_LONGS(LED_CNT)]; /*反映当前led状态的位图 */
unsigned long snd[BITS_TO_LONGS(SND_CNT)]; /*反映当前beep状态的位图 */
unsigned long sw[BITS_TO_LONGS(SW_CNT)];
int absmax[ABS_MAX + 1]; /*记录各个坐标的最大值 */
int absmin[ABS_MAX + 1]; /*记录各个坐标的最小值 */
int absfuzz[ABS_MAX + 1]; /*记录各个坐标的分辨率 */
int absflat[ABS_MAX + 1]; /*记录各个坐标的基准值 */
int (*open)(struct input_dev *dev); /*打开函数 */
void (*close)(struct input_dev *dev); /*关闭函数 */
int (*flush)(struct input_dev *dev, struct file *file); /* 断开连接时冲洗数据 */
int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); /* 回调函数，可选 */
struct input_handle *grab;
spinlock_t event_lock;
struct mutex mutex;
unsigned int users;
int going_away;
struct device dev;
struct list_head h_list; /* handle链表 */ struct list_head node; /* input_dev链表 */
};
struct input_event是事件传送的载体，输入子系统的事件都是包装成struct input_event传给用户空间。各个成员如程序清单 1.2所示。
程序清单 1.2 struct input_event成员介绍
/* include/linux/input.h */
struct input_event {
struct timeval time; /*时间戳 */
__u16 type; /*事件类型 */
__u16 code; /*事件代码 */
__s32 value; /*事件值，如坐标的偏移值 */
};
struct input_dev注册的时候需要跟匹配的hanlder建立连接，匹配的依据就是struct input_dev所包含的struct input_id。struct input_id的各个成员如程序清单 1.3所示。
程序清单 1.3 struct input_id成员描述
/* include/linux/input.h */
struct input_id {
__u16 bustype; /*总线类型 */
__u16 vendor; /*生产商编号 */
__u16 product; /*产品编号 */
__u16 version; /*版本号 */
};
1.2 基于输入子系统的键盘驱动例程
下面提供一个基于输入子系统的键盘驱动例程，这里只是介绍编写一个键盘驱动需要哪些步骤，并不解释本程序的全部细节。如程序清单 1.4所示。
程序清单 1.4 输入子系统设备驱动例程-键盘驱动
#define NR_SCANCODES (4)
typedef unsigned char KEYCODE_T;
static KEYCODE_T keypad_keycode[NR_SCANCODES] = /* 按键值 */
{
KEY_BACKLIGHT, KEY_X, KEY_Y, KEY_Z
};
typedef struct { /*自己定义的结构体 */
struct input_dev *input;
int irq;
KEYCODE_T keycode[ARRAY_SIZE(keypad_keycode)];
KEYCODE_T lastkey;
char phys[32];
}KEYPAD_T;
static int __init keypad_init(void)
{
int err;
int i;
zlgkpd = kzalloc(sizeof(KEYPAD_T), GFP_KERNEL); ①
if (unlikely(!zlgkpd))
{
return-ENOMEM;
}
strcpy(zlgkpd->phys, "keypad/input0");
zlgkpd->input = input_allocate_device(); ②
if (!zlgkpd->input)
{
kfree(zlgkpd);
return-ENOMEM;
}
zlgkpd->input->name = CHIP_NAME; ③
zlgkpd->input->phys = zlgkpd->phys;
zlgkpd->input->id.bustype = BUS_HOST; ④
zlgkpd->input->id.vendor = 0x0001;
zlgkpd->input->id.product = 0x0001;
zlgkpd->input->id.version = 0x0100;
zlgkpd->input->keycode = zlgkpd->keycode; ⑤
zlgkpd->input->keycodesize = sizeof(KEYCODE_T);
zlgkpd->input->keycodemax = ARRAY_SIZE(keypad_keycode);
zlgkpd->input->open = keypad_open; ⑥
zlgkpd->input->close = keypad_close;
zlgkpd->irq = KEYPAD_IRQ;
set_bit(EV_KEY, zlgkpd->input->evbit); ⑦
for (i = 0; i < ARRAY_SIZE(keypad_keycode); i++) { ⑧
set_bit(keypad_keycode[i], zlgkpd->input->keybit);
}
clear_bit(KEY_RESERVED, zlgkpd->input->keybit);
err = input_register_device(zlgkpd->input); ⑨
if (err)
goto err;
DPRINTK("init OK!/n");
return 0;
err:
DPRINTK("init error/n");
input_free_device(zlgkpd->input);
kfree(zlgkpd);
return err;
}
static void __exit keypad_exit(void)
{
input_unregister_device(zlgkpd->input); ⑩
input_free_device(zlgkpd->input);
kfree(zlgkpd);
}
module_init(keypad_init);
module_exit(keypad_exit);
下面来一步步解释：
①为自己定义的类型申请空间。这一步不是典型输入子系统驱动的必须步骤。
②申请 struct input_dev并做初始化。
③初始化设备的名字。
④初始化设备ID。在注册设备之前，名字和ID是必须初始化的。
⑤初始化设备键值数组首地址、键值字节大小和按键的个数。
⑥初始化设备的打开和关闭函数指针。
⑦使设备支持按键事件。只有注册过的事件类型才能响应。
⑧注册支持的按键键值。只有注册过的键值才能响应。
⑨注册设备结构体。
⑩释放占用的资源。
发送事件的代码如下
程序清单 1.5 发送按键事件
static void keypad_do_workqueue(struct work_struct *data)
{
/* ··········
some codes
···········*/
if (pressed) {
············
input_report_key(zlgkpd->input, code, KEY_PRESSED); ①
input_sync(zlgkpd->input);
zlgkpd->lastkey = code;
DPRINTK("KEY is %d, pressed: %d, index:%d/n", code, pressed, index);
input_report_key(zlgkpd->input, code, KEY_RELEASED); ②
input_sync(zlgkpd->input);
}
enable_irq(KEYPAD_IRQ);
}
static irqreturn_t keypad_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
disable_irq(KEYPAD_IRQ);
schedule_work(&key_wq);
return IRQ_HANDLED;
}
在中断底半部中，读取硬件决定发送的按键值，首先发送按键按下的信息，然后发送按键抬起的信息。每次发送事件之后都同步一次。
1.3 输入子系统设备驱动讲解1.3.1 打开和关闭函数
struct input_dev中有open和close两个函数指针。在与handler第一次连接之后会调用open函数，断开连接会调用close。open中应该完成硬件初始化的相关工作，并且申请用到的其他资源，如中断号。close函数做相反的工作。
1.3.2 事件类型
Linux输入子系统支持的事件类型如程序清单 1.6所示。
程序清单 1.6 输入子系统事件类型
/* include/linux/input.h */
#define EV_SYN 0x00 /* 同步事件 */
#define EV_KEY 0x01 /*按键事件 */
#define EV_REL 0x02 /*相对坐标 */
#define EV_ABS 0x03 /*绝对坐标 */
#define EV_MSC 0x04
#define EV_SW 0x05
#define EV_LED 0x11 /* led */
#define EV_SND 0x12 /* beep */
#define EV_REP 0x14 /*连击事件 */
#define EV_FF 0x15
#define EV_PWR 0x16
#define EV_FF_STATUS 0x17
#define EV_MAX 0x1f
#define EV_CNT (EV_MAX+1)
按键事件(EV_KEY)是最简单的事件类型，用来描述按键或者按钮。报告按键事件使用以下函数：
input_report_key(struct input_dev *dev, int code, int value)
code的值在<内核>include/linux/input.h中定义，大小从0到KEY_MAX。value为0时表示按键抬起，非0时代表按键按下。对同一个按键来说，只有当value的值和上次不同才会产生一次事件。
除了按键事件，相对坐标事件(EV_REL)和绝对坐标事件(EV_ABS)也是常用的事件。为了使设备支持这两类事件，需要在初始化时对struct input_dev的evbit相应比特置1，并且还要分别在relbit和absbit位图中为支持的坐标轴置1。参考1.2节的7、8两步。
相对坐标事件用来描述类似鼠标移动的消息。报告相对坐标的函数如下：
input_report_rel(struct input_dev *dev, int code, int value)
code描述坐标轴，value代表相对移动（可正可负）。只有当value的值非零时才能产生一个有效的事件。
绝对坐标需要额外的工作。初始化时需要填充input_dev中的一些数据域。对于支持的每个坐标轴调用如下函数：
input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat);
函数参数从右往左依次代表输入设备指针、坐标轴、最小值、最大值、分辨率、基准值。最后两个参数也可以填为0，代表设备非常精确并且总能精确的回到中心位置。
input_set_abs_params函数的代码如程序清单 1.7所示。
程序清单 1.7 input_set_abs_params
static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
{
dev->absmin[axis] = min;
dev->absmax[axis] = max;
dev->absfuzz[axis] = fuzz;
dev->absflat[axis] = flat;
dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); /* 这一行已经注册了坐标 */
}
另外输入设备驱动中经常用到同步事件(EV_SYN)，输入子系统会默认支持此事件，驱动无需注册。鼠标、触摸板之类的设备需要用它来提示上层已经发送完了一个完整的事件报告。同步事件的报告形式如下：
input_sync(zlgkpd->input);
1.3.3 keycode、 keycodemax和keycodesize
首先说明扫描码和键值的区别。如程序清单 1.4所示，例子中包含四个按键的值，那么扫描码的范围是0~3，键值就是keypad_keycode中的四个值。
keycode、 keycodemax和keycodesize这三个数据域保存的值分别是键值数组的首地址、键值的个数和每个键值的字节大小。有了这三个变量，就可以在运行是改变键盘的键值映射。比如原来数组中的第四个键值为KEY_Z，可以根据需要改为KEY_D或者其他的值。这样同样的扫描码就对应的不同的键值。
这三个域正确填充之后，内核可以使用input_dev的成员函数来修改键值映射。修改映射的函数就是input_dev中的setkeycode、getkeycode这两个函数指针对应的函数，如果注册之前不初始化它们，则初始化函数把系统默认的函数赋给它们。
EVIOCGKEYCODE和EVIOCSKEYCODE这两个ioctl命令分别用来查看和修改键值。
1.3.4 按键的自动连击
我们都有这样的经历：按住方向键不松开，一直把文档往某个方向拉。这个功能就是自动连击，也就是在按键抬起之前连续发送按键事件。
按键连击事件(EV_REP)的开启非常简单，在input_devd的evbit相应比特置1即可。dev->rep[REP_DELAY]和dev->rep[REP_PERIOD]分别存储连击的延时和周期，如果驱动不对它们赋值，则系统为他们分别赋为250和33。按键延时即按键到第一次连击的间隔，按键周期即两次连击之间的间隔。它们的单位都是毫秒。
1.3.5 总线类型
input_dev中input_id用到了总线类型。输入子系统支持的总线类型如程序清单 1.8所示。
程序清单 1.8 输入子系统总线类型
/* include/linux/input.h */
#define BUS_PCI 0x01
#define BUS_ISAPNP 0x02
#define BUS_USB 0x03
#define BUS_HIL 0x04
#define BUS_BLUETOOTH 0x05
#define BUS_VIRTUAL 0x06
#define BUS_ISA 0x10
#define BUS_I8042 0x11
#define BUS_XTKBD 0x12
#define BUS_RS232 0x13
#define BUS_GAMEPORT 0x14
#define BUS_PARPORT 0x15
#define BUS_AMIGA 0x16
#define BUS_ADB 0x17
#define BUS_I2C 0x18
#define BUS_HOST 0x19
#define BUS_GSC 0x1A
#define BUS_ATARI 0x1B
1.3.6 其他的事件类型
EV_LED和EV_SND事件是针对键盘上的led和蜂鸣器。这两类事件是由输入子系统内核发送给驱动的。
如果驱动支持这两类事件的话，应该填充input_dev中的event函数指针，其实这是一个回调函数。另外需要填充input_dev中evbit对应的比特位。
这个回调函数可能在中断或者中断的底半部调用，因此event函数不能睡眠且必须尽快结束。
1.4 input_dev的注册
在输入设备驱动的初始化函数的最后一步就是调用input_register_device注册设备。这个函数如程序清单 1.9所示。
程序清单 1.9 input_register_device
/* driver/input/input.c */
int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);
struct input_handler *handler;
const char *path;
int error;
__set_bit(EV_SYN, dev->evbit); ⑴
init_timer(&dev->timer); ⑵
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
if (!dev->getkeycode) ⑶
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
"input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
error = device_add(&dev->dev);
if (error)
return error;
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
printk(KERN_INFO "input: %s as %s/n",
dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
kfree(path);
error = mutex_lock_interruptible(&input_mutex);
if (error) {
device_del(&dev->dev);
return error;
}
list_add_tail(&dev->node,& input_dev_list); ⑷
list_for_each_entry(handler,& input_handler_list, node) ⑸
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
return 0;
}
下面就标记的几点进行说明：
⑴注册同步事件为支持的类型，任何设备都默认支持同步事件。
⑵初始化设备连击计时器，如果驱动没有填写连击参数就使用默认值。
⑶如果驱动没有实现映射修改和查看的函数，填充默认函数。
⑷将本设备加入设备链表(这个链表是全局的)。
⑸将本设备和已经存在的handler进行比较，与id相匹配的handler建立连接。需要说明的是设备可能跟多个handler连接，这样此设备产生的事件会分发给所有连接的handler。
可以看出上面第五步是最重要的一步，下面继续分析input_attach_handler这个函数。它的代码如程序清单 1.10所示。
程序清单 1.10 input_attach_handler
/* driver/input/input.c */
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
if (handler->blacklist && input_match_device(handler->blacklist, dev)) ⑴
return-ENODEV;
id = input_match_device(handler->id_table, dev); ⑵
if (!id)
return-ENODEV;
error = handler->connect(handler, dev, id); ⑶
if (error && error != -ENODEV)
printk(KERN_ERR
"input: failed to attach handler %s to device %s, "
"error: %d/n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
需要说明的地方有三点：
⑴handler->blacklist中存储的是禁止连接的设备id，因此首先查看该设备是否允许连接。
⑵ handler->id_table存储handler支持的设备id。如果能够找到匹配的id，则建立dev和handler之间的连接。
⑶建立dev和handler之间的连接。
connect函数的实现下章再讲，下面看看input_match_device的实现。代码如程序清单 1.11所示。
程序清单 1.11 input_match_device
/* driver/input/input.c */
#define MATCH_BIT(bit, max) /
for (i = 0; i < BITS_TO_LONGS(max); i++) /
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) / ⑴
break; /
if (i != BITS_TO_LONGS(max)) /
continue;
static const struct input_device_id *input_match_device(const struct input_device_id *id,
struct input_dev *dev)
{
int i;
for (; id->flags || id->driver_info; id++) {
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS) ⑵
if (id->bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->vendor != dev->id.vendor)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;
MATCH_BIT(evbit, EV_MAX); ⑶
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
MATCH_BIT(swbit, SW_MAX);
return id;
}
return NULL;
}
匹配的过程主要做了两件事：
⑵根据id->flag检查id是否匹配。id->flag记录需要匹配哪些域。
⑶检查支持的事件种类是否一致。
第二种检查用到的宏MATCH_BIT定义在⑴处。其中最重要的一句是“if ((id->bit[i] & dev->bit[i]) != id->bit[i])”，这句话意味着id支持的事件种类是dev支持的事件的子集就算匹配了。如果某个handler的id除了id->driver_info之外的域都为0，那么此handler可以和任意dev匹配。实际上<内核>/driver/input/evdev.c中就是这么初始化id的。
现在总结一下input_dev注册的过程：一个input_dev注册的过程主要是在将自己加入input_dev_list，然后在input_handler_list中找到id和事件种类相匹配的handler并与之建立连接的过程。
input_dev产生的事件会分发给所有建立连接的handler。下面继续分析事件的传递。
1.5 事件报告的传递
输入子系统设备报告各种事件通过input_report_XXX族函数，例如程序清单 1.5中报告按键事件。按键、相对坐标、绝对坐标和同步事件报告的函数如程序清单 1.12所示。
程序清单 1.12 事件报告函数
/* include/linux/input.h */
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_KEY, code, !!value); ⑴
}
static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_REL, code, value);
}
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_ABS, code, value);
}
static inline void input_sync(struct input_dev *dev)
{
input_event(dev, EV_SYN, SYN_REPORT, 0);
}
可以看到，这四个函数都调用了input_event，并且在⑴处将按键的value转化为布尔类型的值。所以按键传给input core的value是0(释放)或者1(按下)。
input_event函数的代码如程序清单 1.13所示。
程序清单 1.13 input_event
/* driver/input/input.c */
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
unsigned long flags;
if (is_event_supported(type, dev->evbit, EV_MAX)) {
spin_lock_irqsave(&dev->event_lock, flags);
add_input_randomness(type, code, value); ⑴
input_handle_event(dev, type, code, value); ⑵
spin_unlock_irqrestore(&dev->event_lock, flags);
}
}
EXPORT_SYMBOL(input_event);
本函数总共有两行有效的调用：
⑴由于输入事件具有随机性，因此用输入事件来增加内核熵池的熵。
⑵调用事件分发函数input_handle_event，做进一步的传递。
input_handle_event的代码如所示。
/* driver/input/input.c */
#define INPUT_IGNORE_EVENT 0
#define INPUT_PASS_TO_HANDLERS 1
#define INPUT_PASS_TO_DEVICE 2
#define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)
static void input_handle_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
int disposition = INPUT_IGNORE_EVENT;
switch (type) {
····························
case EV_KEY:
if (is_event_supported(code, dev->keybit, KEY_MAX) && ⑴
!!test_bit(code, dev->key) != value) { ⑵
if (value != 2) { ⑶
__change_bit(code, dev->key); ⑷
if (value) ⑸
input_start_autorepeat(dev, code);
}
disposition = INPUT_PASS_TO_HANDLERS; ⑹
}
break;
case EV_ABS:
if (is_event_supported(code, dev->absbit, ABS_MAX)) { ⑺
value = input_defuzz_abs_event(value, ⑻
dev->abs[code], dev->absfuzz[code]);
if (dev->abs[code] != value) { ⑼
dev->abs[code] = value;
disposition = INPUT_PASS_TO_HANDLERS;
}
}
break;
case EV_REL:
if (is_event_supported(code, dev->relbit, REL_MAX) && value) ⑽
disposition = INPUT_PASS_TO_HANDLERS;
break;
························
}
if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
dev->sync = 0;
if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
dev->event(dev, type, code, value);
if (disposition & INPUT_PASS_TO_HANDLERS)
input_pass_event(dev, type, code, value);
}
上述代码中去除了其他事件的部分，线面说明按键、相对坐标和绝对坐标的处理部分：
⑴检查按键是否为驱动所支持，只有之前注册过的按键才会继续传递。
⑵检查报告的按键状态是否和上次相同。如果连续多次报告按键按下，则只处理第一次。
⑶如果不是连击事件。
⑷翻转按键的当前状态(按下和释放)。
⑸如果是按下，则开始连击计时。
⑹标记消息传递方向。
⑺检查绝对坐标轴是否驱动所支持的。
⑻根据当前报告的值和上次报告的值确定传给处理程序的绝对值大小。
⑼如果本次需要报告的绝对值和上次不同，则将事件传递给处理函数。
⑽检查相对坐标轴是否被驱动所支持。
可以看到input_handle_event分发事件有两个方向：驱动的回调函数dev->event和input core的input_pass_event。下面继续分析input_pass_event，代码如程序清单 1.14所示。
程序清单 1.14 input_pass_event
/* driver/input/input.c */
static void input_pass_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
rcu_read_lock();
handle = rcu_dereference(dev->grab); ⑴
if (handle)
handle->handler->event(handle, type, code, value);
else
list_for_each_entry_rcu(handle,& dev->h_list, d_node) ⑵
if (handle->open) ⑶
handle->handler->event(handle, type, code, value); ⑷
rcu_read_unlock();
}
这个函数将事件分发给相关的handler。
⑴获取独占设备的handle的指针。如果有独占设备的handle，则仅仅将事件传给独占的handle对应的handler。
⑵遍历与此设备连接的每一个handle。
⑶如果hnadle已经被打开。
⑷将事件分发给handler的事件处理函数。
到这里，input core分发事件的任务已经完成，接下来由各个handler处理接收到的事件。
第2章 输入子系统的事件驱动
上一章已经说过输入子系统分为三层，最上面的一层是事件处理层，我们暂时称它为事件驱动，这是相对于上一章的设备驱动来讲的。
上一章介绍了设备驱动注册时要与匹配的handler连接，报告的事件也会分发给连接的handler，这一章介绍handler的相关操作。
2.1 重要的数据结构
首先介绍input_handle，这个结构体用来连接input_dev和input_handler。它的代码如程序清单 2.1所示。
程序清单 2.1 input_handle
/* include/linux/input.h */
struct input_handle {
void *private; ⑴
int open; ⑵
const char *name; ⑶
struct input_dev *dev; ⑷
struct input_handler *handler; ⑸
struct list_head d_node; ⑹
struct list_head h_node; ⑺
};
各个成员的含义如下：
⑴私有数据指针。
⑵记录本设备被打开的次数。
⑶创建此handle的handler所赋予的名字。
⑷指向附着的input_dev。
⑸指向创建此handle的handler。
⑹链表节点，用来加入附着的input_dev。
⑺链表节点，用来加入附着的input_handler。
在程序清单 1.11中，我们看到input_dev和input_handler匹配过程中用到了input_device_id。它的代码如程序清单 2.2所示。
程序清单 2.2 input_device_id
/* include/linux/mod_devicetable.h */
struct input_device_id {
kernel_ulong_t flags; ⑴
__u16 bustype; ⑵
__u16 vendor;
__u16 product;
__u16 version;
kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1]; ⑶
kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1];
kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1];
kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1];
kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1];
kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1];
kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1];
kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1];
kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1];
kernel_ulong_t driver_info; ⑷
};
各个成员的含义如下：
⑴定义需要匹配input_id的哪些域（使用方法参考程序清单 1.11）。
⑵对应input_id的四个数据域。
⑶存储支持事件的位图，与input_dev中的同名数据成员功能一致。
⑷指示结构体中是否含有驱动信息。
input_handler这个结构体是事件驱动的主体，每一种处理方式对应一个handler结构体。它的定义如程序清单 2.3所示。
程序清单 2.3 input_handler
/* include/linux/input.h */
struct input_handler {
void *private; ⑴
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); ⑵
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id); ⑶
void (*disconnect)(struct input_handle *handle); ⑷
void (*start)(struct input_handle *handle); ⑸
const struct file_operations *fops; ⑹
int minor; ⑺
const char *name; ⑻
const struct input_device_id *id_table; ⑼
const struct input_device_id *blacklist; ⑽
struct list_head h_list; ⑾
struct list_head node; ⑿
};
每个成员的具体解释如下：
⑴私有数据指针。
⑵事件处理函数指针。设备驱动报告的事件最终由这个函数来处理(参考程序清单 1.14)。
⑶连接handler和input_dev的函数指针。
⑷断开连接函数指针。
⑸为给定的handle启动handler函数指针。
⑹文件操作结构体。
⑺这个handler可以使用的32个次设备号的最小值。
⑻此handler的名字。
⑼可以处理的input_device_ids列表（用法参考程序清单 1.11）。
⑽需要被忽略的input_device_ids列表。
⑾用来连接handle的链表链表节点。每个与此handler相关的handle都放入此链表。
⑿用来放入全局handler链表的节点。
2.2 input_handler的注册
首先介绍存放注册的input_handler所用的数据结构。如所程序清单 2.4示。
程序清单 2.4 input core全局数据
/* driver/input/input.c */
static LIST_HEAD(input_dev_list); /* 设备链表头 */
static LIST_HEAD(input_handler_list); /* handler链表头 */
static DEFINE_MUTEX(input_mutex); /* 保护以上两个链表 */
static struct input_handler *input_table[8]; /*存放注册的input_handler的指针数组*/
程序清单 1.9中⑷处注册的input_dev结构体加入到上面的input_dev_list当中，下面将要介绍的注册input_handler，其实就是将input_hangler加入到input_handler_list当中。input_table中存放进行文件操作的handler，使用它们次设备号的最高三比特在input_table中寻址，因此每个handler最多支持32个设备节点。由上面的代码可以看出输入子系统最多允许8个进行文件操作的input_handler同时存在。
input_register_handler的代码如程序清单 2.5所示。
程序清单 2.5 input_register_handler
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;
INIT_LIST_HEAD(&handler->h_list); ⑴
if (handler->fops != NULL) { ⑵
if (input_table[handler->minor >> 5]) { ⑶
retval = -EBUSY;
goto out;
}
input_table[handler->minor>> 5] = handler; ⑷
}
list_add_tail(&handler->node,& input_handler_list); ⑸
list_for_each_entry(dev,& input_dev_list, node) ⑹
input_attach_handler(dev, handler); ⑺
input_wakeup_procfs_readers();
out:
mutex_unlock(&input_mutex);
return retval;
}
EXPORT_SYMBOL(input_register_handler);
程序含义如下：
⑴初始化handler中的链表节点，为加入input_handler_list做准备。
⑵如果此handler需要进行文件操作。
⑶如果相应的次设备号段被占用。
⑷将handler注册进input_table。
⑸将handler加入input_handler_list链表。
⑹遍历input_dev_list链表中的每一个input_dev结构体。
⑺将handler与每一个input_dev进行匹配。
input_attach_handler的代码如程序清单 1.10所示，这里不再赘述。
总结一下input_handler的注册过程：见自己加入input_handler_list和input_table，然后与input_dev_list中的input_dev比较并与匹配的建立连接。
参考1.4input_dev的注册这一节，我们发现input_dev和input_handler都是将自己加入各自的链表，然后再和对方链表中匹配的进行连接。
2.3 evdev_handler的实现
Linux输入子系统已经建立好了几个handler，用来处理几类常见的事件，如鼠标、键盘、摇杆等。其中最为基础的是evdev_handler，它是在driver/input/evdev.c中实现的。它能够接收任意类型的事件，任意id的设备都可以和它匹配连接，它对应的设备节点为/dev/eventX，次设备号的范围为64～95。
2.3.1 初始化和input_device_id
如程序清单 2.6所示。
程序清单 2.6 evdev_handler
/* driver/input/evdev.c */
static const struct input_device_id evdev_ids[] = {
{ .driver_info = 1 }, /* Matches all devices */
{ }, /* Terminating zero entry */
};
MODULE_DEVICE_TABLE(input, evdev_ids);
static struct input_handler evdev_handler = {
.event = evdev_event,
.connect = evdev_connect,
.disconnect = evdev_disconnect,
.fops =& evdev_fops,
.minor = EVDEV_MINOR_BASE,
.name = "evdev",
.id_table = evdev_ids,
};
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
static void __exit evdev_exit(void)
{
input_unregister_handler(&evdev_handler);
}
module_init(evdev_init);
module_exit(evdev_exit);
初始化的过程非常简单，就是将evdev_handler进行注册，注册的过程已经在2.2小节讲过了。
evdev_handler只初始化了id_table，根据程序清单 1.11第⑴步的分析，我们可以知道这样的input_device_id可以和任意的设备id相匹配。
由2.2小节我们知道次设备号的最高3比特用来对每个handler在input_table中寻址，那么每个handler拥有的次设备号数就是最低5比特对应的个数，共32个。所以evdev_handler最多能够支持32个输入设备与之建立连接。
2.3.2 建立连接
evdev_handler建立连接的函数原型如下：
static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
它的主要任务是申请一个input_handle结构体将handler和dev连接起来。同时建立连接的设备占用一个次设备号，这个次设备号是64～95中空闲的最小值，如果没有空闲的次设备号可用则连接失败。
2.3.3 打开设备节点
由于每个与evdev_handler建立连接的设备都占用了设备号，所以可以建立对应他们的设备节点。每次打开设备节点，都建立一个fifo环形消息缓冲区，能够存储64个消息。
2.3.4 用户空间读写消息
用户空间可以往evdev_handler连接的设备节点上写入消息，写入数据的格式如程序清单 1.2，写入的长度是数据的字节数。缓冲区写满之后从头开始写，直接覆盖之前的消息并且不会通知用户程序。由于写入消息是通过input core分发的，所以写入的无效消息根本不会进入消息缓冲区。
另外需要注意，虽然每个打开节点的线程都有一个消息缓冲区，写入的消息却会传给打开同一节点的每一个线程。同时也会传给同一个input_dev对应的其它设备节点。
读取消息则只从自己的消息缓冲区中读取。读取的消息格式也是如程序清单 1.2中的input_event一样。每个消息只能被读一次。
2.3.5 事件处理
evdev_handler从input core接收到一个事件之后会将它发送给独占设备的线程(如果有)或者所有打开设备的线程。事件分发之前会先打包成input_event的格式，并加上时间戳。
2.3.6 同步消息
每个input_dev都默认支持同步事件（EV_SYN）。但是evdev_handler并不使用用同步事件，只是将它作为一个一般的事件写入缓冲区。由于每次的写入都是及时的，所以也不需要同步。
2.3.7 evdev_handler适用范围
evdev_handler仅仅将消息打包成input_event的格式，此外不做任何处理。所有设备发送的事件报告都能为用户空间所见。需要直接使用设备原始事件的程序可以读取eventX，对于鼠标类或者更复杂的设备，evdev_handler并不合适。
