為何需要input子系統

Linux系統支援的許多裝置，都是輸入性的裝置，如按鍵、觸控式螢幕、鍵盤、滑鼠。本質上都是一個個的字元裝置驅動，Linux系統為這些裝置統一管理實現了input子系統，方便驅動和應用的開發。

input子系統軟體架構

linux輸入子系統主要分三層：driver層，core層， event hander層。
Driver層根據core層提供的介面，向上報告發生的按鍵動作。然後core根據驅動的型別，分派這個報告給對應的event hander進行處理。
event hander層把資料變化反應到裝置模型的檔案中（事件緩衝區）。並通知在這些裝置模型檔案上等待的程序。

input子系統工作原理

註冊匹配過程

device註冊：

int input_register_device(struct input_dev *dev)
{
    ...

    //加到input_dev_list
    list_add_tail(&dev->node, &input_dev_list);

    //從input_handler_list匹配
    list_for_each_entry(handler, &input_handler_list, node)
        input_attach_handler(dev, handler);
    ...
 

}

handle註冊：

int input_register_handler(struct input_handler *handler)
{
    struct input_dev *dev;
    int error;

    error = mutex_lock_interruptible(&input_mutex);
    if (error)
        return error;

    INIT_LIST_HEAD(&handler->h_list);

    //加入input_handler_list
    list_add_tail(&handler->node, &input_handler_list);

    //依次對input_dev_list的dev做匹配
 

    list_for_each_entry(dev, &input_dev_list, node)
        input_attach_handler(dev, handler);

    input_wakeup_procfs_readers();

    mutex_unlock(&input_mutex);
    return 0;
}

input_attach_handler就是根據id匹配的過程。

讀取過程

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;
size_t read = 0;
int error;

if (count != 0 && count < input_event_size())
    return -EINVAL;

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

    if (client->packet_head == client->tail &&
        (file->f_flags & O_NONBLOCK))
        return -EAGAIN;

    /*
     * count == 0 is special - no IO is done but we check
     * for error conditions (see above).
     */
    if (count == 0)
        break;

    while (read + input_event_size() <= count &&
           evdev_fetch_next_event(client, &event)) {

        if (input_event_to_user(buffer + read, &event))
            return -EFAULT;

        read += input_event_size();
    }

    if (read)
        break;
    //睡眠等待資料
    if (!(file->f_flags & O_NONBLOCK)) {
        error = wait_event_interruptible(evdev->wait,
                client->packet_head != client->tail ||
                !evdev->exist);
        if (error)
            return error;
    }
}

return read;

}

事件上報

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

static inline void input_sync(struct input_dev *dev)
{
    input_event(dev, EV_SYN, SYN_REPORT, 0);
}

其實都是呼叫到input_event，最後呼叫handler->event

static void evdev_events(struct input_handle *handle,
             const struct input_value *vals, unsigned int count)
{
    struct evdev *evdev = handle->private;
    struct evdev_client *client;
    ktime_t time_mono, time_real;

    time_mono = ktime_get();
    time_real = ktime_sub(time_mono, ktime_get_monotonic_offset());

    rcu_read_lock();

    client = rcu_dereference(evdev->grab);

    if (client)
        evdev_pass_values(client, vals, count, time_mono, time_real);
    else
        list_for_each_entry_rcu(client, &evdev->client_list, node)
            evdev_pass_values(client, vals, count,
                      time_mono, time_real);

    rcu_read_unlock();
}

static void evdev_pass_values(struct evdev_client *client,
            const struct input_value *vals, unsigned int count,
            ktime_t mono, ktime_t real)
{
    struct evdev *evdev = client->evdev;
    const struct input_value *v;
    struct input_event event;
    bool wakeup = false;

    event.time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
                      mono : real);

    /* Interrupts are disabled, just acquire the lock. */
    spin_lock(&client->buffer_lock);

    for (v = vals; v != vals + count; v++) {
        event.type = v->type;
        event.code = v->code;
        event.value = v->value;
        __pass_event(client, &event);
        if (v->type == EV_SYN && v->code == SYN_REPORT)
            wakeup = true;
    }

    spin_unlock(&client->buffer_lock);

    if (wakeup)
        wake_up_interruptible(&evdev->wait);//喚醒程序
}

如何寫input子系統裝置驅動

分配一個input_dev結構體

ts->input_dev = input_allocate_device();

設定

ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
ts->input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
input_set_abs_params(ts->input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);
input_set_abs_params(ts->input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);
input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);

註冊

ret = input_register_device(ts->input_dev);

硬體相關的程式碼，比如在中斷服務程式裡上報事件

static irqreturn_t goodix_ts_irq_hanbler(int irq, void *dev_id)
{
    struct goodix_ts_data *ts = (struct goodix_ts_data *)dev_id;

    dprintk(DEBUG_INT_INFO,"==========------TS Interrupt-----============\n");
    queue_work(goodix_wq, &ts->work);
    return IRQ_HANDLED;
}

static void goodix_ts_work_func(struct work_struct *work)
{
    for (idx= 0; idx < GTP_MAX_KEY_NUM; idx++){
        input_report_key(ts->input_dev, touch_key_array[idx], key_value & (0x01<<idx));
    }
    //input_report_key(ts->input_dev, BTN_TOUCH, (touch_num || key_value));
    input_sync(ts->input_dev);
}