Linux Input子系统(2)--设备的注册和打开

最新推荐文章于 2021-11-06 12:15:29 发布
最新推荐文章于 2021-11-06 12:15:29 发布
阅读量536 收藏
点赞数
分类专栏： linux驱动

水平有限，描述不当之处还请指出，转载请注明出处http://blog.csdn.net/vanbreaker/article/details/7718158
        这节结合even handler来分析设备的注册和打开的过程，在设备注册之前，必须先初始化INPUT子系统，由input_init()函数来完成

[cpp] view plain copy print ?
  1. static int __init input_init(void) 
  2. { 
  3.     int err; 
  4.  
  5.     input_init_abs_bypass(); 
  6.  
  7.     err = class_register(&input_class);//注册input类 
  8.     if (err) { 
  9.         printk(KERN_ERR "input: unable to register input_dev class\n"); 
  10.         return err; 
  11.     } 
  12.  
  13.     err = input_proc_init();//创建/proc中的项 
  14.     if (err) 
  15.         goto fail1; 
  16.  
  17.     /*注册设备，设备号为INPUT_MAJOR(13),后面注册的输入设备都使用该主设备号*/ 
  18.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops); 
  19.     if (err) { 
  20.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR); 
  21.         goto fail2; 
  22.     } 
  23.  
  24.     return 0; 
  25.  
  26. fail2: input_proc_exit(); 
  27. fail1: class_unregister(&input_class); 
  28.     return err; 
  29. }  
static int __init input_init(void)
{
	int err;

	input_init_abs_bypass();

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

	err = input_proc_init();//创建/proc中的项
	if (err)
		goto fail1;

	/*注册设备，设备号为INPUT_MAJOR(13),后面注册的输入设备都使用该主设备号*/
	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_fops中只定义了open函数。

[csharp] view plain copy print ?
  1. static const struct file_operations input_fops = { 
  2.     .owner = THIS_MODULE, 
  3.     .open = input_open_file, 
  4. };  
static const struct file_operations input_fops = {
	.owner = THIS_MODULE,
	.open = input_open_file,
};

我们需要在设备驱动层中完成输入设备的注册，通过调用input_register_device()函数来完成，该函数的一个重要任务就是完成设备与事件驱动的匹配。

[cpp] view plain copy print ?
  1. <span style="font-size: 12px;">int input_register_device(struct input_dev *dev) 
  2. { 
  3.     static atomic_t input_no = ATOMIC_INIT(0); 
  4.     struct input_handler *handler; 
  5.     const char *path; 
  6.     int error; 
  7.  
  8.     __set_bit(EV_SYN, dev->evbit); 
  9.  
  10.     /*
  11.      * If delay and period are pre-set by the driver, then autorepeating
  12.      * is handled by the driver itself and we don't do it in input.c.
  13.      */ 
  14.  
  15.     init_timer(&dev->timer); 
  16.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  17.         dev->timer.data = (long) dev; 
  18.         dev->timer.function = input_repeat_key; 
  19.         dev->rep[REP_DELAY] = 250; 
  20.         dev->rep[REP_PERIOD] = 33; 
  21.     } 
  22.  
  23.     /*没有定义设备的getkeycode函数，则使用默认的获取键值函数*/ 
  24.     if (!dev->getkeycode) 
  25.         dev->getkeycode = input_default_getkeycode; 
  26.  
  27.     /*没有定义设备的setkeycode函数，则使用默认的设定键值函数*/ 
  28.     if (!dev->setkeycode) 
  29.         dev->setkeycode = input_default_setkeycode; 
  30.  
  31.     /*设定dev的名字*/ 
  32.     dev_set_name(&dev->dev, "input%ld", 
  33.              (unsigned long) atomic_inc_return(&input_no) - 1); 
  34.  
  35.     /*添加设备*/ 
  36.     error = device_add(&dev->dev); 
  37.     if (error) 
  38.         return error; 
  39.  
  40.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 
  41.     printk(KERN_INFO "input: %s as %s\n", 
  42.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  43.     kfree(path); 
  44.  
  45.     error = mutex_lock_interruptible(&input_mutex); 
  46.     if (error) { 
  47.         device_del(&dev->dev); 
  48.         return error; 
  49.     } 
  50.  
  51.     /*将设备添加到input_dev_list设备链表*/ 
  52.     list_add_tail(&dev->node, &input_dev_list); 
  53.  
  54.     /*遍历input_handler_list，试图与每一个handler进行匹配*/ 
  55.     list_for_each_entry(handler, &input_handler_list, node) 
  56.         input_attach_handler(dev, handler); 
  57.  
  58.     input_wakeup_procfs_readers(); 
  59.  
  60.     mutex_unlock(&input_mutex); 
  61.  
  62.     return 0; 
  63. }</span>  
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);

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

	/*没有定义设备的getkeycode函数，则使用默认的获取键值函数*/
	if (!dev->getkeycode)
		dev->getkeycode = input_default_getkeycode;

	/*没有定义设备的setkeycode函数，则使用默认的设定键值函数*/
	if (!dev->setkeycode)
		dev->setkeycode = input_default_setkeycode;

	/*设定dev的名字*/
	dev_set_name(&dev->dev, "input%ld",
		     (unsigned long) atomic_inc_return(&input_no) - 1);

	/*添加设备*/
	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;
	}

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

	/*遍历input_handler_list，试图与每一个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;
}

[cpp] view plain copy print ?
  1. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler) 
  2. { 
  3.     const struct input_device_id *id; 
  4.     int error; 
  5.  
  6.     /*如果定义了handler的黑名单，并且设备和黑名单中的id匹配了，则该设备不能和handler匹配*/ 
  7.     if (handler->blacklist && input_match_device(handler->blacklist, dev)) 
  8.         return -ENODEV; 
  9.  
  10.     id = input_match_device(handler->id_table, dev); 
  11.     if (!id) 
  12.         return -ENODEV; 
  13.  
  14.     /*执行handler的connect,建立handler与设备之间的联系*/ 
  15.     error = handler->connect(handler, dev, id); 
  16.     if (error && error != -ENODEV) 
  17.         printk(KERN_ERR 
  18.             "input: failed to attach handler %s to device %s, " 
  19.             "error: %d\n", 
  20.             handler->name, kobject_name(&dev->dev.kobj), error); 
  21.  
  22.     return error; 
  23. }  
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

	/*如果定义了handler的黑名单，并且设备和黑名单中的id匹配了，则该设备不能和handler匹配*/
	if (handler->blacklist && input_match_device(handler->blacklist, dev))
		return -ENODEV;

	id = input_match_device(handler->id_table, dev);
	if (!id)
		return -ENODEV;

	/*执行handler的connect,建立handler与设备之间的联系*/
	error = handler->connect(handler, dev, id);
	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;
}


