瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

​
【公众号】迅为电子

【粉丝群】824412014（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第十三篇 输入子系统_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

---

第150章 通用事件处理层event函数分析

接下来，我们将继续学习event和events函数，如下图所示：

evdev_events函数如下所示：

static void evdev_events(struct input_ handle *handle, const struct input_value *vals, unsigned int count)
{
    struct evdev *evdev = handle->private;  // 获取输入句柄的私有数据，这里假设是evdev结构体类型
    struct evdev_client *client;  // 定义evdev客户端指针
    ktime_t *ev_time = input_get_timestamp(handle->dev);  // 获取输入设备的时间戳

    rcu_read_lock();  // 开始读取RCU保护区域

    client = rcu_dereference(evdev->grab);  // RCU安全地获取当前的evdev客户端

    if (client)
        evdev_pass_values(client, vals, count, ev_time);  // 如果存在抢占的客户端，则将值传递给抢占的客户端
    else
        list_for_each_entry_rcu(client, &evdev->client_list, node)
            evdev_pass_values(client, vals, count, ev_time);  // 否则，将值传递给所有注册的客户端

    rcu_read_unlock();  // 结束读取RCU保护区域
}

该函数用于处理输入设备的事件。它接受一个输入句柄、一个输入值数组以及值的数量作为参数。

首先，它从输入句柄的私有数据中获取一个指向evdev结构体的指针。

然后，它获取输入设备的时间戳。

接下来，它通过使用RCU（Read-Copy-Update）机制来保护数据访问。通过调用rcu_read_lock()函数，它开始读取RCU保护区域。

然后，它通过RCU安全地获取当前的evdev客户端。如果存在抢占的客户端（即非空），它将调用evdev_pass_values函数将值传递给抢占的客户端。否则，它使用list_for_each_entry_rcu宏遍历evdev->client_list链表中的每个客户端，并调用evdev_pass_values函数将值传递给每个注册的客户端。

最后，它通过调用rcu_read_unlock()函数结束对RCU保护区域的读取操作。

我们学习一下evdev_pass_values函数，如下所示：

static void evdev_pass_values(struct evdev_client *client, const struct input_value *vals, unsigned int count, ktime_t *ev_time)
{
    struct evdev *evdev = client->evdev;  // 获取evdev客户端所属的evdev结构体
    const struct input_value *v;  // 当前处理的输入值
    struct input_event event;  // 输入事件结构体
    struct timespec64 ts;  // 时间戳
    bool wakeup = false;  // 是否需要唤醒等待线程

    if (client->revoked)
        return;  // 如果客户端已被撤销，则直接返回

    ts = ktime_to_timespec64(ev_time[client->clk_type]);  // 将ev_time转换为struct timespec64类型的时间戳
    event.input_event_sec = ts.tv_sec;  // 输入事件的秒字段设置为时间戳的秒值
    event.input_event_usec = ts.tv_nsec / NSEC_PER_USEC;  // 输入事件的微秒字段设置为时间戳的纳秒值除以1000得到的值

    /* 关中断，只需获取锁即可。 */
    spin_lock(&client->buffer_lock);  // 获取客户端的缓冲区锁

    for (v = vals; v != vals + count; v++) {
        if (__evdev_is_filtered(client, v->type, v->code))
            continue;  // 如果输入值被过滤，则跳过当前值的处理

        if (v->type == EV_SYN && v->code == SYN_REPORT) {
            /* 丢弃空的SYN_REPORT */
            if (client->packet_head == client->head)
                continue;  // 如果客户端的数据包头和数据头相同，则跳过当前值的处理

            wakeup = true;  // 设置唤醒标志为真
        }

        event.type = v->type;  // 设置输入事件的类型字段为当前值的类型
        event.code = v->code;  // 设置输入事件的代码字段为当前值的代码
        event.value = v->value;  // 设置输入事件的值字段为当前值的值
        __pass_event(client, &event);  // 将输入事件传递给客户端的事件处理函数
    }

    spin_unlock(&client->buffer_lock);  // 释放客户端的缓冲区锁

    if (wakeup)
        wake_up_interruptible(&evdev->wait);  // 如果需要唤醒等待线程，则唤醒等待队列中的线程
}

