/*      $NetBSD: vrpiu.c,v 1.46 2025/06/28 06:45:06 andvar Exp $        */

/*
 * Copyright (c) 1999-2003 TAKEMURA Shin All rights reserved.
 * Copyright (c) 2000-2001 SATO Kazumi, All rights reserved.
 * Copyright (c) 1999-2001 PocketBSD Project. 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 REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 *
 */

/*
 * A/D polling part written by SATO Kazumi.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: vrpiu.c,v 1.46 2025/06/28 06:45:06 andvar Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/callout.h>
#include <sys/boot_flag.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsmousevar.h>

#include <machine/bus.h>
#include <machine/platid.h>
#include <machine/platid_mask.h>
#include <machine/config_hook.h>

#include <dev/hpc/hpctpanelvar.h>

#include <dev/hpc/hpcbatteryvar.h>
#include <dev/hpc/hpcbatterytable.h>

#include <hpcmips/vr/vrcpudef.h>
#include <hpcmips/vr/vripif.h>
#include <hpcmips/vr/cmureg.h>
#include <hpcmips/vr/vrpiuvar.h>
#define PIUB_REG_OFFSSET        0
#include <hpcmips/vr/vrpiureg.h>

/*
 * constant and macro definitions
 */
#define VRPIUDEBUG
#ifdef VRPIUDEBUG
int     vrpiu_debug = 0;
#define DPRINTF(arg) if (vrpiu_debug) printf arg;
#define VPRINTF(arg) if (bootverbose || vrpiu_debug) printf arg;
#else
#define DPRINTF(arg)
#define VPRINTF(arg) if (bootverbose) printf arg;
#endif

#ifndef VRPIU_NO_ADHOC_BATTERY_EVENT
#define VRPIU_ADHOC_BATTERY_EVENT       /* currently... */
#endif /* VRPIU_NO_ADHOC_BATTERY_EVENT */

#ifndef VRPIU_AD_POLL_INTERVAL
#define VRPIU_AD_POLL_INTERVAL  60      /* interval is 60 sec */
#endif /* VRPIU_AD_POLL_INTERTVAL */

#define PIUSIVL_SCANINTVAL_MIN  333                     /* 10msec       */
#define PIUSIVL_SCANINTVAL_MAX  PIUSIVL_SCANINTVAL_MASK /* 60msec       */
#define VRPIU_TP_SCAN_TIMEOUT   (hz/10)         /* timeout is 100msec   */

#define TP_INTR (PIUINT_ALLINTR & ~PIUINT_PADADPINTR)
#define AD_INTR (PIUINT_PADADPINTR)

/*
 * data types
 */
/* struct vrpiu_softc is defined in vrpiuvar.h */

/*
 * function prototypes
 */
static int      vrpiumatch(device_t, cfdata_t, void *);
static void     vrpiuattach(device_t, device_t, void *);
static void     vrc4173piuattach(device_t, device_t, void *);
static void     vrpiu_init(struct vrpiu_softc *, void *);

static void     vrpiu_write(struct vrpiu_softc *, int, unsigned short);
static u_short  vrpiu_read(struct vrpiu_softc *, int);

static int      vrpiu_intr(void *);
static void     vrpiu_tp_intr(struct vrpiu_softc *);
static void     vrpiu_ad_intr(struct vrpiu_softc *);
#ifdef DEBUG
static void     vrpiu_dump_cntreg(unsigned int);
#endif

static int      vrpiu_tp_enable(void *);
static int      vrpiu_tp_ioctl(void *, u_long, void *, int, struct lwp *);
static void     vrpiu_tp_disable(void *);
static void     vrpiu_tp_up(struct vrpiu_softc *);
static void     vrpiu_tp_timeout(void *);
int             vrpiu_ad_enable(void *);
void            vrpiu_ad_disable(void *);
static void     vrpiu_start_powerstate(void *);
static void     vrpiu_calc_powerstate(struct vrpiu_softc *);
static void     vrpiu_send_battery_event(struct vrpiu_softc *);
static void     vrpiu_power(int, void *);
static u_int    scan_interval(u_int data);

/* mra is defined in mra.c */
int mra_Y_AX1_BX2_C(int *y, int ys, int *x1, int x1s, int *x2, int x2s,
    int n, int scale, int *a, int *b, int *c);

/*
 * static or global variables
 */
