/* $NetBSD: g42xxeb_kmkbd.c,v 1.18 2024/02/09 22:08:32 andvar Exp $ */

/*-
 * Copyright (c) 2002, 2003, 2005 Genetec corp.
 * All rights reserved.
 *
 * 4x5 matrix key switch driver for TWINTAIL.
 * Written by Hiroyuki Bessho for Genetec corp.
 *
 * 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. Neither the name of The NetBSD Foundation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Use on-board matrix switches as wskbd.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: g42xxeb_kmkbd.c,v 1.18 2024/02/09 22:08:32 andvar Exp $" );

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/callout.h>
#include <sys/kernel.h>                 /* for hz */

#include <sys/bus.h>

#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsksymvar.h>

#include <arch/evbarm/g42xxeb/g42xxeb_var.h>

#include "locators.h"
#include "opt_wsdisplay_compat.h"

#define DEBOUNCE_TICKS  ((hz<=50)?1:hz/50)      /* 20ms */
#define RELEASE_WATCH_TICKS  (hz/10)    /* 100ms */

#define NUMKEYS (4*5)   /* the number of keys */

struct kmkbd_softc {
        device_t dev;

        device_t wskbddev;
        void *ih;                       /* interrupt handler */
        struct callout callout;

        uint32_t  notified_bits;        /* reported state of keys */
        uint32_t  last_bits;            /* used for debounce */
        u_char  debounce_counter;
#define DEBOUNCE_COUNT  3
        u_char  polling;
        u_char  rawkbd;
        enum kmkbd_state {
                ST_INIT,
                ST_DISABLED,
                ST_ALL_UP,              /* waiting for interrupt */
                ST_DEBOUNCE,            /* doing debounce */
                ST_KEY_PRESSED          /* some keys are pressed */
        } state;
};


int kmkbd_match(device_t, cfdata_t, void *);
void kmkbd_attach(device_t, device_t, void *);

CFATTACH_DECL_NEW(kmkbd, sizeof(struct kmkbd_softc),
    kmkbd_match, kmkbd_attach, NULL, NULL);

static  int     kmkbd_enable(void *, int);
static  void    kmkbd_set_leds(void *, int);
static  int     kmkbd_ioctl(void *, u_long, void *, int, struct lwp *);

const struct wskbd_accessops kmkbd_accessops = {
        kmkbd_enable,
        kmkbd_set_leds,
        kmkbd_ioctl,
};

#if 0
void    kmkbd_cngetc(void *, u_int *, int *);
void    kmkbd_cnpollc(void *, int);
void    kmkbd_cnbell(void *, u_int, u_int, u_int);

const struct wskbd_consops kmkbd_consops = {
        kmkbd_cngetc,
        kmkbd_cnpollc,
        kmkbd_cnbell,
};
#endif

static const keysym_t kmkbd_keydesc_0[] = {
/*      pos              normal         shifted */
        KS_KEYCODE(0),   KS_a,          KS_A,
        KS_KEYCODE(1),   KS_b,          KS_B,
        KS_KEYCODE(2),   KS_c,          KS_C,
        KS_KEYCODE(3),   KS_d,          KS_D,
        KS_KEYCODE(4),   KS_e,          KS_E,
        KS_KEYCODE(5),   KS_f,          KS_F,
        KS_KEYCODE(6),   KS_g,          KS_G,
        KS_KEYCODE(7),   KS_h,          KS_H,
        KS_KEYCODE(8),   KS_i,          KS_I,
        KS_KEYCODE(9),   KS_j,          KS_J,
        KS_KEYCODE(10),   KS_k,         KS_K,
        KS_KEYCODE(11),   KS_l,         KS_L,
        KS_KEYCODE(12),   KS_m,         KS_M,
        KS_KEYCODE(13),   KS_n,         KS_N,
        KS_KEYCODE(14),   KS_o,         KS_O,
        KS_KEYCODE(15),   KS_p,         KS_P,
        KS_KEYCODE(16),   KS_q,         KS_Q,
        KS_KEYCODE(17),   KS_r,         KS_R,
        KS_KEYCODE(18),   '\003',       '\003',
        KS_KEYCODE(19),   KS_Return,    KS_Linefeed,
};

