事件層

struct input_dev *input_allocate_device(void)
{
   struct input_dev *dev;

   dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);  /*分配一個 input_dev 結構體,并初始化為 0*/
   if (dev) 
   {
         dev->dev.type = &input_dev_type;   /*初始化設備的類型*/
         dev->dev.class = &input_class;  
         device_initialize(&dev->dev); 
         mutex_init(&dev->mutex);   // 初始話互斥鎖
         spin_lock_init(&dev->event_lock);  // 初始化自旋鎖
         INIT_LIST_HEAD(&dev->h_list);   //初始化鏈表
         INIT_LIST_HEAD(&dev->node);  
         __module_get(THIS_MODULE);
  }
  return dev;
}

該函數返回一個指向 input_dev 類型的指針,該結構體是一個輸入設備結構體,包含了輸入設備的一些相關信息,如
設備支持的按鍵碼、設備的名稱、設備支持的事件等。

Input設備注冊的接口為：input_register_device()。代碼如下：

int input_register_device(struct input_dev *dev) 
{ 
     static atomic_t input_no = ATOMIC_INIT(0); 
     struct input_handler *handler; 
     const char *path; 
     int error; 

     __set_bit(EV_SYN, dev->evbit); 
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
調用__set_bit()函數設置 input_dev 所支持的事件類型。事件類型由 input_dev 的evbit 成員來表示,在這里        將其 EV_SYN 置位,表示設
備支持所有的事件。注意,一個設備可以支持一種或者多種事件類型。常用的事件類型如下:

1. #define EV_SYN     0x00   /*表示設備支持所有的事件*/
2. #define EV_KEY     0x01  /*鍵盤或者按鍵,表示一個鍵碼*/
3. #define EV_REL     0x02  /*鼠標設備,表示一個相對的光標位置結果*/
4. #define EV_ABS     0x03  /*手寫板產生的值,其是一個絕對整數值*/
5. #define EV_MSC     0x04  /*其他類型*/
6. #define EV_LED     0x11   /*LED 燈設備*/
7. #define EV_SND     0x12  /*蜂鳴器,輸入聲音*/
8. #define EV_REP     0x14   /*允許重復按鍵類型*/
9. #define EV_PWR     0x16   /*電源管理事件*/
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
     /* 
      * If delay and period are pre-set by the driver, then autorepeating 
      * is handled by the driver itself and we don't do it in input.c. 
      */ 

     init_timer(&dev->timer);  //初始化一個 timer 定時器,這個定時器是為處理重復擊鍵而定義的。
     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
               dev->timer.data = (long) dev; 
               dev->timer.function = input_repeat_key; 
               dev->rep[REP_DELAY] = 250; 
               dev->rep[REP_PERIOD] = 33; 
     } 
    //如果dev->rep[REP_DELAY]和dev->rep[REP_PERIOD]沒有設值，則將其賦默認值。這主要是處理重復按鍵的.

     if (!dev->getkeycode) 
               dev->getkeycode = input_default_getkeycode; 

     if (!dev->setkeycode) 
               dev->setkeycode = input_default_setkeycode;
    //檢查 getkeycode()函數和 setkeycode()函數是否被定義,如果沒定義,則使用默認的處理函數,這兩個函數為
    //input_default_getkeycode()和 input_default_setkeycode()。input_default_getkeycode()函數用來得到指定位置的鍵
    //值。input_default_setkeycode()函數用來設置鍵值。具體啥用處，我也沒搞清楚？


     snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 
                "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
    //設置 input_dev 中的 device 的名字,名字以 input0、input1、input2、input3、input4等的形式出現在 sysfs文件系統中.

     error = device_add(&dev->dev); 
     if (error) 
               return error; 
    //使用 device_add()函數將 input_dev 包含的 device 結構注冊到 Linux 設備模型中,并可以在 sysfs文件系統中表現出來。


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

     error = mutex_lock_interruptible(&input_mutex); 
     if (error) { 
               device_del(&dev->dev); 
               return error; 
     } 

     list_add_tail(&dev->node, &input_dev_list);
    //調用 list_add_tail()函數將 input_dev 加入 input_dev_list 鏈表中,input_dev_list 鏈
    //表中包含了系統中所有的 input_dev 設備。

     list_for_each_entry(handler, &input_handler_list, node)
               input_attach_handler(dev, handler);
    //將input device 掛到input_dev_list鏈表上.然后，對每一個掛在input_handler_list的handler調用
    //input_attach_handler().在這里的情況有好比設備模型中的device和driver的匹配。所有的input device都掛在
    //input_dev_list鏈上。所有的handler都掛在input_handler_list上。

     input_wakeup_procfs_readers(); 
     mutex_unlock(&input_mutex); 

     return 0; 
} 

