/*      $NetBSD: psh3tp.c,v 1.18 2023/12/20 14:50:02 thorpej Exp $      */
/*
* Copyright (c) 2005 KIYOHARA Takashi
* 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>

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

#include "opt_psh3tp.h"

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

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

#include <machine/intr.h>

#include <sh3/exception.h>
#include <sh3/intcreg.h>
#include <sh3/pfcreg.h>
#include <sh3/adcreg.h>

#include <sh3/dev/adcvar.h>


#ifdef PSH3TP_DEBUG
volatile int psh3tp_debug = 4;
#define DPRINTF_PRINTF          printf_nolog
#define DPRINTF(arg)            if (psh3tp_debug) DPRINTF_PRINTF arg
#define DPRINTFN(n, arg)        if (psh3tp_debug > (n)) DPRINTF_PRINTF arg
#else
#define DPRINTF(arg)            ((void)0)
#define DPRINTFN(n, arg)        ((void)0)
#endif


/*
* PFC bits pertinent to PERSONA HPW-50PA touch-panel
*/
#define PHDR_TP_PEN_UP          0x40
#define SCPDR_TP_SCAN_ENABLE    0x20
#define SCPDR_TP_SCAN_DISABLE   0x01
#define SCPDR_TP_SCAN_X         0x06
#define SCPDR_TP_SCAN_Y         0x09

/*
* A/D converter channels to get x/y from
*/
#define ADC_CHANNEL_TP_X        1
#define ADC_CHANNEL_TP_Y        0

/*
* Default (read: my device) raw X/Y values for framebuffer edges.
*/
#define PSH3TP_FB_RIGHT          56
#define PSH3TP_FB_LEFT          969
#define PSH3TP_FB_TOP           848
#define PSH3TP_FB_BOTTOM        121


struct psh3tp_softc {
       device_t sc_dev;

#define PSH3TP_WSMOUSE_ENABLED  0x01
       int sc_enabled;
       struct callout sc_touch_ch;
       device_t sc_wsmousedev;
       struct tpcalib_softc sc_tpcalib; /* calibration info for wsmouse */
};


/* config machinery */
static int psh3tp_match(device_t, struct cfdata *, void *);
static void psh3tp_attach(device_t, device_t, void *);

/* wsmouse accessops */
static int psh3tp_wsmouse_enable(void *);
static int psh3tp_wsmouse_ioctl(void *, u_long, void *, int, struct lwp *);
static void psh3tp_wsmouse_disable(void *);

/* internal driver routines */
static void psh3tp_enable(struct psh3tp_softc *);
static void psh3tp_disable(struct psh3tp_softc *);
static int psh3tp_set_enable(struct psh3tp_softc *, int, int);
static int psh3tp_intr(void *);
static void psh3tp_start_polling(void *);
static void psh3tp_stop_polling(struct psh3tp_softc *);
static void psh3tp_callout_wsmouse(void *);
static void psh3tp_wsmouse_input(struct psh3tp_softc *, int, int);
static void psh3tp_get_raw_xy(int *, int *);


const struct wsmouse_accessops psh3tp_accessops = {
       psh3tp_wsmouse_enable,
       psh3tp_wsmouse_ioctl,
       psh3tp_wsmouse_disable
};

static const struct wsmouse_calibcoords psh3tp_default_calib = {
       0, 0, 639, 239,
       4,
       {{ PSH3TP_FB_LEFT,  PSH3TP_FB_TOP,      0,   0 },
        { PSH3TP_FB_RIGHT, PSH3TP_FB_TOP,    639,   0 },
        { PSH3TP_FB_LEFT,  PSH3TP_FB_BOTTOM,   0, 239 },
        { PSH3TP_FB_RIGHT, PSH3TP_FB_BOTTOM, 639, 239 }}
};


CFATTACH_DECL_NEW(psh3tp, sizeof(struct psh3tp_softc),
   psh3tp_match, psh3tp_attach, NULL, NULL);


/* ARGSUSED */
static int
psh3tp_match(device_t parent __unused, struct cfdata *cf, void *aux __unused)
{

       if (!platid_match(&platid, &platid_mask_MACH_HITACHI_PERSONA))
               return 0;

       if (strcmp(cf->cf_name, "psh3tp") != 0)
               return 0;

       return 1;
}


