/*      $NetBSD: kbd.c,v 1.59 2024/09/08 09:36:48 rillig Exp $  */

/*
 * Copyright (c) 1995 Leo Weppelman
 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
 * 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. Neither the name of the University 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 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kbd.c,v 1.59 2024/09/08 09:36:48 rillig Exp $");

#include "mouse.h"
#include "ite.h"
#include "wskbd.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/proc.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/kernel.h>
#include <sys/signalvar.h>
#include <sys/syslog.h>
#include <sys/rndsource.h>

#include <dev/cons.h>
#include <machine/cpu.h>
#include <machine/iomap.h>
#include <machine/mfp.h>
#include <machine/acia.h>
#include <atari/dev/itevar.h>
#include <atari/dev/event_var.h>
#include <atari/dev/vuid_event.h>
#include <atari/dev/ym2149reg.h>
#include <atari/dev/kbdreg.h>
#include <atari/dev/kbdvar.h>
#include <atari/dev/kbdmap.h>
#include <atari/dev/msvar.h>

#if NWSKBD>0
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wskbdvar.h>
#include <dev/wscons/wsksymdef.h>
#include <dev/wscons/wsksymvar.h>
#include <atari/dev/wskbdmap_atari.h>
#endif

/*
 * The ringbuffer is the interface between the hard and soft interrupt handler.
 * The hard interrupt runs straight from the MFP interrupt.
 */
#define KBD_RING_SIZE   256   /* Sz of input ring buffer, must be power of 2 */
#define KBD_RING_MASK   255   /* Modulo mask for above                       */

struct kbd_softc {
        int             sc_event_mode;  /* if 1, collect events,        */
                                        /*   else pass to ite           */
        struct evvar    sc_events;      /* event queue state            */
        uint8_t         sc_soft_cs;     /* control-reg. copy            */
        uint8_t         sc_package[20]; /* XXX package being build      */
        uint8_t         sc_pkg_size;    /* Size of the package          */
        uint8_t         sc_pkg_idx;     /* Running pkg assembly index   */
        uint8_t         sc_pkg_type;    /* Type of package              */
        const uint8_t   *sc_sendp;      /* Output pointer               */
        int             sc_send_cnt;    /* Chars left for output        */
#if NWSKBD > 0
        device_t        sc_wskbddev;  /* pointer to wskbd for sending strokes */
        int             sc_pollingmode; /* polling mode on? whatever it is... */
#endif
        void            *sc_sicookie;   /* softint(9) cookie            */
        krndsource_t    sc_rndsource;   /* rnd(9) entropy               */
};

/* WSKBD */
/*
 * If NWSKBD>0 we try to attach a wskbd device to us. What follows
 * is definitions of callback functions and structures that are passed
 * to wscons when initializing.
 */

/*
 * Now with wscons this driver exhibits some weird behaviour.
 * It may act both as a driver of its own and the md part of the
 * wskbd driver. Therefore it can be accessed through /dev/kbd
 * and /dev/wskbd0 both.
 *
 * The data from they keyboard may end up in at least four different
 * places:
 * - If this driver has been opened (/dev/kbd) and the
 *   direct mode (TIOCDIRECT) has been set, data goes to
 *   the process who opened the device. Data will transmit itself
 *   as described by the firm_event structure.
 * - If wskbd support is compiled in and a wskbd driver has been
 *   attached then the data is sent to it. Wskbd in turn may
 *   - Send the data in the wscons_event form to a process that
 *     has opened /dev/wskbd0
 *   - Feed the data to a virtual terminal.
 * - If an ite is present the data may be fed to it.
 */

uint8_t                 kbd_modifier;   /* Modifier mask                */

static uint8_t          kbd_ring[KBD_RING_SIZE];
static volatile u_int   kbd_rbput = 0;  /* 'put' index                  */
static u_int            kbd_rbget = 0;  /* 'get' index                  */

static struct kbd_softc kbd_softc;      /* XXX */

/* {b,c}devsw[] function prototypes */
static dev_type_open(kbdopen);
static dev_type_close(kbdclose);
static dev_type_read(kbdread);
static dev_type_ioctl(kbdioctl);
static dev_type_poll(kbdpoll);
static dev_type_kqfilter(kbdkqfilter);

