/*
|
* 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);
|
}
|
}
|
