policy.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_PM_POLICY_H_
#define ZEPHYR_INCLUDE_PM_POLICY_H_
 
#include <stdbool.h>
#include <stdint.h>
 
#include <zephyr/device.h>
#include <zephyr/pm/state.h>
#include <zephyr/sys/slist.h>
#include <zephyr/toolchain.h>
 
#ifdef __cplusplus
extern "C" {
#endif


typedef void (*pm_policy_latency_changed_cb_t)(int32_t latency);

struct pm_policy_latency_subscription {
        sys_snode_t node;
        pm_policy_latency_changed_cb_t cb;
};

struct pm_policy_latency_request {
        sys_snode_t node;
        uint32_t value_us;
};

struct pm_policy_event {
        sys_snode_t node;
        int64_t uptime_ticks;
};


const struct pm_state_info *pm_policy_next_state(uint8_t cpu, int32_t ticks);


#define PM_ALL_SUBSTATES (UINT8_MAX)
 
#if defined(CONFIG_PM) || defined(__DOXYGEN__)
void pm_policy_state_lock_get(enum pm_state state, uint8_t substate_id);

void pm_policy_state_lock_put(enum pm_state state, uint8_t substate_id);

void pm_policy_state_all_lock_get(void);

void pm_policy_state_all_lock_put(void);

void pm_policy_state_constraints_get(struct pm_state_constraints *constraints);

void pm_policy_state_constraints_put(struct pm_state_constraints *constraints);

bool pm_policy_state_lock_is_active(enum pm_state state, uint8_t substate_id);

bool pm_policy_state_is_available(enum pm_state state, uint8_t substate_id);

bool pm_policy_state_any_active(void);

void pm_policy_event_register(struct pm_policy_event *evt, int64_t uptime_ticks);

void pm_policy_event_update(struct pm_policy_event *evt, int64_t uptime_ticks);

void pm_policy_event_unregister(struct pm_policy_event *evt);

bool pm_policy_device_is_disabling_state(const struct device *dev,
                                         enum pm_state state, uint8_t substate_id);

int64_t pm_policy_next_event_ticks(void);
 
#else
static inline void pm_policy_state_lock_get(enum pm_state state, uint8_t substate_id)
{
        ARG_UNUSED(state);
        ARG_UNUSED(substate_id);
}
 
static inline void pm_policy_state_lock_put(enum pm_state state, uint8_t substate_id)
{
        ARG_UNUSED(state);
        ARG_UNUSED(substate_id);
}
 
static inline void pm_policy_state_all_lock_get(void)
{
}
 
static inline void pm_policy_state_all_lock_put(void)
{
}
 
static inline bool pm_policy_state_lock_is_active(enum pm_state state, uint8_t substate_id)
{
        ARG_UNUSED(state);
        ARG_UNUSED(substate_id);
 
        return false;
}
 
static inline void pm_policy_event_register(struct pm_policy_event *evt, uint32_t cycle)
{
        ARG_UNUSED(evt);
        ARG_UNUSED(cycle);
}
 
static inline void pm_policy_event_update(struct pm_policy_event *evt, uint32_t cycle)
{
        ARG_UNUSED(evt);
        ARG_UNUSED(cycle);
}
 
static inline void pm_policy_event_unregister(struct pm_policy_event *evt)
{
        ARG_UNUSED(evt);
}
 
static inline int64_t pm_policy_next_event_ticks(void)
{
        return -1;
}
 
#endif /* CONFIG_PM */
 
#if defined(CONFIG_PM_POLICY_DEVICE_CONSTRAINTS) || defined(__DOXYGEN__)
void pm_policy_device_power_lock_get(const struct device *dev);

void pm_policy_device_power_lock_put(const struct device *dev);
 
#else
 
static inline void pm_policy_device_power_lock_get(const struct device *dev)
{
        ARG_UNUSED(dev);
}
 
static inline void pm_policy_device_power_lock_put(const struct device *dev)
{
        ARG_UNUSED(dev);
}
#endif /* CONFIG_PM_POLICY_DEVICE_CONSTRAINTS */
 
#if defined(CONFIG_PM) || defined(CONFIG_PM_POLICY_LATENCY_STANDALONE) || defined(__DOXYGEN__)
void pm_policy_latency_request_add(struct pm_policy_latency_request *req,
                                   uint32_t value_us);

void pm_policy_latency_request_update(struct pm_policy_latency_request *req,
                                      uint32_t value_us);

void pm_policy_latency_request_remove(struct pm_policy_latency_request *req);

void pm_policy_latency_changed_subscribe(struct pm_policy_latency_subscription *req,
                                         pm_policy_latency_changed_cb_t cb);

void pm_policy_latency_changed_unsubscribe(struct pm_policy_latency_subscription *req);
#else
static inline void pm_policy_latency_request_add(
        struct pm_policy_latency_request *req, uint32_t value_us)
{
        ARG_UNUSED(req);
        ARG_UNUSED(value_us);
}
 
static inline void pm_policy_latency_request_update(
        struct pm_policy_latency_request *req, uint32_t value_us)
{
        ARG_UNUSED(req);
        ARG_UNUSED(value_us);
}
 
static inline void pm_policy_latency_request_remove(
        struct pm_policy_latency_request *req)
{
        ARG_UNUSED(req);
}
#endif /* CONFIG_PM CONFIG_PM_POLICY_LATENCY_STANDALONE */

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_PM_POLICY_H_ */