/* $OpenBSD: sxidog.c,v 1.4 2024/01/26 17:03:45 kettenis Exp $ */
/*
 * Copyright (c) 2007,2009 Dale Rahn <drahn@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>

#include <machine/bus.h>
#include <machine/fdt.h>

#include <dev/fdt/sunxireg.h>

#include <dev/ofw/openfirm.h>
#include <dev/ofw/fdt.h>

extern void (*cpuresetfn)(void);

/* Allwinner A10 registers */
#define WDOG_CTRL_REG           0x00
#define  WDOG_KEY               (0x0a57 << 1)
#define  WDOG_RSTART            0x01
#define WDOG_MODE_REG           0x04
#define  WDOG_EN                (1 << 0)
#define  WDOG_RST_EN            (1 << 1) /* system reset */
#define  WDOG_INTV_VALUE(x)     ((x) << 3)

/* Allwinner A31 registers */
#define WDOG0_CTRL_REG          0x10
#define  WDOG0_KEY              (0x0a57 << 1)
#define  WDOG0_RSTART           (1 << 0)
#define WDOG0_CFG_REG           0x14
#define  WDOG0_RST_EN           (1 << 0)
#define WDOG0_MODE_REG          0x18
#define  WDOG0_EN               (1 << 0)
#define  WDOG0_INTV_VALUE(x)    ((x) << 4)

struct sxidog_softc {
        struct device           sc_dev;
        bus_space_tag_t         sc_iot;
        bus_space_handle_t      sc_ioh;
        int                     sc_type;
#define SXIDOG_A10              0
#define SXIDOG_A31              1
        uint32_t                sc_key;
};

struct sxidog_softc *sxidog_sc = NULL;  /* for sxidog_reset() */

int sxidog_match(struct device *, void *, void *);
void sxidog_attach(struct device *, struct device *, void *);
int sxidog_activate(struct device *, int);
int sxidog_callback(void *, int);
void sxidog_reset(void);

const struct cfattach   sxidog_ca = {
        sizeof (struct sxidog_softc), sxidog_match, sxidog_attach,
        NULL, sxidog_activate
};

struct cfdriver sxidog_cd = {
        NULL, "sxidog", DV_DULL
};

int
sxidog_match(struct device *parent, void *match, void *aux)
{
        struct fdt_attach_args *faa = aux;

        return (OF_is_compatible(faa->fa_node, "allwinner,sun4i-a10-wdt") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun6i-a31-wdt") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun20i-d1-wdt"));
}

void
sxidog_attach(struct device *parent, struct device *self, void *aux)
{
        struct sxidog_softc *sc = (struct sxidog_softc *)self;
        struct fdt_attach_args *faa = aux;

        if (faa->fa_nreg < 1)
                return;

        sc->sc_iot = faa->fa_iot;
        if (bus_space_map(sc->sc_iot, faa->fa_reg[0].addr,
            faa->fa_reg[0].size, 0, &sc->sc_ioh))
                panic("sxidog_attach: bus_space_map failed!");

        if (OF_is_compatible(faa->fa_node, "allwinner,sun20i-d1-wdt"))
                sc->sc_key = 0x16aa0000;

        if (OF_is_compatible(faa->fa_node, "allwinner,sun6i-a31-wdt") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun20i-d1-wdt")) {
                SXIWRITE4(sc, WDOG0_MODE_REG, sc->sc_key);
                SXIWRITE4(sc, WDOG0_CFG_REG, WDOG0_RST_EN | sc->sc_key);
                sc->sc_type = SXIDOG_A31;
        } else {
                SXIWRITE4(sc, WDOG_MODE_REG, 0);
                sc->sc_type = SXIDOG_A10;
        }

        sxidog_sc = sc;
        cpuresetfn = sxidog_reset;

#ifndef SMALL_KERNEL
        wdog_register(sxidog_callback, sc);
#endif

        printf("\n");
}

int
sxidog_activate(struct device *self, int act)
{
        switch (act) {
        case DVACT_POWERDOWN:
#ifndef SMALL_KERNEL
                wdog_shutdown(self);
#endif
                break;
        }

        return (0);
}

int
sxidog_callback(void *arg, int period)
{
        struct sxidog_softc *sc = (struct sxidog_softc *)arg;
        int enable;

        if (period > 16)
                period = 16;
        else if (period < 0)
                period = 0;

        /* Convert to register encoding. */
        if (period > 6)
                period = 6 + (period - 5) / 2;

        switch (sc->sc_type) {
        case SXIDOG_A10:
                enable = (period > 0) ? WDOG_RST_EN : 0;
                SXIWRITE4(sc, WDOG_MODE_REG,
                    enable | WDOG_EN | WDOG_INTV_VALUE(period));
                SXIWRITE4(sc, WDOG_CTRL_REG, WDOG_KEY | WDOG_RSTART);
                break;
        case SXIDOG_A31:
                enable = (period > 0) ? WDOG0_EN : 0;
                SXIWRITE4(sc, WDOG0_MODE_REG,
                    enable | WDOG0_INTV_VALUE(period) | sc->sc_key);
                SXIWRITE4(sc, WDOG0_CTRL_REG, WDOG0_KEY | WDOG0_RSTART);
                break;
        }

        /* Convert back to seconds. */
        if (period > 6)
                period = 6 + (period - 6) * 2;

        return period;
}

void
sxidog_reset(void)
{
        if (sxidog_sc == NULL)
                return;

        sxidog_callback(sxidog_sc, 1);
        delay(1500000);
}