// include/linux/input.h（关键字段）
struct input_dev {
    const char *name;       // 设备名，显示在proc/bus/input/devices
    const char *phys;       // 物理路径，如"gpio-keys/input0"
    struct input_id id;     // 厂商/产品ID

    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)];  // 支持的绝对轴位图

    struct device dev;      // 内嵌device，支持设备模型    struct list_head h_list; // 绑定的handler链表
};

// include/uapi/linux/input.h
struct input_event {
    struct timeval time;  // 时间戳    __u16 type;           // 事件类型：EV_KEY/EV_REL/EV_ABS/EV_SYN
    __u16 code;           // 事件代码：KEY_ENTER/ABS_X等    __s32 value;          // 事件值：按键1按下0松开，坐标值等
};

1. devm_input_allocate_device  。 分配input_dev
2. 设置支持的事件类型和code   。 __set_bit / input_set_abs_params
3. input_register_device       。 注册到子系统
4. 上报事件                    。 input_report_* + input_sync

// gpio_key_input.c 。GPIO按键驱动，基于input子系。#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/of.h>
#include <linux/gpio/consumer.h>

struct gpio_key_priv {
    struct input_dev     *input;
    struct gpio_desc     *key_gpio;
    int                  irq;
    u32                  key_code;
};

static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
    struct gpio_key_priv *priv = dev_id;
    int val = gpiod_get_value(priv->key_gpio);

    // 上报按键事件。按下/松开
    input_report_key(priv->input, priv->key_code, val);
    input_sync(priv->input);

    return IRQ_HANDLED;
}

static int gpio_key_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct gpio_key_priv *priv;
    int ret;

    priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    // 获取GPIO描述。    priv->key_gpio = devm_gpiod_get(dev, "key", GPIOD_IN);
    if (IS_ERR(priv->key_gpio))
        return dev_err_probe(dev, PTR_ERR(priv->key_gpio),
                             "failed to get key gpio\n");

    // 从设备树读取按键码，默认KEY_POWER
    if (of_property_read_u32(dev->of_node, "linux,code", &priv->key_code))
        priv->key_code = KEY_POWER;

    // 分配input设备
    priv->input = devm_input_allocate_device(dev);
    if (!priv->input)
        return -ENOMEM;

    priv->input->name = "gpio-keys";
    priv->input->phys = "gpio-keys/input0";
    priv->input->id.bustype = BUS_HOST;

    // 声明支持EV_KEY事件和具体按键码
    __set_bit(EV_KEY, priv->input->evbit);
    __set_bit(priv->key_code, priv->input->keybit);

    // 注册input设备
    ret = input_register_device(priv->input);
    if (ret) {
        dev_err(dev, "failed to register input device: %d\n", ret);
        return ret;
    }

    // 申请中断，双边沿触发
    priv->irq = gpiod_to_irq(priv->key_gpio);
    ret = devm_request_irq(dev, priv->irq, gpio_key_isr,
                           IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                           "gpio-key", priv);
    if (ret) {
        dev_err(dev, "failed to request irq: %d\n", ret);
        return ret;
    }

    platform_set_drvdata(pdev, priv);
    return 0;
}

static const struct of_device_id gpio_key_of_match[] = {
    { .compatible = "myboard,gpio-key" },
    { }
};
MODULE_DEVICE_TABLE(of, gpio_key_of_match);

static struct platform_driver gpio_key_driver = {
    .probe  = gpio_key_probe,
    .driver = {
        .name = "gpio-key-input",
        .of_match_table = gpio_key_of_match,
    },
};
module_platform_driver(gpio_key_driver);

MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("GPIO key driver using input subsystem");
MODULE_LICENSE("GPL");

/ {
    gpio_keys {
        compatible = "myboard,gpio-key";
        key-gpios = <&gpio0 5 GPIO_ACTIVE_LOW>;
        linux,code = <KEY_ENTER>;
    };
};

void input_set_abs_params(struct input_dev *dev,
                          unsigned int axis,
                          int min, int max,
                          int fuzz, int flat);

// 初始化：声明支持N个触。input_mt_init_slots(input, 10, INPUT_MT_DIRECT);

// 上报流程
input_mt_slot(input, slot_id);                              // 选中slot
input_mt_report_slot_state(input, MT_TOOL_FINGER, true);   // 标记触点按下
input_report_abs(input, ABS_MT_POSITION_X, x);             // 上报X
input_report_abs(input, ABS_MT_POSITION_Y, y);             // 上报Y
input_mt_report_slot_state(input, MT_TOOL_FINGER, false);  // 标记触点抬起
input_sync(input);                                          // 同步

