Linux电源管理(7)_Wakeup events framework_抽象wakeup source和wakeup event的概念

1. 前言

本文继续“Linux电源管理(6)_Generic PM之Suspend功能”中有关suspend同步以及PM wakeup的话题。这个话题，是近几年Linux kernel最具争议的话题之一，在国外Linux开发论坛，经常可以看到围绕该话题的辩论。辩论的时间跨度和空间跨度可以持续很长，且无法达成一致。

wakeup events framework是这个话题的一个临时性的解决方案，包括wake lock、wakeup count、autosleep等机制。它们就是本文的话题。

2. wakeup events framework要解决的问题

我们知道，系统处于suspend状态，可通过wakeup events唤醒。具体的wakeup events可以是按键按下，可以是充电器插入，等等。但是，如果在suspend的过程中，产生了wakeup events，怎么办？答案很肯定，"wakeup"系统。由于此时系统没有真正suspend，所以这的"wakeup"是个假动作，实际上只是终止suspend。

但由于系统在suspend的过程中，会进行process freeze、 device suspend等操作，而这些操作可能导致内核或用户空间程序不能及时获取wakeup events，从而使系统不能正确wakeup，这就是wakeup events framework要解决的问题：system suspend和system wakeup events之间的同步问题。

3. wakeup events framework的功能总结

仔细推敲一下，上面所讲的同步问题包括两种情况：

情况1：内核空间的同步

wakeup events产生后，通常是以中断的形式通知device driver。driver会处理events，处理的过程中，系统不能suspend。

注1：同步问题只存在于中断开启的情况，因为若中断关闭，就不会产生wakeup events，也就不存在同步的概念。
1
2
3

情况2：用户空间的同步

一般情况下，driver对wakeup events处理后，会交给用户空间程序继续处理，处理的过程，也不允许suspend。这又可以分为两种情况：

1）进行后续处理的用户进程，根本没有机会被调度，即该wakeup events无法上报到用户空间。

2）进行后续处理的用户进程被调度，处理的过程中（以及处理结束后，决定终止suspend操作），系统不能suspend。
1
2
3
4
5

因此，wakeup events framework就包括3大功能：

解决内核空间同步问题（framework的核心功能）；

解决用户空间同步问题的情景1（wakeup count功能）；

解决用户空间同步问题的情景2（wake lock功能） 。
1
2
3
4
5

注2：

用户空间同步的两种情况，咋一看，非常合乎情理，kernel你得好好处理！但事实上，该同步问题牵涉到了另外一个比较有争议的话题：日常的电源管理机制。是否要基于suspend实现？系统何时进入低功耗状态，应该由谁决定？kernel还是用户空间程序？

这最终会决定是否存在用空间同步问题。但是，在当前这个时间点，对这个话题，Linux kernel developers和Android developers持相反的观点。这也造成了wakeup events framework在实现上的撕裂。Kernel的本意是不愿处理用户空间同步问题的，但为了兼容Android平台，不得不增加相关的功能（Wakeup count和Wake lock）。

蜗蜗会在下一篇文章和大家探讨该话题，本文就先focus在wakeup events framework上。

4. wakeup events framework architecture

下面图片描述了wakeup events framework的architecture：

图片中红色边框的block是wakeup events相关的block：

1）wakeup events framework core，在drivers/base/power/wakeup.c中实现，提供了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。
1
2
3
4
5
6
7

2）wakeup events framework sysfs，将设备的wakeup信息，以sysfs的形式提供到用户空间，供用户空间程序查询、配置。在drivers/base/power/sysfs.c中实现

3）wake lock/unlock，为了兼容Android旧的wakeup lock机制而留下的一个后门，扩展wakeup events framework的功能，允许用户空间程序报告/停止wakeup events。换句话说，该后门允许用户空间的任一程序决定系统是否可以休眠。

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

5）auto sleep，允许系统在没有活动时（即一段时间内，没有产生wakeup event），自动休眠。

注3：在Linux kernel看来，power是系统的核心资源，不应开放给用户程序随意访问（wake lock机制违背了这个原则）。而在运行时的电源管理过程中，系统何时进入低功耗状态，也不是用户空间程序能决定的（auto sleep中枪了）。因此，kernel对上述功能的支持，非常的不乐意，我们可以从kernel/power/main.c中sysfs attribute文件窥见一斑（只要定义了PM_SLEEP，就一定支持wakeup count功能，但autosleep和wake lock功能，由另外的宏定义控制）：

