/*      $NetBSD: rk_tsadc.c,v 1.16 2021/12/11 19:24:21 mrg Exp $        */

/*
 * Copyright (c) 2019 Matthew R. Green
 * 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: rk_tsadc.c,v 1.16 2021/12/11 19:24:21 mrg Exp $");

/*
 * Driver for the TSADC temperature sensor monitor in RK3328 and RK3399.
 *
 * TODO:
 * - handle setting various temp values
 * - handle DT trips/temp value defaults
 * - interrupts aren't triggered (test by lowering warn/crit values), and
 *   once they work, make the interrupt do something
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/device.h>
#include <sys/intr.h>
#include <sys/systm.h>
#include <sys/time.h>
#include <sys/kmem.h>

#include <dev/fdt/fdtvar.h>
#include <dev/fdt/syscon.h>

#include <dev/sysmon/sysmonvar.h>

#ifdef RKTSADC_DEBUG
#define DPRINTF(fmt, ...) \
        printf("%s:%d: " fmt "\n", __func__, __LINE__, ## __VA_ARGS__)
#else
#define DPRINTF(fmt, ...)
#endif

/* Register definitions */
#define TSADC_USER_CON                          0x00
#define  TSADC_USER_CON_ADC_STATUS              __BIT(12)
#define  TSADC_USER_CON_INTER_PD_SOC            __BITS(11,6)
#define  TSADC_USER_CON_START                   __BIT(5)
#define  TSADC_USER_CON_START_MODE              __BIT(4)
#define  TSADC_USER_CON_ADC_POWER_CTRL          __BIT(3)
#define  TSADC_USER_CON_ADC_INPUT_SRC_SEL       __BITS(2,0)
#define TSADC_AUTO_CON                          0x04
#define  TSADC_AUTO_CON_LAST_TSHUT_2CRU         __BIT(25)
#define  TSADC_AUTO_CON_LAST_TSHUT_2GPIO        __BIT(24)
#define  TSADC_AUTO_CON_SAMPLE_DLY_SEL          __BIT(17)
#define  TSADC_AUTO_CON_AUTO_STATUS             __BIT(16)
#define  TSADC_AUTO_CON_SRC1_LT_EN              __BIT(13)
#define  TSADC_AUTO_CON_SRC0_LT_EN              __BIT(12)
#define  TSADC_AUTO_CON_TSHUT_POLARITY          __BIT(8)
#define  TSADC_AUTO_CON_SRC1_EN                 __BIT(5)
#define  TSADC_AUTO_CON_SRC0_EN                 __BIT(4)
#define  TSADC_AUTO_CON_Q_SEL                   __BIT(1)
#define  TSADC_AUTO_CON_AUTO_EN                 __BIT(0)
#define TSADC_INT_EN                            0x08
#define  TSADC_INT_EN_EOC_INT_EN                __BIT(16)
#define  TSADC_INT_EN_LT_INTEN_SRC1             __BIT(13)
#define  TSADC_INT_EN_LT_INTEN_SRC0             __BIT(12)
#define  TSADC_INT_EN_TSHUT_2CRU_EN_SRC1        __BIT(9)
#define  TSADC_INT_EN_TSHUT_2CRU_EN_SRC0        __BIT(8)
#define  TSADC_INT_EN_TSHUT_2GPIO_EN_SRC1       __BIT(5)
#define  TSADC_INT_EN_TSHUT_2GPIO_EN_SRC0       __BIT(4)
#define  TSADC_INT_EN_HT_INTEN_SRC1             __BIT(1)
#define  TSADC_INT_EN_HT_INTEN_SRC0             __BIT(0)
#define TSADC_INT_PD                            0x0c
#define  TSADC_INT_PD_EOC_INT_PD_V3             __BIT(16)
#define  TSADC_INT_PD_LT_IRQ_SRC1               __BIT(13)
#define  TSADC_INT_PD_LT_IRQ_SRC0               __BIT(12)
#define  TSADC_INT_PD_EOC_INT_PD_V2             __BIT(8)
#define  TSADC_INT_PD_TSHUT_O_SRC1              __BIT(5)
#define  TSADC_INT_PD_TSHUT_O_SRC0              __BIT(4)
#define  TSADC_INT_PD_HT_IRQ_SRC1               __BIT(1)
#define  TSADC_INT_PD_HT_IRQ_SRC0               __BIT(0)
#define TSADC_DATA0                             0x20
#define  TSADC_DATA0_ADC_DATA                   __BITS(11,0)
#define TSADC_DATA1                             0x24
#define  TSADC_DATA1_ADC_DATA                   __BITS(11,0)
#define TSADC_COMP0_INT                         0x30
#define  TSADC_COMP0_INT_COMP_SRC0              __BITS(11,0)
#define TSADC_COMP1_INT                         0x34
#define  TSADC_COMP1_INT_COMP_SRC1              __BITS(11,0)
#define TSADC_COMP0_SHUT                        0x40
#define  TSADC_COMP0_SHUT_COMP_SRC0             __BITS(11,0)
#define TSADC_COMP1_SHUT                        0x44
#define  TSADC_COMP1_SHUT_COMP_SRC1             __BITS(11,0)
#define TSADC_HIGH_INT_DEBOUNCE                 0x60
#define  TSADC_HIGH_INT_DEBOUNCE_TEMP           __BITS(7,0)
#define TSADC_HIGH_TSHUT_DEBOUNCE               0x64
#define  TSADC_HIGH_TSHUT_DEBOUNCE_TEMP         __BITS(7,0)
#define TSADC_AUTO_PERIOD                       0x68
#define  TSADC_AUTO_PERIOD_TEMP                 __BITS(31,0)
#define TSADC_AUTO_PERIOD_HT                    0x6c
#define  TSADC_AUTO_PERIOD_HT_TEMP              __BITS(31,0)
#define TSADC_COMP0_LOW_INT                     0x80
#define  TSADC_COMP0_LOW_INT_COMP_SRC0          __BITS(11,0)
#define TSADC_COMP1_LOW_INT                     0x84
#define  TSADC_COMP1_LOW_INT_COMP_SRC1          __BITS(11,0)

