【驅動】input子系統全面分析

時間 2019-11-21

標籤驅動 input 子系統全面分析简体版

原文原文鏈接

初識linux輸入子系統

　　linux輸入子系統（linux input subsystem）從上到下由三層實現，分別爲：輸入子系統事件處理層（EventHandler）、輸入子系統核心層（InputCore）和輸入子系統設備驅動層。html

設備驅動層：主要實現對硬件設備的讀寫訪問，中斷設置，並把硬件產生的事件轉換爲核心層定義的規範提交給事件處理層。
核心層：爲設備驅動層提供了規範和接口。設備驅動層只要關心如何驅動硬件並得到硬件數據（例如按下的按鍵數據），而後調用核心層提供的接口，核心層會自動把數據提交給事件處理層。
事件處理層：則是用戶編程的接口（設備節點），並處理驅動層提交的數據處理。

input輸入子系統框架分析

　　輸入子系統由輸入子系統核心層（ Input Core ），驅動層和事件處理層（Event Handler）三部份組成。node

　　一個輸入事件，如鼠標移動，鍵盤按鍵按下，joystick的移動等等經過 input driver -> Input core -> Event handler -> userspace 到達用戶空間傳給應用程序。linux

1.系統核心層

　　主要功能編程

註冊主設備號
對於swi進入的open函數進行第一層處理，並經過次設備號選擇handler進入第二層open，也就是真正的open所在的file_operation,並返回該file_opration的fd
提供input_register_device跟input_register_handler函數分別用於註冊device跟handler

2.handler層（事件處理層）

　　handler層是純軟件層，包含不一樣的解決方案，如鍵盤，鼠標，遊戲手柄等，可是沒有設計到硬件方面的操做數組

　　對於不一樣的解決方案，都包含一個名爲input_handler的結構體，該結構體內含的主要成員以下數據結構

　　　　.id_table　　　一個存放該handler所支持的設備id的表（其實內部存放的是EV_xxx事件,用於判斷device是否支持該事件）框架

　　　　.fops　　　　　該handler的file_operation異步

　　　　.connect　　　鏈接該handler跟所支持device的函數async

　　　　.disconnect　　斷開該鏈接ide

　　　　.event　　　　事件處理函數，讓device調用

　　　　h_list　　　　也是一個鏈表，該鏈表保存着該handler到所支持的全部device的中間站：handle結構體的指針

3.device層（驅動層）

　　device是純硬件操做層，包含不一樣的硬件接口處理，如gpio等

　　對於每種不一樣的具體硬件操做，都對應着不一樣的input_dev結構體

　　該結構體內部也包含着一個h_list

4：input_handler_list和input_device_list

　　對於handler和device，分別用鏈表input_handler_list和input_device_list進行維護，

　　當handler或者device增長或減小的時候，分別往這兩鏈表增長或刪除節點。

5.input子系統框架圖

input子系統調用過程分析

　　1.當外部應用程序須要調用輸入子系統的open函數時，會先經過主設備號進入到核心層，而後經過次設備號進入handler層，再調用.fops內的open函數返回fd；

　　2.當外部應用程序須要調用輸入子系統的read函數時，會經過返回的fd調用.fop內的read函數，而後休眠，等待被.event函數喚醒

　　3.當外部中斷到達的時候，會先肯定中斷事件，而後用input_event上報事件，再經過h_list裏面的全部handle調用對應的handler中的.event函數，對read進行喚醒，而後在read中返回（也就是當device有多個對應的handler的時候,input_event會向全部的handler上報事件）

　　4.當須要加入新的handler時，須要先構建handler結構體，而後調用input_register_handler對該handler進行註冊

　　input_register_handler的內部實現：往input_handler_list加入新增的handler節點，而後對input_device_list的全部結點（也就是全部的device）進行遍歷，經過.id_table查看該device是否支持該handler,對支持的device調用.connect,一一地構建input_handle結構體,鏈接handler跟device

　　5.當須要加入新的device時，須要先構建input_dev結構體，而後調用input_register_device對該input_dev進行註冊

