// Copyright 2020-2021 Beken
//
// 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 <common/bk_include.h>
#include <common/bk_compiler.h>
#include <os/mem.h>
#include "icu_driver.h"
#include "timer_driver.h"
#include "timer_hal.h"
#include <driver/timer.h>
#include "clock_driver.h"
#include "power_driver.h"
#include <driver/int.h>
#include "sys_driver.h"
#include "timer_driver.h"

#if (SOC_TIMER_INTERRUPT_NUM > 1)
static void timer1_isr(void) __BK_SECTION(".itcm");
#endif
static void timer_isr(void) __BK_SECTION(".itcm");

typedef struct {
    timer_hal_t hal;
#if CONFIG_TIMER_PM_CB_SUPPORT
    uint32_t pm_backup[SOC_TIMER_GROUP_NUM-1][TIMER_PM_BACKUP_REG_NUM];
    uint8_t pm_bakeup_is_valid;
#endif
} timer_driver_t;

static timer_driver_t s_timer = {0};
static timer_isr_t s_timer_isr[SOC_TIMER_CHAN_NUM_PER_UNIT] = {NULL};
static bool s_timer_driver_is_init = false;

#define TIMER_RETURN_ON_NOT_INIT() do {\
        if (!s_timer_driver_is_init) {\
            return BK_ERR_TIMER_NOT_INIT;\
        }\
    } while(0)

#define TIMER_RETURN_ON_INVALID_ID(id) do {\
        if ((id) >= SOC_TIMER_CHAN_NUM_PER_UNIT) {\
            return BK_ERR_TIMER_ID;\
        }\
    } while(0)

#define TIMER_RETURN_ON_IS_RUNNING(id, status) do {\
        if ((status) & BIT((id))) {\
            return BK_ERR_TIMER_IS_RUNNING;\
        }\
    } while(0)

#define TIMER_RETURN_TIMER_ID_IS_ERR(id) do {\
        if ((~CONFIG_TIMER_SUPPORT_ID_BITS) & BIT((id))) {\
            return BK_ERR_TIMER_ID_ON_DEFCONFIG;\
        }\
    } while(0)

#if CONFIG_TIMER_PM_CB_SUPPORT
#define TIMER_PM_CHECK_RESTORE(id) do {\
    uint32_t group_id;\
    GLOBAL_INT_DECLARATION();\
    GLOBAL_INT_DISABLE();\
    group_id = id / SOC_TIMER_CHAN_NUM_PER_GROUP;\
    switch (group_id){\
    case 0:\
        break;\
    case 1:\
        if (bk_pm_module_lv_sleep_state_get(PM_DEV_ID_TIMER_1)) {\
            bk_pm_module_vote_power_ctrl(PM_POWER_SUB_MODULE_NAME_BAKP_TIMER1, PM_POWER_MODULE_STATE_ON);\
            timer_pm_restore(0, (void *)id);\
            bk_pm_module_lv_sleep_state_clear(PM_DEV_ID_TIMER_1);\
            }\
        break;\
    default:\
        break;\
    }\
    GLOBAL_INT_RESTORE();\
}while(0)
#else
#define TIMER_PM_CHECK_RESTORE(id)
#endif

#if (CONFIG_SYSTEM_CTRL)
static void timer_clock_select(timer_id_t id, timer_src_clk_t mode)
{
	uint32_t group_index = 0;

	group_index = id / SOC_TIMER_CHAN_NUM_PER_GROUP;
	switch(group_index)
	{
		case 0:
			sys_drv_timer_select_clock(SYS_SEL_TIMER0, mode);
			break;
		case 1:
			sys_drv_timer_select_clock(SYS_SEL_TIMER1, mode);
			break;
		default:
			break;
	}
}

