深层次分析linux2.6input子系统_表格里代码code-CSDN博客

本文链接：https://blog.csdn.net/wu7585535/article/details/7906838

在linux下，按键、触摸屏、鼠标等都可以利用input接口函数来实现设备驱动。

从上图可知：

输入子系统由三部分构成：

1 驱动

2 输入子系统

3 处理函数

其中2,3都是内核已经完成，我们要完成的就是1驱动

设备用input_dev结构体描述，使用input子系统实现输入设备驱动的时候，驱动的核心工作是向系统报告按键、触摸屏、键盘、鼠标等输入事件（event，通过input_event结构体描述），不再需要关心文件操作接口，因为input子系统已经完成了文件操作接口。驱动报告的事件经过InputCore和Eventhandler最终到达用户空间。

Input_dev 结构中比较重要的域有：

Name:名字

Evbit:设备所支持的事件类型

Keybit：按键类型

注册输入设备的函数为：

int input_register_device(struct input_dev *dev)

注销输入设备的函数为：

void input_unregister_device(struct input_dev *dev)

设备所支持的事件类型有：

EV_RST Reset EV_KEY 按键

EV_REL 相对坐标EV_ABS绝对坐标

EV_MSC 其它EV_LED LED

EV_SND 声音EV_REP Repeat

EV_FF 力反馈

并使用set_bit(EV_KEY, button_dev.evbit)告知结构体支持哪种设备类型

用于报告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)

code：

事件的代码。如果事件的类型是EV_KEY，该代码code为设备键盘代码。代码值0~127为键盘上的按键代码，0x110~0x116为鼠标上按键代码，其中0x110(BTN_LEFT)为鼠标左键，0x111(BTN_RIGHT)为鼠标右键,0x112(BTN_ MIDDLE)为鼠标中键。其它代码含义请参看include/linux/input.h文件

value

事件的值。如果事件的类型是EV_KEY,当按键按下时值为1,松开时值为0。

input_sync()用于事件同步，它告知事件的接收者：驱动已经发出了一个完整的报告。

在中断中，使用input_report_key等函数想用户空间报告，在应用程序中直接读取状态。

输入子系统的设备文件名默认为event0 – event31主设备号默认为13，类似于misc混杂设备。

下面基于mini2440的input输入按键驱动代码：

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/fs.h>

#include <linux/init.h>

#include <linux/delay.h>

#include <linux/poll.h>

#include <linux/irq.h>

#include <asm/irq.h>

#include <linux/interrupt.h>

#include <asm/uaccess.h>

#include <mach/regs-gpio.h>

#include <mach/hardware.h>

#include <linux/platform_device.h>

#include <linux/cdev.h>

#include <linux/miscdevice.h>

#include <linux/input.h>

struct input_dev *button_dev;

struct button_irq_desc {

int irq;

int pin;

int pin_setting;

int number;

char *name;

};

static struct button_irq_desc button_irqs [] = {

{IRQ_EINT8 , S3C2410_GPG0 , S3C2410_GPG0_EINT8 , 0, "KEY0"},

{IRQ_EINT11, S3C2410_GPG3 , S3C2410_GPG3_EINT11 , 1, "KEY1"},

{IRQ_EINT13, S3C2410_GPG5 , S3C2410_GPG5_EINT13 , 2, "KEY2"},

{IRQ_EINT14, S3C2410_GPG6 , S3C2410_GPG6_EINT14 , 3, "KEY3"},

{IRQ_EINT15, S3C2410_GPG7 , S3C2410_GPG7_EINT15 , 4, "KEY4"},

{IRQ_EINT19, S3C2410_GPG11, S3C2410_GPG11_EINT19, 5, "KEY5"},

};

static int key_values = 0;

static irqreturn_t buttons_interrupt(int irq, void *dev_id)

