pinebuds/platform/hal/hal_sleep.c

588 lines
14 KiB
C

/***************************************************************************
*
* Copyright 2015-2019 BES.
* All rights reserved. All unpublished rights reserved.
*
* No part of this work may be used or reproduced in any form or by any
* means, or stored in a database or retrieval system, without prior written
* permission of BES.
*
* Use of this work is governed by a license granted by BES.
* This work contains confidential and proprietary information of
* BES. which is protected by copyright, trade secret,
* trademark and other intellectual property rights.
*
****************************************************************************/
#include "hal_sleep.h"
#include "hal_cmu.h"
#include "hal_location.h"
#include "hal_trace.h"
#include "hal_timer.h"
#include "hal_sysfreq.h"
#include "hal_dma.h"
#include "hal_norflash.h"
#include "hal_gpadc.h"
#include "analog.h"
#include "pmu.h"
#include "cmsis.h"
//static uint8_t SRAM_STACK_LOC sleep_stack[128];
static HAL_SLEEP_HOOK_HANDLER sleep_hook_handler[HAL_SLEEP_HOOK_USER_QTY];
static HAL_DEEP_SLEEP_HOOK_HANDLER deep_sleep_hook_handler[HAL_DEEP_SLEEP_HOOK_USER_QTY];
static uint32_t cpu_wake_lock_map;
static uint32_t sys_wake_lock_map;
static uint32_t chip_wake_lock_map;
#ifdef SLEEP_STATS_TRACE
static uint32_t stats_trace_interval;
static uint32_t stats_trace_time;
#endif
static uint32_t stats_interval;
static uint32_t stats_start_time;
static uint32_t light_sleep_time;
static uint32_t sys_deep_sleep_time;
static uint32_t chip_deep_sleep_time;
static bool stats_started;
static bool stats_valid;
static uint8_t light_sleep_ratio;
static uint8_t sys_deep_sleep_ratio;
static uint8_t chip_deep_sleep_ratio;
void hal_sleep_start_stats(uint32_t stats_interval_ms, uint32_t trace_interval_ms)
{
uint32_t lock;
lock = int_lock();
if (stats_interval_ms) {
stats_interval = MS_TO_TICKS(stats_interval_ms);
stats_start_time = hal_sys_timer_get();
light_sleep_time = 0;
sys_deep_sleep_time = 0;
chip_deep_sleep_time = 0;
stats_valid = false;
stats_started = true;
} else {
stats_started = false;
}
int_unlock(lock);
#ifdef SLEEP_STATS_TRACE
if (stats_interval_ms && trace_interval_ms) {
stats_trace_interval = MS_TO_TICKS(trace_interval_ms);
} else {
stats_trace_interval = 0;
}
#endif
}
int hal_sleep_get_stats(struct CPU_USAGE_T *usage)
{
int ret;
uint32_t lock;
lock = int_lock();
if (stats_valid) {
usage->light_sleep = light_sleep_ratio;
usage->sys_deep_sleep = sys_deep_sleep_ratio;
usage->chip_deep_sleep = chip_deep_sleep_ratio;
usage->busy = 100 - (light_sleep_ratio + sys_deep_sleep_ratio + chip_deep_sleep_ratio);
ret = 0;
} else {
ret = 1;
}
int_unlock(lock);
return ret;
}
static int hal_sleep_cpu_busy(void)
{
if (cpu_wake_lock_map || hal_cmu_lpu_busy()) {
return 1;
} else {
return 0;
}
}
static int hal_sleep_sys_busy(void)
{
if (sys_wake_lock_map || hal_sysfreq_busy() || hal_dma_busy()) {
return 1;
} else {
return 0;
}
}
int hal_sleep_set_sleep_hook(enum HAL_SLEEP_HOOK_USER_T user, HAL_SLEEP_HOOK_HANDLER handler)
{
if (user >= ARRAY_SIZE(sleep_hook_handler)) {
return 1;
}
sleep_hook_handler[user] = handler;
return 0;
}
static int SRAM_TEXT_LOC hal_sleep_exec_sleep_hook(void)
{
int i;
int ret;
for (i = 0; i < ARRAY_SIZE(sleep_hook_handler); i++) {
if (sleep_hook_handler[i]) {
ret = sleep_hook_handler[i]();
if (ret) {
return ret;
}
}
}
return 0;
}
int hal_sleep_set_deep_sleep_hook(enum HAL_DEEP_SLEEP_HOOK_USER_T user, HAL_DEEP_SLEEP_HOOK_HANDLER handler)
{
if (user >= ARRAY_SIZE(deep_sleep_hook_handler)) {
return 1;
}
deep_sleep_hook_handler[user] = handler;
return 0;
}
static int SRAM_TEXT_LOC hal_sleep_exec_deep_sleep_hook(void)
{
int i;
int ret;
for (i = 0; i < ARRAY_SIZE(deep_sleep_hook_handler); i++) {
if (deep_sleep_hook_handler[i]) {
ret = deep_sleep_hook_handler[i]();
if (ret) {
return ret;
}
}
}
return 0;
}
int SRAM_TEXT_LOC hal_sleep_irq_pending(void)
{
#if defined(__GIC_PRESENT) && (__GIC_PRESENT)
int i;
for (i = 0; i < (USER_IRQn_QTY + 31) / 32; i++) {
if (GICDistributor->ICPENDR[i] & GICDistributor->ISENABLER[i]) {
return 1;
}
}
#else
#if 0
int i;
for (i = 0; i < (USER_IRQn_QTY + 31) / 32; i++) {
if (NVIC->ICPR[i] & NVIC->ISER[i]) {
return 1;
}
}
#else
// If there is any pending and enabled exception (including sysTick)
if (SCB->ICSR & SCB_ICSR_VECTPENDING_Msk) {
return 1;
}
#endif
#endif
return 0;
}
int SRAM_TEXT_LOC hal_sleep_specific_irq_pending(const uint32_t *irq, uint32_t cnt)
{
int i;
uint32_t check_cnt;
check_cnt = (USER_IRQn_QTY + 31) / 32;
if (check_cnt > cnt) {
check_cnt = cnt;
}
#if defined(__GIC_PRESENT) && (__GIC_PRESENT)
for (i = 0; i < check_cnt; i++) {
if (GICDistributor->ICPENDR[i] & GICDistributor->ISENABLER[i] & irq[i]) {
return 1;
}
}
#else
for (i = 0; i < check_cnt; i++) {
if (NVIC->ICPR[i] & NVIC->ISER[i] & irq[i]) {
return 1;
}
}
#endif
return 0;
}
void WEAK bt_drv_sleep(void)
{
}
void WEAK bt_drv_wakeup(void)
{
}
static enum HAL_SLEEP_STATUS_T SRAM_TEXT_LOC hal_sleep_lowpower_mode(void)
{
enum HAL_SLEEP_STATUS_T ret;
enum HAL_CMU_LPU_SLEEP_MODE_T mode;
uint32_t time = 0;
ret = HAL_SLEEP_STATUS_LIGHT;
// Deep sleep hook
if (hal_sleep_exec_deep_sleep_hook() || hal_trace_busy()) {
return ret;
}
if (stats_started) {
time = hal_sys_timer_get();
}
// Modules (except for psram and flash) sleep
hal_gpadc_sleep();
if (chip_wake_lock_map == 0) {
analog_sleep();
pmu_sleep();
}
bt_drv_sleep();
// End of sleep
//psram_sleep();
hal_norflash_sleep(HAL_NORFLASH_ID_0);
// Now neither psram nor flash are usable
if (!hal_sleep_irq_pending()) {
if (chip_wake_lock_map) {
mode = HAL_CMU_LPU_SLEEP_MODE_SYS;
} else {
mode = HAL_CMU_LPU_SLEEP_MODE_CHIP;
}
hal_cmu_lpu_sleep(mode);
ret = HAL_SLEEP_STATUS_DEEP;
}
hal_norflash_wakeup(HAL_NORFLASH_ID_0);
//psram_wakeup();
// Now both psram and flash are usable
if (chip_wake_lock_map == 0) {
pmu_wakeup();
analog_wakeup();
}
bt_drv_wakeup();
hal_gpadc_wakeup();
// Modules (except for psram and flash) wakeup
// End of wakeup
if (stats_started) {
time = hal_sys_timer_get() - time;
if (chip_wake_lock_map) {
sys_deep_sleep_time += time;
} else {
chip_deep_sleep_time += time;
}
}
return ret;
}
// GCC has trouble in detecting static function usage in embedded ASM statements.
// The following function might be optimized away if there is no explicted call in C codes.
// Specifying "used" (or "noclone") attribute on the function can avoid the mistaken optimization.
static enum HAL_SLEEP_STATUS_T SRAM_TEXT_LOC NOINLINE USED hal_sleep_proc(int light_sleep)
{
enum HAL_SLEEP_STATUS_T ret;
uint32_t time = 0;
uint32_t interval;
ret = HAL_SLEEP_STATUS_LIGHT;
// Check the sleep conditions in interrupt-locked context
if (hal_sleep_cpu_busy()) {
// Cannot sleep
} else {
// Sleep hook
if (hal_sleep_exec_sleep_hook()) {
goto _exit_sleep;
}
if (hal_sleep_sys_busy()) {
// Light sleep
if (stats_started) {
time = hal_sys_timer_get();
}
#ifdef NO_LIGHT_SLEEP
// WFI during USB ISO transfer might generate very weak (0.1 mV) 1K tone interference ???
while (!hal_sleep_irq_pending());
#else
#ifndef __ARM_ARCH_ISA_ARM
SCB->SCR = 0;
#endif
__DSB();
__WFI();
#endif
if (stats_started) {
light_sleep_time += hal_sys_timer_get() - time;
}
#ifdef DEBUG
} else if (hal_trace_busy()) {
// Light sleep with trace busy only
if (stats_started) {
time = hal_sys_timer_get();
}
// No irq will be generated when trace becomes idle, so the trace status should
// be kept polling actively instead of entering WFI
while (!hal_sleep_irq_pending() && hal_trace_busy());
if (stats_started) {
light_sleep_time += hal_sys_timer_get() - time;
}
if (!hal_sleep_irq_pending()) {
goto _deep_sleep;
}
#endif
} else {
// Deep sleep
_deep_sleep: POSSIBLY_UNUSED;
if (light_sleep) {
ret = HAL_SLEEP_STATUS_DEEP;
} else {
ret = hal_sleep_lowpower_mode();
}
}
}
_exit_sleep:
if (stats_started) {
time = hal_sys_timer_get();
interval = time - stats_start_time;
if (interval >= stats_interval) {
if (light_sleep_time > UINT32_MAX / 100) {
light_sleep_ratio = (uint64_t)light_sleep_time * 100 / interval;
} else {
light_sleep_ratio = light_sleep_time * 100 / interval;
}
if (sys_deep_sleep_time > UINT32_MAX / 100) {
sys_deep_sleep_ratio = (uint64_t)sys_deep_sleep_time * 100 / interval;
} else {
sys_deep_sleep_ratio = sys_deep_sleep_time * 100 / interval;
}
if (chip_deep_sleep_time > UINT32_MAX / 100) {
chip_deep_sleep_ratio = (uint64_t)chip_deep_sleep_time * 100 / interval;
} else {
chip_deep_sleep_ratio = chip_deep_sleep_time * 100 / interval;
}
stats_valid = true;
light_sleep_time = 0;
sys_deep_sleep_time = 0;
chip_deep_sleep_time = 0;
stats_start_time = time;
}
#ifdef SLEEP_STATS_TRACE
if (stats_valid && stats_trace_interval) {
uint32_t time = hal_sys_timer_get();
if (time - stats_trace_time >= stats_trace_interval) {
TRACE(4,"CPU USAGE: busy=%d light=%d sys_deep=%d chip_deep=%d",
100 - (light_sleep_ratio + sys_deep_sleep_ratio + chip_deep_sleep_ratio),
light_sleep_ratio, sys_deep_sleep_ratio, chip_deep_sleep_ratio);
stats_trace_time = time;
#ifdef DEBUG_SLEEP_USER
TRACE(4,"SLEEP_USER: cpulock=0x%X syslock=0x%X irq=0x%08X_%08X",
cpu_wake_lock_map, sys_wake_lock_map, (NVIC->ICPR[1] & NVIC->ISER[1]), (NVIC->ICPR[0] & NVIC->ISER[0]));
hal_sysfreq_print();
#endif
}
}
#endif
}
return ret;
}
#ifndef __ARM_ARCH_ISA_ARM
static enum HAL_SLEEP_STATUS_T SRAM_TEXT_LOC NOINLINE USED NAKED hal_sleep_deep_sleep_wrapper(void)
{
asm volatile(
"push {r4, lr} \n"
// Switch current stack pointer to MSP
"mrs r4, control \n"
"bic r4, #2 \n"
"msr control, r4 \n"
"isb \n"
"movs r0, #0 \n"
"bl hal_sleep_proc \n"
// Switch current stack pointer back to PSP
"orr r4, #2 \n"
"msr control, r4 \n"
"isb \n"
"pop {r4, pc} \n"
);
#ifndef __ARMCC_VERSION
return HAL_SLEEP_STATUS_LIGHT;
#endif
}
#endif
enum HAL_SLEEP_STATUS_T SRAM_TEXT_LOC hal_sleep_enter_sleep(void)
{
enum HAL_SLEEP_STATUS_T ret;
uint32_t lock;
ret = HAL_SLEEP_STATUS_LIGHT;
#ifdef NO_SLEEP
return ret;
#endif
lock = int_lock_global();
#ifndef __ARM_ARCH_ISA_ARM
if (__get_CONTROL() & 0x02) {
ret = hal_sleep_deep_sleep_wrapper();
} else
#endif
{
ret = hal_sleep_proc(false);
}
int_unlock_global(lock);
return ret;
}
enum HAL_SLEEP_STATUS_T SRAM_TEXT_LOC hal_sleep_light_sleep(void)
{
enum HAL_SLEEP_STATUS_T ret;
uint32_t lock;
ret = HAL_SLEEP_STATUS_LIGHT;
#ifdef NO_SLEEP
return ret;
#endif
lock = int_lock_global();
ret = hal_sleep_proc(true);
int_unlock_global(lock);
return ret;
}
int hal_cpu_wake_lock(enum HAL_CPU_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_CPU_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
cpu_wake_lock_map |= (1 << user);
int_unlock(lock);
return 0;
}
int hal_cpu_wake_unlock(enum HAL_CPU_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_CPU_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
cpu_wake_lock_map &= ~(1 << user);
int_unlock(lock);
return 0;
}
int hal_sys_wake_lock(enum HAL_SYS_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_SYS_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
sys_wake_lock_map |= (1 << user);
int_unlock(lock);
return 0;
}
int hal_sys_wake_unlock(enum HAL_SYS_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_SYS_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
sys_wake_lock_map &= ~(1 << user);
int_unlock(lock);
return 0;
}
int hal_chip_wake_lock(enum HAL_CHIP_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_CHIP_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
chip_wake_lock_map |= (1 << user);
int_unlock(lock);
return 0;
}
int hal_chip_wake_unlock(enum HAL_CHIP_WAKE_LOCK_USER_T user)
{
uint32_t lock;
if (user >= HAL_CHIP_WAKE_LOCK_USER_QTY) {
return 1;
}
lock = int_lock();
chip_wake_lock_map &= ~(1 << user);
int_unlock(lock);
return 0;
}