/*
* Attach the touch panel driver and its wsmouse child.
*
* Note that we have to use submatch to distinguish between child because
* wsmouse_match matches unconditionally.
*/
/* ARGSUSED */
static void
psh3tp_attach(device_t parent __unused, device_t self, void *aux __unused)
{
       struct psh3tp_softc *sc = device_private(self);
       struct wsmousedev_attach_args wsma;

       aprint_naive("\n");
       aprint_normal("\n");

       sc->sc_dev = self;
       sc->sc_enabled = 0;

       /* touch-panel as a pointing device */
       wsma.accessops = &psh3tp_accessops;
       wsma.accesscookie = sc;

       sc->sc_wsmousedev = config_found(
           self, &wsma, wsmousedevprint, CFARGS_NONE);
       if (sc->sc_wsmousedev == NULL)
               return;

       /* init calibration, set default parameters */
       tpcalib_init(&sc->sc_tpcalib);
       tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS,
           (void *)__UNCONST(&psh3tp_default_calib), 0, 0);

       /* used when in polling mode */
       callout_init(&sc->sc_touch_ch, 0);

       /* establish interrupt handler, but disable until opened */
       intc_intr_establish(SH7709_INTEVT2_IRQ2,
           IST_EDGE, IPL_TTY, psh3tp_intr, sc);
       intc_intr_disable(SH7709_INTEVT2_IRQ2);

       if (!pmf_device_register(self, NULL, NULL))
               aprint_error_dev(self, "unable to establish power handler\n");
}


/*
* Enable touch panel:  we start in interrupt mode.
* Must be called at spltty().
*/
/* ARGSUSED */
static void
psh3tp_enable(struct psh3tp_softc *sc __unused)
{

       DPRINTFN(2, ("%s: enable\n", device_xname(sc->sc_dev)));
       intc_intr_enable(SH7709_INTEVT2_IRQ2);
}


/*
* Disable touch panel: disable interrupt, cancel pending callout.
* Must be called at spltty().
*/
static void
psh3tp_disable(struct psh3tp_softc *sc)
{

       DPRINTFN(2, ("%s: disable\n", device_xname(sc->sc_dev)));
       intc_intr_disable(SH7709_INTEVT2_IRQ2);
       callout_stop(&sc->sc_touch_ch);
}


static int
psh3tp_set_enable(struct psh3tp_softc *sc, int on, int child)
{
       int s = spltty();

       if (on) {
               if (!sc->sc_enabled)
                       psh3tp_enable(sc);
               sc->sc_enabled |= child;
       } else {
               sc->sc_enabled &= ~child;
               if (!sc->sc_enabled)
                       psh3tp_disable(sc);
       }

       splx(s);
       return 0;
}


static int
psh3tp_wsmouse_enable(void *cookie)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;

       DPRINTFN(1, ("%s: wsmouse enable\n", device_xname(sc->sc_dev)));
       return psh3tp_set_enable(sc, 1, PSH3TP_WSMOUSE_ENABLED);
}


static void
psh3tp_wsmouse_disable(void *cookie)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;

       DPRINTFN(1, ("%s: wsmouse disable\n", device_xname(sc->sc_dev)));
       psh3tp_set_enable(sc, 0, PSH3TP_WSMOUSE_ENABLED);
}


static int
psh3tp_intr(void *arg)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;

       uint8_t irr0;
       uint8_t phdr, touched;
       unsigned int steady, tremor_timeout;

       irr0 = _reg_read_1(SH7709_IRR0);
       if ((irr0 & IRR0_IRQ2) == 0) {
#ifdef DIAGNOSTIC
               printf("%s: irr0 %02x?\n", device_xname(sc->sc_dev), irr0);
#endif
               return 0;
       }

       if (!sc->sc_enabled) {
               DPRINTFN(1, ("%s: intr: !sc_enabled\n", device_xname(sc->sc_dev)));
               intc_intr_disable(SH7709_INTEVT2_IRQ2);
               goto served;
       }

       /*
        * Number of times the "touched" bit should be read
        * consecutively.
        */
#define TREMOR_THRESHOLD 0x300
       steady = 0;
       tremor_timeout = TREMOR_THRESHOLD * 16; /* XXX: arbitrary */
       touched = true;         /* we start with "touched" state */

       do {
               uint8_t state;

               phdr = _reg_read_1(SH7709_PHDR);
               state = ((phdr & PHDR_TP_PEN_UP) != PHDR_TP_PEN_UP);

               if (state == touched)
                       ++steady;
               else {
                       steady = 0;
                       touched = state;
               }

               if (--tremor_timeout == 0) {
                       DPRINTF(("%s: tremor timeout!\n",
                           device_xname(sc->sc_dev)));
                       goto served;
               }
       } while (steady < TREMOR_THRESHOLD);

       if (touched) {
               intc_intr_disable(SH7709_INTEVT2_IRQ2);

               /*
                * ADC readings are not stable yet, so schedule
                * callout instead of accessing ADC from the interrupt
                * handler only to immediately delay().
                */
               callout_reset(&sc->sc_touch_ch,
                   hz/32, psh3tp_start_polling, sc);
       } else
               DPRINTFN(1, ("%s: tremor\n", device_xname(sc->sc_dev)));
served:
       /* clear the interrupt */
       _reg_write_1(SH7709_IRR0, irr0 & ~IRR0_IRQ2);

       return 1;
}


