精品轉載：linux input 子系統分析 三

 linux input 子系統分析 三 2013-01-09 00:38:19

分類：

原文地址：linux input 子系統分析 三 作者：xieyancheng

一.  輸入子系統核心分析。

    1.輸入子系統核心對應與/drivers/input/input.c文件,這個也是作爲一個模塊註冊到內核的。所以首先分析模塊初始化函數。

static int __init input_init(void)
{
    int err;

    input_init_abs_bypass();
        //這個暫時沒有發現是做什麼的
    err = class_register(&input_class);
        //向內核註冊一個類，用於linux設備模型。註冊後會在/sys/class下面出現input目錄
    if (err) {
        printk(KERN_ERR "input: unable to register input_dev class\n");
        return err;
    }

    err = input_proc_init();
        //和proc文件系統有關，暫時不管
    if (err)
        goto fail1;


    err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
        //註冊字符設備，接口是2.4內核的。以主設備號INPUT_MAJOR,次設備號0-255,註冊266個設備，說明input設備最大只能有255個
    if (err) {
        printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
        goto fail2;
    }

    return 0;

 fail2: input_proc_exit();
 fail1: class_unregister(&input_class);
    return err;
}

    這個函數主要是註冊了字符設備，這裏和雜項設備的原理是一樣，所以input設備也是一類字符設備，只不過操作方法交給了輸入子系統。從這裏可以看出無論linux設備驅動這塊有多複雜，他們都是由一些基本的組件構成的，都是ldd3所講的基本驅動程序模型。 
    2. 輸入子系統的核心其他部分都是提供的接口，向上連接事件處理層，向下連接驅動層。
    向下對驅動層的接口主要有：
    input_allocate_device    這個函數主要是分配一個input_dev接口，並初始化一些基本的成員，這就是我們不能簡單用kmalloc分配input_dev結構的原因，因爲缺少了一些初始化。
    input_unregister_device  註冊一個input設備
    input_event              這個函數很重要，是驅動層向input子系統核心報告事件的函數，在事件傳遞過程中再分析。
    input_allocate_device    分配並初始化一個input_dev結構
    向上對事件處理層接口主要有：
    input_register_handler   註冊一個事件處理器
    input_register_handle    註冊一個input_handle結構
二.  事件處理層分析（以evdev事件處理器爲例）
    1.事件處理層與用戶程序和輸入子系統核心打交道，是他們兩層的橋樑。一般內核有好幾個事件處理器，像evdev mousedev jotdev。evdev事件處理器可以處理所有的事件，觸摸屏驅動就是用的這個，所以下面分析這個事件處理器的實現。它也是作爲模塊註冊到內核中的，首先分析它的模塊初始化函數。

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

   模塊初始化函數就調用一個註冊handler函數，將evdev_handler註冊到系統中。
    2.主要數據結構
    （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中創建這個結構，並初始化。在關閉設備文件的時候釋放這個結構。
   3.主要函數
   （1）evdev設備打開函數

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];
        //得到evdev設備結構,每次調用evdev_connect配對成功後都會把分配的evdev結構以minor爲索引，保存在evdev_table數組中
    if (evdev)
        get_device(&evdev->dev);  //增加device引用計數
    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設備結構聯繫起來
    evdev_attach_client(evdev, client);
        //這個函數所做的就是把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;
}

   （2）evdev設備打開函數evdev_open_device，由evdev_open調用。

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;
        //判斷設備結構是否存在，在evdev_connect中初始話此成員爲1
    else if (!evdev->open++) {
        retval = input_open_device(&evdev->handle);
        if (retval)
            evdev->open--;
    }
        //evdev->open分配結構的時候沒有初始化，默認爲0，也就是沒有打開，每次打開都會加1
    mutex_unlock(&evdev->mutex);
    return retval;
}

    此函數在判斷結構存在與否後，主要調用了input_open_device，這個函數是子系統核心函數，定義在input.c中，下面分析這個函數：