=============================================================
匹配是在input_attach_handler()中完成的。代碼如下：

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{ 
     const struct input_device_id *id; 
     int error; 

     if (handler->blacklist && input_match_device(handler->blacklist, dev)) 
               return -ENODEV; 
     //首先判斷 handler的 blacklist 是否被賦值,如果被賦值,則匹配 blacklist 中的數據跟 dev->id 的數據是否匹配。blacklist
     //是一個 input_device_id*的類型,其指向 input_device_ids的一個表,這個表中存放了驅動程序應該忽略的設備。即使在
     //id_table 中找到支持的項,也應該忽略這種設備。

     id = input_match_device(handler->id_table, dev);
     //調用 input_match_device()函數匹配 handler->>id_table 和 dev->id 中的數據。如果不成功則返回。
     handle->id_table 也是一個 input_device_id 類型的指針,其表示驅動支持的設備列表。
     if (!id) 
               return -ENODEV; 

     error = handler->connect(handler, dev, id);
     //如果匹配成功,則調用 handler->connect()函數將 handler 與 input_dev 連接起來。
     // 在connect() 中會調用input_register_handle，而這些都需要handler的注冊。
     if (error && error != -ENODEV) 
               printk(KERN_ERR 
                        "input: failed to attach handler %s to device %s, " 
                        "error: %d/n", 
                        handler->name, kobject_name(&dev->dev.kobj), error); 

     return error; 
} 

如果handler的blacklist被賦值。要先匹配blacklist中的數據跟dev->id的數據是否匹配。匹配成功過后再來匹配 handle->id和dev->id中的數據。如果匹配成功，則調用handler->connect().

=============================================================
input_match_device()代碼如下：

 static const struct input_device_id *input_match_device(const struct input_device_id *id,
                                                             struct input_dev *dev)
{ 
     int i; 

     for (; id->flags || id->driver_info; id++) { 

     //匹配設備廠商的信息,設備號的信息。
               if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
                        if (id->bustype != dev->id.bustype) 
                                 continue; 

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

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

               if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION) 
                        if (id->version != dev->id.version) 
                                 continue; 

               MATCH_BIT(evbit,  EV_MAX); 
               MATCH_BIT(,, KEY_MAX); 
               MATCH_BIT(relbit, REL_MAX); 
               MATCH_BIT(absbit, ABS_MAX); 
               MATCH_BIT(mscbit, MSC_MAX); 
               MATCH_BIT(ledbit, LED_MAX); 
               MATCH_BIT(sndbit, SND_MAX); 
               MATCH_BIT(ffbit,  FF_MAX); 
               MATCH_BIT(swbit,  SW_MAX); 
----------------------------------------------------------------------------------
MATCH_BIT宏的定義如下：
#define MATCH_BIT(bit, max) 
               for (i = 0; i < BITS_TO_LONGS(max); i++) 
                        if ((id->bit[i] & dev->bit[i]) != id->bit[i]) 
                                 break; 
               if (i != BITS_TO_LONGS(max)) 
                        continue; 

----------------------------------------------------------------------------------
               return id; 
     } 
   return NULL; 

}

從MATCH_BIT宏的定義可以看出。只有當iput device和input handler的id成員在evbit, keybit,… swbit項相同才會匹配成功。而且匹配的順序是從evbit, keybit到swbit.只要有一項不同，就會循環到id中的下一項進行比較. 簡而言之,注冊input device的過程就是為input device設置默認值，并將其掛以input_dev_list.與掛載在input_handler_list中的handler相匹配。如果匹配成功，就會調用handler的connect函數.

