#include "watchdog.h"
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <linux/watchdog.h>

using namespace MityDSP;

/**
 *  Constructor for the watchdog abstraction
 *
 *  \param apDevice filename of device (defaults to /dev/watchdog)
 */
tcWatchdog::tcWatchdog(const char* apDevice)
: mnMask(0)
, mnSet(0)
, mnFd(-1)
{
	sem_init(&mhSem, 0, 1);
	mpFileName = new char[strlen(apDevice)+1];
	strcpy(mpFileName, apDevice);
}

/**
 *  Destructor.  Shuts down running watchdog.  cleans up resources.
 */
tcWatchdog::~tcWatchdog(void)
{
	const char *no_reboot = "V\n";
	if (mnFd >= 0)
	{
		printf("shutting down watchdog\n");
		write(mnFd,no_reboot,strlen(no_reboot));
		close(mnFd);
	}
	delete [] mpFileName;
	sem_destroy(&mhSem);
}

/**
 *   Enable the watchdog.  This should typically be
 *   called after at least 1 checkpoint has been registered
 *   and the application is ready for the watchdog operation
 *   to begin.
 *
 *   \param TimeoutSecs number of seconds before watchdog timeout
 *   \return non-zero on error.
 */
int tcWatchdog::StartWatchDog(int TimeoutSecs)
{
	mnFd = open(mpFileName, O_RDWR);
	if (mnFd < 0)
	{
		perror("open watchdog:");
		return mnFd;
	}
	// NOTE: L138 watchdog driver doesn't support WDIOC_SETTIMEOUT.
	//  Timeout defaults to 60 seconds
	ioctl(mnFd,WDIOC_SETTIMEOUT,&TimeoutSecs);
	return 0;
}

/**
 *  Register a checkpoint.  The tcWatchdog class supports multiple
 *  checkpoints (or threads, etc.) that must Checkin() prior to the
 *  watchdog being tagged.  This routine generates a handle for a 
 *  newly registered checkpoint.
 *
 *  \return handle to use for Checkin() or -1 on failure.
 */
int tcWatchdog::RegisterCheckpoint(void)
{
	int i, mask;
	int rv = -1;
	sem_wait(&mhSem);
	/* find next available slot in mask */
	for (i = 0, mask=1; i < 31; i++, mask<<=1)
	{
		if (!(mask & mnMask))
		{
			mnMask |= mask;
			rv = mask;
			break;
		}
	}
	sem_post(&mhSem);
	return rv;
}

/**
 *  Remove a registered checkpoint from the monitor list.
 *  \param handle the checkpoint previously from RegisterCheckpoint
 *  \return non-zero on error.
 */
int tcWatchdog::UnRegisterCheckpoint(int handle)
{
	int rv = -1;
	sem_wait(&mhSem);
	if (handle & mnMask)
	{
		mnMask &= ~handle;
		rv = 0;
	}
	sem_post(&mhSem);
	return rv;
}

/**
 *  Check in for the watchdog update.  When all registered 
 *  methods have checked in, the watchdog timer will be
 *  tagged/reset.
 *
 *  \param Checkpoint checkpoint handle from RegisterCheckpoint
 *
 *  \return non-zero on error.
 */
int tcWatchdog::Checkin(int Checkpoint)
{
	if (mnFd < 0)
		return -1;

	sem_wait(&mhSem);
	mnSet |= Checkpoint;
	if (mnSet == mnMask)
	{
		/* tag watchdog */
		mnSet = 0;
		ioctl(mnFd, WDIOC_KEEPALIVE, 0);
	}
	sem_post(&mhSem);

	return 0;
}

#ifdef WATCHDOG_MAIN
int main()
{
	tcWatchdog watch;
	int watchHandle;

	printf("Starting watchdog! Timeout interval 60s.\n");
	watch.StartWatchDog(60000);
	watchHandle = watch.RegisterCheckpoint();

	while (1 == 1)
	{
		printf(".");
		fflush(stdout);

		// Tickle watchdog
		watch.Checkin(watchHandle);
		// Sleep 1 second
		sleep(1);
	}

	return 0;
}
#endif