/*
 * Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
 * its subsidiaries and affiliates (collectly called MKSEMI).
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into an MKSEMI
 *    integrated circuit in a product or a software update for such product,
 *    must reproduce the above copyright notice, this list of conditions and
 *    the following disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * 3. Neither the name of MKSEMI nor the names of its contributors may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    MKSEMI integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be
 *    reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "mk_misc.h"
#include "mk_dual_timer.h"
#include "mk_clock.h"
#include "mk_trace.h"
#include "mk_sleep_timer.h"
#include "mk_reset.h"
// #include "board.h"

uint32_t mk_chip_id(void)
{
    return REG_READ(0x4000000C);
}

void mk_chip_uuid(uint8_t *uuid)
{
    ASSERT(uuid, "uuid is null");
    uint8_t y = REG_READ_BYTE(0x40010074);
    uint8_t x = REG_READ_BYTE(0x40010075);
    uint8_t w = REG_READ_BYTE(0x40010076);
    uint8_t l = REG_READ_BYTE(0x4001007F) - 'A';

    uuid[0] = ((l << 3) & 0x80) | (y & 0x7F);
    uuid[1] = ((l << 4) & 0x80) | (x & 0x7f);
    uuid[2] = ((l << 5) & 0xE0) | (w & 0x1f);
    uuid[3] = REG_READ_BYTE(0x4001007A);
    uuid[4] = REG_READ_BYTE(0x4001007B);
    uuid[5] = REG_READ_BYTE(0x4001007C);
    uuid[6] = REG_READ_BYTE(0x4001007D);
    uuid[7] = REG_READ_BYTE(0x4001007E);
}

/* BOD */

static const struct BOD_BOR_CFG_T default_bod_cfg = {
    .level = BOD_BOR_TH_LVL0,
    .hyst = BOD_BOR_HYST_LVL0,
};

void bod_open(const struct BOD_BOR_CFG_T *cfg)
{
    const struct BOD_BOR_CFG_T *config = (cfg == NULL) ? &default_bod_cfg : cfg;

    // enable BOD
    uint32_t bod_bor_cfg = SYSCON->BOD_BOR;
    bod_bor_cfg &= 0xFF00FFFF;
    bod_bor_cfg |= SYSCON_BOD_EN_MSK | SYSCON_BOD_TH_SEL(config->level) | SYSCON_BOD_HYST_SEL(config->hyst);
    SYSCON->BOD_BOR = bod_bor_cfg;

    NVIC_SetPriority(BOD_IRQn, IRQ_PRIORITY_NORMAL);
    NVIC_ClearPendingIRQ(BOD_IRQn);
    NVIC_EnableIRQ(BOD_IRQn);
}

void bod_close(void)
{
    // disable BOD
    SYSCON->BOD_BOR &= ~SYSCON_BOD_EN_MSK;

    NVIC_DisableIRQ(BOD_IRQn);
    NVIC_ClearPendingIRQ(BOD_IRQn);
}

void BOD_IRQHandler(void)
{
}

/* BOR */

static const struct BOD_BOR_CFG_T default_bor_cfg = {
    .level = BOD_BOR_TH_LVL0,
    .hyst = BOD_BOR_HYST_LVL0,
};

void bor_open(const struct BOD_BOR_CFG_T *cfg)
{
    const struct BOD_BOR_CFG_T *config = (cfg == NULL) ? &default_bor_cfg : cfg;

    // enable BOR
    uint32_t bod_bor_cfg = SYSCON->BOD_BOR;
    bod_bor_cfg &= 0xFFFFFF00;
    bod_bor_cfg |= SYSCON_BOR_EN_MSK | SYSCON_BOR_TH_SEL(config->level) | SYSCON_BOR_HYST_SEL(config->hyst);
    SYSCON->BOD_BOR = bod_bor_cfg;
}

void bor_close(void)
{
    // disable BOD
    SYSCON->BOD_BOR &= ~SYSCON_BOR_EN_MSK;
}

/* SYS Timer */

uint32_t sys_timer_freq = 0;

