/*
 *  kempld_wdt.c - Kontron PLD watchdog driver
 *
 *  Copyright (c) 2010 Kontron Embedded Modules GmbH
 *  Author: Michael Brunner <michael.brunner@kontron.com>
 *  Author: Erwan Velu <erwan.velu@zodiacaerospace.com>
 *
 *  Note: From the PLD watchdog point of view timeout and pretimeout are
 *        defined differently than in the kernel.
 *        First the pretimeout stage runs out before the timeout stage gets
 *        active. This has to be kept in mind.
 *
 *  Kernel/API:                     P-----| pretimeout
 *                |-----------------------T timeout
 *  Watchdog:     |-----------------P       pretimeout_stage
 *                                  |-----T timeout_stage
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License 2 as published
 *  by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <string.h>
#include <sys/io.h>
#include <unistd.h>
#include <syslinux/boot.h>
#include <stdio.h>
#include <stdlib.h>
#include <console.h>
#include "kontron_wdt.h"

struct kempld_device_data  pld;
struct kempld_watchdog_data wdt;
uint8_t status;
char default_label[255];

/* Default Timeout is 60sec */
#define TIMEOUT 60
#define PRETIMEOUT 0

#define do_div(n,base) ({ \
		int __res; \
		__res = ((unsigned long) n) % (unsigned) base; \
		n = ((unsigned long) n) / (unsigned) base; \
		__res; })


/* Basic Wrappers to get code as less changed as possible */
void iowrite8(uint8_t val, uint16_t addr) { outb(val,addr); }
void iowrite16(uint16_t val, uint16_t addr) { outw(val,addr); }
void iowrite32(uint32_t val, uint16_t addr) { outl(val,addr);}
uint8_t ioread8(uint16_t addr)   { return inb(addr);}
uint16_t ioread16(uint16_t addr) { return inw(addr);}
uint32_t ioread32(uint32_t addr) { return inl(addr);}


/**
 * kempld_set_index -  change the current register index of the PLD
 * @pld:   kempld_device_data structure describing the PLD
 * @index: register index on the chip
 *
 * This function changes the register index of the PLD.
 */
void kempld_set_index(struct kempld_device_data *pld, uint8_t index)
{
        if (pld->last_index != index) {
                iowrite8(index, pld->io_index);
                pld->last_index = index;
        }
}


uint8_t kempld_read8(struct kempld_device_data *pld, uint8_t index) {
        kempld_set_index(pld, index);
        return ioread8(pld->io_data);
}


void kempld_write8(struct kempld_device_data *pld, uint8_t index, uint8_t data) {
        kempld_set_index(pld, index);
        iowrite8(data, pld->io_data);
}


uint16_t kempld_read16(struct kempld_device_data *pld, uint8_t index)
{
        return kempld_read8(pld, index) | kempld_read8(pld, index+1) << 8;
}


void kempld_write16(struct kempld_device_data *pld, uint8_t index, uint16_t data)
{
        kempld_write8(pld, index, (uint8_t)data);
        kempld_write8(pld, index+1, (uint8_t)(data>>8));
}

uint32_t kempld_read32(struct kempld_device_data *pld, uint8_t index)
{
        return kempld_read16(pld, index) | kempld_read16(pld, index+2) << 16;
}

void kempld_write32(struct kempld_device_data *pld, uint8_t index, uint32_t data)
{
        kempld_write16(pld, index, (uint16_t)data);
        kempld_write16(pld, index+2, (uint16_t)(data>>16));
}

static void kempld_release_mutex(struct kempld_device_data *pld)
{
        iowrite8(pld->last_index | KEMPLD_MUTEX_KEY, pld->io_index);
}

void init_structure(void) {
	/* set default values for the case we start the watchdog or change
	 * the configuration */
	memset(&wdt,0,sizeof(wdt));
	memset(&pld,0,sizeof(pld));
	memset(&default_label,0,sizeof(default_label));
        wdt.timeout = TIMEOUT;
        wdt.pretimeout = PRETIMEOUT;
        wdt.pld = &pld;

	pld.io_base=KEMPLD_IOPORT;
	pld.io_index=KEMPLD_IOPORT;
	pld.io_data=KEMPLD_IODATA;
	pld.pld_clock=33333333;
}

