51CTO首页
AI.x社区
博客
学堂
精品班
软考社区
免费课
企业培训
鸿蒙开发者社区
WOT技术大会
IT证书
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术24年11月软考PMP项目管理免费题库
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO软考
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
51CTO软考题库
账号设置 退出

Linux驱动 | input 子系统详解

作者：土豆居士
系统 Linux
Linux输入设备种类繁杂，常见的包括触摸屏、键盘、鼠标、摇杆等;这些输入设备属于字符设备，而linux将这些设备的共同特性抽象出来，Linux input 子系统就产生了。

[[420659]]

1. 模块概述

1.1.相关资料和代码研究

  1. drivers/input/ 
  2. include/uapi/linux/input-event-codes.h 

2. 模块功能

linux核心的输入框架

3. 模块学习

3.1.概述

Linux输入设备种类繁杂，常见的包括触摸屏、键盘、鼠标、摇杆等;这些输入设备属于字符设备，而linux将这些设备的共同特性抽象出来，Linux input 子系统就产生了。

3.2.软件架构

输入子系统是由设备驱动层(input driver)、输入核心层(input core)、输入事件处理层(input event handle)组成，具体架构如图4.1所示：

(1)input设备驱动层：负责具体的硬件设备，将底层的硬件输入转化为统一的事件形式，向input核心层和汇报;*(2)input核心层：连接input设备驱动层与input事件处理层，向下提供驱动层的接口，向上提供事件处理层的接口;*(3)input事件处理层：为不同硬件类型提供了用户访问以及处理接口，将硬件驱动层传来的事件报告给用户程序。

在input子系统中，每个事件的发生都使用事件(type)->子事件(code)->值(value) 所有的输入设备的主设备号都是13，input-core通过次设备来将输入设备进行分类，如0-31是游戏杆，32-63是鼠标(对应Mouse Handler)、64-95是事件设备(如触摸屏，对应Event Handler)。

Linux输入子系统支持的数据类型

定义的按键值

  1. #define KEY_RESERVED           0 
  2. #define KEY_ESC                 1 
  3. #define KEY_1                   2 
  4. #define KEY_2                   3 
  5. #define KEY_3                   4 
  6. #define KEY_4                   5 
  7. #define KEY_5                   6 
  8. #define KEY_6                   7 
  9. #define KEY_7                   8 
  10. #define KEY_8                   9 
  11. #define KEY_9                   10 
  12. #define KEY_0                   11 
  13. ... 

3.3.数据结构

三个数据结构input_dev，input_handle，input_handler之间的关系如图4.2、4.3所示

  1. input_dev：是硬件驱动层，代表一个input设备。 
  2. input_handler：是事件处理层，代表一个事件处理器。 
  3. input_handle：属于核心层，代表一个配对的input设备与input事件处理器。 
  4. input_dev 通过全局的input_dev_list链接在一起，设备注册的时候完成这个操作。 

input_handler 通过全局的input_handler_list链接在一起。事件处理器注册的时候实现了这个操作(事件处理器一般内核自带，不需要我们来写)

input_hande 没有一个全局的链表，它注册的时候将自己分别挂在了input_dev 和 input_handler 的h_list上了。通过input_dev 和input_handler就可以找到input_handle在设备注册和事件处理器，注册的时候都要进行配对工作，配对后就会实现链接。通过input_handle也可以找到input_dev和input_handler。

我们可以看到，input_device和input_handler中都有一个h_list,而input_handle拥有指向input_dev和input_handler的指针，也就是说input_handle是用来关联input_dev和input_handler的。

那么为什么一个input_device和input_handler中拥有的是h_list而不是一个handle呢?因为一个device可能对应多个handler,而一个handler也不能只处理一个device,比如说一个鼠标，它可以对应even handler，也可以对应mouse handler,因此当其注册时与系统中的handler进行匹配，就有可能产生两个实例，一个是evdev,另一个是mousedev,而任何一个实例中都只有一个handle。至于以何种方式来传递事件，就由用户程序打开哪个实例来决定。后面一个情况很容易理解，一个事件驱动不能只为一个甚至一种设备服务，系统中可能有多种设备都能使用这类handler,比如event handler就可以匹配所有的设备。在input子系统中，有8种事件驱动，每种事件驱动最多可以对应32个设备，因此dev实例总数最多可以达到256个

3.3.1. Input_dev

输入设备

  1. /* include/linux/input.h */ 
  2. struct input_dev { 
  3.      const char *name;  /* 设备名称 */ 
  4.      const char *phys;  /* 设备在系统中的路径 */ 
  5.      const char *uniq;  /* 设备唯一id */ 
  6.      struct input_id id;  /* input设备id号 */ 
  7.  
  8.      unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; 
  9.  
  10.      unsigned long evbit[BITS_TO_LONGS(EV_CNT)];  /* 设备支持的事件类型，主要有EV_SYNC，EV_KEY，EV_KEY,EV_REL,EV_ABS等*/  
  11. unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];  /* 按键所对应的位图 */ 
  12.      unsigned long relbit[BITS_TO_LONGS(REL_CNT)];  /* 相对坐标对应位图 */ 
  13.      unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];  /* 决定左边对应位图 */ 
  14.      unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];  /* 支持其他事件 */ 
  15.      unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];  /* 支持led事件 */ 
  16.      unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];  /* 支持声音事件 */ 
  17.      unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];  /* 支持受力事件 */ 
  18.      unsigned long swbit[BITS_TO_LONGS(SW_CNT)];  /* 支持开关事件 */ 
  19.  
  20.      unsigned int hint_events_per_packet;  /*  平均事件数*/ 
  21.  
  22.      unsigned int keycodemax;  /* 支持最大按键数 */ 
  23.      unsigned int keycodesize;  /* 每个键值字节数 */ 
  24.      void *keycode;  /* 存储按键值的数组的首地址 */ 
  25.  
  26.      int (*setkeycode)(struct input_dev *dev, 
  27.                  const struct input_keymap_entry *ke, unsigned int *old_keycode); 
  28.      int (*getkeycode)(struct input_dev *dev, struct input_keymap_entry *ke); 
  29.  
  30.      struct ff_device *ff;  /* 设备关联的反馈结构，如果设备支持 */ 
  31.  
  32.      unsigned int repeat_key;  /* 最近一次按键值，用于连击 */ 
  33.      struct timer_list timer;  /* 自动连击计时器 */ 
  34.  
  35.      int rep[REP_CNT];  /* 自动连击参数 */ 
  36.  
  37.      struct input_mt *mt;  /* 多点触控区域 */ 
  38.  
  39.      struct input_absinfo *absinfo;  /* 存放绝对值坐标的相关参数数组 */ 
  40.  
  41.      unsigned long key[BITS_TO_LONGS(KEY_CNT)];  /* 反应设备当前的案件状态 */ 
  42.      unsigned long led[BITS_TO_LONGS(LED_CNT)];  /* 反应设备当前的led状态 */ 
  43.      unsigned long snd[BITS_TO_LONGS(SND_CNT)];  /* 反应设备当前的声音状态 */ 
  44.      unsigned long sw[BITS_TO_LONGS(SW_CNT)];  /* 反应设备当前的开关状态 */ 
  45.  
  46.      int (*open)(struct input_dev *dev);  /* 第一次打开设备时调用，初始化设备用 */ 
  47.      void (*close)(struct input_dev *dev);  /* 最后一个应用程序释放设备事件，关闭设备 */ 
  48.      int (*flush)(struct input_dev *dev, struct file *file); /* 用于处理传递设备的事件 */ 
  49. int (*event)(struct input_dev *dev, unsigned int type, unsigned int code,          int value);  /* 事件处理函数，主要是接收用户下发的命令，如点亮led */ 
  50.  
  51.      struct input_handle __rcu *grab;  /* 当前占有设备的input_handle */ 
  52.  
  53.      spinlock_t event_lock;  /* 事件锁 */ 
  54.      struct mutex mutex;  /* 互斥体 */ 
  55.  
  56.      unsigned int users;  /* 打开该设备的用户数量（input_handle） */ 
  57.      bool going_away;  /* 标记正在销毁的设备 */ 
  58.  
  59.      struct device dev;  /* 一般设备 */ 
  60.  
  61.      struct list_head h_list;  /* 设备所支持的input handle */ 
  62.      struct list_head node;  /* 用于将此input_dev连接到input_dev_list */ 
  63.  
  64.      unsigned int num_vals;  /* 当前帧中排队的值数 */ 
  65.      unsigned int max_vals;  /*  队列最大的帧数*/ 
  66.      struct input_value *vals;  /*  当前帧中排队的数组*/ 
  67.  
  68.      bool devres_managed; /* 表示设备被devres 框架管理，不需要明确取消和释放*/ 
  69. }; 

