Linux电源管理6

Linux电源管理6（基于Linux6.6）---wakeup events framework介绍

---

一、 概述

在 Linux 操作系统中，wakeup events framework（唤醒事件框架）是电源管理的一部分，用于处理系统从低功耗状态（如休眠或待机）唤醒的事件和机制。它主要负责管理触发系统恢复的各种事件源，并确保在唤醒过程中，系统的状态能够正确恢复。

唤醒事件框架的核心目的是有效地管理硬件设备、系统中断以及其他外部因素的唤醒信号，以便系统能够在待机或休眠模式下减少功耗，同时又能够迅速响应外部事件的唤醒请求。唤醒事件框架解决了系统在进入低功耗状态和恢复工作状态之间的协调和同步问题。

1.1、Wakeup Events Framework 的工作原理

唤醒事件框架的工作涉及以下几个重要部分：

• 唤醒源（Wakeup Sources）：这是触发系统从低功耗状态恢复的事件或信号。唤醒源通常由硬件中断、外部设备、定时器、按键等触发。

• 唤醒事件（Wakeup Events）：是由硬件或软件触发的事件，用于通知内核某个条件已满足，系统应从低功耗状态恢复。常见的唤醒事件包括按键事件、网络数据包、外部传感器的信号等。

• 唤醒管理器（Wakeup Manager）：内核中的唤醒管理器负责协调和处理多个唤醒源的事件，决定哪个事件或信号可以触发系统唤醒，以及如何恢复系统状态。它还负责管理和清理唤醒事件，以确保系统状态一致性。

• 唤醒信号的注册与处理：硬件设备、驱动程序、定时器等可以注册唤醒信号。内核通过监听这些事件，确定系统何时恢复运行。例如，通过 GPIO 按钮触发的事件可能会向内核发送唤醒信号。

• 电源管理：唤醒事件框架通常与电源管理子系统紧密集成。内核通过该框架对各个设备和子系统的电源状态进行管理，同时确保唤醒过程中的状态恢复。

1.2、解决的问题

Linux 中的唤醒事件框架主要解决了以下几个问题：

如何高效管理多种唤醒源

现代系统中有许多不同的设备和事件源可能触发唤醒。比如，网络接口接收到数据包、USB 设备插入、硬件定时器超时、按钮按下等，都可能导致系统唤醒。唤醒事件框架需要协调这些不同的唤醒源，确保只有合适的事件会触发系统恢复。

如何确保唤醒的可靠性和同步性

唤醒事件框架需要确保在系统恢复时能够顺利恢复到原来的状态，包括恢复设备的工作状态、处理挂起时保存的数据等。如果唤醒过程中存在同步问题，可能导致设备无法正常工作或系统进入不稳定状态。

如何避免不必要的唤醒

不必要的唤醒会消耗宝贵的系统资源和电力。唤醒事件框架能够控制哪些事件真正需要唤醒系统，避免无用的唤醒，确保系统能够尽可能地处于低功耗状态。

设备驱动与硬件平台的兼容性问题

不同硬件平台的设备可能具有不同的电源管理特性，唤醒事件框架需要确保不同硬件平台的设备能够统一处理唤醒事件，避免驱动程序与硬件的兼容性问题。

1.3、功能总结

唤醒事件框架在 Linux 中的主要功能包括：

唤醒事件的注册与管理

系统中的设备驱动、内核模块和硬件设备可以通过特定的 API 注册唤醒事件。当某个设备或事件源能够触发唤醒时，它会向内核框架注册一个唤醒事件，并在需要时发送唤醒信号。

• 注册唤醒源：内核通过接口（如 wakeup_source_register()）注册各个唤醒源。
• 注销唤醒源：唤醒源可以在唤醒事件处理后注销，以避免系统无谓地响应相同的事件。

控制唤醒源的启用与禁用