void sys_timer_open(void)
{
    // DIV = 1    (max: ~68.8s,     resolution: ~16ns)
    // DIV = 16   (max: ~1101.2s,   resolution: ~256ns)
    // DIV = 256  (max: ~17620.3s   resolution: ~65us)
    struct DUAL_TIMER_CFG_T sys_timer_cfg = {
        .type = DUAL_TIMER_TYPE_FREERUNNING,
        .prescale = DUAL_TIMER_PRESCALE_DIV1,
        .width = DUAL_TIMER_SIZE_32BIT,
        .int_en = false,
        .load = 0xffffffff,
        .callback = NULL,
    };

    dual_timer_open(DUAL_TIMER_ID0, &sys_timer_cfg);
    dual_timer_start(DUAL_TIMER_ID0, sys_timer_cfg.load);
    uint16_t div = sys_timer_cfg.prescale == DUAL_TIMER_PRESCALE_DIV1 ? 1 : sys_timer_cfg.prescale == DUAL_TIMER_PRESCALE_DIV16 ? 16 : 256;
    sys_timer_freq = clock_get_frequency(CLOCK_APB_CLK) / div;
}

void sys_timer_close(void)
{
    dual_timer_close(DUAL_TIMER_ID0);
}

uint32_t sys_timer_get(void)
{
    return -dual_timer_get(DUAL_TIMER_ID0);
}

// max: 68829 us  (DIV = 1)
void sys_timer_delay_us(uint32_t time_us)
{
    uint32_t start = dual_timer_get(DUAL_TIMER_ID0);
    uint32_t ticks = __US_TO_TICKS(time_us);

    while (start - dual_timer_get(DUAL_TIMER_ID0) < ticks)
    {
    }
}

// max: 68829 ms  (DIV = 1)
void sys_timer_delay_ms(uint32_t time_ms)
{
    uint32_t start = dual_timer_get(DUAL_TIMER_ID0);
    uint32_t ticks = __MS_TO_TICKS(time_ms);

    while (start - dual_timer_get(DUAL_TIMER_ID0) < ticks)
    {
    }
}

/* MAC timer */

void mac_timer_open(drv_callback_t callback)
{
    // DIV = 1    (max: ~68.8s,     resolution: ~16ns)
    // DIV = 16   (max: ~1101.2s,   resolution: ~256ns)
    // DIV = 256  (max: ~17620.3s   resolution: ~65us)
    struct DUAL_TIMER_CFG_T mac_timer_cfg = {
        .type = DUAL_TIMER_TYPE_ONESHOT,
        .prescale = DUAL_TIMER_PRESCALE_DIV1,
        .width = DUAL_TIMER_SIZE_32BIT,
        .int_en = true,
        .load = 0xffffffff,
        .callback = NULL,
    };

    mac_timer_cfg.callback = callback;
    dual_timer_open(DUAL_TIMER_ID1, &mac_timer_cfg);
}

void mac_timer_close(void)
{
    dual_timer_close(DUAL_TIMER_ID1);
}

void mac_timer_start(uint32_t count)
{
    dual_timer_start(DUAL_TIMER_ID1, count);
    // board_led_on(BOARD_LED_1);
}

void mac_timer_stop(void)
{
    dual_timer_stop(DUAL_TIMER_ID1);
    // board_led_off(BOARD_LED_1);
}

/* SYS Tick */

static struct SYS_TICK_ENV_T sys_tick_env = {0};

void sys_tick_start(uint32_t ticks)
{
    ASSERT(ticks <= SysTick_LOAD_RELOAD_Msk + 1, "Reload value impossible\r\n");
    SysTick->LOAD = (uint32_t)(ticks - 1UL);                            /* set reload register */
    NVIC_SetPriority(SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL);    /* set Priority for Systick Interrupt */
    SysTick->VAL = 0;                                                   /* A write of any value clears the field to 0 */
    SysTick->CTRL = SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */
}

