输入子系统
Linux的输入子系统不仅支持鼠标、键盘等常规的输入设备，而且还支持蜂鸣器、触摸屏等设备
输入子系统又叫input子系统。其构建非常灵活，只需要调用一些简单的函数，就可以将一个输入设备的功能呈现给应用程序
#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 //蜂鸣器，输入声音
#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)
input_handler是输入设备的事件处理接口，为处理事件提供一个统一的函数模板，程序员应该根据具体的需要实现其中的一些函数，并将其注册到输入子系统中。该结构体的定义如下：
- 01 struct input_handler {
- 02 void *private;
- 03 void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
- 04 int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
- 05 void (*disconnect)(struct input_handle *handle);
- 06 void (*start)(struct input_handle *handle);
- 07 const struct file_operations *fops;
- 08 int minor;
- 09 const char *name;
- 10 const struct input_device_id *id_table;
- 11 const struct input_device_id *blacklist;
- 12 struct list_head h_list;
- 13 struct list_head node;
- 14 };
对该结构体简要分析如下。
第02行，定义了一个private指针，表示驱动特定的数据。这里的驱动指的就是handler处理器。
第03行，定义了一个event()处理函数，这个函数将被输入子系统调用去处理发送给设备的事件。例如将发送一个事件命令LED灯点亮，实际控制硬件的点亮操作就可以放在event()函数中实现。
第04行，定义了一个connect()函数，该函数用来连接handler和input_dev。在input_attach_handler()函数的第10行，就是回调的这个自定义函数。
第05行，定义了一个disconnect()函数，这个函数用来断开handler和input_dev之间的联系。
第07行，表示handler实现的文件操作集，这里不是很重要。
第08行，表示设备的次设备号。
第09行，定义了一个name，表示handler的名字，显示在/proc/bus/input/handlers目录中。
第10行，定义了一个id_table表，表示驱动能够处理的表。
第11行，指向一个input_device_id表，这个表包含handler应该忽略的设备。
第12行，定义了一个链表h_list，表示与这个input_handler相联系的下一个handler。
第13行，定义了一个链表node，将其连接到全局的input_handler_list链表中，所有的input_handler都连接在其上。
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,
unsigned int scancode, unsigned int keycode);//修改键值的函数，可选
int (*getkeycode)(struct input_dev *dev,
unsigned int scancode, unsigned int *keycode);//获取扫描码的键值，可选
struct ff_device *ff;
unsigned int repeat_key;//最近一次按键值，用于连击
struct timer_list timer;//自动连击计时器
int sync;//最后一次同步后没有新的事件置1
int abs[ABS_CNT];//当前各个坐标的值
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)];
/*tp驱动代码里一般使用input_set_abs_params函数设置
函数参数从右往左依次代表输入设备指针、坐标轴、最小值、最大值、分辨率、基准值。
最后两个参数也可以填为0，代表设备非常精确并且总能精确的回到中心位置。*/
int absmax[ABS_CNT];//记录各个坐标的最大值
int absmin[ABS_CNT];//记录各个坐标的最小值
int absfuzz[ABS_CNT];//记录各个坐标的分辨率
int absflat[ABS_CNT];//记录各个坐标的基准值
int absres[ABS_CNT];
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;
bool going_away;
struct device dev;
struct list_head h_list;//handle链表
struct list_head node;//input_dev链表
};
struct input_event是事件传送的载体，输入子系统的事件都是包装成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。
/* include/linux/input.h */
struct input_id {
__u16 bustype;//总线类型
__u16 vendor;//生产商编号
__u16 product;//产品编号
__u16 version;//版本号
};
input_handler这个结构体是事件驱动的主体，每一种处理方式对应一个handler结构体。注册input_handler，其实就是将
input_hangler加入到input_handler_list当中。使用input_register_handler注册。
/* include/linux/input.h */
struct input_handler {
//私有数据指针
void *private;
//事件处理函数指针。设备驱动报告的事件最终由这个函数来处理
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
bool (*match)(struct input_handler *handler, struct input_dev *dev);
//连接handler和input_dev的函数指针
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
//断开连接函数指针
void (*disconnect)(struct input_handle *handle);
//为给定的handle启动handler函数指针
void (*start)(struct input_handle *handle);
//文件操作结构体
const struct file_operations *fops;
//这个handler可以使用的32个次设备号的最小值
int minor;
//此handler的名字
const char *name;
//可以处理的input_device_ids列表
const struct input_device_id *id_table;
//需要被忽略的input_device_ids列表
const struct input_device_id *blacklist;
//用来连接handle的链表链表节点。每个与此handler相关的handle都放入此链表
struct list_head h_list;
//用来放入全局handler链表的节点
struct list_head node;
};
input_handle这个结构体用来连接input_dev和input_handler。
/* include/linux/input.h */
struct input_handle {
void *private;//私有数据指针
int open;//记录本设备被打开的次数
const char *name;//创建此handle的handler所赋予的名字
struct input_dev *dev;//指向附着的input_dev
struct input_handler *handler;//指向创建此handle的handler
struct list_head d_node;//链表节点，用来加入附着的input_dev
struct list_head h_node;//链表节点，用来加入附着的input_handler
};
input_dev和input_handler匹配过程中用到了input_device_id
/* include/linux/mod_devicetable.h */
struct input_device_id {
kernel_ulong_t flags;//定义需要匹配input_id的哪些域
__u16 bustype;//对应input_id的四个数据域
__u16 vendor;
__u16 product;
__u16 version;
//存储支持事件的位图，与input_dev中的同名数据成员功能一致
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;//指示结构体中是否含有驱动信息
};
先看一个简单的输入设备驱动程序的例子：
#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>
static struct input_dev *button_dev; //输入设备结构体
static irqreturn_t button_interrupt(int irq, void *dummy, struct pt_regs *fp) //中断处理函数
{
input_report_key(&button_dev, BTN_0, inb(BUTTON_PORT) & 1); //向输入子系统报告产生的按键事件
input_sync(&button_dev); //通知接收者，一个报告发送完毕
return IRQ_HANDLED;
}
static int __init button_init(void)
{
int error;
if (request_irq(BUTTON_IRQ, button_interrupt, 0, "button", NULL)) { //申请中断处理函数
printk(KERN_ERR "button.c: Can't allocate irq %d\n", button_irq); //申请失败
return -EBUSY;
}
button_dev = input_allocate_device(); //分配一个设备结构体
if(!button_dev) //
{
printk(KERN_ERR"button.c:Not enougu memory\n");
error = -ENOMEM;
goto err_free_irq;
}
button_dev.evbit[0] = BIT(EV_KEY); //设置按键信息
button_dev.keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
error = input_register_device(&button_dev); //注册一个输入设备
if(error)
{
printk("KERN_ERR"button.c: Failed to register device\n");
goto err_free_dev;
}
return 0;
err_free_dev: //下面是错误处理
input_free_device(button_dev);
err_free_irq:
free_irq(BUTTON_IRQ,button_interrupt);
return error;
}
static void __exit button_exit(void) //卸载函数
{
input_unregister_device(&button_dev); //注销按键设备
free_irq(BUTTON_IRQ, button_interrupt); //释放按键占用的中断线
}
module_init(button_init);
module_exit(button_exit);
input_allocate_device()函数在内存中为输入设备结构体分配一个空间，并对其主要成员进行了初始化。
struct input_dev *input_allocate_device(void)
{
struct input_dev *dev;
dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); //分配一个input_dev结构体，并且初始化为0
if (dev) {
dev->dev.type = &input_dev_type; //初始化设备的类型
dev->dev.class = &input_class; //设置为输入设备类
device_initialize(&dev->dev); //初始化device结构
mutex_init(&dev->mutex); //初始化互斥锁
spin_lock_init(&dev->event_lock); //初始化事件自旋锁
INIT_LIST_HEAD(&dev->h_list); //初始化链表
INIT_LIST_HEAD(&dev->node); //初始化链表
__module_get(THIS_MODULE); //增加模块引用计数
}
return dev;
}
该函数返回一个指向input_dev类型的指针，该结构体是一个输入设备结构体，包含输入设备的一些相关信息，如设备支持的按键码、设备的名字、设备支持的事件等
input_register_device()函数注册输入子系统设备结构体 调用失败用input_allocate_deivce()函数释放input_allocate_device()分配的空间。卸载用input_unregister_device()
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); //设置input_dev所支持的事件，这里表示支持所有事件，一个设备可以支持一种或多种时间类型
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
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;
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1); //设置input_dev中的device的名字，出现在sysfs系统中
error =
device_add(&dev->dev);
//将input_dev包含的device结构注册到Linux设备模型中，并可以以sysfs文件系统表现出来
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;
}
input_attach_handler（）函数用于匹配input_dev和handler，只有匹配成功，才能进行下一步的关联操作
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;
}
input_match_device()函数用来与input_dev和handler进行匹配。handler的id_table表中定义了其支持的input_dev设备：
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;
}
#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;
只有当input_device和input_handler的ID成员在evbit,keybit,...,swbit项相同才会匹配成功。而且匹配顺序是从evbit，keybit，到swbit。只要有一项不同就会循环到ID下一项比较
input_report_key（）函数向输入子系统报告发生的事件
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_KEY, code, !!value);
}
第二个参数是产生的事件，可以去BTN_0,BTN_1,BTN_LEFT,BTN_RIGHT等值
input_event（） 向输入子系统报告输入设备产生的事件：
void input_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value) //type是事件的类型，EV_KEY,EV_REL等等
{
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);
}
}
is_event_supported函数检查输入设备是否支持该事件：
static inline int is_event_supported(unsigned int code,
unsigned long *bm, unsigned int max)
{
return code <= max && test_bit(code, bm);
}
input_handle_event()函数向输入子系统传达事件信息：
参数1，输入设备 参数2，事件类型 参数3，键码 参数4，键值
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_SYN:
switch (code) {
case SYN_CONFIG:
disposition = INPUT_PASS_TO_ALL;
break;
case SYN_REPORT:
if (!dev->sync) {
dev->sync = 1;
disposition = INPUT_PASS_TO_HANDLERS;
}
break;
}
break;
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; //事件需要handler来处理，交给handler处理
}
break;
case EV_SW:
if (is_event_supported(code, dev->swbit, SW_MAX) &&
!!test_bit(code, dev->sw) != value) {
__change_bit(code, dev->sw);
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;
case EV_MSC:
if (is_event_supported(code, dev->mscbit, MSC_MAX))
disposition = INPUT_PASS_TO_ALL;
break;
case EV_LED:
if (is_event_supported(code, dev->ledbit, LED_MAX) &&
!!test_bit(code, dev->led) != value) {
__change_bit(code, dev->led);
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_SND:
if (is_event_supported(code, dev->sndbit, SND_MAX)) {
if (!!test_bit(code, dev->snd) != !!value)
__change_bit(code, dev->snd);
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_REP:
if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
dev->rep[code] = value;
disposition = INPUT_PASS_TO_ALL;
}
break;
case EV_FF:
if (value >= 0)
disposition = INPUT_PASS_TO_ALL;
break;
case EV_PWR:
disposition = INPUT_PASS_TO_ALL;
break;
}
if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) //处理EV_SYN事件
dev->sync = 0;
if ((disposition & INPUT_PASS_TO_DEVICE) &&
dev->event)
//交给input_dev处理，并且处理事件存在event（）用来想输入子系统报告一个将要发送给设备的事件
dev->event(dev, type, code, value);
if (disposition & INPUT_PASS_TO_HANDLERS) //交给handler处理，调用input_pass_event()处理
input_pass_event(dev, type, code, value);
}
input_pass_event（）函数将事件传递到合适的函数，然后对其进行处理：
static void input_pass_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
struct input_handle *handle; 分配一个handle结构的指针
rcu_read_lock();
handle = rcu_dereference(dev->grab); 得到dev->grab的指针，grab是强制为input device的handler，这时要调用handler的event函数
if (handle)
handle->handler->event(handle, type, code, value);
else 如果没有为input device强制指定handler，即为grap赋值，就遍历input device->h_list上的handle成员，如果该handle被打开，表示该设备已经被一个用户进程使用
list_for_each_entry_rcu(handle, &dev->h_list,
d_node)
就会调用与输入设备对应的handler的event（）函数。注意，只有在handle被打开的情况下才会收到事件，这
if
(handle->open)
就是说，只有设备被用户程序使用时，才有必要向用户导出信息。
handle->handler->event(handle,
type, code, value);
rcu_read_unlock();
}
事件处理过程如下：
input_handler是输入子系统的主要数据结构，一般将其称为handler处理器，表示对输入事件的具体处理。input_handler为输入设备的功能实现了一个接口，输入事件最终传递到handler处理器，handler处理器根据一定的规则，然后对事件进行处理。
struct input_dev 物理输入设备的基本数据结构，包含设备相关的一些信息
struct input_handler 事件处理结构体，定义怎么处理事件的逻辑
struct input_handle 用来创建input_dev和input_handler之间的关系的结构体
struct input_handler {
void *private; 表示驱动特定的数据。这里的驱动指的就是handler处理器
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);
连接handler和input_dev在input_attach_handler中调用
void (*disconnect)(struct input_handle *handle); 断开handler和input_dev之间的联系
void (*start)(struct input_handle *handle);
const struct file_operations *fops; handler实现的文件操作集
int minor; 次设备号
const char *name; 表示handler的名字，显示在/proc/bus/input/handlers/目录中
const struct input_device_id *id_table; 表示驱动能够处理的表
const struct input_device_id *blacklist; 应该忽略的设备
struct list_head h_list; 与这个handler相联系的下一个handler
struct list_head node; 将其连接到全局的input_handler_list链表中，所有的input_handler都连接在其上
};
input_register_handler()函数注册一个新的input handler处理器。这个handler将为输入设备使用，一个handler可以添加到多个支持它的设备中，也就是一个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]) { 次设备号右移5位作为索引值插入到input_table[]中
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;
}
struct input_handle {
void *private; handle特定的数据
int open; 表示handle是否正在被使用，当使用时，会将事件分发给设备处理
const char *name; handle的名字
struct input_dev *dev; 表示该handle依附的input_dev设备
struct input_handler *handler; 与设备相关的handler处理器
struct list_head d_node; 将handle放到设备相关的链表中，也就是放到input_dev->h_list表示的链表中
struct list_head h_node; 将handle放到input_handler相关的链表中，也就是handler->h_list表示的链表中
};
input_handle是用来连接input_dev和input_handler的一个中间结构体。事件通过input_handle从input_dev发送到input_handler，或者从input_handler发送到input_dev进行处理。在使用input_handle之前，需要对其进行注册，注册函数input_register_handle():
该函数接受一个注册前初始化的input_handle类型指针来注册一个新的handle到输入子系统
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error;
/*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error;
list_add_tail_rcu(&handle->d_node, &dev->h_list); 将handle加入到dev->h_list链表中
mutex_unlock(&dev->mutex);
synchronize_rcu();
/*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
list_add_tail(&handle->h_node, &handler->h_list); 将handle加入到handler->h_list链表中
if (handler->start)
handler->start(handle);
return 0;
}
input_dev、input_handler和input_handle的关系：
input子系统：
在Linux中，输入子系统作为一个模板存在，向上，为用户提供接口函数，向下，为驱动层程序提供统一的接口函数。这样，就能够使输入设备的事件通过输入子系统发送给用户层应用程序，用户程序也可以通过输入子系统通知驱动程序完成某项功能
初始化函数input_init():
先看几个结构的定义：
struct class input_class = { 结构体的定义
.name = "input",
};
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
static int __init input_init(void)
{
int err;
err = class_register(&input_class); 注册input类，所有input
device都属于这个类，在sysfs中表现就是，所有input device所代表的目录都位于/dev/class/input下面：
if (err) {
printk(KERN_ERR "input: unable to register input_dev class\n");
return err;
}
err = input_proc_init(); 在proc下面建立相关的交互文件
if (err)
goto fail1;
err = register_chrdev(INPUT_MAJOR, "input",
&input_fops);
注册主设备号为INPUT_MAJOR(13)次设备号为0～255的字符设备。它的操作指针为input_fops，所有主设备号为13的字符设备的操作，都会转入到input_fops中
if (err) {
printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
goto fail2;
}
return 0;
fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
input_open_file()函数，该函数将控制input_handler中定义的fops文件指针的open（）函数。该函数在input_handler中实现，这样就使不同的handler处理器对应了不同的文件打开方法：
static struct input_handler *input_table[8];
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler;
const struct file_operations *old_fops, *new_fops = NULL;
int err;
lock_kernel();
/* No load-on-demand here? */
handler = input_table[iminor(inode) >> 5]; 取出handler处理器，原理是前面赋值的时候，也可看出一个handler代表32个设备节点
if (!handler || !(new_fops = fops_get(handler->fops))) {
err = -ENODEV;
goto out;
}
/*
* That's _really_ odd. Usually NULL ->open means "nothing special",
* not "no device". Oh, well...
*/
if (!new_fops->open) { 判断new_fops->open（）函数是否定义，如果没有定义，则表示设备不存在
fops_put(new_fops); 减少引用计数
err = -ENODEV;
goto out;
}
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file); 使用新的open（）函数，重新打开设备
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
out:
unlock_kernel();
return err;
}
evdev输入事件驱动：
evdev输入事件驱动，为输入子系统提供了一个默认的事件处理方法。其接收来自底层驱动的大多数事件，并使用相应的逻辑对其进行处理。evdev输入事件驱动从底层接收事件信息，将其反映到sys文件系统中，用户程序通过对sys文件系统的操作，就能够达到处理事件的能力
evdev以模块的方式被组织在内核中
初始化函数evdev_init():
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler); 注册evdev_handler事件处理器
}
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,
};
#define EVDEV_MINOR_BASE 64
因为handler可以处理32个设备，所以evdev_handler所能处理的设备文件范围为（13，64）～（13，64+32），其中13是所有输入设备的主设备号
static const struct input_device_id evdev_ids[] = {
{ .driver_info = 1 }, /* Matches all devices */
{ }, /* Terminating zero entry */
};
evdev_ids没有定义flags，也没有定义匹配属性值。这个evdev_ids的意思就是：evdev_handler可以匹配所有input_dev设备，也就是所有input_dev发出的事件，都可以由evdev_handler来处理。匹配成功后会调用handler->connect()函数
evdev_connect()函数主要用来连接input_dev和input_handler，这样事件的流通链才能建立。流通链建立后，事件才知道被谁处理，或者处理后向谁返回结果：
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
struct evdev *evdev;
int minor;
int error;
for (minor = 0; minor < EVDEV_MINORS; minor++) 宏为32，表示32个设备文件。找到evdev_table为空的那一项，这时，for结束时minor就是数组第一项为空的那一项
if (!evdev_table[minor])
break;
if (minor == EVDEV_MINORS) { 没有空闲的表项
printk(KERN_ERR "evdev: no more free evdev devices\n");
return -ENFILE;
}
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 分配一个struct evdev空间
if (!evdev)
return -ENOMEM;
INIT_LIST_HEAD(&evdev->client_list); 初始化evdev
spin_lock_init(&evdev->client_lock);
mutex_init(&evdev->mutex);
init_waitqueue_head(&evdev->wait);
snprintf(evdev->name, sizeof(evdev->name), "event%d", minor); event1，event2命名
evdev->exist = 1;
evdev->minor = minor;
evdev->handle.dev = input_get_device(dev);
evdev->handle.name = evdev->name;
evdev->handle.handler = handler;
evdev->handle.private = evdev;
dev_set_name(&evdev->dev, evdev->name);
evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
evdev->dev.class = &input_class;
evdev->dev.parent = &dev->dev;
evdev->dev.release = evdev_free;
device_initialize(&evdev->dev);
error = input_register_handle(&evdev->handle); 注册一个input_handle结构体
if (error)
goto err_free_evdev;
error = evdev_install_chrdev(evdev); 将evdev_table的minor项指向evdev
if (error)
goto err_unregister_handle;
error = device_add(&evdev->dev); 将evdev->device注册到sysfs文件系统中
if (error)
goto err_cleanup_evdev;
return 0;
err_cleanup_evdev:
evdev_cleanup(evdev);
err_unregister_handle:
input_unregister_handle(&evdev->handle);
err_free_evdev:
put_device(&evdev->dev);
return error;
}
用户程序通过输入子系统创建的设备节点函数open（），read（）和write（），打开和读写输入设备
对主设备号为INPUT_MAJOR的设备节点进行操作，会将操作集转换成handler的操作集：
static const struct file_operations evdev_fops = {
.owner = THIS_MODULE,
.read = evdev_read,
.write = evdev_write,
.poll = evdev_poll,
.open = evdev_open,
.release = evdev_release,
.unlocked_ioctl = evdev_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = evdev_ioctl_compat,
#endif
.fasync = evdev_fasync,
.flush = evdev_flush
};
evdev_open()函数：
用户可以这样调用open("/dev/input/event1",O_RDONLY)函数打开设备节点时，会调用evdev_fops中的evdev_open()函数：
static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev *evdev;
struct evdev_client *client;
int i = iminor(inode) - EVDEV_MINOR_BASE; 得到在evdev_table[]中的序号
int error;
if (i >= EVDEV_MINORS)
return -ENODEV;
error = mutex_lock_interruptible(&evdev_table_mutex);
if (error)
return error;
evdev = evdev_table[i];
if (evdev)
get_device(&evdev->dev);
mutex_unlock(&evdev_table_mutex);
if (!evdev)
return -ENODEV;
client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL); 分配并初始化一个client结构体，并将它和evdev关联起来
if (!client) {
error = -ENOMEM;
goto err_put_evdev;
}
spin_lock_init(&client->buffer_lock);
client->evdev = evdev;
evdev_attach_client(evdev, client); 将client挂到evdev->client_list上
error = evdev_open_device(evdev); 打开输入设备
if (error)
goto err_free_client;
file->private_data = client;
return 0;
err_free_client:
evdev_detach_client(evdev, client);
kfree(client);
err_put_evdev:
put_device(&evdev->dev);
return error;
}
evdev_open_device()函数用来打开相应的输入设备，使设备准备好接收或者发送数据：
static int evdev_open_device(struct evdev *evdev)
{
int retval;
retval = mutex_lock_interruptible(&evdev->mutex);
if (retval)
return retval;
if (!evdev->exist)
retval = -ENODEV;
else if (!evdev->open++) { 如果是第一次打开，就会调用input_open_device()打开evdev对应的handle
retval = input_open_device(&evdev->handle);
if (retval)
evdev->open--;
}
mutex_unlock(&evdev->mutex);
return retval;
}
int input_open_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
int retval;
retval = mutex_lock_interruptible(&dev->mutex);
if (retval)
return retval;
if (dev->going_away) {
retval = -ENODEV;
goto out;
}
handle->open++;
if (!dev->users++ && dev->open)
retval = dev->open(dev);
if (retval) {
dev->users--;
if (!--handle->open) {
/*
* Make sure we are not delivering any more events
* through this handle
*/
synchronize_rcu();
}
}
out:
mutex_unlock(&dev->mutex);
return retval;
}
