/* $NetBSD: meson_pwm.c,v 1.6 2024/02/07 04:20:26 msaitoh Exp $ */

/*
 * Copyright (c) 2021 Ryo Shimizu
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: meson_pwm.c,v 1.6 2024/02/07 04:20:26 msaitoh Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/bus.h>
#include <sys/device.h>

#include <dev/fdt/fdtvar.h>
#include <dev/pwm/pwmvar.h>

/*#define MESON_PWM_DEBUG*/

#define MESON_PWM_DUTYCYCLE_A_REG       0x00
#define MESON_PWM_DUTYCYCLE_B_REG       0x01
#define  MESON_PWM_DUTYCYCLE_HIGH       __BITS(31,16)
#define  MESON_PWM_DUTYCYCLE_LOW        __BITS(15,0)
#define MESON_PWM_MISC_AB_REG           0x02
#define  MESON_PWM_MISC_AB_B_CLK_EN     __BIT(23)
#define  MESON_PWM_MISC_AB_B_CLK_DIV    __BITS(22,16)
#define  MESON_PWM_MISC_AB_A_CLK_EN     __BIT(15)
#define  MESON_PWM_MISC_AB_A_CLK_DIV    __BITS(14,8)
#define  MESON_PWM_MISC_AB_B_CLK_SEL    __BITS(7,6)
#define  MESON_PWM_MISC_AB_A_CLK_SEL    __BITS(5,4)
#define  MESON_PWM_MISC_AB_DS_B_EN      __BIT(3)
#define  MESON_PWM_MISC_AB_DS_A_EN      __BIT(2)
#define  MESON_PWM_MISC_AB_PWM_B_EN     __BIT(1)
#define  MESON_PWM_MISC_AB_PWM_A_EN     __BIT(0)
#define MESON_PWM_DELTASIGMA_A_B_REG    0x03
#define MESON_PWM_TIME_AB_REG           0x04
#define MESON_PWM_A2_REG                0x05
#define MESON_PWM_B2_REG                0x06
#define MESON_PWM_BLINK_AB_REG          0x07

#define PWM_READ_REG(sc, reg) \
        bus_space_read_4((sc)->sc_bst, (sc)->sc_bsh, (reg) * 4)
#define PWM_WRITE_REG(sc, reg, val) \
        bus_space_write_4((sc)->sc_bst, (sc)->sc_bsh, (reg) * 4, (val))

static const struct device_compatible_entry compat_data[] = {
        { .compat = "amlogic,meson-g12a-ao-pwm-ab" },
        { .compat = "amlogic,meson-g12a-ao-pwm-cd" },
        { .compat = "amlogic,meson-g12a-ee-pwm" },
        DEVICE_COMPAT_EOL
};

#define MESON_PWM_NCHAN 2
struct meson_pwm_channel {
        struct meson_pwm_softc *mpc_sc;
        struct pwm_controller mpc_pwm;
        struct pwm_config mpc_conf;
        u_int mpc_index;
};

struct meson_pwm_softc {
        device_t sc_dev;
        bus_space_tag_t sc_bst;
        bus_space_handle_t sc_bsh;
        kmutex_t sc_reglock;    /* for PWM_A vs. PWM_B */
        int sc_phandle;
        u_int sc_clkfreq;
        u_int sc_clksource;
        struct meson_pwm_channel sc_pwmchan[MESON_PWM_NCHAN];
};

static int
meson_pwm_enable(pwm_tag_t pwm, bool enable)
{
        struct meson_pwm_channel * const pwmchan = pwm->pwm_priv;
        struct meson_pwm_softc * const sc = device_private(pwm->pwm_dev);
        uint32_t val;

        mutex_enter(&sc->sc_reglock);
        switch (pwmchan->mpc_index) {
        case 0: /* A */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                val &= ~MESON_PWM_MISC_AB_DS_A_EN;
                val |= MESON_PWM_MISC_AB_PWM_A_EN;
                PWM_WRITE_REG(sc, MESON_PWM_MISC_AB_REG, val);
                break;
        case 1: /* B */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                val &= ~MESON_PWM_MISC_AB_DS_B_EN;
                val |= MESON_PWM_MISC_AB_PWM_B_EN;
                PWM_WRITE_REG(sc, MESON_PWM_MISC_AB_REG, val);
                break;
        }
        mutex_exit(&sc->sc_reglock);

        return 0;
}