=============================================================
這一條線先講到這里因為接下去就要講handler ，那就是事件層的東西了， 我們先把核心層的東西講完，
在前面的設備驅動層中的中斷響應函數里面，有input_report_key 函數 ，下面我們來看看他。
input_report_key()函數向輸入子系統報告發生的事件,這里就是一個按鍵事件。在 button_interrupt()中斷函數中,
不需要考慮重復按鍵的重復點擊情況,input_report_key()函數會自動檢查這個問題,并報告一次事件給輸入子系統。該
函數的代碼如下:

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_KEY, code, !!value);
}

該函數的第 1 個參數是產生事件的輸入設備, 2 個參數是產生的事件, 3 個參數是事件的值。需要注意的是, 第2 個參數可以取類似 BTN_0、 BTN_1、BTN_LEFT、BTN_RIGHT 等值,這些鍵值被定義在 include/linux/input.h 文件中。當第 2 個參數為按鍵時,第 3 個參數表示按鍵的狀態,value 值為 0 表示按鍵釋放,非 0 表示按鍵按下。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
在 input_report_key()函數中正在起作用的函數是 input_event()函數,該函數用來向輸入子系統報告輸入設備產生的事件,這個函數非常重要,它的代碼如下:

 void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
    unsigned long flags;

    if (is_event_supported(type, dev->evbit, EV_MAX)) {  //檢查輸入設備是否支持該事件

    spin_lock_irqsave(&dev->event_lock, flags);

    add_input_randomness(type, code, value);
    //函數對事件發送沒有一點用處,只是用來對隨機數熵池增加一些貢獻,因為按鍵輸入是一種隨機事件,所以對熵池是有貢獻的。
    input_handle_event(dev, type, code, value);
    //調用 input_handle_event()函數來繼續輸入子系統的相關模塊發送數據。
    spin_unlock_irqrestore(&dev->event_lock, flags);
 }