static void kbdsoft(void *);
static void kbdattach(device_t, device_t, void *);
static int  kbdmatch(device_t, cfdata_t, void *);
#if NITE > 0
static int  kbd_do_modifier(uint8_t);
#endif
static int  kbd_write_poll(const uint8_t *, int);
static void kbd_pkg_start(struct kbd_softc *, uint8_t);

CFATTACH_DECL_NEW(kbd, 0,
    kbdmatch, kbdattach, NULL, NULL);

const struct cdevsw kbd_cdevsw = {
        .d_open = kbdopen,
        .d_close = kbdclose,
        .d_read = kbdread,
        .d_write = nowrite,
        .d_ioctl = kbdioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = kbdpoll,
        .d_mmap = nommap,
        .d_kqfilter = kbdkqfilter,
        .d_discard = nodiscard,
        .d_flag = 0
};

#if NWSKBD>0
/* accessops */
static int      kbd_enable(void *, int);
static void     kbd_set_leds(void *, int);
static int      kbd_ioctl(void *, u_long, void *, int, struct lwp *);

/* console ops */
static void     kbd_getc(void *, u_int *, int *);
static void     kbd_pollc(void *, int);
static void     kbd_bell(void *, u_int, u_int, u_int);

static struct wskbd_accessops kbd_accessops = {
        kbd_enable,
        kbd_set_leds,
        kbd_ioctl
};

static struct wskbd_consops kbd_consops = {
        kbd_getc,
        kbd_pollc,
        kbd_bell
};

/* Pointer to keymaps. */
static struct wskbd_mapdata kbd_mapdata = {
        atarikbd_keydesctab,
        KB_US
};
#endif /* WSKBD */

/*ARGSUSED*/
static int
kbdmatch(device_t parent, cfdata_t cf, void *aux)
{

        if (!strcmp((char *)aux, "kbd"))
                return 1;
        return 0;
}

/*ARGSUSED*/
static void
kbdattach(device_t parent, device_t self, void *aux)
{
        struct kbd_softc *sc = &kbd_softc;
        int timeout;
        const uint8_t kbd_rst[]  = { 0x80, 0x01 };
        const uint8_t kbd_icmd[] = { 0x12, 0x15 };

        /*
         * Disable keyboard interrupts from MFP
         */
        MFP->mf_ierb &= ~IB_AINT;

        /*
         * Reset ACIA and initialize to:
         *    divide by 16, 8 data, 1 stop, no parity, enable RX interrupts
         */
        KBD->ac_cs = A_RESET;
        delay(100);     /* XXX: enough? */
        KBD->ac_cs = sc->sc_soft_cs = KBD_INIT | A_RXINT;

        /*
         * Clear error conditions
         */
        while ((KBD->ac_cs & (A_IRQ | A_RXRDY)) != 0)
                timeout = KBD->ac_da;

        /*
         * Now send the reset string, and read+ignore its response
         */
        aprint_normal("\n");
        if (kbd_write_poll(kbd_rst, 2) == 0)
                aprint_error_dev(self, "error cannot reset keyboard\n");
        for (timeout = 1000; timeout > 0; timeout--) {
                if ((KBD->ac_cs & (A_IRQ | A_RXRDY)) != 0) {
                        timeout = KBD->ac_da;
                        timeout = 100;
                }
                delay(100);
        }
        /*
         * Send init command: disable mice & joysticks
         */
        kbd_write_poll(kbd_icmd, sizeof(kbd_icmd));

        sc->sc_sicookie = softint_establish(SOFTINT_SERIAL, kbdsoft, NULL);
        rnd_attach_source(&sc->sc_rndsource, device_xname(self),
            RND_TYPE_TTY, RND_FLAG_DEFAULT);

#if NWSKBD > 0
        if (self != NULL) {
                /*
                 * Try to attach the wskbd.
                 */
                struct wskbddev_attach_args waa;

                /* Maybe should be done before this?... */
                wskbd_cnattach(&kbd_consops, NULL, &kbd_mapdata);

                waa.console = 1;
                waa.keymap = &kbd_mapdata;
                waa.accessops = &kbd_accessops;
                waa.accesscookie = NULL;
                sc->sc_wskbddev = config_found(self, &waa, wskbddevprint,
                    CFARGS_NONE);

                sc->sc_pollingmode = 0;

                kbdenable();
        }
#endif /* WSKBD */
}