　　input_register_dev的內部實現：往input_device_list加入新增的device節點，而後對input_handler_list的全部結點（也就是全部的handler）進行遍歷，經過handler　的.id_table查看該handler是否支持該device,對支持的device調用該handler的.connect,一一地構建input_handle結構體,鏈接handler跟device

　　在輸入子系統框架下，咱們通常的編寫驅動也就是對device部分進行編寫（分配input_dev並配置，驅動入口，出口，中斷時進行中斷判斷，而後上報事件等），而後對該device的input_dev進行註冊

Input輸入子系統數據結構分析

input_dev

　　input_dev 這是input設備基本的設備結構，每一個input驅動程序中都必須分配初始化這樣一個結構，成員比較多

　　（1）有如下幾個數組：

    unsigned long evbit[BITS_TO_LONGS(EV_CNT)];   //事件支持的類型  
     // 下面是每種類型支持的編碼  
    unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];   //按鍵    
    unsigned long relbit[BITS_TO_LONGS(REL_CNT)];     
    unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];   //絕對座標，其中觸摸屏驅動使用的就是這個  
    unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];  
    unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];  
    unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];  
    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];  
    unsigned long swbit[BITS_TO_LONGS(SW_CNT)];

　　evbit[BITS_TO_LONGS(EV_CNT)]; 這個數組以位掩碼的形式，表明了這個設備支持的事件的類型。

　　設置方式：
　　dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS)
　　absbit[BITS_TO_LONGS(ABS_CNT)]; 這個數組也是以位掩碼的形式，表明這個類型的事件支持的編碼
　　觸摸屏驅動支持EV_ABS,因此要設置這個數組，有一個專門設置這個數組的函數input_set_abs_params

static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)  
{  
    dev->absmin[axis] = min;  
    dev->absmax[axis] = max;  
    dev->absfuzz[axis] = fuzz;  
    dev->absflat[axis] = flat;  
  
    dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);  //填充了absbit這個數組  
}

　　觸摸屏驅動中是這樣調用的

　　input_set_abs_params(dev, ABS_X, 0, 0x3FF, 0, 0)； //這個是設置ad轉換的x座標
　　input_set_abs_params(dev, ABS_Y, 0, 0x3FF, 0, 0); //這個是設置ad轉換的y座標
　　input_set_abs_params(dev, ABS_PRESSURE, 0, 1, 0, 0); //這個是設置觸摸屏是否按下的標誌
　　設置ABS_X編碼值範圍爲0-0x3ff，由於mini2440的AD轉換出的數據最大爲10位，因此不會超過0x3ff。

　（2） struct input_id id 成員
　　這個是標識設備驅動特徵的

struct input_id {  
    __u16 bustype;   //總線類型  
    __u16 vendor;    //生產廠商  
    __u16 product;   //產品類型  
    __u16 version;   //版本  
 };

　　若是須要特定的事件處理器來處理這個設備的話，這幾個就很是重要，由於子系統核心是經過他們，將設備驅動與事件處理層聯繫起來的。可是由於觸摸屏驅動所用的事件處理器爲evdev，匹配全部，全部這個初始化也可有可無。

input_handler

　　input_handler 這是事件處理器的數據結構，表明一個事件處理器

　　（1）幾個操做函數

    void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
    void (*disconnect)(struct input_handle *handle);
    void (*start)(struct input_handle *handle);

　　event 函數是當事件處理器接收到了來自input設備傳來的事件時調用的處理函數，負責處理事件，很是重要。
　　connect 函數是當一個input設備模塊註冊到內核的時候調用的，將事件處理器與輸入設備聯繫起來的函數，也就是將input_dev和input_handler配對的函數。
　　disconnect 函數實現connect相反的功能。

　　（2）兩個id

　　const struct input_device_id *id_table; //這個是事件處理器所支持的input設備
　　const struct input_device_id *blacklist; //這個是事件處理器應該忽略的input設備

　　這兩個數組都會用在connect函數中，input_device_id結構與input_id結構相似，可是input_device_id有一個flag，用來讓程序選擇比較哪項，如：busytype,vendor仍是其餘。

