/*      $NetBSD: zs_kbd.c,v 1.14 2021/09/18 15:14:41 tsutsui Exp $      */

/*
 * Copyright (c) 2004 Steve Rumble
 * 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 the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * 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.
 */

/*
 * IP12/IP20 serial keyboard driver attached to zs channel 0 at 600bps.
 * This layer is the parent of wskbd.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: zs_kbd.c,v 1.14 2021/09/18 15:14:41 tsutsui Exp $");

#include <sys/param.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/device.h>

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

#include <dev/ic/z8530reg.h>
#include <machine/machtype.h>
#include <machine/z8530var.h>

#define ZSKBD_BAUD      600
#define ZSKBD_TXQ_LEN   16              /* power of 2 */
#define ZSKBD_RXQ_LEN   64              /* power of 2 */

#define ZSKBD_DIP_SYNC  0x6E
#define ZSKBD_KEY_UP    0x80

#ifdef ZSKBD_DEBUG
int zskbd_debug = 0;

#define DPRINTF(_x) if (zskbd_debug) printf _x
#else
#define DPRINTF(_x)
#endif

struct zskbd_softc {
        device_t        sc_dev;

        struct zskbd_devconfig *sc_dc;
};

struct zskbd_devconfig {
        /* transmit tail-chasing fifo */
        uint8_t         txq[ZSKBD_TXQ_LEN];
        u_int           txq_head;
        u_int           txq_tail;

        /* receive tail-chasing fifo */
        uint8_t         rxq[ZSKBD_RXQ_LEN];
        u_int           rxq_head;
        u_int           rxq_tail;

        /* state */
#define TX_READY        0x1
#define RX_DIP          0x2
        u_int           state;

        /* keyboard configuration */
#define ZSKBD_CTRL_A            0x0
#define ZSKBD_CTRL_A_SBEEP      0x2     /* 200 ms */
#define ZSKBD_CTRL_A_LBEEP      0x4     /* 1000 ms */
#define ZSKBD_CTRL_A_NOCLICK    0x8     /* turn off keyboard click */
#define ZSKBD_CTRL_A_RCB        0x10    /* request config byte */
#define ZSKBD_CTRL_A_NUMLK      0x20    /* num lock led */
#define ZSKBD_CTRL_A_CAPSLK     0x40    /* caps lock led */
#define ZSKBD_CTRL_A_AUTOREP    0x80    /* auto-repeat after 650 ms, 28x/sec */

#define ZSKBD_CTRL_B            0x1
#define ZSKBD_CTRL_B_CMPL_DS1_2 0x2     /* complement of ds1+ds2 (num+capslk) */
#define ZSKBD_CTRL_B_SCRLK      0x4     /* scroll lock light */
#define ZSKBD_CTRL_B_L1         0x8     /* user-configurable lights */
#define ZSKBD_CTRL_B_L2         0x10
#define ZSKBD_CTRL_B_L3         0x20
#define ZSKBD_CTRL_B_L4         0x40
        uint8_t         kbd_conf[2];

        /* dip switch settings */
        uint8_t         dip;

        /* wscons glue */
        device_t        wskbddev;
        int             enabled;
};

static int      zskbd_match(device_t, cfdata_t, void *);
static void     zskbd_attach(device_t, device_t, void *);
static void     zskbd_rxint(struct zs_chanstate *);
static void     zskbd_stint(struct zs_chanstate *, int);
static void     zskbd_txint(struct zs_chanstate *);
static void     zskbd_softint(struct zs_chanstate *);
static void     zskbd_send(struct zs_chanstate *, uint8_t *, u_int);
static void     zskbd_ctrl(struct zs_chanstate *, uint8_t, uint8_t,
                                                  uint8_t, uint8_t);

static void     zskbd_wskbd_input(struct zs_chanstate *, uint8_t);
static int      zskbd_wskbd_enable(void *, int);
static void     zskbd_wskbd_set_leds(void *, int);
static int      zskbd_wskbd_get_leds(void *);
static void     zskbd_wskbd_set_keyclick(void *, int);
static int      zskbd_wskbd_get_keyclick(void *);
static int      zskbd_wskbd_ioctl(void *, u_long, void *, int, struct lwp *);

void            zskbd_cnattach(int, int);
static void     zskbd_wskbd_getc(void *, u_int *, int *);
static void     zskbd_wskbd_pollc(void *, int);
static void     zskbd_wskbd_bell(void *, u_int, u_int, u_int);

extern struct zschan   *zs_get_chan_addr(int, int);
extern int              zs_getc(void *);
extern void             zs_putc(void *, int);

CFATTACH_DECL_NEW(zskbd, sizeof(struct zskbd_softc),
    zskbd_match, zskbd_attach, NULL, NULL);

static struct zsops zskbd_zsops = {
        zskbd_rxint,
        zskbd_stint,
        zskbd_txint,
        zskbd_softint
};

