设备系统电源管理原理

其实之前我们在介绍系统电源管理的时候已经看到看设备电源管理相关的函数，代码路径zephyr/subsys/pm/power.c:

  1. enum pm_state pm_system_suspend(int32_t ticks)
  2. {
  3.     SYS_PORT_TRACING_FUNC_ENTER(pm, system_suspend, ticks);
  4.     z_power_state = pm_policy_next_state(ticks);
  5.     if (z_power_state.state == PM_STATE_ACTIVE) {
  6.         LOG_DBG("No PM operations done.");
  7.         SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend, ticks, z_power_state.state);
  8.         return z_power_state.state;
  9.     }
  10.     post_ops_done = 0;
  12.     if (ticks != K_TICKS_FOREVER) {
  13.         /*
  14.          * Just a sanity check in case the policy manager does not
  15.          * handle this error condition properly.
  16.          */
  17.         __ASSERT(z_power_state.min_residency_us >=
  18.             z_power_state.exit_latency_us,
  19.             "min_residency_us < exit_latency_us");
  21.         /*
  22.          * We need to set the timer to interrupt a little bit early to
  23.          * accommodate the time required by the CPU to fully wake up.
  24.          */
  25.         z_set_timeout_expiry(ticks -
  26.              k_us_to_ticks_ceil32(z_power_state.exit_latency_us), true);
  27.     }
  28. // 设备电源管理
  29. #if CONFIG_PM_DEVICE
  31.     bool should_resume_devices = true;
  33.     switch (z_power_state.state) {
  34.     case PM_STATE_RUNTIME_IDLE:
  35.         __fallthrough;
  36.     case PM_STATE_SUSPEND_TO_IDLE:
  37.         __fallthrough;
  38.     case PM_STATE_STANDBY:
  39.         /* low power peripherals. */
  40.         if (pm_low_power_devices()) {
  41.             SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend,
  42.                     ticks, _handle_device_abort(z_power_state));
  43.             return _handle_device_abort(z_power_state);
  44.         }
  45.         break;
  46.     case PM_STATE_SUSPEND_TO_RAM:
  47.         __fallthrough;
  48.     case PM_STATE_SUSPEND_TO_DISK:
  49.         __fallthrough;
  50.     case PM_STATE_SOFT_OFF:
  51.         if (pm_suspend_devices()) {
  52.             SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend,
  53.                     ticks, _handle_device_abort(z_power_state));
  54.             return _handle_device_abort(z_power_state);
  55.         }
  56.         break;
  57.     default:
  58.         should_resume_devices = false;
  59.         break;
  60.     }
  61. #endif
  62.     /*
  63.      * This function runs with interruptions locked but it is
  64.      * expected the SoC to unlock them in
  65.      * pm_power_state_exit_post_ops() when returning to active
  66.      * state. We don't want to be scheduled out yet, first we need
  67.      * to send a notification about leaving the idle state. So,
  68.      * we lock the scheduler here and unlock just after we have
  69.      * sent the notification in pm_system_resume().
  70.      */
  71.     k_sched_lock();
  72.     pm_debug_start_timer();
  73.     /* Enter power state */
  74.     pm_state_notify(true);
  75.     pm_state_set(z_power_state);
  76.     pm_debug_stop_timer();
  78.     /* Wake up sequence starts here */
  79. // 设备电源管理
  80. #if CONFIG_PM_DEVICE
  81.     if (should_resume_devices) {
  82.         /* Turn on peripherals and restore device states as necessary */
  83.         pm_resume_devices();
  84.     }
  85. #endif
  86.     pm_log_debug_info(z_power_state.state);
  87.     pm_system_resume();
  88.     k_sched_unlock();
  89.     SYS_PORT_TRACING_FUNC_EXIT(pm, system_suspend, ticks, z_power_state.state);
  90.     return z_power_state.state;
  91. }

从上面可以看出来，设备电源管理在进入休眠的时候会根据系统电源管理状态调用两个函数,pm_low_power_devices或pm_suspend_devices

pm_low_power_devices函数

  1. int pm_low_power_devices(void)
  2. {
  3.     return _pm_devices(PM_DEVICE_STATE_LOW_POWER);
  4. }
  6. static int _pm_devices(enum pm_device_state state)
  7. {
  8.     const struct device *devs;
  9.     size_t devc;
  11.     devc = z_device_get_all_static(&devs);
  13.     num_susp = 0;
  15.     for (const struct device *dev = devs + devc - 1; dev >= devs; dev--) {
  16.         int ret;
  18.         /* ignore busy devices */
  19.         // 判定设备时忙碌或设备时系统唤醒源
  20.         if (pm_device_is_busy(dev) || pm_device_wakeup_is_enabled(dev)) {
  21.             continue;
  22.         }
  23.         // 执行设备的电源管理动作
  24.         ret = pm_device_state_set(dev, state);
  25.         /* ignore devices not supporting or already at the given state */
  26.         if ((ret == -ENOSYS) || (ret == -ENOTSUP) || (ret == -EALREADY)) {
  27.             continue;
  28.         } else if (ret < 0) {
  29.             LOG_ERR("Device %s did not enter %s state (%d)",
  30.                 dev->name, pm_device_state_str(state), ret);
  31.             return ret;
  32.         }
  34.         __pm_device_slots_start[num_susp] = dev;
  35.         num_susp++;
  36.     }
  38.     return 0;
  39. }

