Linux input子系统之核心层

最新推荐文章于 2024-03-07 07:00:00 发布

hwx1546

最新推荐文章于 2024-03-07 07:00:00 发布

阅读量733

点赞数

文章标签： linux 驱动开发 c语言

本文链接：https://blog.csdn.net/hwx1546/article/details/123312059

版权

上一节已经了解了input子系统的设备驱动层的驱动编写，本节就来讲解一下input子系统的核心层。input子系统的核心层有两个作用，对设备驱动层提供设备注册函数，对事件驱动层上报事件。
在这里插入图片描述

一、 input子系统初始化

static int __init input_init(void)
{
	int err;

	err = class_register(&input_class); // 注册类，类名为input
	if (err) {
		pr_err("unable to register input_dev class\n");
		return err;
	}

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

	err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
				     INPUT_MAX_CHAR_DEVICES, "input"); // 注册input子系统主设备号，主设备号为13，次设备号0
	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;
}

如果input子系统初始化成功，可以在系统中查看相关信息。
在这里插入图片描述

二、input核心层提供的设备接口函数

input设备结构体填充函数

struct input_dev *input_allocate_device(void)
{
	static atomic_t input_no = ATOMIC_INIT(-1);
	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_timer(&dev->timer);  // 初始化定时器
		INIT_LIST_HEAD(&dev->h_list); // 初始化链表头
		INIT_LIST_HEAD(&dev->node);

		dev_set_name(&dev->dev, "input%lu",
			     (unsigned long)atomic_inc_return(&input_no));

		__module_get(THIS_MODULE);
	}

	return dev;
}

input_allocate_device函数主要用来给input结构体分配内存空间并初始化一些成员变量。

设备事件类型和键值设置函数

void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
{
	switch (type) {  // 判断类型
	case EV_KEY: // 按键事件
		__set_bit(code, dev->keybit); // 设备键值
		break;

	case EV_REL: // 相对位置事件
		__set_bit(code, dev->relbit);
		break;

	case EV_ABS: // 绝对位置事件
		input_alloc_absinfo(dev);
		if (!dev->absinfo)
			return;

		__set_bit(code, dev->absbit);
		break;

	case EV_MSC: // 杂项类事件
		__set_bit(code, dev->mscbit);
		break;

	case EV_SW: // 开关事件
		__set_bit(code, dev->swbit);
		break;

	case EV_LED: // LED灯事件
		__set_bit(code, dev->ledbit);
		break;

	case EV_SND: // 声音类事件
		__set_bit(code, dev->sndbit);
		break;

	case EV_FF: // 压力事件
		__set_bit(code, dev->ffbit);
		break;

	case EV_PWR: // 电源事件
		/* do nothing */
		break;

	default:
		pr_err("input_set_capability: unknown type %u (code %u)\n",
		       type, code);
		dump_stack();
		return;
	}

	__set_bit(type, dev->evbit);
}

input_set_capability函数用来设置设备的输入类型和设备的键值。具体的设备类型和键值可以在include/uapi/linux/input.h可以查看。

设备注册函数

int input_register_device(struct input_dev *dev)
{
	struct input_devres *devres = NULL;
	struct input_handler *handler;
	unsigned int packet_size;
	const char *path;
	int error;

	if (dev->devres_managed) {
		devres = devres_alloc(devm_input_device_unregister,
				      sizeof(struct input_devres), GFP_KERNEL);
		if (!devres)
			return -ENOMEM;

		devres->input = dev;
	}

	/* Every input device generates EV_SYN/SYN_REPORT events. */
	__set_bit(EV_SYN, dev->evbit); // 设置同步信号

	/* KEY_RESERVED is not supposed to be transmitted to userspace. */
	__clear_bit(KEY_RESERVED, dev->keybit);

	/* Make sure that bitmasks not mentioned in dev->evbit are clean. */
	input_cleanse_bitmasks(dev);

	packet_size = input_estimate_events_per_packet(dev);
	if (dev->hint_events_per_packet < packet_size)
		dev->hint_events_per_packet = packet_size;

	dev->max_vals = dev->hint_events_per_packet + 2;
	dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
	if (!dev->vals) {
		error = -ENOMEM;
		goto err_devres_free;
	}

	/*
	 * 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.
	 */
	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;

	error = device_add(&dev->dev); // 注册设备
	if (error)
		goto err_free_vals;

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

	list_add_tail(&dev->node, &input_dev_list); // 将设备加入到input设备链表

	list_for_each_entry(handler, &input_handler_list, node) // 遍历事件层的input_handler链表
		input_attach_handler(dev, handler); // 将设备与input_handler进行匹配

	input_wakeup_procfs_readers();

	mutex_unlock(&input_mutex);

	if (dev->devres_managed) {
		dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
			__func__, dev_name(&dev->dev));
		devres_add(dev->dev.parent, devres);
	}
	return 0;

err_device_del:
	device_del(&dev->dev);
err_free_vals:
	kfree(dev->vals);
	dev->vals = NULL;
err_devres_free:
	devres_free(devres);
	return error;
}

input_register_device函数主要是将设备注册到input_handler_list链表中，同时遍历input_handler_list链表，寻找设备是否能够与事件层匹配。

事件层处理与设备匹配函数

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); // 将设备与handler进行匹配
	if (!id)
		return -ENODEV;

	error = handler->connect(handler, dev, id); // 如果匹配到就调用事件层的connect函数
	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_attach_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;

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

		if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
			continue;

		if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
			continue;

		if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
			continue;

		if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
			continue;

		if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
			continue;

		if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
			continue;

		if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
			continue;

		if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
			continue;

		if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
			continue;

		if (!handler->match || handler->match(handler, dev))
			return id;
	}

	return NULL;
}

input_match_device函数是做具体的匹配工作，它会根据事件层定义的一些标志位进行匹配。

input设备注销函数

void input_unregister_device(struct input_dev *dev)
{
	if (dev->devres_managed) {
		WARN_ON(devres_destroy(dev->dev.parent,
					devm_input_device_unregister,
					devm_input_device_match,
					dev));
		__input_unregister_device(dev);
		/*
		 * We do not do input_put_device() here because it will be done
		 * when 2nd devres fires up.
		 */
	} else {
		__input_unregister_device(dev);
		input_put_device(dev);
	}
}

事件上报函数

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

		spin_lock_irqsave(&dev->event_lock, flags);
		input_handle_event(dev, type, code, value);
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
}

input_event函数是input子系统提供给开发人员上报事件类型和键值的函数，除此之外内核还根据不同事件类型对input_event进行封装。延伸出了不同的事件上报函数

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

static inline void input_mt_sync(struct input_dev *dev)
{
	input_event(dev, EV_SYN, SYN_MT_REPORT, 0);
}

hwx1546

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Linux input子系统之核心层

上一节已经了解了input子系统的设备驱动层的驱动编写，本节就来讲解一下input子系统的核心层。input子系统的核心层有两个作用，对设备驱动层提供设备注册函数，对事件驱动层上报事件。一、 input子系统初始化static int __init input_init(void){ int err; err = class_register(&input_class); // 注册类，类名为input if (err) { pr_err("unable to registe
复制链接

扫一扫