powman.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _HARDWARE_POWMAN_H
#define _HARDWARE_POWMAN_H
 
#include "pico.h"
#include "hardware/structs/powman.h"
#include "pico/util/fixed_bitset.h"
 
#ifdef __cplusplus
extern "C" {
#endif

 
// PICO_CONFIG: PARAM_ASSERTIONS_ENABLED_HARDWARE_POWMAN, Enable/disable hardware_powman assertions, type=bool, default=0, group=hardware_powman
#ifndef PARAM_ASSERTIONS_ENABLED_HARDWARE_POWMAN
#define PARAM_ASSERTIONS_ENABLED_HARDWARE_POWMAN 0
#endif
 
// PICO_CONFIG: PICO_POWMAN_CALIBRATE_LPOSC_FROM_OTP, Use the OTP calibration value for the low power oscillator frequency, type=bool, default=1, group=hardware_powman
#ifndef PICO_POWMAN_CALIBRATE_LPOSC_FROM_OTP
#define PICO_POWMAN_CALIBRATE_LPOSC_FROM_OTP 1
#endif

uint32_t powman_timer_get_lposc_calib_freq(void);

void powman_timer_set_1khz_tick_source_lposc(void);

void powman_timer_set_1khz_tick_source_lposc_with_hz(uint32_t lposc_freq_hz);

void powman_timer_set_1khz_tick_source_xosc(void);

void powman_timer_set_1khz_tick_source_xosc_with_hz(uint32_t xosc_freq_hz);

void powman_timer_set_1khz_tick_source_gpio(uint32_t gpio);

void powman_timer_enable_gpio_1hz_sync(uint32_t gpio);

void powman_timer_disable_gpio_1hz_sync(void);

uint64_t powman_timer_get_ms(void);

void powman_timer_set_ms(uint64_t time_ms);

void powman_timer_enable_alarm_at_ms(uint64_t alarm_time_ms);

void powman_timer_disable_alarm(void);

static inline void powman_set_bits(volatile uint32_t *reg, uint32_t bits) {
    invalid_params_if(HARDWARE_POWMAN, bits >> 16);
    hw_set_bits(reg, POWMAN_PASSWORD_BITS | bits);
}

static inline void powman_clear_bits(volatile uint32_t *reg, uint32_t bits) {
    invalid_params_if(HARDWARE_POWMAN, bits >> 16);
    hw_clear_bits(reg, POWMAN_PASSWORD_BITS | bits);
}

static inline bool powman_timer_is_running(void) {
    return powman_hw->timer & POWMAN_TIMER_RUN_BITS;
}

static inline void powman_timer_stop(void) {
    powman_clear_bits(&powman_hw->timer, POWMAN_TIMER_RUN_BITS);
}

static inline void powman_timer_pause(void) {
    powman_clear_bits(&powman_hw->timer, POWMAN_TIMER_RUN_BITS);
    powman_timer_set_ms(powman_timer_get_ms());
}

static inline void powman_timer_start(void) {
    powman_set_bits(&powman_hw->timer, POWMAN_TIMER_RUN_BITS);
}

static inline void powman_clear_alarm(void) {
    powman_clear_bits(&powman_hw->timer, POWMAN_TIMER_ALARM_BITS);
}

enum powman_power_domains {
    POWMAN_POWER_DOMAIN_SRAM_BANK1 = 0,    
    POWMAN_POWER_DOMAIN_SRAM_BANK0 = 1,    
    POWMAN_POWER_DOMAIN_XIP_CACHE = 2,     
    POWMAN_POWER_DOMAIN_SWITCHED_CORE = 3, 
    POWMAN_POWER_DOMAIN_COUNT = 4,
};
typedef enum powman_power_domains powman_power_domain_t;
 
typedef uint32_t powman_power_state;
 
typedef fixed_bitset_type(POWMAN_POWER_DOMAIN_COUNT) pstate_bitset_t;
#define pstate_bitset_none() fixed_bitset_with_fill(pstate_bitset_t, POWMAN_POWER_DOMAIN_COUNT, 0)
#define pstate_bitset_all() fixed_bitset_with_fill(pstate_bitset_t, POWMAN_POWER_DOMAIN_COUNT, 1)
 
static inline pstate_bitset_t *pstate_bitset_remove_all(pstate_bitset_t *domains) {
    fixed_bitset_clear_all(&domains->bitset);
    return domains;
}
 
static inline pstate_bitset_t *pstate_bitset_add_all(pstate_bitset_t *domains) {
    fixed_bitset_set_all(&domains->bitset);
    return domains;
}
 
static inline pstate_bitset_t *pstate_bitset_add(pstate_bitset_t *domains, powman_power_domain_t domain) {
    fixed_bitset_set(&domains->bitset, domain);
    return domains;
}
 
static inline pstate_bitset_t *pstate_bitset_remove(pstate_bitset_t *domains, powman_power_domain_t domain) {
    fixed_bitset_clear(&domains->bitset, domain);
    return domains;
}
 
static inline bool pstate_bitset_is_set(pstate_bitset_t *domains, powman_power_domain_t domain) {
    return fixed_bitset_get(&domains->bitset, domain);
}
 
static inline bool pstate_bitset_none_set(pstate_bitset_t *domains) {
    return fixed_bitset_is_empty(&domains->bitset);
}
 
static inline pstate_bitset_t *pstate_bitset_from_powman_power_state(pstate_bitset_t *domains, powman_power_state pstate) {
    static_assert(sizeof(powman_power_state) <= sizeof(uint32_t), "");
    fixed_bitset_write_word(&domains->bitset, 0, pstate);
    return domains;
}
 
static inline powman_power_state pstate_bitset_to_powman_power_state(pstate_bitset_t *domains) {
    return fixed_bitset_read_word(&domains->bitset, 0);
}

powman_power_state powman_get_power_state(void);

int powman_set_power_state(powman_power_state state);
 
#define POWMAN_POWER_STATE_NONE 0

static inline powman_power_state powman_power_state_with_domain_on(powman_power_state orig, enum powman_power_domains domain) {
    invalid_params_if(HARDWARE_POWMAN, domain >= POWMAN_POWER_DOMAIN_COUNT);
    return orig | (1u << domain);
}

static inline powman_power_state powman_power_state_with_domain_off(powman_power_state orig, enum powman_power_domains domain) {
    invalid_params_if(HARDWARE_POWMAN, domain >= POWMAN_POWER_DOMAIN_COUNT);
    return orig &= ~(1u << domain);
}

static inline bool powman_power_state_is_domain_on(powman_power_state state, enum powman_power_domains domain) {
    invalid_params_if(HARDWARE_POWMAN, domain >= POWMAN_POWER_DOMAIN_COUNT);
    return state & (1u << domain);
}

void powman_enable_alarm_wakeup_at_ms(uint64_t alarm_time_ms);

void powman_enable_gpio_wakeup(uint gpio_wakeup_num, uint32_t gpio, bool edge, bool high);

void powman_disable_alarm_wakeup(void);

void powman_disable_gpio_wakeup(uint gpio_wakeup_num);

void powman_disable_all_wakeups(void);

bool powman_configure_wakeup_state(powman_power_state sleep_state, powman_power_state wakeup_state);

static inline void powman_set_debug_power_request_ignored(bool ignored) {
    if (ignored)
        powman_set_bits(&powman_hw->dbg_pwrcfg, 1);
    else
        powman_clear_bits(&powman_hw->dbg_pwrcfg, 1);
}
 
#ifdef __cplusplus
}
#endif
 
#endif