static int kempld_probe(void) {
   /* Check for empty IO space */
	int ret=0;
	uint8_t  index_reg = ioread8(pld.io_index);
        if ((index_reg == 0xff) && (ioread8(pld.io_data) == 0xff)) {
                ret = 1;
                goto err_empty_io;
        }
	printf("Kempld structure found at 0x%X (data @ 0x%X)\n",pld.io_base,pld.io_data);
	return 0;

err_empty_io:
	printf("No IO Found !\n");
	return ret;
}

static int kempld_wdt_probe_stages(struct kempld_watchdog_data *wdt)
{
        struct kempld_device_data *pld = wdt->pld;
        int i, ret;
        uint32_t timeout;
        uint32_t timeout_mask;
        struct kempld_watchdog_stage *stage;

        wdt->stages = 0;
        wdt->timeout_stage = NULL;
        wdt->pretimeout_stage = NULL;

        for (i = 0; i < KEMPLD_WDT_MAX_STAGES; i++) {

		timeout = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(i));
                kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(i), 0x00000000);
                timeout_mask = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(i));
                kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(i), timeout);

                if (timeout_mask != 0xffffffff) {
                        stage = malloc(sizeof(struct kempld_watchdog_stage));
                        if (stage == NULL) {
                                ret = -1;
                                goto err_alloc_stages;
                        }
                        stage->num = i;
                        stage->timeout_mask = ~timeout_mask;
                        wdt->stage[i] = stage;
                        wdt->stages++;

                        /* assign available stages to timeout and pretimeout */
                        if (wdt->stages == 1)
                                wdt->timeout_stage = stage;
                        else if (wdt->stages == 2) {
                                wdt->pretimeout_stage = wdt->timeout_stage;
                                wdt->timeout_stage = stage;
                        }
                } else {
                        wdt->stage[i] = NULL;
                }
        }

        return 0;
err_alloc_stages:
	kempld_release_mutex(pld);
	printf("Cannot allocate stages\n");
	return ret;
}

static int kempld_wdt_keepalive(struct kempld_watchdog_data *wdt)
{
        struct kempld_device_data *pld = wdt->pld;

	kempld_write8(pld, KEMPLD_WDT_KICK, 'K');

        return 0;
}

static int kempld_wdt_setstageaction(struct kempld_watchdog_data *wdt,
                                 struct kempld_watchdog_stage *stage,
                                 int action)
{
        struct kempld_device_data *pld = wdt->pld;
        uint8_t stage_cfg;

        if (stage == NULL)
                return -1;

        stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->num));
        stage_cfg &= ~KEMPLD_WDT_STAGE_CFG_ACTION_MASK;
        stage_cfg |= (action & KEMPLD_WDT_STAGE_CFG_ACTION_MASK);
        if (action == KEMPLD_WDT_ACTION_RESET)
                stage_cfg |= KEMPLD_WDT_STAGE_CFG_ASSERT;
        else
                stage_cfg &= ~KEMPLD_WDT_STAGE_CFG_ASSERT;

        kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->num), stage_cfg);
        stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->num));

        return 0;
}

static int kempld_wdt_setstagetimeout(struct kempld_watchdog_data *wdt,
                                 struct kempld_watchdog_stage *stage,
                                 int timeout)
{
        struct kempld_device_data *pld = wdt->pld;
        uint8_t stage_cfg;
        uint8_t prescaler;
        uint64_t stage_timeout64;
        uint32_t stage_timeout;

        if (stage == NULL)
                return -1;

        prescaler = KEMPLD_WDT_PRESCALER_21BIT;

        stage_timeout64 = ((uint64_t)timeout*pld->pld_clock);
        do_div(stage_timeout64, KEMPLD_PRESCALER(prescaler));
        stage_timeout = stage_timeout64 & stage->timeout_mask;

        if (stage_timeout64 != (uint64_t)stage_timeout)
                return -1;

        stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->num));
        stage_cfg &= ~KEMPLD_WDT_STAGE_CFG_PRESCALER_MASK;
        stage_cfg |= KEMPLD_WDT_STAGE_CFG_SET_PRESCALER(prescaler);
        kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->num), stage_cfg);
        kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->num),
                       stage_timeout);

        return 0;
}