CFATTACH_DECL_NEW(vrpiu, sizeof(struct vrpiu_softc),
    vrpiumatch, vrpiuattach, NULL, NULL);
CFATTACH_DECL_NEW(vrc4173piu, sizeof(struct vrpiu_softc),
    vrpiumatch, vrc4173piuattach, NULL, NULL);

const struct wsmouse_accessops vrpiu_accessops = {
        vrpiu_tp_enable,
        vrpiu_tp_ioctl,
        vrpiu_tp_disable,
};

int vrpiu_ad_poll_interval = VRPIU_AD_POLL_INTERVAL;

/*
 * function definitions
 */
static inline void
vrpiu_write(struct vrpiu_softc *sc, int port, unsigned short val)
{

        bus_space_write_2(sc->sc_iot, sc->sc_ioh, port, val);
}

static inline u_short
vrpiu_read(struct vrpiu_softc *sc, int port)
{

        return (bus_space_read_2(sc->sc_iot, sc->sc_ioh, port));
}

static inline u_short
vrpiu_buf_read(struct vrpiu_softc *sc, int port)
{

        return (bus_space_read_2(sc->sc_iot, sc->sc_buf_ioh, port));
}

static int
vrpiumatch(device_t parent, cfdata_t cf, void *aux)
{

        return (1);
}

static void
vrpiuattach(device_t parent, device_t self, void *aux)
{
        struct vrpiu_softc *sc = device_private(self);

        sc->sc_dev = self;
        sc->sc_ab_paddata_mask = PIUAB_PADDATA_MASK;
        sc->sc_pb_paddata_mask = PIUPB_PADDATA_MASK;
        sc->sc_pb_paddata_max = PIUPB_PADDATA_MAX;
        vrpiu_init(sc, aux);
}

static void
vrc4173piuattach(device_t parent, device_t self, void *aux)
{
        struct vrpiu_softc *sc = device_private(self);

        sc->sc_dev = self;
        sc->sc_ab_paddata_mask = VRC4173PIUAB_PADDATA_MASK;
        sc->sc_pb_paddata_mask = VRC4173PIUPB_PADDATA_MASK;
        sc->sc_pb_paddata_max = VRC4173PIUPB_PADDATA_MAX;
        vrpiu_init(sc, aux);
}

static void
vrpiu_init(struct vrpiu_softc *sc, void *aux)
{
        struct vrip_attach_args *va = aux;
        struct wsmousedev_attach_args wsmaa;
        int res;
        bus_space_tag_t iot = va->va_iot;
        struct platid_data *p;

        if (va->va_parent_ioh != 0)
                res = bus_space_subregion(iot, va->va_parent_ioh, va->va_addr,
                    va->va_size, &sc->sc_ioh);
        else
                res = bus_space_map(iot, va->va_addr, va->va_size, 0,
                    &sc->sc_ioh);
        if (res != 0) {
                printf(": can't map bus space\n");
                return;
        }
        if (va->va_parent_ioh != 0)
                res = bus_space_subregion(iot, va->va_parent_ioh, va->va_addr2,
                    va->va_size2, &sc->sc_buf_ioh);
        else
                res = bus_space_map(iot, va->va_addr2, va->va_size2, 0,
                    &sc->sc_buf_ioh);
        if (res != 0) {
                printf(": can't map second bus space\n");
                return;
        }

        sc->sc_iot = iot;
        sc->sc_unit = va->va_unit;
        sc->sc_vrip = va->va_vc;

        sc->sc_interval = scan_interval(WSMOUSE_RES_DEFAULT);
        if ((p = platid_search_data(&platid, hpcbattery_parameters)) == NULL)
                sc->sc_battery_spec = NULL;
        else
                sc->sc_battery_spec  = p->data;

        /*
         * disable device until vrpiu_enable called
         */
        sc->sc_tpstat = VRPIU_TP_STAT_DISABLE;

        /* initialize touch panel timeout structure     */
        callout_init(&sc->sc_tptimeout, 0);

        /* initialize calibration context       */
        tpcalib_init(&sc->sc_tpcalib);
#if 1
        /*
         * XXX, calibrate parameters
         */
        {
                int i;
                static const struct {
                        platid_mask_t *mask;
                        struct wsmouse_calibcoords coords;
                } calibrations[] = {
                        { &platid_mask_MACH_NEC_MCR_700,
                          { 0, 0, 799, 599,
                            4,
                            { { 115,  80,   0,   0 },
                              { 115, 966,   0, 599 },
                              { 912,  80, 799,   0 },
                              { 912, 966, 799, 599 } } } },
                        { &platid_mask_MACH_NEC_MCR_700A,
                          { 0, 0, 799, 599,
                            4,
                            { { 115,  80,   0,   0 },
                              { 115, 966,   0, 599 },
                              { 912,  80, 799,   0 },
                              { 912, 966, 799, 599 } } } },
                        { &platid_mask_MACH_NEC_MCR_730,
                          { 0, 0, 799, 599,
                            4,
                            { { 115,  80,   0,   0 },
                              { 115, 966,   0, 599 },
                              { 912,  80, 799,   0 },
                              { 912, 966, 799, 599 } } } },
                        { &platid_mask_MACH_NEC_MCR_730A,
                          { 0, 0, 799, 599,
                            4,
                            { { 115,  80,   0,   0 },
                              { 115, 966,   0, 599 },
                              { 912,  80, 799,   0 },
                              { 912, 966, 799, 599 } } } },
                        { NULL,         /* samples got on my MC-R500 */
                          { 0, 0, 639, 239,
                            5,
                            { { 502, 486, 320, 120 },
                              {  55, 109,   0,   0 },
                              {  54, 913,   0, 239 },
                              { 973, 924, 639, 239 },
                              { 975, 123, 639,   0 } } } },
                };
                for (i = 0; ; i++) {
                        if (calibrations[i].mask == NULL
                            || platid_match(&platid, calibrations[i].mask))
                                break;
                }
                tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS,
                    (void *)__UNCONST(&calibrations[i].coords), 0, 0);
        }
