linux input设备驱动

一. 输入设备结构体

1. input_dev 输入设备

[cpp] view
plaincopy

struct input_dev {

const char *name; //设备名

const char *phys; //设备系统层的物理路径

const char *uniq; //

struct input_id 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)]; //led指示灯标志位

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 hint_events_per_packet;

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); //获取键盘码

int (*setkeycode_new)(struct input_dev *dev,const struct input_keymap_entry *ke,unsigned int *old_keycode);

int (*getkeycode_new)(struct input_dev *dev,struct input_keymap_entry *ke);

struct ff_device *ff; //强制反馈设备

unsigned int repeat_key; //重复按键标志位

struct timer_list timer; //定时器

int rep[REP_CNT]; //重复次数

struct input_mt_slot *mt;

int mtsize;

int slot;

struct input_absinfo *absinfo;

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 (*open)(struct input_dev *dev); //open方法

void (*close)(struct input_dev *dev); //close方法

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 __rcu *grab;

spinlock_t event_lock;

struct mutex mutex;

unsigned int users;

bool going_away;

bool sync;

struct device dev; //设备文件

struct list_head h_list; //input_handler处理器链表头

struct list_head node; //input_device设备链表头

};

2. input_handler 输入处理器

[cpp] view
plaincopy

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); //设备匹配

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; //输入设备 id表

struct list_head h_list; //input_handler处理器链表头

struct list_head node; //input_device设备链表头

};

二. 输入系统初始化

1 input_init

[cpp] view
plaincopy

static int __init input_init(void)

{

int err;

err = class_register(&input_class); //注册类 创建"/sys/input"

if (err) {

printk(KERN_ERR "input: unable to register input_dev class\n");

return err;

}

err = input_proc_init(); //初始化"/proc/bus/input"接口

if (err)

goto fail1;

err = register_chrdev(INPUT_MAJOR, "input", &input_fops); //注册所有输入字符设备,并捆绑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;

}

2. /proc 接口

2.1 创建/proc/bus/input下的文件

[cpp] view
plaincopy

static int __init input_proc_init(void)

{

struct proc_dir_entry *entry;

proc_bus_input_dir = proc_mkdir("bus/input", NULL); //创建"/proc/bus/input"

if (!proc_bus_input_dir)

return -ENOMEM;

entry = proc_create("devices", 0, proc_bus_input_dir,&input_devices_fileops); //创建"/proc/bus/input/devices"

if (!entry)

goto fail1;

entry = proc_create("handlers", 0, proc_bus_input_dir,&input_handlers_fileops); //创建"/proc/bus/input/handlers"

if (!entry)

goto fail2;

return 0;

fail2: remove_proc_entry("devices", proc_bus_input_dir);

fail1: remove_proc_entry("bus/input", NULL);

return -ENOMEM;

}

2.2 devices文件

[cpp] view
plaincopy

static const struct file_operations input_devices_fileops = {

.owner = THIS_MODULE,

.open = input_proc_devices_open,

.poll = input_proc_devices_poll,

.read = seq_read,

.llseek = seq_lseek,

.release = seq_release,

};

2.2.1 限于篇幅及省略啰嗦

这里当我们去cat /proc/bus/input/devices时候,会调用input_proc_devices_open函数,接着调用seq_open(file, &input_devices_seq_ops),捆绑了input_devices_seq_ops操作函数集,

其seq_operations函数集中声明了.show方法为input_devices_seq_show,该方法打印了些信息到seq文件,接着cat命令会调用read方法,read方法会调用.show方法,

接着把打印到文件的信息复制用户空间的缓冲区中.这里主要看看.show方法吧

2.2.2 input_devices_seq_show

[cpp] view
plaincopy

static int input_devices_seq_show(struct seq_file *seq, void *v)

{

struct input_dev *dev = container_of(v, struct input_dev, node); //获取到输入设备结构体

const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); //获取在/sys下的路径

struct input_handle *handle;

seq_printf(seq, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);

//打印I：总线类型,厂商id,产品id,版本号

seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : ""); //打印N：输入设备名

seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : ""); //打印P：phys

seq_printf(seq, "S: Sysfs=%s\n", path ? path : ""); //打印S：sysfs文件系统下的路径

seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : ""); //打印U：uniq

seq_printf(seq, "H: Handlers="); //打印H：input_handler处理器名

list_for_each_entry(handle, &dev->h_list, d_node) //遍历处理器链表

seq_printf(seq, "%s ", handle->name);

seq_putc(seq, '\n');

input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX); //打印EV：事件类型位图

if (test_bit(EV_KEY, dev->evbit)) //打印各种具体事件的事件位图

input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);

if (test_bit(EV_REL, dev->evbit))

input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);