static void timer_clock_enable(timer_id_t id)
{
	uint32_t group_index = 0;

	group_index = id / SOC_TIMER_CHAN_NUM_PER_GROUP;
	switch(group_index)
	{
		case 0:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_1, CLK_PWR_CTRL_PWR_UP);
			break;
		case 1:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_2, CLK_PWR_CTRL_PWR_UP);
			break;
		case 2:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_3, CLK_PWR_CTRL_PWR_UP);
			break;
		default:
			break;
	}
}

static void timer_clock_disable(timer_id_t id)
{
	uint32_t group_index = 0;

	group_index = id / SOC_TIMER_CHAN_NUM_PER_GROUP;
	switch(group_index)
	{
		case 0:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_1, CLK_PWR_CTRL_PWR_DOWN);
			break;
		case 1:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_2, CLK_PWR_CTRL_PWR_DOWN);
			break;
		case 2:
			sys_drv_dev_clk_pwr_up(CLK_PWR_ID_TIMER_3, CLK_PWR_CTRL_PWR_DOWN);
			break;
		default:
			break;
	}
}

static void timer_interrupt_enable(timer_id_t id)
{
	uint32_t group_index = 0;

	group_index = id / SOC_TIMER_CHAN_NUM_PER_GROUP;
	switch(group_index)
	{
		case 0:
			sys_drv_int_enable(TIMER_INTERRUPT_CTRL_BIT);
			break;

		case 1:
			sys_drv_int_enable(TIMER1_INTERRUPT_CTRL_BIT);
			break;
		default:
			break;
	}
}
#endif

static void timer_chan_init_common(timer_id_t timer_id)
{
#if (CONFIG_SYSTEM_CTRL)
	timer_clock_select(timer_id, TIMER_SCLK_XTAL);
	timer_clock_enable(timer_id);
#else
	power_pwr_up_timer(timer_id);
#endif
}

static void timer_chan_deinit_common(timer_id_t timer_id)
{
    timer_hal_stop_common(&s_timer.hal, timer_id);
    timer_hal_reset_config_to_default(&s_timer.hal, timer_id);
#if (CONFIG_SYSTEM_CTRL)
	timer_clock_disable(timer_id);
#else
	power_pwr_down_timer(timer_id);
#endif
}

static void timer_chan_enable_interrupt_common(timer_id_t timer_id)
{
#if (CONFIG_SYSTEM_CTRL)
	timer_interrupt_enable(timer_id);
#else
    icu_enable_timer_interrupt();
#endif
    timer_hal_enable_interrupt(&s_timer.hal, timer_id);
}

#if CONFIG_TIMER_PM_CB_SUPPORT
static bk_err_t timer_pm_backup(uint64_t sleep_time, void *args)
{
    uint32_t group_id = (uint32_t)args;
    TIMER_RETURN_ON_NOT_INIT();

    if (group_id > SOC_TIMER_GROUP_NUM - 1)
        return BK_FAIL;

    if (group_id < 1)
        return BK_OK;

    for (group_id; group_id < SOC_TIMER_GROUP_NUM; group_id++ )
    {
        if (!s_timer.pm_bakeup_is_valid)
        {
            timer_hal_backup(&s_timer.hal, group_id, s_timer.pm_backup[group_id - 1]);
            s_timer.pm_bakeup_is_valid = 1;
        }
    }

    return BK_OK;
}

static bk_err_t timer_pm_restore(uint64_t sleep_time, void *args)
{
    uint32_t group_id = (uint32_t)args;
    TIMER_RETURN_ON_NOT_INIT();

    if (group_id > SOC_TIMER_GROUP_NUM - 1)
        return BK_FAIL;

    if (group_id < 1)
        return BK_OK;

    for (group_id; group_id < SOC_TIMER_GROUP_NUM; group_id++ )
    {
        if (s_timer.pm_bakeup_is_valid)
        {
            timer_hal_restore(&s_timer.hal, group_id, s_timer.pm_backup[group_id - 1]);
            s_timer.pm_bakeup_is_valid = 0;
        }
    }

    return BK_OK;
}