// ts_resistive.c 。电阻触摸屏驱动（单点触控+压力检测）
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/gpio/consumer.h>
#include <linux/delay.h>
#include <linux/of.h>
#include <linux/iio/consumer.h>

#define TS_MAX_X    4095
#define TS_MAX_Y    4095
#define TS_MAX_P    255
#define TS_MIN_P    0

struct ts_priv {
    struct input_dev     *input;
    struct iio_channel   *chan_x;
    struct iio_channel   *chan_y;
    struct iio_channel   *chan_pressure;
    struct gpio_desc     *pen_gpio;    // 笔触中断GPIO
    int                  pen_irq;
    struct work_struct   work;
};

static void ts_read_work(struct work_struct *work)
{
    struct ts_priv *priv = container_of(work, struct ts_priv, work);
    int x, y, pressure, pen_down;

    pen_down = !gpiod_get_value(priv->pen_gpio);  // 低电。按下
    if (!pen_down) {
        // 笔抬起，上报压力0并同。        input_report_key(priv->input, BTN_TOUCH, 0);
        input_report_abs(priv->input, ABS_PRESSURE, 0);
        input_sync(priv->input);
        return;
    }

    // 读取ADC通道
    if (iio_read_channel_raw(priv->chan_x, &x) ||
        iio_read_channel_raw(priv->chan_y, &y) ||
        iio_read_channel_raw(priv->chan_pressure, &pressure))
        return;

    // 裁剪到有效范。    x = clamp(x, 0, TS_MAX_X);
    y = clamp(y, 0, TS_MAX_Y);
    pressure = clamp(pressure, TS_MIN_P, TS_MAX_P);

    // 上报触摸事件
    input_report_key(priv->input, BTN_TOUCH, 1);
    input_report_abs(priv->input, ABS_X, x);
    input_report_abs(priv->input, ABS_Y, y);
    input_report_abs(priv->input, ABS_PRESSURE, pressure);
    input_sync(priv->input);
}

static irqreturn_t ts_pen_isr(int irq, void *dev_id)
{
    struct ts_priv *priv = dev_id;
    schedule_work(&priv->work);
    return IRQ_HANDLED;
}

static int ts_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct ts_priv *priv;
    int ret;

    priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
    if (!priv)
        return -ENOMEM;

    INIT_WORK(&priv->work, ts_read_work);

    // 获取IIO ADC通道（X/Y/Pressure。    priv->chan_x = devm_iio_channel_get(dev, "x");
    priv->chan_y = devm_iio_channel_get(dev, "y");
    priv->chan_pressure = devm_iio_channel_get(dev, "pressure");
    if (IS_ERR(priv->chan_x) || IS_ERR(priv->chan_y) ||
        IS_ERR(priv->chan_pressure))
        return dev_err_probe(dev, -EINVAL, "failed to get ADC channels\n");

    // 获取笔触中断GPIO
    priv->pen_gpio = devm_gpiod_get(dev, "pen", GPIOD_IN);
    if (IS_ERR(priv->pen_gpio))
        return dev_err_probe(dev, PTR_ERR(priv->pen_gpio),
                             "failed to get pen gpio\n");

    // 分配input设备
    priv->input = devm_input_allocate_device(dev);
    if (!priv->input)
        return -ENOMEM;

    priv->input->name = "resistive-ts";
    priv->input->id.bustype = BUS_HOST;

    // 声明支持的事。    __set_bit(EV_KEY, priv->input->evbit);
    __set_bit(EV_ABS, priv->input->evbit);
    __set_bit(BTN_TOUCH, priv->input->keybit);

    // 设置绝对坐标参数
    input_set_abs_params(priv->input, ABS_X, 0, TS_MAX_X, 0, 0);
    input_set_abs_params(priv->input, ABS_Y, 0, TS_MAX_Y, 0, 0);
    input_set_abs_params(priv->input, ABS_PRESSURE, TS_MIN_P, TS_MAX_P, 0, 0);

    ret = input_register_device(priv->input);
    if (ret)
        return dev_err_probe(dev, ret, "failed to register input device\n");

    // 申请笔触中断
    priv->pen_irq = gpiod_to_irq(priv->pen_gpio);
    ret = devm_request_irq(dev, priv->pen_irq, ts_pen_isr,
                           IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                           "ts-pen", priv);
    if (ret)
        return dev_err_probe(dev, ret, "failed to request pen irq\n");

    platform_set_drvdata(pdev, priv);
    return 0;
}