该函数用于将输入值传递给evdev客户端进行处理。它接受一个evdev_client结构体指针，一个输入值数组以及值的数量作为参数。

首先，它从客户端结构体中获取所属的evdev结构体。

然后，它检查客户端是否已被撤销，如果是，则直接返回。接下来，它将ev_time转换为struct timespec64类型的时间戳，并将其赋值给ts变量。然后，它将时间戳的秒值赋给输入事件结构体的input_event_sec字段，将时间戳的纳秒值除以1000得到的值赋给输入事件结构体的input_event_usec字段。然后，它获取客户端的缓冲区锁，以确保在处理输入值时不会有竞争条件。

接下来，它遍历输入值数组中的每个值。对于每个值，它首先检查是否被客户端过滤。如果被过滤，则跳过当前值的处理。

然后，它检查当前值是否为EV_SYN类型且代码为SYN_REPORT。如果是，它进一步检查客户端的数据包头和数据头是否相同。如果相同，则说明是一个空的SYN_REPORT，可以丢弃。否则，将唤醒标志设置为真。

接下来，它设置输入事件的类型字段为当前值的类型，代码字段为当前值的代码，值字段为当前值的值，并调用__pass_event函数将输入事件传递给客户端的事件处理函数。

完成对所有输入值的处理后，它释放客户端的缓冲区锁，解除对缓冲区的访问限制。

最后，如果需要唤醒等待线程（即唤醒标志为真），则调用wake_up_interruptible函数唤醒等待队列中的线程，以通知它们有新的事件可用。

   __pass_event函数将输入事件传递给客户端的事件处理函数，我们来学习一下。

static void __pass_event(struct evdev_client *client, const struct input_event *event)
{
    client->buffer[client->head++] = *event;  // 将事件复制到客户端的缓冲区中，然后将缓冲区头指针递增

    client->head &= client->bufsize - 1;  // 将缓冲区头指针掩码处理，确保其在缓冲区范围内

    if (unlikely(client->head == client->tail)) {
        /*
         * 这实际上"丢弃"了所有未消耗的事件，只保留了EV_SYN/SYN_DROPPED加上最新的事件。
         */
        client->tail = (client->head - 2) & (client->bufsize - 1);  // 更新缓冲区尾指针，使其指向倒数第二个事件

        client->buffer[client->tail] = (struct input_event) {
            .input_event_sec = event->input_event_sec,
            .input_event_usec = event->input_event_usec,
            .type = EV_SYN,
            .code = SYN_DROPPED,
            .value = 0,
        };  // 在缓冲区尾指针位置插入一个EV_SYN/SYN_DROPPED事件，表示丢弃了事件

        client->packet_head = client->tail;  // 更新数据包头指针为缓冲区尾指针
    }

    if (event->type == EV_SYN && event->code == SYN_REPORT) {
        client->packet_head = client->head;  // 更新数据包头指针为缓冲区头指针
        kill_fasync(&client->fasync, SIGIO, POLL_IN);  // 向注册的异步通知处理函数发送SIGIO信号，通知有新的事件可读取
    }
}

该函数用于将输入事件传递给evdev客户端的缓冲区进行存储。它接受一个evdev_client结构体指针和一个输入事件指针作为参数。

首先，它将输入事件复制到客户端的缓冲区中，并递增缓冲区头指针。

然后，它对缓冲区头指针进行掩码处理，以确保其在缓冲区范围内。

接下来，它检查缓冲区头指针是否等于缓冲区尾指针。如果相等，表示缓冲区已满，需要丢弃一些事件。

在这种情况下，它将缓冲区尾指针更新为缓冲区头指针减去2，并进行掩码处理，以确保其在缓冲区范围内。这样做是为了给丢弃的事件留出空间。

然后，它在缓冲区尾指针的位置插入一个EV_SYN/SYN_DROPPED事件，表示丢弃了事件。该事件具有与最新事件相同的时间戳。

接下来，它将数据包头指针更新为缓冲区尾指针，以确保数据包头始终指向最新的事件。

最后，如果输入事件的类型为EV_SYN且代码为SYN_REPORT，表示一个数据包的结束，它将数据包头指针更新为缓冲区头指针，并向注册的异步通知处理函数发送SIGIO信号，通知有新的事件可读取。

至此，通用事件处理层event函数分析完毕。