/*************************************************************************************************/
|
/*!
|
* \file wsf_timer.c
|
*
|
* \brief Timer service.
|
*
|
* Copyright (c) 2009-2019 Arm Ltd. All Rights Reserved.
|
*
|
* Copyright (c) 2019-2020 Packetcraft, Inc.
|
*
|
* 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 "wsf_types.h"
|
#include "wsf_queue.h"
|
#include "wsf_timer.h"
|
|
#include "wsf_assert.h"
|
#include "wsf_cs.h"
|
#include "wsf_trace.h"
|
#include "pal_sys.h"
|
|
/**************************************************************************************************
|
Macros
|
**************************************************************************************************/
|
|
#if (WSF_MS_PER_TICK == 10)
|
|
/*! \brief WSF timer ticks per second. */
|
#define WSF_TIMER_TICKS_PER_SEC (1000 / WSF_MS_PER_TICK)
|
|
/* convert seconds to timer ticks */
|
#define WSF_TIMER_SEC_TO_TICKS(sec) (WSF_TIMER_TICKS_PER_SEC * (sec))
|
|
/* convert milliseconds to timer ticks */
|
#define WSF_TIMER_MS_TO_TICKS(ms) ((ms) / WSF_MS_PER_TICK)
|
|
#else
|
#error "WSF_TIMER_MS_TO_TICKS and WSF_TIMER_SEC_TO_TICKS not defined for WSF_MS_PER_TICK"
|
#endif
|
|
/*! \brief Minimum RTC ticks required to go into sleep. */
|
#define WSF_TIMER_MIN_MS_FOR_POWERDOWN (2)
|
#define WSF_TIMER_MAX_MS_FOR_POWERDOWN (10000)
|
|
/**************************************************************************************************
|
Global Variables
|
**************************************************************************************************/
|
|
static wsfQueue_t wsfTimerTimerQueue; /*!< Timer queue */
|
|
/*! \brief Last SysTick value read. */
|
static uint32_t wsfTimerSysTickcLastTick = 0;
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Remove a timer from queue. Note this function does not lock task scheduling.
|
*
|
* \param pTimer Pointer to timer.
|
*/
|
/*************************************************************************************************/
|
static void wsfTimerRemove(wsfTimer_t *pTimer)
|
{
|
wsfTimer_t *pElem;
|
wsfTimer_t *pPrev = NULL;
|
|
pElem = (wsfTimer_t *)wsfTimerTimerQueue.pHead;
|
|
/* find timer in queue */
|
while (pElem != NULL)
|
{
|
if (pElem == pTimer)
|
{
|
break;
|
}
|
pPrev = pElem;
|
pElem = pElem->pNext;
|
}
|
|
/* if timer found remove from queue */
|
if (pElem != NULL)
|
{
|
WsfQueueRemove(&wsfTimerTimerQueue, pTimer, pPrev);
|
|
pTimer->isStarted = FALSE;
|
}
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Insert a timer into the queue sorted by the timer expiration.
|
*
|
* \param pTimer Pointer to timer.
|
* \param ticks Timer ticks until expiration.
|
* \param mode Timer work mode.
|
*/
|
/*************************************************************************************************/
|
static void wsfTimerInsert(wsfTimer_t *pTimer, wsfTimerTicks_t ticks, uint8_t mode)
|
{
|
wsfTimer_t *pElem;
|
wsfTimer_t *pPrev = NULL;
|
|
/* task schedule lock */
|
uint32_t lock = WsfTaskLock();
|
|
/* if timer is already running stop it first */
|
if (pTimer->isStarted)
|
{
|
wsfTimerRemove(pTimer);
|
}
|
|
pTimer->isStarted = TRUE;
|
pTimer->ticks = ticks;
|
pTimer->count = ticks;
|
pTimer->mode = mode;
|
|
pElem = (wsfTimer_t *)wsfTimerTimerQueue.pHead;
|
|
/* find insertion point in queue */
|
while (pElem != NULL)
|
{
|
if (pTimer->ticks < pElem->ticks)
|
{
|
break;
|
}
|
pPrev = pElem;
|
pElem = pElem->pNext;
|
}
|
|
/* insert timer into queue */
|
WsfQueueInsert(&wsfTimerTimerQueue, pTimer, pPrev);
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Return the number of ticks until the next timer expiration. Note that this
|
* function can return zero even if a timer is running, indicating a timer
|
* has expired but has not yet been serviced.
|
*
|
* \param pTimerRunning Returns TRUE if a timer is running, FALSE if no timers running.
|
*
|
* \return The number of ticks until the next timer expiration.
|
*/
|
/*************************************************************************************************/
|
static wsfTimerTicks_t WsfTimerNextExpiration(bool_t *pTimerRunning)
|
{
|
wsfTimerTicks_t ticks;
|
|
/* task schedule lock */
|
uint32_t lock = WsfTaskLock();
|
|
if (wsfTimerTimerQueue.pHead == NULL)
|
{
|
*pTimerRunning = FALSE;
|
ticks = 0;
|
}
|
else
|
{
|
*pTimerRunning = TRUE;
|
ticks = ((wsfTimer_t *)wsfTimerTimerQueue.pHead)->ticks;
|
}
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
|
return ticks;
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Initialize the timer service. This function should only be called once
|
* upon system initialization.
|
*/
|
/*************************************************************************************************/
|
void WsfTimerInit(void)
|
{
|
WSF_QUEUE_INIT(&wsfTimerTimerQueue);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Start a timer in units of seconds.
|
*
|
* \param pTimer Pointer to timer.
|
* \param sec Seconds until expiration.
|
* \param mode Timer work mode.
|
*/
|
/*************************************************************************************************/
|
void WsfTimerStartSec(wsfTimer_t *pTimer, wsfTimerTicks_t sec, uint8_t mode)
|
{
|
WSF_TRACE_INFO2("WsfTimerStartSec pTimer:0x%x ticks:%u", (uint32_t)pTimer, WSF_TIMER_SEC_TO_TICKS(sec));
|
|
/* insert timer into queue */
|
wsfTimerInsert(pTimer, WSF_TIMER_SEC_TO_TICKS(sec), mode);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Start a timer in units of milliseconds.
|
*
|
* \param pTimer Pointer to timer.
|
* \param ms Milliseconds until expiration.
|
* \param mode Timer work mode.
|
*/
|
/*************************************************************************************************/
|
void WsfTimerStartMs(wsfTimer_t *pTimer, wsfTimerTicks_t ms, uint8_t mode)
|
{
|
WSF_TRACE_INFO2("WsfTimerStartMs pTimer:0x%x ticks:%u", (uint32_t)pTimer, WSF_TIMER_MS_TO_TICKS(ms));
|
|
/* insert timer into queue */
|
wsfTimerInsert(pTimer, WSF_TIMER_MS_TO_TICKS(ms), mode);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Stop a timer.
|
*
|
* \param pTimer Pointer to timer.
|
*/
|
/*************************************************************************************************/
|
void WsfTimerStop(wsfTimer_t *pTimer)
|
{
|
WSF_TRACE_INFO1("WsfTimerStop pTimer:0x%x", pTimer);
|
|
/* task schedule lock */
|
uint32_t lock = WsfTaskLock();
|
|
wsfTimerRemove(pTimer);
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Update the timer service with the number of elapsed ticks.
|
*
|
* \param ticks Number of ticks since last update.
|
*/
|
/*************************************************************************************************/
|
void WsfTimerUpdate(wsfTimerTicks_t ticks)
|
{
|
wsfTimer_t *pElem;
|
|
/* task schedule lock */
|
uint32_t lock = WsfTaskLock();
|
|
pElem = (wsfTimer_t *)wsfTimerTimerQueue.pHead;
|
|
/* iterate over timer queue */
|
while (pElem != NULL)
|
{
|
/* decrement ticks while preventing underflow */
|
if (pElem->ticks > ticks)
|
{
|
pElem->ticks -= ticks;
|
}
|
else
|
{
|
pElem->ticks = 0;
|
|
/* timer expired; set task for this timer as ready */
|
WsfTaskSetReady(pElem->handlerId, WSF_TIMER_EVENT);
|
}
|
|
pElem = pElem->pNext;
|
}
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Service expired timers for the given task.
|
*
|
* \param taskId Task ID.
|
*
|
* \return Pointer to timer or NULL.
|
*/
|
/*************************************************************************************************/
|
wsfTimer_t *WsfTimerServiceExpired(wsfTaskId_t taskId)
|
{
|
wsfTimer_t *pElem;
|
wsfTimer_t *pPrev = NULL;
|
|
/* Unused parameters */
|
(void)taskId;
|
|
/* task schedule lock */
|
uint32_t lock = WsfTaskLock();
|
|
/* find expired timers in queue */
|
pElem = (wsfTimer_t *)wsfTimerTimerQueue.pHead;
|
if ((pElem != NULL) && (pElem->ticks == 0))
|
{
|
if (pElem->mode == WSF_TIMER_PERIODIC)
|
{
|
wsfTimerInsert(pElem, pElem->count, WSF_TIMER_PERIODIC);
|
}
|
else
|
{
|
/* remove timer from queue */
|
WsfQueueRemove(&wsfTimerTimerQueue, pElem, pPrev);
|
|
pElem->isStarted = FALSE;
|
}
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
|
WSF_TRACE_INFO1("Timer expired pTimer:0x%x", pElem);
|
|
/* return timer */
|
return pElem;
|
}
|
|
/* task schedule unlock */
|
WsfTaskUnlock(lock);
|
|
return NULL;
|
}
|
|
/*************************************************************************************************/
|
/*!
|
* \brief Function for checking if there is an active timer and if there is enough time to
|
* go to sleep and going to sleep.
|
*/
|
/*************************************************************************************************/
|
uint8_t WsfTimerSleepCheck(uint32_t *sleep_ms)
|
{
|
wsfTimerTicks_t nextExpiration;
|
|
/* If PAL system is busy, no need to sleep. */
|
if (PalSysIsBusy())
|
{
|
// active
|
return 0;
|
}
|
|
bool_t running;
|
nextExpiration = WsfTimerNextExpiration(&running);
|
|
if (running)
|
{
|
uint32_t awake = WSF_MS_PER_TICK * nextExpiration;
|
uint32_t elapsed = PalSysTickElapse();
|
|
/* if we have time to sleep before timer expiration */
|
if ((awake - elapsed) > WSF_TIMER_MIN_MS_FOR_POWERDOWN)
|
{
|
*sleep_ms = awake - elapsed;
|
// Power down
|
return 2;
|
}
|
else
|
{
|
/* Not enough time to go to powerdown. Let the system sleep. */
|
// Sleep
|
return 1;
|
}
|
}
|
else
|
{
|
*sleep_ms = WSF_TIMER_MAX_MS_FOR_POWERDOWN;
|
// Power down
|
return 2;
|
}
|
}
|
|
//*****************************************************************************
|
//
|
// Calculate the elapsed time, and update the WSF software timers.
|
//
|
//*****************************************************************************
|
void WsfTimerUpdateTicks(void)
|
{
|
uint32_t ui32CurrentTick, ui32ElapsedTicks;
|
|
//
|
// Read the continuous systick.
|
//
|
ui32CurrentTick = PalSysTickGet();
|
|
//
|
// Figure out how long it has been since the last time we've read the
|
// continuous systick.
|
//
|
if (ui32CurrentTick > wsfTimerSysTickcLastTick)
|
{
|
ui32ElapsedTicks = ui32CurrentTick - wsfTimerSysTickcLastTick;
|
}
|
else
|
{
|
ui32ElapsedTicks = 0xffffffff - wsfTimerSysTickcLastTick + ui32CurrentTick;
|
}
|
|
WsfTimerUpdate(ui32ElapsedTicks);
|
wsfTimerSysTickcLastTick = ui32CurrentTick;
|
}
|