=============================================================
input_handle_event()函數向輸入子系統傳送事件信息。第 1 個參數是輸入設備 input_dev,第 2 個參數是事件的類型,第 3 個參數是鍵碼,第 4 個參數是鍵值。瀏覽一下該函數的大部分代碼,主要由一個 switch 結構組成。該結構用來對不同的事件類型,分別處理。其中 case語句包含了 EV_SYN、 EV_KEY、EV_SW、EV_SW、EV_SND 等事件類型。在這么多事件中,本例只要關注EV_KEY 事件,因為本節的實例發送的是鍵盤事件。其實,只要對一個事件的處理過程了解后,對其他事件的處理過程也就清楚了。該函數的代碼如下:

 static void input_handle_event(struct input_dev *dev,
 {
    unsigned int type, unsigned int code, int value)
    int disposition = INPUT_IGNORE_EVENT; 
    //定義了一個 disposition 變量,該變量表示使用什么樣的方式處理事件

    switch (type) {
            case EV_SYN:
                    switch (code)
                 {
                            case SYN_CONFIG:
                                    disposition = INPUT_PASS_TO_ALL;
                                    break;
                            case SYN_REPORT:
                            if (!dev->sync) 
                        {
                                    dev->sync = 1;
                                    disposition = INPUT_PASS_TO_HANDLERS;
                            }
                            break;
                    }       
                    break;
           case EV_KEY:
                     if (is_event_supported(code, dev->keybit, KEY_MAX) &&!!test_bit(code, dev->key) != value)
                       //函數判斷是否支持該按鍵
                 {
                            if (value != 2) 
                        {
                                    __change_bit(code, dev->key);
                                    if (value)
                                            input_start_autorepeat(dev, code);   //處理重復按鍵的情況
                              }
                            disposition = INPUT_PASS_TO_HANDLERS;
     //將 disposition變量設置為 INPUT_PASS_TO_HANDLERS,表示事件需要 handler 來處理。
------------------------------------------------------------------------------------
 disposition 的取值有如下幾種:
1. #define INPUT_IGNORE_EVENT           0
2. #define INPUT_PASS_TO_HANDLERS         1
3. #define INPUT_PASS_TO_DEVICE         2
4. #define INPUT_PASS_TO_ALL                 (INPUT_PASS_TO_HANDLERS | INPUT_PASS_TO_DEVICE)

 INPUT_IGNORE_EVENT  表示忽略事件,不對其進行處理。
 INPUT_PASS_ TO_HANDLERS  表示將事件交給 handler 處理。
 INPUT_PASS_TO_DEVICE  表示將事件交給 input_dev 處理。
 INPUT_PASS_TO_ALL 表示將事件交給 handler 和 input_dev 共同處理。
------------------------------------------------------------------------------------
                 }
                    break;
            case EV_SW:
                    if (is_event_supported(code, dev->swbit, SW_MAX) &&!!test_bit(code, dev->sw) != value)
                 {
                            __change_bit(code, dev->sw);
                            disposition = INPUT_PASS_TO_HANDLERS;
                     }
                    break;
            case EV_ABS:
                            if (is_event_supported(code, dev->absbit, ABS_MAX))
                        {
                                    value = input_defuzz_abs_event(value,
                                    dev->abs[code], dev->absfuzz[code]);
                                    if (dev->abs[code] != value)
                               {
                                            dev->abs[code] = value;
                                            disposition = INPUT_PASS_TO_HANDLERS;
                                 }
                        }
                         break;
            case EV_REL:
                    if (is_event_supported(code, dev->relbit, REL_MAX) && value)
                            disposition = INPUT_PASS_TO_HANDLERS;
                    break;
            case EV_MSC:
                    if (is_event_supported(code, dev->mscbit, MSC_MAX))
                            disposition = INPUT_PASS_TO_ALL;
                    break;
            case EV_LED:
                    if (is_event_supported(code, dev->ledbit, LED_MAX) &&!!test_bit(code, dev->led) != value)
                 {
                            __change_bit(code, dev->led);
                            disposition = INPUT_PASS_TO_ALL;
                    }
                  break;
            case EV_SND:
                    if (is_event_supported(code, dev->sndbit, SND_MAX))
                 {
                            if (!!test_bit(code, dev->snd) != !!value)
                                    __change_bit(code, dev->snd);
                            disposition = INPUT_PASS_TO_ALL;
                    }
                    break;
            case EV_REP:
                    if (code <= REP_MAX && value >= 0 && dev->rep[code] != value)
                 {
                         dev->rep[code] = value;
                         disposition = INPUT_PASS_TO_ALL;
                  }
                  break;
           case EV_FF:
                  if (value >= 0)
                         disposition = INPUT_PASS_TO_ALL;
                         break;
                  case EV_PWR:
                         disposition = INPUT_PASS_TO_ALL;
                  break;
    }
    if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
          dev->sync = 0;
    if ((disposition &INPUT_PASS_TO_DEVICE) && dev->event)
           dev->event(dev, type, code, value);
    //首先判斷 disposition 等于 INPUT_PASS_TO_DEVICE,然后判斷 dev->event 是否對其指定了一個處理函數,如果這些條件都滿足,則調用自定義的 dev->event()函數處理事件。
    //有些事件是發送給設備,而不是發送給 handler 處理的。event()函數用來向輸入子系統報告一個將要發送給設備的事件,例如讓 LED 燈點亮事件、蜂鳴器鳴叫事件等。當事件報告給輸入子系統后,就要求設備處理這個事件。

   if (disposition & INPUT_PASS_TO_HANDLERS)
           input_pass_event(dev, type, code, value);
}

=============================================================
input_pass_event()函數將事件傳遞到合適的函數,然后對其進行處理,該函數的代碼如下:

 static void input_pass_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
    struct input_handle *handle;
   rcu_read_lock();
   handle = rcu_dereference(dev->grab);
   //得到 dev->grab 的指針。grab 是強制為 input device 的 handler,這時要調用 handler的 event 函數。
   if (handle)
          handle->handler->event(handle, type, code, value);
    else
          list_for_each_entry_rcu(handle, &dev->h_list, d_node)  //一般情況下走這里

    if (handle->open) 
          handle->handler->event(handle,type, code, value);
   //如果該 handle 被打開,表示該設備已經被一個用戶進程使用。就會調用與輸入設備對應的 handler 的 event()函數。
   //注意,只有在 handle 被打開的情況下才會接收到事件,這就是說,只有設備被用戶程序使用時,才有必要向用戶空間導出信息此處亦是用到了handle ，核心層就到此為止，前面也講過在device和handler  connect() 時會調用input_register_handle，而這些都需要handler的注冊,所以接下來我們看看事件層
    rcu_read_unlock();

}

