state.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Intel corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_PM_STATE_H_
#define ZEPHYR_INCLUDE_PM_STATE_H_
 
#include <zephyr/sys/util.h>
#include <zephyr/devicetree.h>
#include <errno.h>
 
#ifdef __cplusplus
extern "C" {
#endif


enum pm_state {
        PM_STATE_ACTIVE,
        PM_STATE_RUNTIME_IDLE,
        PM_STATE_SUSPEND_TO_IDLE,
        PM_STATE_STANDBY,
        PM_STATE_SUSPEND_TO_RAM,
        PM_STATE_SUSPEND_TO_DISK,
        PM_STATE_SOFT_OFF,
        PM_STATE_COUNT,
};

struct pm_state_info {
        enum pm_state state;

        uint8_t substate_id;

        bool pm_device_disabled;

        uint32_t min_residency_us;

        uint32_t exit_latency_us;
};

struct pm_state_constraint {
        enum pm_state state;
        uint8_t substate_id;
};

struct pm_state_constraints {
        struct pm_state_constraint *list;
        size_t count;
};


#define Z_DT_PHANDLE_01(node_id, prop, idx) \
        COND_CODE_1(DT_NODE_HAS_STATUS_OKAY(DT_PHANDLE_BY_IDX(node_id, prop, idx)), \
                    (1), (0))

#define Z_PM_STATE_INFO_FROM_DT_CPU(i, node_id)                                                   \
        COND_CODE_1(DT_NODE_HAS_STATUS_OKAY(DT_PHANDLE_BY_IDX(node_id, cpu_power_states, i)),     \
                    (PM_STATE_INFO_DT_INIT(DT_PHANDLE_BY_IDX(node_id, cpu_power_states, i)),), ())

#define Z_PM_STATE_FROM_DT_CPU(i, node_id)                                                        \
        COND_CODE_1(DT_NODE_HAS_STATUS_OKAY(DT_PHANDLE_BY_IDX(node_id, cpu_power_states, i)),     \
                    (PM_STATE_DT_INIT(DT_PHANDLE_BY_IDX(node_id, cpu_power_states, i)),), ())


#define PM_STATE_INFO_DT_INIT(node_id)                                         \
        {                                                                      \
                .state = PM_STATE_DT_INIT(node_id),                            \
                .substate_id = DT_PROP_OR(node_id, substate_id, 0),            \
                .min_residency_us = DT_PROP_OR(node_id, min_residency_us, 0),  \
                .exit_latency_us = DT_PROP_OR(node_id, exit_latency_us, 0),    \
                .pm_device_disabled = DT_PROP(node_id, zephyr_pm_device_disabled),    \
        }

#define PM_STATE_DT_INIT(node_id) \
        DT_ENUM_IDX(node_id, power_state_name)

#define DT_NUM_CPU_POWER_STATES(node_id)                                                           \
        COND_CODE_1(DT_NODE_HAS_PROP(node_id, cpu_power_states),                                   \
                    (DT_FOREACH_PROP_ELEM_SEP(node_id, cpu_power_states, Z_DT_PHANDLE_01, (+))),   \
                    (0))

#define PM_STATE_INFO_LIST_FROM_DT_CPU(node_id)                                \
        {                                                                      \
                LISTIFY(DT_PROP_LEN_OR(node_id, cpu_power_states, 0),          \
                        Z_PM_STATE_INFO_FROM_DT_CPU, (), node_id)              \
        }

#define PM_STATE_LIST_FROM_DT_CPU(node_id)                                     \
        {                                                                      \
                LISTIFY(DT_PROP_LEN_OR(node_id, cpu_power_states, 0),          \
                        Z_PM_STATE_FROM_DT_CPU, (), node_id)                   \
        }

#define PM_STATE_CONSTRAINT_INIT(node_id)                                     \
        {                                                                     \
                .state = PM_STATE_DT_INIT(node_id),                           \
                .substate_id = DT_PROP_OR(node_id, substate_id, 0),           \
        }
 
#define Z_PM_STATE_CONSTRAINT_REF(node_id, phandle, idx)                        \
        PM_STATE_CONSTRAINT_INIT(DT_PHANDLE_BY_IDX(node_id, phandle, idx))
 
#define Z_PM_STATE_CONSTRAINTS_LIST_NAME(node_id, phandles)                   \
        _CONCAT_4(node_id, _, phandles, _constraints)

#define PM_STATE_CONSTRAINTS_LIST_DEFINE(node_id, prop)                                    \
        struct pm_state_constraint Z_PM_STATE_CONSTRAINTS_LIST_NAME(node_id, prop)[] =     \
        {                                                                                  \
                DT_FOREACH_PROP_ELEM_SEP(node_id, prop, Z_PM_STATE_CONSTRAINT_REF, (,))    \
        }

#define PM_STATE_CONSTRAINTS_GET(node_id, prop)                                            \
        {                                                                                  \
                .list = Z_PM_STATE_CONSTRAINTS_LIST_NAME(node_id, prop),                   \
                .count = DT_PROP_LEN(node_id, prop),                                       \
        }
 
#if defined(CONFIG_PM) || defined(__DOXYGEN__)
uint8_t pm_state_cpu_get_all(uint8_t cpu, const struct pm_state_info **states);

const struct pm_state_info *pm_state_get(uint8_t cpu, enum pm_state state, uint8_t substate_id);

const char *pm_state_to_str(enum pm_state state);
 

int pm_state_from_str(const char *name, enum pm_state *out);

bool pm_state_in_constraints(const struct pm_state_constraints *constraints,
                             const struct pm_state_constraint match);

 
#else  /* CONFIG_PM */
 
static inline uint8_t pm_state_cpu_get_all(uint8_t cpu, const struct pm_state_info **states)
{
        ARG_UNUSED(cpu);
        ARG_UNUSED(states);
 
        return 0;
}
 
static inline const struct pm_state_info *pm_state_get(uint8_t cpu,
                                                       enum pm_state state,
                                                       uint8_t substate_id)
{
        ARG_UNUSED(cpu);
        ARG_UNUSED(state);
        ARG_UNUSED(substate_id);
 
        return NULL;
}
 
static inline bool pm_state_in_constraints(struct pm_state_constraints *constraints,
                                           struct pm_state_constraint match)
{
        ARG_UNUSED(constraints);
        ARG_UNUSED(match);
 
        return false;
}
#endif /* CONFIG_PM */
 
#ifdef __cplusplus
}
#endif
 
#endif