#星光计划2.0# OpenHarmony 源码解析之电源管理亮灭屏功能 原创 精华

//ubuntu系统：
#cat /sys/power/state 
freeze standby mem disk
//rk3566和自研板
# cat /sys/power/state
freeze mem
1.
2.
3.
4.
5.
6.

#echo mem > /sys/power/state
1.

static napi_value PowerInit(napi_env env, napi_value exports)
{
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter", __func__);
    napi_property_descriptor desc[] = {
        DECLARE_NAPI_FUNCTION("shutdownDevice", ShutdownDevice),
        DECLARE_NAPI_FUNCTION("rebootDevice", RebootDevice),
        DECLARE_NAPI_FUNCTION("isScreenOn", IsScreenOn),
        DECLARE_NAPI_FUNCTION("wakeupDevice", WakeupDevice),   //新增的唤醒接口
        DECLARE_NAPI_FUNCTION("suspendDevice", SuspendDevice), //新增的休眠接口
    };
    NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: exit", __func__);

    return exports;
}
//唤醒接口实现，应用在调用此接口前先调用power模块已提供的IsScreenOn接口
static napi_value WakeupDevice(napi_env env, napi_callback_info info)
{
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter, %{public}s", __func__, "wake up device");
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_value jsthis;
    void *data = nullptr;

    napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data);
    NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "failed to get cb info");
    napi_valuetype type = napi_undefined;
    NAPI_CALL(env, napi_typeof(env, args[0], &type));
    NAPI_ASSERT(env, type == napi_string, "wrong argument type. string expected.");

    char reason[REASON_MAX] = { 0 };
    size_t reasonLen = 0;
    status = napi_get_value_string_utf8(env, args[0], reason, REASON_MAX - 1, &reasonLen);
    if (status != napi_ok) {
        POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: get reason failed", __func__);
        return nullptr;
    }
    g_powerMgrClient.WakeupDevice(WakeupDeviceType::WAKEUP_DEVICE_APPLICATION,std::string(reason));
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: reason %{public}s, exit", __func__, reason);
    return nullptr;
}
//休眠接口，应用在调用此接口前先调用power模块已提供的IsScreenOn接口
static napi_value SuspendDevice(napi_env env, napi_callback_info info)
{
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: enter, %{public}s", __func__, "suspend device");
    size_t argc = 1;
    napi_value args[1] = { 0 };
    napi_value jsthis;
    void *data = nullptr;

    napi_status status = napi_get_cb_info(env, info, &argc, args, &jsthis, &data);
    NAPI_ASSERT(env, (status == napi_ok) && (argc >= 1), "failed to get cb info");
    napi_valuetype type = napi_undefined;
    NAPI_CALL(env, napi_typeof(env, args[0], &type));
    NAPI_ASSERT(env, type == napi_string, "wrong argument type. string expected.");

    char reason[REASON_MAX] = { 0 };
    size_t reasonLen = 0;
    status = napi_get_value_string_utf8(env, args[0], reason, REASON_MAX - 1, &reasonLen);
    if (status != napi_ok) {
        POWER_HILOGE(MODULE_JS_NAPI, "%{public}s: get reason failed", __func__);
        return nullptr;
    }
    g_powerMgrClient.SuspendDevice(SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION,true);
    POWER_HILOGD(MODULE_JS_NAPI, "%{public}s: reason %{public}s, exit", __func__, reason);
    return nullptr;
}
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.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.