匹配的具体过程：

[cpp] view plain copy print ?
  1. static const struct input_device_id *input_match_device(const struct input_device_id *id, 
  2.                             struct input_dev *dev) 
  3. { 
  4.     int i; 
  5.  
  6.     /*遍历handler的id_table与device进行匹配*/ 
  7.     for (; id->flags || id->driver_info; id++) { 
  8.  
  9.         /*根据flags的标志位，按需要匹配相应的字段*/ 
  10.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS) 
  11.             if (id->bustype != dev->id.bustype)//总线类型不匹配 
  12.                 continue; 
  13.  
  14.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)//生产厂商不匹配 
  15.             if (id->vendor != dev->id.vendor) 
  16.                 continue; 
  17.  
  18.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)//产品不匹配 
  19.             if (id->product != dev->id.product) 
  20.                 continue; 
  21.  
  22.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)//版本不匹配 
  23.             if (id->version != dev->id.version) 
  24.                 continue; 
  25.          
  26.         MATCH_BIT(evbit,  EV_MAX);//匹配所有的事件类型 
  27.  
  28.         /*匹配所有事件的子事件*/ 
  29.         MATCH_BIT(keybit, KEY_MAX); 
  30.         MATCH_BIT(relbit, REL_MAX); 
  31.         MATCH_BIT(absbit, ABS_MAX); 
  32.         MATCH_BIT(mscbit, MSC_MAX); 
  33.         MATCH_BIT(ledbit, LED_MAX); 
  34.         MATCH_BIT(sndbit, SND_MAX); 
  35.         MATCH_BIT(ffbit,  FF_MAX); 
  36.         MATCH_BIT(swbit,  SW_MAX); 
  37.  
  38.         return id;//匹配成功，返回id 
  39.     } 
  40.  
  41.     return NULL; 
  42. }  