#define KBD_MAP(name, base, map) \
                        { name, base, sizeof(map)/sizeof(keysym_t), map }

static const struct wscons_keydesc kmkbd_keydesctab[] = {
        KBD_MAP(KB_MACHDEP, 0, kmkbd_keydesc_0),
        {0, 0, 0, 0}
};

const struct wskbd_mapdata kmkbd_keymapdata = {
        kmkbd_keydesctab,
#ifdef KMKBD_LAYOUT
        KMKBD_LAYOUT,
#else
        KB_MACHDEP,
#endif
};

/*
 * Hackish support for a bell on the PC Keyboard; when a suitable beeper
 * is found, it attaches itself into the pckbd driver here.
 */
void    (*kmkbd_bell_fn)(void *, u_int, u_int, u_int, int);
void    *kmkbd_bell_fn_arg;

void    kmkbd_bell(u_int, u_int, u_int, int);
void    kmkbd_hookup_bell(void (* fn)(void *, u_int, u_int, u_int, int), void *arg);

static int      kmkbd_intr(void *);
static void     kmkbd_new_state(struct kmkbd_softc *, enum kmkbd_state);

/*struct kmkbd_internal kmkbd_consdata;*/

static int
kmkbd_is_console(void)
{
#if 0
        return (kmkbd_consdata.t_isconsole &&
                (tag == kmkbd_consdata.t_kbctag) &&
                (slot == kmkbd_consdata.t_kbcslot));
#else
        return 0;
#endif
}

int
kmkbd_match(device_t parent, cfdata_t cf, void *aux)
{
        return 1;
}

void
kmkbd_attach(device_t parent, device_t self, void *aux)
{
        struct kmkbd_softc *sc = device_private(self);
        /*struct obio_attach_args *oa = aux;*/
        int state0;
        struct wskbddev_attach_args a;
        struct obio_softc *osc = device_private(parent);
        int s;

        printf("\n");

        sc->dev = self;
        sc->state = ST_INIT;

        if (kmkbd_is_console()){
                a.console = 1;
                state0 = ST_ALL_UP;
        } else {
                a.console = 0;
                state0 = ST_DISABLED;
        }

#ifdef WSDISPLAY_COMPAT_RAWKBD
        sc->rawkbd = 0;
#endif
        callout_init(&sc->callout, 0);

        s = spltty();
        sc->ih = obio_intr_establish(osc, G42XXEB_INT_KEY, IPL_TTY, 
            IST_EDGE_FALLING, kmkbd_intr, (void *)sc);
        kmkbd_new_state(sc, state0);
        splx(s);

        a.keymap = &kmkbd_keymapdata;

        a.accessops = &kmkbd_accessops;
        a.accesscookie = sc;


        /* Attach the wskbd. */
        sc->wskbddev = config_found(self, &a, wskbddevprint, CFARGS_NONE);

}

static int
kmkbd_enable(void *v, int on)
{
        struct kmkbd_softc *sc = v;

        if (on) {
                if (sc->state != ST_DISABLED) {
#ifdef DIAGNOSTIC
                        printf("kmkbd_enable: bad enable (state=%d)\n", sc->state);
#endif
                        return (EBUSY);
                }

                kmkbd_new_state(sc, ST_ALL_UP);
        } else {
#if 0
                if (sc->id->t_isconsole)
                        return (EBUSY);
#endif

                kmkbd_new_state(sc, ST_DISABLED);
        }

        return (0);
}



static void
kmkbd_set_leds(void *v, int leds)
{
}

static int
kmkbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l)
{
#ifdef WSDISPLAY_COMPAT_RAWKBD
        struct kmkbd_softc *sc = v;
#endif

        switch (cmd) {
            case WSKBDIO_GTYPE:
                *(int *)data = WSKBD_TYPE_PC_XT; /* XXX */
                return 0;
            case WSKBDIO_COMPLEXBELL:
#define d ((struct wskbd_bell_data *)data)
                /*
                 * Keyboard can't beep directly; we have an
                 * externally-provided global hook to do this.
                 */
                kmkbd_bell(d->pitch, d->period, d->volume, 0);
#undef d
                return (0);
#ifdef WSDISPLAY_COMPAT_RAWKBD
            case WSKBDIO_SETMODE:
                sc->rawkbd = (*(int *)data == WSKBD_RAW);
                return (0);
#endif

#if 0
            case WSKBDIO_SETLEDS:
            case WSKBDIO_GETLEDS:
                    /* no LED support */
#endif
        }
        return EPASSTHROUGH;
}

