Input输入子系统分析

Input输入子系统分析

本文基于Linux kernel 2.6.22.6版本。

一、input输入子系统框架

输入子系统由输入子系统核心层（ Input Core ），驱动层和事件处理层（Event Handler）三部份组成。一个输入事件，如鼠标移动，键盘按键按下，joystick的移动等等通过 input driver -> Input core -> Event handler -> userspace 到达用户空间传给应用程序。

二、Input driver编写要点

1、分配、注册、注销input设备

struct input_dev *input_allocate_device(void)
int input_register_device(struct input_dev *dev)
void input_unregister_device(struct input_dev *dev)

2、设置input设备支持的事件类型、事件码、事件值的范围、input_id等信息

参见usb键盘驱动：usbkbd.c

usb_to_input_id(dev, &input_dev->id);//设置bustype、vendo、product等
input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);//支持的事件类型
input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL) | BIT(LED_COMPOSE) | BIT(LED_KANA);// EV_LED事件支持的事件码
for (i = 0; i < 255; i++)
set_bit(usb_kbd_keycode[i], input_dev->keybit); //EV_KEY事件支持的事件码

// 另一种设置方式
set_bit(EV_KEY, buttons_dev->evbit);
set_bit(EV_REP, buttons_dev->evbit);
set_bit(KEY_L, buttons_dev->keybit);
set_bit(KEY_S, buttons_dev->keybit);
set_bit(KEY_ENTER, buttons_dev->keybit);
set_bit(KEY_LEFTSHIFT, buttons_dev->keybit);

include/linux/input.h中定义了支持的类型（下面列出的是2.6.22内核的情况）

#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
#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

一个设备可以支持一个或多个事件类型。每个事件类型下面还需要设置具体的触发事件码。比如：EV_KEY事件，需要定义其支持哪些按键事件码。

3、如果需要，设置input设备的打开、关闭、写入数据时的处理方法

参见usb键盘驱动：usbkbd.c

input_dev->open = usb_kbd_open;
input_dev->close = usb_kbd_close;
input_dev->event = usb_kbd_event;

4、在发生输入事件时，向子系统报告事件

用于报告EV_KEY、EV_REL、EV_ABS等事件的函数有：

void input_report_key(struct input_dev *dev, unsigned int code, int value)
void input_report_rel(struct input_dev *dev, unsigned int code, int value)
void input_report_abs(struct input_dev *dev, unsigned int code, int value)

如果你觉得麻烦，你也可以只记住1个函数（因为上述函数都是通过它实现的）

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

三、Event Handler层分析

1、input_handler结构体

以evdev.c中的evdev_handler为例：

static struct input_handler evdev_handler = {
.event = evdev_event, //driver向系统报告input事件时调用，唤醒进程
.connect = evdev_connect, //和input_dev匹配后调用connect构建
.disconnect = evdev_disconnect,
.fops = &evdev_fops, //event设备文件的操作方法
.minor = EVDEV_MINOR_BASE, //次设备号基准值
.name = "evdev",
.id_table = evdev_ids, //匹配规则
};

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,
.llseek     = no_llseek,
};

2、注册过程

drivers/input/input.c中：

static int __init input_init(void)
{
int err;
err = class_register(&input_class); // 先建了class，后面调用handler的connect时再建设备文件
……
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
……
}

input_fops定义：

static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,//将操作重定位到handler的fops
.llseek = noop_llseek,
};