extern const struct wscons_keydesc wssgi_keydesctab[];
const struct wskbd_mapdata sgikbd_wskbd_keymapdata = {
        wssgi_keydesctab, KB_US
};

const struct wskbd_accessops zskbd_wskbd_accessops = {
        zskbd_wskbd_enable,
        zskbd_wskbd_set_leds,
        zskbd_wskbd_ioctl
};

const struct wskbd_consops zskbd_wskbd_consops = {
        zskbd_wskbd_getc,
        zskbd_wskbd_pollc,
        zskbd_wskbd_bell
};

static struct zskbd_devconfig   zskbd_console_dc;
static int                      zskbd_is_console = 0;

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

        if (mach_type == MACH_SGI_IP12 || mach_type == MACH_SGI_IP20) {
                struct zsc_attach_args *args = aux;

                if (args->channel == 0)
                        return (1);
        }

        return (0);
}

static void
zskbd_attach(device_t parent, device_t self, void *aux)
{
        struct zskbd_softc             *sc;
        struct zs_chanstate            *cs;
        struct zsc_softc               *zsc;
        struct zsc_attach_args         *args;
        struct wskbddev_attach_args     wskaa;
        int                             s, channel;

        zsc = device_private(parent);
        sc = device_private(self);
        sc->sc_dev = self;
        args = aux;

        /* Establish ourself with the MD z8530 driver */
        channel = args->channel;
        cs = zsc->zsc_cs[channel];
        cs->cs_ops = &zskbd_zsops;
        cs->cs_private = sc;

        if (zskbd_is_console) {
                sc->sc_dc = &zskbd_console_dc;
                wskaa.console = 1;
                sc->sc_dc->enabled = 1;
        } else {
                wskaa.console = 0;

                sc->sc_dc = kmem_alloc(sizeof(struct zskbd_devconfig),
                    KM_SLEEP);

                sc->sc_dc->enabled = 0;
        }

        sc->sc_dc->txq_head = 0;
        sc->sc_dc->txq_tail = 0;
        sc->sc_dc->rxq_head = 0;
        sc->sc_dc->rxq_tail = 0;
        sc->sc_dc->state = TX_READY;
        sc->sc_dc->dip = 0;
        sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] = 0;
        sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] = 0;

        aprint_normal(": baud rate %d\n", ZSKBD_BAUD);

        s = splzs();
        zs_write_reg(cs, 9, (channel == 0) ? ZSWR9_A_RESET : ZSWR9_B_RESET);
        cs->cs_preg[1] = ZSWR1_RIE | ZSWR1_TIE;
        cs->cs_preg[4] = (cs->cs_preg[4] & ZSWR4_CLK_MASK) |
                         (ZSWR4_ONESB | ZSWR4_PARENB);  /* 1 stop, odd parity */
        zs_set_speed(cs, ZSKBD_BAUD);
        zs_loadchannelregs(cs);

        /* request DIP switch settings just in case */
        zskbd_ctrl(cs, ZSKBD_CTRL_A_RCB, 0, 0, 0);

        splx(s);

        /* attach wskbd */
        wskaa.keymap =          &sgikbd_wskbd_keymapdata;
        wskaa.accessops =       &zskbd_wskbd_accessops;
        wskaa.accesscookie =    cs;
        sc->sc_dc->wskbddev =   config_found(self, &wskaa, wskbddevprint,
                                             CFARGS_NONE);
}

static void
zskbd_rxint(struct zs_chanstate *cs)
{
        struct zskbd_softc     *sc;
        struct zskbd_devconfig *dc;
        uint8_t                 c, r;

        sc = cs->cs_private;
        dc = sc->sc_dc;

        /* clear errors */
        r = zs_read_reg(cs, 1);
        if (r & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE))
                zs_write_csr(cs, ZSWR0_RESET_ERRORS);

        /* read byte and append to our queue */
        c = zs_read_data(cs);

        dc->rxq[dc->rxq_tail] = c;
        dc->rxq_tail = (dc->rxq_tail + 1) & ~ZSKBD_RXQ_LEN;

        cs->cs_softreq = 1;
}

static void
zskbd_stint(struct zs_chanstate *cs, int force)
{

        zs_write_csr(cs, ZSWR0_RESET_STATUS);
        cs->cs_softreq = 1;
}

static void
zskbd_txint(struct zs_chanstate *cs)
{
        struct zskbd_softc *sc;

        sc = cs->cs_private;
        zs_write_reg(cs, 0, ZSWR0_RESET_TXINT);
        sc->sc_dc->state |= TX_READY;
        cs->cs_softreq = 1;
}