static void timer_register_lvsleep_cb(uint32_t group_id)
{
    pm_cb_conf_t timer_enter_config = {
        .cb = (pm_cb)timer_pm_backup,
        .args = (void *)group_id
        };

    switch(group_id)
    {
        case 0:
            break;  // timer0 of BK7236 is in AON domain
        case 1:
            bk_pm_module_vote_power_ctrl(PM_POWER_SUB_MODULE_NAME_BAKP_TIMER1, PM_POWER_MODULE_STATE_ON);
            bk_pm_sleep_register_cb(PM_MODE_LOW_VOLTAGE, PM_DEV_ID_TIMER_1, &timer_enter_config, NULL);
            bk_pm_module_lv_sleep_state_clear(PM_DEV_ID_TIMER_1);
            break;
        default:
            break;
    }
}

static void timer_unregister_lvsleep_cb(uint32_t group_id)
{
    switch(group_id)
    {
        case 0:
            break;
        case 1:
            bk_pm_sleep_unregister_cb(PM_MODE_LOW_VOLTAGE, PM_DEV_ID_TIMER_1, true, true);
            bk_pm_module_vote_power_ctrl(PM_POWER_SUB_MODULE_NAME_BAKP_TIMER1, PM_POWER_MODULE_STATE_OFF);
            break;
        default:
            break;
    }
}
#endif

static void timer_isr(void) __BK_SECTION(".itcm");

bk_err_t bk_timer_driver_init(void)
{
    if (s_timer_driver_is_init) {
        return BK_OK;
    }

    os_memset(&s_timer, 0, sizeof(s_timer));
    os_memset(&s_timer_isr, 0, sizeof(s_timer_isr));

#if CONFIG_TIMER_PM_CB_SUPPORT
    for(uint32_t group_id = 1; group_id < SOC_TIMER_GROUP_NUM; group_id++)
    {
        timer_register_lvsleep_cb(group_id);
    }
#endif

    bk_int_isr_register(INT_SRC_TIMER, timer_isr, NULL);
#if (SOC_TIMER_INTERRUPT_NUM > 1)
    bk_int_isr_register(INT_SRC_TIMER1, timer1_isr, NULL);
#endif
    timer_hal_init(&s_timer.hal);

    s_timer_driver_is_init = true;

    return BK_OK;
}

bk_err_t bk_timer_driver_deinit(void)
{
    if (!s_timer_driver_is_init) {
        return BK_OK;
    }

#if CONFIG_TIMER_PM_CB_SUPPORT
    for (uint32_t group_id = 1; group_id < SOC_TIMER_GROUP_NUM; group_id++)
    {
        timer_unregister_lvsleep_cb(group_id);
    }
#endif

    for (int chan = 0; chan < SOC_TIMER_CHAN_NUM_PER_UNIT; chan++) {
        timer_chan_deinit_common(chan);
    }

    s_timer_driver_is_init = false;

    return BK_OK;
}

extern void delay(int num);//TODO fix me

bk_err_t bk_timer_start_without_callback(timer_id_t timer_id, uint32_t time_ms)
{
    uint32_t en_status = 0;

#if CONFIG_TIMER_US
	if (timer_id == TIMER_ID0) {
		TIMER_LOGE("timer0 is reserved for us timer!\r\n");
	}
#endif

    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_chan_init_common(timer_id);

#if !CONFIG_RTC_TIMER_PRECISION_TEST
    timer_chan_enable_interrupt_common(timer_id);
#endif

    en_status = timer_hal_get_enable_status(&s_timer.hal);
    if (en_status & BIT(timer_id)) {
        TIMER_LOGD("timer(%d) is running, stop it\r\n", timer_id);
        timer_hal_disable(&s_timer.hal, timer_id);
        /* Delay to fix the bug that timer counter becomes bigger than
         * timer period. Once timer counter becomes bigger than timer period,
         * the timer will never timeout, or takes very very long time to
         * timeout.
         *
         * This issue is firstly observed in HOS tick timer. HOS restarts
         * the tick timer with different time_ms(timer period) again and again,
         * without the delay, the tick timer counter becomes bigger than timer
         * period very soon, then the tick interrupt will never be triggered.
         * */
        delay(4);
    }

    timer_hal_init_timer(&s_timer.hal, timer_id, time_ms, TIMER_UNIT_MS);
    timer_hal_start_common(&s_timer.hal, timer_id);

    return BK_OK;
}

