mbed-os/targets/TARGET_Cypress/TARGET_PSOC6/mtb-hal-cat1/source/cyhal_syspm.c

/***************************************************************************//**
* \file cyhal_syspm.c
*
* \brief
* Provides a high level interface for interacting with the Cypress power
* management and system clock configuration. This interface abstracts out the
* chip specific details. If any chip specific functionality is necessary, or
* performance is critical the low level functions can be used directly.
*
********************************************************************************
* \copyright
* Copyright 2018-2021 Cypress Semiconductor Corporation
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include <limits.h>
#include "cyhal_system.h"
#include "cyhal_syspm.h"
#include "cy_syspm.h"
#include "cy_utils.h"
#include "cyhal_utils.h"
#include "cyhal_lptimer.h"

/* Check if the SysTick is enabled */
#define _cyhal_syspm_is_systick_enabled() (SysTick->CTRL & SysTick_CTRL_ENABLE_Msk)

/* Disable the SysTick */
#define _cyhal_syspm_disable_systick() (SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk)

/* Enable the SysTick */
#define _cyhal_syspm_enable_systick()  (SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk)

/* Hz to KHz */
#define _CYHAL_HZ_TO_KHZ_CONVERSION_FACTOR         1000

/** The common PM callback parameters set, that are used internally for different peripherals */
static cy_stc_syspm_callback_params_t _cyhal_syspm_cb_params_sleep     = {NULL, (uint32_t *)CYHAL_SYSPM_CB_CPU_SLEEP};
static cy_stc_syspm_callback_params_t _cyhal_syspm_cb_params_deepsleep = {NULL, (uint32_t *)CYHAL_SYSPM_CB_CPU_DEEPSLEEP};
static cy_stc_syspm_callback_params_t _cyhal_syspm_cb_params_hibernate = {NULL, (uint32_t *)CYHAL_SYSPM_CB_SYSTEM_HIBERNATE};
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
static cy_stc_syspm_callback_params_t _cyhal_syspm_cb_params_lp = {NULL, (uint32_t *)CYHAL_SYSPM_CB_SYSTEM_NORMAL};
static cy_stc_syspm_callback_params_t _cyhal_syspm_cb_params_ulp = {NULL, (uint32_t *)CYHAL_SYSPM_CB_SYSTEM_LOW};
#endif

/* The first entry in the callback chain is always reserved for the user set
 * cyhal_syspm_register_callback callback. This may be set to a sentinel value
 * indicating it is the end of the list. All subsequent slots are where
 * peripheral drivers are tracked. This makes it very easy to determine whether
 * the user registered a callback and to make sure we run that first. */
static cyhal_syspm_callback_data_t* _cyhal_syspm_callback_ptr = CYHAL_SYSPM_END_OF_LIST;
static cyhal_syspm_callback_data_t* _cyhal_syspm_peripheral_callback_ptr = CYHAL_SYSPM_END_OF_LIST;

static uint16_t _cyhal_deep_sleep_lock = 0;

static uint32_t _cyhal_syspm_supply_voltages[((size_t)CYHAL_VOLTAGE_SUPPLY_MAX) + 1] = { 0 };

static bool _cyhal_systick_disable = false;
static bool _cyhal_disable_systick_before_sleep_deepsleep = false;

#define SYSPM_CALLBACK_ORDER    (10u)

static cy_en_syspm_status_t _cyhal_syspm_common_cb(cy_stc_syspm_callback_params_t *callbackParams, cy_en_syspm_callback_mode_t mode);
static cy_stc_syspm_callback_t cyhal_syspm_cb_sleep =
{
    .callback = _cyhal_syspm_common_cb,
    .type = CY_SYSPM_SLEEP,
    .skipMode = 0,
    .callbackParams = &_cyhal_syspm_cb_params_sleep,
    .prevItm = NULL,
    .nextItm = NULL,
    .order = SYSPM_CALLBACK_ORDER,
};
static cy_stc_syspm_callback_t _cyhal_syspm_cb_deepsleep =
{
    .callback = _cyhal_syspm_common_cb,
    .type = CY_SYSPM_DEEPSLEEP,
    .skipMode = 0,
    .callbackParams = &_cyhal_syspm_cb_params_deepsleep,
    .prevItm = NULL,
    .nextItm = NULL,
    .order = SYSPM_CALLBACK_ORDER,
};
static cy_stc_syspm_callback_t _cyhal_syspm_cb_hibernate =
{
    .callback = _cyhal_syspm_common_cb,
    .type = CY_SYSPM_HIBERNATE,
    .skipMode = 0,
    .callbackParams = &_cyhal_syspm_cb_params_hibernate,
    .prevItm = NULL,
    .nextItm = NULL,
    .order = SYSPM_CALLBACK_ORDER,
};

