/*
 * 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_wdt.h"
#include "mk_clock.h"
#include "mk_reset.h"
#include "mk_trace.h"

#define WDT_UNLOCK 0x1ACCE551
#define WDT_LOCK 0x00000001

static struct WDT_HANDLE_T wdt_handle[WDT_MAX_NUM] = {
    {
        .base = WDT,
        .irq = WDT_IRQn,
        .wdt_started = 1,
        .callback = NULL,
    },
};

int wdt_open(enum WDT_DEV_T id, struct WDT_CFG_T *config)
{
    if ((id >= WDT_MAX_NUM) && (config == NULL))
    {
        return DRV_ERROR;
    }

    if ((config->rst_en || config->int_en) == 0)
    {
        return DRV_ERROR;
    }

    wdt_handle[id].rst_en = config->rst_en;
    wdt_handle[id].int_en = config->int_en;
    wdt_handle[id].callback = config->callback;

    // enable WDT clock
    clock_enable(CLOCK_WDT);
    reset_module(RESET_MODULE_WDT);

    // unlock
    wdt_handle[id].base->LOCK = WDT_UNLOCK;
    wdt_handle[id].base->LOAD = config->timeout;

    // write any value to clear the interrupt and reload the counter
    wdt_handle[id].base->INTR_CLR = 0;

    if (wdt_handle[id].rst_en)
    {
        // enable WDT reset
        wdt_handle[id].base->CTRL |= WDT_CTRL_RESET_EN_MSK;
    }

    if (wdt_handle[id].int_en)
    {
        NVIC_SetPriority(WDT_IRQn, IRQ_PRIORITY_NORMAL);
        NVIC_ClearPendingIRQ(WDT_IRQn);
        NVIC_EnableIRQ(WDT_IRQn);
    }

    // enable WDT counter and interrupt
    wdt_handle[id].base->CTRL |= WDT_CTRL_INT_EN_MSK;

    wdt_handle[id].wdt_started = 1;

    // lock
    wdt_handle[id].base->LOCK = WDT_LOCK;

    LOG_INFO(TRACE_MODULE_DRIVER, "WDT open\r\n");
    return DRV_OK;
}

int wdt_close(enum WDT_DEV_T id)
{
    if (id >= WDT_MAX_NUM)
    {
        return DRV_ERROR;
    }
    // unlock
    wdt_handle[id].base->LOCK = WDT_UNLOCK;

    // disable WDT reset and interrupt
    wdt_handle[id].base->CTRL = 0;

    NVIC_DisableIRQ(WDT_IRQn);
    NVIC_ClearPendingIRQ(WDT_IRQn);

    wdt_handle[id].wdt_started = 0;
    wdt_handle[id].rst_en = 0;
    wdt_handle[id].int_en = 0;

    // lock
    wdt_handle[id].base->LOCK = WDT_LOCK;

    // disable WDT clock
    clock_disable(CLOCK_WDT);
    LOG_INFO(TRACE_MODULE_DRIVER, "WDT close\r\n");
    return DRV_OK;
}

int wdt_set_time(enum WDT_DEV_T id, uint32_t time)
{
    if (id >= WDT_MAX_NUM)
    {
        return DRV_ERROR;
    }

    if (wdt_handle[id].wdt_started == 0)
    {
        return DRV_ERROR;
    }

    // unlock
    wdt_handle[id].base->LOCK = WDT_UNLOCK;

    wdt_handle[id].base->LOAD = time;

    // write any value to clear the interrupt and reload the counter
    wdt_handle[id].base->INTR_CLR = 0;

    // lock
    wdt_handle[id].base->LOCK = WDT_LOCK;

    return DRV_OK;
}

int wdt_ping(enum WDT_DEV_T id)
{
    if (id >= WDT_MAX_NUM)
    {
        return DRV_ERROR;
    }

    if (wdt_handle[id].wdt_started == 0)
    {
        return DRV_ERROR;
    }

    // unlock
    wdt_handle[id].base->LOCK = WDT_UNLOCK;

    // write any value to clear the interrupt and reload the counter
    wdt_handle[id].base->INTR_CLR = 0;

    // lock
    wdt_handle[id].base->LOCK = WDT_LOCK;
    return DRV_OK;
}

int wdt_time_left(enum WDT_DEV_T id, uint32_t *time)
{
    if (id >= WDT_MAX_NUM)
    {
        return DRV_ERROR;
    }

    if (wdt_handle[id].wdt_started == 0)
    {
        return DRV_ERROR;
    }

    if (time)
    {
        *time = wdt_handle[id].base->VALUE;
    }

    return DRV_OK;
}

void WDT_IRQHandler(void)
{
    enum WDT_DEV_T id = WDT_ID0;
    if (wdt_handle[id].callback)
    {
        wdt_handle[id].callback(&id, 0);
    }
}