if (test_bit(EV_ABS, dev->evbit))

input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);

if (test_bit(EV_MSC, dev->evbit))

input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);

if (test_bit(EV_LED, dev->evbit))

input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);

if (test_bit(EV_SND, dev->evbit))

input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);

if (test_bit(EV_FF, dev->evbit))

input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);

if (test_bit(EV_SW, dev->evbit))

input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);

seq_putc(seq, '\n');

kfree(path);

return 0;

}

打印效果大致如下：因设备不同而异

[cpp] view
plaincopy

cat devices

I: Bus=0019 Vendor=0000 Product=0001 Version=0000

N: Name="Power Button"

P: Phys=LNXPWRBN/button/input0

S: Sysfs=/devices/LNXSYSTM:00/LNXPWRBN:00/input/input0

U: Uniq=

H: Handlers=kbd event0

B: EV=3

B: KEY=100000 0 0 0

I: Bus=0017 Vendor=0001 Product=0001 Version=0100

N: Name="Macintosh mouse button emulation"

P: Phys=

S: Sysfs=/devices/virtual/input/input1

U: Uniq=

H: Handlers=mouse0 event1

B: EV=7

B: KEY=70000 0 0 0 0 0 0 0 0

B: REL=3

这里可以根据Bus值得知该输入设备是基于什么总线的

[cpp] view
plaincopy

#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

#define BUS_SPI 0x1C

2.3 handlers文件

[cpp] view
plaincopy

static const struct file_operations input_handlers_fileops = {

.owner = THIS_MODULE,

.open = input_proc_handlers_open,

.read = seq_read,

.llseek = seq_lseek,

.release = seq_release,

};

2.3.1

这里当我们去cat /proc/bus/input/handlers时候,会调用input_proc_handlers_open函数,接着调用seq_open(file, &input_handlers_seq_ops),捆绑了input_handlers_seq_ops操作函数集,

其seq_operations函数集中声明了.show方法为input_handlers_seq_show,该方法打印了些信息到seq文件,接着cat命令会调用read方法,read方法会调用.show方法,

接着把打印到文件的信息复制用户空间的缓冲区中.这里主要看看.show方法吧

[cpp] view
plaincopy

static int input_handlers_seq_show(struct seq_file *seq, void *v)

{

struct input_handler *handler = container_of(v, struct input_handler, node); //获得输入处理器

union input_seq_state *state = (union input_seq_state *)&seq->private;

seq_printf(seq, "N: Number=%u Name=%s", state->pos, handler->name); //打印N：Number=序号 name=设备名

if (handler->filter)

seq_puts(seq, " (filter)");

if (handler->fops)

seq_printf(seq, " Minor=%d", handler->minor); //打印Minor=次设备号

seq_putc(seq, '\n');

return 0;

}

我的打印是

[cpp] view
plaincopy

cat handlers

N: Number=0 Name=rfkill

N: Number=1 Name=kbd

N: Number=2 Name=mousedev Minor=32

N: Number=3 Name=evdev Minor=64

3. 字符设备接口

3.1 主设备号

[cpp] view
plaincopy

#define INPUT_MAJOR 13

3.2 input_fops

[cpp] view
plaincopy

static const struct file_operations input_fops = {

.owner = THIS_MODULE,

.open = input_open_file, //打开方法

.llseek = noop_llseek,

};

3.2.1 input_open_file

[cpp] view
plaincopy

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;

err = mutex_lock_interruptible(&input_mutex);

if (err)

return err;

/* No load-on-demand here? */

handler = input_table[iminor(inode) >> 5]; //根据节点算出次设备号,并在全局input_table找到输入处理器

if (handler)

new_fops = fops_get(handler->fops); //获取输入操作函数集指针

mutex_unlock(&input_mutex);

/*

* That's _really_ odd. Usually NULL ->open means "nothing special",

* not "no device". Oh, well...

*/

if (!new_fops || !new_fops->open) { //判断输入操作函数集的存在且存在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:

return err;

}

三. 分配input_dev

[cpp] view
plaincopy

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; //设置类

device_initialize(&dev->dev); //初始化设备文件

mutex_init(&dev->mutex);

spin_lock_init(&dev->event_lock);

INIT_LIST_HEAD(&dev->h_list); //初始化input_handler链表头

INIT_LIST_HEAD(&dev->node);

__module_get(THIS_MODULE);

}

return dev;

}

四. 设置输入设备类型

1.设置标志位的辅助宏

[cpp] view
plaincopy

#define setbit(a, i) (((u8 *)a)[(i)/NBBY] |= 1<<((i)%NBBY)) //设置标志位(eg：setbit(EV_KEY,my_input_dev.evbit))

