/*      $NetBSD: power.c,v 1.3 2019/04/15 20:40:37 skrll Exp $  */

/*
 * Copyright (c) 2004 Jochen Kunz.
 * 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.
 * 3. The name of Jochen Kunz may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY JOCHEN KUNZ
 * ``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 JOCHEN KUNZ
 * 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.
 */

/*      $OpenBSD: power.c,v 1.5 2004/06/11 12:53:09 mickey Exp $        */

/*
 * Copyright (c) 2003 Michael Shalayeff
 * 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 OR HIS RELATIVES 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 MIND, 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/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/reboot.h>
#include <sys/device.h>
#include <sys/sysctl.h>
#include <sys/kmem.h>

#include <machine/reg.h>
#include <machine/pdc.h>
#include <machine/autoconf.h>

#include <hppa/dev/cpudevs.h>

#include <dev/sysmon/sysmon_taskq.h>
#include <dev/sysmon/sysmonvar.h>

/* Enable / disable control over the power switch. */
#define PWR_SW_CTRL_DISABLE     0
#define PWR_SW_CTRL_ENABLE      1
#define PWR_SW_CTRL_LOCK        2
#define PWR_SW_CTRL_MAX         PWR_SW_CTRL_LOCK

struct power_softc {
        device_t sc_dev;
        bus_space_tag_t sc_bst;
        bus_space_handle_t sc_bsh;

        void (*sc_kicker)(void *);

        struct callout sc_callout;
        int sc_timeout;

        int sc_dr_cnt;
};

int     powermatch(device_t, cfdata_t, void *);
void    powerattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(power, sizeof(struct power_softc),
    powermatch, powerattach, NULL, NULL);

static struct pdc_power_info pdc_power_info;
static bool pswitch_on;                 /* power switch */
static int pwr_sw_control;
static const char *pwr_sw_control_str[] = {"disabled", "enabled", "locked"};
static struct sysmon_pswitch *pwr_sw_sysmon;

static int pwr_sw_sysctl_state(SYSCTLFN_PROTO);
static int pwr_sw_sysctl_ctrl(SYSCTLFN_PROTO);
static void pwr_sw_sysmon_cb(void *);
static void pwr_sw_ctrl(int);
static int pwr_sw_init(struct power_softc *);

void power_thread_dr(void *v);
void power_thread_reg(void *v);
void power_cold_hook_reg(int);

int
powermatch(device_t parent, cfdata_t cf, void *aux)
{
        struct confargs *ca = aux;

        if (cf->cf_unit > 0 && !strcmp(ca->ca_name, "power"))
                return (0);

        return (1);
}

void
powerattach(device_t parent, device_t self, void *aux)
{
        struct power_softc *sc = device_private(self);
        struct confargs *ca = aux;
        int err;

        sc->sc_dev = self;
        sc->sc_kicker = NULL;

        err = pdcproc_soft_power_info(&pdc_power_info);

        if (!err)
                ca->ca_hpa = pdc_power_info.addr;

        switch (cpu_modelno) {
        case HPPA_BOARD_HP712_60:
        case HPPA_BOARD_HP712_80:
        case HPPA_BOARD_HP712_100:
        case HPPA_BOARD_HP712_120:
                sc->sc_kicker = power_thread_dr;

                /* Diag Reg. needs software dampening, poll at 0.2 Hz.*/
                sc->sc_timeout = hz / 5;

                aprint_normal(": DR25\n");
                break;

        default:
                if (ca->ca_hpa) {
                        sc->sc_bst = ca->ca_iot;
                        if (bus_space_map(sc->sc_bst, ca->ca_hpa, 4, 0,
                            &sc->sc_bsh) != 0)
                                aprint_error_dev(self,
                                    "Can't map power switch status reg.\n");

                        cold_hook = power_cold_hook_reg;
                        sc->sc_kicker = power_thread_reg;

                        /* Power Reg. is hardware dampened, poll at 1 Hz. */
                        sc->sc_timeout = hz;

                        aprint_normal("\n");
                } else
                        aprint_normal(": not available\n");
                break;
        }

        if (sc->sc_kicker) {
                if (pwr_sw_init(sc))
                        return;

                pswitch_on = true;
                pwr_sw_control = PWR_SW_CTRL_ENABLE;
        }
}

/*
 * If the power switch is turned off we schedule a sysmon task
 * to register that event for this power switch device.
 */
static void
check_pwr_state(struct power_softc *sc)
{
        if (pswitch_on == false && pwr_sw_control != PWR_SW_CTRL_LOCK)
                sysmon_task_queue_sched(0, pwr_sw_sysmon_cb, NULL);
        else
                callout_reset(&sc->sc_callout, sc->sc_timeout,
                    sc->sc_kicker, sc);
}

void
power_thread_dr(void *v)
{
        struct power_softc *sc = v;
        uint32_t r;

        /* Get Power Fail status from CPU Diagnose Register 25 */
        mfcpu(25, r);

        /*
         * On power failure, the hardware clears bit DR25_PCXL_POWFAIL
         * in CPU Diagnose Register 25.
         */
        if (r & (1 << DR25_PCXL_POWFAIL))
                sc->sc_dr_cnt = 0;
        else
                sc->sc_dr_cnt++;

        /*
         * the bit is undampened straight wire from the power
         * switch and thus we have do dampen it ourselves.
         */
        if (sc->sc_dr_cnt == sc->sc_timeout)
                pswitch_on = false;
        else
                pswitch_on = true;

        check_pwr_state(sc);
}