3.3.2. Input_handler

处理具体的输入事件的具体函数

  1. /* include/linux/input.h */ 
  2. struct input_handler { 
  3.  
  4.      void *private;  /* 存放handle数据 */ 
  5.  
  6. void (*event)(struct input_handle *handle, unsigned int type, unsigned  int code, int value); 
  7.      void (*events)(struct input_handle *handle, 
  8.              const struct input_value *vals, unsigned int count); 
  9. bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value); 
  10.      bool (*match)(struct input_handler *handler, struct input_dev *dev); 
  11. int (*connect)(struct input_handler *handler, struct input_dev *dev, const  struct input_device_id *id); 
  12.      void (*disconnect)(struct input_handle *handle); 
  13.      void (*start)(struct input_handle *handle); 
  14.  
  15.      bool legacy_minors; 
  16.      int minor; 
  17.      const char *name;  /* 名字 */ 
  18.  
  19.      const struct input_device_id *id_table;  /* input_dev匹配用的id */ 
  20.  
  21. struct list_head h_list; /* 用于链接和handler相关的handle，input_dev与input_handler配对之后就会生成一个input_handle结构 */ 
  22.      struct list_head node;  /* 用于将该handler链入input_handler_list，链接所有注册到内核的所有注册到内核的事件处理器 */ 
  23. }; 

3.3.3. Input_handle

连接输入设备和处理函数

  1. /* include/linux/input.h */ 
  2. struct input_handle { 
  3.      void *private;  /* 数据指针 */ 
  4.  
  5.      int open;  /* 打开标志，每个input_handle 打开后才能操作 */ 
  6.      const char *name;  /* 设备名称 */ 
  7.  
  8.      struct input_dev *dev;  /* 指向所属的input_dev */ 
  9.      struct input_handler *handler;  /* 指向所属的input_handler */ 
  10.  
  11.      struct list_head d_node;  /* 用于链入所指向的input_dev的handle链表 */ 
  12.      struct list_head h_node;  /* 用于链入所指向的input_handler的handle链表 */ 
  13. }; 

3.3.4. Evdev

字符设备事件

  1. /* drivers/input/evdev.c */ 
  2. struct evdev { 
  3.      int open;    /* 设备被打开的计数 */ 
  4.      struct input_handle handle;  /* 关联的input_handle */  
  5.      wait_queue_head_t wait;  /* 等待队列，当前进程读取设备，没有事件产生时， 
  6. 进程就会sleep */ 
  7.      struct evdev_client __rcu *grab;  /* event响应 */ 
  8. struct list_head client_list;  /* evdev_client链表，说明evdev设备可以处理多个 evdev _client，可以有多个进程访问evdev设备 */ 
  9.      spinlock_t client_lock; 
  10.      struct mutex mutex; 
  11.      struct device dev; 
  12.      struct cdev cdev; 
  13.      bool exist;   /* 设备存在判断 */ 
  14. }; 

3.3.5. evdev_client

字符设备事件响应

  1. /* drivers/input/evdev.c */ 
  2. struct evdev_client { 
  3.      unsigned int head;  /* 动态索引，每加入一个event到buffer中，head++ */ 
  4.      unsigned int tail;  /* 动态索引，每取出一个buffer中到event，tail++ */ 
  5.      unsigned int packet_head;  /* 数据包头部 */ 
  6.      spinlock_t buffer_lock;   
  7.      struct fasync_struct *fasync;  /* 异步通知函数 */ 
  8.      struct evdev *evdev;   
  9.      struct list_head node;  /* evdev_client链表项 */ 
  10.      int clkid; 
  11.      unsigned int bufsize; 
  12.      struct input_event buffer[];  /* 用来存放input_dev事件缓冲区 */ 
  13. }; 

3.3.6. Evdev_handler

evdev_handler事件处理函数

  1. /* drivers/input/input.c */ 
  2. static struct input_handler evdev_handler = { 
  3.      .event  = evdev_event,   /* 事件处理函数， */   
  4.      .events = evdev_events,  /* 事件处理函数， */ 
  5.      .connect = evdev_connect, /* 连接函数，将事件处理和输入设备联系起来 */ 
  6.      .disconnect = evdev_disconnect,  /* 断开该链接 */ 
  7.      .legacy_minors = true, 
  8.      .minor  = EVDEV_MINOR_BASE, 
  9.      .name  = "evdev", /* handler名称 */ 
  10.      .id_table = evdev_ids, /* 断开该链接 */ 
  11. }; 

3.3.7. input_event

标准按键编码信息

  1. /* drivers/input/evdev.c */ 
  2. struct input_event {                                                             
  3.     struct timeval time;   /* 事件发生的时间  */                                 
  4.     __u16 type;             /* 事件类型 */                                       
  5.     __u16 code;             /* 事件码 */                                         
  6.     __s32 value;            /* 事件值 */                                         
  7. };    

3.3.8. input_id

和input输入设备相关的id信息

  1. /* include/uapi/linux/input.h */ 
  2. struct input_id {   
  3.     __u16 bustype;  /* 总线类型 */   
  4.     __u16 vendor;  /* 生产厂商 */   
  5.     __u16 product;  /* 产品类型 */  
  6.     __u16 version;  /* 版本 */ 
  7.  }; 

3.3.9. input_device_id

  1. /* include/uapi/linux/input.h */ 
  2. struct input_device_id { 
  3.  
  4.      kernel_ulong_t flags; 
  5.  
  6.      __u16 bustype;  /* 总线类型 */ 
  7.      __u16 vendor;  /* 生产厂商 */ 
  8.      __u16 product;  /* 产品类型 */ 
  9.      __u16 version;  /* 版本 */ 
  10.  
  11.      kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + 1]; 
  12.      kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + 1]; 
  13.      kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + 1]; 
  14.      kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + 1]; 
  15.      kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + 1]; 
  16.      kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + 1]; 
  17.      kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + 1]; 
  18.      kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + 1]; 
  19.      kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + 1]; 
  20.      kernel_ulong_t propbit[INPUT_DEVICE_ID_PROP_MAX / BITS_PER_LONG + 1]; 
  21.  
  22.      kernel_ulong_t driver_info; 
  23. }; 

3.3.10. input_even

输入事件的传递已input_event为基本单位

  1. struct input_event { 
  2.  struct timeval time; //时间戳 
  3.      __u16 type; //事件总类型 
  4.      __u16 code; //事件子类型 
  5.      __s32 value; //事件值 
  6. }; 

3.4. Linux input 子系统关键流程

核心层，执行的时候会注册设备号，然后在handler层注册input_handler，也就是evdev_handler会注册到核心层维护的链表中。

然后进行硬件初始化获取数据，而且需要将设备注册到链表中。注册进来就就会遍历input_handler_list链表，找到对应的handler，匹配成功后会调用connect方法。connect分配evdev，evdev就记录了input_handler和input_device之间的关系，同时创建设备节点，还会注册cdev从而可以让应用调用。