#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
static cy_stc_syspm_callback_t _cyhal_syspm_cb_lp =
{
    .callback = _cyhal_syspm_common_cb,
    .type = CY_SYSPM_LP,
    .skipMode = 0,
    .callbackParams = &_cyhal_syspm_cb_params_lp,
    .prevItm = NULL,
    .nextItm = NULL,
    .order = SYSPM_CALLBACK_ORDER,
};
static cy_stc_syspm_callback_t _cyhal_syspm_cb_ulp =
{
    .callback = _cyhal_syspm_common_cb,
    .type = CY_SYSPM_ULP,
    .skipMode = 0,
    .callbackParams = &_cyhal_syspm_cb_params_ulp,
    .prevItm = NULL,
    .nextItm = NULL,
    .order = SYSPM_CALLBACK_ORDER,
};
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */

static cyhal_syspm_callback_data_t* _cyhal_syspm_call_all_pm_callbacks(
    cyhal_syspm_callback_data_t* entry, bool* allow, cyhal_syspm_callback_state_t state, cyhal_syspm_callback_mode_t mode)
{
    while(entry != CYHAL_SYSPM_END_OF_LIST)
    {
        if (entry->callback != NULL &&
            (entry->states & state) == state &&
            (entry->ignore_modes & mode) != mode)
        {
            *allow = entry->callback(state, mode, entry->args) || mode != CYHAL_SYSPM_CHECK_READY;
            if (!(*allow))
            {
                // Do not increment pointer so that backtracking stop at the correct location
                break;
            }
        }
        entry = entry->next;
    }
    return entry;
}

static void _cyhal_syspm_backtrack_all_pm_callbacks(cyhal_syspm_callback_data_t* start, cyhal_syspm_callback_data_t* end, cyhal_syspm_callback_state_t state)
{
    while(start != end)
    {
        if (start->callback != NULL &&
            (start->states & state) == state &&
            (start->ignore_modes & CYHAL_SYSPM_CHECK_FAIL) != CYHAL_SYSPM_CHECK_FAIL)
        {
            start->callback(state, CYHAL_SYSPM_CHECK_FAIL, start->args);
        }
        start = start->next;
    }
}

static cy_en_syspm_status_t _cyhal_syspm_common_cb(cy_stc_syspm_callback_params_t *callbackParams, cy_en_syspm_callback_mode_t mode)
{
    // The PDL function that wrap around this callback enters critical section, this function does not need to enter critical section.
    cyhal_syspm_callback_state_t state = (cyhal_syspm_callback_state_t)(uintptr_t)callbackParams->context;
    if ((state == CYHAL_SYSPM_CB_CPU_DEEPSLEEP) && (mode == CY_SYSPM_CHECK_READY) && (_cyhal_deep_sleep_lock != 0))
    {
        return CY_SYSPM_FAIL;
    }
    else
    {
        cyhal_syspm_callback_mode_t hal_mode = _cyhal_utils_convert_pdltohal_pm_mode(mode);
        bool allow = true;

        cyhal_syspm_callback_data_t *first, *second;
        if (hal_mode == CYHAL_SYSPM_CHECK_FAIL || hal_mode == CYHAL_SYSPM_AFTER_TRANSITION)
        {
            first = _cyhal_syspm_peripheral_callback_ptr;
            second = _cyhal_syspm_callback_ptr;
        }
        else
        {
            second = _cyhal_syspm_peripheral_callback_ptr;
            first = _cyhal_syspm_callback_ptr;
        }

        cyhal_syspm_callback_data_t* first_current = _cyhal_syspm_call_all_pm_callbacks(first, &allow, state, hal_mode);
        cyhal_syspm_callback_data_t* second_current = allow
            ? _cyhal_syspm_call_all_pm_callbacks(second, &allow, state, hal_mode)
            : second;

        if (!allow && (CYHAL_SYSPM_CHECK_READY == hal_mode))
        {
            _cyhal_syspm_backtrack_all_pm_callbacks(second, second_current, state);
            _cyhal_syspm_backtrack_all_pm_callbacks(first, first_current, state);
        }

#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
        if (state == CYHAL_SYSPM_CB_SYSTEM_LOW && hal_mode == CYHAL_SYSPM_BEFORE_TRANSITION)
        {
            uint32_t hfclk_freq_mhz = Cy_SysClk_ClkHfGetFrequency(0) / 1000000;
            Cy_SysLib_SetWaitStates(true, hfclk_freq_mhz);
        }

        if (state == CYHAL_SYSPM_CB_SYSTEM_NORMAL && hal_mode == CYHAL_SYSPM_AFTER_TRANSITION)
        {
            uint32_t hfclk_freq_mhz = Cy_SysClk_ClkHfGetFrequency(0) / 1000000;
            Cy_SysLib_SetWaitStates(false, hfclk_freq_mhz);
        }
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */

        if (allow && ((state == CYHAL_SYSPM_CB_CPU_DEEPSLEEP) || (state == CYHAL_SYSPM_CB_CPU_SLEEP)))
        {
            if (mode == CY_SYSPM_BEFORE_TRANSITION)
            {
                _cyhal_systick_disable = _cyhal_syspm_is_systick_enabled() && _cyhal_disable_systick_before_sleep_deepsleep;
                if (_cyhal_systick_disable)
                {
                    _cyhal_syspm_disable_systick();
                }
            }
            else if (mode == CY_SYSPM_AFTER_TRANSITION)
            {
                if (_cyhal_systick_disable)
                {
                    _cyhal_syspm_enable_systick();
                }
            }
        }

        return allow ? CY_SYSPM_SUCCESS : CY_SYSPM_FAIL;
    }
}