#endif

        /* install interrupt handler and enable interrupt */
        if (!(sc->sc_handler =
            vrip_intr_establish(sc->sc_vrip, sc->sc_unit, 0, IPL_TTY,
                vrpiu_intr, sc))) {
                printf (": can't map interrupt line.\n");
                return;
        }

        /* mask level2 interrupt, stop scan sequencer and mask clock to piu */
        vrpiu_tp_disable(sc);

        printf("\n");

        wsmaa.accessops = &vrpiu_accessops;
        wsmaa.accesscookie = sc;

        /*
         * attach the wsmouse
         */
        sc->sc_wsmousedev = config_found(sc->sc_dev, &wsmaa, wsmousedevprint,
            CFARGS_NONE);

        /*
         * power management events
         */
        sc->sc_power_hook = powerhook_establish(device_xname(sc->sc_dev),
            vrpiu_power, sc);
        if (sc->sc_power_hook == NULL)
                aprint_error("%s: WARNING: couldn't establish powerhook\n",
                    device_xname(sc->sc_dev));

        /*
         * init A/D port polling.
         */
        sc->sc_battery.n_values = 3;
        sc->sc_battery.value[0] = -1;
        sc->sc_battery.value[1] = -1;
        sc->sc_battery.value[2] = -1;
        sc->sc_battery.nextpoll = hz*vrpiu_ad_poll_interval;
        callout_init(&sc->sc_adpoll, 0);
        callout_reset(&sc->sc_adpoll, hz, vrpiu_start_powerstate, sc);
}

/*
 * calculate interval value
 *  input: WSMOUSE_RES_MIN - WSMOUSE_RES_MAX
 * output: value for PIUSIVL_REG
 */
static u_int
scan_interval(u_int data)
{
        int scale;

        if (data < WSMOUSE_RES_MIN)
                data = WSMOUSE_RES_MIN;

        if (WSMOUSE_RES_MAX < data)
                data = WSMOUSE_RES_MAX;

        scale = WSMOUSE_RES_MAX - WSMOUSE_RES_MIN;
        data += WSMOUSE_RES_MIN;

        return PIUSIVL_SCANINTVAL_MIN +
            (PIUSIVL_SCANINTVAL_MAX - PIUSIVL_SCANINTVAL_MIN) *
            (scale - data) / scale;
}