{

struct button_irq_desc *button_irqs = (struct button_irq_desc *)dev_id;

int down;

udelay(0);

down = !s3c2410_gpio_getpin(button_irqs->pin); //down: 1(按下)，0（弹起）

if (!down) {

/*报告事件*/

key_values = button_irqs->number;

//printk("====>rising key_values=%d\n",key_values);

if(key_values==0)

input_report_key(button_dev, KEY_1, 0);

if(key_values==1)

input_report_key(button_dev, KEY_2, 0);

if(key_values==2)

input_report_key(button_dev, KEY_3, 0);

if(key_values==3)

input_report_key(button_dev, KEY_4, 0);

if(key_values==4)

input_report_key(button_dev, KEY_5, 0);

if(key_values==5)

input_report_key(button_dev, KEY_6, 0);

input_sync(button_dev);

}

else {

key_values = button_irqs->number;

//printk("====>falling key_values=%d\n",key_values);

if(key_values==0)

input_report_key(button_dev, KEY_1, 1);

if(key_values==1)

input_report_key(button_dev, KEY_2, 1);

if(key_values==2)

input_report_key(button_dev, KEY_3, 1);

if(key_values==3)

input_report_key(button_dev, KEY_4, 1);

if(key_values==4)

input_report_key(button_dev, KEY_5, 1);

if(key_values==5)

input_report_key(button_dev, KEY_6, 1);

input_sync(button_dev);

}

return IRQ_RETVAL(IRQ_HANDLED);

}

static int s3c24xx_request_irq(void)

{

int i;

int err = 0;

for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {

if (button_irqs[i].irq < 0) {

continue;

}

/* IRQ_TYPE_EDGE_FALLING,IRQ_TYPE_EDGE_RISING,IRQ_TYPE_EDGE_BOTH */

err = request_irq(button_irqs[i].irq, buttons_interrupt, IRQ_TYPE_EDGE_BOTH,

button_irqs[i].name, (void *)&button_irqs[i]);

if (err)

break;

}

if (err) {

i--;

for (; i >= 0; i--) {

if (button_irqs[i].irq < 0) {

continue;

}

disable_irq(button_irqs[i].irq);

free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);

}

return -EBUSY;

}

return 0;

}

static int __init dev_init(void)

{

/*request irq*/

s3c24xx_request_irq();

/* Initialise input stuff */

button_dev = input_allocate_device();

if (!button_dev) {

printk(KERN_ERR "Unable to allocate the input device !!\n");

return -ENOMEM;

}

button_dev->name = "s3c2440_button";

button_dev->id.bustype = BUS_RS232;

button_dev->id.vendor = 0xDEAD;

button_dev->id.product = 0xBEEF;

button_dev->id.version = 0x0100;

button_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT(EV_SYN);

//set_bit(EV_KEY, button_dev->evbit)//支持EV_KEY事件

set_bit(KEY_1, button_dev->keybit);

set_bit(KEY_2, button_dev->keybit);

set_bit(KEY_3, button_dev->keybit);

set_bit(KEY_4, button_dev->keybit);

set_bit(KEY_5, button_dev->keybit);

set_bit(KEY_6, button_dev->keybit);

//printk("KEY_RESERVED=%d ,KEY_1=%d",KEY_RESERVED,KEY_1);

input_register_device(button_dev); //注册input设备

printk ("initialized\n");

return 0;

}

static void __exit dev_exit(void)

{

int i;

for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {

if (button_irqs[i].irq < 0) {

continue;

}

free_irq(button_irqs[i].irq, (void *)&button_irqs[i]);

}

input_unregister_device(button_dev);

}

module_init(dev_init);

module_exit(dev_exit);

MODULE_LICENSE("GPL");

MODULE_AUTHOR("David Xie");

应用程序：

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/select.h>

#include <sys/time.h>

#include <errno.h>

#include <linux/input.h>

int main(void)