#define RK3288_TSADC_AUTO_PERIOD_TIME           250 /* 250ms */
#define RK3288_TSADC_AUTO_PERIOD_HT_TIME        50  /* 50ms */
#define RK3328_TSADC_AUTO_PERIOD_TIME           250 /* 250ms */
#define RK3399_TSADC_AUTO_PERIOD_TIME           1875 /* 2.5ms */
#define TSADC_HT_DEBOUNCE_COUNT                 4

/*
 * All this magic is taking from the Linux rockchip_thermal driver.
 *
 * VCM means "voltage common mode", but the documentation for RK3399
 * does not mention this and I don't know what any of this really
 * is for.
 */
#define RK3399_GRF_SARADC_TESTBIT               0xe644
#define  RK3399_GRF_SARADC_TESTBIT_ON           (0x10001 << 2)
#define RK3399_GRF_TSADC_TESTBIT_L              0xe648
#define  RK3399_GRF_TSADC_TESTBIT_VCM_EN_L      (0x10001 << 7)
#define RK3399_GRF_TSADC_TESTBIT_H              0xe64c
#define  RK3399_GRF_TSADC_TESTBIT_VCM_EN_H      (0x10001 << 7)
#define  RK3399_GRF_TSADC_TESTBIT_H_ON          (0x10001 << 2)

#define TEMP_uC_TO_uK             273150000

#define TSHUT_MODE_CPU    0
#define TSHUT_MODE_GPIO   1

#define TSHUT_LOW_ACTIVE  0
#define TSHUT_HIGH_ACTIVE 1

#define TSHUT_DEF_TEMP    95000

#define TSADC_DATA_MAX    0xfff

#define MAX_SENSORS       2

typedef struct rk_data_array {
        uint32_t data;  /* register value */
        int temp;       /* micro-degC */
} rk_data_array;

struct rk_tsadc_softc;
typedef struct rk_data {
        const char              *rd_name;
        const rk_data_array     *rd_array;
        size_t                   rd_size;
        void                    (*rd_init)(struct rk_tsadc_softc *, int, int);
        bool                     rd_decr;  /* lower values -> higher temp */
        unsigned                 rd_min, rd_max;
        unsigned                 rd_auto_period;
        unsigned                 rd_auto_period_ht;
        unsigned                 rd_num_sensors;
        unsigned                 rd_version;
} rk_data;

/* Per-sensor data */
struct rk_tsadc_sensor {
        envsys_data_t   s_data;
        bool            s_attached;
        /* TSADC register offsets for this sensor */
        unsigned        s_data_reg;
        unsigned        s_comp_tshut;
        unsigned        s_comp_int;
        /* enable bit in AUTO_CON register */
        unsigned        s_comp_int_en;
        /* warn/crit values in micro Kelvin */
        int             s_warn;
        int             s_tshut;
};

struct rk_tsadc_softc {
        device_t                sc_dev;
        int                     sc_phandle;
        bus_space_tag_t         sc_bst;
        bus_space_handle_t      sc_bsh;
        size_t                  sc_size;
        uint32_t                sc_data_mask;
        void                    *sc_ih;

        struct sysmon_envsys    *sc_sme;
        struct rk_tsadc_sensor  sc_sensors[MAX_SENSORS];

        struct clk              *sc_clock;
        struct clk              *sc_clockapb;
        struct fdtbus_reset     *sc_reset;
        struct syscon           *sc_syscon;

        const rk_data           *sc_rd;
};