void
kbdenable(void)
{
        struct kbd_softc *sc = &kbd_softc;
        int s;

        s = spltty();

        /*
         * Clear error conditions...
         */
        while ((KBD->ac_cs & (A_IRQ | A_RXRDY)) != 0)
                (void)KBD->ac_da;
        /*
         * Enable interrupts from MFP
         */
        MFP->mf_iprb  = (uint8_t)~IB_AINT;
        MFP->mf_ierb |= IB_AINT;
        MFP->mf_imrb |= IB_AINT;

        sc->sc_event_mode   = 0;
        sc->sc_events.ev_io = 0;
        sc->sc_pkg_size     = 0;
        splx(s);
}

static int
kbdopen(dev_t dev, int flags, int mode, struct lwp *l)
{
        struct kbd_softc *sc = &kbd_softc;

        if (sc->sc_events.ev_io)
                return EBUSY;

        sc->sc_events.ev_io = l->l_proc;
        ev_init(&sc->sc_events);
        return 0;
}

static int
kbdclose(dev_t dev, int flags, int mode, struct lwp *l)
{
        struct kbd_softc *sc = &kbd_softc;

        /* Turn off event mode, dump the queue */
        sc->sc_event_mode = 0;
        ev_fini(&sc->sc_events);
        sc->sc_events.ev_io = NULL;
        return 0;
}

static int
kbdread(dev_t dev, struct uio *uio, int flags)
{
        struct kbd_softc *sc = &kbd_softc;

        return ev_read(&sc->sc_events, uio, flags);
}

static int
kbdioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct kbd_softc *sc = &kbd_softc;
        struct kbdbell *kb;

        switch (cmd) {
        case KIOCTRANS:
                if (*(int *)data == TR_UNTRANS_EVENT)
                        return 0;
                break;

        case KIOCGTRANS:
                /*
                 * Get translation mode
                 */
                *(int *)data = TR_UNTRANS_EVENT;
                return 0;

        case KIOCSDIRECT:
                sc->sc_event_mode = *(int *)data;
                return 0;

        case KIOCRINGBELL:
                kb = (struct kbdbell *)data;
                if (kb)
                        kbd_bell_sparms(kb->volume, kb->pitch,
                            kb->duration);
                kbdbell();
                return 0;

        case FIONBIO:   /* we will remove this someday (soon???) */
                return 0;

        case FIOASYNC:
                sc->sc_events.ev_async = *(int *)data != 0;
                return 0;

        case FIOSETOWN:
                if (-*(int *)data != sc->sc_events.ev_io->p_pgid &&
                    *(int *)data != sc->sc_events.ev_io->p_pid)
                        return EPERM;
                return 0;

        case TIOCSPGRP:
                if (*(int *)data != sc->sc_events.ev_io->p_pgid)
                        return EPERM;
                return 0;

        default:
                return ENOTTY;
        }

        /*
         * We identified the ioctl, but we do not handle it.
         */
        return EOPNOTSUPP;              /* misuse, but what the heck */
}

static int
kbdpoll(dev_t dev, int events, struct lwp *l)
{
        struct kbd_softc *sc = &kbd_softc;

        return ev_poll(&sc->sc_events, events, l);
}

static int
kbdkqfilter(dev_t dev, struct knote *kn)
{
        struct kbd_softc *sc = &kbd_softc;

        return ev_kqfilter(&sc->sc_events, kn);
}

/*
 * Keyboard interrupt handler called straight from MFP at spl6.
 */
void
kbdintr(int sr)
        /* sr: sr at time of interrupt  */
{
        struct kbd_softc *sc = &kbd_softc;
        uint8_t stat, code = 0 /* XXX gcc */;
        uint32_t rndstat;
        bool got_char = false;

        /*
         * There may be multiple keys available. Read them all.
         */
        stat = KBD->ac_cs;
        rndstat = stat;
        while ((stat & (A_RXRDY | A_OE | A_PE)) != 0) {
                got_char = true;
                if ((KBD->ac_cs & (A_OE | A_PE)) == 0) {
                        code = KBD->ac_da;
                        kbd_ring[kbd_rbput++ & KBD_RING_MASK] = code;
                } else {
                        /* Silently ignore errors */
                        code = KBD->ac_da;
                }
                stat = KBD->ac_cs;
        }

        /*
         * If characters are waiting for transmit, send them.
         */
        if ((sc->sc_soft_cs & A_TXINT) != 0 &&
            (KBD->ac_cs & A_TXRDY) != 0) {
                if (sc->sc_sendp != NULL)
                        KBD->ac_da = *sc->sc_sendp++;
                if (--sc->sc_send_cnt <= 0) {
                        /*
                         * The total package has been transmitted,
                         * wakeup anyone waiting for it.
                         */
                        KBD->ac_cs = (sc->sc_soft_cs &= ~A_TXINT);
                        sc->sc_sendp = NULL;
                        sc->sc_send_cnt = 0;
                        wakeup((void *)&sc->sc_send_cnt);
                }
        }

        /*
         * Activate software-level to handle possible input.
         * Also add status and data to the rnd(9) pool.
         */
        if (got_char) {
                softint_schedule(sc->sc_sicookie);
                rnd_add_uint32(&sc->sc_rndsource, (rndstat << 8) | code);
        }
}