四 事件層

input_handler 是輸入子系統的主要數據結構,一般將其稱為 handler 處理器,表示對輸入事件的具體處理。
input_handler 為輸入設備的功能實現了一個接口,輸入事件最終傳遞到handler 處理器,handler 處理器根據一定的規則,然后對事件進行處理,具體的規則將在下面詳細介紹。
輸入子系統由驅動層、輸入子系統核心層(Input Core)和事件處理層(Event Handler)3 部分組成。一個輸入事件,如鼠標移動,鍵盤按鍵按下等通過驅動層->系統核心層->事件處理層->用戶空間的順序到達用戶空間并傳給應用程序使用。其中 Input Core 即輸入子系統核心層由 driver/input/input.c 及相關頭文件實現。其對下提供了設備驅動的接口,對上提供了事件處理層的編程接口。輸入子系統主要設計 input_dev、input_handler、input_handle 等數據結構.

struct input_dev物理輸入設備的基本數據結構,包含設備相關的一些信息
struct input_handler 事件處理結構體,定義怎么處理事件的邏輯
struct input_handle用來創建 input_dev 和 input_handler 之間關系的結構體

在evdev.c 中：

static struct input_handler evdev_handler = {
    .event        = evdev_event,  // 前面講的傳遞信息是調用，在 input_pass_event 中      
    .connect    = evdev_connect,  //device 和 handler 匹配時調用                                  
    .disconnect    = evdev_disconnect,
    .fops        = &evdev_fops,                        //  event 、connect、 fops 會在后面詳細講                                  
    .minor        = EVDEV_MINOR_BASE,
    .name        = "evdev",
    .id_table    = evdev_ids,
};
------------------------------------------------------------------------------------
struct input_handler {
    void *private; 
    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);
    const struct file_operations *fops;
    int minor;  //表示設備的次設備號
    const char *name;
    const struct input_device_id *id_table; //定義了一個 name, 表示 handler 的名字,顯示在/proc/bus/input/handlers 目錄中。
    const struct input_device_id *blacklist; //指向一個 input_device_id 表,這個表包含 handler 應該忽略的設備
    struct list_head h_list;
    struct list_head node;
};
----------------------------------------------------------------------------------

//事件層注冊

static int __init evdev_init(void)
{
    return input_register_handler(&evdev_handler);
}

=============================================================

int input_register_handler(struct input_handler *handler)
{
    struct input_dev *dev;
    int retval;
    retval = mutex_lock_interruptible(&input_mutex);
    if (retval)
            return retval;
    INIT_LIST_HEAD(&handler->h_list);
    //其中的 handler->minor 表示對應 input 設備結點的次設備號。 handler->minor以右移 5 位作為索引值插入到 //input_table[ ]中

    if (handler->fops != NULL)
    {
           if (input_table[handler->minor >> 5])
           {
                   retval = -EBUSY;
                    goto out;
            }
            input_table[handler->minor >> 5] = handler;
    }

    list_add_tail(&handler->node, &input_handler_list);
    //調用 list_add_tail()函數,將 handler 加入全局的 input_handler_list 鏈表中,該鏈表包含了系統中所有的 input_handler
    list_for_each_entry(dev, &input_dev_list, node)
    input_attach_handler(dev, handler);
    //主 要 調 用 了 input_attach_handler() 函 數 。 該 函 數 在 input_register_device()函數的第 35 行曾詳細的介紹過。input_attach_handler()函數的作用是匹配 input_dev_list 鏈表中的 input_dev 與 handler。如果成功會將 input_dev與 handler 聯系起來。也就是說在注冊handler和dev時都會去調用該函數。
    input_wakeup_procfs_readers();
out:
    mutex_unlock(&input_mutex);
    return retval;
}