static int rk_tsadc_match(device_t, cfdata_t, void *);
static void rk_tsadc_attach(device_t, device_t, void *);
static int rk_tsadc_detach(device_t, int);
static int rk_tsadc_init_clocks(struct rk_tsadc_softc *);
static void rk_tsadc_init_counts(struct rk_tsadc_softc *);
static void rk_tsadc_tshut_set(struct rk_tsadc_softc *s);
static void rk_tsadc_init_tshut(struct rk_tsadc_softc *, int, int);
static void rk_tsadc_init_common(struct rk_tsadc_softc *, int, int);
static void rk_tsadc_init_rk3399(struct rk_tsadc_softc *, int, int);
static void rk_tsadc_init_enable(struct rk_tsadc_softc *);
static void rk_tsadc_init(struct rk_tsadc_softc *, int, int);
static void rk_tsadc_refresh(struct sysmon_envsys *, envsys_data_t *);
static void rk_tsadc_get_limits(struct sysmon_envsys *, envsys_data_t *,
                                sysmon_envsys_lim_t *, uint32_t *);

static int rk_tsadc_intr(void *);
static int rk_tsadc_data_to_temp(struct rk_tsadc_softc *, uint32_t);
static uint32_t rk_tsadc_temp_to_data(struct rk_tsadc_softc *, int);

/* RK3328/RK3399 compatible sensors */
static const struct rk_tsadc_sensor rk_tsadc_sensors[] = {
        {
          .s_data = { .desc = "CPU" },
          .s_data_reg = TSADC_DATA0,
          .s_comp_tshut = TSADC_COMP0_SHUT,
          .s_comp_int = TSADC_COMP0_INT,
          .s_comp_int_en = TSADC_AUTO_CON_SRC0_EN,
          /*
           * XXX DT has:
           * cpu_alert1: cpu_alert1 {
           *    temperature = <75000>;
           *    hysteresis = <2000>;
           * cpu_crit: cpu_crit {
           *    temperature = <95000>;
           *    hysteresis = <2000>;
           * pull out of here?
           * do something with hysteresis?  put in debounce?
           * 
           * Note that tshut may be overridden by the board specific DT.
           */
          .s_warn = 75000000,
          .s_tshut = 95000000,
        }, {
          .s_data = { .desc = "GPU" },
          .s_data_reg = TSADC_DATA1,
          .s_comp_tshut = TSADC_COMP1_SHUT,
          .s_comp_int = TSADC_COMP1_INT,
          .s_comp_int_en = TSADC_AUTO_CON_SRC1_EN,
          .s_warn = 75000000,
          .s_tshut = 95000000,
        },
};

/*
 * Table from RK3288 manual.
 */
static const rk_data_array rk3288_data_array[] = {
#define ENTRY(d,C)      { .data = (d), .temp = (C) * 1000 * 1000, }
        ENTRY(TSADC_DATA_MAX, -40),
        ENTRY(3800, -40),
        ENTRY(3792, -35),
        ENTRY(3783, -30),
        ENTRY(3774, -25),
        ENTRY(3765, -20),
        ENTRY(3756, -15),
        ENTRY(3747, -10),
        ENTRY(3737, -5),
        ENTRY(3728, 0),
        ENTRY(3718, 5),
        ENTRY(3708, 10),
        ENTRY(3698, 15),
        ENTRY(3688, 20),
        ENTRY(3678, 25),
        ENTRY(3667, 30),
        ENTRY(3656, 35),
        ENTRY(3645, 40),
        ENTRY(3634, 45),
        ENTRY(3623, 50),
        ENTRY(3611, 55),
        ENTRY(3600, 60),
        ENTRY(3588, 65),
        ENTRY(3575, 70),
        ENTRY(3563, 75),
        ENTRY(3550, 80),
        ENTRY(3537, 85),
        ENTRY(3524, 90),
        ENTRY(3510, 95),
        ENTRY(3496, 100),
        ENTRY(3482, 105),
        ENTRY(3467, 110),
        ENTRY(3452, 115),
        ENTRY(3437, 120),
        ENTRY(3421, 125),
        ENTRY(0, 15),
#undef ENTRY
};

/*
 * Table from RK3328 manual.  Note that the manual lists valid numbers as
 * 4096 - number.  This also means it is increasing not decreasing for
 * higher temps, and the min and max are also offset from 4096.
 */