void
power_thread_reg(void *v)
{
        struct power_softc *sc = v;
        uint32_t r;

        r = bus_space_read_4(sc->sc_bst, sc->sc_bsh, 0);

        if (!(r & 1))
                pswitch_on = false;
        else
                pswitch_on = true;

        check_pwr_state(sc);
}

void
power_cold_hook_reg(int on)
{
        int error;

        error = pdcproc_soft_power_enable(on == HPPA_COLD_HOT);
        if (error)
                aprint_error("PDC_SOFT_POWER_ENABLE failed (%d)\n", error);
}

static int
pwr_sw_init(struct power_softc *sc)
{
        struct sysctllog *sysctl_log = NULL;
        const struct sysctlnode *pwr_sw_node;
        const char *errmsg;
        int error = EINVAL;

        /*
         * Ensure that we are on a PCX-L / PA7100LC CPU if it is a
         * 712 style machine.
         */
        if (pdc_power_info.addr == 0 && hppa_cpu_info->hci_cputype != hpcxl) {
                aprint_error_dev(sc->sc_dev, "No soft power available.\n");
                return error;
        }

        errmsg = "Can't create sysctl machdep.power_switch (or children)\n";
        error = sysctl_createv(&sysctl_log, 0, NULL, NULL, 0,
            CTLTYPE_NODE, "machdep", NULL, NULL, 0, NULL, 0,
            CTL_MACHDEP, CTL_EOL);

        if (error)
                goto err_sysctl;

        error = sysctl_createv(&sysctl_log, 0, NULL, &pwr_sw_node, 0,
            CTLTYPE_NODE, "power_switch", NULL, NULL, 0, NULL, 0,
            CTL_MACHDEP, CTL_CREATE, CTL_EOL);

        if (error)
                goto err_sysctl;

        error = sysctl_createv(&sysctl_log, 0, NULL, NULL,
            CTLFLAG_READONLY, CTLTYPE_STRING, "state", NULL,
            pwr_sw_sysctl_state, 0, NULL, 16,
            CTL_MACHDEP, pwr_sw_node->sysctl_num, CTL_CREATE, CTL_EOL);

        if (error)
                goto err_sysctl;

        error = sysctl_createv(&sysctl_log, 0, NULL, NULL,
            CTLFLAG_READWRITE, CTLTYPE_STRING, "control", NULL,
            pwr_sw_sysctl_ctrl, 0, NULL, 16,
            CTL_MACHDEP, pwr_sw_node->sysctl_num, CTL_CREATE, CTL_EOL);

        if (error)
                goto err_sysctl;

        errmsg = "Can't alloc sysmon power switch.\n";
        pwr_sw_sysmon = kmem_zalloc(sizeof(*pwr_sw_sysmon), KM_SLEEP);
        errmsg = "Can't register power switch with sysmon.\n";
        sysmon_task_queue_init();
        pwr_sw_sysmon->smpsw_name = "power switch";
        pwr_sw_sysmon->smpsw_type = PSWITCH_TYPE_POWER;
        error = sysmon_pswitch_register(pwr_sw_sysmon);

        if (error)
                goto err_sysmon;

        callout_init(&sc->sc_callout, 0);
        callout_reset(&sc->sc_callout, sc->sc_timeout, sc->sc_kicker, sc);

        return error;

err_sysmon:
        kmem_free(pwr_sw_sysmon, sizeof(*pwr_sw_sysmon));

err_sysctl:
        sysctl_teardown(&sysctl_log);

        aprint_error_dev(sc->sc_dev, errmsg);

        return error;
}

static void
pwr_sw_sysmon_cb(void *not_used)
{
        sysmon_pswitch_event(pwr_sw_sysmon, PSWITCH_EVENT_PRESSED);
}

static void
pwr_sw_ctrl(int enable)
{
        int on;

#ifdef DEBUG
        printf("pwr_sw_control=%d enable=%d\n", pwr_sw_control, enable);
#endif /* DEBUG */

        if (cold_hook == NULL)
                return;

        switch(enable) {
        case PWR_SW_CTRL_DISABLE:
                on = HPPA_COLD_OFF;
                break;
        case PWR_SW_CTRL_ENABLE:
        case PWR_SW_CTRL_LOCK:
                on = HPPA_COLD_HOT;
                break;
        default:
                panic("invalid power state in pwr_sw_control: %d", enable);
        }

        pwr_sw_control = enable;

        if (cold_hook)
                (*cold_hook)(on);
}

int
pwr_sw_sysctl_state(SYSCTLFN_ARGS)
{
        struct sysctlnode node;
        const char *status;

        if (pswitch_on == true)
                status = "on";
        else
                status = "off";

        node = *rnode;
        node.sysctl_data = __UNCONST(status);
        return sysctl_lookup(SYSCTLFN_CALL(&node));
}

int
pwr_sw_sysctl_ctrl(SYSCTLFN_ARGS)
{
        struct sysctlnode node;
        int i, error;
        char val[16];

        node = *rnode;
        strcpy(val, pwr_sw_control_str[pwr_sw_control]);

        node.sysctl_data = val;

        error = sysctl_lookup(SYSCTLFN_CALL(&node));

        if (error || newp == NULL)
                return error;

        for (i = 0; i <= PWR_SW_CTRL_MAX; i++)
                if (strcmp(val, pwr_sw_control_str[i]) == 0) {
                        pwr_sw_ctrl(i);
                        return 0;
                }

        return EINVAL;
}