唤醒事件框架提供了对唤醒源的控制功能，可以根据需要启用或禁用某些唤醒源。例如，系统可以在不需要外部事件时禁用某些唤醒源，从而降低不必要的功耗。

避免重复唤醒

唤醒事件框架能够避免系统因重复的唤醒源信号而被多次唤醒。这对于延长电池寿命和优化功耗是非常重要的。例如，如果系统在休眠中连续接收到相同的唤醒信号，框架会将其合并，防止不必要的重复唤醒。

唤醒事件的时序控制

框架确保唤醒事件按正确的顺序被处理。在多个事件源同时触发时，唤醒事件框架负责协调唤醒的时序，确保系统按预期的顺序恢复到正常状态。

处理设备和内核状态恢复

在系统从低功耗状态恢复时，唤醒事件框架与电源管理子系统紧密协作，确保恢复所有设备的工作状态，并恢复内存中的数据。这通常涉及到恢复设备的驱动程序、硬件状态以及进程的状态。

支持不同类型的低功耗模式

Linux 支持多种低功耗模式（如 suspend-to-RAM, suspend-to-disk, idle 等），唤醒事件框架需要支持这些模式中的唤醒事件管理，以确保系统在不同功耗状态下都能可靠地恢复。

二、wakeup events framework architecture

下图描述了wakeup events framework的architecture：

​

黄色模块的block是wakeup events相关的block：

1）wakeup events framework core，提供了wakeup events framework的核心功能，包括：

        抽象wakeup source和wakeup event的概念；

        向各个device driver提供wakeup source的注册、使能等接口；

        向各个device driver提供wakeup event的上报、停止等接口；

        向上层的PM core（包括wakeup count、auto sleep、suspend、hibernate等模块）提供wakeup event的查询接口，以判断是否可以suspend、是否需要终止正在进行的suspend。

2）wakeup events framework sysfs，将设备的wakeup信息，以sysfs的形式提供到用户空间，供用户空间程序查询、配置。

3）wake lock/unlock，为了兼容Android旧的wakeup lock机制而留下的一个后门，扩展wakeup events framework的功能，允许用户空间程序报告/停止wakeup events。

4）wakeup count，基于wakeup events framework，解决用户空间同步的问题。

5）auto sleep，允许系统在没有活动时，自动休眠。

三、 代码分析

3.1、wakeup source和wakeup event

在kernel中，可以唤醒系统的只有设备(struct device)，但并不是每个设备都具备唤醒功能，那些具有唤醒功能的设备称作wakeup source。struct device结构：

struct device {
        ...
        struct dev_pm_info      power;
        ...
};

该结构中有一个power变量，保存了和wakeup event相关的信息，让我们接着看一下struct dev_pm_info数据结构：

struct dev_pm_info {
        ...
        unsigned int            can_wakeup:1;
        ...
#ifdef CONFIG_PM_SLEEP
        ...
        struct wakeup_source    *wakeup;
        ...
#else
        unsigned int            should_wakeup:1;
#endif
};

can_wakeup，标识本设备是否具有唤醒能力。只有具备唤醒能力的设备，才会在sysfs中有一个power目录，用于提供所有的wakeup信息，这些信息是以struct wakeup_source的形式组织起来的。也就是上面wakeup指针。struct wakeup_source的定义。

include/linux/pm_wakeup.h

struct wakeup_source {
	const char 		*name;
	int			id;
	struct list_head	entry;
	spinlock_t		lock;
	struct wake_irq		*wakeirq;
	struct timer_list	timer;
	unsigned long		timer_expires;
	ktime_t total_time;
	ktime_t max_time;
	ktime_t last_time;
	ktime_t start_prevent_time;
	ktime_t prevent_sleep_time;
	unsigned long		event_count;
	unsigned long		active_count;
	unsigned long		relax_count;
	unsigned long		expire_count;
	unsigned long		wakeup_count;
	struct device		*dev;
	bool			active:1;
	bool			autosleep_enabled:1;
};