static int kempld_wdt_settimeout(struct kempld_watchdog_data *wdt)
{
        int stage_timeout;
        int stage_pretimeout;
        int ret;
        if ((wdt->timeout <= 0) ||
            (wdt->pretimeout < 0) ||
            (wdt->pretimeout > wdt->timeout)) {
                ret = -1;
                goto err_check_values;
        }

        if ((wdt->pretimeout == 0) || (wdt->pretimeout_stage == NULL)) {
                if (wdt->pretimeout != 0)
                        printf("No pretimeout stage available, only enabling reset!\n");
                stage_pretimeout = 0;
                stage_timeout =  wdt->timeout;
        } else {
                stage_pretimeout = wdt->timeout - wdt->pretimeout;
                stage_timeout =  wdt->pretimeout;
        }

        if (stage_pretimeout != 0) {
                ret = kempld_wdt_setstageaction(wdt, wdt->pretimeout_stage,
                                                KEMPLD_WDT_ACTION_NMI);
        } else if ((stage_pretimeout == 0)
                   && (wdt->pretimeout_stage != NULL)) {
                ret = kempld_wdt_setstageaction(wdt, wdt->pretimeout_stage,
                                                KEMPLD_WDT_ACTION_NONE);
        } else
                ret = 0;
        if (ret)
                goto err_setstage;

        if (stage_pretimeout != 0) {
                ret = kempld_wdt_setstagetimeout(wdt, wdt->pretimeout_stage,
                                                 stage_pretimeout);
                if (ret)
                        goto err_setstage;
        }

        ret = kempld_wdt_setstageaction(wdt, wdt->timeout_stage,
                                        KEMPLD_WDT_ACTION_RESET);
        if (ret)
                goto err_setstage;

        ret = kempld_wdt_setstagetimeout(wdt, wdt->timeout_stage,
                                         stage_timeout);
        if (ret)
                goto err_setstage;

        return 0;
err_setstage:
err_check_values:
        return ret;
}

static int kempld_wdt_start(struct kempld_watchdog_data *wdt)
{
        struct kempld_device_data *pld = wdt->pld;
        uint8_t status;

        status = kempld_read8(pld, KEMPLD_WDT_CFG);
        status |= KEMPLD_WDT_CFG_ENABLE;
        kempld_write8(pld, KEMPLD_WDT_CFG, status);
        status = kempld_read8(pld, KEMPLD_WDT_CFG);

        /* check if the watchdog was enabled */
        if (!(status & KEMPLD_WDT_CFG_ENABLE))
                return -1;

        return 0;
}

/* A regular configuration file looks like

   LABEL WDT
       COM32 wdt.c32
       APPEND timeout=120 default_label=local
*/
void detect_parameters(const int argc, const char *argv[]) {
	for (int i = 1; i < argc; i++) {
		/* Override the timeout if specified on the cmdline */
		if (!strncmp(argv[i], "timeout=", 8)) {
			wdt.timeout=atoi(argv[i]+8);
		} else
		/* Define which boot entry shall be used */
		if (!strncmp(argv[i], "default_label=", 14)) {
			strlcpy(default_label, argv[i] + 14, sizeof(default_label));
		}
	}
}

int main(int argc, const char *argv[]) {
	int ret=0;
	openconsole(&dev_rawcon_r, &dev_stdcon_w);
	init_structure();
	detect_parameters(argc,argv);
	kempld_probe();

        /* probe how many usable stages we have */
        if (kempld_wdt_probe_stages(&wdt)) {
		printf("Cannot Probe Stages\n");
		return -1;
	}

	/* Useless but who knows */
	wdt.ident.firmware_version = KEMPLD_WDT_REV_GET(kempld_read8(&pld, KEMPLD_WDT_REV));

        status = kempld_read8(&pld, KEMPLD_WDT_CFG);
	/* kick the watchdog if it is already enabled, otherwise start it */
        if (status & KEMPLD_WDT_CFG_ENABLE) {
		/* Maybye the BIOS did setup a first timer
		 * in this case, let's enforce the timeout
		 * to be sure we do have the proper value */
		kempld_wdt_settimeout(&wdt);
                kempld_wdt_keepalive(&wdt);
        } else {
		ret = kempld_wdt_settimeout(&wdt);
                if (ret) {
			printf("Unable to setup timeout !\n");
			goto booting;
		}

		ret = kempld_wdt_start(&wdt);
                if (ret) {
			printf("Unable to start watchdog !\n");
			goto booting;
		}

        }

	printf("Watchog armed ! Rebooting in %d seconds if no feed occurs !\n",wdt.timeout);

booting:
	/* Release Mutex to let Linux's Driver taking control */
        kempld_release_mutex(&pld);

	/* Let's boot the default entry if specified */
	if (strlen(default_label)>0) {
		printf("Executing default label = '%s'\n",default_label);
		syslinux_run_command(default_label);
	} else {
		return ret;
	}
}