int input_open_device(struct input_handle *handle)
{
    struct input_dev *dev = handle->dev;
    int retval;


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


    if (dev->going_away) {
        retval = -ENODEV;
        goto out;
    }


    handle->open++;
        //將handle的打開計數加1，注意和evdev的open的區別
    if (!dev->users++ && dev->open)
        retval = dev->open(dev);
        //如果此input_dev沒有進程在引用，並且定義了open方法，就調用open方法
    if (retval) {    //retval = 1 說明沒有打開成功
        dev->users--;
        if (!--handle->open) {  //說明有其他的進程已經打開了這個handle
            /*
             * Make sure we are not delivering any more events
             * through this handle
             */
            synchronize_rcu();
        }
    }


 out:
    mutex_unlock(&dev->mutex);
    return retval;
}

   （3）讀操作函數 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;    //這個客戶端結構在打開的時候分配並保存在file->private_data中
    struct evdev *evdev = client->evdev;
    struct input_event event;
    int retval;


    if (count < input_event_size())
        return -EINVAL;
        //這條語句提示，用戶進程每次讀取設備的字節數，不要少於input_event結構的大小
    if (client->head == client->tail && evdev->exist &&
        (file->f_flags & O_NONBLOCK))
        return -EAGAIN;
        //head等於tail說明目前還沒有事件傳回來，如果設置了非阻塞操作，則會立刻返回
    retval = wait_event_interruptible(evdev->wait,
        client->head != client->tail || !evdev->exist);
        //沒有事件就會睡在evdev的等待隊列上了，等待條件是有事件到來或者設備不存在了（設備關閉的時候，清這個標誌）
    if (retval)
        return retval;
        //如果能執行上面這條語句說明有事件傳來或者，設備被關閉了，或者內核發過來終止信號
    if (!evdev->exist)
        return -ENODEV;


    while (retval + input_event_size() <= count &&
           evdev_fetch_next_event(client, &event)) {
        // evdev_fetch_next_event這個函數遍歷client裏面的input_event buffer數組
        if (input_event_to_user(buffer + retval, &event))
        //將事件複製到用戶空間
            return -EFAULT;


        retval += input_event_size();
    }

    return retval;   //返回複製的數據字節數
}

三. 事件傳遞過程（以s3c2410_ts爲例）
   1. 事件產生
    當按下觸摸屏時，進入觸摸屏按下中斷，開始ad轉換，ad轉換完成進入ad完成中斷，在這個終端中將事件發送出去，調用
    input_report_abs(dev, ABS_X, xp);
    input_report_abs(dev, ABS_Y, yp); 這兩個函數調用了 input_event(dev, EV_ABS, code, value)
    所有的事件報告函數都調用這個函數。
   2. 事件報告
   （1） input_event 函數分析，這個函數定義在input.c中

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);
        //這個函數是事件處理的關鍵函數，下面詳細分析
        spin_unlock_irqrestore(&dev->event_lock, flags);
    }
}

   （2） input_handle_event 函數分析，這個函數定義在input.c中

static void input_handle_event(struct input_dev *dev,
                   unsigned int type, unsigned int code, int value)
{
    int disposition = INPUT_IGNORE_EVENT;


    switch (type) {
        ......
    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);
                else
                    input_stop_autorepeat(dev);
            }
            disposition = INPUT_PASS_TO_HANDLERS;
        }
        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);


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

   這個函數主要是根據事件類型的不同，做相應的處理。這裏之關心EV_KEY類型，其他函數和事件傳遞關係不大，只要關心，disposition這個是事件處理的方式，默認的是INPUT_IGNORE_EVENT，忽略這個事件，如果是INPUT_PASS_TO_HANDLERS則是傳遞給事件處理器，如果是INPUT_PASS_TO_DEVICE，則是傳遞給設備處理，觸摸屏驅動沒有定義這個。下面分析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);  //如果是綁定的handle，則調用綁定的handler->event函數
    if (handle)
        handle->handler->event(handle, type, code, value);
    else
        //如果沒有綁定，則遍歷dev的h_list鏈表，尋找handle，如果handle已經打開，說明有進程讀取設備關聯的evdev。
        list_for_each_entry_rcu(handle, &dev->h_list, d_node)
            if (handle->open)
                handle->handler->event(handle,
                            type, code, value);
        // 調用相關的事件處理器的event函數，進行事件的處理
    rcu_read_unlock();
}

下面分析 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;
        //將傳過來的事件，賦值給input_event結構
    rcu_read_lock();


    client = rcu_dereference(evdev->grab);
        //如果evdev綁定了client那麼，處理這個客戶端，觸摸屏驅動沒有綁定
    if (client)
        evdev_pass_event(client, &event);
    else
        //遍歷client鏈表，調用evdev_pass_event函數
        list_for_each_entry_rcu(client, &evdev->client_list, node)
            evdev_pass_event(client, &event);


    rcu_read_unlock();


    wake_up_interruptible(&evdev->wait); //喚醒等待的進程
}

下面分析 evdev_pass_event 函數

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;   //將事件賦值給客戶端的input_event 數組
    client->head &= EVDEV_BUFFER_SIZE - 1;
    spin_unlock(&client->buffer_lock);


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

可以看出， evdev_pass_event函數最終將事件傳遞給了用戶端的client結構中的input_event數組中，只需將這個input_event數組複製給用戶空間，進程就能收到觸摸屏按下的信息了。具體處理由具體的應用程序來完成。