因此，一个wakeup source代表了一个具有唤醒能力的设备，也称该设备为一个wakeup source。

wakeup source代表一个具有唤醒能力的设备，该设备产生的可以唤醒系统的事件，就称作wakeup event。当wakeup source产生wakeup event时，需要将wakeup source切换为activate状态；当wakeup event处理完毕后，要切换为deactivate状态。因此，理解一下几个wakeup source比较混淆的变量：event_count, active_count和wakeup_count：

1. event_count

event_count 用于跟踪某个唤醒源被触发的总次数。每当唤醒源被触发（例如设备发出一个中断信号），event_count 就会递增。这个变量主要用于记录唤醒源的总事件次数。

• 用途：这个计数器跟踪唤醒源触发的次数，便于诊断和统计唤醒事件的发生频率。

• 示例：如果一个硬件设备（如定时器或外部中断）多次触发唤醒信号，event_count 就会在每次触发时增加。这个值通常用于调试和性能分析，以了解哪些唤醒源最常触发。

2. active_count

active_count 跟踪的是当前唤醒源处于活动状态的次数，表示唤醒源处于激活（或者正在监视中）的状态。只有当唤醒源被注册并且启用时，它才会被认为是“活动”状态。如果一个唤醒源被禁用或者不再参与系统的唤醒管理，它的 active_count 会被设为零。

• 用途：active_count 主要用于判断当前有多少个唤醒源处于活动状态。它能够反映系统中当前在监控的唤醒源数量，并帮助判断是否有过多的唤醒源被启用，可能导致不必要的功耗增加。

• 示例：假设有多个设备能够触发唤醒事件（如 USB 设备、定时器、外部中断等）。如果某个设备被禁用，active_count 就会减少，表示该唤醒源不再活跃。

3. wakeup_count

wakeup_count 用于记录系统实际因唤醒源被激活而导致的唤醒次数。即，当一个唤醒源触发了系统从低功耗模式恢复时，wakeup_count 就会递增。与 event_count 的区别在于，wakeup_count 只关注那些真正导致系统唤醒的事件。

• 用途：这个计数器用于跟踪系统从低功耗状态（如待机或休眠状态）唤醒的实际次数。它有助于监控系统的功耗和电池续航情况，尤其是在嵌入式和移动设备中非常重要。

• 示例：如果一个设备在待机模式下多次触发唤醒源，但是只有一些唤醒事件导致了系统从睡眠中恢复，wakeup_count 只会记录那些有效的唤醒事件，而 event_count 会记录所有的唤醒源触发事件（即使它们没有导致系统恢复）。

---

它们之间的关系：

• event_count 记录的是唤醒源触发的总次数（不一定每次都导致系统唤醒），它是一个广泛的计数器，统计唤醒源触发的所有事件。

• active_count 记录的是当前唤醒源处于活动状态的次数，反映了系统中有多少唤醒源是启用并处于监控状态的。

• wakeup_count 记录的是系统实际被唤醒的次数，仅计入那些真正使系统从低功耗状态恢复的事件。

举个例子：

假设一个设备（例如 USB 设备）是一个唤醒源，它会在有数据传输时触发唤醒。假设 USB 设备触发了 5 次唤醒事件，其中 3 次系统从睡眠中恢复，另外 2 次只是唤醒源触发了事件但没有导致系统唤醒。则：

• event_count 会是 5，因为唤醒源触发了 5 次事件。
• active_count 可能是 1，如果这个设备当前被启用为唤醒源并处于活动状态。
• wakeup_count 会是 3，因为其中只有 3 次事件真正导致了系统从睡眠中恢复。

3.2、几个counters

有几个比较重要的计数器，是wakeup events framework的实现基础，包括：

1. Registered Wakeup Events (已注册的唤醒事件)

在 Linux 内核中，“wakeup events” 是指某些事件或信号触发 CPU 或线程从休眠状态唤醒。这些事件可以是系统内部的硬件中断、内核信号，或者是由用户空间程序发起的事件。