void
kmkbd_bell(u_int pitch, u_int period, u_int volume, int poll)
{

        if (kmkbd_bell_fn != NULL)
                (*kmkbd_bell_fn)(kmkbd_bell_fn_arg, pitch, period,
                    volume, poll);
}

void
kmkbd_hookup_bell(void (* fn)(void *, u_int, u_int, u_int, int), void *arg)
{

        if (kmkbd_bell_fn == NULL) {
                kmkbd_bell_fn = fn;
                kmkbd_bell_fn_arg = arg;
        }
}

#if 0
int
kmkbd_cnattach(pckbc_tag_t kbctag, int kbcslot)
{
        int res;

        res = kmkbd_init(&kmkbd_consdata, kbctag, kbcslot, 1);

        wskbd_cnattach(&kmkbd_consops, &kmkbd_consdata, &kmkbd_keymapdata);

        return (0);
}

void
kmkbd_cngetc(void *v, u_int type, int *data)
{
        struct kmkbd_internal *t = v;
        int val;

        for (;;) {
                val = pckbc_poll_data(t->t_kbctag, t->t_kbcslot);
                if ((val != -1) && kmkbd_decode(t, val, type, data))
                        return;
        }
}

void
kmkbd_cnpollc(void *v, int on)
{
        struct kmkbd_internal *t = v;

        pckbc_set_poll(t->t_kbctag, t->t_kbcslot, on);
}

void
kmkbd_cnbell(void *v, u_int pitch, u_int period, u_int volume)
{

        kmkbd_bell(pitch, period, volume, 1);
}
#endif


/*
 * low level access to key matrix
 *
 * returns bitset of keys being pressed.
 */
static u_int
kmkbd_read_matrix(struct kmkbd_softc *sc)
{
        int i;
        u_int ret, data;
        struct obio_softc *osc = device_private(device_parent(sc->dev));
        bus_space_tag_t iot = osc->sc_iot;
        bus_space_handle_t ioh = osc->sc_obioreg_ioh;

#define KMDELAY()       delay(3)

        bus_space_write_2( iot, ioh, G42XXEB_KEYSCAN, 0 );
        KMDELAY();

        data = KEYSCAN_SENSE_IN &
            bus_space_read_2(iot, ioh, G42XXEB_KEYSCAN);

        bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, KEYSCAN_SCAN_OUT);

        if (data == KEYSCAN_SENSE_IN)
                return 0;

        ret = 0;
        for( i=0; i<5; ++i ){
                /* scan one line */
                bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, ~(0x0100<<i));
                KMDELAY();
                data = bus_space_read_2(iot, ioh, G42XXEB_KEYSCAN );

                data = ~data & KEYSCAN_SENSE_IN;
                ret |= data << (i*4);
        }
    
        bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, KEYSCAN_SCAN_OUT);
        return ret;

#undef KMDELAY

}

/*
 * report key status change to wskbd subsystem.
 */
static void
kmkbd_report(struct kmkbd_softc *sc, u_int bitset)
{
        u_int changed;
        int i;

        if (bitset == sc->notified_bits)
                return;

        if (sc->notified_bits && bitset == 0){
                wskbd_input(sc->wskbddev, WSCONS_EVENT_ALL_KEYS_UP, 0);
                sc->notified_bits = 0;
                return;
        }

        changed = bitset ^ sc->notified_bits;
        for( i=0; changed; ++i){
                if ((changed & (1<<i)) == 0)
                        continue;
                changed &= ~(1<<i);

                wskbd_input(sc->wskbddev, 
                    (bitset & (1<<i)) ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP,
                    i);
        }

        sc->notified_bits = bitset;
}