uint32_t sys_tick_us(void)
{
    uint32_t lock = int_lock();

    uint32_t count = sys_tick_env.count;
    uint32_t load = SysTick->LOAD + 1;
    uint32_t val = SysTick->VAL;

    uint32_t flag_pending = REG_READ(0xE000ED04) & (1 << 26);
    if (flag_pending)
    {
        count += 1;

        val = load;
    }
    else if (val == 0)
    {
        val = load;
    }

    uint32_t tick_us = (count * 328 + (load - val)) * 30;

    int_unlock(lock);

    return tick_us;
}

uint32_t sys_tick_ms(void)
{
    uint32_t lock = int_lock();

    uint32_t count = sys_tick_env.count;
    uint32_t load = SysTick->LOAD + 1;
    uint32_t val = SysTick->VAL;

    uint32_t flag_pending = REG_READ(0xE000ED04) & (1 << 26);
    if (flag_pending)
    {
        count += 1;

        val = load;
    }
    else if (val == 0)
    {
        val = load;
    }

    uint32_t tick_ms = (count * 10 + (load - val) * 10 / 328);

    int_unlock(lock);

    return tick_ms;
}

uint32_t sys_tick_get(void)
{
    return sys_tick_env.count;
}

void sys_tick_callback_set(void (*callback)(void))
{
    sys_tick_env.callback = callback;
}

uint32_t sys_tick_elapse_ms(void)
{
    uint32_t lock = int_lock();

    uint32_t load = SysTick->LOAD + 1;
    uint32_t val = SysTick->VAL;

    uint32_t flag_pending = REG_READ(0xE000ED04) & (1 << 26);
    if (flag_pending)
    {
        val = 0;
    }
    else if (val == 0)
    {
        val = load;
    }

    uint32_t elapse_ms = (load - val) * 10 / 328;

    int_unlock(lock);

    return elapse_ms;
}

void sys_tick_pause(void)
{
    // Stop SysTick
    SysTick->CTRL = 0;
    uint32_t val = SysTick->VAL;
    uint32_t load = SysTick->LOAD + 1;
    uint32_t flag_pending = REG_READ(0xE000ED04) & (1 << 26);

    if (flag_pending)
    {
        sys_tick_env.count += 1;
        val = load;

        // clear pending systick interrupt
        REG_WRITE(0xE000ED04, (1 << 25));
    }
    else if (val == 0)
    {
        val = load;
    }

    // Store SysTick counter
    sys_tick_env.load = load;
    // SysTick->VAL cannot be set
    sys_tick_env.elapse += (load - val);
}

void sys_tick_resume(void)
{
    sys_tick_start(sys_tick_env.load);

    uint32_t slp_cnt = high_xtal_off_time();
    uint32_t cnt = slp_cnt / sys_tick_env.load;
    sys_tick_env.elapse += (slp_cnt - cnt * sys_tick_env.load);
    while (sys_tick_env.elapse >= sys_tick_env.load)
    {
        sys_tick_env.elapse -= sys_tick_env.load;
        cnt += 1;
    }

    sys_tick_env.count += cnt;
    if ((sys_tick_env.callback != NULL) && (cnt))
    {
        sys_tick_env.callback();
    }
}

void SysTick_Handler(void)
{
    // board_led_on(BOARD_LED_2);
    sys_tick_env.count++;
    if (sys_tick_env.callback != NULL)
    {
        sys_tick_env.callback();
    }
    // board_led_off(BOARD_LED_2);
}