bk_err_t bk_timer_start(timer_id_t timer_id, uint32_t time_ms, timer_isr_t callback)
{
#if CONFIG_TIMER_US
	if (timer_id == TIMER_ID0) {
		TIMER_LOGE("timer0 is reserved for us timer!\r\n");
	}
#endif

#if CONFIG_TIMER_SUPPORT_ID_BITS
    TIMER_RETURN_TIMER_ID_IS_ERR(timer_id);
#endif
    BK_LOG_ON_ERR(bk_timer_start_without_callback(timer_id, time_ms));

    if (timer_id < SOC_TIMER_CHAN_NUM_PER_UNIT){
        s_timer_isr[timer_id] = callback;
    }

    return BK_OK;
}

bk_err_t bk_timer_stop(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
#if CONFIG_TIMER_SUPPORT_ID_BITS
    TIMER_RETURN_TIMER_ID_IS_ERR(timer_id);
#endif
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_hal_stop_common(&s_timer.hal, timer_id);

    return BK_OK;
}

bk_err_t bk_timer_cancel(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
#if CONFIG_TIMER_SUPPORT_ID_BITS
    TIMER_RETURN_TIMER_ID_IS_ERR(timer_id);
#endif
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_ll_reset_config_to_default(s_timer.hal.hw, timer_id);

    s_timer_isr[timer_id] = NULL;

    return BK_OK;
}

uint32_t bk_timer_get_cnt(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    return timer_hal_get_count(&s_timer.hal, timer_id);
}

bk_err_t bk_timer_enable(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_hal_enable(&s_timer.hal, timer_id);
    return BK_OK;
}

bk_err_t bk_timer_disable(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_hal_disable(&s_timer.hal, timer_id);
    return BK_OK;
}

uint32_t bk_timer_get_period(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    return timer_hal_get_end_count(&s_timer.hal, timer_id);
}

uint32_t bk_timer_get_enable_status(void)
{
    TIMER_RETURN_ON_NOT_INIT();
    return timer_hal_get_enable_status(&s_timer.hal);
}

bool bk_timer_is_interrupt_triggered(timer_id_t timer_id)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    uint32_t int_status = timer_hal_get_interrupt_status(&s_timer.hal);
    return timer_hal_is_interrupt_triggered(&s_timer.hal, timer_id, int_status);
}

uint32_t timer_clear_isr_status(void)
{
	uint32_t int_status;
    timer_hal_t *hal = &s_timer.hal;

    int_status = timer_hal_get_interrupt_status(hal);
    timer_hal_clear_interrupt_status(hal, int_status);

	return int_status;
}