static struct attribute * g[] = {
	&state_attr.attr,
#ifdef CONFIG_PM_TRACE
	&pm_trace_attr.attr,
	&pm_trace_dev_match_attr.attr,
#endif
#ifdef CONFIG_PM_SLEEP
	&pm_async_attr.attr,
	&wakeup_count_attr.attr,
#ifdef CONFIG_SUSPEND
	&mem_sleep_attr.attr,
	&sync_on_suspend_attr.attr,
#endif
#ifdef CONFIG_PM_AUTOSLEEP
	&autosleep_attr.attr,
#endif
#ifdef CONFIG_PM_WAKELOCKS
	&wake_lock_attr.attr,
	&wake_unlock_attr.attr,
#endif
#ifdef CONFIG_PM_SLEEP_DEBUG
	&pm_test_attr.attr,
	&pm_print_times_attr.attr,
	&pm_wakeup_irq_attr.attr,
	&pm_debug_messages_attr.attr,
#endif
#endif
#ifdef CONFIG_FREEZER
	&pm_freeze_timeout_attr.attr,
#endif
	NULL,
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

5. 代码分析

5.1 wakeup source和wakeup event

在kernel中，可以唤醒系统的只有设备(struct device)，但并不是每个设备都具备唤醒功能，那些具有唤醒功能的设备称作wakeup source。是时候回到这篇文章中了（Linux设备模型(5)_device和device driver），在那里，介绍struct device结构时，涉及到一个struct dev_pm_info类型的power变量，蜗蜗说留待后面的专题讲解。我们再回忆一下struct device结构：

   1: struct device {
   2:         ...
   3:         struct dev_pm_info      power;
   4:         ...
   5: };
1
2
3
4
5

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

   1: struct dev_pm_info {
   2:         ...
   3:         unsigned int            can_wakeup:1;
   4:         ...
   5: #ifdef CONFIG_PM_SLEEP
   6:         ...
   7:         struct wakeup_source    *wakeup;
   8:         ...
   9: #else
  10:         unsigned int            should_wakeup:1;
  11: #endif
  12: };
1
2
3
4
5
6
7
8
9
10
11
12

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;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

因此，一个wakeup source代表了一个具有唤醒能力的设备，也称该设备为一个wakeup source。该结构中各个字段的意义如下：

name，该wakeup source的名称，一般为对应的device name（有个例外，就是wakelock）；

entery，用于将所有的wakeup source挂在一个链表中；

timer、timer_expires，一个wakeup source产生了wakeup event，称作wakeup source activate，wakeup event处理完毕后（不再需要系统为此保持active），称作deactivate。activate和deactivate的操作可以由driver亲自设置，也可以在activate时，指定一个timeout时间，时间到达后，由wakeup events framework自动将其设置为deactivate状态。这里的timer以及expires时间，就是用来实现该功能；

total_time，该wakeup source处于activate状态的总时间（可以指示该wakeup source对应的设备的繁忙程度、耗电等级）；

max_time，该wakeup source持续处于activate状态的最大时间（越长越不合理）；

last_time，该wakeup source上次active的开始时间；

start_prevent_time，该wakeup source开始阻止系统自动睡眠（auto sleep）的时间点；

prevent_sleep_time，该wakeup source阻止系统自动睡眠的总时间；

event_count，wakeup source上报的event个数；

active_count，wakeup source activate的次数；

relax_count， wakeup source deactivate的次数；

expire_count，wakeup source timeout到达的次数；

wakeup_count，wakeup source终止suspend过程的次数；

active，wakeup source的activate状态；

autosleep_enabled，记录系统auto sleep的使能状态（每个wakeup source都重复记录这样一个状态，这种设计真实不敢恭维！）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

event_count，wakeup source产生的wakeup event的个数；

active_count，产生wakeup event时，wakeup source需要切换到activate状态。但并不是每次都要切换，因此有可能已经处于activate状态了。因此active_count可能小于event_count，换句话说，很有可能在前一个wakeup event没被处理完时，又产生了一个。这从一定程度上反映了wakeup source所代表的设备的繁忙程度；

wakeup_count，wakeup source在suspend过程中产生wakeup event的话，就会终止suspend过程，该变量记录了wakeup source终止suspend过程的次数（如果发现系统总是suspend失败，检查一下各个wakeup source的该变量，就可以知道问题出在谁身上了）。
1
2
3
4
5

5.2 几个counters

在drivers/base/power/wakeup.c中，有几个比较重要的计数器，是wakeup events framework的实现基础，包括：

1）registered wakeup events和saved_count

记录了系统运行以来产生的所有wakeup event的个数，在wakeup source上报event时加1。

这个counter对解决用户空间同步问题很有帮助，因为一般情况下（无论是用户程序主动suspend，还是auto sleep），由专门的进程（或线程）触发suspend。当这个进程判断系统满足suspend条件，决定suspend时，会记录一个counter值(saved_count)。在后面suspend的过程中，如果系统发现counter有变，则说明系统产生了新的wakeup event，这样就可以终止suspend。

该功能即是wakeup count功能，会在后面更详细的说明。

2）wakeup events in progress

记录正在处理的event个数。

当wakeup source产生wakeup event时，会通过wakeup events framework提供的接口将wakeup source设置为activate状态。当该event处理结束后，设置为deactivate状态。activate到deactivate的区间，表示该event正在被处理。

当系统中有任何正在被处理的wakeup event时，则不允许suspend。如果suspend正在进行，则要终止。

思考一个问题：registered wakeup events在什么时候增加？答案是在wakeup events in progress减小时，因为已经完整的处理完一个event了，可以记录在案了。

基于这种特性，kernel将它俩合并成一个32位的整型数，以原子操作的形式，一起更新。这种设计巧妙的让人叫绝，值得我们学习。具体如下：

/*
 * Combined counters of registered wakeup events and wakeup events in progress.
 * They need to be modified together atomically, so it's better to use one
 * atomic variable to hold them both.
 */
static atomic_t combined_event_count = ATOMIC_INIT(0);

#define IN_PROGRESS_BITS	(sizeof(int) * 4)
#define MAX_IN_PROGRESS		((1 << IN_PROGRESS_BITS) - 1)

static void split_counters(unsigned int *cnt, unsigned int *inpr)
{
	unsigned int comb = atomic_read(&combined_event_count);

	*cnt = (comb >> IN_PROGRESS_BITS);
	*inpr = comb & MAX_IN_PROGRESS;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

定义和读取。

  1: cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);
1