当应用程序调用open，read等接口的时候就会调用input_handler层实现的xxx_open，那么open就会分配好evdev_client，最终在input_dev层上报数据的时候会自动调用input_handler，input_handler就会调用events填充上报的数据到缓冲区client，此时如果没有唤醒队列的话应用read的时候会阻塞，而唤醒队列后最终使用copy_to_user来给应用数据。设备驱动程序上报事件的函数有：

  1. input_report_key //上报按键事件 
  2. input_report_rel //上报相对坐标事件 
  3. input_report_abs //上报绝对坐标事件 
  4. input_report_ff_status 
  5. input_report_switch 
  6. input_sync //上报完成后需要调用这些函数来通知系统处理完整事件  
  7. input_mt_sync //上报完成后需要调用这些函数来通知系统处理完整事件 

这些函数其实是input_event函数的封装，调用的都是input_event函数，在输入设备驱动(input_dev)中，一般通过轮询或中断方式获取输入事件的原始值(raw value)，经过处理后再使用input_event()函数上报;核心层将事件数据(type、code、value)打包、分发至事件处理器;调用关系为：input_event->input_handle_event->input_pass_values，这一函数都在input.c实现。

3.4.1. Input 设备注册流程

输入设备注册过程如图4.3所示

图4.3 输入设备注册流程图

3.4.2. 连接设备流程

连接设备流程如图4.4所示

图4.4 连接设备流程图

3.4.3. 事件上报流程

事件上报流程如图4.5所示

3.4.4. 数据读取流程

数据读取流程如图4.6所示

3.5.关键函数解析

3.5.1. input_init

input子系统使用subsys_initcall宏修饰input_init()函数在内核启动阶段被调用。input_init()函数在内核启动阶段被调用。input_init()函数的主要工作是：在sys文件系统下创建一个设备类(/sys/class/input)，调用register_chrdev()函数注册input设备。

  1. /* drivers/input/input.c */ 
  2. static int __init input_init(void) 
  3. { 
  4.      int err; 
  5.  
  6.      err = class_register(&input_class);  /* 注册类，放在sys/class下 */   
  7.      if (err) { 
  8.           pr_err("unable to register input_dev class\n"); 
  9.           return err; 
  10.      } 
  11.  
  12.      err = input_proc_init();  /* 在proc目录下建立相关目录 */ 
  13.      if (err) 
  14.           goto fail1; 
  15.  
  16.      err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0), 
  17.         INPUT_MAX_CHAR_DEVICES, "input");  /* 注册字符设备编号，INPUT_MAJOR   永远是13 */   
  18.      if (err) { 
  19.           pr_err("unable to register char major %d", INPUT_MAJOR); 
  20.           goto fail2; 
  21.      } 
  22.  
  23.      return 0; 
  24.  
  25.  fail2: input_proc_exit(); 
  26.  fail1: class_unregister(&input_class); 
  27.      return err; 
  28. } 

3.5.2. Input_register_device

  1. /* drivers/input/input.c */ 
  2. int input_register_device(struct input_dev *dev) 
  3. { 
  4.     struct atomic_t  input_no = ATOMIC_INIT(0); 
  5.      struct input_devres *devres = NULL; 
  6.      struct input_handler *handler; 
  7.      unsigned int packet_size; 
  8.      const char *path; 
  9.      int error; 
  10.  
  11.      if (dev->devres_managed) { 
  12.           devres = devres_alloc(devm_input_device_unregister, 
  13.                   sizeof(*devres), GFP_KERNEL); 
  14.       if (!devres) 
  15.            return -ENOMEM; 
  16.  
  17.       devres->input = dev; 
  18.  } 
  19.  
  20.      /* 每个input_device都会产生EV_SYN/SYN_REPORT时间，所以就放在一起设置 */ 
  21.      __set_bit(EV_SYN, dev->evbit); 
  22.  
  23.      /* KEY_RESERVED is not supposed to be transmitted to userspace. */ 
  24.      __clear_bit(KEY_RESERVED, dev->keybit); 
  25.  
  26.      /* 没有设置的位，确保被清零 */ 
  27.      input_cleanse_bitmasks(dev); 
  28.      /*  */ 
  29.      packet_size = input_estimate_events_per_packet(dev); 
  30.      if (dev->hint_events_per_packet < packet_size) 
  31.            dev->hint_events_per_packet = packet_size; 
  32.  
  33.      dev->max_vals = dev->hint_events_per_packet + 2; 
  34.      dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL); 
  35.      if (!dev->vals) { 
  36.           error = -ENOMEM; 
  37.           goto err_devres_free; 
  38.      } 
  39.  
  40.     /* 如果延时周期是程序预先设定的，那么是由驱动自动处理，主要是为了处理重复按键 */ 
  41.      init_timer(&dev->timer); 
  42.      if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  43.           dev->timer.data = (long) dev; 
  44.           dev->timer.function = input_repeat_key; 
  45.           dev->rep[REP_DELAY] = 250; 
  46.           dev->rep[REP_PERIOD] = 33; 
  47.       } 
  48.  
  49.      if (!dev->getkeycode)  /* 获取按键值 */ 
  50.           dev->getkeycode = input_default_getkeycode; 
  51.  
  52.      if (!dev->setkeycode)  /* 设置按键值 */ 
  53.           dev->setkeycode = input_default_setkeycode; 
  54.  
  55.      error = device_add(&dev->dev);  /* 将dev注册到sys */ 
  56.      if (error) 
  57.           goto err_free_vals; 
  58.  
  59.      path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 
  60.      pr_info("%s as %s\n", 
  61.       dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  62.      kfree(path); 
  63.  
  64.      error = mutex_lock_interruptible(&input_mutex); 
  65.      if (error) 
  66.           goto err_device_del; 
  67.  
  68.      list_add_tail(&dev->node, &input_dev_list);  /* 将新的dev放入链表中 */ 
  69. /* 遍历input_handler_list链表中的所有input_handler，是否支持这个新input_dev ； 
  70. 若两者支持，便进行连接 */ 
  71.      list_for_each_entry(handler, &input_handler_list, node) 
  72.       input_attach_handler(dev, handler);  
  73.  
  74.      input_wakeup_procfs_readers(); 
  75.  
  76.      mutex_unlock(&input_mutex); 
  77.  
  78.      if (dev->devres_managed) { 
  79.       dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n", 
  80.            __func__, dev_name(&dev->dev)); 
  81.       devres_add(dev->dev.parent, devres); 
  82.   } 
  83.  return 0; 
  84.  
  85. err_device_del: 
  86.      device_del(&dev->dev); 
  87. err_free_vals: 
  88.      kfree(dev->vals); 
  89.      dev->vals = NULL; 
  90. err_devres_free: 
  91.      devres_free(devres); 
  92.      return error; 
  93. } 
  94. EXPORT_SYMBOL(input_register_device); 

input_dev_list和input_handler_list是全局的一个链表

  1. static LIST_HEAD(input_dev_list); 
  2. static LIST_HEAD(input_handler_list); 

list_for_each_entry是一个宏，展开如下 获取input_handler_list的每一项和input_dev匹配，通过for循环遍历.

  1. for (handler = list_first_entry(input_handler_list, &handler, node);  
  2.      &handler->node != (input_handler_list);      
  3.      &handler = list_next_entry(&handler, node)) 
  4.  
  5.      input_attach_handler(dev, handler); 

list_first_entry 获得第一个列表元素 list_next_entry 获得下一个列表元素

3.5.3. input_register_handle

注册一个handle，链接input_handler和input_dev的h_list

  1. /* drivers/input/input.c */ 
  2. int input_register_handle(struct input_handle *handle) 
  3. { 
  4.      struct input_handler *handler = handle->handler; 
  5.      struct input_dev *dev = handle->dev; 
  6.      int error; 
  7.  
  8.      error = mutex_lock_interruptible(&dev->mutex); 
  9.      if (error) 
  10.          return error; 
  11.      
  12.      if (handler->filter) 
  13.           list_add_rcu(&handle->d_node, &dev->h_list); 
  14.      else 
  15.          list_add_tail_rcu(&handle->d_node, &dev->h_list); 
  16. /* 将handle的d_node，链接到其相关的input_dev的h_list链表中  */ 
  17.  
  18.      mutex_unlock(&dev->mutex); 
  19.  
  20.      list_add_tail_rcu(&handle->h_node, &handler->h_list); 
  21. /* 将handle的h_node，链接到其相关的input_handler的h_list链表中 */ 
  22.  
  23.      if (handler->start) 
  24.           handler->start(handle); 
  25.  
  26.  return 0; 
  27. } 
  28. EXPORT_SYMBOL(input_register_handle); 

