/* $NetBSD: psm.c,v 1.11 2016/07/07 06:55:38 msaitoh Exp $ */
/*
 * Copyright (c) 2006 Itronix Inc.
 * All rights reserved.
 *
 * Ported from Tadpole Solaris sources by Garrett D'Amore for Itronix Inc.
 *
 * 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 Itronix Inc. may not be used to endorse
 *    or promote products derived from this software without specific
 *    prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``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 ITRONIX INC. 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.
 */ 
/*
 * Tadpole-RDI Ultrabook IIi (huxley) power management.  Note that
 * there is a lot of stuff still missing here, due in part to the confusion
 * that exists with the NetBSD power management framework.  I'm not wasting
 * time with APM at this point, and some of sysmon seems "lacking".
 */
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: psm.c,v 1.11 2016/07/07 06:55:38 msaitoh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/kthread.h>
#include <sys/types.h>
#include <sys/device.h>
#include <sys/poll.h>
#include <sys/kauth.h>

#include <machine/autoconf.h>
#include <sys/bus.h>
#include <machine/intr.h>

#include <dev/ebus/ebusreg.h>
#include <dev/ebus/ebusvar.h>

#include <dev/sysmon/sysmonvar.h>

#include <sparc64/dev/psmreg.h>

struct psm_softc {
        device_t                sc_dev;
        bus_space_tag_t         sc_memt;
        bus_space_handle_t      sc_memh;

        int                     sc_event;
        int                     sc_flags;
        struct sysmon_pswitch   sc_sm_pbutton;
        struct sysmon_pswitch   sc_sm_lid;
        struct sysmon_pswitch   sc_sm_ac;
        struct evcnt            sc_intrcnt;
        lwp_t                   *sc_thread;
};

#define PUT8(sc, r, v)          \
        bus_space_write_1(sc->sc_memt, sc->sc_memh, r, v)
#define GET8(sc, r)             \
        bus_space_read_1(sc->sc_memt, sc->sc_memh, r)

#define WAIT_DELAY              1000
#define WAIT_RETRIES            1000

#define RESET_DELAY             200
#define CMD_DELAY               10
#define CMD_RETRIES             5

#ifdef  DEBUG
#define STATIC
#else
#define STATIC  static
#endif

/* flags indicating state */
#define PSM_FLAG_ACPWR          0x1
#define PSM_FLAG_LIDCLOSED      0x2
#define PSM_FLAG_DOCKED         0x4

/* system events -- causes activity in the event thread */
#define PSM_EV_PBUTTON          0x1
#define PSM_EV_LID              0x2
#define PSM_EV_ACPWR            0x4
#define PSM_EV_BATT             0x8
#define PSM_EV_TEMP             0x10

STATIC void psm_sysmon_setup(struct psm_softc *);
STATIC void psm_event_thread(void *);
STATIC int psm_init(struct psm_softc *);
STATIC void psm_reset(struct psm_softc *);
STATIC void psm_poll_acpower(struct psm_softc *);
STATIC int psm_intr(void *);
STATIC int psm_misc_rd(struct psm_softc *, uint8_t, uint8_t *);
STATIC int psm_misc_wr(struct psm_softc *, uint8_t, uint8_t);
STATIC int psm_wait(struct psm_softc *, uint8_t);
#if 0
STATIC int psm_ecmd_rd16(struct psm_softc *, uint16_t *, uint8_t, uint8_t,
    uint8_t);
#endif
STATIC int psm_ecmd_rd8(struct psm_softc *, uint8_t *, uint8_t, uint8_t,
    uint8_t);
STATIC int psm_ecmd_wr8(struct psm_softc *, uint8_t, uint8_t, uint8_t,
    uint8_t);
STATIC int psm_match(device_t, cfdata_t, void *);
STATIC void psm_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(psm, sizeof(struct psm_softc),
    psm_match, psm_attach, NULL, NULL);


int
psm_match(device_t parent, cfdata_t cf, void *aux)
{
        struct ebus_attach_args *ea = aux;

        if (strcmp(ea->ea_name, "psm") != 0)
                return (0);
        return (1);
}

