input device

转载自：点击打开链接 

input是一种典型的驱动，目标是支持所有的linux输入设备，当前仅支持USB（2.4）， 2。5/2.6以后将会支持大多数现有输入系统。

这部分模块直接与硬件交互，传递事件给输入模块（input module).
他同时也能处理分辨输入事件。


关键字：
HID：人机交互设备（界面），此类设备固件必须支持HID报表格式。例如touchscreen中所使用到的
input_report_abs
input_report_key
input_mt_sync


./Documnetation/input/ 中有如下文件
amijoy.txt
appletouch.txt
atarikbd.txt
bcm5974.txt
cd32.txt
cma3000_d0x.txt
cs461x.txt
elantech.txt
event-codes.txt
ff.txt
gameport-programming.txt
iforce-protocol.txt
input-programming.txt
input.txt
interactive.fig
joystick-api.txt
joystick-parport.txt
joystick.txt
multi-touch-protocol.txt
notifier.txt
ntrig.txt
rotary-encoder.txt
sentelic.txt
shape.fig
walkera0701.txt
xpad.txt
yealink.txt


将其归类为3类
游戏杆类 *joy* , cd32.txt, gameport-programming.txt， rotary-encoder.txt（编码），walkera0701.txt，xpad.txt
触摸屏/板类 *touch*,bcm5974.txt,elantech.txt,ntrig.txt，
键盘类 atarikbd.txt,notifier.txt， sentelic.txt（鼠标），yealink.txt（电话面板）
动机加速探测 cma3000_d0x.txt,cs461x.txt,
震动（力反馈）探测 ff.txt， iforce-protocol.txt，（技术新颖 ff iforce 2套协议，后期跟进）
input_dev相关阐述类 event-codes.txt（通报事件编码），input-programming.txt（例子），input.txt（简单介绍，过于陈旧）


很多，量也很大，我决定从通用到特殊这样的顺序来阅读这些文档，先阅读input_dev通用相关阐述，然后针对个人所需阅读相关类型的通用文档，例如，键盘编码，然后再参考的阅读下某个特定的说明文档。
input.txt 这个是我们应该第一个看的文档，他简单的介绍了input_dev的用途
event-code.txt中讲述了一些详细的宏编码及其意义，注意内部介绍的发送顺序注意点。（注意并非所用宏关键字都已经完善eg EV_PWR）
翻译几句，将会用到的TS相关描述：
ABS_{X, Y}用于上报触摸点（注意区别与鼠标的REL_{X,Y}),触屏发生触摸时，必须使用BTN_TOUCH进行上报，BTN_TOOL_<name>也可用。


阅读input-programming.txt 了解input_dev的使用。
input_dev的使用
1.input_allocate_device 申请input_dev内存空间(NOTE:其使用位置）
2.设置input_dev的属性（接受发送事件类型）
3.注册input_register_device;
下图是我对input_dev的理解， 他可以看作一种通用型接口层（类似HAL），也可以独立作为一个驱动来进行对物理硬件的操作。
|------------------------------------------|
|                                                    |
|  input_dev                                  |
|                                                    |
|------------------------------------------|
| any other driver                       |
| or direct access                          |
| the phyiscal hardware                |
|------------------------------------------|
|                                                       |
| hardware                                     |
|____________________________|


*************************multi-touch-protocol.txt**************
这个协议是为了上报多个触点而规定的，按照设备的兼容性分为A类与B类
触点的信息按照顺序，以独立分隔的报文包发送ABS_MT事件。只识别ABS_MT事件。因为ABS_MT是被ST（single touch)所忽略的，所以MT可以在其基础上进行实现。


A类设备的驱动以input_mt_sync()函数在每个包的最后发送来区别不同的包，他会产生一个SYN_MT_REPORT事件，告诉接收者接收数据并准备下一次接收。
B类设备的驱动以input_mt_slot()函数在每个包发送前调用，这个会产生一个ABS_MT_SLOT事件。
所有的驱动以调用input_sync()函数作为多触点传输结束标志。
无状态A类协议与状态B类协议主要区别就是是否使用标记联系量来减少传输到用户层的数据数量。
这点表示没看懂，我看了下正在使用的源码，感觉2类就是分割不一样。有知道的请告知 qingluo
个人猜测是不用发送完整的XY坐标，如果只是单个坐标变换，仅需要发送ID与变换的那个坐标就行了。


多点触控，触摸压力的探测：
首先有2个变量
ABS_MT_TOUCH_MAJOR 手指尖实际触摸到屏幕的面积的直径
ABS_MT_WIDTH_MAJOR 整个手指的周长的等效面积的直径