{

int buttons_fd;

int key_value,i=0,count;

struct input_event ev_key;

buttons_fd = open("/dev/event0", O_RDWR);

if (buttons_fd < 0) {

perror("open device buttons");

exit(1);

}

for (;;) {

count = read(buttons_fd,&ev_key,sizeof(struct input_event));

// printf("count=%d\n",count);

for(i=0; i<(int)count/sizeof(struct input_event); i++)

if(EV_KEY==ev_key.type)

printf("type:%d,code:%d,value:%d\n", ev_key.type,ev_key.code-1,ev_key.value);

if(EV_SYN==ev_key.type)

printf("syn event\n\n");

}

close(buttons_fd);

return 0;

}

加载内核模块：

多了event0设备文件

运行应用程序：

、

下面我们分析input子系统源码：

在分析源代码之前，我们要先了解几个主要的结构：

Input_dev是代表一个输入设备。

struct input_dev {
const char *name;
const char *phys;
const char *uniq;
struct input_id id; /*ID域*/

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)];

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;

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)];
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
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 absres[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; /*用于连接input_handler和input_dev的结构*/

spinlock_t event_lock;
struct mutex mutex;

unsigned int users;
bool going_away;

struct device dev;

struct list_head h_list; /*链表连接input_handle*/
struct list_head node;/*链表连接下一个input_dev*/
};

input_handler表示一个Input设备对应的handler

struct input_handler {

void *private;
/*事件处理函数*/
void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
/*用来连接handler和dev的函数*/
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;
/*用来连接handle*/
struct list_head h_list;
/*用来连接下一个hanlder*/
struct list_head node;
};

input_handle是用来连接input_handler和input_dev的结构

/*用于连接input_dev和input_hander*/
struct input_handle {

void *private; /*私有指针*/
/*打开计数*/
int open;
const char *name;

struct input_dev *dev; /*依附的input_dev结构*/
struct input_handler *handler; /*依附的handler*/

struct list_head d_node; /*连接dev*/
struct list_head h_node;/*连接handler*/
};

在内核中，因为Input是作为子系统存在，跟其子系统一样，首先会执行input.c的input_init,(如rtc子系统在加载具体设备驱动程序之前会加载rtc_init,iic子系统会加载iic_init)。

其中input_init的标志是subsys_initcall(input_init);“优先级”比module_init更高。