void
psm_attach(device_t parent, device_t self, void *aux)
{
        struct psm_softc        *sc = device_private(self);
        struct ebus_attach_args *ea = aux;
        bus_addr_t              devaddr;
        const char              *xname;


        sc->sc_dev = self;
        sc->sc_memt = ea->ea_bustag;
        devaddr = EBUS_ADDR_FROM_REG(&ea->ea_reg[0]);

        xname = device_xname(sc->sc_dev);
        if (bus_space_map(sc->sc_memt, devaddr, ea->ea_reg[0].size,
                0, &sc->sc_memh) != 0) {
                printf(": unable to map device registers\n");
                return;
        }
        if (psm_init(sc) != 0) {
                printf(": unable to initialize device\n");
                return;
        }

        printf(": UltraBook IIi power control\n");

        psm_sysmon_setup(sc);

        if (kthread_create(PRI_NONE, 0, NULL, psm_event_thread, sc,
            &sc->sc_thread, "%s", xname) != 0) {
                aprint_error_dev(sc->sc_dev, "unable to create event kthread\n");
        }

        /*
         * Establish device interrupts
         */
        (void) bus_intr_establish(sc->sc_memt, ea->ea_intr[0], IPL_HIGH,
            psm_intr, sc);
        evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
            xname, "intr");
}

/*
 * Register sensors and events with sysmon.
 */
void
psm_sysmon_setup(struct psm_softc *sc)
{
        const char      *xname  = device_xname(sc->sc_dev);


        /*
         * XXX: Register sysmon environment.
         */

        /*
         * Register sysmon events
         */
        sc->sc_sm_pbutton.smpsw_name = xname;
        sc->sc_sm_pbutton.smpsw_type = PSWITCH_TYPE_POWER;
        if (sysmon_pswitch_register(&sc->sc_sm_pbutton) != 0)
                printf("%s: unable to register power button\n", xname);
        
        sc->sc_sm_lid.smpsw_name = xname;
        sc->sc_sm_lid.smpsw_type = PSWITCH_TYPE_LID;
        if (sysmon_pswitch_register(&sc->sc_sm_lid) != 0)
                printf("%s: unable to register lid switch\n", xname);

        sc->sc_sm_ac.smpsw_name = xname;
        sc->sc_sm_ac.smpsw_type = PSWITCH_TYPE_ACADAPTER;
        if (sysmon_pswitch_register(&sc->sc_sm_ac) != 0)
                printf("%s: unable to register AC adapter\n", xname);
}

void
psm_event_thread(void *arg)
{
        struct psm_softc *sc = arg;
        int     x;
        int     event;
        int     flags;

        for (;;) {
                x = splhigh();
                /* check for AC power.  sets event if there is a change */
                psm_poll_acpower(sc);

                /* read and clear events */
                event = sc->sc_event;
                flags = sc->sc_flags;
                sc->sc_event = 0;
                splx(x);

                if (event & PSM_EV_PBUTTON) {
                        sysmon_pswitch_event(&sc->sc_sm_pbutton,
                            PSWITCH_EVENT_PRESSED);
                }

                if (event & PSM_EV_LID) {
                        sysmon_pswitch_event(&sc->sc_sm_lid,
                            flags & PSM_FLAG_LIDCLOSED ?
                            PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
                }

                if (event & PSM_EV_ACPWR) {
                        sysmon_pswitch_event(&sc->sc_sm_ac,
                            flags & PSM_FLAG_ACPWR ?
                            PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
                }

                /* XXX: handle PSM_EV_TEMP */

                /* one second interval between probes of power */
                tsleep(&sc, PWAIT, "psm", hz);
        }
}

int
psm_init(struct psm_softc *sc)
{
        int     x;
        uint8_t batt = 0xff;    /* keep GCC 4.x happy */

        /* clear interrupts */
        x = splhigh();
        PUT8(sc, PSM_ICR, 0xff);
        splx(x);

        /* enable interrupts */
        if (psm_misc_wr(sc, PSM_MISC_IMR, PSM_IMR_ALL))
                return (-1);

        /* make sure that UPS battery is reasonable */
        if (psm_misc_rd(sc, PSM_MISC_UPS, &batt) || (batt > PSM_MAX_BATTERIES))
                if (psm_misc_wr(sc, PSM_MISC_UPS, batt))
                        aprint_error_dev(sc->sc_dev, "cannot set UPS battery");

        return (0);
}

void
psm_reset(struct psm_softc *sc)
{

        PUT8(sc, PSM_MCR, PSM_MCR_RST);
        delay(RESET_DELAY);
}

void
psm_poll_acpower(struct psm_softc *sc)
{
        int     flags = sc->sc_flags;

        if (GET8(sc, PSM_STAT) & PSM_STAT_AC) {
                sc->sc_flags |= PSM_FLAG_ACPWR;
        } else {
                sc->sc_flags &= ~PSM_FLAG_ACPWR;
        }
        if (flags != sc->sc_flags)
                sc->sc_event |= PSM_EV_ACPWR;
}

int
psm_misc_rd(struct psm_softc *sc, uint8_t mreg, uint8_t *data)
{

        return (psm_ecmd_rd8(sc, data, mreg, PSM_MODE_MISC, 0));
}

int
psm_misc_wr(struct psm_softc *sc, uint8_t mreg, uint8_t data)
{

        return (psm_ecmd_wr8(sc, data, mreg, PSM_MODE_MISC, 0));
}

int
psm_wait(struct psm_softc *sc, uint8_t flag)
{
    int retr = WAIT_RETRIES;

    while (GET8(sc, PSM_STAT) & flag) {
            if (!(retr--)) {
                    return (-1);
            }
            delay(WAIT_DELAY);
    }
    return (0);
}

#if 0
int
psm_ecmd_rd16(struct psm_softc *sc, uint16_t *data, uint8_t iar, uint8_t mode,
    uint8_t addr)
{
        uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_16, PSM_D_RD, addr);
        int     x, rc, retr = CMD_RETRIES;

        x = splhigh();

        do {
                if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
                        psm_reset(sc);
                        continue;
                }

                PUT8(sc, PSM_IAR, iar);
                PUT8(sc, PSM_CMR, cmr);

                delay(CMD_DELAY);

                if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
                        *data = GET8(sc, PSM_PWDL) | (GET8(sc, PSM_PWDU) << 8);
                        break;
                }

                psm_reset(sc);

        } while (--retr);

        splx(x);
        return (rc);
}
#endif

