/*      $OpenBSD: sxirtc.c,v 1.9 2024/01/27 11:22:16 kettenis Exp $     */
/*
 * Copyright (c) 2008 Mark Kettenis
 * Copyright (c) 2013 Artturi Alm
 *
 * 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/device.h>
#include <sys/malloc.h>
#include <sys/systm.h>

#include <dev/clock_subr.h>

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

#include <dev/fdt/sunxireg.h>

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

#define SXIRTC_LOSC_CTRL                0x00
#define  SXIRTC_LOSC_CTRL_KEY_FIELD     0x16aa0000
#define  SXIRTC_LOSC_CTRL_SEL_EXT32K    0x00000001
#define SXIRTC_YYMMDD_A10               0x04
#define SXIRTC_HHMMSS_A10               0x08
#define SXIRTC_YYMMDD_A31               0x10
#define SXIRTC_HHMMSS_A31               0x14
#define SXIRTC_LOSC_OUT_GATING          0x60

#define LEAPYEAR(y)        \
    (((y) % 4 == 0 &&    \
    (y) % 100 != 0) ||    \
    (y) % 400 == 0) 

struct sxirtc_softc {
        struct device           sc_dev;
        bus_space_tag_t         sc_iot;
        bus_space_handle_t      sc_ioh;

        struct clock_device     sc_cd;

        bus_size_t              sc_yymmdd;
        bus_size_t              sc_hhmmss;
        uint32_t                base_year;
        uint32_t                year_mask;
        uint32_t                leap_shift;
        int                     linear_day;
};

int     sxirtc_match(struct device *, void *, void *);
void    sxirtc_attach(struct device *, struct device *, void *);

const struct cfattach sxirtc_ca = {
        sizeof(struct sxirtc_softc), sxirtc_match, sxirtc_attach
};

struct cfdriver sxirtc_cd = {
        NULL, "sxirtc", DV_DULL
};

uint32_t sxirtc_get_frequency(void *, uint32_t *);
void    sxirtc_enable(void *, uint32_t *, int);
int     sxirtc_gettime(todr_chip_handle_t, struct timeval *);
int     sxirtc_settime(todr_chip_handle_t, struct timeval *);

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

        return (OF_is_compatible(faa->fa_node, "allwinner,sun4i-a10-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun7i-a20-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun6i-a31-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun8i-h3-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-h5-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-h616-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-r329-rtc"));
}

void
sxirtc_attach(struct device *parent, struct device *self, void *aux)
{
        struct sxirtc_softc *sc = (struct sxirtc_softc *)self;
        struct fdt_attach_args *faa = aux;
        todr_chip_handle_t handle;

        if (faa->fa_nreg < 1)
                return;

        handle = malloc(sizeof(struct todr_chip_handle), M_DEVBUF, M_NOWAIT);
        if (handle == NULL)
                panic("sxirtc_attach: couldn't allocate todr_handle");

        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("sxirtc_attach: bus_space_map failed!");

        if (OF_is_compatible(faa->fa_node, "allwinner,sun6i-a31-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun8i-h3-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-h5-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-h616-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-r329-rtc")) {
                sc->sc_yymmdd = SXIRTC_YYMMDD_A31;
                sc->sc_hhmmss = SXIRTC_HHMMSS_A31;
        } else {
                sc->sc_yymmdd = SXIRTC_YYMMDD_A10;
                sc->sc_hhmmss = SXIRTC_HHMMSS_A10;
        }

        if (OF_is_compatible(faa->fa_node, "allwinner,sun7i-a20-rtc")) {
                sc->base_year = 1970;
                sc->year_mask = 0xff;
                sc->leap_shift = 24;
        } else {
                sc->base_year = 2010;
                sc->year_mask = 0x3f;
                sc->leap_shift = 22;
        }

        /*
         * Newer SoCs store the number of days since a fixed epoch
         * instead of YYMMDD.  Take this to be the number of days
         * since the Unix epoch since that is what Linux does.
         */
        if (OF_is_compatible(faa->fa_node, "allwinner,sun50i-h616-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-r329-rtc")) {
                sc->base_year = 1970;
                sc->linear_day = 1;
        }

        if (OF_is_compatible(faa->fa_node, "allwinner,sun8i-h3-rtc") ||
            OF_is_compatible(faa->fa_node, "allwinner,sun50i-h5-rtc")) {
                /* Switch to external oscillator. */
                SXIWRITE4(sc, SXIRTC_LOSC_CTRL,
                    SXIRTC_LOSC_CTRL_KEY_FIELD | SXIRTC_LOSC_CTRL_SEL_EXT32K);

                sc->sc_cd.cd_node = faa->fa_node;
                sc->sc_cd.cd_cookie = sc;
                sc->sc_cd.cd_get_frequency = sxirtc_get_frequency;
                sc->sc_cd.cd_enable = sxirtc_enable;
                clock_register(&sc->sc_cd);
        }

        handle->cookie = self;
        handle->todr_gettime = sxirtc_gettime;
        handle->todr_settime = sxirtc_settime;
        handle->bus_cookie = NULL;
        handle->todr_setwen = NULL;
        handle->todr_quality = 0;
        todr_attach(handle);

        printf("\n");
}