static const struct input_device_id *input_match_device(const struct input_device_id *id,
							struct input_dev *dev)
{
	int i;

	/*遍历handler的id_table与device进行匹配*/
	for (; id->flags || id->driver_info; id++) {

		/*根据flags的标志位，按需要匹配相应的字段*/
		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);

		return id;//匹配成功，返回id
	}

	return NULL;
}


MATCH_BIT是将device的相应字段和handler的相应字段逐位对比，都一样的话表示成功，否则continue

[cpp] view plain copy print ?
  1. #define MATCH_BIT(bit, max) \ 
  2.         for (i = 0; i < BITS_TO_LONGS(max); i++) \ 
  3.             if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \ 
  4.                 break; \ 
  5.         if (i != BITS_TO_LONGS(max)) \ 
  6.             continue;  
#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;


以event handler为例，看connect函数做了什么：

[cpp] view plain copy print ?
  1. static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 
  2.              const struct input_device_id *id) 
  3. { 
  4.     struct evdev *evdev; 
  5.     int minor; 
  6.     int error; 
  7.  
  8.     /*在evdev_table中找到空闲块，其对应的数组下标再加上EVDEV_MINOR_BASE(64)就是次设备号
  9.       每个handler都拥有32个此设备号，也就是最多可以对应32个设备*/ 
  10.     for (minor = 0; minor < EVDEV_MINORS; minor++) 
  11.         if (!evdev_table[minor]) 
  12.             break; 
  13.  
  14.     if (minor == EVDEV_MINORS) { 
  15.         printk(KERN_ERR "evdev: no more free evdev devices\n"); 
  16.         return -ENFILE; 
  17.     } 
  18.  
  19.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 
  20.     if (!evdev) 
  21.         return -ENOMEM; 
  22.  
  23.     INIT_LIST_HEAD(&evdev->client_list); 
  24.     spin_lock_init(&evdev->client_lock); 
  25.     mutex_init(&evdev->mutex); 
  26.     init_waitqueue_head(&evdev->wait); 
  27.  
  28.     /*初始化evdev的内部变量*/ 
  29.     snprintf(evdev->name, sizeof(evdev->name), "event%d", minor); 
  30.     evdev->exist = 1; 
  31.     evdev->minor = minor; 
  32.  
  33.     /*初始化handle,每个evdev中都有一个handle*/ 
  34.     evdev->handle.dev = input_get_device(dev); 
  35.     evdev->handle.name = evdev->name; 
  36.     evdev->handle.handler = handler; 
  37.     evdev->handle.private = evdev; 
  38.  
  39.     /*初始化evdev中的内嵌device*/ 
  40.     dev_set_name(&evdev->dev, evdev->name); 
  41.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor); 
  42.     evdev->dev.class = &input_class; 
  43.     evdev->dev.parent = &dev->dev; 
  44.     evdev->dev.release = evdev_free; 
  45.     device_initialize(&evdev->dev); 
  46.  
  47.     /*注册handle,主要将handle链接到input_dev和handler的h_list链表中去*/ 
  48.     error = input_register_handle(&evdev->handle); 
  49.     if (error) 
  50.         goto err_free_evdev; 
  51.  
  52.     /*将evdev存入evdev_table数组*/ 
  53.     error = evdev_install_chrdev(evdev); 
  54.     if (error) 
  55.         goto err_unregister_handle; 
  56.  
  57.     error = device_add(&evdev->dev); 
  58.     if (error) 
  59.         goto err_cleanup_evdev; 
  60.  
  61.     return 0; 
  62.  
  63. err_cleanup_evdev: 
  64.     evdev_cleanup(evdev); 
  65. err_unregister_handle: 
  66.     input_unregister_handle(&evdev->handle); 
  67. err_free_evdev: 
  68.     put_device(&evdev->dev); 
  69.     return error; 
  70. }  
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_table中找到空闲块，其对应的数组下标再加上EVDEV_MINOR_BASE(64)就是次设备号
	  每个handler都拥有32个此设备号，也就是最多可以对应32个设备*/
	for (minor = 0; minor < EVDEV_MINORS; minor++)
		if (!evdev_table[minor])
			break;

	if (minor == EVDEV_MINORS) {
		printk(KERN_ERR "evdev: 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的内部变量*/
	snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);
	evdev->exist = 1;
	evdev->minor = minor;

	/*初始化handle,每个evdev中都有一个handle*/
	evdev->handle.dev = input_get_device(dev);
	evdev->handle.name = evdev->name;
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;

	/*初始化evdev中的内嵌device*/
	dev_set_name(&evdev->dev, evdev->name);
	evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev);

	/*注册handle,主要将handle链接到input_dev和handler的h_list链表中去*/
	error = input_register_handle(&evdev->handle);
	if (error)
		goto err_free_evdev;

	/*将evdev存入evdev_table数组*/
	error = evdev_install_chrdev(evdev);
	if (error)
		goto err_unregister_handle;

	error = device_add(&evdev->dev);
	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;
}