#define RK3328_DATA_OFFSET (4096)
static const rk_data_array rk3328_data_array[] = {
#define ENTRY(d,C) \
        { .data = RK3328_DATA_OFFSET - (d), .temp = (C) * 1000 * 1000, }
        ENTRY(TSADC_DATA_MAX,    -40),
        ENTRY(3800, -40),
        ENTRY(3792, -35),
        ENTRY(3783, -30),
        ENTRY(3774, -25),
        ENTRY(3765, -20),
        ENTRY(3756, -15),
        ENTRY(3747, -10),
        ENTRY(3737,  -5),
        ENTRY(3728,   0),
        ENTRY(3718,   5),
        ENTRY(3708,  10),
        ENTRY(3698,  15),
        ENTRY(3688,  20),
        ENTRY(3678,  25),
        ENTRY(3667,  30),
        ENTRY(3656,  35),
        ENTRY(3645,  40),
        ENTRY(3634,  45),
        ENTRY(3623,  50),
        ENTRY(3611,  55),
        ENTRY(3600,  60),
        ENTRY(3588,  65),
        ENTRY(3575,  70),
        ENTRY(3563,  75),
        ENTRY(3550,  80),
        ENTRY(3537,  85),
        ENTRY(3524,  90),
        ENTRY(3510,  95),
        ENTRY(3496, 100),
        ENTRY(3482, 105),
        ENTRY(3467, 110),
        ENTRY(3452, 115),
        ENTRY(3437, 120),
        ENTRY(3421, 125),
        ENTRY(0,    125),
#undef ENTRY
};

/* Table from RK3399 manual */
static const rk_data_array rk3399_data_array[] = {
#define ENTRY(d,C)      { .data = (d), .temp = (C) * 1000 * 1000, }
        ENTRY(0,   -40),
        ENTRY(402, -40),
        ENTRY(410, -35),
        ENTRY(419, -30),
        ENTRY(427, -25),
        ENTRY(436, -20),
        ENTRY(444, -15),
        ENTRY(453, -10),
        ENTRY(461,  -5),
        ENTRY(470,   0),
        ENTRY(478,   5),
        ENTRY(487,  10),
        ENTRY(496,  15),
        ENTRY(504,  20),
        ENTRY(513,  25),
        ENTRY(521,  30),
        ENTRY(530,  35),
        ENTRY(538,  40),
        ENTRY(547,  45),
        ENTRY(555,  50),
        ENTRY(564,  55),
        ENTRY(573,  60),
        ENTRY(581,  65),
        ENTRY(590,  70),
        ENTRY(599,  75),
        ENTRY(607,  80),
        ENTRY(616,  85),
        ENTRY(624,  90),
        ENTRY(633,  95),
        ENTRY(642, 100),
        ENTRY(650, 105),
        ENTRY(659, 110),
        ENTRY(668, 115),
        ENTRY(677, 120),
        ENTRY(685, 125),
        ENTRY(TSADC_DATA_MAX, 125),
#undef ENTRY
};

static const rk_data rk3288_data_table = {
        .rd_name = "RK3288",
        .rd_array = rk3288_data_array,
        .rd_size = __arraycount(rk3288_data_array),
        .rd_init = rk_tsadc_init_common,
        .rd_decr = true,
        .rd_max = 3800,
        .rd_min = 3421,
        .rd_auto_period = RK3288_TSADC_AUTO_PERIOD_TIME,
        .rd_auto_period_ht = RK3288_TSADC_AUTO_PERIOD_HT_TIME,
        .rd_num_sensors = 2,
        .rd_version = 2,
};

static const rk_data rk3328_data_table = {
        .rd_name = "RK3328",
        .rd_array = rk3328_data_array,
        .rd_size = __arraycount(rk3328_data_array),
        .rd_init = rk_tsadc_init_common,
        .rd_decr = false,
        .rd_max = RK3328_DATA_OFFSET - 3420,
        .rd_min = RK3328_DATA_OFFSET - 3801,
        .rd_auto_period = RK3328_TSADC_AUTO_PERIOD_TIME,
        .rd_auto_period_ht = RK3328_TSADC_AUTO_PERIOD_TIME,
        .rd_num_sensors = 1,
        .rd_version = 3,
};

static const rk_data rk3399_data_table = {
        .rd_name = "RK3399",
        .rd_array = rk3399_data_array,
        .rd_size = __arraycount(rk3399_data_array),
        .rd_init = rk_tsadc_init_rk3399,
        .rd_decr = false,
        .rd_max = 686,
        .rd_min = 401,
        .rd_auto_period = RK3399_TSADC_AUTO_PERIOD_TIME,
        .rd_auto_period_ht = RK3399_TSADC_AUTO_PERIOD_TIME,
        .rd_num_sensors = 2,
        .rd_version = 3,
};

static const struct device_compatible_entry compat_data[] = {
        { .compat = "rockchip,rk3288-tsadc",    .data = &rk3288_data_table },
        { .compat = "rockchip,rk3328-tsadc",    .data = &rk3328_data_table },
        { .compat = "rockchip,rk3399-tsadc",    .data = &rk3399_data_table },
        DEVICE_COMPAT_EOL
};