static int __init input_init(void)
{
int err;
/*填充input_abs_bypass数组*/
input_init_abs_bypass();
/*注册input类，在/sys/class/input*/
err = class_register(&input_class);
if (err) {
  printk(KERN_ERR "input: unable to register input_dev class\n");
  return err;
}
/*在Proc建立相关文件*/
err = input_proc_init();
if (err)
  goto fail1;
/*注册cdev结构主设备号是13*/
err = register_chrdev(INPUT_MAJOR, "input", &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_init主要功能（1）填充input_abs_bypass数组并注册input类（2）在proc目录下建立交互文件（3）注册cdev，主设备号为13

我们在查看input_fops结构：

static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
只有open函数，为什么呢，我们查看input_open_file的源码：

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? */
/*通过次设备号左移5位找到handler结构，也就是次设备号0-31对应的handler结构都一样
32-63一样，依次类推*/
handler = input_table[iminor(inode) >> 5];
  /*获取handler中的fops*/
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...
*/
/*如果open函数指针为空*/
if (!new_fops->open) {
  fops_put(new_fops);
  err = -ENODEV;
  goto out;
}
old_fops = file->f_op;
file->f_op = new_fops;
/*执行handler的open函数*/
err = new_fops->open(inode, file);

if (err) {
  fops_put(file->f_op);
  file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
out:
unlock_kernel();
return err;
}

由上可知：open函数最终会调用对应handler的open函数。

子系统初始化之后，下面就是事件的驱动了，在这里我们支持的是按键，对应的驱动是evdev.c

static int __init evdev_init(void)
{
return input_register_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,
};

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);
/*将handler存于input_handler数组*/
if (handler->fops != NULL) {
  if (input_table[handler->minor >> 5]) {
   retval = -EBUSY;
   goto out;
  }
  input_table[handler->minor >> 5] = handler;
}
/*将hander添加到input_handler_list*/
list_add_tail(&handler->node, &input_handler_list);
/*遍历整个input_dev_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_dev *input_allocate_device(void)
{
struct input_dev *dev;
/*分配内存空间*/
dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
if (dev) {
  /*填充结构*/
  dev->dev.type = &input_dev_type;
  dev->dev.class = &input_class;
  /*设备初始化，在/sys/device目录下建立目录*/
  device_initialize(&dev->dev);
  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_allocate_device分配一个input_dev,并在/sys/device下建立目录。

下面注册dev结构

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;
/* 对每个输入设备都设置EV_SYN位 */
__set_bit(EV_SYN, dev->evbit);

/*
* 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);
/*添加设备到device*/
error = device_add(&dev->dev);
if (error)
  return error;
  /*获取kobj路径*/
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;
}
/*将dev结构加入到input_dev_list链表头*/
list_add_tail(&dev->node, &input_dev_list);
/*遍历整个input_handler_list链表，通过判断handler的id域和dev的id域是否匹配，如果匹配将handler和dev联系起来*/
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_register_device的主要作用是

（1）对形参Input_dev结构的一些默认参数做填充，包括支持的事件类型，timer函数，getkeycode函数指针，setkeycode函数指针，并且对dev域的name填充。

（2） device_add 添加设备到device核心

（3）将该Input_dev结构加入到input_dev_list链表

（4）遍历整个input_handler_list链表，找到一个handler的id_table和input_dev的id一直的handler结构，并将此hanlder和此input_dev结构联系起来

对(4)要重点分析：

list_for_each_entry(handler, &input_handler_list, node)

input_attach_handler(dev, handler);

list_for_each_entry之前已经讲过，就是对input_handler_list整个链表进行遍历。

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
/*如果该dev的id在handler的blacklist已经登记，则跳过*/
if (handler->blacklist && input_match_device(handler->blacklist, dev))
  return -ENODEV;
/*找到handler的id_table和dev的id一致的id_table结构*/
id = input_match_device(handler->id_table, dev);
if (!id)
  return -ENODEV;
/*通过ID将input和handler联系起来了*/
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的id_table和dev的id一致就执行handler的connect函数将dev和handler联系起来。执行handler的connect函数。那么在这里对应的就是evdev_handler的evdev_connect函数。

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;
/*找到evdev_table中第一个为NULL的元素*/
for (minor = 0; minor < EVDEV_MINORS; minor++)
  if (!evdev_table[minor])
   break;
/*如果evdev_table中每个元素存在则退出*/
if (minor == EVDEV_MINORS) {
  printk(KERN_ERR "evdev: no more free evdev devices\n");
  return -ENFILE;
}
/*分配内存*/
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
if (!evdev)
  return -ENOMEM;

INIT_LIST_HEAD(&evdev->client_list);
spin_lock_init(&evdev->client_lock);
mutex_init(&evdev->mutex);
init_waitqueue_head(&evdev->wait);

dev_set_name(&evdev->dev, "event%d", minor);
evdev->exist = 1;
evdev->minor = minor;

evdev->handle.dev = input_get_device(dev);
evdev->handle.name = dev_name(&evdev->dev);
evdev->handle.handler = handler;
evdev->handle.private = evdev;

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);
/*将hanlde handler input_dev三者联系起来*/
error = input_register_handle(&evdev->handle);
if (error)
  goto err_free_evdev;
/*将evdev填充到evdev_table*/
error = evdev_install_chrdev(evdev);
if (error)
  goto err_unregister_handle;
/*添加设备*/
error = device_add(&evdev->dev);
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;
}

由上：evdev_connect的函数主要功能：（1）分配一个evdev，并将它填充到evdev_table中（方便以后调用），（2）调用input_register_handle将hander handle input_dev连接起来，其中handle分别和input_dev和handler相连。（3）调用device_add添加设备。