static void _cyhal_syspm_remove_callback_from_list(cyhal_syspm_callback_data_t **list, cyhal_syspm_callback_data_t *remove)
{
    uint32_t intr_status = cyhal_system_critical_section_enter();
    while(*list != CYHAL_SYSPM_END_OF_LIST)
    {
        if (*list == remove)
        {
            *list = remove->next;
            remove->next = NULL;
            break;
        }
        list = &((*list)->next);
    }
    cyhal_system_critical_section_exit(intr_status);
}

static bool _cyhal_syspm_is_registered(cyhal_syspm_callback_data_t *list, cyhal_syspm_callback_data_t *callback)
{
    CY_UNUSED_PARAMETER(list);
    // If callback->next is NULL it must not be registered since all registered
    // next ptrs in the list must point to the next callback or be equal to
    // CYHAL_SYSPM_END_OF_LIST
    if(callback->next == NULL)
        return false;
    else
        return true;
}

void _cyhal_syspm_register_peripheral_callback(cyhal_syspm_callback_data_t *callback_data)
{
    CY_ASSERT(callback_data != NULL);
    uint32_t intr_status = cyhal_system_critical_section_enter();
    if(!_cyhal_syspm_is_registered(_cyhal_syspm_peripheral_callback_ptr, callback_data))
    {
        callback_data->next = _cyhal_syspm_peripheral_callback_ptr;
        _cyhal_syspm_peripheral_callback_ptr = callback_data;
    }
    cyhal_system_critical_section_exit(intr_status);
}

void _cyhal_syspm_unregister_peripheral_callback(cyhal_syspm_callback_data_t *callback_data)
{
    _cyhal_syspm_remove_callback_from_list(&_cyhal_syspm_peripheral_callback_ptr, callback_data);
}


/******************************************************************************
 ******************************** Public APIs *********************************
 *****************************************************************************/

cy_rslt_t cyhal_syspm_init(void)
{
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
    /* Check the IO status. If current status is frozen, unfreeze the system. */
    if (Cy_SysPm_GetIoFreezeStatus())
    {
        /* Unfreeze the system */
        Cy_SysPm_IoUnfreeze();
    }
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */

    cy_rslt_t rslt = CY_RSLT_SUCCESS;
    if (!Cy_SysPm_RegisterCallback(&cyhal_syspm_cb_sleep)
        || !Cy_SysPm_RegisterCallback(&_cyhal_syspm_cb_deepsleep)
        || !Cy_SysPm_RegisterCallback(&_cyhal_syspm_cb_hibernate)
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
        || !Cy_SysPm_RegisterCallback(&_cyhal_syspm_cb_lp)
        || !Cy_SysPm_RegisterCallback(&_cyhal_syspm_cb_ulp)
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */
    )
        {
            rslt = CYHAL_SYSPM_RSLT_INIT_ERROR;
        }
    return rslt;
}