#define TSADC_READ(sc, reg)             \
        bus_space_read_4((sc)->sc_bst, (sc)->sc_bsh, (reg))
#define TSADC_WRITE(sc, reg, val)       \
        bus_space_write_4((sc)->sc_bst, (sc)->sc_bsh, (reg), (val))

CFATTACH_DECL3_NEW(rk_tsadc, sizeof(struct rk_tsadc_softc),
        rk_tsadc_match, rk_tsadc_attach, rk_tsadc_detach, NULL, NULL, NULL,
        DVF_DETACH_SHUTDOWN);

/* init/teardown support */
static int
rk_tsadc_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
rk_tsadc_attach(device_t parent, device_t self, void *aux)
{
        struct rk_tsadc_softc * const sc = device_private(self);
        struct fdt_attach_args * const faa = aux;
        char intrstr[128];
        const int phandle = faa->faa_phandle;
        bus_addr_t addr;
        int mode, polarity, tshut_temp;

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

        sc->sc_sme = sysmon_envsys_create();

        sc->sc_sme->sme_name = device_xname(self);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = rk_tsadc_refresh;
        sc->sc_sme->sme_get_limits = rk_tsadc_get_limits;
        sc->sc_data_mask = TSADC_DATA_MAX;

        pmf_device_register(self, NULL, NULL);

        sc->sc_rd = of_compatible_lookup(faa->faa_phandle, compat_data)->data;

        aprint_naive("\n");
        aprint_normal(": %s Temperature Sensor ADC\n", sc->sc_rd->rd_name);

        /* Default to tshut via gpio and tshut low is active */
        if (of_getprop_uint32(phandle, "rockchip,hw-tshut-mode",
                              &mode) != 0) {
                aprint_error(": could not get TSHUT mode, default to GPIO");
                mode = TSHUT_MODE_GPIO;
        }
        if (mode != TSHUT_MODE_CPU && mode != TSHUT_MODE_GPIO) {
                aprint_error(": TSHUT mode should be 0 or 1\n");
                goto fail;
        }

        if (of_getprop_uint32(phandle, "rockchip,hw-tshut-polarity",
                              &polarity) != 0) {
                aprint_error(": could not get TSHUT polarity, default to low");
                polarity = TSHUT_LOW_ACTIVE;
        }
        if (of_getprop_uint32(phandle,
                              "rockchip,hw-tshut-temp", &tshut_temp) != 0) {
                aprint_error(": could not get TSHUT temperature, default to %u",
                             TSHUT_DEF_TEMP);
                tshut_temp = TSHUT_DEF_TEMP;
        }
        tshut_temp *= 1000;     /* convert fdt mK -> uK */

        memcpy(sc->sc_sensors, rk_tsadc_sensors, sizeof(sc->sc_sensors));
        for (unsigned n = 0; n < sc->sc_rd->rd_num_sensors; n++) {
                struct rk_tsadc_sensor *rks = &sc->sc_sensors[n];

                rks->s_data.flags = ENVSYS_FMONLIMITS;
                rks->s_data.units = ENVSYS_STEMP;
                rks->s_data.state = ENVSYS_SINVALID;

                if (sysmon_envsys_sensor_attach(sc->sc_sme, &rks->s_data))
                        goto fail;
                rks->s_attached = true;
                rks->s_tshut = tshut_temp;
#if 0
                // testing
                rks->s_tshut = 68000000;
                rks->s_warn = 61000000;
#endif
        }

        sc->sc_syscon = fdtbus_syscon_acquire(phandle, "rockchip,grf");
        if (sc->sc_syscon == NULL) {
                aprint_error(": couldn't get grf syscon\n");
                goto fail;
        }
        if (fdtbus_get_reg(phandle, 0, &addr, &sc->sc_size) != 0) {
                aprint_error(": couldn't get registers\n");
                sc->sc_size = 0;
                goto fail;
        }
        if (bus_space_map(sc->sc_bst, addr, sc->sc_size, 0, &sc->sc_bsh) != 0) {
                aprint_error(": couldn't map registers\n");
                sc->sc_size = 0;
                goto fail;
        }

        if (!fdtbus_intr_str(phandle, 0, intrstr, sizeof(intrstr))) {
                aprint_error(": failed to decode interrupt\n");
                goto fail;
        }

        sc->sc_ih = fdtbus_intr_establish_xname(phandle, 0, IPL_VM, FDT_INTR_MPSAFE,
            rk_tsadc_intr, sc, device_xname(self));
        if (sc->sc_ih == NULL) {
                aprint_error_dev(self, "couldn't establish interrupt on %s\n",
                    intrstr);
                goto fail;
        }
        aprint_normal_dev(self, "interrupting on %s\n", intrstr);

        if (rk_tsadc_init_clocks(sc)) {
                aprint_error(": couldn't enable clocks\n");
                return;
        }

        /*
         * Manual says to setup auto period (both), high temp (interrupt),
         * high temp (shutdown), enable high temp resets (TSHUT to GPIO
         * or reset chip), set the debounce times, and, finally, enable the
         * controller iself.
         */
        rk_tsadc_init(sc, mode, polarity);

        return;

fail:
        rk_tsadc_detach(self, 0);
}