#ifdef WSDISPLAY_COMPAT_RAWKBD
static void
kmkbd_report_raw(struct kmkbd_softc *sc, u_int bitset)
{
        int i, nc;
        char cbuf[NUMKEYS];
        u_int changed;
        
        if (bitset == sc->notified_bits)
                return;

        nc = 0;
        changed = bitset ^ sc->notified_bits;

        while (changed) {
                i = ffs(changed) - 1;
                if (nc < NUMKEYS) {
                        cbuf[nc] = i + 1;
                        if (0 == (bitset & (1<<i))) {
                                /* the key is released */
                                cbuf[nc] |= 0x80;
                        }
                        ++nc;
                }

                changed &= ~(1<<i);
        }

        wskbd_rawinput(sc->wskbddev, cbuf, nc);
        sc->notified_bits = bitset;
}
#endif

static int
kmkbd_intr(void *arg)
{
        struct kmkbd_softc *sc = arg;
        struct obio_softc *osc = device_private(device_parent(sc->dev));

        if ( sc->state != ST_ALL_UP ){
                printf("Spurious interrupt from key matrix\n");
                obio_intr_mask(osc, sc->ih);
                return 1;
        }

        kmkbd_new_state(sc, ST_DEBOUNCE);

        return 1;
}

static void
kmkbd_debounce(void *arg)
{
        struct kmkbd_softc *sc = arg;
        u_int newbits;
        enum kmkbd_state new_state = ST_DEBOUNCE;
        int s = spltty();

        newbits = kmkbd_read_matrix(sc);

        if (newbits != sc->last_bits){
                sc->last_bits = newbits;
                sc->debounce_counter = 0;
        }
        else if( ++(sc->debounce_counter) >= DEBOUNCE_COUNT ){
                new_state = newbits == 0 ? ST_ALL_UP : ST_KEY_PRESSED;
#ifdef WSDISPLAY_COMPAT_RAWKBD
                if (sc->rawkbd)
                        kmkbd_report_raw(sc, newbits);
                else
#endif
                        kmkbd_report(sc, newbits);
        }

        kmkbd_new_state(sc, new_state);
        splx(s);
}

/* callout routine to watch key release */
static void
kmkbd_watch(void *arg)
{
        int s = spltty();
        struct kmkbd_softc *sc = arg;
        u_int newbits;
        int new_state = ST_KEY_PRESSED;

        newbits = kmkbd_read_matrix(sc);

        if (newbits != sc->last_bits){
                /* some keys are released or new keys are pressed.
                   start debounce */
                new_state = ST_DEBOUNCE;
                sc->last_bits = newbits;
        }

        kmkbd_new_state(sc, new_state);
        splx(s);
}

static void
kmkbd_new_state(struct kmkbd_softc *sc, enum kmkbd_state new_state)
{
        struct obio_softc *osc = device_private(device_parent(sc->dev));

        switch(new_state){
        case ST_DISABLED:
                if (sc->state != ST_DISABLED){
                        callout_stop(&sc->callout);
                        obio_intr_mask(osc,sc->ih);
                }
                break;
        case ST_DEBOUNCE:
                if (sc->state == ST_ALL_UP){
                        obio_intr_mask(osc, sc->ih);
                        sc->last_bits = kmkbd_read_matrix(sc);
                }
                if (sc->state != ST_DEBOUNCE)
                        sc->debounce_counter = 0;

                /* start debounce timer */
                callout_reset(&sc->callout, DEBOUNCE_TICKS, kmkbd_debounce, sc);
                break;
        case ST_KEY_PRESSED:
                /* start timer to check key release */
                callout_reset(&sc->callout, RELEASE_WATCH_TICKS, kmkbd_watch, sc);
                break;
        case ST_ALL_UP:
                if (sc->state != ST_ALL_UP){
                        bus_space_tag_t iot = osc->sc_iot;
                        bus_space_handle_t ioh = osc->sc_obioreg_ioh;

                        obio_intr_unmask(osc, sc->ih);
                        bus_space_write_2(iot, ioh, G42XXEB_KEYSCAN, 0);
                }
                break;
        case ST_INIT:
                ; /* Nothing to do */
        }

        sc->state = new_state;
}