static const struct of_device_id ts_of_match[] = {
    { .compatible = "myboard,resistive-ts" },
    { }
};
MODULE_DEVICE_TABLE(of, ts_of_match);

static struct platform_driver ts_driver = {
    .probe  = ts_probe,
    .driver = {
        .name = "resistive-ts",
        .of_match_table = ts_of_match,
    },
};
module_platform_driver(ts_driver);

MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("Resistive touchscreen driver using input subsystem");
MODULE_LICENSE("GPL");

/ {
    resistive_ts {
        compatible = "myboard,resistive-ts";
        pen-gpios = <&gpio1 10 GPIO_ACTIVE_LOW>;
        x-channel = <&adc0 0>;
        y-channel = <&adc0 1>;
        pressure-channel = <&adc0 2>;
    };
};

// 用户态读取input事件示例
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/input.h>

int main(int argc, char *argv[])
{
    const char *dev = argc > 1 ? argv[1] : "/dev/input/event0";
    struct input_event ev;
    int fd = open(dev, O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    while (read(fd, &ev, sizeof(ev)) == sizeof(ev)) {
        if (ev.type == EV_KEY)
            printf("KEY  code=%d value=%d\n", ev.code, ev.value);
        else if (ev.type == EV_ABS)
            printf("ABS  code=%d value=%d\n", ev.code, ev.value);
        else if (ev.type == EV_SYN)
            printf("SYN_REPORT\n");
    }

    close(fd);
    return 0;
}

cat /proc/bus/input/devices

# 安装
sudo apt install evtest

# 监听指定设备
sudo evtest /dev/input/event2

# 交互式选择设备
sudo evtest

Event: time 1717700000.123456, type 1 (EV_KEY), code 28 (KEY_ENTER), value 1
Event: time 1717700000.123460, -------------- SYN_REPORT ------------
Event: time 1717700000.234567, type 1 (EV_KEY), code 28 (KEY_ENTER), value 0
Event: time 1717700000.234570, -------------- SYN_REPORT ------------

#include <libevdev/libevdev.h>

struct libevdev *dev = NULL;
int fd = open("/dev/input/event0", O_RDONLY);
libevdev_new_from_fd(fd, &dev);

printf("设备。 %s\n", libevdev_get_name(dev));
printf("支持EV_KEY: %d\n", libevdev_has_event_type(dev, EV_KEY));
printf("支持KEY_ENTER: %d\n", libevdev_has_event_code(dev, EV_KEY, KEY_ENTER));

struct input_event ev;
while (libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev) == LIBEVDEV_READ_STATUS_SUCCESS) {
    // 处理事件
}

libevdev_free(dev);
close(fd);

from evdev import InputDevice, categorize, ecodes

dev = InputDevice('/dev/input/event2')
print(f"设备: {dev.name}")

for event in dev.read_loop():
    if event.type == ecodes.EV_KEY:
        key = ecodes.KEY[event.code] if event.code in ecodes.KEY else f"KEY_{event.code}"
        state = "按下" if event.value else "松开"
        print(f"{key} {state}")
    elif event.type == ecodes.EV_ABS:
        abs_axis = ecodes.ABS[event.code] if event.code in ecodes.ABS else f"ABS_{event.code}"
        print(f"{abs_axis} = {event.value}")

// 错误：只设了keybit没设evbit
__set_bit(KEY_ENTER, input->keybit);  // 不够

// 正确：先设evbit再设keybit
__set_bit(EV_KEY, input->evbit);
__set_bit(KEY_ENTER, input->keybit);

// 最容易漏的：input_sync
input_report_key(input, KEY_ENTER, 1);
// input_sync(input);  。漏了这行，事件不会到达用户空```

### Q3：多点触控不识别。
Type B协议必须先调`input_mt_init_slots`，否则`input_mt_slot`和`input_mt_report_slot_state`都不会生效：

```c
// 注册前初始化MT slot
ret = input_mt_init_slots(input, max_touches, INPUT_MT_DIRECT);
if (ret)
    return ret;

// 上报时按顺序调用
input_mt_slot(input, slot);
input_mt_report_slot_state(input, MT_TOOL_FINGER, active);
input_report_abs(input, ABS_MT_POSITION_X, x);
input_report_abs(input, ABS_MT_POSITION_Y, y);
input_sync(input);  // 一批slot都报完再sync

分配 。设evbit 。设具体code/abs参数 。注册 。中断里上。sync