#define clrbit(a, i) (((u8 *)a)[(i)/NBBY] &= ~(1<<((i)%NBBY))) //清除标志位(eg：setbit(REL_Z,my_input_dev.relbit))

#define isset(a, i) (((const u8 *)a)[(i)/NBBY] & (1<<((i)%NBBY))) //检测某标志位是否设置

#define isclr(a, i) ((((const u8 *)a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0) //检测某标志位是否清除

2.设置事件类型标志位ev_bit

[cpp] view
plaincopy

#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

3.设置对应事件的标志位

标志位的值在include/linux/Input.h中有详细定义

五. 注册注销输入设备

1.1 注册输入设备

[cpp] view
plaincopy

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); //添加同步事件

__clear_bit(KEY_RESERVED, dev->keybit); //清除保留键

input_cleanse_bitmasks(dev); //清除位掩码

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_new) //若没定义获取键盘码的函数

dev->getkeycode_new = input_default_getkeycode; //则设置为系统默认的获取键盘码函数

if (!dev->setkeycode && !dev->setkeycode_new) //若没定义设置键盘码的函数

dev->setkeycode_new = input_default_setkeycode; //则设置为系统默认的设置键盘码函数

dev_set_name(&dev->dev, "input%ld",(unsigned long) atomic_inc_return(&input_no) - 1); //设置输入设备名字-->"/sys/class/input/input%d"

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_dev和input_handler

input_wakeup_procfs_readers();

mutex_unlock(&input_mutex);

return 0;

}

1.2 注销输入设备

[cpp] view
plaincopy

void input_unregister_device(struct input_dev *dev)

{

struct input_handle *handle, *next;

input_disconnect_device(dev); //断开设备连接

mutex_lock(&input_mutex);

list_for_each_entry_safe(handle, next, &dev->h_list, d_node) //遍历输入处理器链表

handle->handler->disconnect(handle); //查找到对应项并调用其断开连接函数

WARN_ON(!list_empty(&dev->h_list));

del_timer_sync(&dev->timer); //移除定时器

list_del_init(&dev->node); //逆初始化设备

input_wakeup_procfs_readers();

mutex_unlock(&input_mutex);

device_unregister(&dev->dev); //注销设备

}

六. 输入处理器

1.输入处理器的驱动,内核已经帮我们设计好了 eg：evdev.c，tsdev.c，joydev.c，keyboard.c，mousedev.c

2. 以mousedev.c为蓝本分析下处理器驱动的设计

2.1 mousedev_handler的定义

[cpp] view
plaincopy

static struct input_handler mousedev_handler = {

.event = mousedev_event, //事件处理函数(设备上报输入事件给到处理器,处理器调用此函数解析)

.connect = mousedev_connect, //连接(处理器和设备匹配后调用)

.disconnect = mousedev_disconnect, //断开

.fops = &mousedev_fops, //操作函数集

.minor = MOUSEDEV_MINOR_BASE, //次设备号

.name = "mousedev", //设备名

.id_table = mousedev_ids,

};

2.1.1 mousedev_ids

input_device_id的结构体在处理器与设备匹配的时候会用上,mousedev_ids罗列了鼠标的大致分类,flags标记了需要匹配的事件类型

[cpp] view
plaincopy

static const struct input_device_id mousedev_ids[] = {

{

.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT | INPUT_DEVICE_ID_MATCH_RELBIT,

.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },

.keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },

.relbit = { BIT_MASK(REL_X) | BIT_MASK(REL_Y) },

}, /* A mouse like device, at least one button,two relative axes */

{

.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_RELBIT,

.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_REL) },

.relbit = { BIT_MASK(REL_WHEEL) },

}, /* A separate scrollwheel */

{

.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT | INPUT_DEVICE_ID_MATCH_ABSBIT,

.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },

.keybit = { [BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH) },

.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },

}, /* A tablet like device, at least touch detection,two absolute axes */

{

.flags = INPUT_DEVICE_ID_MATCH_EVBIT |INPUT_DEVICE_ID_MATCH_KEYBIT | INPUT_DEVICE_ID_MATCH_ABSBIT,

.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },

.keybit = { [BIT_WORD(BTN_TOOL_FINGER)] =BIT_MASK(BTN_TOOL_FINGER) },

.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |BIT_MASK(ABS_PRESSURE) |BIT_MASK(ABS_TOOL_WIDTH) },

}, /* A touchpad */

{

.flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT |INPUT_DEVICE_ID_MATCH_ABSBIT,

.evbit = { BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) },

.keybit = { [BIT_WORD(BTN_LEFT)] = BIT_MASK(BTN_LEFT) },

.absbit = { BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) },

}, /* Mouse-like device with absolute X and Y but ordinaryclicks, like hp ILO2 High Performance mouse */