调用完evdev_connect之后handle handler input_dev之间就通过链表关联起来了。

对于(2)要分析一下：

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;
/*将handle连接到input的头部*/
list_add_tail_rcu(&handle->d_node, &dev->h_list);
mutex_unlock(&dev->mutex);

/*
* 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.
*/
/*将handle连接到handler的尾部*/
list_add_tail(&handle->h_node, &handler->h_list);
/*如果存在start域，则执行start*/
if (handler->start)
handler->start(handle);

return 0;
}

通过input_register_handle就将handler handle input_dev3个结构通过链表联系起来了。

当上面这些步骤完成之前，驱动就在内核注册好了，驱动程序加载完后，在/dev/input目录下就生成了even0设备，它的主设备号是13，次设备号为64.

当应用程序使用open函数打开/dev/input/even0设备时，在内核中Input子系统，open对应的驱动时input.c的input_open_file函数：

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;

input_open_file主要做了以下事情：（1）通过此设备号右移5位（因为Input_register_handler中次设备号左移5位存储于Input_table中）获取handler结构，在此处就是evdev_handler。（2）如果evdev_handler的open函数存在就执行evdev_handler的open函数。

上面已经提到：evdev_handler的fops：下面就执行evdev_handler的fops的open了。

static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev *evdev;
/*evdev_client结构对应一个具体的设备*/
struct evdev_client *client;
/*次设备号减去64=0*/
int i = iminor(inode) - EVDEV_MINOR_BASE;
int error;

if (i >= EVDEV_MINORS)
return -ENODEV;

error = mutex_lock_interruptible(&evdev_table_mutex);
if (error)
return error;
/*获取储存在evdev_table的evdev结构*/
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);
if (!client) {
error = -ENOMEM;
goto err_put_evdev;
}

spin_lock_init(&client->buffer_lock);
client->evdev = evdev;
/*通过链表将client置于evdev的链表头*/
evdev_attach_client(evdev, client);

error = evdev_open_device(evdev);
if (error)
goto err_free_client;
/*将client置于file的私有指针域*/
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函数主要做了以下事情：（1）通过次设备号获取evdev结构（2）分配一个endev_client结构并将client->evdev指向获取的evdev结构（3）调用evdev_attach_client函数将client置于evdev的链表头（4）调用evdev_open_device函数

evdev_open_device函数：

{

int retval;

retval = mutex_lock_interruptible(&evdev->mutex);

if (retval)

return retval;

if (!evdev->exist)

retval = -ENODEV;

else if (!evdev->open++) {

retval = input_open_device(&evdev->handle);

if (retval)

evdev->open--;

}

mutex_unlock(&evdev->mutex);

return retval;

}

函数调用input_open_device函数

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;

}

/*open计数加一*/

handle->open++;

/*当用户第一次调用时会调用dev的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;

}

因为在本按键驱动中，没有设置button_dev的open域，所以这里input_open_device无意义。

下面就是read函数监听键值了：

Read函数对应的驱动程序是 evdev.c的evdev_read。

static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
/*获得client结构*/
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
struct input_event event;
int retval;
/*如果读取的字符数小于input_event结构的大小*/
if (count < input_event_size())
  return -EINVAL;
/*如果头结点等于尾节点而且打开标志是不阻塞的，那么直接返回*/
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);
if (retval)
  return retval;

if (!evdev->exist)
return -ENODEV;

while (retval + input_event_size() <= count &&
evdev_fetch_next_event(client, &event)) {

if (input_event_to_user(buffer + retval, &event))
return -EFAULT;

retval += input_event_size();
}

return retval;
}

这里有必要提一下evdev_read函数中的client结构：

struct evdev_client {
/*存放事件的buffer*/
struct input_event buffer[EVDEV_BUFFER_SIZE];
/*事件头结点*/
int head;
/*事件尾节点*/
int tail;
spinlock_t buffer_lock; /* protects access to buffer, head and tail */
struct fasync_struct *fasync;
/*evdev结构指针*/
struct evdev *evdev;
/*指向handler的链表*/
struct list_head node;
};