/*
 * Keyboard soft interrupt handler
 */
static void
kbdsoft(void *junk1)
{
        struct kbd_softc *sc = &kbd_softc;
        int s;
        uint8_t code;
        struct firm_event *fe;
        int put, get, n;

        get = kbd_rbget;

        for (;;) {
                n = kbd_rbput;
                if (get == n) /* We're done     */
                        break;
                n -= get;
                if (n > KBD_RING_SIZE) { /* Ring buffer overflow        */
                        get += n - KBD_RING_SIZE;
                        n    = KBD_RING_SIZE;
                }
                while (--n >= 0) {
                        code = kbd_ring[get++ & KBD_RING_MASK];

                        /*
                         * If collecting a package, stuff it in and
                         * continue.
                         */
                        if (sc->sc_pkg_size &&
                            (sc->sc_pkg_idx < sc->sc_pkg_size)) {
                                sc->sc_package[sc->sc_pkg_idx++] = code;
                                if (sc->sc_pkg_idx == sc->sc_pkg_size) {
                                        /*
                                         * Package is complete.
                                         */
                                        switch (sc->sc_pkg_type) {
#if NMOUSE > 0
                                        case KBD_AMS_PKG:
                                        case KBD_RMS_PKG:
                                        case KBD_JOY1_PKG:
                                                mouse_soft(
                                                    (REL_MOUSE *)sc->sc_package,
                                                    sc->sc_pkg_size,
                                                    sc->sc_pkg_type);
#endif /* NMOUSE */
                                        }
                                        sc->sc_pkg_size = 0;
                                }
                                continue;
                        }
                        /*
                         * If this is a package header, init pkg. handling.
                         */
                        if (!KBD_IS_KEY(code)) {
                                kbd_pkg_start(sc, code);
                                continue;
                        }
#if NWSKBD > 0
                        /*
                         * If we have attached a wskbd and not in polling mode
                         * and nobody has opened us directly, then send the
                         * keystroke to the wskbd.
                         */

                        if (sc->sc_pollingmode == 0 &&
                            sc->sc_wskbddev != NULL &&
                            sc->sc_event_mode == 0) {
                                wskbd_input(sc->sc_wskbddev,
                                    KBD_RELEASED(code) ?
                                    WSCONS_EVENT_KEY_UP :
                                    WSCONS_EVENT_KEY_DOWN,
                                    KBD_SCANCODE(code));
                                continue;
                        }
#endif /* NWSKBD */
#if NITE > 0
                        if (kbd_do_modifier(code) && !sc->sc_event_mode)
                                continue;
#endif

                        /*
                         * if not in event mode, deliver straight to ite to
                         * process key stroke
                         */
                        if (!sc->sc_event_mode) {
                                /* Gets to spltty() by itself   */
#if NITE > 0
                                ite_filter(code, ITEFILT_TTY);
#endif
                                continue;
                        }

                        /*
                         * Keyboard is generating events.  Turn this keystroke
                         * into an event and put it in the queue.  If the queue
                         * is full, the keystroke is lost (sorry!).
                         */
                        s = spltty();
                        put = sc->sc_events.ev_put;
                        fe  = &sc->sc_events.ev_q[put];
                        put = (put + 1) % EV_QSIZE;
                        if (put == sc->sc_events.ev_get) {
                                log(LOG_WARNING,
                                    "keyboard event queue overflow\n");
                                splx(s);
                                continue;
                        }
                        fe->id    = KBD_SCANCODE(code);
                        fe->value = KBD_RELEASED(code) ? VKEY_UP : VKEY_DOWN;
                        firm_gettime(fe);
                        sc->sc_events.ev_put = put;
                        EV_WAKEUP(&sc->sc_events);
                        splx(s);
                }
                kbd_rbget = get;
        }
}