从上面可以看出，当设备是忙碌或者设备是系统的唤醒源是那就不执行设备休眠。
真正执行设备电源管理动作的还是通过pm_device_state_set函数。

pm_suspend_devices函数

  1. int pm_suspend_devices(void)
  2. {
  3.     return _pm_devices(PM_DEVICE_STATE_SUSPENDED);
  4. }
  6. static int _pm_devices(enum pm_device_state state)
  7. {
  8.     const struct device *devs;
  9.     size_t devc;
  11.     devc = z_device_get_all_static(&devs);
  13.     num_susp = 0;
  15.     for (const struct device *dev = devs + devc - 1; dev >= devs; dev--) {
  16.         int ret;
  18.         /* ignore busy devices */
  19.         // 判定设备是否忙碌或设备是否是系统唤醒源
  20.         if (pm_device_is_busy(dev) || pm_device_wakeup_is_enabled(dev)) {
  21.             continue;
  22.         }
  23.         // 执行设备电源管理动作
  24.         ret = pm_device_state_set(dev, state);
  25.         /* ignore devices not supporting or already at the given state */
  26.         if ((ret == -ENOSYS) || (ret == -ENOTSUP) || (ret == -EALREADY)) {
  27.             continue;
  28.         } else if (ret < 0) {
  29.             LOG_ERR("Device %s did not enter %s state (%d)",
  30.                 dev->name, pm_device_state_str(state), ret);
  31.             return ret;
  32.         }
  34.         __pm_device_slots_start[num_susp] = dev;
  35.         num_susp++;
  36.     }
  38.     return 0;
  39. }

从上面可以看出，当设备是忙碌或者设备是系统的唤醒源是那就不执行设备休眠。
真正执行设备电源管理动作的还是通过pm_device_state_set函数。

设备系统电源管理示例

Kconfig定义:

  1. CONFIG_GPIO=y
  2. //启动电源管理
  3. CONFIG_PM=y
  4. //启动设备电源管理
  5. CONFIG_PM_DEVICE=y

设备树:

  1. /{
  2.     power-states {
  3.         stop0: state0 {
  4.             compatible = "zephyr,power-state";
  5.             power-state-name = "suspend-to-idle";
  6.             substate-id = <1>;
  7.             min-residency-us = <500>;
  8.         };
  9.         stop1: state1 {
  10.             compatible = "zephyr,power-state";
  11.             power-state-name = "suspend-to-idle";
  12.             substate-id = <2>;
  13.             min-residency-us = <700>;
  14.         };
  15.         stop2: state2 {
  16.             compatible = "zephyr,power-state";
  17.             power-state-name = "suspend-to-idle";
  18.             substate-id = <3>;
  19.             min-residency-us = <1000>;
  20.         };
  21.     };
  22.     leds {
  23.         compatible = "gpio-leds";
  24.         green_led_2: led_2 {
  25.             gpios = <&gpioa 5 GPIO_ACTIVE_HIGH>;
  26.             label = "User LD2";
  27.         };
  28.     };
  29.     aliases {
  30.         led0 = &green_led_2;
  31.         sw0 = &user_button;
  32.     };
  33. }

代码:

  1. /*
  2.  * Copyright (c) 2021 Linaro Limited
  3.  *
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. #include <zephyr.h>
  8. #include <device.h>
  9. #include <devicetree.h>
  10. #include <drivers/gpio.h>
  11. #include <sys/printk.h>
  13. #define SLEEP_TIME_MS   2000
  15. static const struct gpio_dt_spec led =
  16.     GPIO_DT_SPEC_GET(DT_ALIAS(led0), gpios);
  18. void main(void)
  19. {
  20.     bool led_is_on = true;
  22.     __ASSERT_NO_MSG(device_is_ready(led.port));
  24.     printk("Device ready\n");
  25.     // 标记设备时忙碌的，打开这个注释设备就无法休眠
  26.     // pm_device_busy_set(led.port);
  27.     while (true) {
  28.         gpio_pin_configure_dt(&led, GPIO_OUTPUT_ACTIVE);
  29.         gpio_pin_set(led.port, led.pin, (int)led_is_on);
  30.         if (led_is_on == false) {
  31.             /* Release resource to release device clock */
  32.             gpio_pin_configure(led.port, led.pin, GPIO_DISCONNECTED);
  33.         }
  34.         k_msleep(SLEEP_TIME_MS);
  35.         if (led_is_on == true) {
  36.             /* Release resource to release device clock */
  37.             gpio_pin_configure(led.port, led.pin, GPIO_DISCONNECTED);
  38.         }
  39.         led_is_on = !led_is_on;
  40.     }
  41. }