2.1 input subsystem 初始化流程
接下来我们分析input.c的代码中,input subsystem的初始化与退出:
static int __init input_init(void)
{
int err;
err = class_register(&input_class);//向内核注册一个类,用于linux设备模型,注册后会在/sys/class/下面出现input目录
if (err) {
pr_err("unable to register input_dev class\n");
return err;
}
err = input_proc_init();//与proc文件系统有关
if (err)
goto fail1;
/*注册字符设备,主设备号为13表示input设备,可以在/proc/devices下看到*/
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (err) {
pr_err("unable to register char major %d", INPUT_MAJOR);
goto fail2;
}
return 0;
fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}
register_chrdev 参考
( 内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。)
static void __exit input_exit(void)
{
input_proc_exit();
unregister_chrdev(INPUT_MAJOR, "input");
class_unregister(&input_class);
}
subsys_initcall(input_init);
module_exit(input_exit);
在注册input的时候绑定的操作函数集
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
.llseek = noop_llseek,
};
特别注意: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;
err = mutex_lock_interruptible(&input_mutex);
if (err)
return err;
/* No load-on-demand here? */
handler = input_table[iminor(inode) >> 5];//获得handler,因为每个注册的handler都会把自己注册到input_table这个数组里,下标右移5位表示除以32,因为每个handler最大可以处理32个设备,所以是以32为倍数对齐
if (handler)
new_fops = fops_get(handler->fops);//获得handler的操作函数集
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;
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:
return err;
}
该函数主要是获取handler的操作函数集,如果获得成功,使用新的集代替旧的操作函数,并调用新函数集的open函数。
接下来看input子系统中3个重要结构体的注册和注销(input_dev,input_handle,input_handler)
int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);//原子变量,代表总共注册的input设备,每注册一个加1,由于是静态变量,每次调用都不会清零
struct input_handler *handler;
const char *path;
int error;
/* Every input device generates EV_SYN/SYN_REPORT events. */
__set_bit(EV_SYN, dev->evbit);//EV_SYN这个是所有设备要支持的事件类型,所以要设置
/* KEY_RESERVED is not supposed to be transmitted to userspace. */
__clear_bit(KEY_RESERVED, dev->keybit);//KEY_RESERVED(版权)不应该传到用户空间
/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
input_cleanse_bitmasks(dev);//确保dev->evbit被清零是不介意的
if (!dev->hint_events_per_packet)
dev->hint_events_per_packet =
input_estimate_events_per_packet(dev);
/*
* 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;
}
/*如果没有dev->getkeycode和dev->setkeycode使用由input提供的默认函数*/
if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
/*设置input_dev中device的名字,名字将在/class/input/中出现*/
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1);
error = device_add(&dev->dev);//将device加到linux设备模型中
if (error)
return error;
/*得到device的路径*/
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
pr_info("%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);//将device的节点加到input_dev_list链表上
/*遍历input_handler_list链表,配对input_dev和input_handler*/
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
return 0;
}
EXPORT_SYMBOL(input_register_device);
注册input_dev主要完成一些初始化设置,然后调用 input_attach_handler来匹配input_dev和input_handler.
这里写代码片static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
/*主要的配对函数,主要比较ID中的各项*/
id = input_match_device(handler, dev);
if (!id)
return -ENODEV;
/*配对成功调用 handler->connect函数,在事件处理器中定义,主要生成input_handle结构,并初始化,还生成一个事件处理器相关的结构*/
error = handler->connect(handler, dev, id);
if (error && error != -ENODEV)
pr_err("failed to attach handler %s to device %s, error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
匹配函数首先调用了 input_match_device,在匹配成功以后调用了handler的connect函数
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;
/*遍历传入的handler->id_table,寻找合适的ID进行配对*/
for (id = handler->id_table; id->flags || id->driver_info; id++) {
/*根据flags来,来筛选出同种类型的ID,否者进入下一个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)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
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))
return id;
}
return NULL;
}
这个函数主要从handler->id_table中找出和input_dev同种类型的input_handler,然后比较支持的事件,最后看handler是否提供了match函数,提供了就调用handler的match进行匹配,没有提供直接返回同类型的id.
#define MATCH_BIT(bit, max) \
for (i = 0; i < BITS_TO_LONGS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != BITS_TO_LONGS(max)) \
continue;
这个可以看出这里是按位比较,比较成功,进入下一个MATCH_BIT比较下一个事件类型,否则进行下一个ID的比较。对于触摸屏来说对应的事件处理器为evdev,在evdev事件处理器中没有提供match函数,所以只要flag和事件类型都匹配成功,就会返回这个handler的id。当然evdev提供了connect函数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_MINORS等于32,说明evdev可以同时有32个设备和它配对,evdev_table的下标minor并不是次设备号*/
for (minor = 0; minor < EVDEV_MINORS; minor++)
if (!evdev_table[minor])
break;
/*说明32个设备全部被占用了,链接失败*/
if (minor == EVDEV_MINORS) {
pr_err("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);
/* 设置evdev中device的名字,它也将出现在/class/input/下,但是他和input_dev下面的device是有区别的,
* evdev配对以后的虚拟设备结构,没有对应的硬件,但是可以通过它找到相应的硬件*/
dev_set_name(&evdev->dev, "event%d", minor);
evdev->exist = true;
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);//minor不是真正的次设备号,还要加上EVDEV_MINOR_BASE
evdev->dev.class = &input_class;
evdev->dev.parent = &dev->dev;//配对生成新的device,父设备是与他相关联的input_dev
evdev->dev.release = evdev_free;
device_initialize(&evdev->dev);
error = input_register_handle(&evdev->handle);//注册handle结构体
if (error)
goto err_free_evdev;
error = evdev_install_chrdev(evdev);//把evdev结构保存到evdev_table中,这个数组以minor为索引
if (error)
goto err_unregister_handle;
error = device_add(&evdev->dev);//将evdev下面的device注册到linux设备模型中
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;
}
connect函数evdev的分配和初始化,保存到evdev_table数组中,并注册一个handle。
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;
/*
* Filters go to the head of the list, normal handlers
* to the tail.
*/
if (handler->filter)
list_add_rcu(&handle->d_node, &dev->h_list);//将handle的d_node链接到相关input_dev的h_list链表中
else
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.
*/
list_add_tail_rcu(&handle->h_node, &handler->h_list);//将handle的h_node链接到其相关的input_handler的h_list链表中
if (handler->start)
handler->start(handle);
return 0;
}
EXPORT_SYMBOL(input_register_handle);
从上面可以看出,connect调用input_register_handle主要就是通过handle充当桥梁,建立input_dev和input_handler的关联。
input_handler的注册,一般事件处理层入口处注册input_handler,比如evdev事件处理器。
static int __init evdev_init(void)
{
/*将evdev_handler注册到系统中*/
return input_register_handler(&evdev_handler);
}
static void __exit evdev_exit(void)
{
input_unregister_handler(&evdev_handler);
}
module_init(evdev_init);
module_exit(evdev_exit);
input_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);
/*每次注册一个handler都会将其保存到input_table,这里索引值等于handler->minor左移5位,也就是除以32。
* 因为每个handler最多可以处理32个input_dev设备,所以要以32为对齐minor是传进来的handler的MINOR_BASE*/
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);//将handler连接到input_handler_list链表中
/*遍历input_dev链表,开始匹配*/
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;
}
EXPORT_SYMBOL(input_register_handler);
从上面的代码可以看出注册handler主要完成两件事,首先将handler链接到input_handler_list链表,然后匹配input_dev和input_handler.在注册input_dev的时候需要匹配input_dev和input_handler,是遍历的handler的链表,表示从device来找handler。在注册input_handler的时候也需要匹配input_dev和input_handler,但是是遍历的dev的链表,表示是从handler来找device。
3. 设备驱动层实现原理
在Linux中,Input设备用input_dev结构体描述,定义在input.h中。设备的驱动只需按照如下步骤就可实现了。
1).在驱动模块加载函数中设置Input设备支持input子系统的哪些事件;
2).将Input设备注册到input子系统中;
3).在Input设备发生输入操作时(如:键盘被按下/抬起、触摸屏被触摸/抬起/移动、鼠标被移动/单击/抬起时等),提交所发生的事件及对应的键值/坐标等状态。