int
vrpiu_ad_enable(void *v)
{
        struct vrpiu_softc *sc = v;
        int s;
        unsigned int cnt;

        DPRINTF(("%s(%d): vrpiu_ad_enable(): interval=0x%03x\n",
            __FILE__, __LINE__, sc->sc_interval));
        if (sc->sc_adstat != VRPIU_AD_STAT_DISABLE)
                return EBUSY;

        /* supply clock to PIU */
        vrip_power(sc->sc_vrip, sc->sc_unit, 1);

        /* set scan interval */
        vrpiu_write(sc, PIUSIVL_REG_W, sc->sc_interval);

        s = spltty();

        /* clear interrupt status */
        vrpiu_write(sc, PIUINT_REG_W, AD_INTR);

        /* Disable -> Standby */
        cnt = PIUCNT_PIUPWR |
            PIUCNT_PIUMODE_COORDINATE |
            PIUCNT_PADATSTART | PIUCNT_PADATSTOP;
        vrpiu_write(sc, PIUCNT_REG_W, cnt);

        /* Level2 interrupt register setting */
        vrip_intr_setmask2(sc->sc_vrip, sc->sc_handler, AD_INTR, 1);

        /* save pen status, touch or release */
        cnt = vrpiu_read(sc, PIUCNT_REG_W);

        /*
         * Enable scan sequencer operation
         * Standby -> WaitPenTouch
         */
        cnt |= PIUCNT_PIUSEQEN;
        vrpiu_write(sc, PIUCNT_REG_W, cnt);

        sc->sc_adstat = VRPIU_AD_STAT_ENABLE;

        splx(s);

        return 0;
}

void
vrpiu_ad_disable(void *v)
{
        struct vrpiu_softc *sc = v;

        DPRINTF(("%s(%d): vrpiu_ad_disable()\n", __FILE__, __LINE__));

        /* Set level2 interrupt register to mask interrupts */
        vrip_intr_setmask2(sc->sc_vrip, sc->sc_handler, AD_INTR, 0);

        sc->sc_adstat = VRPIU_AD_STAT_DISABLE;

        if (sc->sc_tpstat == VRPIU_TP_STAT_DISABLE){
                /* Disable scan sequencer operation and power off */
                vrpiu_write(sc, PIUCNT_REG_W, 0);

                /* mask clock to PIU */
                vrip_power(sc->sc_vrip, sc->sc_unit, 0);
        }
}

int
vrpiu_tp_enable(void *v)
{
        struct vrpiu_softc *sc = v;
        int s;
        unsigned int cnt;

        DPRINTF(("%s(%d): vrpiu_tp_enable(): interval=0x%03x\n",
            __FILE__, __LINE__, sc->sc_interval));
        if (sc->sc_tpstat != VRPIU_TP_STAT_DISABLE)
                return EBUSY;

        /* supply clock to PIU */
        vrip_power(sc->sc_vrip, sc->sc_unit, 1);

        /* set scan interval */
        vrpiu_write(sc, PIUSIVL_REG_W, sc->sc_interval);

        s = spltty();

        /* clear interrupt status */
        vrpiu_write(sc, PIUINT_REG_W, TP_INTR);

        /* Disable -> Standby */
        cnt = PIUCNT_PIUPWR |
            PIUCNT_PIUMODE_COORDINATE |
            PIUCNT_PADATSTART | PIUCNT_PADATSTOP;
        vrpiu_write(sc, PIUCNT_REG_W, cnt);

        /* Level2 interrupt register setting */
        vrip_intr_setmask2(sc->sc_vrip, sc->sc_handler, TP_INTR, 1);

        /* save pen status, touch or release */
        cnt = vrpiu_read(sc, PIUCNT_REG_W);

        /*
         * Enable scan sequencer operation
         * Standby -> WaitPenTouch
         */
        cnt |= PIUCNT_PIUSEQEN;
        vrpiu_write(sc, PIUCNT_REG_W, cnt);

        /* transit status DISABLE -> TOUCH or RELEASE */
        sc->sc_tpstat = (cnt & PIUCNT_PENSTC) ?
            VRPIU_TP_STAT_TOUCH : VRPIU_TP_STAT_RELEASE;

        splx(s);

        return 0;
}

void
vrpiu_tp_disable(void *v)
{
        struct vrpiu_softc *sc = v;

        DPRINTF(("%s(%d): vrpiu_tp_disable()\n", __FILE__, __LINE__));

        /* Set level2 interrupt register to mask interrupts */
        vrip_intr_setmask2(sc->sc_vrip, sc->sc_handler, TP_INTR, 0);

        sc->sc_tpstat = VRPIU_TP_STAT_DISABLE;

        if (sc->sc_adstat == VRPIU_AD_STAT_DISABLE){
                /* Disable scan sequencer operation and power off */
                vrpiu_write(sc, PIUCNT_REG_W, 0);

                /* mask clock to PIU */
                vrip_power(sc->sc_vrip, sc->sc_unit, 0);
        }
}

