input子系统分析

转载 2013年12月04日 10:59:50
  1. 一、input子系统概述
  2. 在linux下,按键、触摸屏、鼠标等都可以利用input接口函数来实现设备驱动。
  3. 1,linux输入子系统主要分三层: 驱动,输入CORE, 事件处理层。
  4. 驱动根据CORE提供的接口,向上报告发生的按键动作。然后CORE根据驱动的类型,分派这个报告给对应的事件处理层进行处事。
  5. 事件处理层把数据变化反应到设备模型的文件中(事件缓冲区)。并通知在这些设备模型文件上等待的进程。

  6. 2,输入子系统在KERNEL初始化时被初始化。会创建所有类型输入输出设备的逻辑设备(及sysfs结点)。当硬件注册时,就会调用所有类型的input handler的connect函数,根据硬件注册的结构来判断是否与自己相关,然后再创建一个具体的设备结点。

  7. 3,驱动只负责的把输入设备注册到输入子系统中,然后输入子系统来创建对应的具体设备结点。而事件处理层,在初始化时,需要注册所一类设备的输入事件处理函数及相关接口

  8. 4,一类input handler可以和多个硬件设备相关联,创建多个设备节点。而一个设备也可能与多个input handler相关联,创建多个设备节点。

  9. .主要input通用数据结构
  10. 1.input_dev 这是input设备基本的设备结构,每个input驱动程序中都必须分配初始化这样一个结构,成员比较多 
  11. struct input_dev { 
  12.     const char *name; 
  13.     const char *phys; 
  14.     const char *uniq; 
  15.     struct input_id id;//与input_handler匹配用的id,包括 
  16.     /*struct input_id { 
  17.      __u16 bustype; //总线类型 
  18.      __u16 vendor; //生产厂商 
  19.      __u16 product; //产品类型 
  20.      __u16 version; //版本 
  21.          }; */
  22.          /*
  23.       #define EV_SYN 0x00 //同步事件
  24.     #define EV_KEY 0x01 //绝对二进制值,如键盘或按钮
  25.     #define EV_REL 0x02 //绝对结果,如鼠标设备
  26.     #define EV_ABS 0x03 //绝对整数值,如操纵杆或书写板
  27.     #define EV_MSC 0x04 //其它类
  28.     #define EV_SW 0x05 //开关事件
  29.     #define EV_LED 0x11 //LED或其它指示设备
  30.     #define EV_SND 0x12 //声音输出,如蜂鸣器
  31.     #define EV_REP 0x14 //允许按键自重复
  32.     #define EV_FF 0x15 //力反馈
  33.     #define EV_PWR 0x16 //电源管理事件
  34.     */
  35.     unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //设备支持的事件类型如上 
  36.     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //按键事件支持的子事件类型 
  37.     unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; //相对坐标事件支持的子事件类型 
  38.     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; //绝对坐标事件支持的子事件类型 
  39.     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; 
  40.     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; 
  41.     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; 
  42.     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; 
  43.     unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; 
  44.   
  45.     unsigned int keycodemax; 
  46.     unsigned int keycodesize; 
  47.     void *keycode; 
  48.     int (*setkeycode)(struct input_dev *dev, int scancode, int keycode); 
  49.     int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode); 
  50.   
  51.     struct ff_device *ff; 
  52.   
  53.     unsigned int repeat_key; //最近一次的按键值 
  54.     struct timer_list timer; 
  55.   
  56.     int sync; 
  57.   
  58.     int abs[ABS_MAX + 1]; 
  59.     int rep[REP_MAX + 1]; 
  60.   
  61.     unsigned long key[BITS_TO_LONGS(KEY_CNT)];//反应设备当前的按键状态 
  62.     unsigned long led[BITS_TO_LONGS(LED_CNT)];//反应设备当前的led状态 
  63.     unsigned long snd[BITS_TO_LONGS(SND_CNT)];//反应设备当前的声音输入状态 
  64.     unsigned long sw[BITS_TO_LONGS(SW_CNT)]; //反应设备当前的开关状态 
  65.   
  66.     int absmax[ABS_MAX + 1];//来自绝对坐标事件的最大键值 
  67.     int absmin[ABS_MAX + 1];//来自绝对坐标事件的最小键值 
  68.     int absfuzz[ABS_MAX + 1]; 
  69.     int absflat[ABS_MAX + 1]; 
  70.   
  71.     int (*open)(struct input_dev *dev); //第一次打开设备时调用,初始化设备用 
  72.     void (*close)(struct input_dev *dev);//最后一个应用程序释放设备时用,关闭设备 
  73.     int (*flush)(struct input_dev *dev, struct file *file); 
  74.     /*用于处理传递给设备的事件,如LED事件和声音事件*/ 
  75.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); 
  76.   
  77.     struct input_handle *grab;//当前占有该设备的input_handle 
  78.   
  79.     spinlock_t event_lock; 
  80.     struct mutex mutex; 
  81.   
  82.     unsigned int users;//打开该设备的用户数量(input handlers) 
  83.     int going_away; 
  84.   
  85.     struct device dev; 
  86.   
  87.     struct list_head h_list;//该链表头用于链接此设备所关联的input_handle 
  88.     struct list_head node; //用于将此设备链接到input_dev_list 
  89. }

  90. 2. input_handler 这是事件处理器的数据结构,代表一个事件处理器
  91. struct input_handler { 
  92.     void *private; 
  93.     /*event用于处理事件*/ 
  94.     void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); 
  95.     /*connect用于建立handler和device的联系*/ 
  96.     int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id); 
  97.     /*disconnect用于解除handler和device的联系*/ 
  98.     void (*disconnect)(struct input_handle *handle); 
  99.     void (*start)(struct input_handle *handle); 
  100.     const struct file_operations *fops;//handler的一些处理函数 
  101.     int minor;//次设备号 
  102.     const char *name; 
  103.     const struct input_device_id *id_table;//用于和device匹配 ,这个是事件处理器所支持的input设备
  104.     const struct input_device_id *blacklist;//匹配黑名单,这个是事件处理器应该忽略的input设备 
  105.     struct list_head h_list;//这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构 
  106.     struct list_head node; //链接到input_handler_list,这个链表链接了所有注册到内核的事件处理器 
  107. }; 

  108. 3.input_handle 结构体代表一个成功配对的input_dev和input_handler
  109. struct input_handle { 
  110.     void *private; //每个配对的事件处理器都会分配一个对应的设备结构,如evdev事件处理器的evdev结构,注意这个结构与设备驱动层的input_dev不同,初始化handle时,保存到这里。 
  111.     int open; //打开标志,每个input_handle 打开后才能操作,这个一般通过事件处理器的open方法间接设置 
  112.     const char *name; 
  113.     struct input_dev *dev; //关联的input_dev结构 
  114.     struct input_handler *handler; //关联的input_handler结构 
  115.     struct list_head d_node; //input_handle通过d_node连接到了input_dev上的h_list链表上 
  116.     struct list_head h_node; //input_handle通过h_node连接到了input_handler的h_list链表上 
  117. }; 

  118. 4.三个数据结构之间的关系
  119. input_dev 是硬件驱动层,代表一个input设备
  120. input_handler 是事件处理层,代表一个事件处理器
  121. input_handle 个人认为属于核心层,代表一个配对的input设备与input事件处理器
  122. input_dev 通过全局的input_dev_list链接在一起。设备注册的时候实现这个操作。
  123. input_handler 通过全局的input_handler_list链接在一起。事件处理器注册的时候实现这个操作(事件处理器一般内核自带,一般不需要我们来写)
  124. input_hande 没有一个全局的链表,它注册的时候将自己分别挂在了input_dev 和 input_handler 的h_list上了。通过input_dev 和input_handler就可以找到input_handle在设备注册和事件处理器,注册的时候都要进行配对工作,配对后就会实现链接。通过input_handle也可以找到input_dev和input_handler。
  125.      
  126. 我们可以看到,input_device和input_handler中都有一个h_list,而input_handle拥有指向input_dev和input_handler的指针,也就是说input_handle是用来关联input_dev和input_handler的。
  127. 那么为什么一个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个。


  128. 三、输入子系统驱动层分析(以tps6507x为例)
  129. 1.platform device的注册 

  130. 2.platform driver注册
  131. static struct platform_driver tps6507x_ts_driver = {
  132.     .driver = {
  133.         .name = "tps6507x-ts",
  134.         .owner = THIS_MODULE,
  135.     },
  136.     .probe = tps6507x_ts_probe,
  137.     .remove = __devexit_p(tps6507x_ts_remove),
  138. };

  139. //tps6507x触摸屏封装的设备结构
  140. struct tps6507x_ts {
  141.     struct input_dev *input_dev;
  142.     struct device *dev;
  143.     char phys[32];
  144.     struct delayed_work work;
  145.     unsigned polling; /* polling is active */
  146.     struct ts_event tc;
  147.     struct tps6507x_dev *mfd;
  148.     u16 model;
  149.     unsigned pendown;
  150.     int irq;
  151.     void (*clear_penirq)(void);
  152.     unsigned long poll_period; /* ms */
  153.     u16 min_pressure;
  154.     int vref; /* non-zero to leave vref on */
  155. };
  156.  
  157. static int __init tps6507x_ts_init(void)
  158. {
  159.     return platform_driver_register(&tps6507x_ts_driver);
  160. }

  161. //与platform device匹配成功后会调用tps6507x_ts_probe
  162. static int tps6507x_ts_probe(struct platform_device *pdev)
  163. {
  164.     int error;
  165.     struct tps6507x_ts *tsc;
  166.     struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent);
  167.     struct touchscreen_init_data *init_data;
  168.     struct input_dev *input_dev;
  169.     struct tps6507x_board *tps_board;
  170.     int schd;

  171.     //找到tps6507x platform data
  172.     tps_board = (struct tps6507x_board *)tps6507x_dev->dev->platform_data;

  173.     if (!tps_board) {
  174.         dev_err(tps6507x_dev->dev,"Could not find tps6507x platform datan");
  175.         return -EIO;
  176.     }

  177.     //得到触摸屏的一些初始化信息,如厂商信息等
  178.     init_data = tps_board->tps6507x_ts_init_data;
  179.     
  180.     //分配tps6507x_ts结构体
  181.     tsc = kzalloc(sizeof(struct tps6507x_ts), GFP_KERNEL);
  182.     if (!tsc) {
  183.         dev_err(tps6507x_dev->dev, "failed to allocate driver datan");
  184.         error = -ENOMEM;
  185.         goto err0;
  186.     }

  187.     tps6507x_dev->ts = tsc;
  188.     tsc->mfd = tps6507x_dev;
  189.     tsc->dev = tps6507x_dev->dev;
  190.     
  191.     //分配一个input_dev接口,并初始化一些基本的成员
  192.     input_dev = input_allocate_device();
  193.     if (!input_dev) {
  194.         dev_err(tsc->dev, "Failed to allocate input device.n");
  195.         error = -ENOMEM;
  196.         goto err1;
  197.     }
  198.     
  199.     input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);//设备支持的事件类型为按键事件和绝对坐标事件 
  200.     input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);//按键事件支持的子事件类型 
  201.     
  202.     //MAX_10BIT=0x3FF,设置ABS_X编码值范围为0-0x3ff,因为mini2440的AD转换出的数据最大为10位,所以不会超过0x3ff
  203.     input_set_abs_params(input_dev, ABS_X, 0, MAX_10BIT, 0, 0);//这个是设置ad转换的x坐标
  204.     input_set_abs_params(input_dev, ABS_Y, 0, MAX_10BIT, 0, 0);//这个是设置ad转换的y坐标
  205.     input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_10BIT, 0, 0);//这个是设置触摸屏是否按下的标志
  206.     
  207.     input_dev->name = "TPS6507x Touchscreen";
  208.     input_dev->id.bustype = BUS_I2C;//总线类型是I2C
  209.     input_dev->dev.parent = tsc->dev;//父设备

  210.     snprintf(tsc->phys, sizeof(tsc->phys),"%s/input0", dev_name(tsc->dev));
  211.     input_dev->phys = tsc->phys;

  212.     dev_dbg(tsc->dev, "device: %sn", input_dev->phys);

  213.     input_set_drvdata(input_dev, tsc);//保存tsc结构到input_dev中
  214.     tsc->input_dev = input_dev;//tsc结构指向初始化过的input_dev设备

  215.     INIT_DELAYED_WORK(&tsc->work, tps6507x_ts_handler);
  216.     tsc->wq = create_workqueue("TPS6507x Touchscreen");

  217.     if (init_data) {
  218.         tsc->poll_period = init_data->poll_period;//触摸屏采样时间30ms
  219.         tsc->vref = init_data->vref;//turn off vref when not using A/D
  220.         tsc->min_pressure = init_data->min_pressure;//触摸屏最小压力0x30
  221.         input_dev->id.vendor = init_data->vendor;//0
  222.         input_dev->id.product = init_data->product;//65070
  223.         input_dev->id.version = init_data->version;//0x100
  224.     } else {
  225.         tsc->poll_period = TSC_DEFAULT_POLL_PERIOD;
  226.         tsc->min_pressure = TPS_DEFAULT_MIN_PRESSURE;
  227.     }
  228.     
  229.     //设置设备standby状态
  230.     error = tps6507x_adc_standby(tsc);
  231.     if (error)
  232.         goto err2;
  233.     
  234.     //注册一个input设备
  235.     error = input_register_device(input_dev);
  236.     if (error)
  237.         goto err2;

  238.     schd = queue_delayed_work(tsc->wq, &tsc->work,msecs_to_jiffies(tsc->poll_period));

  239.     if (schd)
  240.         tsc->polling = 1;
  241.     else {
  242.         tsc->polling = 0;
  243.         dev_err(tsc->dev, "schedule failed");
  244.         goto err2;
  245.      }
  246.     platform_set_drvdata(pdev, tps6507x_dev);

  247.     return 0;

  248. err2:
  249.     cancel_delayed_work_sync(&tsc->work);
  250.     destroy_workqueue(tsc->wq);
  251.     input_free_device(input_dev);
  252. err1:
  253.     kfree(tsc);
  254.     tps6507x_dev->ts = NULL;
  255. err0:
  256.     return error;
  257. }

  258. int input_register_device(struct input_dev *dev)
  259. {
  260.     //这个原子变量,代表总共注册的input设备,每注册一个加1,因为是静态变量,所以每次调用都不会清零的 
  261.     static atomic_t input_no = ATOMIC_INIT(0);
  262.     struct input_handler *handler;
  263.     const char *path;
  264.     int error;

  265.     //EN_SYN这个是设备都要支持的事件类型,所以要设置 
  266.     __set_bit(EV_SYN, dev->evbit);

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

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

  271.     //这个内核定时器是为了重复按键而设置的
  272.     //rep主要是处理重复按键,如果没有定义dev->rep[REP_DELAY]和dev->rep[REP_PERIOD], 
  273.   //则将其赋值为默认值。dev->rep[REP_DELAY]是指第一次按下多久算一次,这里是250ms, 
  274.   //dev->rep[REP_PERIOD]指如果按键没有被抬起,每33ms算一次。 
  275.     init_timer(&dev->timer);
  276.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
  277.         dev->timer.data = (long) dev;
  278.         dev->timer.function = input_repeat_key;
  279.         dev->rep[REP_DELAY] = 250;
  280.         dev->rep[REP_PERIOD] = 33;
  281.         //如果没有定义有关重复按键的相关值,就用内核默认的 
  282.     }
  283.     
  284.     /*如果dev没有定义getkeycode和setkeycode,则赋默认值。他们的作用一个是获得键的扫描码,一个是设置键的扫描码*/
  285.     if (!dev->getkeycode && !dev->getkeycode_new)
  286.         dev->getkeycode_new = input_default_getkeycode;

  287.     if (!dev->setkeycode && !dev->setkeycode_new)
  288.         dev->setkeycode_new = input_default_setkeycode;
  289.     
  290.     //设置input_dev中device的名字,这个名字会在/class/input中出现 
  291.     dev_set_name(&dev->dev, "input%ld",(unsigned long) atomic_inc_return(&input_no) - 1);

  292.     error = device_add(&dev->dev);//添加input设备,注册到linux设备模型中,生成一系列的sys相关文件,udev会根据dev文件生成设备节点
  293.     if (error)
  294.         return error;

  295.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
  296.     printk(KERN_INFO "input: %s as %sn",dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
  297.     kfree(path);

  298.     error = mutex_lock_interruptible(&input_mutex);
  299.     if (error) {
  300.         device_del(&dev->dev);
  301.         return error;
  302.     }

  303.     list_add_tail(&dev->node, &input_dev_list);//将新分配的input设备连接到input_dev_list链表上 

  304.     list_for_each_entry(handler, &input_handler_list, node)//遍历input_handler_list链表,配对input_dev和input_handler
  305.         input_attach_handler(dev, handler);

  306.     input_wakeup_procfs_readers();//与proc文件系统有关

  307.     mutex_unlock(&input_mutex);

  308.     return 0;
  309. }

  310. 四、输入子系统核心分析
  311. static const struct file_operations input_fops = {
  312.     .owner = THIS_MODULE,
  313.     .open = input_open_file,
  314.     .llseek = noop_llseek,
  315. };

  316. struct class input_class = {
  317.     .name        = "input",
  318.     .devnode    = input_devnode,
  319. };

  320. static int __init input_init(void)
  321. {
  322.     int err;
  323.     //向内核注册一个类,用于linux设备模型。注册后会在/sys/class下面出现input目录 
  324.     err = class_register(&input_class);
  325.     if (err) {
  326.         printk(KERN_ERR "input: unable to register input_dev classn");
  327.         return err;
  328.     }
  329.     
  330.     //和proc文件系统有关,暂时不管 
  331.     err = input_proc_init();
  332.     if (err)
  333.         goto fail1;
  334.     
  335.     //注册字符设备,以主设备号INPUT_MAJOR,次设备号0-255,注册266个设备,说明input设备最大只能有255个 
  336.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
  337.     if (err) {
  338.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
  339.         goto fail2;
  340.     }

  341.     return 0;

  342.  fail2:    input_proc_exit();
  343.  fail1:    class_unregister(&input_class);
  344.     return err;
  345. }


  346. . 事件处理层分析(以evdev事件处理器为例)
  347. 1.主要数据结构
  348. (1) evdev设备结构
  349. struct evdev { 
  350.     int exist; 
  351.     int open; //打开标志 
  352.     int minor; //次设备号 
  353.     struct input_handle handle; //关联的input_handle 
  354.     wait_queue_head_t wait; //等待队列,当进程读取设备,而没有事件产生的时候,进程就会睡在其上面 
  355.     struct evdev_client *grab; //强制绑定的evdev_client结构,这个结构后面再分析 
  356.     struct list_head client_list; //evdev_client 链表,这说明一个evdev设备可以处理多个evdev_client,可以有多个进程访问evdev设备 
  357.     spinlock_t client_lock; /* protects client_list */ 
  358.     struct mutex mutex; 
  359.     struct device dev; //device结构,说明这是一个设备结构 
  360. }; 
  361. //evdev结构体在配对成功的时候生成,由handler->connect生成,对应设备文件为/class/input/event(n),如触摸屏驱动的event0,这个设备是用户空间要访问的设备,可以理解它是一个虚拟设备,因为没有对应的硬件,但是通过handle->dev 就可以找到input_dev结构,而它对应着触摸屏,设备文件为/class/input/input0。这个设备结构生成之后保存在evdev_table中,索引值是minor。

  362. (2)evdev用户端结构
  363. struct evdev_client { 
  364.     struct input_event buffer[EVDEV_BUFFER_SIZE];//这个是一个input_event数据结构的数组,input_event代表一个事件,基本成员:类型(type),编码(code),值(value) 
  365.     int head; //针对buffer数组的索引 
  366.     int tail; //针对buffer数组的索引,当head与tail相等的时候,说明没有事件 
  367.     spinlock_t buffer_lock; /* protects access to buffer, head and tail */ 
  368.     struct fasync_struct *fasync; //异步通知函数 
  369.     struct evdev *evdev; //evdev设备 
  370.     struct list_head node; // evdev_client 链表项 
  371. }; 
  372. //这个结构在进程打开event0设备的时候调用evdev的open方法,在open中创建这个结构,并初始化。在关闭设备文件的时候释放这个结构。

  373. (3)input_event结构
  374. struct input_event { 
  375.     struct timeval time; //事件发生的时间 
  376.     __u16 type; //事件类型 
  377.     __u16 code; //子事件 
  378.     __s32 value; //事件的value 
  379. }; 

  380. 2.事件处理层与用户程序和输入子系统核心打交道,是他们两层的桥梁。一般内核有好几个事件处理器,像evdev mousedev jotdev。evdev事件处理器可以处理所有的事件,触摸屏驱动就是用的这个,所以下面分析这个事件处理器的实现。它也是作为模块注册到内核中的,首先分析它的模块初始化函数。
  381. static const struct file_operations evdev_fops = {
  382.     .owner        = THIS_MODULE,
  383.     .read        = evdev_read,
  384.     .write        = evdev_write,
  385.     .poll        = evdev_poll,
  386.     .open        = evdev_open,
  387.     .release    = evdev_release,
  388.     .unlocked_ioctl    = evdev_ioctl,
  389. #ifdef CONFIG_COMPAT
  390.     .compat_ioctl    = evdev_ioctl_compat,
  391. #endif
  392.     .fasync        = evdev_fasync,
  393.     .flush        = evdev_flush,
  394.     .llseek        = no_llseek,
  395. };

  396. static const struct input_device_id evdev_ids[] = {
  397.     { .driver_info = 1 },    //适合所有的类型的设备
  398.     { },            /* Terminating zero entry */
  399. };

  400. static struct input_handler evdev_handler = {
  401.     .event        = evdev_event, //向系统报告input事件,系统通过read方法读取
  402.     .connect    = evdev_connect,//和input_dev匹配后调用connect构建
  403.     .disconnect    = evdev_disconnect,
  404.     .fops        = &evdev_fops,//event设备文件的操作方法
  405.     .minor        = EVDEV_MINOR_BASE,//次设备号基准值
  406.     .name        = "evdev",
  407.     .id_table    = evdev_ids,//匹配规则
  408. };

  409. static int __init evdev_init(void)
  410. {
  411.     //模块初始化函数就调用一个注册handler函数,将evdev_handler注册到系统中。
  412.     return input_register_handler(&evdev_handler);
  413. }

  414. int input_register_handler(struct input_handler *handler)
  415. {
  416.     struct input_dev *dev;
  417.     int retval;

  418.     retval = mutex_lock_interruptible(&input_mutex);
  419.     if (retval)
  420.         return retval;

  421.     INIT_LIST_HEAD(&handler->h_list);

  422.     if (handler->fops != NULL) {
  423.         if (input_table[handler->minor >> 5]) {
  424.             retval = -EBUSY;
  425.             goto out;
  426.         }
  427.         input_table[handler->minor >> 5] = handler;//添加到全局数组中
  428.         //input_table,每个注册的handler都会将自己保存到这里,索引值为handler->minor右移5为,也就是除以32 
  429.     //为什么会这样呢,因为每个handler都会处理最大32个input_dev,所以要以minor的32为倍数对齐,这个minor是传进来的handler的MINOR_BASE 
  430.     //每一个handler都有一个这一个MINOR_BASE,以evdev为例,EVDEV_MINOR_BASE = 64,可以看出系统总共可以注册8个handler 
  431.     }
  432.     
  433.     //连接到input_handler_list链表中
  434.     list_add_tail(&handler->node, &input_handler_list);

  435.     list_for_each_entry(dev, &input_dev_list, node)//配对,遍历input_dev_list链表中的input_dev设备,与对应的input_handler结构配对,和注册input_dev过程一样的
  436.         input_attach_handler(dev, handler); 

  437.     input_wakeup_procfs_readers();//与proc文件系统有关

  438.  out:
  439.     mutex_unlock(&input_mutex);
  440.     return retval;
  441. }

  442. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
  443. {
  444.     const struct input_device_id *id;
  445.     int error;

  446.     id = input_match_device(handler, dev);//这个是主要的配对函数,主要比较id中的各项
  447.     if (!id)
  448.         return -ENODEV;
  449.     
  450.     //配对成功调用handler的connect函数,这个函数在事件处理器中定义,主要生成一个input_handle结构,并初始化,还生成一个事件处理器相关的设备结构,
  451.     error = handler->connect(handler, dev, id);//调用evdev_connect
  452.     if (error && error != -ENODEV)
  453.         printk(KERN_ERR"input: failed to attach handler %s to device %s, ""error: %dn",handler->name, kobject_name(&dev->dev.kobj), error);

  454.     return error;
  455. }

  456. static const struct input_device_id *input_match_device(struct input_handler *handler,struct input_dev *dev)
  457. {
  458.     const struct input_device_id *id;
  459.     int i;

  460.     for (id = handler->id_table; id->flags || id->driver_info; id++) {//id->driver_info=1,表示可以配对所有

  461.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
  462.             if (id->bustype != dev->id.bustype)
  463.                 continue;

  464.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
  465.             if (id->vendor != dev->id.vendor)
  466.                 continue;

  467.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
  468.             if (id->product != dev->id.product)
  469.                 continue;

  470.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
  471.             if (id->version != dev->id.version)
  472.                 continue;
  473.         
  474.         //配对成功,进入下面的宏
  475.         MATCH_BIT(evbit, EV_MAX);
  476.         MATCH_BIT(keybit, KEY_MAX);
  477.         MATCH_BIT(relbit, REL_MAX);
  478.         MATCH_BIT(absbit, ABS_MAX);
  479.         MATCH_BIT(mscbit, MSC_MAX);
  480.         MATCH_BIT(ledbit, LED_MAX);
  481.         MATCH_BIT(sndbit, SND_MAX);
  482.         MATCH_BIT(ffbit, FF_MAX);
  483.         MATCH_BIT(swbit, SW_MAX);
  484.     
  485.         //没有match函数
  486.         if (!handler->match || handler->match(handler, dev))
  487.             return id;
  488.     }

  489.     return NULL;
  490. }

  491. //如果匹配上了就会创建一个evdev,它里边封装了一个handle,会把input_dev和input_handler关联到一起。关系如下:

  492. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,const struct input_device_id *id)
  493. {
  494.     struct evdev *evdev;
  495.     int minor;
  496.     int error;
  497.     
  498.     //EVDEV_MINORS为32,说明evdev这个handler可以同时有32个输入设备和他配对,evdev_table中以minor(非次设备号,但是有一个换算关系)存放evdev结构体
  499.     for (minor = 0; minor < EVDEV_MINORS; minor++)
  500.         if (!evdev_table[minor])
  501.             break;

  502.     if (minor == EVDEV_MINORS) {//这个说明32个位置全都被占用了,连接失败 
  503.         printk(KERN_ERR "evdev: no more free evdev devicesn");
  504.         return -ENFILE;
  505.     }
  506.     
  507.     //分配一个evdev结构体,这个结构体是evdev事件处理器特有的
  508.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
  509.     if (!evdev)
  510.         return -ENOMEM;
  511.     
  512.     //初始化结构体的一些成员
  513.     INIT_LIST_HEAD(&evdev->client_list);
  514.     spin_lock_init(&evdev->client_lock);
  515.     mutex_init(&evdev->mutex);
  516.     init_waitqueue_head(&evdev->wait);
  517.     
  518.     //这个是设置evdev中device的名字,他将出现在/class/input中。 
  519.   //前面也有一个device是input_dev的,名字是input(n),注意与他的不同 
  520.   //这个结构是配对后的虚拟设备结构,没有对应的硬件,但是通过它可以找到相关的硬件 
  521.     dev_set_name(&evdev->dev, "event%d", minor);
  522.     evdev->exist = true;
  523.     evdev->minor = minor;
  524.     
  525.     //因为evdev中包含handle了,所以初始化它就可以了,这样就连接了input_handler与input_dev
  526.     evdev->handle.dev = input_get_device(dev);
  527.     evdev->handle.name = dev_name(&evdev->dev);
  528.     evdev->handle.handler = handler;
  529.     evdev->handle.private = evdev;
  530.     //注意:这个minor不是真正的次设备号,还要加上EVDEV_MINOR_BASE 
  531.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
  532.     evdev->dev.class = &input_class;
  533.     evdev->dev.parent = &dev->dev;//配对生成的device,父设备是与他相关连的input_dev
  534.     evdev->dev.release = evdev_free;
  535.     device_initialize(&evdev->dev);//做一些初始化device结构

  536.     error = input_register_handle(&evdev->handle);// 注册一个input_handle结构体
  537.     if (error)
  538.         goto err_free_evdev;
  539.     
  540.     //这个函数只做了一件事,就是把evdev结构保存到evdev_table中,这个数组也minor为索引,evdev_table[evdev->minor] = evdev; 
  541.     error = evdev_install_chrdev(evdev);
  542.     if (error)
  543.         goto err_unregister_handle;

  544.     error = device_add(&evdev->dev);//注册到linux设备模型中,生成一系列的sys相关文件,udev会根据dev文件生成设备节点
  545.     if (error)
  546.         goto err_cleanup_evdev;

  547.     return 0;

  548.  err_cleanup_evdev:
  549.     evdev_cleanup(evdev);
  550.  err_unregister_handle:
  551.     input_unregister_handle(&evdev->handle);
  552.  err_free_evdev:
  553.     put_device(&evdev->dev);
  554.     return error;
  555. }

  556. //这个函数基本没做什么事,就是把一个handle结构体通过d_node链表项,分别链接到input_dev的h_list,input_handler的h_list上。以后通过这个h_list就可以遍历相关的input_handle了。
  557. int input_register_handle(struct input_handle *handle) 
  558. { 
  559.     struct input_handler *handler = handle->handler; 
  560.     struct input_dev *dev = handle->dev; 
  561.     int error; 
  562.   
  563.     error = mutex_lock_interruptible(&dev->mutex); 
  564.     if (error) 
  565.         return error; 
  566.     list_add_tail_rcu(&handle->d_node, &dev->h_list); //将handle的d_node,链接到其相关的input_dev的h_list链表中 
  567.     mutex_unlock(&dev->mutex); 
  568.   
  569.     list_add_tail(&handle->h_node, &handler->h_list);//将handle的h_node,链接到其相关的input_handler的h_list链表中 
  570.     if (handler->start)//字段为空
  571.         handler->start(handle); 
  572.     return 0; 
  573. } 

  574. 3.evdev设备结点的open()操作
  575. 我们知道.对主设备号为INPUT_MAJOR的设备节点进行操作,会将操作集转换成handler的操作集.在evdev中,这个操作集就是evdev_fops.对应的open函数如下示:
  576. static int evdev_open(struct inode *inode, struct file *file)
  577. {
  578.     struct evdev *evdev;
  579.     struct evdev_client *client;
  580.     int i = iminor(inode) - EVDEV_MINOR_BASE;//就得到了在evdev_table[ ]中的序号
  581.     unsigned int bufsize;
  582.     int error;

  583.     if (>= EVDEV_MINORS)
  584.         return -ENODEV;

  585.     error = mutex_lock_interruptible(&evdev_table_mutex);
  586.     if (error)
  587.         return error;
  588.         
  589.     evdev = evdev_table[i];//将数组中对应的evdev取出.
  590.     if (evdev)
  591.         get_device(&evdev->dev);//递增devdev中device的引用计数.
  592.     mutex_unlock(&evdev_table_mutex);

  593.     if (!evdev)
  594.         return -ENODEV;
  595.     
  596.     //evdev_client的buffer大小
  597.     bufsize = evdev_compute_buffer_size(evdev->handle.dev);
  598.     //打开的时候创建一个evdev_client
  599.     client = kzalloc(sizeof(struct evdev_client) +bufsize * sizeof(struct input_event),GFP_KERNEL);
  600.     if (!client) {
  601.         error = -ENOMEM;
  602.         goto err_put_evdev;
  603.     }

  604.     client->bufsize = bufsize;//buffer size
  605.     spin_lock_init(&client->buffer_lock);
  606.     client->evdev = evdev;//指向evdev结构,将evdev和client绑定到一起
  607.     evdev_attach_client(evdev, client);

  608.     error = evdev_open_device(evdev);//调用打开真正的底层设备函数
  609.     if (error)
  610.         goto err_free_client;

  611.     file->private_data = client;//将file->private_data指向刚刚建的client,后边会用到的
  612.     nonseekable_open(inode, file);

  613.     return 0;

  614.  err_free_client:
  615.     evdev_detach_client(evdev, client);
  616.     kfree(client);
  617.  err_put_evdev:
  618.     put_device(&evdev->dev);
  619.     return error;
  620. }

  621. static int evdev_open_device(struct evdev *evdev)
  622. {
  623.     int retval;

  624.     retval = mutex_lock_interruptible(&evdev->mutex);
  625.     if (retval)
  626.         return retval;

  627.     if (!evdev->exist)/*如果设备不存在,返回错误*/ 
  628.         retval = -ENODEV;
  629.     else if (!evdev->open++) {//递增打开计数
  630.         retval = input_open_device(&evdev->handle);//如果是被第一次打开,则调用input_open_device
  631.         if (retval)
  632.             evdev->open--;
  633.     }

  634.     mutex_unlock(&evdev->mutex);
  635.     return retval;
  636. }

  637. int input_open_device(struct input_handle *handle)
  638. {
  639.     struct input_dev *dev = handle->dev;//根据input_handle找到对应的input_dev设备
  640.     int retval;

  641.     retval = mutex_lock_interruptible(&dev->mutex);
  642.     if (retval)
  643.         return retval;

  644.     if (dev->going_away) {
  645.         retval = -ENODEV;
  646.         goto out;
  647.     }

  648.     handle->open++;//递增handle的打开计数

  649.     if (!dev->users++ && dev->open)//如果是第一次打开.则调用input device的open()函数
  650.         retval = dev->open(dev);

  651.     if (retval) {
  652.         dev->users--;
  653.         if (!--handle->open) {
  654.             synchronize_rcu();
  655.         }
  656.     }

  657.  out:
  658.     mutex_unlock(&dev->mutex);
  659.     return retval;
  660. }

  661. 4.用户进程读取event的底层实现
  662. static ssize_t evdev_read(struct file *file, char __user *buffer,size_t count, loff_t *ppos)
  663. {
  664.     struct evdev_client *client = file->private_data;//就是刚才在open函数中保存的evdev_client
  665.     struct evdev *evdev = client->evdev;
  666.     struct input_event event;
  667.     int retval;
  668.     
  669.     if (count < input_event_size())//count小于input_event结构的size,则返回
  670.         return -EINVAL;
  671.     
  672.     //如果client的环形缓冲区中没有数据并且是非阻塞的,那么返回-EAGAIN,也就是try again
  673.     if (client->head == client->tail && evdev->exist &&(file->f_flags & O_NONBLOCK))
  674.         return -EAGAIN;
  675.     
  676.     //如果没有数据,并且是阻塞的,则在等待队列上等待吧
  677.     retval = wait_event_interruptible(evdev->wait,client->head != client->tail || !evdev->exist);
  678.     if (retval)
  679.         return retval;

  680.     if (!evdev->exist)
  681.         return -ENODEV;
  682.         
  683.     //如果获得了数据则取出来,调用evdev_fetch_next_event
  684.     while (retval + input_event_size() <= count && evdev_fetch_next_event(client, &event)) {

  685.         if (input_event_to_user(buffer + retval, &event))//input_event_to_user调用copy_to_user传入用户程序中,这样读取完成
  686.             return -EFAULT;

  687.         retval += input_event_size();
  688.     }

  689.     return retval;
  690. }

  691. static int evdev_fetch_next_event(struct evdev_client *client, struct input_event *event) 
  692. { 
  693.     int have_event; 
  694.   
  695.     spin_lock_irq(&client->buffer_lock); 
  696.     /*先判断一下是否有数据*/ 
  697.     have_event = client->head != client->tail; 
  698.     /*如果有就从环形缓冲区的取出来,记得是从head存储,tail取出*/ 
  699.     if (have_event) { 
  700.         *event = client->buffer[client->tail++]; 
  701.         client->tail &= EVDEV_BUFFER_SIZE - 1; 
  702.     } 
  703.     spin_unlock_irq(&client->buffer_lock); 
  704.     return have_event; 
  705. } 

  706. int input_event_to_user(char __user *buffer, const struct input_event *event) 
  707. { 
  708.     /*如果设置了标志INPUT_COMPAT_TEST就将事件event包装成结构体compat_event*/ 
  709.     if (INPUT_COMPAT_TEST) { 
  710.         struct input_event_compat compat_event; 
  711.         compat_event.time.tv_sec = event->time.tv_sec; 
  712.         compat_event.time.tv_usec = event->time.tv_usec; 
  713.         compat_event.type = event->type; 
  714.         compat_event.code = event->code; 
  715.         compat_event.value = event->value; 
  716.         /*将包装成的compat_event拷贝到用户空间*/ 
  717.         if (copy_to_user(buffer, &compat_event, sizeof(struct input_event_compat))) 
  718.             return -EFAULT; 
  719.     } else { 
  720.         /*否则,将event拷贝到用户空间*/ 
  721.         if (copy_to_user(buffer, event, sizeof(struct input_event))) 
  722.             return -EFAULT; 
  723.     } 
  724.     return 0; 
  725. } 

  726. . 事件传递过程
  727. 1. 事件产生
  728. 当按下触摸屏时,进入触摸屏按下中断,开始ad转换,ad转换完成进入ad完成中断,在这个终端中将事件发送出去,调用
  729. input_report_abs(dev, ABS_X, xp);
  730. input_report_abs(dev, ABS_Y, yp); 这两个函数调用了 input_event(dev, EV_ABS, code, value)
  731. 所有的事件报告函数都调用这个函数。
  732. 2. 事件报告
  733. 1)input_event 函数分析,这个函数定义在input.c中
  734. void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 
  735. { 
  736.     unsigned long flags; 
  737.     
  738.     if (is_event_supported(type, dev->evbit, EV_MAX)) {//判断是否支持此种事件类型和事件类型中的编码类型 
  739.         spin_lock_irqsave(&dev->event_lock, flags); 
  740.         add_input_randomness(type, code, value); //对系统随机熵池有贡献,因为这个也是一个随机过程 
  741.          
  742.         input_handle_event(dev, type, code, value); //这个函数是事件处理的关键函数
  743.          
  744.         spin_unlock_irqrestore(&dev->event_lock, flags); 
  745.     } 
  746. } 

  747. 2)input_handle_event 函数分析,这个函数定义在input.c中
  748. static void input_handle_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 
  749. { 
  750.     int disposition = INPUT_IGNORE_EVENT; //默认的操作:忽略
  751.   
  752.     switch (type) { 
  753.         ...... 
  754.     case EV_KEY: 
  755.             ////检查按键是否为驱动所支持,只有之前注册过的按键才会继续传递;检查报告的按键状态是否和上次相同,如果连续多次报告按键按下,则只处理第一次
  756.         if (is_event_supported(code, dev->keybit, KEY_MAX) && !!test_bit(code, dev->key) != value) { 
  757.             if (value != 2) {//如果不是连击事件 
  758.                 __change_bit(code, dev->key);//翻转按键的当前状态(按下和释放) 
  759.                 if (value)//如果是按下,则开始连击计时
  760.                     input_start_autorepeat(dev, code); 
  761.                 else 
  762.                     input_stop_autorepeat(dev); 
  763.             } 
  764.             disposition = INPUT_PASS_TO_HANDLERS;//标记消息传递方向 
  765.         } 
  766.         break; 
  767.         ...... 
  768.     if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN) 
  769.         dev->sync = 0; 
  770.   
  771.     if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event) 
  772.         dev->event(dev, type, code, value); 
  773.   
  774.     if (disposition & INPUT_PASS_TO_HANDLERS) 
  775.         input_pass_event(dev, type, code, value); 
  776. } 
  777. 这个函数主要是根据事件类型的不同,做相应的处理。这里之关心EV_KEY类型,其他函数和事件传递关系不大,只要关心disposition这个是事件处理的方式,默认的是INPUT_IGNORE_EVENT,忽略这个事件,如果是INPUT_PASS_TO_HANDLERS则是传递给事件处理器,如果是INPUT_PASS_TO_DEVICE,则是传递给设备处理,触摸屏驱动没有定义这个。下面分析input_pass_event函数。
  778.  
  779. static void input_pass_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 
  780. { 
  781.     struct input_handle *handle; 
  782.     rcu_read_lock(); 
  783.       
  784.       //获取独占设备的handle的指针。如果有独占设备的handle,则仅仅将事件传给独占的handle对应的handler
  785.     handle = rcu_dereference(dev->grab);
  786.     if (handle) 
  787.             //这里直接调用了handler事件驱动对应的XX_event函数,这个XX_event函数把事件数据包传递给了handler,当应用程序使用XX_read时就可以读取到这些数据包
  788.         handle->handler->event(handle, type, code, value); 
  789.     else 
  790.         //如果没有绑定,则遍历dev的h_list链表,寻找handle,如果handle已经打开,说明有进程读取设备关联的evdev。 
  791.         list_for_each_entry_rcu(handle, &dev->h_list, d_node) 
  792.             if (handle->open) 
  793.                 handle->handler->event(handle, type, code, value);//调用相关的事件处理器的event函数,进行事件的处理,即evdev_event 
  794.     rcu_read_unlock(); 
  795. } 

  796. static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value) 
  797. { 
  798.     struct evdev *evdev = handle->private; 
  799.     struct evdev_client *client; 
  800.     struct input_event event; 
  801.   
  802.       //将传过来的事件,赋值给input_event结构 
  803.     do_gettimeofday(&event.time);//获取事件时间 
  804.     event.type = type; 
  805.     event.code = code; 
  806.     event.value = value; 
  807.           
  808.     rcu_read_lock(); 
  809.   
  810.     client = rcu_dereference(evdev->grab); //如果evdev绑定了client那么,处理这个客户端,触摸屏驱动没有绑定 
  811.     if (client) 
  812.         evdev_pass_event(client, &event); 
  813.     else 
  814.         //遍历client链表,调用evdev_pass_event函数 
  815.         list_for_each_entry_rcu(client, &evdev->client_list, node) 
  816.             evdev_pass_event(client, &event); 
  817.     
  818.     rcu_read_unlock(); 
  819.     wake_up_interruptible(&evdev->wait); //唤醒等待的进程 
  820. } 


  821. static void evdev_pass_event(struct evdev_client *client, struct input_event *event) 
  822. { 
  823.     spin_lock(&client->buffer_lock); 
  824.     client->buffer[client->head++] = *event;//将事件赋值给客户端的input_event 数组 
  825.     client->head &= EVDEV_BUFFER_SIZE - 1; 
  826.     spin_unlock(&client->buffer_lock); 
  827.   
  828.     kill_fasync(&client->fasync, SIGIO, POLL_IN); 
  829. } 
  830. 总结一下事件的传递过程:首先在驱动层中,调用inport_report_abs,然后他调用了input core层的input_event,input_event调用了input_handle_event对事件进行分派,调用input_pass_event,在这里他会把事件传递给具体的handler层,然后在相应handler的event处理函数中,封装一个event,然后把它投入evdev的那个client_list上的client的事件buffer中,等待用户空间来读取。

