/**************************************************************************
*
* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
*
* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
*
* @file WatchdogMgmt.c
*
* @author (last) Dara Navaei
* @date (last) 30-Apr-2020
*
* @author (original) Dara Navaei
* @date (original) 05-Nov-2019
*
***************************************************************************/

#include "CPLD.h"
#include "SafetyShutdown.h"
#include "SystemCommMessages.h"
#include "Timers.h"
#include "WatchdogMgmt.h"

/**
 *  @addtogroup WatchdogMgmt
 *  @{
 */

// ********** private definitions **********

#define MIN_WATCHDOG_PET_INTERVAL_MS        45                                              ///< Minimum watchdog pet interval (in ms).
#define WATCHDOG_POST_TIMEOUT_MS            100                                             ///< Watchdog POST test timeout (in ms).
#define WATCHDOG_RECOVERY_TIME_MS           250                                             ///< After watchdog POST test, wait this long (in ms) before moving on.

/// Enumeration of watchdog self-test states.
typedef enum Watchdog_Self_Test_States
{
    WATCHDOG_SELF_TEST_STATE_START = 0,                                                     ///< Watchdog self-test start state
    WATCHDOG_SELF_TEST_STATE_IN_PROGRESS,                                                   ///< Watchdog self-test in progress state
    WATCHDOG_SELF_TEST_STATE_RECOVER,                                                       ///< Watchdog self-test recovery state
    WATCHDOG_SELF_TEST_STATE_COMPLETE,                                                      ///< Watchdog self-test completed state
    NUM_OF_WATCHDOG_SELF_TEST_STATES                                                        ///< Number of watchdog self-test states
} WATCHDOG_SELF_TEST_STATE_T;

// ********** private data **********

static U32  lastWatchdogPetTime = 0;                                                        ///< Timestamp (ms counter) since last watchdog pet.

static OVERRIDE_U32_T watchdogTaskCheckedIn[ NUM_OF_TASKS ];                                ///< Array of flags indicating whether individual tasks have checked in with watchdog manager.

static WATCHDOG_SELF_TEST_STATE_T watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_START;   ///< Current watchdog self-test state.
static SELF_TEST_STATUS_T         watchdogSelfTestStatus;                                   ///< Watchdog self-test state timer counter.
static U32 watchdogSelfTestTimerCount = 0;

// ********** private function prototypes **********

static void resetWDTaskCheckIns( void );
static BOOL haveAllTasksCheckedIn( void );
static void petWatchdog( void );
static DATA_ARRAY_GET_PROTOTYPE( BOOL, hasTaskGeneralCheckedIn, task );

/*********************************************************************//**
 * @brief
 * The initWatchdogMgmt function initializes the watchdog mgmt. module.
 * @details
 * Inputs : none
 * Outputs : Watchdog mgmt. module initialized.
 * @return none
 *************************************************************************/
void initWatchdogMgmt( void )
{
    U32 i;

    lastWatchdogPetTime = 0;
    watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_START;
    watchdogSelfTestStatus = SELF_TEST_STATUS_IN_PROGRESS;
    watchdogSelfTestTimerCount = 0;
    // initialize task check-ins to false
    for ( i = 0; i < NUM_OF_TASKS; i++ )
    {
        watchdogTaskCheckedIn[ i ].data = FALSE;
        watchdogTaskCheckedIn[ i ].ovData = FALSE;
        watchdogTaskCheckedIn[ i ].ovInitData = FALSE;
        watchdogTaskCheckedIn[ i ].override = OVERRIDE_RESET;
    }
}

/*********************************************************************//**
 * @brief
 * The execWatchdogMgmt function executes thewatchdog mgmt. service.
 * @details
 * Inputs : watchdogTaskCheckedIn[]
 * Outputs : watchdogTaskCheckedIn[]
 * @return none
 *************************************************************************/