static void
meson_pwm_get_current(struct meson_pwm_softc *sc, int chan,
    struct pwm_config *conf)
{
        uint64_t period_hz, duty_hz;
        uint32_t val;
        u_int period, duty, clk_div, hi, lo;

        memset(conf, 0, sizeof(*conf));

        mutex_enter(&sc->sc_reglock);
        switch (chan) {
        case 0: /* A */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                clk_div = __SHIFTOUT(val, MESON_PWM_MISC_AB_A_CLK_DIV);
                val = PWM_READ_REG(sc, MESON_PWM_DUTYCYCLE_A_REG);
                hi = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_HIGH);
                lo = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_LOW);
                break;
        case 1: /* B */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                clk_div = __SHIFTOUT(val, MESON_PWM_MISC_AB_B_CLK_DIV);
                val = PWM_READ_REG(sc, MESON_PWM_DUTYCYCLE_B_REG);
                hi = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_HIGH);
                lo = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_LOW);
                break;
        default:
                mutex_exit(&sc->sc_reglock);
                return;
        }
        mutex_exit(&sc->sc_reglock);

        clk_div += 1;
        duty_hz = (uint64_t)hi * clk_div;
        period_hz = (uint64_t)(hi + lo) * clk_div;

        period = period_hz * 1000000000ULL / sc->sc_clkfreq;
        duty = duty_hz * 1000000000ULL / sc->sc_clkfreq;

        conf->polarity = PWM_ACTIVE_HIGH;
        conf->period = period;
        conf->duty_cycle = duty;
}

static int
meson_pwm_get_config(pwm_tag_t pwm, struct pwm_config *conf)
{
        struct meson_pwm_channel * const pwmchan = pwm->pwm_priv;

        *conf = pwmchan->mpc_conf;
        return 0;
}

static int
meson_pwm_set_config(pwm_tag_t pwm, const struct pwm_config *conf)
{
        struct meson_pwm_channel * const pwmchan = pwm->pwm_priv;
        struct meson_pwm_softc * const sc = device_private(pwm->pwm_dev);
        uint64_t period_hz, duty_hz;
        uint32_t val;
        u_int period, duty, clk_div, hi, lo;
#ifdef MESON_PWM_DEBUG
        u_int old_div = 0, old_hi = 0, old_lo = 0;
#endif

        period = conf->period;
        duty = conf->duty_cycle;
        if (period == 0)
                return EINVAL;
        KASSERT(period >= duty);
        if (conf->polarity == PWM_ACTIVE_LOW)
                duty = period - duty;

        /* calculate the period to be within the maximum value (0xffff) */
#define MESON_PWMTIME_MAX       0xffff
#define MESON_CLKDIV_MAX        127
        clk_div = 1;
        period_hz = ((uint64_t)sc->sc_clkfreq * period + 500000000ULL) /
            1000000000ULL;
        duty_hz = ((uint64_t)sc->sc_clkfreq * duty + 500000000ULL) /
            1000000000ULL;
        if (period_hz > MESON_PWMTIME_MAX) {
                clk_div = (period_hz + 0x7fff) / 0xffff;
                period_hz /= clk_div;
                duty_hz /= clk_div;
        }

        clk_div -= 1;   /* the divider is N+1 */
        if (clk_div > MESON_CLKDIV_MAX)
                return EINVAL;

        hi = duty_hz;
        lo = period_hz - duty_hz;

        mutex_enter(&sc->sc_reglock);
        switch (pwmchan->mpc_index) {
        case 0: /* A */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                val &= ~MESON_PWM_MISC_AB_A_CLK_DIV;
#ifdef MESON_PWM_DEBUG
                old_div = __SHIFTOUT(val, MESON_PWM_MISC_AB_A_CLK_DIV);
#endif
                val |= __SHIFTIN(clk_div, MESON_PWM_MISC_AB_A_CLK_DIV);
                val &= ~MESON_PWM_MISC_AB_A_CLK_SEL;
                val |= __SHIFTIN(sc->sc_clksource, MESON_PWM_MISC_AB_A_CLK_SEL);
                val |= MESON_PWM_MISC_AB_A_CLK_EN;
                PWM_WRITE_REG(sc, MESON_PWM_MISC_AB_REG, val);
                val = PWM_READ_REG(sc, MESON_PWM_DUTYCYCLE_A_REG);
#ifdef MESON_PWM_DEBUG
                old_hi = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_HIGH);
                old_lo = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_LOW);