cy_rslt_t cyhal_syspm_hibernate(cyhal_syspm_hibernate_source_t source)
{
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
    /* Defines for mapping hal hibernate sources to pdl */
    static const uint32_t source_map[] =
    {
        0u,                                        // Default value, no wakeup
        (uint32_t)CY_SYSPM_HIBERNATE_LPCOMP0_LOW,  // CYHAL_SYSPM_HIBERNATE_LPCOMP0_LOW
        (uint32_t)CY_SYSPM_HIBERNATE_LPCOMP0_HIGH, // CYHAL_SYSPM_HIBERNATE_LPCOMP0_HIGH
        (uint32_t)CY_SYSPM_HIBERNATE_LPCOMP1_LOW,  // CYHAL_SYSPM_HIBERNATE_LPCOMP1_LOW
        (uint32_t)CY_SYSPM_HIBERNATE_LPCOMP1_HIGH, // CYHAL_SYSPM_HIBERNATE_LPCOMP1_HIGH
        (uint32_t)CY_SYSPM_HIBERNATE_RTC_ALARM,    // CYHAL_SYSPM_HIBERNATE_RTC_ALARM
        (uint32_t)CY_SYSPM_HIBERNATE_WDT,          // CYHAL_SYSPM_HIBERNATE_WDT
        (uint32_t)CY_SYSPM_HIBERNATE_PIN0_LOW,     // CYHAL_SYSPM_HIBERNATE_PINA_LOW
        (uint32_t)CY_SYSPM_HIBERNATE_PIN0_HIGH,    // CYHAL_SYSPM_HIBERNATE_PINA_HIGH
        (uint32_t)CY_SYSPM_HIBERNATE_PIN1_LOW,     // CYHAL_SYSPM_HIBERNATE_PINB_LOW
        (uint32_t)CY_SYSPM_HIBERNATE_PIN1_HIGH,    // CYHAL_SYSPM_HIBERNATE_PINB_HIGH
    };

    Cy_SysPm_SetHibernateWakeupSource(_cyhal_utils_convert_flags(source_map, sizeof(source_map) / sizeof(uint32_t), (uint32_t)source));
    return Cy_SysPm_SystemEnterHibernate();
#elif defined(COMPONENT_CAT2)
    CY_UNUSED_PARAMETER(source);
    return CYHAL_SYSPM_RSLT_ERR_NOT_SUPPORTED;
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */
}

cy_rslt_t cyhal_syspm_set_system_state(cyhal_syspm_system_state_t state)
{
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
    cy_rslt_t rslt;

    /* The wait states are changed in the common syspm handler after
     * state change is allowed and all handlers are called to take into
     * account any frequency change that might happen as a part of the
     * power management handlers
     */
    switch (state)
    {
        case CYHAL_SYSPM_SYSTEM_NORMAL:
            rslt = Cy_SysPm_SystemEnterLp();
            break;
        case CYHAL_SYSPM_SYSTEM_LOW:
            rslt = Cy_SysPm_SystemEnterUlp();
            break;
        default:
            /* Should never get here */
            CY_ASSERT(false);
            rslt = CYHAL_SYSPM_RSLT_BAD_ARGUMENT;
            break;
    }
    return rslt;
#elif defined(COMPONENT_CAT2)
    CY_UNUSED_PARAMETER(state);
    return CYHAL_SYSPM_RSLT_ERR_NOT_SUPPORTED;
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */
}

void cyhal_syspm_register_callback(cyhal_syspm_callback_data_t *callback_data)
{
    CY_ASSERT(callback_data != NULL);
    uint32_t intr_status = cyhal_system_critical_section_enter();
    if(!_cyhal_syspm_is_registered(_cyhal_syspm_callback_ptr, callback_data))
    {
        callback_data->next = _cyhal_syspm_callback_ptr;
        _cyhal_syspm_callback_ptr = callback_data;
    }
    cyhal_system_critical_section_exit(intr_status);
}

void cyhal_syspm_unregister_callback(cyhal_syspm_callback_data_t *callback_data)
{
    _cyhal_syspm_remove_callback_from_list(&_cyhal_syspm_callback_ptr, callback_data);
}