• 已注册的唤醒事件指的是系统中所有触发唤醒的事件，这些事件通常会在内核中维护一个队列，等待它们触发并唤醒相应的任务。通常，这些事件包括：
  • 计时器中断（例如 hrtimer）
  • I/O 事件（例如磁盘、网络等 I/O 操作）
  • 用户空间进程发送的信号
  • 电源管理事件（例如从待机或休眠状态唤醒）

系统通过这些事件来决定何时唤醒被挂起的进程或线程。

2. saved_count

saved_count 是在某些情况下与唤醒事件、CPU 调度以及进程状态转换相关的一个计数值。在 Linux 内核中，saved_count 变量通常与内核的调度器和睡眠机制有关。它的作用通常是记录在等待事件（如 I/O 操作、计时器过期等）完成期间，系统保存的唤醒事件计数。

具体来说，saved_count 在某些调度器或睡眠机制中用于：

• 保存当前挂起事件的计数。
• 在进程被唤醒时，通过比较 saved_count 来判断是否所有预定的事件都已完成。

例如，在某些情况下，进程可能会因为 I/O 操作或定时器等待而进入睡眠状态，saved_count 记录了该进程在等待过程中需要的唤醒事件数量。当唤醒事件全部发生时，进程会被重新调度执行。

3. Wakeup Events in Progress (唤醒事件正在进行中)

“wakeup events in progress” 是指当前正在触发并正在处理的唤醒事件。这个概念常见于多核处理器系统中，尤其是在并发和任务调度方面。

具体来说，"wakeup events in progress" 可以指：

• 当前正在被内核处理的唤醒事件（例如，计时器中断或 I/O 完成信号）。
• 在多核系统中，可能会有多个核心在并行处理不同的唤醒事件。此时，内核会跟踪哪些唤醒事件正在进行中，以确保进程正确地从睡眠状态恢复到运行状态。

“wakeup events in progress” 也有助于在进行任务调度时，避免重复处理已经发生的事件或错误地唤醒不需要唤醒的任务。它通常会与“已注册的唤醒事件”和“saved_count”一起用于管理和同步唤醒操作。

3.3、wakeup events framework的核心功能

wakeup events framework的核心功能体现在它向底层的设备驱动所提供的用于上报wakeup event的接口，这些接口根据操作对象可分为两类，具体如下。

include/linux/pm_wakeup.h

类型一：

extern void __pm_stay_awake(struct wakeup_source *ws);
extern void __pm_relax(struct wakeup_source *ws);
extern void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec);

__pm_stay_awake，通知PM core，ws产生了wakeup event，且正在处理，因此不允许系统suspend（stay awake）；

__pm_relax，通知PM core，ws没有正在处理的wakeup event，允许系统suspend（relax）；

__pm_wakeup_event，为上边两个接口的功能组合，通知PM core，ws产生了wakeup event，会在msec毫秒内处理结束（wakeup events framework自动relax）。

类型二（操作对象为device，为设备驱动的常用接口）：

extern int device_wakeup_enable(struct device *dev);
extern int device_wakeup_disable(struct device *dev);
extern void device_set_wakeup_capable(struct device *dev, bool capable);
extern int device_init_wakeup(struct device *dev, bool val);
extern int device_set_wakeup_enable(struct device *dev, bool enable);
extern void pm_stay_awake(struct device *dev);
extern void pm_relax(struct device *dev);
extern void pm_wakeup_event(struct device *dev, unsigned int msec);

device_set_wakeup_capable，设置dev的can_wakeup标志，并增加或移除该设备在sysfs相关的power文件；

device_wakeup_enable/device_wakeup_disable/device_set_wakeup_enable，对于can_wakeup的设备，使能或者禁止wakeup功能。主要是对struct wakeup_source结构的相关操作；