int
vrpiu_tp_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct vrpiu_softc *sc = v;

        DPRINTF(("%s(%d): vrpiu_tp_ioctl(%08lx)\n", __FILE__, __LINE__, cmd));

        switch (cmd) {
        case WSMOUSEIO_SRES:
        {
                int tp_enable;
                int ad_enable;

                tp_enable = (sc->sc_tpstat != VRPIU_TP_STAT_DISABLE);
                ad_enable = (sc->sc_adstat != VRPIU_AD_STAT_DISABLE);

                if (tp_enable)
                        vrpiu_tp_disable(sc);
                if (ad_enable)
                        vrpiu_ad_disable(sc);

                sc->sc_interval = scan_interval(*(u_int *)data);
                DPRINTF(("%s(%d): WSMOUSEIO_SRES: *data=%d, interval=0x%03x\n",
                    __FILE__, __LINE__, *(u_int *)data, sc->sc_interval));

                if (sc->sc_interval < PIUSIVL_SCANINTVAL_MIN)
                        sc->sc_interval = PIUSIVL_SCANINTVAL_MIN;

                if (PIUSIVL_SCANINTVAL_MAX < sc->sc_interval)
                        sc->sc_interval = PIUSIVL_SCANINTVAL_MAX;

                if (tp_enable)
                        vrpiu_tp_enable(sc);
                if (ad_enable)
                        vrpiu_ad_enable(sc);
        }
        break;

        default:
                return hpc_tpanel_ioctl(&sc->sc_tpcalib, cmd, data, flag, l);
        }
        return 0;
}

/*
 * PIU AD interrupt handler.
 */
void
vrpiu_ad_intr(struct vrpiu_softc *sc)
{
        unsigned int i;
        unsigned int intrstat;

        intrstat = vrpiu_read(sc, PIUINT_REG_W);

        if (sc->sc_adstat == VRPIU_AD_STAT_DISABLE) {
                /*
                 * the device isn't enabled. just clear interrupt.
                 */
                vrpiu_write(sc, PIUINT_REG_W, AD_INTR);
                return;
        }

        if (intrstat & PIUINT_PADADPINTR) {
                sc->sc_battery.value[0] = (unsigned int)
                    vrpiu_buf_read(sc, PIUAB(0));
                sc->sc_battery.value[1] = (unsigned int)
                    vrpiu_buf_read(sc, PIUAB(1));
                sc->sc_battery.value[2] = (unsigned int)
                    vrpiu_buf_read(sc, PIUAB(2));
        }

        if (intrstat & PIUINT_PADADPINTR) {
                for (i = 0; i < 3; i++) {
                        if (sc->sc_battery.value[i] & PIUAB_VALID)
                                sc->sc_battery.value[i] &=
                                        sc->sc_ab_paddata_mask;
                        else
                                sc->sc_battery.value[i] = 0;
                }
                vrpiu_calc_powerstate(sc);
        }
        vrpiu_write(sc, PIUINT_REG_W, AD_INTR);

        return;
}
/*
 * PIU TP interrupt handler.
 */