static uint8_t sound[] = {
        0xA8, 0x01, 0xA9, 0x01, 0xAA, 0x01, 0x00,
        0xF8, 0x10, 0x10, 0x10, 0x00, 0x20, 0x03
};

void
kbdbell(void)
{
        int i, s;

        s = splhigh();
        for (i = 0; i < sizeof(sound); i++) {
                YM2149->sd_selr = i;
                YM2149->sd_wdat = sound[i];
        }
        splx(s);
}


/*
 * Set the parameters of the 'default' beep.
 */

#define KBDBELLCLOCK    125000  /* 2MHz / 16 */
#define KBDBELLDURATION 128     /* 256 / 2MHz */

void
kbd_bell_gparms(u_int *volume, u_int *pitch, u_int *duration)
{
        u_int tmp;

        tmp = sound[11] | (sound[12] << 8);
        *duration = (tmp * KBDBELLDURATION) / 1000;

        tmp = sound[0] | (sound[1] << 8);
        *pitch = KBDBELLCLOCK / tmp;

        *volume = 0;
}

void
kbd_bell_sparms(u_int volume, u_int pitch, u_int duration)
{
        u_int f, t;

        f = pitch > 10 ? pitch : 10;    /* minimum pitch */
        if (f > 20000)
                f = 20000;              /* maximum pitch */

        f = KBDBELLCLOCK / f;

        t = (duration * 1000) / KBDBELLDURATION;

        sound[ 0] = f & 0xff;
        sound[ 1] = (f >> 8) & 0xf;
        f -= 1;
        sound[ 2] = f & 0xff;
        sound[ 3] = (f >> 8) & 0xf;
        f += 2;
        sound[ 4] = f & 0xff;
        sound[ 5] = (f >> 8) & 0xf;

        sound[11] = t & 0xff;
        sound[12] = (t >> 8) & 0xff;

        sound[13] = 0x03;
}

int
kbdgetcn(void)
{
        uint8_t code;
        int s = spltty();
        int ints_active;

        ints_active = 0;
        if ((MFP->mf_imrb & IB_AINT) != 0) {
                ints_active   = 1;
                MFP->mf_imrb &= ~IB_AINT;
        }
        for (;;) {
                while (!((KBD->ac_cs & (A_IRQ | A_RXRDY)) == (A_IRQ | A_RXRDY)))
                        continue;       /* Wait for key */
                if ((KBD->ac_cs & (A_OE | A_PE)) != 0) {
                        code = KBD->ac_da;      /* Silently ignore errors */
                        continue;
                }
                code = KBD->ac_da;
#if NITE>0
                if (!kbd_do_modifier(code))
#endif
                        break;
        }

        if (ints_active) {
                MFP->mf_iprb  = (uint8_t)~IB_AINT;
                MFP->mf_imrb |=  IB_AINT;
        }

        splx(s);
        return code;
}

/*
 * Write a command to the keyboard in 'polled' mode.
 */
static int
kbd_write_poll(const uint8_t *cmd, int len)
{
        int timeout;

        while (len-- > 0) {
                KBD->ac_da = *cmd++;
                for (timeout = 100; (KBD->ac_cs & A_TXRDY) == 0; timeout--)
                        delay(10);
                if ((KBD->ac_cs & A_TXRDY) == 0)
                        return 0;
        }
        return 1;
}

/*
 * Write a command to the keyboard. Return when command is send.
 */
void
kbd_write(const uint8_t *cmd, int len)
{
        struct kbd_softc *sc = &kbd_softc;
        int s;

        /*
         * Get to splhigh, 'real' interrupts arrive at spl6!
         */
        s = splhigh();

        /*
         * Make sure any previous write has ended...
         */
        while (sc->sc_sendp != NULL)
                tsleep((void *)&sc->sc_sendp, TTOPRI, "kbd_write1", 0);

        /*
         * If the KBD-acia is not currently busy, send the first
         * character now.
         */
        KBD->ac_cs = (sc->sc_soft_cs |= A_TXINT);
        if ((KBD->ac_cs & A_TXRDY) != 0) {
                KBD->ac_da = *cmd++;
                len--;
        }

        /*
         * If we're not yet done, wait until all characters are send.
         */
        if (len > 0) {
                sc->sc_sendp    = cmd;
                sc->sc_send_cnt = len;
                tsleep((void *)&sc->sc_send_cnt, TTOPRI, "kbd_write2", 0);
        }
        splx(s);

        /*
         * Wakeup all procs waiting for us.
         */
        wakeup((void *)&sc->sc_sendp);
}