int
psm_ecmd_rd8(struct psm_softc *sc, uint8_t *data, uint8_t iar, uint8_t mode,
    uint8_t addr)
{
        uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_RD, addr);
        int     x, rc, retr = CMD_RETRIES;

        x = splhigh();

        do {
                if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
                        psm_reset(sc);
                        continue;
                }

                PUT8(sc, PSM_IAR, iar);
                PUT8(sc, PSM_CMR, cmr);

                delay(CMD_DELAY);

                if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
                        (void) GET8(sc, PSM_PWDU);
                        *data = GET8(sc, PSM_PWDL);
                        break;
                }

                psm_reset(sc);

        } while (--retr);

        splx(x);
        return (rc);
}

int
psm_ecmd_wr8(struct psm_softc *sc, uint8_t data, uint8_t iar, uint8_t mode,
    uint8_t addr)
{
        uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_WR, addr);
        int     x, rc, retr = CMD_RETRIES;

        x = splhigh();

        do {
                if ((rc = psm_wait(sc, PSM_STAT_WBF)) != 0) {
                        psm_reset(sc);
                        continue;
                }

                PUT8(sc, PSM_PWDU, 0);
                PUT8(sc, PSM_PWDL, data);
                PUT8(sc, PSM_IAR, iar);
                PUT8(sc, PSM_CMR, cmr);

                delay(CMD_DELAY);

                if ((rc = psm_wait(sc, PSM_STAT_WBF)) == 0) {
                        break;
                }

                psm_reset(sc);
        } while (--retr);

        splx(x);

        return (rc);
}

int
psm_intr(void *arg)
{
        struct psm_softc *sc = arg;
        uint8_t isr;

        isr = GET8(sc, PSM_ISR);
        if (isr & PSM_ISR_PO) {
                PUT8(sc, PSM_ICR, PSM_ISR_PO);
                sc->sc_event |= PSM_EV_PBUTTON;
        }
        if (isr & PSM_ISR_DK) {
                PUT8(sc, PSM_ICR, PSM_ISR_DK);
                sc->sc_flags |= PSM_FLAG_DOCKED;
        }
        if (isr & PSM_ISR_UDK) {
                PUT8(sc, PSM_ICR, PSM_ISR_UDK);
                sc->sc_flags &= ~PSM_FLAG_DOCKED;
        }
        if (isr & PSM_ISR_LIDC) {
                PUT8(sc, PSM_ICR, PSM_ISR_LIDC);
                sc->sc_flags |= PSM_FLAG_LIDCLOSED;
                sc->sc_event |= PSM_EV_LID;
        }
        if (isr & PSM_ISR_LIDO) {
                PUT8(sc, PSM_ICR, PSM_ISR_LIDO);
                sc->sc_flags &= ~PSM_FLAG_LIDCLOSED;
                sc->sc_event |= PSM_EV_LID;
        }
        if (isr & PSM_ISR_TMP) {
                /* Over temperature */
                PUT8(sc, PSM_ICR, PSM_ISR_TMP);
                sc->sc_event |= PSM_EV_TEMP;
        }
        if (isr & PSM_ISR_BCC) {
                /* battery config changed */
                PUT8(sc, PSM_ICR, PSM_ISR_BCC);
                sc->sc_event |= PSM_EV_BATT;
        }
        if (isr & PSM_ISR_RPD) {
                /* request to power down */
                sc->sc_event |= PSM_EV_PBUTTON;
        }
        if (sc->sc_event) {
                /* wake up the thread */
                wakeup(sc);
        }
        return (1);
}