=============================================================
ok下面我們來看下handle的注冊，在前面evdev_handler結構體中，有一個.connect = evdev_connect, 在
connect里面會注冊handle，在前面注冊dev，匹配成功后調用。

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
                         const struct input_device_id *id)
{
     struct evdev *evdev;
     int minor;
     int error;

     for (minor = 0; minor < EVDEV_MINORS; minor++)
               if (!evdev_table[minor])
                        break;

     if (minor == EVDEV_MINORS) {
               printk(KERN_ERR "evdev: no more free evdev devices/n");
               return -ENFILE;
     }

     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
     if (!evdev)
               return -ENOMEM;

     INIT_LIST_HEAD(&evdev->client_list);
     spin_lock_init(&evdev->client_lock);
     mutex_init(&evdev->mutex);
     init_waitqueue_head(&evdev->wait);

     snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);
     evdev->exist = 1;
     evdev->minor = minor;

     evdev->handle.dev = input_get_device(dev);
     evdev->handle.name = evdev->name;
     evdev->handle.handler = handler;
     evdev->handle.private = evdev;
     //分配了一個 evdev結構 ,并對這個結構進行初始化 .在這里我們可以看到 ,這個結構封裝了一個 handle結構 ,這結構與我們之前所討論的 handler是不相同的 .注意有一個字母的差別哦 .我們可以把 handle看成是 handler和 input device的信息集合體 .在這個結構里集合了匹配成功的 handler和 input device

     strlcpy(evdev->dev.bus_id, evdev->name, sizeof(evdev->dev.bus_id));
     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
     evdev->dev.class = &input_class;
     evdev->dev.parent = &dev->dev;
     evdev->dev.release = evdev_free;
     device_initialize(&evdev->dev);
     //在這段代碼里主要完成 evdev封裝的 device的初始化 .注意在這里 ,使它所屬的類指向 input_class.這樣在 /sysfs中創建的設備目錄就會在 /sys/class/input/下面顯示 .

     error = input_register_handle(&evdev->handle);
     if (error)
               goto err_free_evdev;
     error = evdev_install_chrdev(evdev);
     if (error)
               goto err_unregister_handle;

     error = device_add(&evdev->dev);
     if (error)
               goto err_cleanup_evdev;

     return 0;

 err_cleanup_evdev:
     evdev_cleanup(evdev);
 err_unregister_handle:
     input_unregister_handle(&evdev->handle);
 err_free_evdev:
     put_device(&evdev->dev);
     return error;
} 

=============================================================

int input_register_handle(struct input_handle *handle)
{
     struct input_handler *handler = handle->handler;
     struct input_dev *dev = handle->dev;
     int error;

     /*
      * We take dev->mutex here to prevent race with
      * input_release_device().
      */
     error = mutex_lock_interruptible(&dev->mutex);
     if (error)
               return error;
     list_add_tail_rcu(&handle->d_node, &dev->h_list);
     mutex_unlock(&dev->mutex);
     synchronize_rcu();

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

     if (handler->start)
               handler->start(handle);

     return 0;
} 

將handle掛到所對應input device的h_list鏈表上.還將handle掛到對應的handler的hlist鏈表上.如果handler定義了start函數,將調用之. 到這里,我們已經看到了input device, handler和handle是怎么關聯起來的了

=============================================================

接下來我們看看上報信息是調用的 .event = evdev_event
每當input device上報一個事件時,會將其交給和它匹配的handler的event函數處理.在evdev中.這個event函數
對應的代碼為:

static void evdev_event(struct input_handle *handle, 
                        unsigned int type, unsigned int code, int value) 
{ 
     struct evdev *evdev = handle->private; 
     struct evdev_client *client; 
     struct input_event event; 

     do_gettimeofday(&event.time); 
     event.type = type; 
     event.code = code; 
     event.value = value; 

     rcu_read_lock(); 

     client = rcu_dereference(evdev->grab); 
     if (client) 
               evdev_pass_event(client, &event); 
     else 
               list_for_each_entry_rcu(client, &evdev->client_list, node)   
                        evdev_pass_event(client, &event); 

     rcu_read_unlock(); 

     wake_up_interruptible(&evdev->wait); 
} 

=============================================================

static void evdev_pass_event(struct evdev_client *client, 
                             struct input_event *event) 
{ 
     /* 
      * Interrupts are disabled, just acquire the lock 
      */ 
     spin_lock(&client->buffer_lock); 
     client->buffer[client->head++] = *event; 
     client->head &= EVDEV_BUFFER_SIZE - 1; 
     spin_unlock(&client->buffer_lock); 

