Chinaunix首页 | 论坛 | 博客

辉辉308appleguet.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

apple_guet

  • 博客访问： 1835606
  • 博文数量： 134
  • 博客积分： 2488
  • 博客等级： 大尉
  • 技术积分： 7554
  • 用 户 组： 普通用户
  • 注册时间： 2011-02-26 21:19
个人简介

1.每日自省； 2.享受人生； 3.尽力而为； 4.坚持不懈； 5.切莫急躁； 6.慎言敏行； 7.动心忍性； 8.上善若水。

文章分类

全部博文（134）

文章存档

2014年（38）

2013年（42）

2012年（15）

2011年（39）

我的朋友
最近访客
推荐博文
相关博文
input子系统(三)--input核心

分类： LINUX

2014-04-09 11:20:24

一、input子系统简介

1.1、input子系统原理

        在Linux中，输 入子系统是由输入子系统设备驱动层、输入子系统核心层(Input Core)和输入子系统事件处理层(Event Handler)组成。其中设备驱动层提供对硬件各寄存器的读写访问和将底层硬件对用户输入访问的响应转换为标准的输入事件，再通过核心层提交给事件处理 层；而核心层对下提供了设备驱动层的编程接口，对上又提供了事件处理层的编程接口；而事件处理层就为我们用户空间的应用程序提供了统一访问设备的接口和驱 动层提交来的事件处理。所以这使得我们输入设备的驱动部分不在用关心对设备文件的操作，而是要关心对各硬件寄存器的操作和提交的输入事件。下面用图形来描述一下这三者的关系！
 
        从上图可以看出，对于设备驱动层，主要涉及结构体input_dev，对于核心层，主要涉及结构体handle，而对于事件层涉及到了结构体handler。接下来会对这三个结构体进行详细的描述。
        现在我们从设备模型来看下input子系统所处的位置： 

        从上图可以看出，input处于kernel层，input向下操作设备寄存器，向上提供了设备驱动程序操作的设备节点。

1.2、注册input核心

        这里所说的input核心，就是指input.c文件中提供的函数，包括1.1中涉及三个结构体的操作函数。
        在input.c文件中，有模块初始化和退出函数，如：

点击(此处)折叠或打开

  1. struct class input_class = {
  2.     .name        = "input",
  3.     .devnode    = input_devnode,
  4. };
  5. static int __init input_init(void)
  6. {
  7.     int err;

  9.     err = class_register(&input_class);
  10.     if (err) {
  11.         pr_err("unable to register input_dev class\n");
  12.         return err;
  13.     }

  15.     err = input_proc_init();
  16.     if (err)
  17.         goto fail1;

  19.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
  20.     if (err) {
  21.         pr_err("unable to register char major %d", INPUT_MAJOR);
  22.         goto fail2;
  23.     }

  25.     return 0;

  27.  fail2:    input_proc_exit();
  28.  fail1:    class_unregister(&input_class);
  29.     return err;
  30. }
  31. static void __exit input_exit(void)
  32. {
  33.     input_proc_exit();
  34.     unregister_chrdev(INPUT_MAJOR, "input");
  35.     class_unregister(&input_class);
  36. }
  37. subsys_initcall(input_init);
  38. module_exit(input_exit);

        说明：

        1) 这里初始化使用的是subsys_initcall，具有较高优先级。

        2) 在初始化中，首先注册了input类，实际就是在/sys/class目录下建立一个input目录。

        3) input的proc文件系统初始化。

        4) 静态注册设备号。

二、input_dev设备相关函数

        在上面“输入子系统图”中，最左边是设备驱动层，其中涉及结构体input_dev，现在就来讲述其中涉及到的结构体和操作函数。

2.1、input_dev结构体简述