static int
rk_tsadc_detach(device_t self, int flags)
{
        struct rk_tsadc_softc *sc = device_private(self);

        pmf_device_deregister(self);

        for (unsigned n = 0; n < sc->sc_rd->rd_num_sensors; n++) {
                struct rk_tsadc_sensor *rks = &sc->sc_sensors[n];

                if (rks->s_attached) {
                        sysmon_envsys_sensor_detach(sc->sc_sme, &rks->s_data);
                        rks->s_attached = false;
                }
        }

        sysmon_envsys_unregister(sc->sc_sme);

        if (sc->sc_clockapb)
                clk_disable(sc->sc_clockapb);
        if (sc->sc_clock)
                clk_disable(sc->sc_clock);

        if (sc->sc_ih)
                fdtbus_intr_disestablish(sc->sc_phandle, sc->sc_ih);

        if (sc->sc_size)
                bus_space_unmap(sc->sc_bst, sc->sc_bsh, sc->sc_size);

        sysmon_envsys_destroy(sc->sc_sme);

        return 0;
}

static int
rk_tsadc_init_clocks(struct rk_tsadc_softc *sc)
{
        int error;

        fdtbus_clock_assign(sc->sc_phandle);

        sc->sc_reset = fdtbus_reset_get(sc->sc_phandle, "tsadc-apb");
        sc->sc_clock = fdtbus_clock_get(sc->sc_phandle, "tsadc");
        sc->sc_clockapb = fdtbus_clock_get(sc->sc_phandle, "apb_pclk");
        if (sc->sc_reset == NULL ||
            sc->sc_clock == NULL ||
            sc->sc_clockapb == NULL)
                return EINVAL;

        fdtbus_reset_assert(sc->sc_reset);

        error = clk_enable(sc->sc_clock);
        if (error) {
                fdtbus_reset_deassert(sc->sc_reset);
                return error;
        }

        error = clk_enable(sc->sc_clockapb);

        DELAY(20);
        fdtbus_reset_deassert(sc->sc_reset);

        return error;
}

static void
rk_tsadc_init_counts(struct rk_tsadc_softc *sc)
{

        TSADC_WRITE(sc, TSADC_AUTO_PERIOD, sc->sc_rd->rd_auto_period);
        TSADC_WRITE(sc, TSADC_AUTO_PERIOD_HT, sc->sc_rd->rd_auto_period_ht);
        TSADC_WRITE(sc, TSADC_HIGH_INT_DEBOUNCE, TSADC_HT_DEBOUNCE_COUNT);
        TSADC_WRITE(sc, TSADC_HIGH_TSHUT_DEBOUNCE, TSADC_HT_DEBOUNCE_COUNT);
}

/* Configure the hardware with the tshut setup. */
static void
rk_tsadc_tshut_set(struct rk_tsadc_softc *sc)
{
        uint32_t val = TSADC_READ(sc, TSADC_AUTO_CON);

        for (unsigned n = 0; n < sc->sc_rd->rd_num_sensors; n++) {
                struct rk_tsadc_sensor *rks = &sc->sc_sensors[n];
                uint32_t data, warndata;

                if (!rks->s_attached)
                        continue;

                data = rk_tsadc_temp_to_data(sc, rks->s_tshut);
                warndata = rk_tsadc_temp_to_data(sc, rks->s_warn);

                DPRINTF("(%s:%s): tshut/data %d/%u warn/data %d/%u",
                        sc->sc_sme->sme_name, rks->s_data.desc,
                        rks->s_tshut, data,
                        rks->s_warn, warndata);

                if (data == sc->sc_data_mask) {
                        aprint_error_dev(sc->sc_dev,
                            "Failed converting critical temp %u.%06u to code",
                            rks->s_tshut / 1000000, rks->s_tshut % 1000000);
                        continue;
                }
                if (warndata == sc->sc_data_mask) {
                        aprint_error_dev(sc->sc_dev,
                            "Failed converting warn temp %u.%06u to code",
                            rks->s_warn / 1000000, rks->s_warn % 1000000);
                        continue;
                }

                TSADC_WRITE(sc, rks->s_comp_tshut, data);
                TSADC_WRITE(sc, rks->s_comp_int, warndata);

                val |= rks->s_comp_int_en;
        }
        TSADC_WRITE(sc, TSADC_AUTO_CON, val);
}