3.5.4. input_register_handler

注册一个事件，进行匹配设备和事件的绑定

  1. /* drivers/input/input.c */ 
  2. int input_register_handler(struct input_handler *handler) 
  3. { 
  4.      struct input_dev *dev; 
  5.      int error; 
  6.  
  7.      error = mutex_lock_interruptible(&input_mutex); 
  8.      if (error) 
  9.           return error; 
  10.  
  11.     INIT_LIST_HEAD(&handler->h_list); 
  12.  
  13.      list_add_tail(&handler->node, &input_handler_list);  /* 连接到input_handler_list链表中 */ 
  14. /* 遍历input_dev_list，配对 input_dev 和 handler */ 
  15.      list_for_each_entry(dev, &input_dev_list, node) 
  16.       input_attach_handler(dev, handler);  /* event节点加入列表 */ 
  17.  
  18.      input_wakeup_procfs_readers(); 
  19.  
  20.      mutex_unlock(&input_mutex); 
  21.      return 0; 
  22. } 
  23. EXPORT_SYMBOL(input_register_handler); 

3.5.5. evdev_connect

事件处理器evdev，生成一个新的evdev设备，连接input核心，回调函数。

  1. /* drivers/input/evdev.c */ 
  2. static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 
  3.     const struct input_device_id *id) 
  4. { 
  5.      struct evdev *evdev; 
  6.      int minor; 
  7.      int dev_no; 
  8.      int error; 
  9.     /* 获取次设备号，从evdev_table中找到一个未使用的最小的数组项，最大值32 */ 
  10.      minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true); 
  11.      if (minor < 0) { 
  12.           error = minor; 
  13.           pr_err("failed to reserve new minor: %d\n", error); 
  14.           return error; 
  15.      } 
  16.     /* 分配空间 */ 
  17.      evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 
  18.      if (!evdev) { 
  19.           error = -ENOMEM; 
  20.           goto err_free_minor; 
  21.      } 
  22. /* 初始化client_list链表头，代表多少应用读写这个设备 */ 
  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);  /* 初始化等待队列，当evdev没有数据可读时，就 在 该队列上睡眠 */ 
  27.      evdev->exist = true;  /* 设备存在 */ 
  28.  
  29.      dev_no = minor; 
  30.   
  31.      if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS) 
  32.           dev_no -= EVDEV_MINOR_BASE; 
  33.      dev_set_name(&evdev->dev, "event%d", dev_no);  /* 设置设备名为eventX */ 
  34.  
  35.      evdev->handle.dev = input_get_device(dev);  /* 获取设备 */ 
  36.      evdev->handle.name = dev_name(&evdev->dev);  /* 设备名称 */ 
  37.      evdev->handle.handler = handler;  /* handler绑定 */   
  38.      evdev->handle.private = evdev;  /* evdev数据指向 */ 
  39.  
  40.      evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);  /* sysfs下的设备号 */ 
  41.      evdev->dev.class = &input_class;  /* 将input_class作为设备类 */ 
  42.      evdev->dev.parent = &dev->dev;  /* input_dev作为evdev的父设备 */ 
  43.      evdev->dev.release = evdev_free;  /* 释放函数 */ 
  44.      device_initialize(&evdev->dev);  /* 初始化设备 */ 
  45.         /* 注册一个handle处理事件 */ 
  46.      error = input_register_handle(&evdev->handle); if (error) 
  47.           goto err_free_evdev; 
  48.  
  49.      cdev_init(&evdev->cdev, &evdev_fops);  /* 字符设备初始化 */ 
  50.  
  51.      error = cdev_device_add(&evdev->cdev, &evdev->dev);  /* 添加字符设备 */ 
  52.      if (error) 
  53.           goto err_cleanup_evdev; 
  54.  
  55.      return 0; 
  56.  
  57. err_cleanup_evdev: 
  58.      evdev_cleanup(evdev); 
  59. err_unregister_handle: 
  60.      input_unregister_handle(&evdev->handle); 
  61. err_free_evdev: 
  62.      put_device(&evdev->dev); 
  63. err_free_minor: 
  64.      input_free_minor(minor); 
  65.      return error; 
  66. } 

(1)是在保存区驱动设备名字，比如下图(键盘驱动)event1：因为没有设置设备号，默认从小到大排序，其中event0是表示input子系统，所以键盘驱动名字就是event1。

(2)是保存驱动设备的主次设备号，其中主设备号INPUT_MAJOR=13，次设备号=EVSEV_MINOR_BASE+驱动程序本身设备号。

(3)会在/sys/class/input类下创建驱动设备event%d，比如键盘驱动event1

(4)最终进入input_register_handler()函数来注册handle。

3.5.6. input_attach_handler

设备匹配具体实现

  1. /* drivers/input/input.c */ 
  2. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)   
  3. {   
  4.     const struct input_device_id *id;   
  5.     int error;   
  6.  
  7. /* blacklist是handler该忽略input设备类型 */     
  8.     if (handler->blacklist && input_match_device(handler->blacklist, dev))   
  9.         return -ENODEV;   
  10.         id = input_match_device(handler->id_table, dev);   
  11.     /* 这个是主要的配对函数，匹配handler和device的ID */ 
  12.     if (!id)   
  13.         return -ENODEV;   
  14.    
  15.     error = handler->connect(handler, dev, id);   
  16.     /* 配对成功调用handler的connect函数，这个函数在事件处理器中定义，主要生成一个input_handle结构，并初始化，还生成一个事件处理器相关的设备结构 */ 
  17.     if (error && error != -ENODEV)   
  18.         printk(KERN_ERR   
  19.             "input: failed to attach handler %s to device %s, "   
  20.             "error: %d\n",   
  21.             handler->name, kobject_name(&dev->dev.kobj), error);   
  22.         /* 出错处理 */   
  23.     return error;   
  24.  } 

3.5.7. input_match_device

比较input_dev中的id和handler支持的id，存放在handler中的id_table。

  1. /* drivers/input/input.c */ 
  2. static const struct input_device_id *input_match_device(struct input_handler *handler, struct input_dev *dev) 
  3. { 
  4.      const struct input_device_id *id; 
  5.     /* 遍历id_table的id匹配 */ 
  6.      for (id = handler->id_table; id->flags || id->driver_info; id++) { 
  7.           if (input_match_device_id(dev, id) && 
  8.               (!handler->match || handler->match(handler, dev))) { 
  9.                return id; 
  10.           } 
  11.       } 
  12.  
  13.      return NULL; 
  14. } 

3.5.8. input_allocate_device

初始化input_dev设备

  1. /* drivers/input/evdev.c */ 
  2. struct input_dev *input_allocate_device(void) 
  3. { 
  4.      static atomic_t input_no = ATOMIC_INIT(-1); 
  5.      struct input_dev *dev; 
  6. /* 遍历id_table的id匹配 */ 
  7.      dev = kzalloc(sizeof(*dev), GFP_KERNEL); 
  8.      if (dev) { 
  9.           dev->dev.type = &input_dev_type; 
  10.           dev->dev.class = &input_class; 
  11.           device_initialize(&dev->dev); 
  12.           mutex_init(&dev->mutex); 
  13.           spin_lock_init(&dev->event_lock); 
  14.           timer_setup(&dev->timer, NULL, 0); 
  15.           INIT_LIST_HEAD(&dev->h_list); 
  16.           INIT_LIST_HEAD(&dev->node); 
  17.  
  18.            dev_set_name(&dev->dev, "input%lu", 
  19.         (unsigned long)atomic_inc_return(&input_no)); 
  20.  
  21.   __module_get(THIS_MODULE); 
  22.  } 
  23.  
  24.  return dev; 
  25. } 
  26. EXPORT_SYMBOL(input_allocate_device); 