base\powermgr\power_manager\services\native\src\actions\default\device_state_action.cpp：
//系统挂起时先灭屏再休眠
void DeviceStateAction::Suspend(int64_t callTimeMs, SuspendDeviceType type, uint32_t flags)
{
    DisplayManager::SetScreenState(ScreenState::SCREEN_STATE_OFF);//调用displaymgr的屏幕关闭
    SystemSuspendController::GetInstance().EnableSuspend();//系统休眠
}
//唤醒系统时先唤醒再亮屏
void DeviceStateAction::Wakeup(int64_t callTimeMs, WakeupDeviceType type, const string& details,
    const string& pkgName)
{
    SystemSuspendController::GetInstance().DisableSuspend();//系统唤醒
    DisplayManager::SetScreenState(ScreenState::SCREEN_STATE_ON);//调用displaymgr的屏幕打开
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

//base\powermgr\power_manager\services\native\src\actions\default\system_suspend_controller.cpp
//目前系统目录没有下面这两个文件影响休眠和唤醒功能：
1）/sys/power/wake_lock  //该wakelock可以阻止系统进入低功耗模式。
2）/sys/power/wake_unlock //写入相同的字符串，即可注销一个wakelock
//挂起，系统进入低功耗模式
void SystemSuspendController::EnableSuspend()
{
    std::lock_guard lock(mutex_);
    sc_->EnableSuspend();//睡眠的具体操作。
    if (!suspendEnabled_) {
        rlh_->Release(WAKEUP_HOLDER);  //wake_unlock写入"OHOSPowerMgr.WakeupHolder";允许睡眠
        suspendEnabled_ = true;
    }
}
//唤醒，即阻止系统进入低功耗模式。
void SystemSuspendController::DisableSuspend()
{
    std::lock_guard lock(mutex_);
    if (suspendEnabled_) {
        rlh_->Acquire(WAKEUP_HOLDER);  //wake_lock写入"OHOSPowerMgr.WakeupHolder";阻止睡眠
        suspendEnabled_ = false;
    }
}
//base\powermgr\power_manager\services\native\src\actions\default\suspend\suspend_controller.cpp：
static constexpr const char * const SUSPEND_STATE = "mem";
static constexpr const char * const SUSPEND_STATE_PATH = "/sys/power/state";
static constexpr const char * const WAKEUP_COUNT_PATH = "/sys/power/wakeup_count";
void SuspendController::EnableSuspend()
{
    suspend_->Start();//启动AutoSuspendLoop线程
    POWER_HILOGI(MODULE_SERVICE, "AutoSuspend enabled");
}
void SuspendController::AutoSuspend::AutoSuspendLoop()
{
    while (true) {
        std::this_thread::sleep_for(waitTime_);
        const std::string wakeupCount = WaitWakeupCount();  //在rk3566和自研板上阻塞在读取/sys/power/wakeup_count文件，应该是系统不支持
        if (wakeupCount.empty()) {
            continue;
        }
        waitingFunc_();//阻塞函数，只有等到休眠条件才会继续执行。
        if (!WriteWakeupCount(wakeupCount)) {//写入wakeupcount
            continue;
        }
        bool success = SuspendEnter();//写入mem
        if (!success) {
            POWER_HILOGE(MODULE_SERVICE, "Start suspend failed!");
        }
    }
}
//读取wakeupcount
std::string SuspendController::AutoSuspend::WaitWakeupCount()
{
    if (wakeupCountFd < 0) {
        wakeupCountFd = UniqueFd(TEMP_FAILURE_RETRY(open(WAKEUP_COUNT_PATH, O_RDWR | O_CLOEXEC)));
    }
    std::string wakeupCount;
    bool ret = LoadStringFromFd(wakeupCountFd, wakeupCount);
    if (!ret) {
        POWER_HILOGW(MODULE_SERVICE, "Read wakeup count failed!");
        return std::string();
    }
    return wakeupCount;
}
//写入wakeupcount
bool SuspendController::AutoSuspend::WriteWakeupCount(std::string wakeupCount)
{
    if (wakeupCountFd < 0) {
        return false;
    }
    bool ret = SaveStringToFd(wakeupCountFd, wakeupCount.c_str());
    if (!ret) {
        POWER_HILOGE(MODULE_SERVICE, "Failed to write the wakeup count!");
    }
    return ret;
}
//通过向/sys/power/state写入mem实现挂起功能。
bool SuspendController::AutoSuspend::SuspendEnter()
{
    static bool inited = false;
    static UniqueFd suspendStateFd(TEMP_FAILURE_RETRY(open(SUSPEND_STATE_PATH, O_RDWR | O_CLOEXEC)));
    if (!inited) {
        if (suspendStateFd < 0) {
            POWER_HILOGE(MODULE_SERVICE, "Failed to open the suspending state fd!");
            return false;
        }
        inited = true;
    }
    bool ret = SaveStringToFd(suspendStateFd, SUSPEND_STATE);
    if (!ret) {
        POWER_HILOGE(MODULE_SERVICE, "Failed to write the suspending state!");
    }
    return ret;
}
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.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.

//base\powermgr\display_manager\service\native\src\screen_action.cpp：
bool ScreenAction::SetPowerState(ScreenState state __attribute__((__unused__)))
{
    int32_t dispErr_ = DISPLAY_SUCCESS;
    if (!hdiFuncs_) {
        DISPLAY_HILOGE(MODULE_SERVICE, "Invalid device functions");
        return false;
    }
    if (ScreenState::SCREEN_STATE_ON == state)
    {
        dispErr_ = hdiFuncs_->SetDisplayPowerStatus(0,DispPowerStatus::POWER_STATUS_ON);
    }
    else
    {
        dispErr_ = hdiFuncs_->SetDisplayPowerStatus(0,DispPowerStatus::POWER_STATUS_OFF);
    }    
    DISPLAY_HILOGE(MODULE_SERVICE, "SetDisplayPowerStatus:%{public}u result:%{public}d",ToUnderlying(state),dispErr_);
    return dispErr_ == DISPLAY_SUCCESS;
}
//drivers\peripheral\display\interfaces\include\display_device.h：
SetDisplayPowerStatus：接口说明：
    /**
     * @brief Sets the power status.
     *
     * When the OS enters the sleep mode or wakes up from the sleep mode, the display service or
     * the power management module can set the power status of the display device, so that the driver IC
     * of the device can normally enter the specified state.
     *
     * @param devId Indicates the ID of a display device. The value ranges from 0 to 4, where 0 indicates
     * the first display device and 4 indicates the last display device.
     * @param status Indicates the power status to set. The display service determines whether to set the
     * display device to the on or off state based on this setting. For details, see @link PowerStatus}.
     *
     * @return Returns 0 if the operation is successful; returns an error code defined in {@link DispErrCode} otherwise.
     * @since 1.0
     * @version 1.0
     */
    int32_t (*SetDisplayPowerStatus)(uint32_t devId, DispPowerStatus status);
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.

//drivers\peripheral\display\hal\disp_hal.c：
static int32_t DispCmdSend(const uint32_t cmd, struct HdfSBuf *reqData, struct HdfSBuf *respData)
{
    struct HdfIoService *dispService = NULL;
    HDF_LOGE("%s:add by wangkui", __func__);
    dispService = HdfIoServiceBind(DISP_SERVICE_NAME);//此处是找hdf_disp驱动服务。
    if ((dispService == NULL) || (dispService->dispatcher == NULL) || (dispService->dispatcher->Dispatch == NULL)) {
        HDF_LOGE("%s:bad remote service found modified by wangkui", __func__);
        goto EXIT;
    }
    int32_t ret = dispService->dispatcher->Dispatch(&dispService->object, cmd, reqData, respData);
    if (ret != DISPLAY_SUCCESS) {
        HDF_LOGE("%s: cmd=%u, ret=%d", __func__, cmd, ret);
        goto EXIT;
    }
    HDF_LOGI("%s: cmd=%u, ret=%d", __func__, cmd, ret);
    HdfIoServiceRecycle(dispService);
    return DISPLAY_SUCCESS;

EXIT:
    HdfIoServiceRecycle(dispService);
    return DISPLAY_FAILURE;
}
//drivers\framework\core\shared\src\hdf_io_service.c：
struct HdfIoService *HdfIoServiceBind(const char *serviceName)
{
    return HdfIoServiceAdapterObtain(serviceName);
}
//drivers\framework\core\adapter\syscall\src\hdf_syscall_adapter.c：
struct HdfIoService *HdfIoServiceAdapterObtain(const char *serviceName)
{
    struct HdfSyscallAdapter *adapter = NULL;
    struct HdfIoService *ioService = NULL;
    char *devNodePath = NULL;
    char *realPath = NULL;

    const char *devPath = DEV_NODE_PATH;
    if (access(DEV_NODE_PATH, F_OK) != 0) {
        devPath = DEV_PATH;
    }

    devNodePath = OsalMemCalloc(PATH_MAX);
    realPath = OsalMemCalloc(PATH_MAX);
    if (devNodePath == NULL || realPath == NULL) {
        HDF_LOGE("%s: out of memory", __func__);
        goto out;
    }

    if (sprintf_s(devNodePath, PATH_MAX - 1, "%s%s", devPath, serviceName) < 0) {
        HDF_LOGE("Failed to get the node path");
        goto out;
    }

    if (realpath(devNodePath, realPath) == NULL) {//此处发现找不到hdf_disp文件
        HDF_LOGE("%s: file name %{public}s is invalid", __func__, devNodePath);
        if (HdfLoadDriverByServiceName(serviceName) != HDF_SUCCESS) {//通过hdf_disp服务名查找
            HDF_LOGE("%s: load %{public}s driver failed,", __func__, serviceName);
            goto out;
        }
        if (realpath(devNodePath, realPath) == NULL) {
            HDF_LOGE("%s: file name %{public}s is invalid", __func__, devNodePath);
            goto out;
        }
    }

    adapter = (struct HdfSyscallAdapter *)OsalMemCalloc(sizeof(struct HdfSyscallAdapter));
    if (adapter == NULL) {
        HDF_LOGE("Failed to allocate SyscallAdapter");
        goto out;
    }

    DListHeadInit(&adapter->listenerList);
    if (OsalMutexInit(&adapter->mutex)) {
        HDF_LOGE("%s: Failed to create mutex", __func__);
        OsalMemFree(adapter);
        goto out;
    }

    adapter->fd = open(realPath, O_RDWR);
    if (adapter->fd < 0) {
        HDF_LOGE("Open file node %{public}s failed, (%d)%{public}s", realPath, errno, strerror(errno));
        OsalMutexDestroy(&adapter->mutex);
        OsalMemFree(adapter);
        goto out;
    }
    ioService = &adapter->super;
    static struct HdfIoDispatcher dispatch = {
        .Dispatch = HdfSyscallAdapterDispatch,
    };
    ioService->dispatcher = &dispatch;
out:
    OsalMemFree(devNodePath);
    OsalMemFree(realPath);
    return ioService;
}
int32_t HdfLoadDriverByServiceName(const char *serviceName)
{
    int32_t ret = HDF_FAILURE;
    struct HdfSBuf *data = NULL;
    if (serviceName == NULL || strcmp(serviceName, DEV_MGR_NODE) == 0) {
        HDF_LOGE("failed to get %s service,call self!!!", serviceName);//如果是dev_mgr则返回，防止死循环。
        return ret;
    }
    struct HdfIoService *ioService = HdfIoServiceBind(DEV_MGR_NODE);//这里找dev_mgr，根据日志看也没找到，所以没发现hdf_disp服务。
    if (ioService == NULL) {
        HDF_LOGE("failed to get %s service", DEV_MGR_NODE);
        return ret;
    }
    data = HdfSBufObtainDefaultSize();
    if (data == NULL) {
        HDF_LOGE("failed to obtain sbuf data");
        ret = HDF_DEV_ERR_NO_MEMORY;
        goto out;
    }
    if (!HdfSbufWriteString(data, serviceName)) {
        HDF_LOGE("failed to write sbuf");
        ret = HDF_FAILURE;
        goto out;
    }
    ret = ioService->dispatcher->Dispatch(&ioService->object, DEVMGR_LOAD_SERVICE, data, NULL);
    if (ret != HDF_SUCCESS) {
        HDF_LOGE("failed to load khdf driver %s", serviceName);
    }
out:
    HdfIoServiceRecycle(ioService);
    HdfSBufRecycle(data);
    return ret;
}
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.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.

#define power_attr(_name) \
static struct kobj_attribute _name##_attr = {	\
	.attr	= {				\
		.name = __stringify(_name),	\
		.mode = 0644,			\
	},					\
	.show	= _name##_show,			\
	.store	= _name##_store,		\
}