static void
rk_tsadc_init_tshut(struct rk_tsadc_softc *sc, int mode, int polarity)
{
        uint32_t val;

        /* Handle TSHUT temp setting. */
        rk_tsadc_tshut_set(sc);

        /* Handle TSHUT mode setting. */
        val = TSADC_READ(sc, TSADC_INT_EN);
        if (mode == TSHUT_MODE_CPU) {
                val |= TSADC_INT_EN_TSHUT_2CRU_EN_SRC1 |
                       TSADC_INT_EN_TSHUT_2CRU_EN_SRC0;
                val &= ~(TSADC_INT_EN_TSHUT_2GPIO_EN_SRC1 |
                         TSADC_INT_EN_TSHUT_2GPIO_EN_SRC0);
        } else {
                KASSERT(mode == TSHUT_MODE_GPIO);
                val &= ~(TSADC_INT_EN_TSHUT_2CRU_EN_SRC1 |
                         TSADC_INT_EN_TSHUT_2CRU_EN_SRC0);
                val |= TSADC_INT_EN_TSHUT_2GPIO_EN_SRC1 |
                       TSADC_INT_EN_TSHUT_2GPIO_EN_SRC0;
        }
        TSADC_WRITE(sc, TSADC_INT_EN, val);

        /* Handle TSHUT polarity setting. */
        val = TSADC_READ(sc, TSADC_AUTO_CON);
        if (polarity == TSHUT_HIGH_ACTIVE)
                val |= TSADC_AUTO_CON_TSHUT_POLARITY;
        else
                val &= ~TSADC_AUTO_CON_TSHUT_POLARITY;
        TSADC_WRITE(sc, TSADC_AUTO_CON, val);
}

static void
rk_tsadc_init_common(struct rk_tsadc_softc *sc, int mode, int polarity)
{

        rk_tsadc_init_tshut(sc, mode, polarity);
        rk_tsadc_init_counts(sc);
}

static void
rk_tsadc_init_rk3399(struct rk_tsadc_softc *sc, int mode, int polarity)
{

        syscon_lock(sc->sc_syscon);
        syscon_write_4(sc->sc_syscon, RK3399_GRF_TSADC_TESTBIT_L,
                                      RK3399_GRF_TSADC_TESTBIT_VCM_EN_L);
        syscon_write_4(sc->sc_syscon, RK3399_GRF_TSADC_TESTBIT_H,
                                      RK3399_GRF_TSADC_TESTBIT_VCM_EN_H);

        DELAY(20);
        syscon_write_4(sc->sc_syscon, RK3399_GRF_SARADC_TESTBIT,
                                      RK3399_GRF_SARADC_TESTBIT_ON);
        syscon_write_4(sc->sc_syscon, RK3399_GRF_TSADC_TESTBIT_H,
                                      RK3399_GRF_TSADC_TESTBIT_H_ON);
        DELAY(100);
        syscon_unlock(sc->sc_syscon);

        rk_tsadc_init_common(sc, mode, polarity);
}

static void
rk_tsadc_init_enable(struct rk_tsadc_softc *sc)
{
        uint32_t val;

        val = TSADC_READ(sc, TSADC_AUTO_CON);
        val |= TSADC_AUTO_CON_AUTO_STATUS | 
               TSADC_AUTO_CON_SRC1_LT_EN | TSADC_AUTO_CON_SRC0_LT_EN;
        TSADC_WRITE(sc, TSADC_AUTO_CON, val);

        /* Finally, register & enable the controller */
        sysmon_envsys_register(sc->sc_sme);

        val = TSADC_READ(sc, TSADC_AUTO_CON);
        val |= TSADC_AUTO_CON_AUTO_EN;
        if (sc->sc_rd->rd_version >= 3) {
                val |= TSADC_AUTO_CON_Q_SEL;
        }
        TSADC_WRITE(sc, TSADC_AUTO_CON, val);
}

static void
rk_tsadc_init(struct rk_tsadc_softc *sc, int mode, int polarity)
{

        (*sc->sc_rd->rd_init)(sc, mode, polarity);
        rk_tsadc_init_enable(sc);
}

/* run time support */

/* given edata, find the matching rk sensor structure */
static struct rk_tsadc_sensor *
rk_tsadc_edata_to_sensor(struct rk_tsadc_softc * const sc, envsys_data_t *edata)
{

        for (unsigned n = 0; n < sc->sc_rd->rd_num_sensors; n++) {
                struct rk_tsadc_sensor *rks = &sc->sc_sensors[n];

                if (&rks->s_data == edata)
                        return rks;
        }
        return NULL;
}

