power-states {
	idle: idle {
		compatible = "zephyr,power-state";
		power-state-name = "runtime-idle";
	};

	stop: stop {
		compatible = "zephyr,power-state";
		power-state-name = "suspend-to-idle"; // pm状态，见yaml
		substate-id = <0>; // 如果有两个相同的power-state-name，需要用substate-id来区分
		min-residency-us = <1000>; // 最少在该状态停留的时间
		exit-latency-us = <2>; // 离开该状态最worse的时间
	};

	pstop1: pstop1 {
		compatible = "zephyr,power-state";
		power-state-name = "suspend-to-idle";
		substate-id = <1>;
		min-residency-us = <1000>;
		exit-latency-us = <2>;
	};
};

static struct pm_notifier notifier = {
	.state_entry = notify_pm_state_entry,
	.state_exit = notify_pm_state_exit,
};

void pm_notifier_register(struct pm_notifier *notifier)

enum pm_state {
	PM_STATE_ACTIVE,
	// cpu cores都进入idle状态，不改变devices状态。
	PM_STATE_RUNTIME_IDLE,
	// cpu cores都进入idle状态，可以让外设进入低功耗状态。
	PM_STATE_SUSPEND_TO_IDLE,
	// 单核和suspend to idle一样，多核会把non-boot cpus都关掉。
	PM_STATE_STANDBY,
	// 内存进入自刷新模式，devices和cpus状态都保存到memory，resume从rom code起来。
	PM_STATE_SUSPEND_TO_RAM,
	// 内存也关掉，内容都保存到flash/disk，启动再读出来。
	PM_STATE_SUSPEND_TO_DISK,
	// 全部关掉，cpu和memory内容也不保存。
	PM_STATE_SOFT_OFF,
	PM_STATE_COUNT,
};

bool pm_system_suspend(int32_t ticks)
{
	uint8_t id = _current_cpu->id;
	k_spinlock_key_t key;

	key = k_spin_lock(&pm_forced_state_lock);
	if (z_cpus_pm_forced_state[id].state != PM_STATE_ACTIVE) {
		z_cpus_pm_state[id] = z_cpus_pm_forced_state[id];
		z_cpus_pm_forced_state[id].state = PM_STATE_ACTIVE;
	} else {
		const struct pm_state_info *info;

		info = pm_policy_next_state(id, ticks);
		if (info != NULL) {
			z_cpus_pm_state[id] = *info;
		}
	}
	k_spin_unlock(&pm_forced_state_lock, key);

	if (z_cpus_pm_state[id].state == PM_STATE_ACTIVE) {
		LOG_DBG("No PM operations done.");
		SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend, ticks,
				   z_cpus_pm_state[id].state);
		return false;
	}
// 如果打开了PM_DEVICE，并且不是只由runtime pm管理，会把所有devices都suspend
#if defined(CONFIG_PM_DEVICE) && !defined(CONFIG_PM_DEVICE_RUNTIME_EXCLUSIVE)
	if (atomic_sub(&_cpus_active, 1) == 1) {
		if (z_cpus_pm_state[id].state != PM_STATE_RUNTIME_IDLE) {
			pm_suspend_devices();
		}
	}
#endif

	if (ticks != K_TICKS_FOREVER) {
		/*
		 * We need to set the timer to interrupt a little bit early to
		 * accommodate the time required by the CPU to fully wake up.
		 */
		sys_clock_set_timeout(ticks -
		     k_us_to_ticks_ceil32(
			     z_cpus_pm_state[id].exit_latency_us),
				     true);
	}

	k_sched_lock();
	pm_stats_start();
	/* Enter power state */
	// 调用app注册的回调函数。
	pm_state_notify(true);
	atomic_set_bit(z_post_ops_required, id);
	// 这个函数是SoC自定义的进入不同状态的操作函数。
	// 一般会进入suspend/sleep状态，进入WFI等待前面设置的timeout中断。
	pm_state_set(z_cpus_pm_state[id].state, z_cpus_pm_state[id].substate_id);
	pm_stats_stop();

	/* Wake up sequence starts here */
#if defined(CONFIG_PM_DEVICE) && !defined(CONFIG_PM_DEVICE_RUNTIME_EXCLUSIVE)
	if (atomic_add(&_cpus_active, 1) == 0) {
		pm_resume_devices();
	}