/*
 * Setup softc-fields to assemble a keyboard package.
 */
static void
kbd_pkg_start(struct kbd_softc *sc, uint8_t msg_start)
{

        sc->sc_pkg_idx    = 1;
        sc->sc_package[0] = msg_start;
        switch (msg_start) {
        case 0xf6:
                sc->sc_pkg_type = KBD_MEM_PKG;
                sc->sc_pkg_size = 8;
                break;
        case 0xf7:
                sc->sc_pkg_type = KBD_AMS_PKG;
                sc->sc_pkg_size = 6;
                break;
        case 0xf8:
        case 0xf9:
        case 0xfa:
        case 0xfb:
                sc->sc_pkg_type = KBD_RMS_PKG;
                sc->sc_pkg_size = 3;
                break;
        case 0xfc:
                sc->sc_pkg_type = KBD_CLK_PKG;
                sc->sc_pkg_size = 7;
                break;
        case 0xfe:
                sc->sc_pkg_type = KBD_JOY0_PKG;
                sc->sc_pkg_size = 2;
                break;
        case 0xff:
                sc->sc_pkg_type = KBD_JOY1_PKG;
                sc->sc_pkg_size = 2;
                break;
        default:
                printf("kbd: Unknown packet 0x%x\n", msg_start);
                break;
        }
}

#if NITE > 0
/*
 * Modifier processing
 */
static int
kbd_do_modifier(uint8_t code)
{
        uint8_t up, mask;

        up   = KBD_RELEASED(code);
        mask = 0;

        switch (KBD_SCANCODE(code)) {
        case KBD_LEFT_SHIFT:
                mask = KBD_MOD_LSHIFT;
                break;
        case KBD_RIGHT_SHIFT:
                mask = KBD_MOD_RSHIFT;
                break;
        case KBD_CTRL:
                mask = KBD_MOD_CTRL;
                break;
        case KBD_ALT:
                mask = KBD_MOD_ALT;
                break;
        case KBD_CAPS_LOCK:
                /* CAPSLOCK is a toggle */
                if (!up)
                        kbd_modifier ^= KBD_MOD_CAPS;
                return 1;
        }
        if (mask) {
                if (up)
                        kbd_modifier &= ~mask;
                else
                        kbd_modifier |= mask;
                return 1;
        }
        return 0;
}
#endif

#if NWSKBD > 0
/*
 * These are the callback functions that are passed to wscons.
 * They really don't do anything worth noting, just call the
 * other functions above.
 */

static int
kbd_enable(void *c, int on)
{

        /* Wonder what this is supposed to do... */
        return 0;
}

static void
kbd_set_leds(void *c, int leds)
{

        /* we can not set the leds */
}

static int
kbd_ioctl(void *c, u_long cmd, void *data, int flag, struct lwp *p)
{
        struct wskbd_bell_data *kd;

        switch (cmd) {
        case WSKBDIO_COMPLEXBELL:
                kd = (struct wskbd_bell_data *)data;
                kbd_bell(0, kd->pitch, kd->period, kd->volume);
                return 0;
        case WSKBDIO_SETLEDS:
                return 0;
        case WSKBDIO_GETLEDS:
                *(int *)data = 0;
                return 0;
        case WSKBDIO_GTYPE:
                *(u_int *)data = WSKBD_TYPE_ATARI;
                return 0;
        }

        /*
         * We are supposed to return EPASSTHROUGH to wscons if we didn't
         * understand.
         */
        return EPASSTHROUGH;
}

static void
kbd_getc(void *c, u_int *type, int *data)
{
        int key;

        key = kbdgetcn();

        *data = KBD_SCANCODE(key);
        *type = KBD_RELEASED(key) ? WSCONS_EVENT_KEY_UP : WSCONS_EVENT_KEY_DOWN;
}

static void
kbd_pollc(void *c, int on)
{
        struct kbd_softc *sc = &kbd_softc;

        sc->sc_pollingmode = on;
}

static void
kbd_bell(void *v, u_int pitch, u_int duration, u_int volume)
{

        kbd_bell_sparms(volume, pitch, duration);
        kbdbell();
}
#endif /* NWSKBD */