   1: cec = atomic_inc_return(&combined_event_count);
1

wakeup events in progress加1。

5.3 wakeup events framework的核心功能

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

类型一（操作对象为wakeup source，编写设备驱动时，一般不会直接使用）：

   1: /* include/linux/pm_wakeup.h */
   2: extern void __pm_stay_awake(struct wakeup_source *ws);
   3: extern void __pm_relax(struct wakeup_source *ws);
   4: extern void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec);
1
2
3
4

__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）。

注4：__pm_stay_awake和__pm_relax应成对调用。
注5：上面3个接口，均可以在中断上下文调用。
1
2
3
4
5
6
7
8

类型二（操作对象为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_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_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard);
extern void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard);

1
2
3
4
5
6
7
8
9

device_set_wakeup_capable，设置dev的can_wakeup标志（enable或disable，可参考5.1小节），并增加或移除该设备在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。
1
2
3
4
5
6
7

5.3.1 device_set_wakeup_capable

/**
 * device_set_wakeup_capable - 设置/重置设备的唤醒能力标志。
 * @dev: 要处理的设备。
 * @capable: 指定 @dev 是否具有从睡眠中唤醒系统的能力。
 *
 * 如果 @capable 被设置为真，设置 @dev 的 power.can_wakeup 标志，并将与其唤醒相关的属性添加到 sysfs 中。
 * 否则，取消 @dev 的 power.can_wakeup 标志，并从 sysfs 中移除与其唤醒相关的属性。
 *
 * 此函数可能会休眠，不能从任何不允许休眠的上下文中调用。
 */