#endif
                PWM_WRITE_REG(sc, MESON_PWM_DUTYCYCLE_A_REG,
                    __SHIFTIN(hi, MESON_PWM_DUTYCYCLE_HIGH) |
                    __SHIFTIN(lo, MESON_PWM_DUTYCYCLE_LOW));
                break;
        case 1: /* B */
                val = PWM_READ_REG(sc, MESON_PWM_MISC_AB_REG);
                val &= ~MESON_PWM_MISC_AB_B_CLK_DIV;
#ifdef MESON_PWM_DEBUG
                old_div = __SHIFTOUT(val, MESON_PWM_MISC_AB_B_CLK_DIV);
#endif
                val |= __SHIFTIN(clk_div, MESON_PWM_MISC_AB_B_CLK_DIV);
                val &= ~MESON_PWM_MISC_AB_B_CLK_SEL;
                val |= __SHIFTIN(sc->sc_clksource, MESON_PWM_MISC_AB_B_CLK_SEL);
                val |= MESON_PWM_MISC_AB_B_CLK_EN;
                PWM_WRITE_REG(sc, MESON_PWM_MISC_AB_REG, val);
                val = PWM_READ_REG(sc, MESON_PWM_DUTYCYCLE_B_REG);
#ifdef MESON_PWM_DEBUG
                old_hi = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_HIGH);
                old_lo = __SHIFTOUT(val, MESON_PWM_DUTYCYCLE_LOW);
#endif
                PWM_WRITE_REG(sc, MESON_PWM_DUTYCYCLE_B_REG,
                    __SHIFTIN(hi, MESON_PWM_DUTYCYCLE_HIGH) |
                    __SHIFTIN(lo, MESON_PWM_DUTYCYCLE_LOW));
                break;
        }
        mutex_exit(&sc->sc_reglock);

        pwmchan->mpc_conf = *conf;

#ifdef MESON_PWM_DEBUG
        device_printf(sc->sc_dev,
            "%s: %s: polarity=%s, DutuCycle/Period=%uns/%uns(%u%%) : "
            "%uHz, HIGH:LOW=%u:%u(%u%%) -> "
            "%uHz, HIGH:LOW=%u:%u(%u%%)\n", __func__,
            pwmchan->mpc_index ? "A" : "B",
            (conf->polarity == PWM_ACTIVE_LOW) ? "LOW" : "HIGH",
            conf->duty_cycle, conf->period,
            conf->duty_cycle * 100 / conf->period,
            sc->sc_clkfreq / (old_div + 1), old_hi, old_lo,
            old_hi * 100 / (old_hi + old_lo),
            sc->sc_clkfreq / (clk_div + 1), hi, lo, hi * 100 / (hi + lo));
#endif
        return 0;
}