　　（3）兩個鏈表

    struct list_headh_list;  //這個鏈表用來連接他所支持的input_handle結構,input_dev與input_handler配對以後就會生成一個input_handle結構
    struct list_headnode;    //連接到input_handler_list，這個鏈表連接了全部註冊到內核的事件處理器

input_handle

　　input_handle 結構體表明一個成功配對的input_dev和input_handler

struct input_handle {  
    void *private;   //每一個配對的事件處理器都會分配一個對應的設備結構，如evdev事件處理器的evdev結構，注意這個結構與設備驅動層的input_dev不一樣，初始化handle時，保存到這裏。  
    int open;        //打開標誌，每一個input_handle 打開後才能操做，這個通常經過事件處理器的open方法間接設置  
    const char *name;   
    struct input_dev *dev;  //關聯的input_dev結構  
    struct input_handler *handler; //關聯的input_handler結構  
    struct list_head    d_node;  //input_handle經過d_node鏈接到了input_dev上的h_list鏈表上  
    struct list_head    h_node;  //input_handle經過h_node鏈接到了input_handler的h_list鏈表上  
};

三個數據結構之間的關係

　　input_dev 是硬件驅動層，表明一個input設備
　　input_handler 是事件處理層，表明一個事件處理器
　　input_handle 屬於核心層，表明一個配對的input設備與input事件處理器
　　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。

補充兩個結構體

　　（1） evdev設備結構

struct evdev {  
    int exist;  
    int open;           //打開標誌  
    int minor;          //次設備號  
    struct input_handle handle;  //關聯的input_handle  
    wait_queue_head_t wait;      //等待隊列，當進程讀取設備，而沒有事件產生的時候，進程就會睡在其上面  
    struct evdev_client *grab;   //強制綁定的evdev_client結構，這個結構後面再分析  
    struct list_head client_list;  //evdev_client 鏈表，這說明一個evdev設備能夠處理多個evdev_client，能夠有多個進程訪問evdev設備  
    spinlock_t client_lock; /* protects client_list */  
    struct mutex mutex;  
    struct device dev;       //device結構，說明這是一個設備結構  
};

　　evdev結構體在配對成功的時候生成，由handler->connect生成，對應設備文件爲/class/input/event(n)。

　　如觸摸屏驅動的event0，這個設備是用戶空間要訪問的設備，能夠理解它是一個虛擬設備，由於沒有對應的硬件，可是經過handle->dev 就能夠找到input_dev結構，而它對應着觸摸屏，設備文件爲/class/input/input0。這個設備結構生成以後保存在evdev_table中，索引值是minor

　　（2） evdev用戶端結構

struct evdev_client {  
    struct input_event buffer[EVDEV_BUFFER_SIZE];    
        //這個是一個input_event數據結構的數組，input_event表明一個事件，基本成員：類型（type），編碼（code），值（value）  
    int head;              //針對buffer數組的索引  
    int tail;              //針對buffer數組的索引，當head與tail相等的時候，說明沒有事件  
    spinlock_t buffer_lock; /* protects access to buffer, head and tail */  
    struct fasync_struct *fasync;  //異步通知函數  
    struct evdev *evdev;           //evdev設備  
    struct list_head node;         // evdev_client 鏈表項  
};

　　這個結構在進程打開event0設備的時候調用evdev的open方法，在open中建立這個結構，並初始化。在關閉設備文件的時候釋放這個結構。

Input輸入子系統數據結構關係圖

input輸入子系統主要函數分析

各類註冊函數

　　每種數據結構都表明一類對象，因此每種數據結構都會對應一個註冊函數，他們都定義在子系統核心的input.c文件中。

　　主要有三個註冊函數

     input_register_device    //向內核註冊一個input設備
     input_register_handle    //向內核註冊一個handle結構
     input_register_handler   //註冊一個事件處理器

1.input_register_device