3.5.9. input_event

调用input_handle_event进行事件处理 dev是上报事件的设备，type是事件总类型，code是事件子类型，value是事件值。

  1. /* drivers/input/input.c */ 
  2. void (struct input_dev *dev, unsigned int type, unsigned int code, int value) 
  3. { 
  4.      unsigned long flags; 
  5.     /* 判断输入事件是否支持该设备 */ 
  6.      if (is_event_supported(type, dev->evbit, EV_MAX)) { 
  7. spin_lock_irqsave(&dev->event_lock, flags);  /* 事件加锁 */ 
  8.           input_handle_event(dev, type, code, value); /* 发送事件调用input_pass_values */ 
  9.           spin_unlock_irqrestore(&dev->event_lock, flags); 
  10.      } 
  11. }EXPORT_SYMBOL(input_event); 

3.5.10. input_handle_event

按键上报的处理函数

  1. /* drivers/input/input.c */ 
  2. static void input_handle_event(struct input_dev *dev, 
  3.           unsigned int type, unsigned int code, int value) 
  4. {   /* 处理事件 */ 
  5.      int disposition = input_get_disposition(dev, type, code, &value); 
  6. /* 处理EV_SYN事件 */ 
  7.      if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) 
  8.           add_input_randomness(type, code, value); 
  9. /* 一些特殊事件需要对dev也上报，比如led */ 
  10.      if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event) 
  11.           dev->event(dev, type, code, value); 
  12.  
  13.      if (!dev->vals) 
  14.           return; 
  15.     /* 向上层handler汇报事件 */ 
  16.      if (disposition & INPUT_PASS_TO_HANDLERS) { 
  17.           struct input_value *v; 
  18.  
  19.           if (disposition & INPUT_SLOT) { 
  20.                v = &dev->vals[dev->num_vals++]; 
  21.                v->type = EV_ABS; 
  22.                v->code = ABS_MT_SLOT; 
  23.                v->value = dev->mt->slot; 
  24.           } 
  25. /* 缓存event事件 */ 
  26.           v = &dev->vals[dev->num_vals++]; 
  27.           v->type = type; 
  28.           v->code = code; 
  29.           v->value = value; 
  30.      } 
  31.     /* 向上层handler汇报事件，刷新缓冲区，上报event事件 */ 
  32.      if (disposition & INPUT_FLUSH) { 
  33.           if (dev->num_vals >= 2) 
  34.                input_pass_values(dev, dev->vals, dev->num_vals); 
  35.           dev->num_vals = 0; 
  36.        /* 缓冲的时间超过上限，也进行上报处理 */ 
  37.      } else if (dev->num_vals >= dev->max_vals - 2) { 
  38.           dev->vals[dev->num_vals++] = input_value_sync; 
  39.           input_pass_values(dev, dev->vals, dev->num_vals);/* 上报event事件 */ 
  40.           dev->num_vals = 0; 
  41.      } 
  42. } 

3.5.11. input_get_disposition

获取input事件类型

  1. /* drivers/input/input.c */ 
  2. static int input_get_disposition(struct input_dev *dev, 
  3.      unsigned int type, unsigned int code, int *pval) 
  4. { 
  5.      int disposition = INPUT_IGNORE_EVENT;  /* 定义初始变量，如果没有更新，最后忽略 */ 
  6.      int value = *pval; 
  7.      /* 处理各类事件 */ 
  8.      switch (type) { 
  9. /* 同步事件 */ 
  10.          case EV_SYN: 
  11.              switch (code) { 
  12.              case SYN_CONFIG: 
  13.                   disposition = INPUT_PASS_TO_ALL; 
  14.                   break; 
  15.  
  16.               case SYN_REPORT: 
  17.                     disposition = INPUT_PASS_TO_HANDLERS | INPUT_FLUSH; 
  18.                     break; 
  19.               case SYN_MT_REPORT: 
  20.                     disposition = INPUT_PASS_TO_HANDLERS; 
  21.                     break; 
  22.       } 
  23.       break; 
  24.  
  25.      case EV_KEY: 
  26.         /* 判断是否支持该键，同时判断按键状态是否改变 */ 
  27.          if (is_event_supported(code, dev->keybit, KEY_MAX)) { 
  28. if (value == 2) { 
  29.                     disposition = INPUT_PASS_TO_HANDLERS; 
  30.                     break; 
  31.                } 
  32. /* 判断value是否改变 */ 
  33.           if (!!test_bit(code, dev->key) != !!value) { 
  34.                 __change_bit(code, dev->key);  /* 按位取反 */ 
  35.                 disposition = INPUT_PASS_TO_HANDLERS; 
  36.           } 
  37.       } 
  38.       break; 
  39.  
  40.      case EV_SW: 
  41.       if (is_event_supported(code, dev->swbit, SW_MAX) && 
  42.           !!test_bit(code, dev->sw) != !!value) { 
  43.  
  44.            __change_bit(code, dev->sw); 
  45.              disposition = INPUT_PASS_TO_HANDLERS; 
  46.       } 
  47.       break; 
  48.  
  49.      case EV_ABS: 
  50.           if (is_event_supported(code, dev->absbit, ABS_MAX)) 
  51.                disposition = input_handle_abs_event(dev, code, &value); 
  52.  
  53.            break; 
  54.  
  55.      case EV_REL: 
  56.           if (is_event_supported(code, dev->relbit, REL_MAX) && value) 
  57.                  disposition = INPUT_PASS_TO_HANDLERS; 
  58.  
  59.            break; 
  60.  
  61.      case EV_MSC: 
  62.           if (is_event_supported(code, dev->mscbit, MSC_MAX)) 
  63.                disposition = INPUT_PASS_TO_ALL; 
  64.  
  65.           break; 
  66.  
  67.      case EV_LED: 
  68.           if (is_event_supported(code, dev->ledbit, LED_MAX) && 
  69.               !!test_bit(code, dev->led) != !!value) { 
  70.  
  71.               __change_bit(code, dev->led); 
  72.              disposition = INPUT_PASS_TO_ALL; 
  73.          } 
  74.          break; 
  75.  
  76.       case EV_SND: 
  77.            if (is_event_supported(code, dev->sndbit, SND_MAX)) { 
  78.                  if (!!test_bit(code, dev->snd) != !!value) 
  79.                       __change_bit(code, dev->snd); 
  80.                  disposition = INPUT_PASS_TO_ALL; 
  81.           } 
  82.           break; 
  83.  
  84.       case EV_REP: 
  85.            if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) { 
  86.                 dev->rep[code] = value; 
  87.                 disposition = INPUT_PASS_TO_ALL; 
  88.            } 
  89.          break; 
  90.  
  91.      case EV_FF: 
  92.       if (value >= 0) 
  93.           disposition = INPUT_PASS_TO_ALL; 
  94.          break; 
  95.  
  96.      case EV_PWR: 
  97.           disposition = INPUT_PASS_TO_ALL; 
  98.           break; 
  99.      } 
  100.  
  101.      *pval = value; 
  102.      return disposition; 
  103. } 

3.5.12. input_pass_event

调用input_pass_values

  1. /* drivers/input/input.c */ 
  2. static void input_pass_event(struct input_dev *dev, 
  3.         unsigned int type, unsigned int code, int value) 
  4. { 
  5.      struct input_value vals[] = { { type, code, value } }; 
  6.  
  7.      input_pass_values(dev, vals, ARRAY_SIZE(vals));  /* 调用input_pass_values */ 
  8. } 

3.5.13. input_pass_values