uint32_t
sxirtc_get_frequency(void *cookie, uint32_t *cells)
{
        struct sxirtc_softc *sc = cookie;
        uint32_t idx = cells[0];

        switch (idx) {
        case 0:                 /* osc32k */
        case 1:                 /* osc32k-out */
                return clock_get_frequency_idx(sc->sc_cd.cd_node, 0);
        case 2:                 /* iosc */
                return 16000000;
        }

        printf("%s: 0x%08x\n", __func__, idx);
        return 0;
}

void
sxirtc_enable(void *cookie, uint32_t *cells, int on)
{
        struct sxirtc_softc *sc = cookie;
        uint32_t idx = cells[0];

        switch (idx) {
        case 0:                 /* osc32k */
                break;
        case 1:                 /* osc32k-out */
                if (on)
                        SXISET4(sc, SXIRTC_LOSC_OUT_GATING, 1);
                else
                        SXICLR4(sc, SXIRTC_LOSC_OUT_GATING, 1);
                break;
        case 2:                 /* iosc */
                break;
        default:
                printf("%s: 0x%08x\n", __func__, idx);
                break;
        }
}

int
sxirtc_gettime(todr_chip_handle_t handle, struct timeval *tv)
{
        struct sxirtc_softc *sc = (struct sxirtc_softc *)handle->cookie;
        struct clock_ymdhms dt;
        uint32_t reg;

        reg = SXIREAD4(sc, sc->sc_yymmdd);
        if (sc->linear_day) {
                clock_secs_to_ymdhms(reg * SECDAY, &dt);
        } else {
                dt.dt_day = reg & 0x1f;
                dt.dt_mon = reg >> 8 & 0x0f;
                dt.dt_year = (reg >> 16 & sc->year_mask) + sc->base_year;
        }

        reg = SXIREAD4(sc, sc->sc_hhmmss);
        dt.dt_sec = reg & 0x3f;
        dt.dt_min = reg >> 8 & 0x3f;
        dt.dt_hour = reg >> 16 & 0x1f;
        dt.dt_wday = reg >> 29 & 0x07;

        if (dt.dt_sec > 59 || dt.dt_min > 59 ||
            dt.dt_hour > 23 || dt.dt_wday > 6 ||
            dt.dt_day > 31 || dt.dt_day == 0 ||
            dt.dt_mon > 12 || dt.dt_mon == 0)
                return 1;

        /*
         * Reject the first year that can be represented by the clock.
         * This avoids reporting a bogus time if the RTC isn't battery
         * powered.
         */
        if (dt.dt_year == sc->base_year)
                return 1;

        tv->tv_sec = clock_ymdhms_to_secs(&dt);
        tv->tv_usec = 0;
        return 0;
}

int
sxirtc_settime(todr_chip_handle_t handle, struct timeval *tv)
{
        struct sxirtc_softc *sc = (struct sxirtc_softc *)handle->cookie;
        struct clock_ymdhms dt;

        clock_secs_to_ymdhms(tv->tv_sec, &dt);

        if (dt.dt_sec > 59 || dt.dt_min > 59 ||
            dt.dt_hour > 23 || dt.dt_wday > 6 ||
            dt.dt_day > 31 || dt.dt_day == 0 ||
            dt.dt_mon > 12 || dt.dt_mon == 0)
                return 1;

        SXICMS4(sc, sc->sc_hhmmss, 0xe0000000 | 0x1f0000 | 0x3f00 | 0x3f,
            dt.dt_sec | (dt.dt_min << 8) | (dt.dt_hour << 16) |
            (dt.dt_wday << 29));

        if (sc->linear_day) {
                SXICMS4(sc, sc->sc_yymmdd, 0xffff, tv->tv_sec / SECDAY);
        } else {
                SXICMS4(sc, sc->sc_yymmdd, 0x00400000 | (sc->year_mask << 16) |
                    0x0f00 | 0x1f, dt.dt_day | (dt.dt_mon << 8) |
                    ((dt.dt_year - sc->base_year) << 16) |
                    (LEAPYEAR(dt.dt_year) << sc->leap_shift));
        }

        return 0;
}