void sys_reset(uint32_t error)
{
    //LOG_INFO(TRACE_MODULE_DRIVER, "system reboot%x", error);

    delay_us(10000);

    // reboot
    reset_module(RESET_MODULE_REBOOT);
}
void delay_US(uint32_t nTimer)  
{  
    uint32_t i=0;  
    for(i=0;i<nTimer;i++){  
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
		__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
		__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();  
        __NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
		__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();
		__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();__NOP();  
        __NOP();__NOP();__NOP();__NOP(); 
    }  
}
void delay_ms(uint32_t nTimer)  
{  
    uint32_t i=1000*nTimer;  
    delay_US(i);  
}  
void delay_us(uint32_t cnt)
{
#define SYSTEM_CLOCK_MHZ 62.4

// the larger LSLS bits the more accurate of this delay function but the shorter of available delay time
#define SYSTEM_CLOCK_LSLS_BITS 5
#define SYSTEM_CLOCK_LSLS (uint16_t)(SYSTEM_CLOCK_MHZ * (1 << SYSTEM_CLOCK_LSLS_BITS))

// you should adjust these num manually if SYSTEM_CLOCK_MHZ or SYSTEM_CLOCK_LSLS_BITS changes
#define SYSTEM_CLOCK_MULT_HI 0x07 // (uint8_t)((SYSTEM_CLOCK_LSLS & 0xFF00) >> 8)
#define SYSTEM_CLOCK_MULT_LO 0xCD // (uint8_t)(SYSTEM_CLOCK_LSLS & 0x00FF)

#define AAPCS_PREP_CYCLES 18
#define DELAY_LOOP_CYCLES 4

#if defined(__GNUC__) && !defined(__ARMCC_VERSION)
    __asm volatile(".syntax unified\n");
#endif

    __asm volatile(
        "cmp r0, #0\n"
        "beq exit%=\n"
        "push {r4,r5}\n"
        "movs r5, %[mult_hi]\n"
        "lsls r4, r5, #8\n"
        "movs r5, %[mult_lo]\n"
        "adds r4, r4, r5\n"
        "muls r0, r4\n"
        "lsrs r0, r0, %[shift]\n"
        "subs r0, r0, %[adjust]\n"
        "loop%=:\n"
        "subs r0, r0, %[decr]\n"
        "bhi loop%=\n"
        "pop {r4,r5}\n"
        "exit%=:\n"
    :
    : [mult_hi] "i"(SYSTEM_CLOCK_MULT_HI), [mult_lo] "i"(SYSTEM_CLOCK_MULT_LO), [shift] "i"(SYSTEM_CLOCK_LSLS_BITS), [adjust] "i"(AAPCS_PREP_CYCLES),
        [decr] "i"(DELAY_LOOP_CYCLES));

#if defined(__GNUC__) && !defined(__ARMCC_VERSION)
    __asm volatile(".syntax divided\n");
#endif
}

uint8_t count_bits(uint32_t value)
{
    uint8_t count = 0;
    while (value)
    {
        value &= value - 1;
        count++;
    }
    return count;
}

uint8_t search_byte_right_one(uint8_t value)
{
    uint8_t index = 1;
    if (value == 0)
    {
        return 0;
    }

    if ((value & 0x0F) == 0)
    {
        value >>= 4;
        index += 4;
    }

    if ((value & 0x03) == 0)
    {
        value >>= 2;
        index += 2;
    }

    if ((value & 0x01) == 0)
    {
        index += 1;
    }
    return index;
}

uint8_t byte_right_one_mask(uint8_t value)
{
    return (value & (~value + 1));
}

int32_t average_filter(int32_t input)
{
#define TOTAL_SAMPLES (5)
#if 1
    // arithmetical averaging
    static int32_t data_buffer[TOTAL_SAMPLES] = {0};
    static uint8_t data_num = 0;
    int64_t sum = 0;

    // if buffer is full, remove the oldest data
    if (data_num == TOTAL_SAMPLES)
    {
        data_num--;
    }

    // add a new data in buffer
    for (int i = data_num; i > 0; i--)
    {
        data_buffer[i] = data_buffer[i - 1];
        sum += data_buffer[i];
    }
    data_buffer[0] = input;
    sum += data_buffer[0];
    data_num++;

    return (int32_t)(sum / data_num);
#else
    // weighted averaging
#endif
}

int16_t mk_q7_to_s16(int16_t data)
{
    return (data / 128);
}

int16_t mk_s16_to_q7(int16_t data)
{
    return (data * 128);
}

float mk_q7_to_f32(int16_t data)
{
    return (float)(data / 128.0);
}

int16_t mk_f32_to_q7(float data)
{
    return (int16_t)(data * 128);
}