588 lines
14 KiB
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;
|
|
}
|
|
|