input子系统

输入设备（如按键、键盘、触摸屏、鼠标等）是典型的字符设备，其一般的工作机理是底层在按键、触摸等动作发送时产生一个中断（或驱动通过 timer 定时查询），然后 CPU 通过 SPI、 I2C或外部存储器总线读取键值、坐标等数据，放入一个缓冲区，字符设备驱动管理该缓冲区，而驱
动的 read()接口让用户可以读取键值、坐标等数据。
显然，在这些工作中，只是中断、读键值/坐标值是设备相关的，而输入事件的缓冲区管理以及字符设备驱动的 file_operations 接口则对输入设备是通用的。基于此，内核设计了输入子系统，由核心层处理公共的工作。
核心API：kernel/drivers/input/input.c

分配和释放一个设备
struct input_dev *devm_input_allocate_device(struct device *dev)；
void input_free_device(struct input_dev *dev)；

/**
 * devm_input_allocate_device - allocate managed input device
 * @dev: device owning the input device being created
 *
 * Returns prepared struct input_dev or %NULL.
 *
 * Managed input devices do not need to be explicitly unregistered or
 * freed as it will be done automatically when owner device unbinds from
 * its driver (or binding fails). Once managed input device is allocated,
 * it is ready to be set up and registered in the same fashion as regular
 * input device. There are no special devm_input_device_[un]register()
 * variants, regular ones work with both managed and unmanaged devices,
 * should you need them. In most cases however, managed input device need
 * not be explicitly unregistered or freed.
 *
 * NOTE: the owner device is set up as parent of input device and users
 * should not override it.
 */
struct input_dev *devm_input_allocate_device(struct device *dev)
{
    struct input_dev *input;
    struct input_devres *devres;

    devres = devres_alloc(devm_input_device_release,
                  sizeof(struct input_devres), GFP_KERNEL);
    if (!devres)
        return NULL;

    input = input_allocate_device();
    if (!input) {
        devres_free(devres);
        return NULL;
    }

    input->dev.parent = dev;
    input->devres_managed = true;

    devres->input = input;
    devres_add(dev, devres);

    return input;
}
EXPORT_SYMBOL(devm_input_allocate_device);

/**
 * input_free_device - free memory occupied by input_dev structure
 * @dev: input device to free
 *
 * This function should only be used if input_register_device()
 * was not called yet or if it failed. Once device was registered
 * use input_unregister_device() and memory will be freed once last
 * reference to the device is dropped.
 *
 * Device should be allocated by input_allocate_device().
 *
 * NOTE: If there are references to the input device then memory
 * will not be freed until last reference is dropped.
 */
 //释放一个输入设备
void input_free_device(struct input_dev *dev)
{
    if (dev) {
        if (dev->devres_managed)
            WARN_ON(devres_destroy(dev->dev.parent,
                        devm_input_device_release,
                        devm_input_device_match,
                        dev));
        input_put_device(dev);
    }
}
EXPORT_SYMBOL(input_free_device);

注册和注销一个输入设备
int input_register_device(struct input_dev *dev)；
void input_unregister_device(struct input_dev *dev)；

/**
 * input_register_device - register device with input core
 * @dev: device to be registered
 *
 * This function registers device with input core. The device must be
 * allocated with input_allocate_device() and all it's capabilities
 * set up before registering.
 * If function fails the device must be freed with input_free_device().
 * Once device has been successfully registered it can be unregistered
 * with input_unregister_device(); input_free_device() should not be
 * called in this case.
 *
 * Note that this function is also used to register managed input devices
 * (ones allocated with devm_input_allocate_device()). Such managed input
 * devices need not be explicitly unregistered or freed, their tear down
 * is controlled by the devres infrastructure. It is also worth noting
 * that tear down of managed input devices is internally a 2-step process:
 * registered managed input device is first unregistered, but stays in
 * memory and can still handle input_event() calls (although events will
 * not be delivered anywhere). The freeing of managed input device will
 * happen later, when devres stack is unwound to the point where device
 * allocation was made.
 */