power_attr(wake_lock);
power_attr(wake_unlock);
//根据宏定义开关注册sleep、autosleep、suspend、wakelock等。
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,
#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,
};
static const struct attribute_group attr_group = {
	.attrs = g,
};
static const struct attribute_group *attr_groups[] = {
	&attr_group,
#ifdef CONFIG_PM_SLEEP
	&suspend_attr_group,
#endif
	NULL,
};
static int __init pm_init(void)
{
	int error = pm_start_workqueue();
	if (error)
		return error;
	hibernate_image_size_init();
	hibernate_reserved_size_init();
	pm_states_init();
	power_kobj = kobject_create_and_add("power", NULL);//先创建power目录
	if (!power_kobj)
		return -ENOMEM;
	error = sysfs_create_groups(power_kobj, attr_groups);//创建power目录下的其它设备节点。
	if (error)
		return error;
	pm_print_times_init();
	return pm_autosleep_init();
}

core_initcall(pm_init);
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.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.

static ssize_t wake_lock_store(struct kobject *kobj,
			       struct kobj_attribute *attr,
			       const char *buf, size_t n)
{
	int error = pm_wake_lock(buf);
	return error ? error : n;
}
1.
2.
3.
4.
5.
6.
7.

//用于上报一个wakeup event，输入参数为一个字符串，如："wakelocktest 1000"
int pm_wake_lock(const char *buf)
{
	const char *str = buf;
	struct wakelock *wl;
	u64 timeout_ns = 0;
	size_t len;
	int ret = 0;

    //检查调用的进程是否有执行阻止系统休眠的权限，PowerMgr打包在foundation进程，所以需要修改foundation进程的权限，增加BLOCK_SUSPEND
    //./foundation/appexecfwk/standard/sa_profile/foundation.rc:    capabilities SYS_PTRACE KILL SYS_BOOT
	//./foundation/appexecfwk/standard/sa_profile/foundation.cfg:            "caps" : ["SYS_PTRACE", "KILL", "SYS_BOOT"]
	if (!capable(CAP_BLOCK_SUSPEND))
		return -EPERM;
	//解析字符串，取出wakelock的名字和超时时间，超时时间可以不带。
	while (*str && !isspace(*str))
		str++;

	len = str - buf;
	if (!len)
		return -EINVAL;

	if (*str && *str != '\n') {
		/* Find out if there's a valid timeout string appended. */
		ret = kstrtou64(skip_spaces(str), 10, &timeout_ns);
		if (ret)
			return -EINVAL;
	}

	mutex_lock(&wakelocks_lock);
	//向wakelock维护的红黑树tree中添加新的wakelock，且注册wakeup source，name就是入参的buf。
	wl = wakelock_lookup_add(buf, len, true);
	if (IS_ERR(wl)) {
		ret = PTR_ERR(wl);
		goto out;
	}
    //1）__pm_stay_awake，通知PM core，注册的wakeup source产生了wakeup event，且正在处理，因此不允许系统suspend；
	//2）__pm_relax，通知PM core，注册的wakeup source没有正在处理的wakeup event，允许系统suspend；
	//3）__pm_wakeup_event，为上边两个接口的功能组合，通知PM core，注册的wakeup source产生了wakeup event，会在timeout_ms毫秒内处理结束，由PM core自动调用__pm_relax。
	if (timeout_ns) {
		u64 timeout_ms = timeout_ns + NSEC_PER_MSEC - 1;

		do_div(timeout_ms, NSEC_PER_MSEC);
		__pm_wakeup_event(wl->ws, timeout_ms);
	} else {
		__pm_stay_awake(wl->ws);
	}

	wakelocks_lru_most_recent(wl);//wakelocks有GC机制，通过LRU策略进行淘汰长时间不活动的wakelock

 out:
	mutex_unlock(&wakelocks_lock);
	return ret;
}
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.