上报事件的处理

  1. /* drivers/input/input.c */ 
  2. static void input_pass_values(struct input_dev *dev, 
  3.          struct input_value *vals, unsigned int count) 
  4. { 
  5.      struct input_handle *handle; 
  6.      struct input_value *v; 
  7.  
  8.      if (!count) 
  9.           return; 
  10.  
  11.      rcu_read_lock(); 
  12.     /* grab是强制为input device绑定的handler ，如果存在就直接调用 */ 
  13.      handle = rcu_dereference(dev->grab); 
  14.      if (handle) { 
  15.           count = input_to_handler(handle, vals, count); 
  16.      } else { 
  17.     /* 如果device绑定具体的handle，则遍历这个dev上的所有handle，向应用层open过的发送信息 */   
  18.           list_for_each_entry_rcu(handle, &dev->h_list, d_node) 
  19.            if (handle->open) { 
  20.                 count = input_to_handler(handle, vals, count); 
  21.                 if (!count) 
  22.                      break; 
  23.           } 
  24.      } 
  25.  
  26.      rcu_read_unlock(); 
  27.  
  28.      /* 按键事件自动回复 */ 
  29.      if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) { 
  30.           for (v = vals; v != vals + count; v++) { 
  31.                if (v->type == EV_KEY && v->value != 2) { 
  32.                     if (v->value) 
  33.                          input_start_autorepeat(dev, v->code); 
  34.                     else 
  35.                          input_stop_autorepeat(dev); 
  36.                } 
  37.           } 
  38.      } 
  39. } 

函数最终就会调用到handler->event,对事件进行处理。

3.5.14. input_to_handler

  1. /* drivers/input/input.c */ 
  2. static unsigned int input_to_handler(struct input_handle *handle, 
  3.    struct input_value *vals, unsigned int count) 
  4. { 
  5.      struct input_handler *handler = handle->handler; 
  6.      struct input_value *end = vals; 
  7.      struct input_value *v; 
  8.  
  9.      if (handler->filter) { 
  10.           for (v = vals; v != vals + count; v++) { 
  11.                if (handler->filter(handle, v->type, v->code, v->value)) 
  12.                     continue; 
  13.                if (end != v) 
  14.                     *end = *v; 
  15.                end++; 
  16.           } 
  17.           count = end - vals; 
  18.      } 
  19.  
  20.      if (!count) 
  21.           return 0; 
  22.  
  23.      if (handler->events) 
  24.           handler->events(handle, vals, count); 
  25.      else if (handler->event) 
  26.           for (v = vals; v != vals + count; v++) 
  27.                handler->event(handle, v->type, v->code, v->value); 
  28.  
  29.      return count; 
  30. } 

3.5.15. evdev_events

事件处理函数

  1. /* drivers/input/evdev.c */ 
  2. static void evdev_events(struct input_handle *handle, 
  3.         const struct input_value *vals, unsigned int count) 
  4. { 
  5.      struct evdev *evdev = handle->private; 
  6.      struct evdev_client *client; 
  7.      ktime_t time_mono, time_real; 
  8.        /* 获取时间信息 */ 
  9.      time_meno = ktime_get(); 
  10.      time_real = ktime_sub(time_mono, ktime_get_monotonic_offset()); 
  11.  
  12.      rcu_read_lock(); 
  13.  
  14.      client = rcu_dereference(evdev->grab); 
  15.  /* 如果该evdev有个专用的client，那么就将事件发给它，如果发送给它，如果该evdev不存在专用的 cliect，那就把该事件发送给evdev上client_list链表上所有的client */ 
  16.      if (client) 
  17.           evdev_pass_values(client, vals, count, ev_time);   /* 打包数据 */ 
  18.      else 
  19.           list_for_each_entry_rcu(client, &evdev->client_list, node) 
  20.    evdev_pass_values(client, vals, count, ev_time); 
  21.  
  22.  rcu_read_unlock(); 
  23. } 

3.5.16. evdev_pass_values

填充event数据。

  1. /* drivers/input/evdev.c */ 
  2. static void evdev_pass_values(struct evdev_client *client, 
  3.          const struct input_value *vals, unsigned int count, ktime_t *ev_time) 
  4. { 
  5.      struct evdev *evdev = client->evdev;  
  6.      const struct input_value *v; 
  7.      struct input_event event; 
  8.      struct timespec64 ts; 
  9.      bool wakeup = false; 
  10.  
  11.      if (client->revoked) 
  12.           return; 
  13.  
  14.      ts = ktime_to_timespec64(ev_time[client->clk_type]); /* 获取时间戳 */ 
  15.      event.input_event_sec = ts.tv_sec; 
  16.      event.input_event_usec = ts.tv_nsec / NSEC_PER_USEC; 
  17.  
  18.      /* 中断禁止, 获取锁 */ 
  19.     spin_lock(&client->buffer_lock); 
  20.     /* 多个数据 */ 
  21.      for (v = vals; v != vals + count; v++) { 
  22.           if (__evdev_is_filtered(client, v->type, v->code)) 
  23.                 continue; 
  24.  
  25.           if (v->type == EV_SYN && v->code == SYN_REPORT) { 
  26.                /* drop empty SYN_REPORT */ 
  27.                if (client->packet_head == client->head) 
  28.                       continue; 
  29.                wakeup = true; 
  30.           } 
  31.         /* 数据重新封装为event对象 */ 
  32.           event.type = v->type; 
  33.           event.code = v->code; 
  34.           event.value = v->value; 
  35.           __pass_event(client, &event);// 在里面做消息传递 
  36.      } 
  37.  
  38.      spin_unlock(&client->buffer_lock); 
  39.       /* 唤醒队列 */ 
  40.      if (wakeup) 
  41.           wake_up_interruptible(&evdev->wait); 
  42. } 

3.5.17. __pass_event