#endif
	pm_stats_update(z_cpus_pm_state[id].state);
	pm_system_resume();
	k_sched_unlock();
	SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend, ticks,
				   z_cpus_pm_state[id].state);

	return true;
}

static int dummy_driver_pm_action(const struct device *dev,
                                  enum pm_device_action action)
{
    switch (action) {
    case PM_DEVICE_ACTION_SUSPEND:
        /* suspend the device */
        break;
    case PM_DEVICE_ACTION_RESUME:
        /* resume the device */
        break;
    case PM_DEVICE_ACTION_TURN_ON:
        /*
         * powered on the device, used when the power
         * domain this device belongs is resumed.
         */
        ...
        break;
    case PM_DEVICE_ACTION_TURN_OFF:
        /*
         * power off the device, used when the power
         * domain this device belongs is suspended.
         */
        break;
    default:
        return -ENOTSUP;
    }

    return 0;
}

// 定义inst0对应的pm_device结构体
PM_DEVICE_DT_INST_DEFINE(0, dummy_driver_pm_action);

// 第三个参数把pm_device挂入device结构体
DEVICE_DT_INST_DEFINE(0, &dummy_init,
    PM_DEVICE_DT_INST_GET(0), NULL, NULL, POST_KERNEL,
    CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, NULL);

enum pm_device_state {
	PM_DEVICE_STATE_ACTIVE,
	PM_DEVICE_STATE_SUSPENDED,
	/** Device is being suspended. */
	PM_DEVICE_STATE_SUSPENDING,
	/** Device is turned off (power removed).*/
	PM_DEVICE_STATE_OFF
};

static struct pm_device __pm_device_dev_id =
{
	.base.action_cb = action_cb,
	.base.state = PM_DEVICE_STATE_ACTIVE, // 初始状态为active
	.base.flag =  PM_DEVICE_FLAG_WS_CAPABLE | PM_DEVICE_FLAG_RUNTIME_AUTO | PM_DEVICE_FLAG_PD // 从设备树中获取wakeup_source, zephyr_pm_device_runtime_auto, power_domain属性，有则把对应flag置起，没有不置起。
	.base.domain =
	.lock = Z_SEM_INITIALIZER(obj.lock, 1, 1),
	.event = Z_EVENT_INITIALIZER(obj.event),
}

// driver init function
static int mydev_init(const struct device *dev)
{
    /* OPTIONAL: mark device as suspended if it is physically suspended */
    pm_device_init_suspended(dev);

    /* enable device runtime power management */
    pm_device_runtime_enable(dev);
}

static inline void pm_device_init_suspended(const struct device *dev)
{
	struct pm_device_base *pm = dev->pm_base;

	pm->state = PM_DEVICE_STATE_SUSPENDED;
}

int pm_device_runtime_enable(const struct device *dev)
{
	int ret = 0;
	struct pm_device *pm = dev->pm;

	// 默认这个flag是不会置起来的，在这个函数末尾置起
	if (atomic_test_bit(&pm->base.flags, PM_DEVICE_FLAG_RUNTIME_ENABLED)) {
		goto end;
	}

	/* lazy init of PM fields */
	// pm_device初始化的时候并没有设置pm->dev，所以这里应该会跑进去，初始化system workqueue delayable work
	if (pm->dev == NULL) {
		pm->dev = dev;
		k_work_init_delayable(&pm->work, runtime_suspend_work);
	}
	// 默认状态是PM_DEVICE_STATE_ACTIVE，所以上来会调用一次driver回调函数进suspend。
	if (pm->base.state == PM_DEVICE_STATE_ACTIVE) {
		ret = pm->base.action_cb(pm->dev, PM_DEVICE_ACTION_SUSPEND);
		if (ret < 0) {
			goto unlock;
		}
		// 设置状态为suspend.
		pm->base.state = PM_DEVICE_STATE_SUSPENDED;
	}
	//初始化为没有人在使用该device
	pm->base.usage = 0U;
	//至此初始化完成，把runtime_enable置起
	atomic_set_bit(&pm->base.flags, PM_DEVICE_FLAG_RUNTIME_ENABLED);

end:
	return ret;
}