void cyhal_syspm_lock_deepsleep(void)
{
    CY_ASSERT(_cyhal_deep_sleep_lock != USHRT_MAX);
    uint32_t intr_status = cyhal_system_critical_section_enter();
    if (_cyhal_deep_sleep_lock < USHRT_MAX)
    {
        _cyhal_deep_sleep_lock++;
    }
    cyhal_system_critical_section_exit(intr_status);
}

void cyhal_syspm_unlock_deepsleep(void)
{
    CY_ASSERT(_cyhal_deep_sleep_lock != 0U);
    uint32_t intr_status = cyhal_system_critical_section_enter();
    if (_cyhal_deep_sleep_lock > 0U)
    {
        _cyhal_deep_sleep_lock--;
    }
    cyhal_system_critical_section_exit(intr_status);
}

cy_rslt_t cyhal_syspm_tickless_sleep_deepsleep(cyhal_lptimer_t *obj, uint32_t desired_ms, uint32_t *actual_ms, bool deep_sleep)
{
#if defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B)
    CY_ASSERT(obj != NULL);
    uint32_t initial_ticks;
    uint32_t sleep_ticks;
    cyhal_lptimer_info_t timer_info;

    *actual_ms = 0;
    cy_rslt_t result = CY_RSLT_SUCCESS;

    if(desired_ms > 0)
    {
        cyhal_lptimer_get_info(obj, &timer_info);

        //lp_ticks = ms * lp_rate_khz
        sleep_ticks = ((desired_ms - 1) * timer_info.frequency_hz) / _CYHAL_HZ_TO_KHZ_CONVERSION_FACTOR;
        initial_ticks = cyhal_lptimer_read(obj);

        result = cyhal_lptimer_set_delay(obj, sleep_ticks);
        if(result == CY_RSLT_SUCCESS)
        {
            /* Disabling and enabling the system timer is handled in _cyhal_syspm_common_cb in order
             * to prevent loosing kernel ticks when sleep/deep-sleep is rejected causing the time spent
             * in the callback handlers to check if the system can make the sleep/deep-sleep transition
             * to be not accounted for.
             */
            _cyhal_disable_systick_before_sleep_deepsleep = true;
            cyhal_lptimer_enable_event(obj, CYHAL_LPTIMER_COMPARE_MATCH, CYHAL_ISR_PRIORITY_DEFAULT, true);

            result = deep_sleep ? cyhal_syspm_deepsleep() : cyhal_syspm_sleep();
            if(result == CY_RSLT_SUCCESS)
            {
                uint32_t final_ticks = cyhal_lptimer_read(obj);
                uint32_t ticks = (final_ticks < initial_ticks)
                                ? (timer_info.max_counter_value - initial_ticks) + final_ticks
                                : final_ticks - initial_ticks;
                *actual_ms = (ticks * _CYHAL_HZ_TO_KHZ_CONVERSION_FACTOR) / timer_info.frequency_hz;
            }

            cyhal_lptimer_enable_event(obj, CYHAL_LPTIMER_COMPARE_MATCH, CYHAL_ISR_PRIORITY_DEFAULT, false);
            _cyhal_disable_systick_before_sleep_deepsleep = false;
        }
    }

    return result;
#elif defined(COMPONENT_CAT2)
    CY_UNUSED_PARAMETER(obj);
    CY_UNUSED_PARAMETER(desired_ms);
    CY_UNUSED_PARAMETER(actual_ms);
    CY_UNUSED_PARAMETER(deep_sleep);
    return CYHAL_SYSPM_RSLT_ERR_NOT_SUPPORTED;
#endif /* defined(COMPONENT_CAT1A) || defined(COMPONENT_CAT1B) */

}

void cyhal_syspm_set_supply_voltage(cyhal_syspm_voltage_supply_t supply, uint32_t mvolts)
{
    CY_ASSERT((size_t)supply <= CYHAL_VOLTAGE_SUPPLY_MAX);
    _cyhal_syspm_supply_voltages[(size_t)supply] = mvolts;
}

uint32_t cyhal_syspm_get_supply_voltage(cyhal_syspm_voltage_supply_t supply)
{
    CY_ASSERT((size_t)supply <= CYHAL_VOLTAGE_SUPPLY_MAX);
    return _cyhal_syspm_supply_voltages[(size_t)supply];
}