input_open_file函数在应用程序去open 设备/dev/input/*时调用，该函数会重定位到input_table数组中handler对应的open函数，比如evdev_fops的evdev_open

static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler;
...
//数组input_table由input_register_handler构造
handler = input_table[iminor(inode) >> 5];
...
new_fops = fops_get(handler->fops);
...
old_fops = file->f_op;
file->f_op = new_fops;
...
// 调用input_handler中fops的open函数，比如evdev_handler的evdev_fops的evdev_open
err = new_fops->open(inode, file);
...
}

input_dev注册流程（以buttons程序为例）：

static struct input_dev *buttons_dev;
static int buttons_init(void)
{
// 1. 分配 input_dev
buttons_dev = input_allocate_device();
// 2. 设置能产生哪一类事件中的哪些事件
set_bit(EV_KEY, buttons_dev->evbit);
set_bit(EV_REP, buttons_dev->evbit);
set_bit(KEY_L, buttons_dev->keybit);
set_bit(KEY_S, buttons_dev->keybit);
set_bit(KEY_ENTER, buttons_dev->keybit);
set_bit(KEY_LEFTSHIFT, buttons_dev->keybit);
// 3. 注册input_dev
input_register_device(buttons_dev);
...
request_irq(pins_desc[i].irq, buttons_irq, IRQT_BOTHEDGE, pins_desc[i].name, &pins_desc[i]);
}

int input_register_device(struct input_dev *dev)
{
struct input_handler *handler;
......
// 将要注册的input_dev添加到input_dev_list链表中
list_add_tail(&dev->node, &input_dev_list);
// 从input_handler_list链表中找出每一项handler跟本input_dev匹配
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);
......
}

handler注册流程(以evdev.c为例)：

static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}

int input_register_handler(struct input_handler *handler)
{
......
list_add_tail(&handler->node, &input_handler_list);
// 从input_dev_list链表中找出每一项input_dev跟本handler匹配
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);
......
}

看见不论是先注册input_dev，还是先注册input_handler，最终都会调用到input_attach_handler函数。

input_attach_handler会先去做匹配操作，如果匹配上就调用handler的connect函数。

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
......
// 看handler->id_table跟input_dev是否匹配，如果匹配就调用handler的connect函数
id = input_match_device(handler->id_table, dev);
......
error = handler->connect(handler, dev, id);
......
}

比如：evdev_handler 的evdev_connect

1. 分配一个input_handle结构（注意是handle而不是handler）

2. 设置input_handle里面的dev，指向input_match_device匹配后的input_dev

3. 设置input_handle里面的handler，指向input_match_device匹配后的input_handler

4. 在input_class下创建设备节点event+minor

5. 调用input_register_handle，将该handle放入到input_dev里面的h_list链表里还有input_handler里面的h_list链表里

evdev 结构包含了一个input_handle

struct evdev {
int exist;
int open;
int minor;
char name[16];
struct input_handle handle; // 包含了一个input_handle
wait_queue_head_t wait;
struct evdev_client *grab;
struct list_head client_list;
};

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,const struct input_device_id *id)
{
......
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);//为每个匹配evdev_handler的设备创建一个evdev。
......
evdev->exist = 1;
evdev->minor = minor;
evdev->handle.dev = dev; // 指向input_dev
evdev->handle.name = evdev->name;
evdev->handle.handler = handler; // 指向input_handler
evdev->handle.private = evdev;
sprintf(evdev->name, "event%d", minor);
//记录evdev的位置，字符设备/dev/input/evnetx访问时根据次设备号及EVDEV_MINOR_BASE最终在evdev_open中找到对应的evdev
evdev_table[minor] = evdev;
devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
//创建了event字符设备节点
cdev = class_device_create(&input_class, &dev->cdev, devt,dev->cdev.dev, evdev->name);
……
error = input_register_handle(&evdev->handle);
}

input_register_handle：将该handle放入到input_dev里面的h_list链表里还有input_handler里面的h_list链表里

int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;

list_add_tail(&handle->d_node, &handle->dev->h_list);
list_add_tail(&handle->h_node, &handler->h_list);

if (handler->start)
handler->start(handle);

return 0;
}

`

3、Event 的其它操作

由于在open阶段已经把设备文件的操作方法重定位了到了具体的input_handler，所以其它接口操作（read、write、ioctl等），由各个input_handler的fops方法决定。如evdev.c中的：evdev_fops。

// 当应用程序去read设备/dev/input/event1时调用
static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
// 环形缓冲区没有数据并且是非阻塞方式打开时，立刻返回
if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
return -EAGAIN;
......
// 否则休眠
retval = wait_event_interruptible(evdev->wait,
client->head != client->tail || !evdev->exist);
}

休眠后谁来唤醒？

static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
......
wake_up_interruptible(&evdev->wait);
}

谁调用evdev_event唤醒evdev->wait？

是硬件相关代码，input_dev层调用，比如设备的中断服务程序里，确定事件，然后调用相应的input_handler的event函数

input_event(buttons_dev, EV_KEY, pindesc->key_val, 1);

input_sync(buttons_dev);

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
// 找到input_dev->h_list链表里的每一项，注册时指向handle，调用handle里面handler指向的event函数，即evdev_event
list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle, type, code, value);
}