点击(此处)折叠或打开

  1. #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
  2. #define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
  3. struct input_dev {
  4.     const char *name;
  5.     const char *phys;
  6.     const char *uniq;
  7.     struct input_id id;

  9.     unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

  11.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
  12.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
  13.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
  14.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
  15.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
  16.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
  17.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
  18.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
  19.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];

  21.     unsigned int hint_events_per_packet;

  23.     unsigned int keycodemax;
  24.     unsigned int keycodesize;
  25.     void *keycode;

  27.     int (*setkeycode)(struct input_dev *dev,
  28.              const struct input_keymap_entry *ke,
  29.              unsigned int *old_keycode);
  30.     int (*getkeycode)(struct input_dev *dev,
  31.              struct input_keymap_entry *ke);

  33.     struct ff_device *ff;

  35.     unsigned int repeat_key;
  36.     struct timer_list timer;

  38.     int rep[REP_CNT];

  40.     struct input_mt_slot *mt;
  41.     int mtsize;
  42.     int slot;
  43.     int trkid;

  45.     struct input_absinfo *absinfo;

  47.     unsigned long key[BITS_TO_LONGS(KEY_CNT)];
  48.     unsigned long led[BITS_TO_LONGS(LED_CNT)];
  49.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];
  50.     unsigned long sw[BITS_TO_LONGS(SW_CNT)];

  52.     int (*open)(struct input_dev *dev);
  53.     void (*close)(struct input_dev *dev);
  54.     int (*flush)(struct input_dev *dev, struct file *file);
  55.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

  57.     struct input_handle __rcu *grab;

  59.     spinlock_t event_lock;
  60.     struct mutex mutex;

  62.     unsigned int users;
  63.     bool going_away;

  65.     bool sync;

  67.     struct device dev;

  69.     struct list_head    h_list;
  70.     struct list_head    node;
  71. };

        说明：

        1) 结构体中包括名称、id和链表等。

        2) 结构体中有很多数组，数组成员大小使用宏BITS_TO_LONGS计算。

        3) 因为这些数组中，每个成员中的一位代表一种类型，所以此处就是根据其支持最多的类型，计算出数组中需要几个成员。

2.2、分配input_dev设备函数：input_allocate_device()

点击(此处)折叠或打开

  1. struct input_dev *input_allocate_device(void)
  2. {
  3.     struct input_dev *dev;

  5.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
  6.     if (dev) {
  7.         dev->dev.type = &input_dev_type;
  8.         dev->dev.class = &input_class;
  9.         device_initialize(&dev->dev);
  10.         mutex_init(&dev->mutex);
  11.         spin_lock_init(&dev->event_lock);
  12.         INIT_LIST_HEAD(&dev->h_list);
  13.         INIT_LIST_HEAD(&dev->node);

  15.         __module_get(THIS_MODULE);
  16.     }

  18.     return dev;
  19. }

        说明：

        1) 首先申请了结构体input_dev内存。

        2) 如果申请成功，对其成员进行初始化，包括对设备的类型和类初始化，设备的类属于input，则其会显示在/sys/class/input目录下。

        3) 对input设备中的设备进行初始化。

        4) 初始化互斥锁和链表。

2.3、注册input_dev设备函数：input_register_device()

点击(此处)折叠或打开

  1. 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;

  8.     /* Every input device generates EV_SYN/SYN_REPORT events. */
  9.     __set_bit(EV_SYN, dev->evbit);

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

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

  17.     if (!dev->hint_events_per_packet)
  18.         dev->hint_events_per_packet =
  19.                 input_estimate_events_per_packet(dev);

  21.     /*
  22.      * If delay and period are pre-set by the driver, then autorepeating
  23.      * is handled by the driver itself and we don't do it in input.c.
  24.      */
  25.     init_timer(&dev->timer);
  26.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
  27.         dev->timer.data = (long) dev;
  28.         dev->timer.function = input_repeat_key;
  29.         dev->rep[REP_DELAY] = 250;
  30.         dev->rep[REP_PERIOD] = 33;
  31.     }

  33.     if (!dev->getkeycode)
  34.         dev->getkeycode = input_default_getkeycode;

  36.     if (!dev->setkeycode)
  37.         dev->setkeycode = input_default_setkeycode;

  39.     dev_set_name(&dev->dev, "input%ld",
  40.          (unsigned long) atomic_inc_return(&input_no) - 1);

  42.     error = device_add(&dev->dev);
  43.     if (error)
  44.         return error;

  46.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
  47.     pr_info("%s as %s\n",
  48.         dev->name ? dev->name : "Unspecified device",
  49.         path ? path : "N/A");
  50.     kfree(path);

  52.     error = mutex_lock_interruptible(&input_mutex);
  53.     if (error) {
  54.         device_del(&dev->dev);
  55.         return error;
  56.     }

  58.     list_add_tail(&dev->node, &input_dev_list);

  60.     list_for_each_entry(handler, &input_handler_list, node)
  61.         input_attach_handler(dev, handler);

  63.     input_wakeup_procfs_readers();

  65.     mutex_unlock(&input_mutex);

  67.     return 0;
  68. }

        说明：

        1) 首先设置，支持同步。

        2) 初始化延时定时器，初始化其成员变量。

        3) 初始化设备dev成员。

        4) 将input设备中的链表链入input设备全局链表input_dev_list中。

        5) 遍历链表input_handler_list，由于input设备注册先执行，所以此处input_handler链表为空，不执行input_attach_handler(dev, handler);。
        接下来看下定时器到时执行函数input_repeat_key()：