　　input_register_device 註冊一個input輸入設備，這個註冊函數在三個註冊函數中是驅動程序惟一調用的。

 1 int input_register_device(struct input_dev *dev)  
 2 {  
 3     static atomic_t input_no = ATOMIC_INIT(0);    
 4         //這個原子變量，表明總共註冊的input設備，每註冊一個加1，由於是靜態變量，因此每次調用都不會清零的  
 5     struct input_handler *handler;  
 6     const char *path;  
 7     int error;  
 8   
 9     __set_bit(EV_SYN, dev->evbit);  //EN_SYN 這個是設備都要支持的事件類型，因此要設置  
10   
11     /* 
12      * If delay and period are pre-set by the driver, then autorepeating 
13      * is handled by the driver itself and we don't do it in input.c. 
14      */  
15         // 這個內核定時器是爲了重複按鍵而設置的  
16     init_timer(&dev->timer);  
17     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
18         dev->timer.data = (long) dev;  
19         dev->timer.function = input_repeat_key;  
20         dev->rep[REP_DELAY] = 250;  
21         dev->rep[REP_PERIOD] = 33;  
22         //若是沒有定義有關重複按鍵的相關值，就用內核默認的  
23     }  
24   
25     if (!dev->getkeycode)  
26         dev->getkeycode = input_default_getkeycode;  
27     if (!dev->setkeycode)  
28         dev->setkeycode = input_default_setkeycode;  
29         //以上設置的默認函數由input核心提供  
30     dev_set_name(&dev->dev, "input%ld",  
31              (unsigned long) atomic_inc_return(&input_no) - 1);  
32         //設置input_dev中device的名字，這個名字會在/class/input中出現  
33     error = device_add(&dev->dev);  
34         //將device加入到linux設備模型中去  
35     if (error)  
36         return error;  
37   
38     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
39     printk(KERN_INFO "input: %s as %s\n",  
40         dev->name ? dev->name : "Unspecified device", path ? path : "N/A");  
41     kfree(path);  
42         //這個獲得路徑名稱，並打印出來  
43     error = mutex_lock_interruptible(&input_mutex);  
44     if (error) {  
45         device_del(&dev->dev);  
46         return error;  
47     }  
48   
49     list_add_tail(&dev->node, &input_dev_list);  
50         // 將新分配的input設備鏈接到input_dev_list鏈表上  
51     list_for_each_entry(handler, &input_handler_list, node)  
52         input_attach_handler(dev, handler);  
53         //遍歷input_handler_list鏈表，配對 input_dev 和 input_handler  
54         //input_attach_handler 這個函數是配對的關鍵 
55     input_wakeup_procfs_readers();  
56         // 和proc文件系統有關 
57     mutex_unlock(&input_mutex);  
58   
59     return 0;  
60    }

View Code

　　input_register_device完成的主要功能就是：初始化一些默認的值，將本身的device結構添加到linux設備模型當中，將input_dev添加到input_dev_list鏈表中，而後尋找合適的handler與input_handler配對,配對的核心函數是input_attach_handler。

　　下面看看input_attach_handler函數

 1 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)  
 2 {  
 3     const struct input_device_id *id;  
 4     int error;  
 5   
 6     if (handler->blacklist && input_match_device(handler->blacklist, dev))  
 7         return -ENODEV;  
 8         //blacklist是handler因該忽略的input設備類型，若是應該忽略的input設備也配對上了，那就出錯了  
 9     id = input_match_device(handler->id_table, dev);  
10         //這個是主要的配對函數，主要比較id中的各項
11     if (!id)  
12         return -ENODEV;  
13   
14     error = handler->connect(handler, dev, id);  
15         //配對成功調用handler的connect函數，這個函數在事件處理器中定義，主要生成一個input_handle結構，並初始化，還生成一個事件處理器相關的設備結構
16     if (error && error != -ENODEV)  
17         printk(KERN_ERR  
18             "input: failed to attach handler %s to device %s, "  
19             "error: %d\n",  
20             handler->name, kobject_name(&dev->dev.kobj), error);  
21         //出錯處理  
22     return error;  
23  }

View Code

　　input_attach_handler的主要功能就是調用了兩個函數，一個input_match_device進行配對，一個connect處理配對成功後續工做。