相关文章推荐

Linux Input子系统分析.pdf

  • 2012年03月22日 21:39
  • 335KB
  • 下载

Input子系统分析

Linux  Input 设备驱动 1认识和使用 input 事件: 1.1Linux input 驱动分类 Input驱动程序是Linux输入设备的驱动程序,分成游戏杆(joystick)、鼠...

input输入子系统源码部分函数分析

/* * 源文件目录: * /drivers/input/input.c */ 入口函数: static int __init input_init(void) 1、 err = c...
  • toraloo
  • toraloo
  • 2013年04月09日 15:28
  • 1079

input子系统九之系统流程全面分析

1      input输入子系统整体流程 本节分析input子系统在内核中的实现,包括输入子系统(Input Core),事件处理层(Event Handler)和设备驱动层。由于上节代码讲解...

inux input子系统分析---2、主要函数

一. 各种注册函数     因为分析一所讲的每种数据结构都代表一类对象,所以每种数据结构都会对应一个注册函数,他们都定义在子系统核心的input.c文件中。主要有三个注册函数      input_...

input输入子系统分析1

input_register_handler(struct input_handler *handler) /* 1: * 在开始的时候让input_handler的h_list指向自己,也就是一个...

linux input 子系统实例分析

一,前言: 1, 近日要写一个很特殊的键盘驱动,故对linux的input子系统分析了一番,写下分析笔记,以防不日即忘。 2, 使用input子系统的一般流程为:input_allocate_d...

linux input 子系统分析 二

linux input子系统分析--主要函数  一. 各种注册函数     因为分析一所讲的每种数据结构都代表一类对象,所以每种数据结构都会对应一个注册函数,他们都定义在子系统核心的input.c...

android input子系统分析---事件层

3 核心层 核心层主要都是在input.c中处理。这里会处理各种Event,各种sensor,触摸事件,按键事件等等。流程图如下, input_event方法直接调用input_han...

input子系统学习笔记五 按键驱动实例分析上

【感谢终结者投递本文】         下面是按键驱动的简单例子,这个输入设备只有一个按键,按键被连接到一条中断线上,当按键被按下时,将产生一个中断,内核将检测到这个中断,并对其进行处理。代码含注释...
  • linux58
  • linux58
  • 2012年06月27日 22:53
  • 489
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:input子系统分析
举报原因:
原因补充:

(最多只允许输入30个字)