设备驱动上报事件并不是直接传递给用户空间的，在通用事件处理器(evdev)中，事件被缓冲存在缓冲区中。__pass_event函数里会将input_event放到client结构结构体的环形缓冲区里，即evdev_client结构体的buffer,用户程序通过read()函数从环形缓冲区中获取input_event事件。

  1. /* drivers/input/evdev.c */ 
  2. static void __pass_event(struct evdev_client *client, 
  3.     const struct input_event *event) 
  4. { 
  5.      client->buffer[client->head++] = *event; /*将事件赋值给客户端的input_event缓冲区*/ 
  6.      client->head &= client->bufsize - 1; /*对头head自增指向下一个元素空间 */ 
  7.  
  8.     /*当队头head与队尾tail相等时，说明缓冲区已满 */ 
  9.      if (unlikely(client->head == client->tail)) { 
  10.           /* 
  11.            * This effectively "drops" all unconsumed events, leaving 
  12.            * EV_SYN/SYN_DROPPED plus the newest event in the queue. 
  13.           */ 
  14.           client->tail = (client->head - 2) & (client->bufsize - 1); 
  15. client->buffer[client->tail].input_event_sec = event->input_event_sec; 
  16.           client->buffer[client->tail].input_event_usec = event->input_event_usec; 
  17.           client->buffer[client->tail].type = EV_SYN; 
  18.           client->buffer[client->tail].code = SYN_DROPPED; 
  19.           client->buffer[client->tail].value = 0; 
  20. client->packet_head = client->tail; 
  21.      } 
  22.       /* 当遇到EV_SYN/ SYN_REPORT同步事件时，packet_head移动到对头head位置*/ 
  23.      if (event->type == EV_SYN && event->code == SYN_REPORT) { 
  24.           client->packet_head = client->head; 
  25.           kill_fasync(&client->fasync, SIGIO, POLL_IN); 
  26. static int evdev_connect(struct input_handler *handler, struct input_dev *dev, 
  27.     const struct input_device_id *id) 
  28. { 
  29.      struct evdev *evdev; 
  30.      int minor; 
  31.      int dev_no; 
  32.      int error; 
  33.  
  34.      minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true); 
  35.      if (minor < 0) { 
  36.           error = minor; 
  37.           pr_err("failed to reserve new minor: %d\n", error); 
  38.           return error; 
  39.      } 
  40.  
  41.      evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); 
  42.      if (!evdev) { 
  43.           error = -ENOMEM; 
  44.           goto err_free_minor; 
  45.      } 
  46.  
  47.      INIT_LIST_HEAD(&evdev->client_list); 
  48.      spin_lock_init(&evdev->client_lock); 
  49.      mutex_init(&evdev->mutex); 
  50.      init_waitqueue_head(&evdev->wait); 
  51.      evdev->exist = true; 
  52.  
  53.      dev_no = minor; 
  54.      /* Normalize device number if it falls into legacy range */ 
  55.      if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS) 
  56.           dev_no -= EVDEV_MINOR_BASE; 
  57.  
  58. /*这里我们能看到最终生成的设备文件，例如event0、event1等待 
  59.      dev_set_name(&evdev->dev, "event%d", dev_no);  
  60.  
  61.      evdev->handle.dev = input_get_device(dev); 
  62.      evdev->handle.name = dev_name(&evdev->dev); 
  63.      evdev->handle.handler = handler; 
  64.      evdev->handle.private = evdev; 
  65.  
  66.     /*在设备驱动视图/sys/class/input/和/sys/devices/目录下产生eventx设备，最终依event机制和mdev在/dev目录生成对应的设备文件*/ 
  67.      evdev->dev.devt = MKDEV(INPUT_MAJOR, minor); 
  68.      evdev->dev.class = &input_class; 
  69.      evdev->dev.parent = &dev->dev; 
  70.      evdev->dev.release = evdev_free; 
  71.      device_initialize(&evdev->dev); 
  72.  
  73.      error = input_register_handle(&evdev->handle); 
  74.      if (error) 
  75.           goto err_free_evdev; 
  76.  
  77.      cdev_init(&evdev->cdev, &evdev_fops); 
  78.      evdev->cdev.kobj.parent = &evdev->dev.kobj; 
  79.      error = cdev_add(&evdev->cdev, evdev->dev.devt, 1); 
  80.      if (error) 
  81.           goto err_unregister_handle; 
  82.  
  83.      error = device_add(&evdev->dev); 
  84.      if (error) 
  85.           goto err_cleanup_evdev; 
  86.  
  87.      return 0; 
  88.  
  89. err_cleanup_evdev: 
  90.      evdev_cleanup(evdev); 
  91. err_unregister_handle: 
  92.      input_unregister_handle(&evdev->handle); 
  93. err_free_evdev: 
  94.      put_device(&evdev->dev); 
  95. err_free_minor: 
  96.      input_free_minor(minor); 
  97.  
  98.      return error; 
  99. } 
  100.      } 
  101. } 

3.5.18. evdev_connect

创建一个新的evdev 设备

3.5.19. input_proc_init

创建对应的目录结构

  1. /* drivers/input/input.c */ 
  2. static int __init input_proc_init(void) 
  3. { 
  4.      struct proc_dir_entry *entry; 
  5. /* 在/proc/bus目录下创建input */ 
  6.      proc_bus_input_dir = proc_mkdir("bus/input", NULL); 
  7.      if (!proc_bus_input_dir) 
  8.           return -ENOMEM; 
  9. /* 在/proc/bus/input目录下创建devices文件 */ 
  10.      entry = proc_create("devices", 0, proc_bus_input_dir, &input_devices_fileops); 
  11.      if (!entry) 
  12.           goto fail1; 
  13. /* 在/proc/bus/input目录下创建handlers文件 */ 
  14.      entry = proc_create("handlers", 0, proc_bus_input_dir, &input_handlers_fileops); 
  15.      if (!entry) 
  16.           goto fail2; 
  17.  
  18.      return 0; 
  19. fail2:  
  20. remove_proc_entry("devices", proc_bus_input_dir); 
  21. fail1:  
  22. remove_proc_entry("bus/input", NULL); 
  23.      return -ENOMEM; 
  24. } 

3.5.20. input_set_capability

设置输入设备可以上报哪些事件，需要注意一次只能设置一个事件，如果设备上报多个事件，需要重复调用

  1. /* drivers/input/input.c */ 
  2. void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code) 
  3. { 
  4.      switch (type) { 
  5.          case EV_KEY: 
  6.           __set_bit(code, dev->keybit); 
  7.           break; 
  8.  
  9.          case EV_REL: 
  10.           __set_bit(code, dev->relbit); 
  11.           break; 
  12.  
  13.          case EV_ABS: 
  14.           input_alloc_absinfo(dev); 
  15.           if (!dev->absinfo) 
  16.                return; 
  17.  
  18.           __set_bit(code, dev->absbit); 
  19.           break; 
  20.  
  21.          case EV_MSC: 
  22.           __set_bit(code, dev->mscbit); 
  23.           break; 
  24.  
  25.         case EV_SW: 
  26.          __set_bit(code, dev->swbit); 
  27.          break; 
  28.  
  29.          case EV_LED: 
  30.           __set_bit(code, dev->ledbit); 
  31.           break; 
  32.  
  33.          case EV_SND: 
  34.           __set_bit(code, dev->sndbit); 
  35.           break; 
  36.  
  37.         case EV_FF: 
  38.          __set_bit(code, dev->ffbit); 
  39.          break; 
  40.  
  41.        case EV_PWR: 
  42.         /* do nothing */ 
  43.         break; 
  44.  
  45.      default: 
  46.       pr_err("%s: unknown type %u (code %u)\n", __func__, type, code); 
  47.       dump_stack(); 
  48.       return; 
  49.  } 
  50.  
  51.      __set_bit(type, dev->evbit); 
  52. } 
  53. EXPORT_SYMBOL(input_set_capability); 

3.5.21. evdev_read

读取event数据

  1. static ssize_t evdev_read(struct file *file, char __user *buffer, 
  2.      size_t count, loff_t *ppos) 
  3. { 
  4.      struct evdev_client *client = file->private_data; 
  5.      struct evdev *evdev = client->evdev; 
  6.      struct input_event event; 
  7.      size_t read = 0; 
  8.      int error; 
  9.  
  10.      if (count != 0 && count < input_event_size()) 
  11.           return -EINVAL; 
  12.  
  13.      for (;;) { 
  14.           if (!evdev->exist || client->revoked) 
  15.                 return -ENODEV; 
  16. /* client的环形缓冲区中没有数据并且是非阻塞的，那么返回-EAGAIN，也就是try again */ 
  17.           if (client->packet_head == client->tail &&(file->f_flags & O_NONBLOCK)) 
  18.                 return -EAGAIN; 
  19.  
  20.          /* 
  21.           * count == 0 is special - no IO is done but we check 
  22.           * for error conditions (see above). 
  23.           */ 
  24.           if (count == 0) 
  25.                break; 
  26. /* 如果获得了数据，就取出来 */ 
  27.           while (read + input_event_size() <= count && 
  28.               evdev_fetch_next_event(client, &event)) { 
  29. /* 传给用户 */ 
  30.           if (input_event_to_user(buffer + read, &event)) 
  31.                return -EFAULT; 
  32.  
  33.             read += input_event_size(); 
  34.     } 
  35.  
  36.       if (read) 
  37.            break; 
  38. /* 如果没有数据，并且是阻塞的，则在等待队列上等待 */ 
  39.       if (!(file->f_flags & O_NONBLOCK)) { 
  40.            error = wait_event_interruptible(evdev->wait, 
  41.              client->packet_head != client->tail || !evdev->exist || client->revoked); 
  42.        if (error) 
  43.             return error; 
  44.       } 
  45.  } 
  46.  
  47.  return read; 
  48. } 

如果read进行进入休眠状态，则会被evdev_event函数唤醒

4. 模块测试

4.1.测试概述

应用有两条路径，如下所示 /sys/class/input

  1. console:/sys/class/input # ls 
  2. event0 event1 event2 input0 input1 input2 mice 

