设备电源管理驱动

其实之前我们在将设备驱动模型的时候有有一个参数我们一直没说，那就电源管理控制函数。
我们在注册驱动的时候时需要提供一个设备电源管理函数的。

  1. #define DEVICE_DEFINE(dev_name, drv_name, init_fn, pm_control_fn,    \
  2.               data_ptr, cfg_ptr, level, prio, api_ptr)        \

其中:pm_control_fn就是设备管理控制函数。
函数原型如下:

  1. int dummy_device_pm_ctrl(const struct device *dev,
  2.                 enum pm_device_action action)

其中pm_device_action为设备电源管理操作类型:

  1. /** @brief Device PM actions. */
  2. enum pm_device_action {
  3.     /** Suspend. */
  4.     PM_DEVICE_ACTION_SUSPEND,
  5.     /** Resume. */
  6.     PM_DEVICE_ACTION_RESUME,
  7.     /** Turn off. */
  8.     PM_DEVICE_ACTION_TURN_OFF,
  9.     /** Force suspend. */
  10.     PM_DEVICE_ACTION_FORCE_SUSPEND,
  11.     /** Low power. */
  12.     PM_DEVICE_ACTION_LOW_POWER,
  13. };

设备电源管理驱动示例

  1. /*
  2.  * Copyright (c) 2018 Intel Corporation
  3.  *
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. #include <pm/device_runtime.h>
  8. #include <sys/printk.h>
  9. #include "dummy_parent.h"
  11. static uint32_t store_value;
  13. static int dummy_transfer(const struct device *dev, uint32_t cmd,
  14.               uint32_t *val)
  15. {
  16.     printk("transfer()\n");
  18.     if (cmd == DUMMY_PARENT_WR) {
  19.         store_value = *val;
  20.     } else {
  21.         *val = store_value;
  22.     }
  24.     return 0;
  25. }
  27. static int dummy_parent_pm_ctrl(const struct device *dev,
  28.                 enum pm_device_action action)
  29. {
  30.     switch (action) {
  31.     case PM_DEVICE_ACTION_RESUME:
  32.         printk("parent resuming..\n");
  33.         break;
  34.     case PM_DEVICE_ACTION_SUSPEND:
  35.         printk("parent suspending..\n");
  36.         break;
  37.     default:
  38.         return -ENOTSUP;
  39.     }
  41.     return 0;
  42. }
  44. static const struct dummy_parent_api funcs = {
  45.     .transfer = dummy_transfer,
  46. };
  48. int dummy_parent_init(const struct device *dev)
  49. {
  50.     //使能设备运行时设备管理
  51.     pm_device_enable(dev);
  52.     return 0;
  53. }
  55. DEVICE_DEFINE(dummy_parent, DUMMY_PARENT_NAME, &dummy_parent_init,
  56.             dummy_parent_pm_ctrl, NULL, NULL, POST_KERNEL,
  57.             CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &funcs);

控制设备电源

系统为我们提供了主动控制设备电源管理的函数:

  1. /**
  2.  * @brief Set the power state of a device.
  3.  *
  4.  * This function calls the device PM control callback so that the device does
  5.  * the necessary operations to put the device into the given state.
  6.  *
  7.  * @note Some devices may not support all device power states.
  8.  *
  9.  * @param dev Device instance.
  10.  * @param state Device power state to be set.
  11.  *
  12.  * @retval 0 If successful.
  13.  * @retval -ENOTSUP If requested state is not supported.
  14.  * @retval -EALREADY If device is already at (or transitioning to) the requested
  15.  *         state.
  16.  * @retval Errno Other negative errno on failure.
  17.  */
  18. int pm_device_state_set(const struct device *dev,
  19.             enum pm_device_state state);
  21. /**
  22.  * @brief Obtain the power state of a device.
  23.  *
  24.  * @param dev Device instance.
  25.  * @param state Pointer where device power state will be stored.
  26.  *
  27.  * @retval 0 If successful.
  28.  * @retval -ENOSYS If device does not implement power management.
  29.  */
  30. int pm_device_state_get(const struct device *dev,
  31.             enum pm_device_state *state);
  32. /**
  33.  * @brief Force usage of given power state.
  34.  *
  35.  * This function overrides decision made by PM policy forcing
  36.  * usage of given power state immediately.
  37.  *
  38.  * @note This function can only run in thread context
  39.  *
  40.  * @param info Power state which should be used in the ongoing
  41.  *    suspend operation.
  42.  */
  43. void pm_power_state_force(struct pm_state_info info);
  • pm_device_state_set: 设置设备的电源管理状态
  • pm_device_state_get: 获取设备的电源管理状态
  • pm_power_state_force: 强制设置电源管理的策略信息

控制设备电源示例

  1. void main(void)
  2. {
  3.     int rc;
  4.     const struct device *cons = device_get_binding(CONSOLE_LABEL);
  6.     printk("\n%s system off demo\n", CONFIG_BOARD);
  8.     /* Configure to generate PORT event (wakeup) on button 1 press. */
  9.     nrf_gpio_cfg_input(DT_GPIO_PIN(DT_NODELABEL(button0), gpios),
  10.                NRF_GPIO_PIN_PULLUP);
  11.     nrf_gpio_cfg_sense_set(DT_GPIO_PIN(DT_NODELABEL(button0), gpios),
  12.                    NRF_GPIO_PIN_SENSE_LOW);
  14.     printk("Busy-wait %u s\n", BUSY_WAIT_S);
  15.     k_busy_wait(BUSY_WAIT_S * USEC_PER_SEC);
  17.     printk("Busy-wait %u s with UART off\n", BUSY_WAIT_S);
  18.     rc = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPENDED);
  19.     k_busy_wait(BUSY_WAIT_S * USEC_PER_SEC);
  20.     rc = pm_device_state_set(cons, PM_DEVICE_STATE_ACTIVE);
  22.     printk("Sleep %u s\n", SLEEP_S);
  23.     k_sleep(K_SECONDS(SLEEP_S));
  25.     printk("Sleep %u s with UART off\n", SLEEP_S);
  26.     rc = pm_device_state_set(cons, PM_DEVICE_STATE_SUSPENDED);
  27.     k_sleep(K_SECONDS(SLEEP_S));
  28.     rc = pm_device_state_set(cons, PM_DEVICE_STATE_ACTIVE);
  30.     printk("Entering system off; press BUTTON1 to restart\n");
  32.     /* Above we disabled entry to deep sleep based on duration of
  33.      * controlled delay.  Here we need to override that, then
  34.      * force entry to deep sleep on any delay.
  35.      */
  36.     pm_power_state_force((struct pm_state_info){PM_STATE_SOFT_OFF, 0, 0});
  38.     printk("ERROR: System off failed\n");
  39.     while (true) {
  40.         /* spin to avoid fall-off behavior */
  41.     }
  42. }