至此设备的注册完成！对应event handler,在/dev中将多出一个event(x)设备文件，对应一个evdev实例，应用程序打开它的话也就意味着通过event handler来和设备驱动层传递事件。

再来看打开设备的过程，还是以event handler为例，假如打开一个event(x),则先执行：

[cpp] view plain copy print ?
  1. static int input_open_file(struct inode *inode, struct file *file) 
  2. { 
  3.     struct input_handler *handler; 
  4.     const struct file_operations *old_fops, *new_fops = NULL; 
  5.     int err; 
  6.  
  7.     lock_kernel(); 
  8.     /* No load-on-demand here? */ 
  9.      
  10.     /*32个设备是共用一个handler的,通过此设备号得到设备对应的handler*/ 
  11.     handler = input_table[iminor(inode) >> 5]; 
  12.     if (!handler || !(new_fops = fops_get(handler->fops))) { 
  13.         err = -ENODEV; 
  14.         goto out; 
  15.     } 
  16.  
  17.     /*
  18.      * That's _really_ odd. Usually NULL ->open means "nothing special",
  19.      * not "no device". Oh, well...
  20.      */ 
  21.     if (!new_fops->open) { 
  22.         fops_put(new_fops); 
  23.         err = -ENODEV; 
  24.         goto out; 
  25.     } 
  26.     old_fops = file->f_op; 
  27.     /*定位fops*/ 
  28.     file->f_op = new_fops; 
  29.  
  30.     err = new_fops->open(inode, file); 
  31.  
  32.     if (err) { 
  33.         fops_put(file->f_op); 
  34.         file->f_op = fops_get(old_fops); 
  35.     } 
  36.     fops_put(old_fops); 
  37. out: 
  38.     unlock_kernel(); 
  39.     return err; 
  40. }  
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;

	lock_kernel();
	/* No load-on-demand here? */
	
	/*32个设备是共用一个handler的,通过此设备号得到设备对应的handler*/
	handler = input_table[iminor(inode) >> 5];
	if (!handler || !(new_fops = fops_get(handler->fops))) {
		err = -ENODEV;
		goto out;
	}

	/*
	 * That's _really_ odd. Usually NULL ->open means "nothing special",
	 * not "no device". Oh, well...
	 */
	if (!new_fops->open) {
		fops_put(new_fops);
		err = -ENODEV;
		goto out;
	}
	old_fops = file->f_op;
	/*定位fops*/
	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:
	unlock_kernel();
	return err;
}


通过此设备号所在的组(0~31)，(32~63),(64~95)……就可以找到相应的handler，所有的handler都保存在input_table中，对于次设备号在64~95范围的设备，将定位到下标为2的handler,，也就是event handler，然后将用handler中的open函数替代之前的open函数，并执行新的open函数，这样就以handler本身定义的open来打开设备完成相应的初始化了。

event handler中的open函数：