void execWatchdogMgmt( void )
{
    BOOL allTasksCheckedIn;

    // called by background task, so give bg task credit for checking in
    checkInWithWatchdogMgmt( TASK_BG );

    // check to see if all monitored tasks have checked in
    allTasksCheckedIn = haveAllTasksCheckedIn();

    // if all monitored tasks checked in, pet watchdog and clear the slate
    if ( ( TRUE == allTasksCheckedIn ) && ( didTimeout( lastWatchdogPetTime, MIN_WATCHDOG_PET_INTERVAL_MS ) ) )
    {
        petWatchdog();
        resetWDTaskCheckIns();
    }
#ifndef RM46_EVAL_BOARD_TARGET
    // check to see if watchdog has expired
#ifndef BREADBOARD_TARGET
    if ( getCPLDWatchdogExpired() == PIN_SIGNAL_LOW )
#else
    if ( getCPLDWatchdogExpired() == PIN_SIGNAL_HIGH )
#endif
    {
        // ignore expired watchdog until after watchdog POST
        if ( WATCHDOG_SELF_TEST_STATE_COMPLETE == watchdogSelfTestState )
        {
#ifndef DEBUG_ENABLED
            activateAlarmNoData( ALARM_ID_WATCHDOG_EXPIRED );
#endif
        }
    }
#endif
}


/*********************************************************************//**
 * @brief
 * The checkInWithWatchdogMgmt function checks a given task in with the
 * watchdog mgmt. service.
 * @details
 * Inputs : none
 * Outputs : task is checked in with the watchdog mgmt..
 * @param task the task that is checking in with the watchdog mgmt
 * @return none
 *************************************************************************/
void checkInWithWatchdogMgmt( TASK_T task )
{
    if ( task < NUM_OF_TASKS )
    {
        watchdogTaskCheckedIn[ task ].data = TRUE;
    }
}

/*********************************************************************//**
 * @brief
 * The execWatchdogTest function executes the watchdog test.
 * This function should be called periodically until a pass or fail
 * result is returned.
 * @details
 * Inputs : watchdogSelfTestState
 * Outputs : watchdogSelfTestState
 * @return in progress, passed, or failed
 *************************************************************************/