void
vrpiu_tp_intr(struct vrpiu_softc *sc)
{
        unsigned int cnt, i;
        unsigned int intrstat, page;
        int tpx0, tpx1, tpy0, tpy1;
        int x, y, xraw, yraw;

        tpx0 = tpx1 = tpy0 = tpy1 = 0;  /* XXX: gcc -Wuninitialized */

        intrstat = vrpiu_read(sc, PIUINT_REG_W);

        if (sc->sc_tpstat == VRPIU_TP_STAT_DISABLE) {
                /*
                 * the device isn't enabled. just clear interrupt.
                 */
                vrpiu_write(sc, PIUINT_REG_W, intrstat & TP_INTR);
                return;
        }

        page = (intrstat & PIUINT_OVP) ? 1 : 0;
        if (intrstat & (PIUINT_PADPAGE0INTR | PIUINT_PADPAGE1INTR)) {
                tpx0 = vrpiu_buf_read(sc, PIUPB(page, 0));
                tpx1 = vrpiu_buf_read(sc, PIUPB(page, 1));
                tpy0 = vrpiu_buf_read(sc, PIUPB(page, 2));
                tpy1 = vrpiu_buf_read(sc, PIUPB(page, 3));
        }

        if (intrstat & PIUINT_PADDLOSTINTR) {
                page = page ? 0 : 1;
                for (i = 0; i < 4; i++)
                        vrpiu_buf_read(sc, PIUPB(page, i));
        }

        cnt = vrpiu_read(sc, PIUCNT_REG_W);
#ifdef DEBUG
        if (vrpiu_debug)
                vrpiu_dump_cntreg(cnt);
#endif

        /* clear interrupt status */
        vrpiu_write(sc, PIUINT_REG_W, intrstat & TP_INTR);

#if 0
        DPRINTF(("vrpiu_intr: OVP=%d", page));
        if (intrstat & PIUINT_PADCMDINTR)
                DPRINTF((" CMD"));
        if (intrstat & PIUINT_PADADPINTR)
                DPRINTF((" A/D"));
        if (intrstat & PIUINT_PADPAGE1INTR)
                DPRINTF((" PAGE1"));
        if (intrstat & PIUINT_PADPAGE0INTR)
                DPRINTF((" PAGE0"));
        if (intrstat & PIUINT_PADDLOSTINTR)
                DPRINTF((" DLOST"));
        if (intrstat & PIUINT_PENCHGINTR)
                DPRINTF((" PENCHG"));
        DPRINTF(("\n"));
#endif
        if (intrstat & (PIUINT_PADPAGE0INTR | PIUINT_PADPAGE1INTR)) {
                /*
                 * just ignore scan data if status isn't Touch.
                 */
                if (sc->sc_tpstat == VRPIU_TP_STAT_TOUCH) {
                        /* reset tp scan timeout        */
                        callout_reset(&sc->sc_tptimeout, VRPIU_TP_SCAN_TIMEOUT,
                            vrpiu_tp_timeout, sc);

                        if (!((tpx0 & PIUPB_VALID) && (tpx1 & PIUPB_VALID) &&
                            (tpy0 & PIUPB_VALID) && (tpy1 & PIUPB_VALID))) {
                                printf("vrpiu: internal error,"
                                    " data is not valid!\n");
                        } else {
                                tpx0 &= sc->sc_pb_paddata_mask;
                                tpx1 &= sc->sc_pb_paddata_mask;
                                tpy0 &= sc->sc_pb_paddata_mask;
                                tpy1 &= sc->sc_pb_paddata_mask;
#define ISVALID(n, c)   ((c) - (c)/5 < (n) && (n) < (c) + (c)/5)
                                if (ISVALID(tpx0 + tpx1, sc->sc_pb_paddata_max) &&
                                    ISVALID(tpy0 + tpy1, sc->sc_pb_paddata_max)) {
#if 0
                                        DPRINTF(("%04x %04x %04x %04x\n",
                                            tpx0, tpx1, tpy0, tpy1));
                                        DPRINTF(("%3d %3d (%4d %4d)->", tpx0,
                                            tpy0, tpx0 + tpx1, tpy0 + tpy1));
#endif
                                        xraw = tpy1 * sc->sc_pb_paddata_max / (tpy0 + tpy1);
                                        yraw = tpx1 * sc->sc_pb_paddata_max / (tpx0 + tpx1);
                                        DPRINTF(("%3d %3d", xraw, yraw));

                                        tpcalib_trans(&sc->sc_tpcalib, xraw,
                                            yraw, &x, &y);

                                        DPRINTF(("->%4d %4d", x, y));
                                        wsmouse_input(sc->sc_wsmousedev,
                                            1, /* button 0 down */
                                            x, /* x */
                                            y, /* y */
                                            0, /* z */
                                            0, /* w */
                                            WSMOUSE_INPUT_ABSOLUTE_X |
                                            WSMOUSE_INPUT_ABSOLUTE_Y);
                                        DPRINTF(("\n"));
                                }
                        }
                }
        }

        if (cnt & PIUCNT_PENSTC) {
                if (sc->sc_tpstat == VRPIU_TP_STAT_RELEASE) {
                        /*
                         * pen touch
                         */
                        DPRINTF(("PEN TOUCH\n"));
                        sc->sc_tpstat = VRPIU_TP_STAT_TOUCH;
                        /*
                         * We should not report button down event while
                         * we don't know where it occur.
                         */

                        /* set tp scan timeout  */
                        callout_reset(&sc->sc_tptimeout, VRPIU_TP_SCAN_TIMEOUT,
                            vrpiu_tp_timeout, sc);
                }
        } else {
                vrpiu_tp_up(sc);
        }

        if (intrstat & PIUINT_PADDLOSTINTR) {
                cnt |= PIUCNT_PIUSEQEN;
                vrpiu_write(sc, PIUCNT_REG_W, cnt);
        }

        return;
}

