#include "driverlib/watchdog.h"

/* Enable WDT0 clock */
SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
while (!SysCtlPeripheralReady(SYSCTL_PERIPH_WDOG0));

/* Set timeout: 1 second at 80 MHz = 80,000,000 cycles */
WatchdogReloadSet(WATCHDOG0_BASE, 80000000);

/* Enable watchdog interrupt (first timeout = IRQ) */
WatchdogIntEnable(WATCHDOG0_BASE);

/* Enable reset on second timeout */
WatchdogResetEnable(WATCHDOG0_BASE);

/* Unlock registers before modifying (if previously locked) */
/* WatchdogUnlock(WATCHDOG0_BASE); */

/* Enable the watchdog — once enabled, RESEN cannot be cleared */
WatchdogEnable(WATCHDOG0_BASE);

/* Lock the watchdog to prevent accidental disable */
WatchdogLock(WATCHDOG0_BASE);

/* Enable watchdog interrupt in NVIC */
IntEnable(INT_WATCHDOG);
IntMasterEnable();

/* Reset the countdown — call this regularly to prevent timeout */
void WatchdogFeed(void)
{
    WatchdogReloadSet(WATCHDOG0_BASE, 80000000);  // reload = reset countdown
}

#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_watchdog.h"

void WDT0_Init(uint32_t ui32Timeout)
{
    /* Enable WDT0 clock */
    HWREG(SYSCTL_RCGCWD) |= (1U << 0);
    while (!(HWREG(SYSCTL_PRWD) & (1U << 0)));

    /* Unlock the watchdog (write magic key 0x1ACCE551) */
    HWREG(WATCHDOG0_BASE + WDT_O_LOCK) = WDT_LOCK_UNLOCK;  // 0x1ACCE551

    /* Set reload value */
    HWREG(WATCHDOG0_BASE + WDT_O_LOAD) = ui32Timeout;

    /* Enable interrupt (INTEN=1) and reset (RESEN=1) */
    HWREG(WATCHDOG0_BASE + WDT_O_CTL) = WDT_CTL_INTEN | WDT_CTL_RESEN;

    /* Enable stall-in-debug (stops WDT when CCS halts CPU) */
    HWREG(WATCHDOG0_BASE + WDT_O_TEST) |= WDT_TEST_STALL;

    /* Lock registers to prevent accidental modification */
    HWREG(WATCHDOG0_BASE + WDT_O_LOCK) = WDT_LOCK_LOCKED;  // any value ≠ key

    /* Enable NVIC interrupt for WDT0 (IRQ 18) */
    HWREG(NVIC_EN0) = (1U << (INT_WATCHDOG - 16));
}

/* Feed the watchdog — must be called before timeout */
void WDT0_Feed(void)
{
    /* Unlock to allow writing LOAD */
    HWREG(WATCHDOG0_BASE + WDT_O_LOCK) = WDT_LOCK_UNLOCK;
    HWREG(WATCHDOG0_BASE + WDT_O_LOAD) = 80000000;  // reload 1 second
    HWREG(WATCHDOG0_BASE + WDT_O_LOCK) = WDT_LOCK_LOCKED;
}

void Watchdog_Handler(void)
{
    /* Clear the watchdog interrupt (WDTICR) */
    WatchdogIntClear(WATCHDOG0_BASE);

    /* Log the event, attempt recovery */
    /* WARNING: if we return without petting the dog,
     * the second timeout (RESEN) will generate a hardware reset */

    /* Attempt emergency pet if we can safely do so */
    /* WatchdogFeed(); */

    /* Or intentionally let the second timeout reset the system */
}

void CheckResetCause(void)
{
    uint32_t ui32ResetCause = SysCtlResetCauseGet();
    SysCtlResetCauseClear(ui32ResetCause);  // clear for next boot

    if (ui32ResetCause & SYSCTL_CAUSE_WDOG0)
    {
        /* System was reset by WDT0 — log it, notify user */
        /* Set a flag in a non-volatile RAM region preserved across resets */
    }
    else if (ui32ResetCause & SYSCTL_CAUSE_POR)
    {
        /* Power-on reset — normal startup */
    }
    else if (ui32ResetCause & SYSCTL_CAUSE_EXT)
    {
        /* External reset pin was asserted */
    }
}

/*
 * watchdog_demo.c
 * WDT0 configured for 1-second timeout.
 * Main loop pets the dog every 500 ms.
 * SW1 (PF4) held down simulates a hang — WDT resets the system.
 * After reset, the firmware detects the WDT cause and blinks blue LED.
 * Board  : TM4C123GXL EK LaunchPad
 * SDK    : TivaWare_C_Series-2.2.x
 */

#include <stdint.h>
#include <stdbool.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/watchdog.h"
#include "driverlib/interrupt.h"

static bool g_bWdtReset = false;

void Watchdog_Handler(void)
{
    WatchdogIntClear(WATCHDOG0_BASE);
    /* Do not pet — allow second timeout to reset system */
}

int main(void)
{
    /* Step 1: 80 MHz clock */
    SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL |
                   SYSCTL_OSC_MAIN   | SYSCTL_XTAL_16MHZ);

    /* Step 2: Check if last reset was caused by WDT */
    uint32_t ui32Cause = SysCtlResetCauseGet();
    SysCtlResetCauseClear(ui32Cause);
    if (ui32Cause & SYSCTL_CAUSE_WDOG0)
        g_bWdtReset = true;

    /* Step 3: Configure LEDs and SW1 */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    while (!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOF));
    GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,
                          GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
    GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
    GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4,
                     GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);

    /* Step 4: Indicate WDT reset with blue LED on boot */
    if (g_bWdtReset)
    {
        /* Blink blue LED 5 times to signal WDT reset */
        int i;
        for (i = 0; i < 5; i++)
        {
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
            SysCtlDelay(SysCtlClockGet() / 6);  // 500 ms
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
            SysCtlDelay(SysCtlClockGet() / 6);
        }
    }

    /* Step 5: Configure WDT0 for 1-second timeout */
    SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
    while (!SysCtlPeripheralReady(SYSCTL_PERIPH_WDOG0));

    WatchdogReloadSet(WATCHDOG0_BASE, SysCtlClockGet());  // 1 second
    WatchdogIntEnable(WATCHDOG0_BASE);
    WatchdogResetEnable(WATCHDOG0_BASE);

    /* Pause watchdog during CCS debug halt */
    WatchdogStallEnable(WATCHDOG0_BASE);

    WatchdogEnable(WATCHDOG0_BASE);
    WatchdogLock(WATCHDOG0_BASE);

    IntEnable(INT_WATCHDOG);
    IntMasterEnable();

    /* Step 6: Normal operation — pet the dog every 500 ms
     * Hold SW1 to simulate a hang (no pet → WDT resets) */
    while (1)
    {
        /* Normal heartbeat: green LED on */
        GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3);
        SysCtlDelay(SysCtlClockGet() / 6);  // 500 ms

        GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
        SysCtlDelay(SysCtlClockGet() / 6);  // 500 ms

        /* If SW1 is held: do not pet → WDT fires and resets */
        if (!GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4))
        {
            /* Simulate hang: Red LED on, no pet */
            GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);
            while (!GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4));
            /* When WDT fires, Watchdog_Handler clears ISR but does NOT pet
               → second timeout → hardware reset */
        }

        /* Pet the watchdog (unlock → reload → lock) */
        WatchdogUnlock(WATCHDOG0_BASE);
        WatchdogReloadSet(WATCHDOG0_BASE, SysCtlClockGet());
        WatchdogLock(WATCHDOG0_BASE);
    }
}