/*
* Called from the interrupt handler at spltty() upon first touch.
* Decide if we are going to report this touch as a mouse click/drag.
*/
static void
psh3tp_start_polling(void *arg)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;
       uint8_t phdr;
       int rawx, rawy;

       phdr = _reg_read_1(SH7709_PHDR);
       if ((phdr & PHDR_TP_PEN_UP) == PHDR_TP_PEN_UP) {
               DPRINTFN(2, ("%s: start: pen is not down\n",
                   device_xname(sc->sc_dev)));
               psh3tp_stop_polling(sc);
               return;
       }

       psh3tp_get_raw_xy(&rawx, &rawy);
       DPRINTFN(2, ("%s: start: %4d %4d -> ",
           device_xname(sc->sc_dev), rawx, rawy));

       if (sc->sc_enabled & PSH3TP_WSMOUSE_ENABLED) {
               DPRINTFN(2, ("mouse\n"));
               psh3tp_wsmouse_input(sc, rawx, rawy);
               callout_reset(&sc->sc_touch_ch,
                   hz/32, psh3tp_callout_wsmouse, sc);
       } else {
               DPRINTFN(2, ("ignore\n"));
               psh3tp_stop_polling(sc);
       }
}


/*
* Re-enable touch panel interrupt.
* Called at spltty() when polling code detects pen-up.
*/
/* ARGSUSED */
static void
psh3tp_stop_polling(struct psh3tp_softc *sc __unused)
{
       uint8_t irr0;

       DPRINTFN(2, ("%s: stop\n", device_xname(sc->sc_dev)));

       /* clear pending interrupt signal before re-enabling the interrupt */
       irr0 = _reg_read_1(SH7709_IRR0);
       if ((irr0 & IRR0_IRQ2) != 0)
               _reg_write_1(SH7709_IRR0, irr0 & ~IRR0_IRQ2);

       intc_intr_enable(SH7709_INTEVT2_IRQ2);
}


/*
* We are reporting this touch as a mouse click/drag.
*/
static void
psh3tp_callout_wsmouse(void *arg)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)arg;
       uint8_t phdr;
       int rawx, rawy;
       int s;

       s = spltty();

       if (!sc->sc_enabled) {
               DPRINTFN(1, ("%s: wsmouse callout: !sc_enabled\n",
                   device_xname(sc->sc_dev)));
               splx(s);
               return;
       }

       phdr = _reg_read_1(SH7709_PHDR);
       if ((phdr & PHDR_TP_PEN_UP) != PHDR_TP_PEN_UP) {
               psh3tp_get_raw_xy(&rawx, &rawy);
               psh3tp_wsmouse_input(sc, rawx, rawy); /* mouse dragged */
               callout_schedule(&sc->sc_touch_ch, hz/32);
       } else {
               wsmouse_input( /* button up */
                   sc->sc_wsmousedev, 0, 0, 0, 0, 0, WSMOUSE_INPUT_DELTA);
               psh3tp_stop_polling(sc);
       }
       splx(s);
}


/*
* Report mouse click/drag.
*/
static void
psh3tp_wsmouse_input(struct psh3tp_softc *sc, int rawx, int rawy)
{
       int x, y;

       tpcalib_trans(&sc->sc_tpcalib, rawx, rawy, &x, &y);

       DPRINTFN(3, ("%s: %4d %4d -> %3d %3d\n",
            device_xname(sc->sc_dev), rawx, rawy, x, y));

       wsmouse_input(sc->sc_wsmousedev,
           1,  /* button */
           x, y, 0, 0,
           WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y);
}


/*
* Read raw X/Y coordinates from the ADC.
*/
static void
psh3tp_get_raw_xy(int *rawxp, int *rawyp)
{
       uint8_t scpdr;

       /* X axis */
       scpdr = _reg_read_1(SH7709_SCPDR);
       scpdr &= ~SCPDR_TP_SCAN_DISABLE;
       scpdr |= (SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_X);
       _reg_write_1(SH7709_SCPDR, scpdr);
       delay(40);

       *rawxp = adc_sample_channel(ADC_CHANNEL_TP_X);

       /* Y axis */
       scpdr = _reg_read_1(SH7709_SCPDR);
       scpdr &=  ~SCPDR_TP_SCAN_X;
       scpdr |= (SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_Y);
       _reg_write_1(SH7709_SCPDR, scpdr);
       delay(40);

       *rawyp = adc_sample_channel(ADC_CHANNEL_TP_Y);

       /* restore SCPDR */
       scpdr = _reg_read_1(SH7709_SCPDR);
       scpdr &= ~(SCPDR_TP_SCAN_ENABLE | SCPDR_TP_SCAN_Y);
       scpdr |= SCPDR_TP_SCAN_DISABLE;
       _reg_write_1(SH7709_SCPDR, scpdr);
}


static int
psh3tp_wsmouse_ioctl(void *cookie, u_long cmd, void *data, int flag,
                    struct lwp *l)
{
       struct psh3tp_softc *sc = (struct psh3tp_softc *)cookie;

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

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.