void
vrpiu_tp_up(struct vrpiu_softc *sc)
{
        if (sc->sc_tpstat == VRPIU_TP_STAT_TOUCH) {
                /*
                 * pen release
                 */
                DPRINTF(("RELEASE\n"));
                sc->sc_tpstat = VRPIU_TP_STAT_RELEASE;

                /* clear tp scan timeout        */
                callout_stop(&sc->sc_tptimeout);

                /* button 0 UP */
                wsmouse_input(sc->sc_wsmousedev, 0, 0, 0, 0, 0, 0);
        }
}

/* touch panel timeout handler */
void
vrpiu_tp_timeout(void *v)
{
        struct vrpiu_softc *sc = (struct vrpiu_softc *)v;

#ifdef VRPIUDEBUG
        {
                unsigned int cnt = vrpiu_read(sc, PIUCNT_REG_W);
                DPRINTF(("TIMEOUT: stat=%s  reg=%s\n",
                    (sc->sc_tpstat == VRPIU_TP_STAT_TOUCH)?"touch":"release",
                    (cnt & PIUCNT_PENSTC)?"touch":"release"));
        }
#endif
        vrpiu_tp_up(sc);
}

/*
 * PIU interrupt handler.
 */
int
vrpiu_intr(void *arg)
{
        struct vrpiu_softc *sc = arg;

        vrpiu_ad_intr(sc);
        vrpiu_tp_intr(sc);

        return 0;
}

void
vrpiu_start_powerstate(void *v)
{
        int mask;
        struct vrpiu_softc *sc = (struct vrpiu_softc *)v;

        vrpiu_ad_enable(sc);
        mask = vrpiu_read(sc, PIUAMSK_REG_W);
        mask &= 0xff8f; /* XXX */
        vrpiu_write(sc, PIUAMSK_REG_W, mask);
        vrpiu_write(sc, PIUASCN_REG_W, PIUACN_ADPSSTART);
        /*
         * restart next A/D polling
         */
        callout_reset(&sc->sc_adpoll, hz*vrpiu_ad_poll_interval,
            vrpiu_start_powerstate, sc);
}

void
vrpiu_calc_powerstate(struct vrpiu_softc *sc)
{
        extern void vrgiu_diff_io(void);
        vrpiu_ad_disable(sc);
        VPRINTF(("vrpiu:AD: %d, %d, %d\n",
            sc->sc_battery.value[0],
            sc->sc_battery.value[1],
            sc->sc_battery.value[2]));
        sc->sc_battery.nextpoll = hz*vrpiu_ad_poll_interval;
        vrpiu_send_battery_event(sc);
        /*
         * restart next A/D polling if change polling timing.
         */
        if (sc->sc_battery.nextpoll != hz*vrpiu_ad_poll_interval)
                callout_reset(&sc->sc_adpoll, sc->sc_battery.nextpoll,
                    vrpiu_start_powerstate, sc);
        if (bootverbose)
                vrgiu_diff_io();

}

static void
vrpiu_power(int why, void *arg)
{
        struct vrpiu_softc *sc = arg;

        switch (why) {
        case PWR_STANDBY:
        case PWR_SUSPEND:
                break;
        case PWR_RESUME:
                callout_reset(&sc->sc_adpoll, hz,
                    vrpiu_start_powerstate, sc);
                break;
        }
}

