正常的字符设备驱动程序框架：
- 设置 major 设备号
- 填充 file_operations 结构体
- register_chrdev 注册字符设备驱动程序
- 编写 init 入口函数 和 exit 出口函数
输入子系统驱动程序的大致流程与我们自己写的字符设备驱动程序是一样的。
1. 输入子系统框架分析 1.1 init 函数static int __init input_init(void)
{
err = class_register(&input_class);
err = input_proc_init();
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
}
-
class_register(&input_class); 注册一个类。（可以在 /sys/class/ 目录下看到）
-
register_chrdev(INPUT_MAJOR, "input", &input_fops); 注册一个字符设备驱动程序。与我们自己写的字符设备驱动程序一样。
static const struct file_operations input_fops = { .owner = THIS_MODULE, .open = input_open_file, };input_fops 中只定义了一个 .open 函数。
在 input_fops 中我们没有看到读、写等对设备的操作函数。说明在 input_open_file 函数中可能做了一些特殊的处理工作。
1.2 open函数static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler = input_table[iminor(inode) >> 5];
const struct file_operations *old_fops, *new_fops = NULL;
int err;
if (!handler || !(new_fops = fops_get(handler->fops)))
return -ENODEV;
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file);
}
-
input_table[iminor(inode) >> 5]，通过 input_table 获取一个 input_handler。
input_handler 的定义如下：
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; }; -
fops_get(handler->fops)：获取了 input_handler 中的 fops；
-
file->f_op = new_fops：将 input_handler 中的 fops 替换掉原理的 f_op （input_fops）；
-
new_fops->open(inode, file)：打开了 input_handler 这个设备的 open 函数；
通过上面分析可知，核心在于 input_table 是中的 input_handler 是怎么来的。换言之，input_table 如何构造的？
1.3 input 系统input_table 是一个全局的静态数组：
static struct input_handler *input_table[8];input_handler
将 input_handler 填充（注册）进 input_table 使用的是 input_register_handler 这个函数，其定义如下：
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5])
return -EBUSY;
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);
}
我们以内核中的 evdev.c 文件为例，来说明 input_register_handler 的使用。
在 evdev.c 的 init 函数中：
static int __init evdev_init(void) { return input_register_handler(&evdev_handler); }调用了 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, };
evdev_ids：是一个数组，里面存放的是该 handler 所能够支持的所有的 device 类型。定义如下：
static const struct input_device_id evdev_ids[] = { { .driver_info = 1 }, { }, };input_handler 是一个纯软件的概念，与之对应的是 input_dev，后者是一个硬件相关的实现。
input_handler 中的 id_table 会记录该 handler 所支持的 input_dev 的类型。当两者的符合时，就会调用 input_handler 的 connect 函数与 input_dev 建立一个“连接”。这个工作由 input_attach_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);
}
input_dev
而将 input_dev 注册进内核是使用 input_register_device 函数，其功能与 input_register_handler 类似：
int input_register_device(struct input_dev *dev)
{
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_attach_handler 进行连接的建立；
连接的建立input_attach_handler 函数内部会调用 handler->connect(handler, dev, id) 建立连接。
我们还是以 evdev.c 文件为例：
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->exist = 1;
evdev->minor = minor;
evdev->handle.dev = dev;
evdev->handle.name = evdev->name;
evdev->handle.handler = handler;
evdev->handle.private = evdev;
sprintf(evdev->name, "event%d", minor);
evdev_table[minor] = evdev;
devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
cdev = class_device_create(&input_class, &dev->cdev, devt,
dev->cdev.dev, evdev->name);
error = input_register_handle(&evdev->handle);
}
input_register_handle 的定义如下：
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;
}
- list_add_tail(&handle->d_node, &handle->dev->h_list)：将 handle 添加进 dev 的 h_list 链表中，这样 dev 就可以访问 handle。
- list_add_tail(&handle->h_node, &handler->h_list)：同理，将 handle 添加进 handler 的 h_list 链表中。
总结一下连接的建立：
- 分配一个 input_handle 的结构体
- 在 input_handle 中记录设备的 dev、处理驱动的 handler
- 调用 input_register_handle 进行注册，使得：handler->h_list = &input_handle 和 dev->h_list = &input_handle；
当设备 dev 上可读时，最终会调用 evdev_read 函数进行处理：
static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
int retval;
if (count < evdev_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;
}
- 在14行，调用了 wait_event_interruptible 使得读操作进入阻塞。那么谁来唤醒？
在 evdev_event 函数：
static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
wake_up_interruptible(&evdev->wait);
}
有一个 wake_up_interruptible 的唤醒操作。
我们重新看到 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,
};
里面还有一个 .event 函数。从函数名字可以猜测，当有设备 dev 上事件发送时，该函数就会被调用。
那么 evdev_event 是被谁调用的？
猜测，应该是 input_dev 来调用的。这里我们以 gpio_keys.c 这个文件内的设备为例。该文件并不是实际的设备驱动，只是内核中的一个例子。
我们看到它的中断处理函数 gpio_keys_isr 函数：
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
int gpio = button->gpio;
if (irq == gpio_to_irq(gpio)) {
unsigned int type = button->type ?: EV_KEY;
int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low;
input_event(input, type, button->code, !!state);
input_sync(input);
}
}
}
input_event 用于向 handler 上报事件，其函数的定义如下：
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
if (dev->grab)
dev->grab->handler->event(dev->grab, type, code, value);
else
list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle, type, code, value);
}
2. 总结list_for_each_entry 从这个函数我们也可以知道，对于 dev 而言，一个 dev 可能有多个 handler 与之进行绑定。同理一个 handler 也可以处理多个 dev 设备。它们之间的关系是多对多的关系。
整个输入子系统的框架就如上图所示：
-
输入子系统分为两层，上层为 input 层，也就是核心层。应用程序操作时与核心层进行交互。
核心层会将自己的 file_operations 结构体替换成下层 input_handler 中的 file_operations。从而使应用程序可以间接访问到 input_handler 的 file_operations 。
-
下层分为两个部分：
- handler：该部分负责完成驱动的处理操作；
- dev：该部分负责与硬件设备进行交互工作；
它们之间通过一个 handle 的数据结构相连在一起。
-
当设备端有事件发生时：
dev 部分负责完成与设备的交互。例如：获取数据，判断按键的值等。
然后 dev 通过其 h_list 中记录的 handle，对每一个 handle 都调用 event 函数。最终会调用 handler 中实现的 event 函数，从而触发 handler 端完成相关的处理工作。