int input_register_device(struct input_dev *dev)
{
    struct input_devres *devres = NULL;
    struct input_handler *handler;
    unsigned int packet_size;
    const char *path;
    int error;

    if (dev->devres_managed) {
        devres = devres_alloc(devm_input_device_unregister,
                      sizeof(struct input_devres), GFP_KERNEL);
        if (!devres)
            return -ENOMEM;

        devres->input = dev;
    }

    /* Every input device generates EV_SYN/SYN_REPORT events. */
    __set_bit(EV_SYN, dev->evbit);

    /* KEY_RESERVED is not supposed to be transmitted to userspace. */
    __clear_bit(KEY_RESERVED, dev->keybit);

    /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
    input_cleanse_bitmasks(dev);

    packet_size = input_estimate_events_per_packet(dev);
    if (dev->hint_events_per_packet < packet_size)
        dev->hint_events_per_packet = packet_size;

    dev->max_vals = dev->hint_events_per_packet + 2;
    dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
    if (!dev->vals) {
        error = -ENOMEM;
        goto err_devres_free;
    }

    /*
     * 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.
     */
    if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
        input_enable_softrepeat(dev, 250, 33);

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

    if (!dev->setkeycode)
        dev->setkeycode = input_default_setkeycode;

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

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

    error = mutex_lock_interruptible(&input_mutex);
    if (error)
        goto err_device_del;

    list_add_tail(&dev->node, &input_dev_list);

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

    input_wakeup_procfs_readers();

    mutex_unlock(&input_mutex);

    if (dev->devres_managed) {
        dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
            __func__, dev_name(&dev->dev));
        devres_add(dev->dev.parent, devres);
    }
    return 0;

err_device_del:
    device_del(&dev->dev);
err_free_vals:
    kfree(dev->vals);
    dev->vals = NULL;
err_devres_free:
    devres_free(devres);
    return error;
}
EXPORT_SYMBOL(input_register_device);

/**
 * input_unregister_device - unregister previously registered device
 * @dev: device to be unregistered
 *
 * This function unregisters an input device. Once device is unregistered
 * the caller should not try to access it as it may get freed at any moment.
 */

void input_unregister_device(struct input_dev *dev)
{
    if (dev->devres_managed) {
        WARN_ON(devres_destroy(dev->dev.parent,
                    devm_input_device_unregister,
                    devm_input_device_match,
                    dev));
        __input_unregister_device(dev);
        /*
         * We do not do input_put_device() here because it will be done
         * when 2nd devres fires up.
         */
    } else {
        __input_unregister_device(dev);
        input_put_device(dev);
    }
}
EXPORT_SYMBOL(input_unregister_device);

报告输入事件
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)；
报告键值
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)；
报告相对坐标
static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)；
报告绝对坐标
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)；
报告同步事件
static inline void input_sync(struct input_dev *dev)；

/**
 * input_event() - report new input event
 * @dev: device that generated the event
 * @type: type of the event
 * @code: event code
 * @value: value of the event
 *
 * This function should be used by drivers implementing various input
 * devices to report input events. See also input_inject_event().
 *
 * NOTE: input_event() may be safely used right after input device was
 * allocated with input_allocate_device(), even before it is registered
 * with input_register_device(), but the event will not reach any of the
 * input handlers. Such early invocation of input_event() may be used
 * to 'seed' initial state of a switch or initial position of absolute
 * axis, etc.
 */
 //报告制定type、code的输入事件
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);
        input_handle_event(dev, type, code, value);
        spin_unlock_irqrestore(&dev->event_lock, flags);
    }
}
EXPORT_SYMBOL(input_event);

//报告键值
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_report_rel(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_REL, code, value);
}
//报告绝对坐标
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_ABS, code, value);
}
//报告同步事件
static inline void input_sync(struct input_dev *dev)
{
    input_event(dev, EV_SYN, SYN_REPORT, 0);
}

在kernel/include/uapi/linux/input.h中定义了input_event结构体。

struct input_event {
        struct timeval time;
        __u16 type;
        __u16 code;
        __s32 value;
};

drivers/input/keyboard/gpio_keys.c 基于 input 架构实现了一个通用的 GPIO 按键驱动。该驱动
基于 platform_driver 架构，名为“gpio-keys”。它将硬件相关的信息（如使用的 GPIO 号，按下和
抬起时的电平等）屏蔽在板文件 platform_device 的 platform_data 中，因此该驱动可应用于各个处
理器，具有良好的跨平台性。