　　下面看看input_match_device函數

 1 static const struct input_device_id *input_match_device(const struct input_device_id *id,  
 2                             struct input_dev *dev)  
 3 {  
 4     int i;  
 5         //函數傳入的參數是所要配對handler的id_table，下面遍歷這個id_table尋找合適的id進行配對  
 6     for (; id->flags || id->driver_info; id++) {  
 7         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)  
 8             if (id->bustype != dev->id.bustype)  
 9                 continue;  
10                 ......  
11                 //針對handler->id->flag，比較不一樣的類型  
12                 //若是比較成功進入下面的宏，不然進入下一個id  
13                 MATCH_BIT(evbit,  EV_MAX);  
14             ......    
15         MATCH_BIT(swbit,  SW_MAX);  
16   
17   
18         return id;  
19     }  
20  }

View Code

　　此函數主要是比較input_dev中的id和handler支持的id,這個存放在handler的id_table中。

　　首先看id->driver_info有沒有設置，若是設置了說明它匹配全部的id，evdev就是這個樣的handler
　　而後依據id->flag來比較內容，若是都比較成功進入MATCH_BIT，這個宏是用來按位進行比較的，功能是比較所支持事件的類型，只有全部的位都匹配才成功返回，不然進行下一個id的比較。

1 #define MATCH_BIT(bit, max) \  
2 for (i = 0; i < BITS_TO_LONGS(max); i++) \  
3     if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \  
4         break; \  
5 if (i != BITS_TO_LONGS(max)) \  
6     continue;

View Code

　　這個宏對於每種事件類型，以及每種事件類型支持的編碼全部的位都比較一次，看handler的id是否支持，若是有一個不支持就不會比較成功，進入下一個id進行比較。
　　對於connect函數，每種事件處理器的實現都有差別，但原理都相同。

　　由於觸摸屏用的事件處理器爲evdev，下面看看evdev的connect函數evdev_connect

 1 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  
 2              const struct input_device_id *id)  
 3 {  
 4         //此函數傳入三個參數，分別是：handler，dev,id  
 5     struct evdev *evdev;  
 6     int minor;  
 7     int error;  
 8   
 9   
10     for (minor = 0; minor < EVDEV_MINORS; minor++)  
11         if (!evdev_table[minor])  
12             break;  
13         //EVDEV_MINORS爲32，說明evdev這個handler能夠同時有32個輸入設備和他配對，evdev_table中以minor（非次設備號，可是有一個換算關係）存放evdev結構體，後面要詳細分析這個結構體  
14     if (minor == EVDEV_MINORS) {  
15         printk(KERN_ERR "evdev: no more free evdev devices\n");  
16         return -ENFILE;  
17     }  
18         //這個說明32個位置全都被佔用了，鏈接失敗  
19     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
20         //分配一個evdev結構體，這個結構體是evdev事件處理器特有的，後面會詳細分析  
21     if (!evdev)  
22         return -ENOMEM;  
23   
24   
25     INIT_LIST_HEAD(&evdev->client_list);  
26     spin_lock_init(&evdev->client_lock);  
27     mutex_init(&evdev->mutex);  
28     init_waitqueue_head(&evdev->wait);  
29         //初始化結構體的一些成員  
30     dev_set_name(&evdev->dev, "event%d", minor);  
31         //這個是設置evdev中device的名字，他將出如今/class/input中。  
32         //前面也有一個device是input_dev的，名字是input（n），注意與他的不一樣  
33         //這個結構是配對後的虛擬設備結構，沒有對應的硬件，可是經過它能夠找到相關的硬件  
34     evdev->exist = 1;  
35     evdev->minor = minor;  
36   
37   
38     evdev->handle.dev = input_get_device(dev);  
39     evdev->handle.name = dev_name(&evdev->dev);  
40     evdev->handle.handler = handler;  
41     evdev->handle.private = evdev;  
42         //由於evdev中包含handle了，因此初始化它就能夠了，這樣就鏈接了input_handler與input_dev  
43     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor); //注意：這個minor不是真正的次設備號，還要加上EVDEV_MINOR_BASE  
44     evdev->dev.class = &input_class;  
45     evdev->dev.parent = &dev->dev;  
46         //配對生成的device，父設備是與他相關連的input_dev  
47     evdev->dev.release = evdev_free;  
48     device_initialize(&evdev->dev);  
49   
50   
51     error = input_register_handle(&evdev->handle);  
52         //註冊handle結構體,這個函數後面詳細分析  
53     if (error)  
54         goto err_free_evdev;  
55   
56   
57     error = evdev_install_chrdev(evdev);  
58         //這個函數只作了一件事，就是把evdev結構保存到evdev_table中，這個數組也minor爲索引  
59     if (error)  
60         goto err_unregister_handle;  
61   
62   
63     error = device_add(&evdev->dev);  
64         //註冊到linux設備模型中  
65     if (error)  
66         goto err_cleanup_evdev;  
67   
68   
69     return 0;  
70   
71   
72   err_cleanup_evdev:  
73     evdev_cleanup(evdev);  
74   err_unregister_handle:  
75     input_unregister_handle(&evdev->handle);  
76   err_free_evdev:  
77     put_device(&evdev->dev);  
78     return error;  
79 }