static pwm_tag_t
meson_pwm_get_tag(device_t dev, const void *data, size_t len)
{
        struct meson_pwm_softc * const sc = device_private(dev);
        struct meson_pwm_channel *pwmchan;
        const u_int *pwm = data;

        if (len != 16)
                return NULL;

        const u_int index = be32toh(pwm[1]);
        if (index >= MESON_PWM_NCHAN)
                return NULL;
        const u_int period = be32toh(pwm[2]);
        const u_int polarity = (pwm[3] == 0) ? PWM_ACTIVE_HIGH : PWM_ACTIVE_LOW;

        pwmchan = &sc->sc_pwmchan[index];

        /*
         * if polarity or period in pwm-tag is different from the copy of
         * config it holds, the content returned by pwm_get_conf() should
         * also be according to the tag.
         * this is because the caller may only set_conf() if necessary.
         */
        if (pwmchan->mpc_conf.polarity != polarity) {
                pwmchan->mpc_conf.duty_cycle =
                    pwmchan->mpc_conf.period - pwmchan->mpc_conf.duty_cycle;
                pwmchan->mpc_conf.polarity = polarity;
        }
        if (pwmchan->mpc_conf.period != period) {
                if (pwmchan->mpc_conf.period == 0) {
                        pwmchan->mpc_conf.duty_cycle = 0;
                } else {
                        pwmchan->mpc_conf.duty_cycle =
                            (uint64_t)pwmchan->mpc_conf.duty_cycle *
                            period / pwmchan->mpc_conf.period;
                }
                pwmchan->mpc_conf.period = period;
        }

        return &pwmchan->mpc_pwm;
}

static struct fdtbus_pwm_controller_func meson_pwm_funcs = {
        .get_tag = meson_pwm_get_tag
};

static int
meson_pwm_match(device_t parent, cfdata_t cf, void *aux)
{
        struct fdt_attach_args * const faa = aux;

        return of_compatible_match(faa->faa_phandle, compat_data);
}

static void
meson_pwm_attach(device_t parent, device_t self, void *aux)
{
        struct meson_pwm_softc * const sc = device_private(self);
        struct fdt_attach_args * const faa = aux;
        bus_addr_t addr;
        bus_size_t size;
        struct clk *clk;
        int phandle, i;

        sc->sc_dev = self;
        sc->sc_bst = faa->faa_bst;
        sc->sc_phandle = phandle = faa->faa_phandle;

        clk = fdtbus_clock_get_index(phandle, 0);
        if (clk == NULL) {
                aprint_error(": couldn't get clock\n");
                return;
        }
        sc->sc_clkfreq = clk_get_rate(clk);

        if (clk == fdtbus_clock_byname("vid_pll"))
                sc->sc_clksource = 1;
        else if (clk == fdtbus_clock_byname("fclk_div4"))
                sc->sc_clksource = 2;
        else if (clk == fdtbus_clock_byname("fclk_div3"))
                sc->sc_clksource = 3;
        else
                sc->sc_clksource = 0;   /* default: "xtal" */

        if (fdtbus_get_reg(phandle, 0, &addr, &size) != 0) {
                aprint_error(": couldn't get registers\n");
                return;
        }
        if (bus_space_map(sc->sc_bst, addr, size, 0, &sc->sc_bsh) != 0) {
                aprint_error(": couldn't map registers\n");
                return;
        }

        aprint_naive("\n");
        aprint_normal(": Pulse-Width Modulation\n");

        mutex_init(&sc->sc_reglock, MUTEX_DEFAULT, IPL_NONE);
        for (i = 0; i < __arraycount(sc->sc_pwmchan); i++) {
                sc->sc_pwmchan[i].mpc_sc = sc;
                sc->sc_pwmchan[i].mpc_index = i;
                sc->sc_pwmchan[i].mpc_pwm.pwm_enable = meson_pwm_enable;
                sc->sc_pwmchan[i].mpc_pwm.pwm_get_config = meson_pwm_get_config;
                sc->sc_pwmchan[i].mpc_pwm.pwm_set_config = meson_pwm_set_config;
                sc->sc_pwmchan[i].mpc_pwm.pwm_dev = self;
                sc->sc_pwmchan[i].mpc_pwm.pwm_priv = &sc->sc_pwmchan[i];
                meson_pwm_get_current(sc, i, &sc->sc_pwmchan[i].mpc_conf);
        }

        fdtbus_register_pwm_controller(self, phandle, &meson_pwm_funcs);
}

CFATTACH_DECL_NEW(meson_pwm, sizeof(struct meson_pwm_softc),
    meson_pwm_match, meson_pwm_attach, NULL, NULL);