6410之输入子系统（1）

本文链接：https://blog.csdn.net/longshan_2009/article/details/10067003

输入子系统框架：

一、Input.c (drivers\input) ：核心层，只是处于中转的作用。下面分析：

static int __init input_init(void)
{
int err;


err = class_register(&input_class);
if (err) {
printk(KERN_ERR "input: unable to register input_dev class\n");
return err;
}


err = input_proc_init();
if (err)
goto fail1;


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_MAJOR，名字为input，file_operations为input_fops的字符设备。input_fops的定义如下：

static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};

从上面的file_operations中只有一个open的操作，那么对设备节点的读写应该在open函数中做了相应的操作，继续查看：

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);   //从handler中获取新的file_operations结构体


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) {
fops_put(new_fops);
err = -ENODEV;
goto out;
}


old_fops = file->f_op;
file->f_op = new_fops; //将新的file_operations赋值给file_f_op，这样对字符设备节点的读写等其他一切操作就使用nes_fops了


err = new_fops->open(inode, file);//使用新的file_operations打开节点
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
out:
return err;
}

从上面代码可以看到，input.c在linux中处于中间转接的作用。

总结一下：

drivers/input/input.c：
input_init > err = register_chrdev(INPUT_MAJOR, "input", &input_fops); //注册字符设备驱动

static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};

问：怎么读按键？
input_open_file
struct input_handler *handler = input_table[iminor(inode) >> 5];
new_fops = fops_get(handler->fops) //获取新的file_operations
file->f_op = new_fops; file_operations已经变化
err = new_fops->open(inode, file);

app: read > ... > file->f_op->read //新的file_operations的read函数,这样就可以读取按键的值了。

那么如何获取到新的file_operations的呢？

搜索input_table数组，可以发现该数组在input_register_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]) {
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;
}

搜索input_register_handler函数，在下面文件中均有调用到：

Evbug.c (drivers\input):	return input_register_handler(&evbug_handler);
Evdev.c (drivers\input):	return input_register_handler(&evdev_handler);
Joydev.c (drivers\input):	return input_register_handler(&joydev_handler);
Keyboard.c (drivers\char):	error = input_register_handler(&kbd_handler);
Mac_hid.c (drivers\macintosh):	err = input_register_handler(&mac_hid_emumouse_handler);
Mousedev.c (drivers\input):	error = input_register_handler(&mousedev_handler);
Sysrq.c (drivers\char):	error = input_register_handler(&sysrq_handler);

他们向上注册了一个 input_handler。

下面具体看下input_register_handler：

input_register_handler
// 将注册的handler放入数组input_table中
input_table[handler->minor >> 5] = handler;

// 将handler放入handler链表
list_add_tail(&handler->node, &input_handler_list);

// 对于每个input_dev，调用input_attach_handler
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev

以上都是input子系统的纯软件框架层。还有物理硬件层操作：注册input_dev，使用到的函数为：input_register_device

下面看下input_register_device的操作：

注册输入设备:
input_register_device
// 放入链表
list_add_tail(&dev->node, &input_dev_list);

// 对于每一个input_handler，都调用input_attach_handler
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev

从上面分析发现：这两个函数最终都会调用到input_attach_handler。

input_attach_handler
id = input_match_device(handler->id_table, dev); // 匹配input_handler和input_dev
error = handler->connect(handler, dev, id);//执行handler的connect函数

注册input_dev或input_handler时，会两两比较input_dev和input_handler,根据input_handler的id_table判断这个input_handler能否支持这个input_dev，如果能支持，则调用input_handler的connect函数建立"连接"

怎么建立连接？connect函数
1. 分配一个input_handle结构体
2.
input_handle.dev = input_dev; // 指向左边的input_dev
input_handle.handler = input_handler; // 指向右边的input_handler
3. 注册：
input_handler->h_list = &input_handle;
inpu_dev->h_list = &input_handle;

举evdev.c为例：

evdev_connect
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); // 分配一个input_handle
// 设置
evdev->handle.dev = dev; // 指向input_dev
evdev->handle.name = evdev->name;
evdev->handle.handler = handler; // 指向input_handler
evdev->handle.private = evdev;
// 注册
error = input_register_handle(&evdev->handle);

总框图：

怎么读按键？
app: read
--------------------------
.......
evdev_read
// 无数据并且是非阻塞方式打开，则立刻返回
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);

谁来唤醒？
evdev_event
wake_up_interruptible(&evdev->wait);

evdev_event被谁调用？
猜：应该是硬件相关的代码，input_dev那层调用的
在设备的中断服务程序里，确定事件是什么，然后调用相应的input_handler的event处理函数
gpio_keys_isr
// 上报事件
input_event(input, type, button->code, !!state);
input_sync(input);

input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
struct input_handle *handle;

list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle, type, code, value);