void device_set_wakeup_capable(struct device *dev, bool capable)
{
	// 检查设备的唤醒能力标志是否需要更改，如果不需要，则直接返回
	if (!!dev->power.can_wakeup == !!capable)
		return;

	// 更新设备的唤醒能力标志
	dev->power.can_wakeup = capable;

	// 如果设备已注册且 power.entry 列表不为空
	if (device_is_registered(dev) && !list_empty(&dev->power.entry)) {
		// 如果设备具有唤醒能力，则向 sysfs 添加唤醒相关的属性
		if (capable) {
			int ret = wakeup_sysfs_add(dev);

			if (ret)
				dev_info(dev, "Wakeup sysfs attributes not added\n");
		} else {
			// 否则，从 sysfs 中移除与唤醒相关的属性
			wakeup_sysfs_remove(dev);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

函数 device_set_wakeup_capable 用于设置或重置设备的唤醒能力标志。通过传入的 capable 参数指定设备是否具有从睡眠中唤醒系统的能力。

函数首先检查设备的唤醒能力标志是否需要更改，如果不需要，则直接返回。然后，更新设备的 power.can_wakeup 标志，以反映设备的唤醒能力。

如果设备已经注册并且 power.entry 列表不为空，函数将根据设备的唤醒能力来添加或移除与唤醒相关的属性。如果设备具有唤醒能力，则调用 wakeup_sysfs_add 函数向 sysfs 中添加唤醒相关的属性。如果添加属性失败，会打印一条错误消息。如果设备不具有唤醒能力，则调用 wakeup_sysfs_remove 函数从 sysfs 中移除与唤醒相关的属性。

这段代码的作用是管理设备的唤醒能力标志和相关的属性，通过设置或重置设备的唤醒能力标志，来控制是否在 sysfs 中添加或移除唤醒相关的属性。唤醒能力标志的更新和属性的添加/移除是在设备注册且 power.entry 列表不为空的情况下进行的。函数的注释提醒了该函数可能会休眠，因此不能从不允许休眠的上下文中调用。

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,
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1）wakeup

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

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

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

   1: /*
   2:  * Changes to device_may_wakeup take effect on the next pm state change.
   3:  */
   4:  
   5: static inline bool device_can_wakeup(struct device *dev)
   6: {
   7:         return dev->power.can_wakeup;
   8: }
   9:  
  10: static inline bool device_may_wakeup(struct device *dev)
  11: {
  12:         return dev->power.can_wakeup && !!dev->power.wakeup;
  13: }
1
2
3
4
5
6
7
8
9
10
11
12
13

2）wakeup_count

只读，获取dev->power.wakeup->wakeup_count。

static ssize_t wakeup_count_show(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	unsigned long count;
	bool enabled = false;

	spin_lock_irq(&dev->power.lock);
	if (dev->power.wakeup) {
		count = dev->power.wakeup->wakeup_count;
		enabled = true;
	}
	spin_unlock_irq(&dev->power.lock);

	if (!enabled)
		return sysfs_emit(buf, "\n");
	return sysfs_emit(buf, "%lu\n", count);
}

static DEVICE_ATTR_RO(wakeup_count);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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。

注6：阅读上述代码时，我们可以看到很多类似“!!dev->power.can_wakeup == !!capable”的、带有两个“！”操作符的语句，是为了保证最后的操作对象非0即1。这从侧面反映了内核开发者的严谨程度，值得我们学习。

5.3.2 device_wakeup_enable/device_wakeup_disable/device_set_wakeup_enable

/**
 * device_wakeup_enable - 启用给定设备作为唤醒源。
 * @dev: 要处理的设备。
 *
 * 创建一个唤醒源对象，将其注册并附加到 @dev 上。
 */
int device_wakeup_enable(struct device *dev)
{
	struct wakeup_source *ws;
	int ret;

	// 检查设备和设备的唤醒能力是否有效，如果无效则返回错误
	if (!dev || !dev->power.can_wakeup)
		return -EINVAL;

	// 如果当前系统状态不是 PM_SUSPEND_ON（系统挂起状态），打印警告信息
	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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

该代码段定义了一个名为 device_wakeup_enable 的函数，用于启用给定设备作为唤醒源。

函数首先检查设备和设备的唤醒能力是否有效，如果无效则返回错误。然后，检查当前系统状态是否为 PM_SUSPEND_ON（系统挂起状态），如果不是，则打印一条警告信息。

接下来，函数创建一个唤醒源对象 ws 并将其注册到系统中，使用设备的名称作为唤醒源的名称。

然后，函数将唤醒源对象附加到设备上，使用 device_wakeup_attach 函数完成此操作。如果附加失败，函数将注销唤醒源对象并返回错误。

wakeup_source_register接口的实现也比较简单，会先后调用wakeup_source_create、wakeup_source_prepare、wakeup_source_add等接口，所做的工作包括分配struct wakeup_source变量所需的内存空间、初始化内部变量、将新建的wakeup source添加到名称为wakeup_sources的全局链表中、等等。

device_wakeup_attach接口更为直观，不过有一点我们要关注，如果设备的dev->power.wakeup非空，也就是说之前已经有一个wakeup source了，是不允许再enable了的，会报错返回。

5.3.3 pm_stay_awake

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

/**
 * pm_stay_awake - 通知 PM 核心正在处理唤醒事件。
 * @dev: 相关联唤醒事件的设备。
 *
 * 通过调用 __pm_stay_awake 函数，通知 PM 核心有一个唤醒事件（由 @dev 指示）。
 *
 * 在检测到唤醒事件后，如果接下来会直接调用 pm_relax() 来处理事件（可能将事件传递给用户空间进行进一步处理），
 * 则调用此函数。
 */
void pm_stay_awake(struct device *dev)
{
	unsigned long flags;

	if (!dev)
		return;

	spin_lock_irqsave(&dev->power.lock, flags);
	// 通过调用 __pm_stay_awake 函数来通知 PM 核心有一个唤醒事件
	__pm_stay_awake(dev->power.wakeup);
	spin_unlock_irqrestore(&dev->power.lock, flags);
}
EXPORT_SYMBOL_GPL(pm_stay_awake);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

直接调用__pm_stay_awake，这也是本文的index里没有该接口的原因。接着看代码。

/**
 * __pm_stay_awake - Notify the PM core of a wakeup event.
 * @ws: Wakeup source object associated with the source of the event.
 *
 * This function is used to notify the PM core of a wakeup event. It takes a
 * wakeup source object (@ws) as a parameter, which is associated with the
 * source of the event.
 *
 * It is safe to call this function from interrupt context.
 */
void __pm_stay_awake(struct wakeup_source *ws)
{
	unsigned long flags;

	if (!ws)
		return;

	spin_lock_irqsave(&ws->lock, flags);  // Acquire a spin lock to protect the wakeup source object

	wakeup_source_report_event(ws, false);  // Report the wakeup event to the PM core
	del_timer(&ws->timer);  // Delete the timer associated with the wakeup source
	ws->timer_expires = 0;  // Reset the timer expiration value

	spin_unlock_irqrestore(&ws->lock, flags);  // Release the spin lock
}
EXPORT_SYMBOL_GPL(__pm_stay_awake);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

/**
 * wakeup_source_report_event - Report a wakeup event using the given source.
 * @ws: Wakeup source to report the event for.
 * @hard: If set, abort suspends in progress and wake up from suspend-to-idle.
 *
 * This function is used to report a wakeup event using the provided wakeup source (@ws).
 * The function increments the event count of the wakeup source. If events checking is
 * enabled, it also increments the wakeup count. If the wakeup source is not active,
 * it activates the wakeup source. If the @hard flag is set, it triggers a system wakeup.
 */
static void wakeup_source_report_event(struct wakeup_source *ws, bool hard)
{
	ws->event_count++;  // Increment the event count of the wakeup source

	/* This is racy, but the counter is approximate anyway. */
	if (events_check_enabled)
		ws->wakeup_count++;  // Increment the wakeup count if events checking is enabled

	if (!ws->active)
		wakeup_source_activate(ws);  // Activate the wakeup source if it's not already active

	if (hard)
		pm_system_wakeup();  // Trigger a system wakeup if the @hard flag is set
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

该函数用于报告使用给定的唤醒源（ws）的唤醒事件。它执行以下操作：

增加唤醒源的事件计数。
如果启用了事件检查，增加唤醒计数。
如果唤醒源未激活，则激活唤醒源。
如果设置了hard标志，触发系统唤醒。
该函数通过更新相关计数并触发适当的操作来处理唤醒事件。
1
2
3
4
5
6
7

/**
 * wakeup_source_activate - 将给定的唤醒源标记为活动状态。
 * @ws: 要处理的唤醒源。
 *
 * 更新唤醒源（@ws）的统计信息，并在唤醒源刚刚被激活时通知PM核心该事件，通过增加正在处理的唤醒事件计数器。
 */
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;  // 如果启用了自动休眠，更新阻止休眠的起始时间

	/* 增加正在处理的事件计数器。 */
	cec = atomic_inc_return(&combined_event_count);

	trace_wakeup_source_activate(ws->name, cec);  // 跟踪唤醒源的激活事件
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

函数wakeup_source_activate的作用是将给定的唤醒源(@ws)标记为活动状态。它更新唤醒源的统计信息，增加活动计数，记录最后的活动时间，并且如果启用了自动休眠，记录阻止休眠的起始时间。

此外，它还增加正在处理的唤醒事件计数器。函数通过调用trace_wakeup_source_activate来跟踪唤醒源的激活事件。

注意：由于没有提供wakeup_source_not_registered和trace_wakeup_source_activate函数的具体实现，仅凭此代码片段无法确定它们的具体行为和影响。
1
2
3
4
5

5.3.4 pm_relax

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

   1: /**
   2:  * pm_relax - Notify the PM core that processing of a wakeup event has ended.
   3:  * @dev: Device that signaled the event.
   4:  *
   5:  * Execute __pm_relax() for the @dev's wakeup source object.
   6:  */
   7: void pm_relax(struct device *dev)
   8: {
   9:         unsigned long flags;
  10:  
  11:         if (!dev)
  12:                 return;
  13:  
  14:         spin_lock_irqsave(&dev->power.lock, flags);
  15:         __pm_relax(dev->power.wakeup);
  16:         spin_unlock_irqrestore(&dev->power.lock, flags);
  17: }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

**
 * __pm_relax - Notify the PM core that processing of a wakeup event has ended.
 * @ws: Wakeup source object associated with the source of the event.
 *
 * Call this function for wakeup events whose processing started with calling
 * __pm_stay_awake().
 *
 * It is safe to call it from interrupt context.
 */
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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

/**
 * wakeup_source_deactivate - Mark given wakeup source as inactive.
 * @ws: Wakeup source to handle.
 *
 * Update the @ws' statistics and notify the PM core that the wakeup source has
 * become inactive by decrementing the counter of wakeup events being processed
 * and incrementing the counter of registered wakeup events.
 */
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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

a）relax_count加1（如果relax_count和active_count不等，则说明有重复调用，要退出）。

b）清除active标记。

c）更新total_time、max_time、last_time等变量。

d）如果使能auto sleep，更新相关的变量（后面再详细描述）。

e）再欣赏一下艺术，wakeup events in progress减1，registered wakeup events加1。

f）wakeup count相关的处理，后面再详细说明。
1
2
3
4
5
6
7
8
9
10
11

5.3.5 pm_wakeup_event

pm_wakeup_event是pm_stay_awake和pm_relax的组合版，在上报event时，指定一个timeout时间，timeout后，自动relax，一般用于不知道何时能处理完成的场景。该接口比较简单，就不一一描述了

5.3.6 pm_wakeup_pending

drivers产生的wakeup events，最终要上报到PM core，PM core会根据这些events，决定是否要终止suspend过程。这表现在suspend过程中频繁调用pm_wakeup_pending接口上（可参考“Linux电源管理(6)_Generic PM之Suspend功能”）。该接口的实现如下：

/**
 * pm_wakeup_pending - 检查正在进行的电源转换是否应该中止。
 *
 * 将当前注册的唤醒事件数量与过去保存的数量进行比较，如果自从存储旧值以来注册了新的唤醒事件，或者当前正在处理的唤醒事件数量与零不同，返回true。
 */
bool pm_wakeup_pending(void)
{
	unsigned long flags;
	bool ret = false;
	char suspend_abort[MAX_SUSPEND_ABORT_LEN];

	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();  // 打印当前活动的唤醒源信息
		pm_get_active_wakeup_sources(suspend_abort,
					     MAX_SUSPEND_ABORT_LEN);  // 获取活动的唤醒源信息
		log_suspend_abort_reason(suspend_abort);  // 记录挂起中止的原因
		pr_info("PM: %s\n", suspend_abort);  // 打印挂起中止的原因
	}

	return ret || atomic_read(&pm_abort_suspend) > 0;  // 如果有待处理的唤醒事件或挂起操作被中止，则返回true
}
EXPORT_SYMBOL_GPL(pm_wakeup_pending);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

5.4 wakeup count、wake lock和auto sleep

这篇文章写的有点长了，不能继续了，这几个功能，会接下来的文章中继续分析。

参考连接： http://www.wowotech.net/pm_subsystem/wakeup_events_framework.html