static void timer_isr(void)
{
    uint32_t int_status;
    timer_hal_t *hal = &s_timer.hal;

    int_status = timer_clear_isr_status();

#if (SOC_TIMER_INTERRUPT_NUM > 1)
     for(int chan = 0; chan < SOC_TIMER_CHAN_NUM_PER_GROUP; chan++) {
#else
    for(int chan = 0; chan < SOC_TIMER_CHAN_NUM_PER_UNIT; chan++) {
#endif
        if(timer_hal_is_interrupt_triggered(hal, chan, int_status)) {
            if(s_timer_isr[chan]) {
                s_timer_isr[chan](chan);
            }
        }
    }
}

#if (SOC_TIMER_INTERRUPT_NUM > 1)
static void timer1_isr(void)
{
    uint32_t int_status;
    timer_hal_t *hal = &s_timer.hal;

    int_status = timer_clear_isr_status();

    for(int chan = SOC_TIMER_CHAN_NUM_PER_GROUP; chan < SOC_TIMER_CHAN_NUM_PER_UNIT; chan++) {
        if(timer_hal_is_interrupt_triggered(hal, chan, int_status)) {
            if(s_timer_isr[chan]) {
                s_timer_isr[chan](chan);
            }
        }
    }
}
#endif

uint64_t bk_timer_get_time(timer_id_t timer_id, uint32_t div, uint32_t last_count, timer_value_unit_t unit_type)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

    TIMER_PM_CHECK_RESTORE(timer_id);

    uint64_t current_time = 0;
    uint64_t unit_factor = 1;

    uint64_t current_count = timer_hal_get_count(&s_timer.hal, timer_id) + last_count;

    if (div == 0) {
        div = 1;
    }

#if (CONFIG_SYSTEM_CTRL)
	uint32_t group_index = 0;
	uint32_t timer_clock = TIMER_SCLK_XTAL;

	group_index = timer_id / SOC_TIMER_CHAN_NUM_PER_GROUP;
	switch(group_index)
	{
		case 0:
			timer_clock = sys_hal_timer_select_clock_get(SYS_SEL_TIMER0);
			break;
		case 1:
			timer_clock = sys_hal_timer_select_clock_get(SYS_SEL_TIMER1);
			break;
		default:
			break;
	}

    unit_factor = (unit_type == TIMER_UNIT_MS) ? 1 : 1000;

	if(timer_clock == TIMER_SCLK_XTAL) {
        current_time = unit_factor * current_count * (uint64_t)div / TIMER_CLOCK_FREQ_26M;
	} else {
        current_time = unit_factor * current_count * (uint64_t)div / TIMER_CLOCK_FREQ_32K;
	}

#else
    if (timer_id < SOC_TIMER_CHAN_NUM_PER_GROUP) {
        current_time = unit_factor * current_count * div / TIMER_CLOCK_FREQ_26M;
    } else {
        current_time = unit_factor * current_count * div / TIMER_CLOCK_FREQ_32K;
    }
#endif

    return current_time;
}

bk_err_t bk_timer_delay_with_callback(timer_id_t timer_id, uint64_t time_us, timer_isr_t callback)
{
    TIMER_RETURN_ON_NOT_INIT();
    TIMER_RETURN_ON_INVALID_ID(timer_id);

#if CONFIG_TIMER_SUPPORT_ID_BITS
    TIMER_RETURN_TIMER_ID_IS_ERR(timer_id);
#endif
    uint64_t current_count = 0;
    uint64_t delta_count = 0;
    uint64_t end_count = 0;

    TIMER_PM_CHECK_RESTORE(timer_id);

    timer_chan_init_common(timer_id);
    timer_chan_enable_interrupt_common(timer_id);

    current_count = timer_hal_get_count(&s_timer.hal, timer_id);
    delta_count = timer_hal_cal_end_count(timer_id, time_us, 1, TIMER_UNIT_US);
    end_count = current_count + delta_count;

    if(end_count > 0xFFFFFFFFFFFFFFFF){
        end_count = 0xFFFFFFFFFFFFFFFF;
    }

    timer_ll_set_end_count(s_timer.hal.hw, timer_id, (uint32_t)end_count);
    timer_ll_set_clk_div(s_timer.hal.hw, timer_id, 0);
    timer_ll_clear_chan_interrupt_status(s_timer.hal.hw, timer_id);

    timer_hal_start_common(&s_timer.hal, timer_id);

    s_timer_isr[timer_id] = callback;

    return BK_OK;
}

#if CONFIG_TIMER_US
__IRAM_SEC void bk_timer_delay_us(uint32_t us)
{
	timer_hal_delay_us(us);
}
#endif