点击(此处)折叠或打开

  1. /*
  2.  * Generate software autorepeat event. Note that we take
  3.  * dev->event_lock here to avoid racing with input_event
  4.  * which may cause keys get "stuck".
  5.  */
  6. static void input_repeat_key(unsigned long data)
  7. {
  8.     struct input_dev *dev = (void *) data;
  9.     unsigned long flags;

  11.     spin_lock_irqsave(&dev->event_lock, flags);

  13.     if (test_bit(dev->repeat_key, dev->key) &&
  14.      is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {

  16.         input_pass_event(dev, EV_KEY, dev->repeat_key, 2);

  18.         if (dev->sync) {
  19.             /*
  20.              * Only send SYN_REPORT if we are not in a middle
  21.              * of driver parsing a new hardware packet.
  22.              * Otherwise assume that the driver will send
  23.              * SYN_REPORT once it's done.
  24.              */
  25.             input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
  26.         }

  28.         if (dev->rep[REP_PERIOD])
  29.             mod_timer(&dev->timer, jiffies +
  30.                     msecs_to_jiffies(dev->rep[REP_PERIOD]));
  31.     }

  33.     spin_unlock_irqrestore(&dev->event_lock, flags);
  34. }
        说明：
        1) 在触摸屏中，该函数在持续触摸状态下会被调用。即如果触摸屏一直被按下，那么每隔定时时间到达，此函数即被执行。
        2) 首先上自旋锁，保护临界区。
        3) 判断是否支持按键事件。
        4) 报告按键值，如果此次支持同步，向应用层报告同步事件。
        5) 如果设置了定时器重新启动周期，那么就重新启动定时器。

2.4、注销input设备函数input_unregister_device()

点击(此处)折叠或打开

  1. void input_unregister_device(struct input_dev *dev)
  2. {
  3.     struct input_handle *handle, *next;

  5.     input_disconnect_device(dev);

  7.     mutex_lock(&input_mutex);

  9.     list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
  10.         handle->handler->disconnect(handle);
  11.     WARN_ON(!list_empty(&dev->h_list));

  13.     del_timer_sync(&dev->timer);
  14.     list_del_init(&dev->node);

  16.     input_wakeup_procfs_readers();

  18.     mutex_unlock(&input_mutex);

  20.     device_unregister(&dev->dev);
  21. }

        说明：

        1) 注销函数是注册函数的相反过程。

        2) 主要就是删除注销函数中申请的资源。
        3) 调用handler中注册的断开函数。

三、handler相关函数

3.1、handler结构体简述

        handler结构体内容如下：

点击(此处)折叠或打开

  1. struct input_handler {

  3.     void *private;

  5.     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
  6.     bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
  7.     bool (*match)(struct input_handler *handler, struct input_dev *dev);
  8.     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
  9.     void (*disconnect)(struct input_handle *handle);
  10.     void (*start)(struct input_handle *handle);

  12.     const struct file_operations *fops;
  13.     int minor;
  14.     const char *name;

  16.     const struct input_device_id *id_table;

  18.     struct list_head    h_list;
  19.     struct list_head    node;
  20. }
        说明：
        1) handler结构体中定义了input回调函数，包括链接、释放事件函数等。
        2) 定义了应用层操作结构体。
        3) 定义了设备的次设备号。
        4) 定义了input设备ID表。
        5) 定义了链表。

3.2、注册handler函数input_register_handler()

        在讨论handler之前，先看一下input.c文件中的全局数组变量：static struct input_handler *input_table[8];。

        从上可以看到，此数组共有8个成员。在Linux中，最多可以支持8个handler，每个handler最多可以支持32个次设备。也即 32*8=256。那么在注册input_handler时，其成员.minor必须是32的倍数，即：0、32、64、96、128、160、192和 224。这些数是一个handler的次设备号的基址。
        handler注册程序如下：