device_init_wakeup，设置dev的can_wakeup标志，若是enable，同时调用device_wakeup_enable使能wakeup功能；

pm_stay_awake、pm_relax、pm_wakeup_event，直接调用上面的wakeup source操作接口，操作device的struct wakeup_source变量，处理wakeup events。

device_set_wakeup_capable

该接口位于在drivers/base/power/wakeup.c中，代码如下：

void device_set_wakeup_capable(struct device *dev, bool capable)
{
	if (!!dev->power.can_wakeup == !!capable)
		return;

	dev->power.can_wakeup = capable;
	if (device_is_registered(dev) && !list_empty(&dev->power.entry)) {
		if (capable) {
			int ret = wakeup_sysfs_add(dev);

			if (ret)
				dev_info(dev, "Wakeup sysfs attributes not added\n");
		} else {
			wakeup_sysfs_remove(dev);
		}
	}
}
EXPORT_SYMBOL_GPL(device_set_wakeup_capable);

接口的实现很简单，主要包括sysfs的add/remove和can_wakeup标志的设置两部分。如果设置can_wakeup标志，则调用wakeup_sysfs_add，向该设备的sysfs目录下添加power文件夹，并注册相应的attribute文件。如果清除can_wakeup标志，执行sysfs的移除操作。

wakeup_sysfs_add/wakeup_sysfs_remove位于drivers/base/power/sysfs.c中，对wakeup events framework来说，主要包括如下的attribute文件：

static struct attribute *wakeup_attrs[] = {
#ifdef CONFIG_PM_SLEEP
	&dev_attr_wakeup.attr,
	&dev_attr_wakeup_count.attr,
	&dev_attr_wakeup_active_count.attr,
	&dev_attr_wakeup_abort_count.attr,
	&dev_attr_wakeup_expire_count.attr,
	&dev_attr_wakeup_active.attr,
	&dev_attr_wakeup_total_time_ms.attr,
	&dev_attr_wakeup_max_time_ms.attr,
	&dev_attr_wakeup_last_time_ms.attr,
#ifdef CONFIG_PM_AUTOSLEEP
	&dev_attr_wakeup_prevent_sleep_time_ms.attr,
#endif
#endif
	NULL,
};
static const struct attribute_group pm_wakeup_attr_group = {
	.name	= power_group_name,
	.attrs	= wakeup_attrs,
};

1）wakeup

读，获得设备wakeup功能的使能状态，返回"enabled"或"disabled"字符串。

写，更改设备wakeup功能的使能状态，根据写入的字符串（"enabled"或"disabled"），调用device_set_wakeup_enable接口完成实际的状态切换。

设备wakeup功能是否使能，取决于设备的can_wakeup标志，以及设备是否注册有相应的struct wakeup_source指针。即can wakeup和may wakeup，如下：

 /*
 * Changes to device_may_wakeup take effect on the next pm state change.
 */
 
static inline bool device_can_wakeup(struct device *dev)
{
        return dev->power.can_wakeup;
}
 
static inline bool device_may_wakeup(struct device *dev)
{
        return dev->power.can_wakeup && !!dev->power.wakeup;
}

2）wakeup_count，只读，获取dev->power.wakeup->event_count值。

3）wakeup_active_count，只读，获取dev->power.wakeup->active_count值。

4）wakeup_abort_count，只读，获取dev->power.wakeup->wakeup_count值。

5）wakeup_expire_count，只读，获dev->power.wakeup->expire_count取值。

6）wakeup_active，只读，获取dev->power.wakeup->active值。

7）wakeup_total_time_ms，只读，获取dev->power.wakeup->total_time值，单位为ms。

8）wakeup_max_time_ms，只读，获dev->power.wakeup->max_time取值，单位为ms。

9）wakeup_last_time_ms，只读，获dev->power.wakeup->last_time取值，单位为ms。

10）wakeup_prevent_sleep_time_ms，只读，获取dev->power.wakeup->prevent_sleep_time值，单位为ms。