这个结构中的head tail相当于一个循环队列，只有当head不等于tail的时候才表示buffer里面不为空。那么当调用evdev_read时运行到retval = wait_event_interruptible(evdev->wait,client->head != client->tail || !evdev->exist);时evdev_read会阻塞。这样就会等待按键。

当按下键值，进入中断函数，调用input_report_key报告event。

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
input_event(dev, EV_KEY, code, !!value);
}

void input_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
unsigned long flags;
/*判断evbit是否是事件所支持*/
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);
}
}

函数最终调用input_handle_event

input_handle_event函数再根据type类型做相应处理，该驱动去type为EV_KEY，
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;
  case SYN_MT_REPORT:
   dev->sync = 0;
   disposition = INPUT_PASS_TO_HANDLERS;
   break;
  }
  break;

case EV_KEY:
  /*再次判断keybit是否是小于最大键值*/
  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);
    else
     input_stop_autorepeat(dev);
   }

   disposition = INPUT_PASS_TO_HANDLERS;
  }
  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)) {

   if (test_bit(code, input_abs_bypass)) {
    disposition = INPUT_PASS_TO_HANDLERS;
    break;
   }

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)
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最终调用：input_pass_event

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);
/*最终调用handler的event函数*/
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();
}

input_pass_event再调用evdev_event

static void evdev_event(struct input_handle *handle,
unsigned int type, unsigned int code, int value)
{
struct evdev *evdev = handle->private;
struct evdev_client *client;
struct input_event event;

do_gettimeofday(&event.time);
/*将按键信息存于event结构*/
event.type = type;
event.code = code;
event.value = value;

rcu_read_lock();
/*获得client结构*/
client = rcu_dereference(evdev->grab);
if (client)
  evdev_pass_event(client, &event);
else
  list_for_each_entry_rcu(client, &evdev->client_list, node)
   evdev_pass_event(client, &event);

rcu_read_unlock();

wake_up_interruptible(&evdev->wait);
}

evdev_event会调用evdev_pass_event函数：

static void evdev_pass_event(struct evdev_client *client,
struct input_event *event)
{
/*
* Interrupts are disabled, just acquire the lock
*/
spin_lock(&client->buffer_lock);
/*将事件结构存在buffer中并且head加一*/
client->buffer[client->head++] = *event;
/*溢出处理*/
client->head &= EVDEV_BUFFER_SIZE - 1;
spin_unlock(&client->buffer_lock);

kill_fasync(&client->fasync, SIGIO, POLL_IN);
}

从evdev_pass_event函数我们可以得到：将事件结构存在buffe,client的head指针加一，那么head加一之后，也就是报告键值完毕了，回到了evdev_read函数中：此时的head是不等于tail的，所以唤醒等待队列：

下面就会执行evdev_read的evdev_fetch_next_event函数：

static int evdev_fetch_next_event(struct evdev_client *client,

struct input_event *event)

{

int have_event;

spin_lock_irq(&client->buffer_lock);

have_event = client->head != client->tail;

if (have_event) {

/*获取事件指针并且tail加一*/

*event = client->buffer[client->tail++];

/*溢出处理*/

client->tail &= EVDEV_BUFFER_SIZE - 1;

}

spin_unlock_irq(&client->buffer_lock);

return have_event;

}

evdev_fetch_next_event将client的尾节点加一(这时候head和tail又相等了)。

随后evdev_read调用input_event_to_user

int input_event_to_user(char __user *buffer,
const struct input_event *event)
{
if (copy_to_user(buffer, event, sizeof(struct input_event)))
return -EFAULT;

return 0;
}

这样就将按键事件结构event传递到了用户空间。

总结：由上我们看出，input子系统的确是很复杂的。下面画一个简单的流程图。