点击(此处)折叠或打开

  1. int input_register_handler(struct input_handler *handler)
  2. {
  3.     struct input_dev *dev;
  4.     int retval;

  6.     retval = mutex_lock_interruptible(&input_mutex);
  7.     if (retval)
  8.         return retval;

  10.     INIT_LIST_HEAD(&handler->h_list);

  12.     if (handler->fops != NULL) {
  13.         if (input_table[handler->minor >> 5]) {
  14.             retval = -EBUSY;
  15.             goto out;
  16.         }
  17.         input_table[handler->minor >> 5] = handler;
  18.     }

  20.     list_add_tail(&handler->node, &input_handler_list);

  22.     list_for_each_entry(dev, &input_dev_list, node)
  23.         input_attach_handler(dev, handler);

  25.     input_wakeup_procfs_readers();

  27.  out:
  28.     mutex_unlock(&input_mutex);
  29.     return retval;
  30. }

        说明：

        1) 首先锁定互斥锁，然后初始化handler中的链表。

        2) 判断handler中是否有fops成员，如果有就按照次设备作为标识保存handler。

        3) 将handler的链表插入handler的全局链表input_handler_list中。

        4) 遍历input_dev_list设备链表，由2.2中知道，此时input设备链表中已经有成员了。

        5) 关联input设备和handler，程序如下：

点击(此处)折叠或打开

  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;

  6.     id = input_match_device(handler, dev);
  7.     if (!id)
  8.         return -ENODEV;

  10.     error = handler->connect(handler, dev, id);
  11.     if (error && error != -ENODEV)
  12.         pr_err("failed to attach handler %s to device %s, error: %d\n",
  13.          handler->name, kobject_name(&dev->dev.kobj), error);

  15.     return error;
  16. }

        说明：

        1) 首先查找匹配的设备。

        2) 调用handler的连接函数，也就是《input子系统(一)--GSC3280触摸屏驱动》中的tsdev_connect()函数。

        3) tsdev_connect()函数中使用input_register_handle()注册了handle。

四、handle相关函数

4.1、handle结构体简述

点击(此处)折叠或打开

  1. struct input_handle {

  3.     void *private;

  5.     int open;
  6.     const char *name;

  8.     struct input_dev *dev;
  9.     struct input_handler *handler;

  11.     struct list_head    d_node;
  12.     struct list_head    h_node;
  13. };
        说明：
        1) 结构体中定义私有指针和名称等。
        2) 定义input设备和handler指针。
        3) 定义链表。

4.2、handle注册函数input_register_handle()：

点击(此处)折叠或打开

  1. int input_register_handle(struct input_handle *handle)
  2. {
  3.     struct input_handler *handler = handle->handler;
  4.     struct input_dev *dev = handle->dev;
  5.     int error;

  7.     /*
  8.      * We take dev->mutex here to prevent race with
  9.      * input_release_device().
  10.      */
  11.     error = mutex_lock_interruptible(&dev->mutex);
  12.     if (error)
  13.         return error;

  15.     /*
  16.      * Filters go to the head of the list, normal handlers
  17.      * to the tail.
  18.      */
  19.     if (handler->filter)
  20.         list_add_rcu(&handle->d_node, &dev->h_list);
  21.     else
  22.         list_add_tail_rcu(&handle->d_node, &dev->h_list);

  24.     mutex_unlock(&dev->mutex);

  26.     /*
  27.      * Since we are supposed to be called from ->connect()
  28.      * which is mutually exclusive with ->disconnect()
  29.      * we can't be racing with input_unregister_handle()
  30.      * and so separate lock is not needed here.
  31.      */
  32.     list_add_tail_rcu(&handle->h_node, &handler->h_list);

  34.     if (handler->start)
  35.         handler->start(handle);

  37.     return 0;
  38. }

        说明：

        1) 函数分别将handle的链表插入到设备和handler的链表中。

五、input核心中触摸屏相关函数

4.1、input_set_abs_params()