static void
vrpiu_send_battery_event(struct vrpiu_softc *sc)
{
#ifdef VRPIU_ADHOC_BATTERY_EVENT
        static int batteryhigh = 0;
        static int batterylow = 0;
        static int critical = 0;

        if (sc->sc_battery_spec == NULL
            || sc->sc_battery_spec->main_port == -1)
                return;

        if (sc->sc_battery.value[sc->sc_battery_spec->main_port]
            <= sc->sc_battery_spec->dc_critical) {
                batteryhigh = 0;
                config_hook_call(CONFIG_HOOK_PMEVENT,
                    CONFIG_HOOK_PMEVENT_BATTERY,
                    (void *)CONFIG_HOOK_BATT_CRITICAL);
                batterylow = 3;
                if (critical) {
                        config_hook_call(CONFIG_HOOK_PMEVENT,
                            CONFIG_HOOK_PMEVENT_SUSPENDREQ,
                            (void *)0);
                        critical = 0;
                        batterylow = 0;
                }
                critical++;
        } else if (sc->sc_battery.value[sc->sc_battery_spec->main_port]
            <= sc->sc_battery_spec->dc_20p) {
                batteryhigh = 0;
                if (batterylow == 1)
                        config_hook_call(CONFIG_HOOK_PMEVENT,
                            CONFIG_HOOK_PMEVENT_BATTERY,
                            (void *)CONFIG_HOOK_BATT_20P);
                config_hook_call(CONFIG_HOOK_PMEVENT,
                    CONFIG_HOOK_PMEVENT_BATTERY,
                    (void *)CONFIG_HOOK_BATT_LOW);
                batterylow = 2;
        } else if (sc->sc_battery.value[sc->sc_battery_spec->main_port]
            <= sc->sc_battery_spec->dc_50p) {
                batteryhigh = 0;
                if (batterylow == 0) {
                        batterylow = 1;
                        config_hook_call(CONFIG_HOOK_PMEVENT,
                            CONFIG_HOOK_PMEVENT_BATTERY,
                            (void *)CONFIG_HOOK_BATT_50P);
                }
        } else if (sc->sc_battery.value[sc->sc_battery_spec->main_port]
            >= sc->sc_battery_spec->ac_80p) {
                batterylow = 0;
                if (batteryhigh == 0) {
                        batteryhigh = 1;
                        config_hook_call(CONFIG_HOOK_PMEVENT,
                            CONFIG_HOOK_PMEVENT_BATTERY,
                            (void *)CONFIG_HOOK_BATT_80P);
                        config_hook_call(CONFIG_HOOK_PMEVENT,
                            CONFIG_HOOK_PMEVENT_BATTERY,
                            (void *)CONFIG_HOOK_BATT_HIGH);
                }
        }
#else /* VRPIU_ADHOC_BATTERY_EVENT */
        config_hook_call(CONFIG_HOOK_SET,
            CONFIG_HOOK_BATTERYVAL,
            (void *)&sc->sc_battery);
#endif /* VRPIU_ADHOC_BATTERY_EVENT */
}

#ifdef DEBUG
void
vrpiu_dump_cntreg(unsigned int cnt)
{
        printf("%s", (cnt & PIUCNT_PENSTC) ? "Touch" : "Release");
        printf(" state=");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_CmdScan)
                printf("CmdScan");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_IntervalNextScan)
                printf("IntervalNextScan");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_PenDataScan)
                printf("PenDataScan");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_WaitPenTouch)
                printf("WaitPenTouch");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_RFU)
                printf("???");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_ADPortScan)
                printf("ADPortScan");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_Standby)
                printf("Standby");
        if ((cnt & PIUCNT_PADSTATE_MASK) == PIUCNT_PADSTATE_Disable)
                printf("Disable");
        if (cnt & PIUCNT_PADATSTOP)
                printf(" AutoStop");
        if (cnt & PIUCNT_PADATSTART)
                printf(" AutoStart");
        if (cnt & PIUCNT_PADSCANSTOP)
                printf(" Stop");
        if (cnt & PIUCNT_PADSCANSTART)
                printf(" Start");
        if (cnt & PIUCNT_PADSCANTYPE)
                printf(" ScanPressure");
        if ((cnt & PIUCNT_PIUMODE_MASK) == PIUCNT_PIUMODE_ADCONVERTER)
                printf(" A/D");
        if ((cnt & PIUCNT_PIUMODE_MASK) == PIUCNT_PIUMODE_COORDINATE)
                printf(" Coordinate");
        if (cnt & PIUCNT_PIUSEQEN)
                printf(" SeqEn");
        if ((cnt & PIUCNT_PIUPWR) == 0)
                printf(" PowerOff");
        if ((cnt & PIUCNT_PADRST) == 0)
                printf(" Reset");
        printf("\n");
}
#endif