ABS_MT_WIDTH_MAJOR ＝> ABS_MT_TOUCH_MAJOR 这个等式恒成立。
所以在刚开始触摸(轻触）时，TOUCH/WIDTH 比值较小，
当触摸压力增大，TOUCH值增加，TOUCH/WIDTH的比值增大；
当触摸压力减小，TOUCH值减小，TOUCH/WIDTH的比值减小；
这样就能智能的探测压力的变化了。在设备初始化期，我们可以设定并校正一个基础值。


其他的一些特性比较抽象，在以后用的到时候再提（实际上也比较新颖，但是在较为低端的触控IC上无法完全支持）。
***********************************接下来看源码*****************************************
通用型的源码文件有以下几个
input.c input-compat.c input-compat.h input-mt.c input-polldev.c
这几个文件在链接的时候会组合成input-core.o，这个就是input device的核心文件了。
首先看input.c:
来到最下面，额为什么是subsys_initcall而不是module_init呢？以前没有弄清楚这2个东西，现在来弄清吧！
参考文章：http://blog.youkuaiyun.com/heyunqi/article/details/1897108
这2个都会被#ifndef MODULE/#else/#endif区分成2种实现
非MODULE形式

首先来跟踪module_init

[cpp]  view plain copy print ?

1. include/linux/init.h中  
2. 258 /** 
3. 259  * module_init() - driver initialization entry point 
4. 260  * @x: function to be run at kernel boot time or module insertion 
5. 261  *  
6. 262  * module_init() will either be called during do_initcalls() (if 
7. 263  * builtin) or at module insertion time (if a module).  There can only 
8. 264  * be one per module. 
9. 265  */  
10. 266 #define module_init(x)  __initcall(x);  

继续深入跟踪__initcall(x)

[cpp]  view plain copy print ?

1. include/linux/init.h中  
2. 212 #define __initcall(fn) device_initcall(fn)  

好了接下来的跟踪等会儿进行，我们来跟踪subsys_init

[cpp]  view plain copy print ?

1. 在include/linux/init.h中  
2. 258 /** 
3. 259  * module_init() - driver initialization entry point 
4. 260  * @x: function to be run at kernel boot time or module insertion 
5. 261  *  
6. 262  * module_init() will either be called during do_initcalls() (if 
7. 263  * builtin) or at module insertion time (if a module).  There can only 
8. 264  * be one per module. 
9. 265  */  
10. 266 #define module_init(x)  __initcall(x);  

说明在MODULE形式中2者的最终实现是完全相同的，
接下来MODULE形式：
287 #define subsys_initcall(fn)     module_init(fn)  注意这个是不被建议的使用方式，具体参考282行
*****************************************************************************************

[cpp]  view plain copy print ?

1. 295 #define module_init(initfn)                 \  
2. 296     static inline initcall_t __inittest(void)       \  
3. 297     { return initfn; }                  \  
4. 298     int init_module(void) __attribute__((alias(#initfn)));  

这里就是一个简单的回调


接下来我们开非MODULE模式的__initcall(x)的具体实现。
他们都在

[cpp]  view plain copy print ?

1. 188 /* 
2. 189  * A "pure" initcall has no dependencies on anything else, and purely 
3. 190  * initializes variables that couldn't be statically initialized. 
4. 191  * 
5. 192  * This only exists for built-in code, not for modules. 
6. 193  */  
7. 194 #define pure_initcall(fn)       __define_initcall("0",fn,0)  
8. 195   
9. 196 #define core_initcall(fn)       __define_initcall("1",fn,1)  
10. 197 #define core_initcall_sync(fn)      __define_initcall("1s",fn,1s)  
11. 198 #define postcore_initcall(fn)       __define_initcall("2",fn,2)  
12. 199 #define postcore_initcall_sync(fn)  __define_initcall("2s",fn,2s)  
13. 200 #define arch_initcall(fn)       __define_initcall("3",fn,3)  
14. 201 #define arch_initcall_sync(fn)      __define_initcall("3s",fn,3s)  
15. 202 #define subsys_initcall(fn)     __define_initcall("4",fn,4)  
16. 203 #define subsys_initcall_sync(fn)    __define_initcall("4s",fn,4s)  
17. 204 #define fs_initcall(fn)         __define_initcall("5",fn,5)  
18. 205 #define fs_initcall_sync(fn)        __define_initcall("5s",fn,5s)  
19. 206 #define rootfs_initcall(fn)     __define_initcall("rootfs",fn,rootfs)  
20. 207 #define device_initcall(fn)     __define_initcall("6",fn,6)  
21. 208 #define device_initcall_sync(fn)    __define_initcall("6s",fn,6s)  
22. 209 #define late_initcall(fn)       __define_initcall("7",fn,7)  
23. 210 #define late_initcall_sync(fn)      __define_initcall("7s",fn,7s)  

这个中，深入__define_initcall

[cpp]  view plain copy print ?

1. 167 /* initcalls are now grouped by functionality into separate  
2. 168  * subsections. Ordering inside the subsections is determined 
3. 169  * by link order.  
4. 170  * For backwards compatibility, initcall() puts the call in  
5. 171  * the device init subsection. 
6. 172  * 
7. 173  * The `id' arg to __define_initcall() is needed so that multiple initcalls 
8. 174  * can point at the same handler without causing duplicate-symbol build errors. 
9. 175  */  
10. 176   
11. 177 #define __define_initcall(level,fn,id) \  
12. 178     static initcall_t __initcall_##fn##id __used \  
13. 179     __attribute__((__section__(".initcall" level ".init"))) = fn  

so subsys_initcall == __initcall_fn4 它将被链接器放于section  .initcall4.init. 中
在启动过程中，do_basic_setup--->do_initcalls里有以下代码:

[cpp]  view plain copy print ?

1. 699 static void __init do_initcalls(void)  
2. 700 {  
3. 701     initcall_t *fn;  
4. 702   
5. 703     for (fn = __early_initcall_end; fn < __initcall_end; fn++)  
6. 704         do_one_initcall(*fn);  
7. 705 }  
8. do_one_initcall中  
9. 666 int __init_or_module do_one_initcall(initcall_t fn)  
10. ......  
11. 671     if (initcall_debug)  
12. 672         ret = do_one_initcall_debug(fn);  
13. 673     else  
14. 674         ret = fn();  
15. ......  
16. 694 }  

完成初始化回调。
接下来看初始化函数

[cpp]  view plain copy print ?

1. 2139 static int __init input_init(void)  
2. 2140 {  
3. 2141     int err;  
4. 2142   
5. 2143     err = class_register(&input_class); //1.注册类型 input类  
6. 2144     if (err) {  
7. 2145         pr_err("unable to register input_dev class\n");  
8. 2146         return err;  
9. 2147     }  
10. 2148   
11. 2149     err = input_proc_init(); //2.做一些proc文件的初始化操作  
12. 2150     if (err)  
13. 2151         goto fail1;  
14. 2152   
15. 2153     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);//3.注册字符设备  
16. 2154     if (err) {  
17. 2155         pr_err("unable to register char major %d", INPUT_MAJOR);  
18. 2156         goto fail2;  
19. 2157     }  
20. 2158   
21. 2159     return 0;  
22. 2160   
23. 2161  fail2: input_proc_exit();  
24. 2162  fail1: class_unregister(&input_class);  
25. 2163     return err;  
26. 2164 }  

接下来一步一步分析。
第一步：注册input类

[cpp]  view plain copy print ?

1. 1632 struct class input_class = {  
2. 1633     .name       = "input",  
3. 1634     .devnode    = input_devnode,  
4. 1635 };  
5. 1636 EXPORT_SYMBOL_GPL(input_class);  

由于class是会被其他所使用的，所以我们应该将他符号外抛，name不解释了，devnode在注释中是Callback to provide the devtmpfs.
这个暂时不知，放一边先！
这里就注册了一个class。
第二步：proc文件初始化操作

[cpp]  view plain copy print ?

1. 1165 static int __init input_proc_init(void)  
2. 1166 {  
3. 1167     struct proc_dir_entry *entry;  
4. 1168   
5. 1169     proc_bus_input_dir = proc_mkdir("bus/input", NULL);  
6. 1170     if (!proc_bus_input_dir)  
7. 1171         return -ENOMEM;  
8. 1172   
9. 1173     entry = proc_create("devices", 0, proc_bus_input_dir,  
10. 1174                 &input_devices_fileops);  
11. 1175     if (!entry)  
12. 1176         goto fail1;  
13. 1177       
14. 1178     entry = proc_create("handlers", 0, proc_bus_input_dir,  
15. 1179                 &input_handlers_fileops);  
16. 1180     if (!entry)  
17. 1181         goto fail2;  
18. 1182   
19. 1183     return 0;   
20. 1184   
21. 1185  fail2: remove_proc_entry("devices", proc_bus_input_dir);  
22. 1186  fail1: remove_proc_entry("bus/input", NULL);  
23. 1187     return -ENOMEM;  
24. 1188 }  

这里创建了一个proc文件夹路径 bus/input  2个文件 devices， handlers，这里注意与这2个文件相关联的文件操作函数指针。
第三步：注册字符设备
看似完毕，实际上刚刚开始。具体的文件操作函数我们涉及到的时候再来看。
在某款multitouch产品的驱动初始化函数中，第一个首先调用的是input_alloc_device()

[cpp]  view plain copy print ?

1. 1638 /** 
2. 1639  * input_allocate_device - allocate memory for new input device 
3. 1640  * 
4. 1641  * Returns prepared struct input_dev or NULL.                                                                                            
5. 1642  * 
6. 1643  * NOTE: Use input_free_device() to free devices that have not been 
7. 1644  * registered; input_unregister_device() should be used for already 
8. 1645  * registered devices.    
9. 1646  */  
10. 1647 struct input_dev *input_allocate_device(void)  
11. 1648 {   
12. 1649     struct input_dev *dev;  
13. 1650     
14. 1651     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); //申请动态存储空间  
15. 1652     if (dev) {  
16. 1653         dev->dev.type = &input_dev_type; //设置struct device中的type属性  
17. 1654         dev->dev.class = &input_class;   //设置struct device中的class属性  
18. 1655         device_initialize(&dev->dev);    //稍后分析  
19. 1656         mutex_init(&dev->mutex);         //初始化互斥量  
20. 1657         spin_lock_init(&dev->event_lock); //初始化自旋锁  
21. 1658         INIT_LIST_HEAD(&dev->h_list);    //初始化input handlers链表，这个链表存放了所有与该设备相关联的input handlers，访问该链表时  
22. //注意使用mutex  
23. 1659         INIT_LIST_HEAD(&dev->node); //初始化node，node是用于将设备放到input_dev_list的  
24. 1660     
25. 1661         __module_get(THIS_MODULE); //这个不大理解，猜测是标记设备属于当前调用模块  
26. 1662     }  
27. 1663                            
28. 1664     return dev;  
29. 1665 }                          
30. 1666 EXPORT_SYMBOL(input_allocate_device);  

**********************************************************************************************************
接下来我们来深入分析下 device_initialize(),这个也是devcie_register函数的前半部分。
 

[cpp]  view plain copy print ?

1. 587 void device_initialize(struct device *dev)  
2. 588 {  
3. 589     dev->kobj.kset = devices_kset;  
4. 590     kobject_init(&dev->kobj, &device_ktype);  
5. 591     INIT_LIST_HEAD(&dev->dma_pools);  
6. 592     mutex_init(&dev->mutex);  
7. 593     lockdep_set_novalidate_class(&dev->mutex);  
8. 594     spin_lock_init(&dev->devres_lock);  
9. 595     INIT_LIST_HEAD(&dev->devres_head);  
10. 596     device_pm_init(dev);  
11. 597     set_dev_node(dev, -1);  
12. 598 }  

这也是最复杂的部分，我看着kobject，kset就头大，因为还没有理清他们。
参考文章1  http://www.cnblogs.com/leaven/archive/2010/04/24/1719191.html
参考文章2  http://blog.chinaunix.net/uid-11319766-id-3253414.html
文章2相对清晰很多。我的理解就是kobject，类似于JAVA中的OBJECT或QT中的QObject之类的，配置list_head与container_of，明确的体现了面向对象思想中的封装（内嵌），继承并小小的体现了“多态“。
589     dev->kobj.kset = devices_kset;
590     kobject_init(&dev->kobj, &device_ktype);
那么我们这里就是，dev中有自己的kobject，我们将他设置到devices_kset的链中去，我们就能发现在/sys/devices/目录下有出现相应的设备（内部包含了object)了。建议反复阅读文章2，深入理解linux如何管理模块的。