点击(此处)折叠或打开

  1. struct input_absinfo {
  2.     __s32 value;
  3.     __s32 minimum;
  4.     __s32 maximum;
  5.     __s32 fuzz;
  6.     __s32 flat;
  7.     __s32 resolution;
  8. };
  9. void input_alloc_absinfo(struct input_dev *dev)
  10. {
  11.     if (!dev->absinfo)
  12.         dev->absinfo = kcalloc(ABS_CNT, sizeof(struct input_absinfo),
  13.                     GFP_KERNEL);

  15.     WARN(!dev->absinfo, "%s(): kcalloc() failed?\n", __func__);
  16. }
  17. void input_set_abs_params(struct input_dev *dev, unsigned int axis,
  18.              int min, int max, int fuzz, int flat)
  19. {
  20.     struct input_absinfo *absinfo;

  22.     input_alloc_absinfo(dev);
  23.     if (!dev->absinfo)
  24.         return;

  26.     absinfo = &dev->absinfo[axis];
  27.     absinfo->minimum = min;
  28.     absinfo->maximum = max;
  29.     absinfo->fuzz = fuzz;
  30.     absinfo->flat = flat;

  32.     dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);

  33. }        

       说明：
        1) 首先查看设备是否有absinfo结构体，如果没有，就申请。

        2) 对absinfo结构体初始化，设置其最大最小值。

        3) 设置input设备结构体中的absbit数组，表示对相应操作类型的支持。

4.2、报告事件函数

        input_report_abs()、input_report_key()和input_sync()等报告事件函数中，查看其函数体，最后都是调用input_event()函数，如下：

点击(此处)折叠或打开

  1. static inline int is_event_supported(unsigned int code,
  2.                  unsigned long *bm, unsigned int max)
  3. {
  4.     return code <= max && test_bit(code, bm);
  5. }
  6. void input_event(struct input_dev *dev,
  7.          unsigned int type, unsigned int code, int value)
  8. {
  9.     unsigned long flags;

  11.     if (is_event_supported(type, dev->evbit, EV_MAX)) {

  13.         spin_lock_irqsave(&dev->event_lock, flags);
  14.         add_input_randomness(type, code, value);
  15.         input_handle_event(dev, type, code, value);
  16.         spin_unlock_irqrestore(&dev->event_lock, flags);
  17.     }
  18. }

        说明：

        1) 首先判断是否支持此类型。

        2) 如果支持，调用input_handle_event(dev, type, code, value);函数。

点击(此处)折叠或打开

  1. static void input_handle_event(struct input_dev *dev,
  2.              unsigned int type, unsigned int code, int value)
  3. {
  4.     int disposition = INPUT_IGNORE_EVENT;

  6.     switch (type) {

  8.     case EV_SYN:
  9.         switch (code) {
  10.         case SYN_CONFIG:
  11.             disposition = INPUT_PASS_TO_ALL;
  12.             break;

  14.         case SYN_REPORT:
  15.             if (!dev->sync) {
  16.                 dev->sync = true;
  17.                 disposition = INPUT_PASS_TO_HANDLERS;
  18.             }
  19.             break;
  20.         case SYN_MT_REPORT:
  21.             dev->sync = false;
  22.             disposition = INPUT_PASS_TO_HANDLERS;
  23.             break;
  24.         }
  25.         break;

  27.     case EV_KEY:
  28.         if (is_event_supported(code, dev->keybit, KEY_MAX) &&
  29.          !!test_bit(code, dev->key) != value) {

  31.             if (value != 2) {
  32.                 __change_bit(code, dev->key);
  33.                 if (value)
  34.                     input_start_autorepeat(dev, code);
  35.                 else
  36.                     input_stop_autorepeat(dev);
  37.             }

  39.             disposition = INPUT_PASS_TO_HANDLERS;
  40.         }
  41.         break;

  43.     case EV_SW:
  44.         if (is_event_supported(code, dev->swbit, SW_MAX) &&
  45.          !!test_bit(code, dev->sw) != value) {

  47.             __change_bit(code, dev->sw);
  48.             disposition = INPUT_PASS_TO_HANDLERS;
  49.         }
  50.         break;

  52.     case EV_ABS:
  53.         if (is_event_supported(code, dev->absbit, ABS_MAX))
  54.             disposition = input_handle_abs_event(dev, code, &value);

  56.         break;

  58.     case EV_REL:
  59.         if (is_event_supported(code, dev->relbit, REL_MAX) && value)
  60.             disposition = INPUT_PASS_TO_HANDLERS;

  62.         break;

  64.     case EV_MSC:
  65.         if (is_event_supported(code, dev->mscbit, MSC_MAX))
  66.             disposition = INPUT_PASS_TO_ALL;

  68.         break;

  70.     case EV_LED:
  71.         if (is_event_supported(code, dev->ledbit, LED_MAX) &&
  72.          !!test_bit(code, dev->led) != value) {

  74.             __change_bit(code, dev->led);
  75.             disposition = INPUT_PASS_TO_ALL;
  76.         }
  77.         break;

  79.     case EV_SND:
  80.         if (is_event_supported(code, dev->sndbit, SND_MAX)) {

  82.             if (!!test_bit(code, dev->snd) != !!value)
  83.                 __change_bit(code, dev->snd);
  84.             disposition = INPUT_PASS_TO_ALL;
  85.         }
  86.         break;

  88.     case EV_REP:
  89.         if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
  90.             dev->rep[code] = value;
  91.             disposition = INPUT_PASS_TO_ALL;
  92.         }
  93.         break;

  95.     case EV_FF:
  96.         if (value >= 0)
  97.             disposition = INPUT_PASS_TO_ALL;
  98.         break;

  100.     case EV_PWR:
  101.         disposition = INPUT_PASS_TO_ALL;
  102.         break;
  103.     }

  105.     if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
  106.         dev->sync = false;

  108.     if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
  109.         dev->event(dev, type, code, value);

  111.     if (disposition & INPUT_PASS_TO_HANDLERS)
  112.         input_pass_event(dev, type, code, value);
  113. }

        说明：

        1) 我们拿EV_ABS事件作为例子，最后调用input_handle_abs_event(dev, code, &value);函数。