device_wakeup_enable/device_wakeup_disable/device_set_wakeup_enable

以device_wakeup_enable为例，drivers/base/power/wakeup.c

/**
 * device_wakeup_enable - Enable given device to be a wakeup source.
 * @dev: Device to handle.
 *
 * Create a wakeup source object, register it and attach it to @dev.
 */
int device_wakeup_enable(struct device *dev)
{
	struct wakeup_source *ws;
	int ret;

	if (!dev || !dev->power.can_wakeup)
		return -EINVAL;

	if (pm_suspend_target_state != PM_SUSPEND_ON)
		dev_dbg(dev, "Suspicious %s() during system transition!\n", __func__);

	ws = wakeup_source_register(dev, dev_name(dev));
	if (!ws)
		return -ENOMEM;

	ret = device_wakeup_attach(dev, ws);
	if (ret)
		wakeup_source_unregister(ws);

	return ret;
}
EXPORT_SYMBOL_GPL(device_wakeup_enable);

a）若设备指针为空，或者设备不具备wakeup能力，退出。

b）调用wakeup_source_register接口，以设备名为参数，创建并注册一个wakeup source。

c）调用device_wakeup_attach接口，将新建的wakeup source保存在dev->power.wakeup指针中。

pm_stay_awake

当设备有wakeup event正在处理时，需要调用该接口通知PM core，该接口的实现如下：

drivers/base/power/wakeup.c

void pm_stay_awake(struct device *dev)
{
	unsigned long flags;

	if (!dev)
		return;

	spin_lock_irqsave(&dev->power.lock, flags);
	__pm_stay_awake(dev->power.wakeup);
	spin_unlock_irqrestore(&dev->power.lock, flags);
}
EXPORT_SYMBOL_GPL(pm_stay_awake);

void __pm_stay_awake(struct wakeup_source *ws)
{
	unsigned long flags;

	if (!ws)
		return;

	spin_lock_irqsave(&ws->lock, flags);

	wakeup_source_report_event(ws, false);
	del_timer(&ws->timer);
	ws->timer_expires = 0;

	spin_unlock_irqrestore(&ws->lock, flags);
}
EXPORT_SYMBOL_GPL(__pm_stay_awake);

由于pm_stay_awake报告的event需要经过pm_relax主动停止，因此就不再需要timer，所以__pm_stay_awake实现是直接调用wakeup_source_report_event，然后停止timer。接着看代码：

drivers/base/power/wakeup.c

static void wakeup_source_report_event(struct wakeup_source *ws, bool hard)
{
	ws->event_count++;
	/* This is racy, but the counter is approximate anyway. */
	if (events_check_enabled)
		ws->wakeup_count++;

	if (!ws->active)
		wakeup_source_activate(ws);

	if (hard)
		pm_system_wakeup();
}

a）增加wakeup source的event_count，表示该source又产生了一个event。

b）根据events_check_enabled变量的状态，决定是否增加wakeup_count。这和wakeup count的功能有关，到时再详细描述。

c）如果wakeup source没有active，则调用wakeup_source_activate，activate之。event_count和active_count的区别所在。wakeup_source_activate的代码如下。

 drivers/base/power/wakeup.c

static void wakeup_source_activate(struct wakeup_source *ws)
{
	unsigned int cec;

	if (WARN_ONCE(wakeup_source_not_registered(ws),
			"unregistered wakeup source\n"))
		return;

	ws->active = true;
	ws->active_count++;
	ws->last_time = ktime_get();
	if (ws->autosleep_enabled)
		ws->start_prevent_time = ws->last_time;

	/* Increment the counter of events in progress. */
	cec = atomic_inc_return(&combined_event_count);

	trace_wakeup_source_activate(ws->name, cec);
}

到此，pm_stay_awake执行结束，意味着系统至少正在处理一个wakeup event，因此不能suspend。那处理完成后呢？driver要调用pm_relax通知PM core。