lockdep_set_novalidate_class(&dev->mutex);这个大概就是将这个互斥量映射到系统的管理模块中，让其他需要使用这个量的模块可以使用，恩，大概就这么猜，跳过。
 596     device_pm_init(dev);这个才是比较重要的，PC级开发都可以忽略，但是在嵌入式设备中，能耗管理是十分重要的一个指标与技术。
这里主要干了2件事
 

[cpp]  view plain copy print ?

1. 68 void device_pm_init(struct device *dev)  
2. 69 {                          
3. 70     dev->power.is_prepared = false;  
4. 71     dev->power.is_suspended = false;  
5. 72     init_completion(&dev->power.completion);  
6. 73     complete_all(&dev->power.completion);  
7. 74     dev->power.wakeup = NULL;  
8. 75     spin_lock_init(&dev->power.lock);  
9. 76     pm_runtime_init(dev);  
10. 77     INIT_LIST_HEAD(&dev->power.entry);  
11. 78 }  

1.初始化power相关的属性量
2.设置相关默认值与挂载相关的能源管理完成队列
**************************************哇，input_alloc_device都做了这么多东西**************************************************
接下来可以按照各自的需求设置一下input_device的支持的动作类型，与相应的初始化值。
注册input_device input_register_device()

[cpp]  view plain copy print ?

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;  
7.   
8.   
9.     /* Every input device generates EV_SYN/SYN_REPORT events. */  
10.     __set_bit(EV_SYN, dev->evbit);  
11.   
12.   
13.     /* KEY_RESERVED is not supposed to be transmitted to userspace. */  
14.     __clear_bit(KEY_RESERVED, dev->keybit);  
15.   
16.   
17.     /* Make sure that bitmasks not mentioned in dev->evbit are clean. */  
18.     input_cleanse_bitmasks(dev);  
19.   
20.   
21.     if (!dev->hint_events_per_packet)  
22.         dev->hint_events_per_packet =  
23.                 input_estimate_events_per_packet(dev);  
24.   
25.   
26.     /*    
27.      * If delay and period are pre-set by the driver, then autorepeating 
28.      * is handled by the driver itself and we don't do it in input.c. 
29.      */  
30.     init_timer(&dev->timer);  
31.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
32.         dev->timer.data = (long) dev;   
33.         dev->timer.function = input_repeat_key;  
34.         dev->rep[REP_DELAY] = 250;   
35.         dev->rep[REP_PERIOD] = 33;  
36.     }      
37.   
38.   
39.     if (!dev->getkeycode)  
40.         dev->getkeycode = input_default_getkeycode;  
41.     if (!dev->setkeycode)  
42.         dev->setkeycode = input_default_setkeycode;  
43.   
44.   
45.     dev_set_name(&dev->dev, "input%ld",  
46.              (unsigned long) atomic_inc_return(&input_no) - 1);  
47.   
48.   
49.     error = device_add(&dev->dev);  
50.     if (error)  
51.         return error;  
52.   
53.   
54.     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
55.     pr_info("%s as %s\n",  
56.         dev->name ? dev->name : "Unspecified device",  
57.         path ? path : "N/A");  
58.     printk("<qingluo>position mark\n");  
59.     kfree(path);  
60.   
61.   
62.     error = mutex_lock_interruptible(&input_mutex);  
63.     if (error) {  
64.         device_del(&dev->dev);  
65.         return error;  
66.     }  
67.   
68.   
69.     list_add_tail(&dev->node, &input_dev_list);  
70.   
71.   
72.     list_for_each_entry(handler, &input_handler_list, node)  
73.         input_attach_handler(dev, handler);  
74.   
75.   
76.     input_wakeup_procfs_readers();  
77.   
78.   
79.     mutex_unlock(&input_mutex);  
80.   
81.   
82.     return 0;  
83. }  