static ssize_t wake_unlock_store(struct kobject *kobj,
				 struct kobj_attribute *attr,
				 const char *buf, size_t n)
{
	int error = pm_wake_unlock(buf);
	return error ? error : n;
}
1.
2.
3.
4.
5.
6.
7.

//入参为字符串，跟创建wakelock一样的名字。
int pm_wake_unlock(const char *buf)
{
	struct wakelock *wl;
	size_t len;
	int ret = 0;

	if (!capable(CAP_BLOCK_SUSPEND))//检查权限
		return -EPERM;
	//解析字符串，获取wakelock名字
	len = strlen(buf);
	if (!len)
		return -EINVAL;

	if (buf[len-1] == '\n')
		len--;

	if (!len)
		return -EINVAL;

	mutex_lock(&wakelocks_lock);
	//查找是否有相同name的wakelock。如果有，直接返回wakelock的指针；如果没有，退出。
	wl = wakelock_lookup_add(buf, len, false);
	if (IS_ERR(wl)) {
		ret = PTR_ERR(wl);
		goto out;
	}
	__pm_relax(wl->ws);//通知PM core，注册的wakeup source没有正在处理的wakeup event，允许系统suspend；

    //wakelocks有GC机制，通过LRU策略进行淘汰长时间不活动的wakelock
	wakelocks_lru_most_recent(wl);
	wakelocks_gc();//执行GC回收。

 out:
	mutex_unlock(&wakelocks_lock);
	return ret;
}
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.

