/**************************************************************************
*
* Copyright (c) 2019-2022 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)      Sean Nash
* @date    (last)      12-Nov-2021
*
* @author  (original)  Dara Navaei
* @date    (original)  05-Nov-2019
*
***************************************************************************/

#include "CPLD.h"
#include "FPGA.h"
#include "InternalADC.h"
#include "OperationModes.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            500                                             ///< Watchdog POST test timeout (in ms).
#define WATCHDOG_RECOVERY_TIME_MS           500                                             ///< After watchdog POST test, wait this long (in ms) before moving on.

#define MAX_24V_LEVEL_ON_WATCHDOG_EXPIRED   5.0                                             ///< Maximum voltage on 24V line when watchdog is expired.  // TODO - check w/ Systems.  Takes time for V to bleed off.  Had to raise to 5V.
#define MIN_24V_LEVEL_ON_WATCHDOG_RECOVER   22.6                                            ///< Minimum voltage on 24V line when watchdog is recovered.
#define MIN_BACKUP_ALARM_CURRENT_MA         200.0                                           ///< Minimum backup alarm audio current (in mA) detected when watchdog is expired.
#define MAX_BACKUP_ALARM_CURRENT_MA         10.0                                            ///< Maximum backup alarm audio current (in mA) detected when watchdog is recovered.

/// 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 BOOL hasTaskGeneralCheckedIn( U32 task );

/*********************************************************************//**
 * @brief
 * The initWatchdogMgmt function initializes the watchdog mgmt. module.
 * @details Inputs: none
 * @details 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[]
 * @details 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();
    }
    // Check to see if watchdog has expired
    if ( getCPLDWatchdogExpired() == PIN_SIGNAL_LOW )
    {
        // Ignore expired watchdog until after watchdog POST
        if ( ( WATCHDOG_SELF_TEST_STATE_COMPLETE == watchdogSelfTestState ) ||
             ( getCurrentOperationMode() != MODE_INIT ) )
        {
#ifndef DEBUG_ENABLED
            activateAlarmNoData( ALARM_ID_WATCHDOG_EXPIRED );
#endif
        }
    }
}

/*********************************************************************//**
 * @brief
 * The checkInWithWatchdogMgmt function checks a given task in with the
 * watchdog mgmt. service.
 * @details Inputs: none
 * @details 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
 * @details Outputs: watchdogSelfTestState
 * @return in progress, passed, or failed
 *************************************************************************/
SELF_TEST_STATUS_T execWatchdogTest( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS;

#ifndef DISABLE_WD_AND_SFTY_POST_TESTS
    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_LOW )
            {
                F32 v24 = getIntADCVoltageConverted( INT_ADC_24V_ACTUATORS );
                F32 audioCurrent = getFPGABackupAlarmAudioCurrent();

                // Verify 24V is down when w.d. expired
                if ( v24 > MAX_24V_LEVEL_ON_WATCHDOG_EXPIRED )
                {
                    SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED, 2.0, v24 );
                    watchdogSelfTestStatus = SELF_TEST_STATUS_FAILED;
                }
#ifndef DISABLE_ALARM_AUDIO
                // Verify backup alarm audio is on when w.d. expired
                else if ( audioCurrent < MIN_BACKUP_ALARM_CURRENT_MA )
                {
                    SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED, 3.0, audioCurrent );
                    watchdogSelfTestStatus = SELF_TEST_STATUS_FAILED;
                }
#endif
            }
            else
            {
                SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED, 1 );
                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 ) )
            {   // Verify watchdog expired signal no longer active
                if ( getCPLDWatchdogExpired() == PIN_SIGNAL_HIGH )
                {
                    F32 v24 = getIntADCVoltageConverted( INT_ADC_24V_ACTUATORS );
                    F32 audioCurrent = getFPGABackupAlarmAudioCurrent();

                    // Verify 24V is down when w.d. recovered
                    if ( v24 < MIN_24V_LEVEL_ON_WATCHDOG_RECOVER )
                    {
                        SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED, 4.0, v24 );
                        watchdogSelfTestStatus = SELF_TEST_STATUS_FAILED;
                    }
#ifndef DISABLE_ALARM_AUDIO
                    // Verify backup alarm audio is on when w.d. recovered
                    else if ( audioCurrent > MAX_BACKUP_ALARM_CURRENT_MA )
                    {
                        SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_WATCHDOG_POST_TEST_FAILED, 5.0, audioCurrent );
                        watchdogSelfTestStatus = SELF_TEST_STATUS_FAILED;
                    }
#endif
                    else
                    {
                        watchdogSelfTestStatus = SELF_TEST_STATUS_PASSED;
                    }
                }
                result = watchdogSelfTestStatus;
                watchdogSelfTestState = WATCHDOG_SELF_TEST_STATE_COMPLETE;
            }
            break;

        case WATCHDOG_SELF_TEST_STATE_COMPLETE:
            // If we get called in this state, assume we are 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;
    }
#else
    watchdogSelfTestStatus = SELF_TEST_STATUS_PASSED;
    result = watchdogSelfTestStatus;
#endif

    return result;
}

/*********************************************************************//**
 * @brief
 * The resetWDTaskCheckIns function resets the task check-ins with the watchdog.
 * @details Inputs: none
 * @details 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[]
 * @details 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[]
 * @details 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
 * @details Outputs: CPLD WD pet signal is pulsed
 * @return none
 *************************************************************************/
static void petWatchdog( void )
{
    // Pulse the watchdog signal
    toggleCPLDWatchdog();

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

/**@}*/