SELF_TEST_STATUS_T execWatchdogTest( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS;

    switch ( watchdogSelfTestState )
    {
        case WATCHDOG_SELF_TEST_STATE_START:
            watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_IN_PROGRESS;
            watchdogSelfTestTimerCount = getMSTimerCount();
            // no break here so we pass through directly to in progress processing

        case WATCHDOG_SELF_TEST_STATE_IN_PROGRESS:
            while ( FALSE == didTimeout( watchdogSelfTestTimerCount, WATCHDOG_POST_TIMEOUT_MS ) )
            {
                // waiting here for w.d. test period to prevent this task from checking in - watchdog should expire
            }
            if ( getCPLDWatchdogExpired() == PIN_SIGNAL_HIGH )
            {
                watchdogSelfTestStatus = SELF_TEST_STATUS_PASSED;
            }
            else
            {
                activateAlarmNoData( ALARM_ID_WATCHDOG_POST_TEST_FAILED );
                watchdogSelfTestStatus = SELF_TEST_STATUS_FAILED;
            }
            watchdogSelfTestTimerCount = getMSTimerCount();
            watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_RECOVER;
            break;

        case WATCHDOG_SELF_TEST_STATE_RECOVER:
            if ( TRUE == didTimeout( watchdogSelfTestTimerCount, WATCHDOG_RECOVERY_TIME_MS ) )
            {
                result = watchdogSelfTestStatus;
                watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_COMPLETE;
            }
            break;

        case WATCHDOG_SELF_TEST_STATE_COMPLETE:
            // if we get called in this state, assume we're doing self-test again
            watchdogSelfTestStatus = SELF_TEST_STATUS_IN_PROGRESS;
            watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_START;
            break;

        default:
            result = SELF_TEST_STATUS_FAILED;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_WATCHDOG_INVALID_SELF_TEST_STATE, watchdogSelfTestState )
            break;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The resetWDTaskCheckIns function resets the task check-ins with the watchdog.
 * @details
 * Inputs : none
 * Outputs : watchdogTaskCheckedIn[] array reset to all false.
 * @return none
 *************************************************************************/
static void resetWDTaskCheckIns( void )
{
    U32 i;

    // initialize task check-ins to false
    for ( i = 0; i < NUM_OF_TASKS; i++ )
    {
        watchdogTaskCheckedIn[ i ].data = FALSE;
    }
}

/*********************************************************************//**
 * @brief
 * The haveAllTasksCheckedIn function determines whether all tasks have
 * checked in with watchdog mgmt.
 * @details
 * Inputs : watchdogTaskCheckedIn[]
 * Outputs : none
 * @return TRUE if all tasks have checked in since last watchdog pet, FALSE if not.
 *************************************************************************/
static BOOL haveAllTasksCheckedIn( void )
{
    BOOL result = TRUE;
    U32  i;

    // check that each task has checked in
    for ( i = 0; i < NUM_OF_TASKS; i++ )
    {
        if ( FALSE == hasTaskGeneralCheckedIn( i ) )
        {
            result = FALSE;
            break;
        }
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The hasTaskGeneralCheckedIn function gets the check-in state of a given
 * task.
 * @details
 * Inputs : watchdogTaskCheckedIn[]
 * Outputs : none
 * @param task ID of task to check
 * @return TRUE if given task has checked in, FALSE if not
 *************************************************************************/
BOOL hasTaskGeneralCheckedIn( U32 task )
{
    BOOL result = FALSE;

    if ( task < NUM_OF_TASKS )
    {
        if ( OVERRIDE_KEY == watchdogTaskCheckedIn[ task ].override )
        {
            result = (BOOL)watchdogTaskCheckedIn[ task ].ovData;
        }
        else
        {
            result = (BOOL)watchdogTaskCheckedIn[ task ].data;
        }
    }
    else
    {
        activateAlarmNoData( ALARM_ID_HD_SOFTWARE_FAULT );
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The petWatchdog function pets the watchdog by pulsing the CPLD WD pet
 * signal.
 * @details
 * Inputs : none
 * Outputs : CPLD WD pet signal is pulsed
 * @return none
 *************************************************************************/
static void petWatchdog( void )
{
#ifndef RM46_EVAL_BOARD_TARGET
    // pulse the watchdog signal
    toggleCPLDWatchdog();
#endif

    // remember when we last pet the watchdog
    lastWatchdogPetTime = getMSTimerCount();
}


/*************************************************************************
 *                       TEST SUPPORT FUNCTIONS
 *************************************************************************/


/*********************************************************************//**
 * @brief
 * The testSetWatchdogTaskCheckInOverride function overrides the state of the
 * task check-in with the watchdog management with a given check-in state.
 * @details
 * Inputs : none
 * Outputs : watchdogTaskCheckedIn[]
 * @param task ID of task to override check-in state for
 * @param value override state for the given task ID
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testSetWatchdogTaskCheckInOverride( U32 task, BOOL value )
{
    BOOL result = FALSE;

    if ( task < NUM_OF_TASKS )
    {
        if ( TRUE == isTestingActivated() )
        {
            result = TRUE;
            watchdogTaskCheckedIn[ task ].ovData = value;
            watchdogTaskCheckedIn[ task ].override = OVERRIDE_KEY;
        }
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The testResetWatchdogTaskCheckInOverride function resets the override of the
 * state of the check-in with the watchdog management.
 * @details
 * Inputs : none
 * Outputs : watchdogTaskCheckedIn[]
 * @param task ID of task to override check-in state for
 * @return TRUE if override reset successful, FALSE if not
 *************************************************************************/
BOOL testResetWatchdogTaskCheckInOverride( U32 task )
{
    BOOL result = FALSE;

    if ( task < NUM_OF_TASKS )
    {
        if ( TRUE == isTestingActivated() )
        {
            result = TRUE;
            watchdogTaskCheckedIn[ task ].override = OVERRIDE_RESET;
            watchdogTaskCheckedIn[ task ].ovData = watchdogTaskCheckedIn[ task ].ovInitData;
        }
    }

    return result;
}

/**@}*/