这个函数没有太多需要解释的，每个调用都很清晰，简单跟进深入一下就知道了，实现也不是很复杂。
接下来看看input实际工作过程：
例如某multitouch中，A类设备
首先调用

[cpp]  view plain copy print ?

1. input_mt_slot()  
2. static inline void input_mt_slot(struct input_dev *dev, int slot)  
3. {  
4. input_event(dev, EV_ABS, ABS_MT_SLOT, slot);  
5. }  
6.   
7.   
8. void input_event(struct input_dev *dev,  
9.          unsigned int type, unsigned int code, int value)  
10. {  
11.     unsigned long flags;  
12.   
13.   
14.     if (is_event_supported(type, dev->evbit, EV_MAX)) { //检查是否支持该类型的事件  
15.   
16.   
17.         spin_lock_irqsave(&dev->event_lock, flags);  
18.         add_input_randomness(type, code, value);  
19.         input_handle_event(dev, type, code, value);  
20.         spin_unlock_irqrestore(&dev->event_lock, flags);  
21.     }    
22. }  
23. EXPORT_SYMBOL(input_event);   
24.   
25.   
26. void add_input_randomness(unsigned int type, unsigned int code,  
27.                  unsigned int value)  
28. {  
29.     static unsigned char last_value;  
30.   
31.   
32.     /* ignore autorepeat and the like */  
33.     if (value == last_value)  
34.         return;  
35.   
36.   
37.     DEBUG_ENT("input event\n");  
38.     last_value = value;  
39.     add_timer_randomness(&input_timer_state,  
40.                  (type << 4) ^ code ^ (code >> 4) ^ value);  
41. }     
42. EXPORT_SYMBOL_GPL(add_input_randomness);