[cpp] view plain copy print ?
  1. static int evdev_open(struct inode *inode, struct file *file) 
  2. { 
  3.     struct evdev *evdev; 
  4.     struct evdev_client *client; 
  5.     int i = iminor(inode) - EVDEV_MINOR_BASE; 
  6.     int error; 
  7.  
  8.     if (i >= EVDEV_MINORS) 
  9.         return -ENODEV; 
  10.  
  11.     error = mutex_lock_interruptible(&evdev_table_mutex); 
  12.     if (error) 
  13.         return error; 
  14.     /*从evdev_table中取出和此设备号对应的evdev实例*/ 
  15.     evdev = evdev_table[i]; 
  16.     if (evdev) 
  17.         get_device(&evdev->dev); 
  18.     mutex_unlock(&evdev_table_mutex); 
  19.  
  20.     if (!evdev) 
  21.         return -ENODEV; 
  22.  
  23.     /*每当一个应用程序打开该文件都会生成一个client*/ 
  24.     client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL); 
  25.     if (!client) { 
  26.         error = -ENOMEM; 
  27.         goto err_put_evdev; 
  28.     } 
  29.  
  30.     spin_lock_init(&client->buffer_lock); 
  31.     client->evdev = evdev; 
  32.     /*将client链入evdev的client_list中*/ 
  33.     evdev_attach_client(evdev, client); 
  34.  
  35.     error = evdev_open_device(evdev); 
  36.     if (error) 
  37.         goto err_free_client; 
  38.  
  39.     file->private_data = client; 
  40.     return 0; 
  41.  
  42. err_free_client: 
  43.     evdev_detach_client(evdev, client); 
  44.     kfree(client); 
  45. err_put_evdev: 
  46.     put_device(&evdev->dev); 
  47.     return error; 
  48. }  
static int evdev_open(struct inode *inode, struct file *file)
{
	struct evdev *evdev;
	struct evdev_client *client;
	int i = iminor(inode) - EVDEV_MINOR_BASE;
	int error;

	if (i >= EVDEV_MINORS)
		return -ENODEV;

	error = mutex_lock_interruptible(&evdev_table_mutex);
	if (error)
		return error;
	/*从evdev_table中取出和此设备号对应的evdev实例*/
	evdev = evdev_table[i];
	if (evdev)
		get_device(&evdev->dev);
	mutex_unlock(&evdev_table_mutex);

	if (!evdev)
		return -ENODEV;

	/*每当一个应用程序打开该文件都会生成一个client*/
	client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
	if (!client) {
		error = -ENOMEM;
		goto err_put_evdev;
	}

	spin_lock_init(&client->buffer_lock);
	client->evdev = evdev;
	/*将client链入evdev的client_list中*/
	evdev_attach_client(evdev, client);

	error = evdev_open_device(evdev);
	if (error)
		goto err_free_client;

	file->private_data = client;
	return 0;

 err_free_client:
	evdev_detach_client(evdev, client);
	kfree(client);
 err_put_evdev:
	put_device(&evdev->dev);
	return error;
}


[cpp] view plain copy print ?
  1. static int evdev_open_device(struct evdev *evdev) 
  2. { 
  3.     int retval; 
  4.  
  5.     retval = mutex_lock_interruptible(&evdev->mutex); 
  6.     if (retval) 
  7.         return retval; 
  8.  
  9.     if (!evdev->exist) 
  10.         retval = -ENODEV; 
  11.     else if (!evdev->open++) {/*如果是第一次打开该设备，则要执行设备中定义的open*/ 
  12.         retval = input_open_device(&evdev->handle); 
  13.         if (retval) 
  14.             evdev->open--; 
  15.     } 
  16.  
  17.     mutex_unlock(&evdev->mutex); 
  18.     return retval; 
  19. }  
static int evdev_open_device(struct evdev *evdev)
{
	int retval;

	retval = mutex_lock_interruptible(&evdev->mutex);
	if (retval)
		return retval;

	if (!evdev->exist)
		retval = -ENODEV;
	else if (!evdev->open++) {/*如果是第一次打开该设备，则要执行设备中定义的open*/
		retval = input_open_device(&evdev->handle);
		if (retval)
			evdev->open--;
	}

	mutex_unlock(&evdev->mutex);
	return retval;
}


