/*      $NetBSD: nbpkbd.c,v 1.3 2021/08/07 16:18:53 thorpej Exp $ */
/*
 * Copyright (c) 2011 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>
__KERNEL_RCSID(0, "$NetBSD: nbpkbd.c,v 1.3 2021/08/07 16:18:53 thorpej Exp $");

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

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

#include <arm/xscale/pxa2x0_i2c.h>

#include <hpcarm/dev/nbppconvar.h>

#include <dev/hpc/hpckbdvar.h>

#include <dev/i2c/i2cvar.h>

#include "locators.h"

#ifdef NBPKBD_DEBUG
#define DPRINTF(x)      printf x
#else
#define DPRINTF(x)
#endif

#define IS_KEY_DOWN(x)  (((x) & 0x80) == 0x00)
#define KEY_CODE(x)     ((x) & 0x7f)
#define KEY_INITIAL_INTERVAL    (500 * hz / 1000)       /* 500ms */
#define KEY_REPEAT_INTERVAL     (200 * hz / 1000)       /* 200ms */

struct nbpkbd_softc {
        device_t sc_dev;
        device_t sc_parent;
        int sc_tag;

        struct hpckbd_ic_if sc_if;
        struct hpckbd_if *sc_hpckbd;

        int sc_enabled;

        callout_t  sc_callout;
        uint8_t sc_last_scancode;
};

static int nbpkbd_match(device_t, cfdata_t, void *);
static void nbpkbd_attach(device_t, device_t, void *);

static int nbpkbd_input_establish(void *, struct hpckbd_if *);
static int nbpkbd_input(void *, int, char *);
static int nbpkbd_poll(void *);

static void nbpkbd_key_repeat(void *);

CFATTACH_DECL_NEW(nbpkbd, sizeof(struct nbpkbd_softc),
    nbpkbd_match, nbpkbd_attach, NULL, NULL);


/* ARGSUSED */
static int
nbpkbd_match(device_t parent, cfdata_t match, void *aux)
{
        struct nbppcon_attach_args *pcon = aux;

        if (strcmp(pcon->aa_name, match->cf_name) ||
            pcon->aa_tag == NBPPCONCF_TAG_DEFAULT)
                return 0;

        return 1;
}

static void
nbpkbd_attach(device_t parent, device_t self, void *aux)
{
        struct nbpkbd_softc *sc = device_private(self);
        struct nbppcon_attach_args *pcon = aux;
        struct hpckbd_attach_args haa;

        aprint_normal(": NETBOOK PRO Keyboard\n");
        aprint_naive("\n");

        sc->sc_dev = self;
        sc->sc_parent = parent;
        sc->sc_tag = pcon->aa_tag;
        sc->sc_if.hii_ctx = sc;
        sc->sc_if.hii_establish = nbpkbd_input_establish;
        sc->sc_if.hii_poll = nbpkbd_poll;

        hpckbd_cnattach(&sc->sc_if);

        callout_init(&sc->sc_callout, 0);
        callout_setfunc(&sc->sc_callout, nbpkbd_key_repeat, sc);

        /* Attach hpckbd */
        haa.haa_ic = &sc->sc_if;
        config_found(self, &haa, hpckbd_print, CFARGS_NONE);

        if (nbppcon_regist_callback(parent, sc->sc_tag, nbpkbd_input, sc) ==
            NULL)
                aprint_error_dev(self, "callback regist failed\n");
}


static int
nbpkbd_input_establish(void *arg, struct hpckbd_if *kbdif)
{
        struct nbpkbd_softc *sc = arg;

        sc->sc_hpckbd = kbdif;
        sc->sc_enabled = 1;

        return 0;
}

static int
nbpkbd_input(void *arg, int buflen, char *buf)
{
        struct nbpkbd_softc *sc = arg;

#ifdef NBPKBD_DEBUG
        {
                int i;

                printf("%s:", __func__);
                for (i = 0; i < buflen; i++)
                        printf(" %02x", buf[i]);
                printf("\n");
        }
#endif

        if (buflen != 2) {
                aprint_error_dev(sc->sc_dev, "ugly length %d\n", buflen);
                return -1;
        }

        hpckbd_input(sc->sc_hpckbd, IS_KEY_DOWN(buf[1]), KEY_CODE(buf[1]));

        sc->sc_last_scancode = buf[1];
        if (IS_KEY_DOWN(buf[1]))
                callout_schedule(&sc->sc_callout, KEY_INITIAL_INTERVAL);
        else
                callout_stop(&sc->sc_callout);

        delay(50);      /* XXXX */

        if (nbppcon_kbd_ready(sc->sc_parent) != 0)
                aprint_error_dev(sc->sc_dev,
                    "%s: kbd-ready failed\n", __func__);

        return 0;
}

static int
nbpkbd_poll(void *arg)
{
        struct nbpkbd_softc *sc = arg;
        int rv, s;
        char buf[2];

        if (!sc->sc_enabled)
                return 0;

        s = spltty();

        rv = nbppcon_poll(sc->sc_parent, sc->sc_tag, sizeof(buf), buf);

        DPRINTF(("%s: received %02x %02x\n",
            device_xname(sc->sc_dev), buf[0], buf[1]));

        hpckbd_input(sc->sc_hpckbd, IS_KEY_DOWN(buf[1]), KEY_CODE(buf[1]));

        delay(50);      /* XXXX */

        rv = nbppcon_kbd_ready(sc->sc_parent);

        splx(s);

        if (rv != 0)
                aprint_error_dev(sc->sc_dev,
                    "%s: kbd-ready failed\n", __func__);

        return 0;
}

static void
nbpkbd_key_repeat(void *arg)
{
        struct nbpkbd_softc *sc = arg;

        hpckbd_input(sc->sc_hpckbd, IS_KEY_DOWN(sc->sc_last_scancode),
            KEY_CODE(sc->sc_last_scancode));

        if (IS_KEY_DOWN(sc->sc_last_scancode))
                callout_schedule(&sc->sc_callout, KEY_REPEAT_INTERVAL);
}