/**
*pm_get_wakeup_count-读取已注册的wakeup事件数。
*@count:用于存储值的地址。
*@block：是否阻塞。
*将注册的wakeup事件数存储在@count中。如果@block为true，阻止直到当前的wakeup事件数已处理的值为零。
*如果当前正在处理的wakeup事件数为非零范围“false”。否则返回“true”。
*/
bool pm_get_wakeup_count(unsigned int *count, bool block)
{
	unsigned int cnt, inpr;
    pr_debug("pm_get_wakeup_count block: %d\n", block);
	if (block) {
		DEFINE_WAIT(wait);

		for (;;) {
			prepare_to_wait(&wakeup_count_wait_queue, &wait,
					TASK_INTERRUPTIBLE);
			split_counters(&cnt, &inpr);
			if (inpr == 0 || signal_pending(current))
				break;
			pm_print_active_wakeup_sources();//debug日志打印出active的事件，以此判断阻塞在何处。
			schedule();
		}
		finish_wait(&wakeup_count_wait_queue, &wait);
	}

	split_counters(&cnt, &inpr);
	*count = cnt;
	return !inpr;
}
static atomic_t combined_event_count = ATOMIC_INIT(0);
#define IN_PROGRESS_BITS	(sizeof(int) * 4)    //16
#define MAX_IN_PROGRESS		((1 << IN_PROGRESS_BITS) - 1)    //0xFFFF
static void split_counters(unsigned int *cnt, unsigned int *inpr)
{
	unsigned int comb = atomic_read(&combined_event_count);
	//高16位存储已处理完的wakeup个数，低16位存储正在处理（即Active）的wakeup个数
    //秒！正在处理的wakeup event和已处理的wakeup event在一个变量中维护。
	*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.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.

/**
*pm_save_wakeup_count-保存当前已注册的wakeup事件数。
*@count：与当前已注册wakeup事件数进行比较的值。
*如果@count等于当前注册的wakeup事件数，且当前正在处理的wakeup事件数为零，并将当前的wakeup count保存在saved count变量中，启用wakeup事件检测。
*否则禁用wakeup事件检测并返回“false”。
*/
bool pm_save_wakeup_count(unsigned int count)
{
	unsigned int cnt, inpr;
	unsigned long flags;

	events_check_enabled = false;
	raw_spin_lock_irqsave(&events_lock, flags);
	split_counters(&cnt, &inpr);
	if (cnt == count && inpr == 0) {
		saved_count = count;
		events_check_enabled = true;
	}
	raw_spin_unlock_irqrestore(&events_lock, flags);
	return events_check_enabled;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

//切换休眠状态
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
{
	suspend_state_t state;
	int error;

	error = pm_autosleep_lock();
	if (error)
		return error;

	if (pm_autosleep_state() > PM_SUSPEND_ON) {
		error = -EBUSY;
		goto out;
	}

	state = decode_state(buf, n);//将“mem”转为对应的数字
	if (state < PM_SUSPEND_MAX) {
		if (state == PM_SUSPEND_MEM)
			state = mem_sleep_current;

		error = pm_suspend(state);//核心的kernel休眠流程
	} else if (state == PM_SUSPEND_MAX) {
		error = hibernate();
	} else {
		error = -EINVAL;
	}

 out:
	pm_autosleep_unlock();
	return error ? error : n;
}
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.

//kernel\linux-4.19\kernel\power\suspend.c
int pm_suspend(suspend_state_t state)
{
	error = enter_state(state);
}
static int enter_state(suspend_state_t state)
{
	trace_suspend_resume(TPS("suspend_enter"), state, true);
	if (state == PM_SUSPEND_TO_IDLE) {
	} else if (!valid_state(state)) {//检查平台是否支持电源管理，即全局suspend_ops有没有被赋值，并调用其suspend_ops->valid()
		return -EINVAL;
	}
	error = suspend_prepare(state);//准备挂起
	error = suspend_devices_and_enter(state);//让设备进入suspend状态
	suspend_finish(); 
}
//kernel\linux-4.19\kernel\power\suspend.c
static int suspend_prepare(suspend_state_t state)
{
    //kernel\linux-4.19\kernel\power\console.c
	//切换挂起、恢复执行内核触发的VT开关，切换到SUSPEND_CONSOLE
	pm_prepare_console();
    //kernel/power/main.c
    //通知驱动程序准备suspend
	error = __pm_notifier_call_chain(PM_SUSPEND_PREPARE, -1, &nr_calls);
    //kernel\linux-4.19\kernel\power\power.h
    //冻结App和内核线程
	error = suspend_freeze_processes();
}
//kernel\linux-4.19\kernel\power\suspend.c
////挂起设备并进入系统睡眠状态
int suspend_devices_and_enter(suspend_state_t state)
{
    //如果平台相关的代码有begin函数就去调用它,suspend_ops->begin(state)
	error = platform_suspend_begin(state);
	//kernel\linux-4.19\kernel\printk\printk.c
    //挂起console子系统，此时不能用printk()调试。
	suspend_console();
	suspend_test_start();
	error = dpm_suspend_start(PMSG_SUSPEND);	
	suspend_test_finish("suspend devices");
	
	do {
        //关闭核心模块，如cpu等，并设置唤醒源，如果电源键按下则会进入唤醒流程。
		error = suspend_enter(state, &wakeup);
	} while (!error && !wakeup && platform_suspend_again(state));

 Resume_devices:
	suspend_test_start();
	dpm_resume_end(PMSG_RESUME);
	suspend_test_finish("resume devices");
	resume_console();
}
//kernel\linux-4.19\kernel\power\suspend.c
static void suspend_finish(void)
{
    //唤醒应用程序
	suspend_thaw_processes();
    //通知关注这个事件的App程序，对全局pm_chain_head->head中的每一个都调用其notifier_call()
	pm_notifier_call_chain(PM_POST_SUSPEND);
    //返回用户空间
	pm_restore_console();
}
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.
56.
57.
58.
59.
60.
61.
62.
63.