/dev/input

  1. console:/dev/input # ls 
  2. event0 event1 event2 mice 

查看设备信息

  1. $ cat /proc/bus/input/devices 
  2. I: Bus=0000 Vendor=0000 Product=0000 Version=0000 
  3. N: Name="lombo-ir" 
  4. P: Phys=lombo-ir/input0 
  5. S: Sysfs=/devices/platform/4014800.ir/rc/rc0/input0 
  6. U: Uniq= 
  7. H: Handlers=event0 
  8. B: PROP=0 
  9. B: EV=100013 
  10. B: KEY=1 0 0 0 0 0 0 0 1680 0 0 ffc 
  11. B: MSC=10 

event节点里面存放的数据都是没有经过处理的原始数据流。cat 对应的eventX节点就可以查看输入的数据。

  1. $ cat event0 

4.2.应用测试

  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3. #include <sys/ioctl.h> 
  4. #include <sys/time.h> 
  5. #include <sys/types.h> 
  6. #include <fcntl.h> 
  7. #include <unistd.h> 
  8. #include <errno.h> 
  9. #include <time.h> 
  10. #include <linux/input.h> 
  11.  
  12.  
  13. int main(void) 
  14. { 
  15.     int ret; 
  16.     int fd; 
  17.  
  18.     struct input-event value; 
  19.  
  20.     fd = open("/dev/input/event1", O_RDWR); 
  21.     if (fd < 0) { 
  22.          printf("open event1 failed %d\n", fd); 
  23.          return 0; 
  24.     } 
  25.  
  26.     while(1) { 
  27.           ret = read(fd, &value, sizeof(value)); 
  28.           if (ret < 0) 
  29.                printf("read failed\n"); 
  30.    
  31.           printf("input type:%d code:%d value:%d\n", value.type, 
  32.                value.code, value.value); 
  33.      } 
  34.     return 0; 
  35. } 

本文转载自微信公众号「一口Linux」

 

责任编辑：姜华 来源： 一口Linux
Linux inputLinux 系统
相关推荐
Linux内核增加HDF驱动子系统
HDF驱动子系统是OpenHarmony重要的特色功能之一，其主要的功能是实现驱动程序在多内核多平台的物联网环境，实现一次驱动开发，多端部署。

2021-12-15 10:02:25

鸿蒙HarmonyOS应用
Linux 中断子系统的驱动解析
这里主要分析linuxkernel中GICv3中断控制器的代码(driversirqchipirqgicv3.c)。

2021-08-10 11:30:30

Linux代码中断控制器
Linux 中断子系统的驱动解析
这里主要分析linuxkernel中GICv3中断控制器的代码(driversirqchipirqgicv3.c)。

2021-08-03 15:10:26

Linux代码驱动
Linux input子系统编程、分析与模板
input对象描述了一个输入设备，包括它可能上报的事件，这些事件使用位图来描述，内核提供的相应的工具帮助我们构建一个input对象，大家可以参考内核文档"Documentationinputinputprogramming.txt"，里面对于input子系统的使用有详细的描述。

2017-02-28 18:26:09

Linuxinput子系统编程
Linux 4.3内核增加了MOST驱动子系统
当Linux4.2内核还没有正式发布的时候，GregKroahHartman就为他维护的各种子系统模块打开了Linux4.3的合并窗口。Linux4.3的合并窗口更新，内容涉及驱动核心、TTY串口、USB驱动、字符杂项以及暂存区内容。这些拉取申请没有提供任何震撼性的改变，大部分都是改进附加修改bug。暂存区内容又是大量的修正和清理，但是还是有一个新的驱动子系统。

2015-10-19 17:36:19

MOST内核Linux
Android图形子系统详解
Android的图形系统发展经历了通过CPU模拟图形操作，和GPU专门进行图形处理的阶段，因为这方面硬件技术发展很快，因此Android图形系统也在不断调整，以期提供更加快速流畅的UI体验。

2013-01-06 13:06:02

Android Input子系统：Input进程的创建，监听线程的启动
从我个人的理解来看，Android的Input系统其实就是系统级的事件处理、分发框架，它需要的功能模块大致有：事件读取、事件分类、事件分发。那么我们就从整个Input系统的输入源入手，了解事件是如何被输入到Input系统中的。

2017-09-11 15:35:43

AndroidInput系统框架
鸿蒙的驱动子系统-3-驱动相关模块的编译
本篇带给大家驱动子系统的编译相关内容，互相交叉，关系稍微有点复杂，我花了一点时间做了梳理，先把一些要点做一下总结。

2021-08-17 14:39:00

鸿蒙HarmonyOS应用
Windows 亲生的 Linux 子系统
WSL只是长得像Linux而已，虽然在这个子系统中，我们可以执行Linux程序，但是到了底层，WSL调用的还是win32API。

2021-07-22 08:03:08

Windows 操作系统Linux
浅谈Linux内核无线子系统
Linux内核无线子系统看成两大块：cfg80211和mac80211，它们连通内核其他模块和用户空间的应用程序。Linux内核无线子系统统一各种WiFi设备，并处理OSI模型中最底层的MAC、PHY两层。Linux子系统实现大部分的MAC高层回调函数。

2016-07-22 10:50:56

Linux内核无线子系统
Linux 中断子系统(一)：框架
中断是大家用的最多的功能，不管是单片机还是Linux系统，都需要用到中断，对它的深入理解是非常必要的。

2021-12-08 08:41:31

Linux 中断子系统Linux 系统
Linux内核继续打造WWAN子系统 发展通用驱动并加强扩展能力
Linaro继续领导Linux内核的无线广域网(WWAN)子系统框架的开发工作。该框架旨在至少部分地处理无线广域网硬件的复杂性和异质性。

2021-04-06 11:18:47

LinuxWWAN子系统驱动
鸿蒙的驱动子系统-4-驱动配置文件的分析
前文《小型系统驱动示例程序的编译和验证》提到，以UART驱动实例程序为例，可将示驱动程序分为三部分,本文将基于Hi3516平台详细分析第一部分驱动的配置文件的相关要点。

2021-09-02 15:27:54

鸿蒙HarmonyOS应用
Windows的Linux子系统之Arch Linux
Canonical和微软合作的BashonWindows也仅仅是Ubuntu的命令行而已，并非是正规的图形用户界面。

2016-10-17 08:49:15

WindowsLinuxArch Linux
OpenHarmony Input 驱动框架
OpenAtomOpenHarmony系统HDF驱动框架采用C语言面向对象编程模型构建，通过平台解耦、内核解耦，来达到兼容不同内核，统一平台底座的目的。

2022-04-01 15:18:04

HarmonyHDF 驱动鸿蒙
漫话Linux之“躺平”: IDLE 子系统
当数据库处于全局锁的状态时，其他线程的一下语句会被阻塞：数据更新语句(数据的增删改)、数据定义语句(建表、索引变更、修改表结构等)和更新类事务的提交语句。

2021-06-07 08:13:11

LinuxIDLE 子系统
Linux下SPI驱动详解（干货）
SPI，是英语SerialPeripheralinterface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。

2021-03-05 11:52:50

LinuxSPI驱动详解
微软发布全新 Linux DirectX 驱动程序，升级 Windows 11/10 WSL 子系统内核
微软已经在Kernel.org上发布了一个新的Linux的DirectX内核驱动程序。更新后的驱动程序反映了微软首次尝试将该技术引入开源操作系统时的反馈。

2022-01-16 07:41:46

Windows 11操作系统微软
一文搞懂 Linux 时钟子系统
Clock时钟就是SoC中的脉搏，由它来控制各个部件按各自的节奏跳动。比如，CPU主频设置，串口的波特率设置，I2S的采样率设置，I2C的速率设置等等。

2022-04-12 09:05:30

Linux时钟
用QEMU研究Linux内核PCI子系统
OracleLinux内核工程师DongliZhang介绍了如何利用QEMU研究Linux内核PCI子系统。

2021-07-07 08:00:00

Linux开发虚拟机
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服