pm_relax

pm_relax和pm_stay_awake成对出现，用于在event处理结束后通知PM core，其实现如下：

drivers/base/power/wakeup.c

void pm_relax(struct device *dev)
{
	unsigned long flags;

	if (!dev)
		return;

	spin_lock_irqsave(&dev->power.lock, flags);
	__pm_relax(dev->power.wakeup);
	spin_unlock_irqrestore(&dev->power.lock, flags);
}
EXPORT_SYMBOL_GPL(pm_relax);

直接调用__pm_relax，如下：

void __pm_relax(struct wakeup_source *ws)
{
	unsigned long flags;

	if (!ws)
		return;

	spin_lock_irqsave(&ws->lock, flags);
	if (ws->active)
		wakeup_source_deactivate(ws);
	spin_unlock_irqrestore(&ws->lock, flags);
}
EXPORT_SYMBOL_GPL(__pm_relax);

 如果该wakeup source处于active状态，调用wakeup_source_deactivate接口，deactivate之。deactivate接口和activate接口一样，是wakeup events framework的核心逻辑，如下：

 drivers/base/power/wakeup.c

static void wakeup_source_deactivate(struct wakeup_source *ws)
{
	unsigned int cnt, inpr, cec;
	ktime_t duration;
	ktime_t now;

	ws->relax_count++;
	/*
	 * __pm_relax() may be called directly or from a timer function.
	 * If it is called directly right after the timer function has been
	 * started, but before the timer function calls __pm_relax(), it is
	 * possible that __pm_stay_awake() will be called in the meantime and
	 * will set ws->active.  Then, ws->active may be cleared immediately
	 * by the __pm_relax() called from the timer function, but in such a
	 * case ws->relax_count will be different from ws->active_count.
	 */
	if (ws->relax_count != ws->active_count) {
		ws->relax_count--;
		return;
	}

	ws->active = false;

	now = ktime_get();
	duration = ktime_sub(now, ws->last_time);
	ws->total_time = ktime_add(ws->total_time, duration);
	if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))
		ws->max_time = duration;

	ws->last_time = now;
	del_timer(&ws->timer);
	ws->timer_expires = 0;

	if (ws->autosleep_enabled)
		update_prevent_sleep_time(ws, now);

	/*
	 * Increment the counter of registered wakeup events and decrement the
	 * counter of wakeup events in progress simultaneously.
	 */
	cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);
	trace_wakeup_source_deactivate(ws->name, cec);

	split_counters(&cnt, &inpr);
	if (!inpr && waitqueue_active(&wakeup_count_wait_queue))
		wake_up(&wakeup_count_wait_queue);
}

pm_wakeup_event

pm_wakeup_event是pm_stay_awake和pm_relax的组合版，在上报event时，指定一个timeout时间，timeout后，自动relax，一般用于不知道何时能处理完成的场景。

pm_wakeup_pending

drivers产生的wakeup events，最终要上报到PM core，PM core会根据这些events，决定是否要终止suspend过程。该接口的实现如下：

drivers/base/power/wakeup.c

bool pm_wakeup_pending(void)
{
	unsigned long flags;
	bool ret = false;

	raw_spin_lock_irqsave(&events_lock, flags);
	if (events_check_enabled) {
		unsigned int cnt, inpr;

		split_counters(&cnt, &inpr);
		ret = (cnt != saved_count || inpr > 0);
		events_check_enabled = !ret;
	}
	raw_spin_unlock_irqrestore(&events_lock, flags);

	if (ret) {
		pm_pr_dbg("Wakeup pending, aborting suspend\n");
		pm_print_active_wakeup_sources();
	}

	return ret || atomic_read(&pm_abort_suspend) > 0;
}
EXPORT_SYMBOL_GPL(pm_wakeup_pending);

该接口的逻辑比较直观，只要正在处理的events不为0，就返回true，调用者就会终止suspend。