[cpp] view plain copy print ?
  1. int input_open_device(struct input_handle *handle) 
  2. { 
  3.     struct input_dev *dev = handle->dev; 
  4.     int retval; 
  5.  
  6.     retval = mutex_lock_interruptible(&dev->mutex); 
  7.     if (retval) 
  8.         return retval; 
  9.  
  10.     if (dev->going_away) { 
  11.         retval = -ENODEV; 
  12.         goto out; 
  13.     } 
  14.  
  15.     handle->open++; 
  16.  
  17.     if (!dev->users++ && dev->open) 
  18.         retval = dev->open(dev);//执行input_dev中定义的open，完成设备的初始化 
  19.  
  20.     if (retval) { 
  21.         dev->users--; 
  22.         if (!--handle->open) { 
  23.             /*
  24.              * Make sure we are not delivering any more events
  25.              * through this handle
  26.              */ 
  27.             synchronize_rcu(); 
  28.         } 
  29.     } 
  30.  
  31. out: 
  32.     mutex_unlock(&dev->mutex); 
  33.     return retval; 
  34. } 

 

emtribe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【分析笔记】Linux input 子系统原理分析
lovemengx的博客
08-13 1153
本文主要分析 Linux 子系统的实现原理。
Linux V4L2子系统-应用层访问video设备（四）-test ok
最新发布
小硕算法工程师
07-31 415
V4L2子系统向上提供了很多访问Video设备的接口，应用程序可以通过系统调用访问Video设备。但由于Video设备千差万别，很少有设备驱动程序能支持所有的接口功能，因此在使用之前，需要了解设备驱动程序支持的功能。
Linux Input子系统--设备的注册和打开
系统运维
07-05 112
水平有限，描述不当之处还请指出，转载请注明出处http://blog.csdn.net/vanbreaker/article/details/7718158 这节结合even handler来分析设备的注册和打开的过程，在设备注册之前，必须先初始化INPUT子系统，由input_init()函数来完成 static int __init input_init(void) { int e...
linux设备启动,[ 总结 ] Linux系统启动流程
weixin_39959298的博客
05-06 279
Linux系统启动过程分析：按下电源 --> BIOS自检 --> 系统引导(lilo/grub) --> 启动内核 --> 初始化系统 --> 用户登录1. BIOS自检：BIOS(basic input/output system), 又称基本输入输出系统，可以视为永久的记录在ROM中的一个软件，是操作系统输入输出管理的一部分。BIOS的功能分为两种：POST码和...
[android] 从上至下深入分析]输入子系统---设备注册(框架部分)
05-07 160
我们在上一遍看了输入子系统的启动流程,最后,我们看到运行了两个线程: mDispatcherThread->run  mReaderThread->run. 单从字面上来理解,一个是分发线程,另一个是读取线程.没有读取哪来分发?接下来我们先看一下读取线程是干了什么. InputReader.cpp bool InputReaderThread::threadLoop() { m
input子系统学习(1)
u012444155的专栏
03-22 490
input子系统学习进行简单的总结。先看driver/input/input.c 入口函数input_init 点击(此处)折叠或打开 static int __init input_init(void) {    //此函数主要代码     input_init_abs_bypass();     err = class_regis
input分析linux,Linux input子系统框架分析
weixin_32204687的博客
05-14 244
subsys_initcall(input_init) /* 在kernel启动时候加载，进入input_init函数*/static int __init input_init(void) /* input系统的入口函数*//*input_init分析之第1部分*/1、err = class_register(&input_class); /*注册class类*/__class_r...
linux input输入子系统分析《一》：初识input输入子系统 - CSDN博客1
08-04
3. **注册设备**：使用`input_register_device()`函数将设备注册到输入子系统，使其能够被用户空间访问。 4. **处理中断事件**：在中断处理函数中，将硬件事件转换为内核可识别的格式，并调用`input_report_*()`...
Linux设备模型之input子系统详解.doc
02-24
input子系统的主要功能包括事件处理、设备注册和注销、设备状态报告等。 一、input子系统概述 input子系统负责接收来自各个输入设备的事件，如按键按下、鼠标移动等，并将这些事件转化为统一的数据格式，供用户空间...
163 输入(input)子系统基础概念
engineer0的博客
11-06 1113
一、 统一管理外部输入设备，如： 按键 键盘 鼠标 触摸屏 … 用户空间接口 /dev/input/event0/1/2/… /dev/input/mouse0/1/2/…（鼠标） /dev/input/sj0/1/2/… … 分层模型 核心层 创建input设备类 根据输入设备种类、分发事件到不同事件处理器 事件处理层 包括各种事件处理器 提供具体设备的操作接口，为输入设备(input_dev结构体)创建具体设备文件。因此不需要我们再去为这些输入设备创建设备文件，事件处理层的对应的事件处理器会为我
Linux Kernel input设备之input设备注册
星空探索
03-13 1120
/**  * input_register_device - register device with input core  * @dev: device to be registered  *  * This function registers device with input core. The device must be  * allocated with input_al
linux input 子系统分析 三
窗外云天的专栏
09-14 8506
linux input子系统分析--子系统核心.事件处理层.事件传递过程 一.  输入子系统核心分析。     1.输入子系统核心对应与/drivers/input/input.c文件,这个也是作为一个模块注册到内核的。所以首先分析模块初始化函数。 static int
Linux input子系统分析
jansert的博客
01-05 436
Linux input子系统主要分为3层： input_device(设备驱动层) input_handle(核心层,即input_core) 和input_handler(事件处理层)。 所有的input子系统输入设备的主设备号都是13，input_core通过次设备号对输入设备进行分类管理，输入设备总共分为8类，每一类可包含最多32个次设备。 input子系统初始化： 1、in...
input 子系统的详解讲解到evdev
sunweizhong1024的专栏
05-22 3837
<!-- @page {margin:0.79in} p {margin-bottom:0.08in} --> error= input_register_device(mxt->input); */ intinput_register_device(structinput_dev *dev) { staticatomic_tinput_no =
input子系统详解4——输入事件驱动层源码分析
主要记录嵌入式学习与开发过程。
12-12 1742
以下内容源于朱有鹏嵌入式课程的学习与整理，如有侵权请告知删除。
手把手教你写Linux设备驱动---input子系统(一)--input事件应用程序的读写实现(基于友善之臂4412开发板)...
weixin_33851177的博客
04-09 547
这节，我们来说下input子系统，什么是input子系统? input子系统就是输入子系统。 输入子系统是 Linux内核用于管理各种输入设备 (键盘，鼠标，遥控杆，书写板等等 )的部分，用户通过输入子系统进行内核，命令行，图形接口之间的交换。输入子系统在内核里实现，因为设备经常要通过特定的硬件接口被访问 (例如串口， ps/2， ...
Linux驱动子系统之输入子系统(6)-gpio-keys
liaoye's blog
11-27 1万+
6．Gpio-keys 6.1 概述 l  Gpio-keys是基于input子系统实现的一个通用的GPIO按键驱动。工程中我们常常会利用它来写按键驱动。   l  gpio-keys驱动是基于platform来实现，platform driver(通用的部分)位于drivers/input/keyboard/gpio_keys.c，platform device通常和硬件有关，需要我们在
linux内核部件分析（二）——原子性操作atomic_t
热门推荐
qb_2008的专栏
10-02 2万+
在任何处理器平台下，都会有一些原子性操作，供操作系统使用，我们这里只讲x86下面的。在单处理器情况下，每条指令的执行都是原子性的，但在多处理器情况下，只有那些单独的读操作或写操作才是原子性的。为了弥补这一缺点，x86提供了附加的lock前缀，使带lock前缀的读修改写指令也能原子
input子系统分析：源码1. kernel-3.18\drivers\input\input.c
zhigouliu的博客
05-25 1037
/* * The input core * * Copyright (c) 1999-2002 Vojtech Pavlik */ /* * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public Licens...
Linux内核Input子系统驱动初始化详解
Linux内核Input子系统的初始化驱动架构是一个层次化的、灵活的设计，它允许系统动态地添加、删除和管理输入设备，同时也为用户空间提供了简单易用的接口来获取和处理输入事件。这种设计极大地增强了系统的可扩展性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值