{ }, /* Terminating entry */

};

2.2 处理器的注册

[cpp] view
plaincopy

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; //填充全局input_table表

}

list_add_tail(&handler->node, &input_handler_list); //添加输入处理器到全局输入处理器链表

list_for_each_entry(dev, &input_dev_list, node) //遍历全局输入设链表

input_attach_handler(dev, handler); //匹配input_device和input_handler

input_wakeup_procfs_readers();

out:

mutex_unlock(&input_mutex);

return retval;

}

2.3 处理器的注销

[cpp] view
plaincopy

void input_unregister_handler(struct input_handler *handler)

{

struct input_handle *handle, *next;

mutex_lock(&input_mutex);

list_for_each_entry_safe(handle, next, &handler->h_list, h_node)

handler->disconnect(handle); //调用断开连接函数

WARN_ON(!list_empty(&handler->h_list));

list_del_init(&handler->node); //删除输入设备链表

if (handler->fops != NULL)

input_table[handler->minor >> 5] = NULL; //清空全局输入处理器表

input_wakeup_procfs_readers();

mutex_unlock(&input_mutex);

}

七. 设备的匹配



1.在输入设备或者输入处理器注册的时候都会遍历全局链表input_handler_list或input_dev_list并调用input_attach_handler寻找匹配项

[cpp] view
plaincopy

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)

{

const struct input_device_id *id;

int error;

id = input_match_device(handler, dev); //匹配input_handler和input_dev获取input_device_id

if (!id)

return -ENODEV;

error = handler->connect(handler, dev, id); //匹配到则调用其input_handler的连接方法

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;

}

2.input_match_device

[cpp] view
plaincopy

static const struct input_device_id *input_match_device(struct input_handler *handler,struct input_dev *dev)

{

const struct input_device_id *id;

int i;

for (id = handler->id_table; 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) //判断厂商id

continue;

if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)

if (id->product != dev->id.product) //判断产品id

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

if (!handler->match || handler->match(handler, dev)) //若input_handler存在match方法则调用其方法

return id;

}

return NULL;

}

八. 事件的处理

1.设备需要上报事件(一般在中断处理函数中上报)

[cpp] view
plaincopy

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_report_ff_status(struct input_dev *dev, unsigned int code, int value) //上报强制反馈事件

{

input_event(dev, EV_FF_STATUS, code, value);

}

static inline void input_report_switch(struct input_dev *dev, unsigned int code, int value) //上报开关事件

{

input_event(dev, EV_SW, code, !!value);

}

static inline void input_sync(struct input_dev *dev) //上报同步事件----在上报完其他事件后必须上报同步事件通知对应的输入处理器

{

input_event(dev, EV_SYN, SYN_REPORT, 0);

}

2.所有上报事件都会调用到input_event函数

[cpp] view
plaincopy

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)) { //判断对应的input_dev是否支持该事件

spin_lock_irqsave(&dev->event_lock, flags);

add_input_randomness(type, code, value);

input_handle_event(dev, NULL, type, code, value); //输入事件处理句柄

spin_unlock_irqrestore(&dev->event_lock, flags);

}

}

3.input_handle_event函数

[cpp] view
plaincopy

static void input_handle_event(struct input_dev *dev,struct input_handler *src_handler,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; //这里有个宏#define INPUT_PASS_TO_ALL (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)

break;

case SYN_REPORT:

if (!dev->sync) {

dev->sync = true;

disposition = INPUT_PASS_TO_HANDLERS;

}

break;

case SYN_MT_REPORT:

dev->sync = false;

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

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

disposition = input_handle_abs_event(dev, src_handler,code, &value);

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: //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 = false;

if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)

dev->event(dev, type, code, value); //根据事件类型不同,部分事件会先调用到input_dev的事件处理函数

if (disposition & INPUT_PASS_TO_HANDLERS)

input_pass_event(dev, src_handler, type, code, value); //直接传递事件给对应事件的输入处理器处理

}

4.input_pass_event

[cpp] view
plaincopy

static void input_pass_event(struct input_dev *dev,struct input_handler *src_handler,unsigned int type, unsigned int code, int value)

{

struct input_handler *handler;

struct input_handle *handle;

rcu_read_lock();

handle = rcu_dereference(dev->grab);

if (handle)

handle->handler->event(handle, type, code, value); //调用处理器的event方法

else {

bool filtered = false;

list_for_each_entry_rcu(handle, &dev->h_list, d_node) {

if (!handle->open)

continue;

handler = handle->handler;

if (handler == src_handler)

continue;

if (!handler->filter) {

if (filtered)

break;

handler->event(handle, type, code, value);

} else if (handler->filter(handle, type, code, value))

filtered = true;

}

}

rcu_read_unlock();

}