点击(此处)折叠或打开

  1. static int input_handle_abs_event(struct input_dev *dev,
  2.                  unsigned int code, int *pval)
  3. {
  4.     bool is_mt_event;
  5.     int *pold;

  7.     if (code == ABS_MT_SLOT) {
  8.         /*
  9.          * "Stage" the event; we'll flush it later, when we
  10.          * get actual touch data.
  11.          */
  12.         if (*pval >= 0 && *pval < dev->mtsize)
  13.             dev->slot = *pval;

  15.         return INPUT_IGNORE_EVENT;
  16.     }

  18.     is_mt_event = code >= ABS_MT_FIRST && code <= ABS_MT_LAST;

  20.     if (!is_mt_event) {
  21.         pold = &dev->absinfo[code].value;
  22.     } else if (dev->mt) {
  23.         struct input_mt_slot *mtslot = &dev->mt[dev->slot];
  24.         pold = &mtslot->abs[code - ABS_MT_FIRST];
  25.     } else {
  26.         /*
  27.          * Bypass filtering for multi-touch events when
  28.          * not employing slots.
  29.          */
  30.         pold = NULL;
  31.     }

  33.     if (pold) {
  34.         *pval = input_defuzz_abs_event(*pval, *pold,
  35.                         dev->absinfo[code].fuzz);
  36.         if (*pold == *pval)
  37.             return INPUT_IGNORE_EVENT;

  39.         *pold = *pval;
  40.     }

  42.     /* Flush pending "slot" event */
  43.     if (is_mt_event && dev->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
  44.         input_abs_set_val(dev, ABS_MT_SLOT, dev->slot);
  45.         input_pass_event(dev, EV_ABS, ABS_MT_SLOT, dev->slot);
  46.     }

  48.     return INPUT_PASS_TO_HANDLERS;
  49. }
  50. static void input_pass_event(struct input_dev *dev,
  51.              unsigned int type, unsigned int code, int value)
  52. {
  53.     struct input_handler *handler;
  54.     struct input_handle *handle;

  56.     rcu_read_lock();

  58.     handle = rcu_dereference(dev->grab);
  59.     if (handle)
  60.         handle->handler->event(handle, type, code, value);
  61.     else {
  62.         bool filtered = false;

  64.         list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
  65.             if (!handle->open)
  66.                 continue;

  68.             handler = handle->handler;
  69.             if (!handler->filter) {
  70.                 if (filtered)
  71.                     break;

  73.                 handler->event(handle, type, code, value);

  75.             } else if (handler->filter(handle, type, code, value))
  76.                 filtered = true;
  77.         }
  78.     }

  80.     rcu_read_unlock();
  81. }

        说明：

        1) 在input_handle_abs_event(dev, code, &value);函数中，调用input_pass_event()函数，该函数调用handler中的event函数，即《input子系统(一)--GSC3280触摸屏驱动》3.3中的tsdev_event()函数。


阅读(8531) | 评论(1) | 转发(2) |
1

上一篇：linux平台下 延迟工作队列实例

下一篇：[C] typeof

给主人留下些什么吧！~~

CU博客助理2014-06-12 10:28:21

专家点评：这篇文章写得相当精彩。博主画的input系统的结构图，以及主要代码的分析，足可体现博主对该系统的熟悉和理解。连我这个门外汉通过这篇文章，都可以明白input系统的大致结构。

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6