View Code

　　evdev_connect函數作配對後的善後工做，分配一個evdev結構體，並初始化相關成員，evdev結構體中有input_handle結構，初始化並註冊之。

2.input_register_handle

　　input_register_handle 註冊一個input_handle結構體，比較簡單

 1 int input_register_handle(struct input_handle *handle)  
 2 {  
 3     struct input_handler *handler = handle->handler;  
 4     struct input_dev *dev = handle->dev;  
 5     int error;  
 6   
 7   
 8     /* 
 9      * We take dev->mutex here to prevent race with 
10      * input_release_device(). 
11      */  
12     error = mutex_lock_interruptible(&dev->mutex);  
13     if (error)  
14         return error;  
15     list_add_tail_rcu(&handle->d_node, &dev->h_list);  
16         //將handle的d_node，連接到其相關的input_dev的h_list鏈表中  
17     mutex_unlock(&dev->mutex);  
18   
19   
20     list_add_tail(&handle->h_node, &handler->h_list);  
21         //將handle的h_node，連接到其相關的input_handler的h_list鏈表中  
22     if (handler->start)  
23         handler->start(handle);  
24   
25   
26     return 0;  
27 }

View Code

　　這個函數基本沒作什麼事，就是把一個handle結構體經過d_node鏈表項，分別連接到input_dev的h_list,input_handler的h_list上。

　　之後經過這個h_list就能夠遍歷相關的input_handle了。

3. input_register_handler

　　input_register_handler 註冊一個input_handler結構體

 1 int input_register_handler(struct input_handler *handler)  
 2  {  
 3     struct input_dev *dev;  
 4     int retval;  
 5   
 6   
 7     retval = mutex_lock_interruptible(&input_mutex);  
 8     if (retval)  
 9         return retval;  
10   
11   
12     INIT_LIST_HEAD(&handler->h_list);  
13   
14   
15     if (handler->fops != NULL) {  
16         if (input_table[handler->minor >> 5]) {  
17             retval = -EBUSY;  
18             goto out;  
19         }  
20         input_table[handler->minor >> 5] = handler;  
21     }  
22         //input_table，每一個註冊的handler都會將本身保存到這裏，索引值爲handler->minor右移5爲，也就是除以32  
23         //爲何會這樣呢，由於每一個handler都會處理最大32個input_dev，因此要以minor的32爲倍數對齊,這個minor是傳進來的handler的MINOR_BASE  
24         //每個handler都有一個這一個MINOR_BASE，以evdev爲例,EVDEV_MINOR_BASE = 64,能夠看出系統總共能夠註冊8個handler  
25     list_add_tail(&handler->node, &input_handler_list);  
26         //鏈接到input_handler_list鏈表中  
27     list_for_each_entry(dev, &input_dev_list, node)  
28         input_attach_handler(dev, handler);  
29         //又是配對，不過此次遍歷input_dev，和註冊input_dev過程同樣的  
30     input_wakeup_procfs_readers();  
31   
32   
33  out:  
34     mutex_unlock(&input_mutex);  
35     return retval;  
36 }