static void
zskbd_softint(struct zs_chanstate *cs)
{
        struct zskbd_softc      *sc;
        struct zskbd_devconfig  *dc;

        sc = cs->cs_private;
        dc = sc->sc_dc;

        /* handle pending transmissions */
        if (dc->txq_head != dc->txq_tail && (dc->state & TX_READY)) {
                int s;

                dc->state &= ~TX_READY;

                s = splzs();
                zs_write_data(cs, dc->txq[dc->txq_head]);
                splx(s);

                dc->txq_head = (dc->txq_head + 1) & ~ZSKBD_TXQ_LEN;
        }

        /* don't bother if nobody is listening */
        if (!dc->enabled) {
                dc->rxq_head = dc->rxq_tail;
                return;
        }

        /* handle incoming keystrokes/config */
        while (dc->rxq_head != dc->rxq_tail) {
                uint8_t key = dc->rxq[dc->rxq_head];

                if (dc->state & RX_DIP) {
                        dc->dip = key;
                        dc->state &= ~RX_DIP;
                } else if (key == ZSKBD_DIP_SYNC) {
                        dc->state |= RX_DIP;
                } else {
                        /* toss wskbd a bone */
                        zskbd_wskbd_input(cs, key);
                }

                dc->rxq_head = (dc->rxq_head + 1) & ~ZSKBD_RXQ_LEN;
        }
}

/* expects to be in splzs() */
static void
zskbd_send(struct zs_chanstate *cs, uint8_t *c, u_int len)
{
        u_int                   i;
        struct zskbd_softc     *sc;
        struct zskbd_devconfig *dc;

        sc = cs->cs_private;
        dc = sc->sc_dc;

        for (i = 0; i < len; i++) {
                if (dc->state & TX_READY) {
                        zs_write_data(cs, c[i]);
                        dc->state &= ~TX_READY;
                } else {
                        dc->txq[dc->txq_tail] = c[i];
                        dc->txq_tail = (dc->txq_tail + 1) & ~ZSKBD_TXQ_LEN;
                        cs->cs_softreq = 1;
                }
        }
}

/* expects to be in splzs() */
static void
zskbd_ctrl(struct zs_chanstate *cs, uint8_t a_on, uint8_t a_off,
           uint8_t b_on, uint8_t b_off)
{
        struct zskbd_softc      *sc;
        struct zskbd_devconfig  *dc;

        sc = cs->cs_private;
        dc = sc->sc_dc;

        dc->kbd_conf[ZSKBD_CTRL_A] |=   a_on;
        dc->kbd_conf[ZSKBD_CTRL_A] &= ~(a_off | ZSKBD_CTRL_B);
        dc->kbd_conf[ZSKBD_CTRL_B] &=  ~b_off;
        dc->kbd_conf[ZSKBD_CTRL_B] |=  (b_on | ZSKBD_CTRL_B);

        zskbd_send(cs, dc->kbd_conf, 2);

        /* make sure we don't resend these each time */
        dc->kbd_conf[ZSKBD_CTRL_A] &= ~(ZSKBD_CTRL_A_RCB | ZSKBD_CTRL_A_SBEEP |
            ZSKBD_CTRL_A_LBEEP);
}

/******************************************************************************
 * wskbd glue
 ******************************************************************************/

static void
zskbd_wskbd_input(struct zs_chanstate *cs, uint8_t key)
{
        struct zskbd_softc     *sc;
        u_int                   type;

        sc = cs->cs_private;

        if (key & ZSKBD_KEY_UP)
                type = WSCONS_EVENT_KEY_UP;
        else
                type = WSCONS_EVENT_KEY_DOWN;

        wskbd_input(sc->sc_dc->wskbddev, type, (key & ~ZSKBD_KEY_UP));

        DPRINTF(("zskbd_wskbd_input: inputted key 0x%x\n", key));

#ifdef WSDISPLAY_COMPAT_RAWKBD
        wskbd_rawinput(sc->sc_dc->wskbddev, &key, 1);
#endif
}

static int
zskbd_wskbd_enable(void *cookie, int on)
{
        struct zskbd_softc *sc;
        struct zs_chanstate *cs;

        cs = cookie;
        sc = cs->cs_private;

        if (on) {
                if (sc->sc_dc->enabled)
                        return (EBUSY);
                else
                        sc->sc_dc->enabled = 1;
        } else
                sc->sc_dc->enabled = 0;

        DPRINTF(("zskbd_wskbd_enable: %s\n", on ? "enabled" : "disabled"));

        return (0);
}