static void
rk_tsadc_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        struct rk_tsadc_softc * const sc = sme->sme_cookie;
        struct rk_tsadc_sensor *rks = rk_tsadc_edata_to_sensor(sc, edata);
        unsigned data;
        int temp;

        if (rks == NULL)
                return;

        data = TSADC_READ(sc, rks->s_data_reg) & sc->sc_data_mask;
        temp = rk_tsadc_data_to_temp(sc, data);

        DPRINTF("(%s:%s): temp/data %d/%u",
                sc->sc_sme->sme_name, rks->s_data.desc,
                temp, data);

        if (temp == sc->sc_data_mask) {
                edata->state = ENVSYS_SINVALID;
        } else {
                edata->value_cur = temp + TEMP_uC_TO_uK;
                edata->state = ENVSYS_SVALID;
        }
}

static void
rk_tsadc_get_limits(struct sysmon_envsys *sme,
                    envsys_data_t *edata,
                    sysmon_envsys_lim_t *lim,
                    uint32_t *props)
{
        struct rk_tsadc_softc *sc = sme->sme_cookie;
        struct rk_tsadc_sensor *rks = rk_tsadc_edata_to_sensor(sc, edata);

        if (rks == NULL)
                return;

        lim->sel_critmax = rks->s_tshut + TEMP_uC_TO_uK;
        lim->sel_warnmax = rks->s_warn + TEMP_uC_TO_uK;

        *props = PROP_CRITMAX | PROP_WARNMAX;
}

/* XXX do something with interrupts that don't happen yet.  */
static int
rk_tsadc_intr(void *arg)
{
        struct rk_tsadc_softc * const sc = arg;
        uint32_t val;

        /* XXX */
        DPRINTF("(%s): interrupted", sc->sc_sme->sme_name);
        for (unsigned n = 0; n < __arraycount(rk_tsadc_sensors); n++) {
                struct rk_tsadc_sensor *rks = &sc->sc_sensors[n];

                rk_tsadc_refresh(sc->sc_sme, (envsys_data_t *)rks);
        }

        /* ack interrupt */
        val = TSADC_READ(sc, TSADC_INT_PD);
        if (sc->sc_rd->rd_version >= 3) {
                TSADC_WRITE(sc, TSADC_INT_PD,
                    val & ~TSADC_INT_PD_EOC_INT_PD_V3);
        } else {
                TSADC_WRITE(sc, TSADC_INT_PD,
                    val & ~TSADC_INT_PD_EOC_INT_PD_V2);
        }

        return 1;
}

/*
 * Convert TDASC data codes to temp and reverse.  The manual only has codes
 * and temperature values in 5 degC intervals, but says that interpolation
 * can be done to achieve better resolution between these values, and that
 * the spacing is linear.
 */
static int
rk_tsadc_data_to_temp(struct rk_tsadc_softc *sc, uint32_t data)
{
        unsigned i;
        const rk_data *rd = sc->sc_rd;

        if (data > rd->rd_max || data < rd->rd_min) {
                DPRINTF("data out of range (%u > %u || %u < %u)",
                        data, rd->rd_max, data, rd->rd_min);
                return sc->sc_data_mask;
        }
        for (i = 1; i < rd->rd_size; i++) {
                if (rd->rd_array[i].data >= data) {
                        int temprange, offset;
                        uint32_t datarange, datadiff;
                        unsigned first, secnd;

                        if (rd->rd_array[i].data == data)
                                return rd->rd_array[i].temp;

                        /* must interpolate */
                        if (rd->rd_decr) {
                                first = i;
                                secnd = i+1;
                        } else {
                                first = i;
                                secnd = i-1;
                        }

                        temprange = rd->rd_array[first].temp -
                                    rd->rd_array[secnd].temp;
                        datarange = rd->rd_array[first].data -
                                    rd->rd_array[secnd].data;
                        datadiff = data - rd->rd_array[secnd].data;

                        offset = (temprange * datadiff) / datarange;
                        return rd->rd_array[secnd].temp + offset;
                }
        }
        panic("didn't find range");
}

static uint32_t
rk_tsadc_temp_to_data(struct rk_tsadc_softc *sc, int temp)
{
        unsigned i;
        const rk_data *rd = sc->sc_rd;

        for (i = 1; i < rd->rd_size; i++) {
                if (rd->rd_array[i].temp >= temp) {
                        int temprange, tempdiff;
                        uint32_t datarange, offset;
                        unsigned first, secnd;

                        if (rd->rd_array[i].temp == temp)
                                return rd->rd_array[i].data;

                        /* must interpolate */
                        if (rd->rd_decr) {
                                first = i;
                                secnd = i+1;
                        } else {
                                first = i;
                                secnd = i-1;
                        }

                        datarange = rd->rd_array[first].data -
                                    rd->rd_array[secnd].data;
                        temprange = rd->rd_array[first].temp -
                                    rd->rd_array[secnd].temp;
                        tempdiff = temp - rd->rd_array[secnd].temp;

                        offset = (datarange * tempdiff) / temprange;
                        return rd->rd_array[secnd].data + offset;
                }
        }

        return sc->sc_data_mask;
}