     kill_fasync(&client->fasync, SIGIO, POLL_IN); 
} 

這里的操作很簡單.就是將event(上傳數據)保存到client->buffer中.而client->head就是當前的數據位置.注意這里是一個環形緩存區.寫數據是從client->head寫.而讀數據則是從client->tail中讀.

=============================================================
最后我們看下handler的相關操作函數 .fops = &evdev_fops,
我們知道.對主設備號為INPUT_MAJOR的設備節點進行操作,會將操作集轉換成handler的操作集.在evdev中,這個
操作集就是evdev_fops.對應的open函數如下示:

static int evdev_open(struct inode *inode, struct file *file) 
{ 
     struct evdev *evdev; 
     struct evdev_client *client; 
     int i = iminor(inode) - EVDEV_MINOR_BASE; 
     int error; 

     if (i >= EVDEV_MINORS) 
               return -ENODEV; 

     error = mutex_lock_interruptible(&evdev_table_mutex); 
     if (error) 
               return error; 
     evdev = evdev_table[i]; 
     if (evdev) 
               get_device(&evdev->dev); 
     mutex_unlock(&evdev_table_mutex); 

     if (!evdev) 
               return -ENODEV; 

     client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL); 
     if (!client) { 
               error = -ENOMEM; 
               goto err_put_evdev; 
     } 
     spin_lock_init(&client->buffer_lock); 
     client->evdev = evdev; 
     evdev_attach_client(evdev, client); 

     error = evdev_open_device(evdev); 
     if (error) 
               goto err_free_client; 

     file->private_data = client; 
     return 0; 

err_free_client: 
     evdev_detach_client(evdev, client); 
     kfree(client); 
err_put_evdev: 
     put_device(&evdev->dev); 
     return error; 
} 

=============================================================
evdev_open_device()函數用來打開相應的輸入設備，使設備準備好接收或者發送數據。evdev_open_device()函數先獲得互斥鎖，然后檢查設備是否存在，并判斷設備是否已經被打開。如果沒有打開，則調用 input_open_device()函數打開設備.

static int evdev_open_device(struct evdev *evdev) 
{ 
     int retval; 

     retval = mutex_lock_interruptible(&evdev->mutex); 
     if (retval) 
               return retval; 

     if (!evdev->exist) 
               retval = -ENODEV; 
     else if (!evdev->open++) { 
               retval = input_open_device(&evdev->handle); 
               if (retval) 
                        evdev->open--; 
     } 

     mutex_unlock(&evdev->mutex); 
     return retval; 
} 

=============================================================
對于evdev設備節點的read操作都會由evdev_read()完成.它的代碼如下:

static ssize_t evdev_read(struct file *file, char __user *buffer, 
                          size_t count, loff_t *ppos) 
{ 
     struct evdev_client *client = file->private_data; 
     struct evdev *evdev = client->evdev; 
     struct input_event event; 
     int retval; 

     if (count < evdev_event_size()) 
               return -EINVAL; 

     if (client->head == client->tail && evdev->exist && 
         (file->f_flags & O_NONBLOCK)) 
               return -EAGAIN; 

     retval = wait_event_interruptible(evdev->wait, 
               client->head != client->tail || !evdev->exist); 
     if (retval) 
               return retval; 

     if (!evdev->exist) 
               return -ENODEV; 

     while (retval + evdev_event_size() <= count && 
            evdev_fetch_next_event(client, &event)) { 

               if (evdev_event_to_user(buffer + retval, &event)) 
                        return -EFAULT; 

               retval += evdev_event_size(); 
     } 

     return retval; 

}
首先,它判斷緩存區大小是否足夠.在讀取數據的情況下,可能當前緩存區內沒有數據可讀.在這里先睡眠等待緩存
區中有數據.如果在睡眠的時候,.條件滿足.是不會進行睡眠狀態而直接返回的. 然后根據read()提夠的緩存區大小.將client中的數據寫入到用戶空間的緩存區中.

五 用戶空間

到這就沒啥講的了， ok到此為止吧！！！