static void
zskbd_wskbd_set_leds(void *cookie, int leds)
{
        struct zs_chanstate *cs;
        int     s;
        uint8_t a_on, a_off, b_on, b_off;

        a_on = a_off = b_on = b_off = 0;

        if (leds & WSKBD_LED_CAPS)
                a_on |=  ZSKBD_CTRL_A_CAPSLK;
        else
                a_off |= ZSKBD_CTRL_A_CAPSLK;

        if (leds & WSKBD_LED_NUM)
                a_on |=  ZSKBD_CTRL_A_NUMLK;
        else
                a_off |= ZSKBD_CTRL_A_NUMLK;

        if (leds & WSKBD_LED_SCROLL)
                b_on |=  ZSKBD_CTRL_B_SCRLK;
        else
                b_off |= ZSKBD_CTRL_B_SCRLK;

        cs = cookie;
        s = splzs();
        zskbd_ctrl(cs, a_on, a_off, b_on, b_off);
        splx(s);
}

static int
zskbd_wskbd_get_leds(void *cookie)
{
        struct zskbd_softc     *sc;
        struct zs_chanstate    *cs;
        int                     leds;

        cs = cookie;
        sc = cs->cs_private;
        leds = 0;

        if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NUMLK)
                leds |= WSKBD_LED_NUM;

        if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_CAPSLK)
                leds |= WSKBD_LED_CAPS;

        if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_B] & ZSKBD_CTRL_B_SCRLK)
                leds |= WSKBD_LED_SCROLL;

        return (leds);
}

static void
zskbd_wskbd_set_keyclick(void *cookie, int on)
{
        int                     s;
        struct zs_chanstate    *cs;

        cs = cookie;

        if (on) {
                if (!zskbd_wskbd_get_keyclick(cookie)) {
                        s = splzs();
                        zskbd_ctrl(cs, 0, ZSKBD_CTRL_A_NOCLICK, 0, 0);
                        splx(s);
                }
        } else {
                if (zskbd_wskbd_get_keyclick(cookie)) {
                        s = splzs();
                        zskbd_ctrl(cs, ZSKBD_CTRL_A_NOCLICK, 0, 0, 0);
                        splx(s);
                }
        }
}

static int
zskbd_wskbd_get_keyclick(void *cookie)
{
        struct zskbd_softc *sc;
        struct zs_chanstate *cs;

        cs = cookie;
        sc = cs->cs_private;

        if (sc->sc_dc->kbd_conf[ZSKBD_CTRL_A] & ZSKBD_CTRL_A_NOCLICK)
                return (0);
        else
                return (1);
}

static int
zskbd_wskbd_ioctl(void *cookie, u_long cmd,
                  void *data, int flag, struct lwp *l)
{

        switch (cmd) {
        case WSKBDIO_GTYPE:
                *(int *)data = WSKBD_TYPE_SGI;
                break;

#ifdef notyet
        case WSKBDIO_COMPLEXBELL:
        case WSKBDIO_SETKEYREPEAT:
        case WSKBDIO_GETKEYREPEAT:
        case WSKBDIO_SETDEFAULTKEYREPEAT:
        case WSKBDIO_GETDEFAULTKEYREPEAT:
#endif

        case WSKBDIO_SETLEDS:
                zskbd_wskbd_set_leds(cookie, *(int *)data);
                break;

        case WSKBDIO_GETLEDS:
                *(int *)data = zskbd_wskbd_get_leds(cookie);
                break;

#ifdef notyet
        case WSKBDIO_GETMAP:
        case WSKBDIO_SETMAP:
        case WSKBDIO_GETENCODING:
        case WSKBDIO_SETENCODING:
        case WSKBDIO_SETMODE:
        case WSKBDIO_GETMODE:
#endif

        case WSKBDIO_SETKEYCLICK:
                zskbd_wskbd_set_keyclick(cookie, *(int *)data);
                break;

        case WSKBDIO_GETKEYCLICK:
                *(int *)data = zskbd_wskbd_get_keyclick(cookie);
                break;

        default:
                return (EPASSTHROUGH);
        }

        return (0);
}

/*
 * console routines
 */
void
zskbd_cnattach(int zsunit, int zschan)
{

        wskbd_cnattach(&zskbd_wskbd_consops, zs_get_chan_addr(zsunit, zschan),
            &sgikbd_wskbd_keymapdata);
        zskbd_is_console = 1;
}

static void
zskbd_wskbd_getc(void *cookie, u_int *type, int *data)
{
        int key;

        key = zs_getc(cookie);

        if (key & ZSKBD_KEY_UP)
                *type = WSCONS_EVENT_KEY_UP;
        else
                *type = WSCONS_EVENT_KEY_DOWN;

        *data = key & ~ZSKBD_KEY_UP;
}

static void
zskbd_wskbd_pollc(void *cookie, int on)
{
}

static void
zskbd_wskbd_bell(void *cookie, u_int pitch, u_int period, u_int volume)
{

        /*
         * Since we don't have any state, this'll nuke our lights,
         * key click, and other bits in ZSKBD_CTRL_A.
         */
        if (period >= 1000)
                zs_putc(cookie, ZSKBD_CTRL_A_LBEEP);
        else
                zs_putc(cookie, ZSKBD_CTRL_A_SBEEP);
}