common/io/kbd.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"
                        /* SunOS-4.0 1.60   */
/*  From:   SunOS4.0    sundev/kbd.c    */

/*
 * Keyboard input streams module - handles conversion of up/down codes to
 * ASCII or event format.
 */
#include <sys/types.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/termios.h>
#include <sys/termio.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/kmem.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/consdev.h>
#include <sys/kbd.h>
#include <sys/kbio.h>
#include <sys/kbdreg.h>
#include <sys/vuid_event.h>
#include <sys/debug.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/policy.h>

#include <sys/modctl.h>
#include <sys/beep.h>
#include <sys/int_limits.h>

static struct streamtab kbd_info;

static struct fmodsw fsw = {
    "kb",
    &kbd_info,
    D_MP | D_MTPERMOD
};

/*
 * Module linkage information for the kernel.
 */

static struct modlstrmod modlstrmod = {
    &mod_strmodops, "streams module for keyboard", &fsw
};

static struct modlinkage modlinkage = {
    MODREV_1, (void *)&modlstrmod, NULL
};

int
_init(void)
{
    return (mod_install(&modlinkage));
}

int
_fini(void)
{
    return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
    return (mod_info(&modlinkage, modinfop));
}

/*
 * For now these are shared.
 * These data structures are static (defined in keytables.c) thus
 * there is no need to perform any locking.
 */
extern struct keyboards keytables[];
extern char keystringtab[16][KTAB_STRLEN];
extern struct compose_sequence_t kb_compose_table[];
extern signed char kb_compose_map[];
extern struct fltaccent_sequence_t kb_fltaccent_table[];
extern uchar_t kb_numlock_table[];

/*
 * This value corresponds approximately to max 10 fingers
 */
static int  kbd_downs_size = 15;

typedef struct  key_event {
    uchar_t key_station;    /* Physical key station associated with event */
    Firm_event event;   /* Event that sent out on down */
} Key_event;
struct  kbddata {
    queue_t *kbdd_readq;
    queue_t *kbdd_writeq;
    mblk_t  *kbdd_iocpending;   /* "ioctl" awaiting buffer */
    mblk_t  *kbdd_replypending; /* "ioctl" reply awaiting result */
    int kbdd_flags;     /* random flags */
    bufcall_id_t kbdd_bufcallid;    /* bufcall id */
    timeout_id_t kbdd_rptid;    /* timeout id for kbdrpt() */
    timeout_id_t kbdd_layoutid; /* timeout id for kbdlayout() */
    int kbdd_iocid;     /* ID of "ioctl" being waited for */
    int kbdd_iocerror;      /* error return from "ioctl" */
    struct  keyboardstate kbdd_state;
                    /*
                     * State of keyboard & keyboard
                     * specific settings, e.g., tables
                     */
    int kbdd_translate;     /* Translate keycodes? */
    int kbdd_translatable;  /* Keyboard is translatable? */
    int kbdd_compat;        /* Generating pre-4.1 events? */
    short   kbdd_ascii_addr;    /* Vuid_id_addr for ascii events */
    short   kbdd_top_addr;      /* Vuid_id_addr for top events */
    short   kbdd_vkey_addr;     /* Vuid_id_addr for vkey events */
    struct  key_event *kbdd_downs;
                    /*
                     * Table of key stations currently down
                     * that have firm events that need
                     * to be matched with up transitions
                     * when kbdd_translate is TR_*EVENT
                     */
    int kbdd_downs_entries; /* # of possible entries in kbdd_downs */
    uint_t  kbdd_downs_bytes; /* # of bytes allocated for kbdd_downs */
    ushort_t compose_key;       /* first compose key */
    ushort_t fltaccent_entry;   /* floating accent keymap entry */
    char    led_state;      /* current state of LEDs */
    unsigned char shiftkey;     /* used for the new abort keys */
};

#define KBD_OPEN    0x00000001 /* keyboard is open for business */
#define KBD_IOCWAIT 0x00000002 /* "open" waiting for "ioctl" to finish */

#define NO_HARD_RESET   0       /* don't do hard reset */
#define HARD_RESET  1       /* do hard reset */


/*
 * Constants setup during the first open of a kbd (so that they can be patched
 * for debugging purposes).
 */
static int kbd_repeatrate;
static int kbd_repeatdelay;

static int kbd_overflow_cnt;    /* Number of times kbd overflowed input q */
static int kbd_overflow_msg = 1; /* Whether to print message on q overflow */

#ifdef  KBD_DEBUG
int kbd_debug = 0;
int kbd_ra_debug = 0;
int kbd_raw_debug = 0;
int kbd_rpt_debug = 0;
int kbd_input_debug = 0;
#endif  /* KBD_DEBUG */

static int  kbdopen(queue_t *, dev_t *, int, int, cred_t *);
static int  kbdclose(queue_t *, int, cred_t *);
static void kbdwput(queue_t *, mblk_t *);
static void kbdrput(queue_t *, mblk_t *);

static struct module_info kbdmiinfo = {
    0,
    "kb",
    0,
    INFPSZ,
    2048,
    128
};

static struct qinit kbdrinit = {
    (int (*)())kbdrput,
    (int (*)())NULL,
    kbdopen,
    kbdclose,
    (int (*)())NULL,
    &kbdmiinfo
};

static struct module_info kbdmoinfo = {
    0,
    "kb",
    0,
    INFPSZ,
    2048,
    128
};

static struct qinit kbdwinit = {
    (int (*)())kbdwput,
    (int (*)())NULL,
    kbdopen,
    kbdclose,
    (int (*)())NULL,
    &kbdmoinfo
};

static struct streamtab kbd_info = {
    &kbdrinit,
    &kbdwinit,
    NULL,
    NULL,
};

static void kbdreioctl(void *);
static void kbdioctl(queue_t *, mblk_t *);
static void kbdflush(struct kbddata *);
static void kbduse(struct kbddata *, unsigned);
static void kbdsetled(struct kbddata *);
static void kbd_beep_off(void *arg);
static void kbd_beep_on(void *arg);
static void kbdcmd(queue_t *, char);
static void kbdreset(struct kbddata *, uint_t);
static int  kbdsetkey(struct kbddata *, struct kiockey *,  cred_t *);
static int  kbdgetkey(struct kbddata *, struct kiockey *);
static int  kbdskey(struct kbddata *, struct kiockeymap *,  cred_t *);
static int  kbdgkey(struct kbddata *, struct kiockeymap *);
static void kbdlayouttimeout(void *);
static void kbdinput(struct kbddata *, unsigned);
static void kbdid(struct kbddata *, int);
static struct   keymap *settable(struct kbddata *, uint_t);
static void kbdrpt(void *);
static void kbdcancelrpt(struct kbddata *);
static void kbdtranslate(struct kbddata *, unsigned, queue_t *);
static int  kbd_do_compose(ushort_t, ushort_t, ushort_t *);
static void kbd_send_esc_event(char, struct kbddata *);
char        *strsetwithdecimal(char *, uint_t, uint_t);
static void kbdkeypressed(struct kbddata *, uchar_t, Firm_event *,
                                ushort_t);
static void kbdqueuepress(struct kbddata *, uchar_t, Firm_event *);
static void kbdkeyreleased(struct kbddata *, uchar_t);
static void kbdreleaseall(struct kbddata *);
static void kbdputcode(uint_t, queue_t *);
static void kbdputbuf(char *, queue_t *);
static void kbdqueueevent(struct kbddata *, Firm_event *);

/*
 * Dummy qbufcall callback routine used by open and close.
 * The framework will wake up qwait_sig when we return from
 * this routine (as part of leaving the perimeters.)
 * (The framework enters the perimeters before calling the qbufcall() callback
 * and leaves the perimeters after the callback routine has executed. The
 * framework performs an implicit wakeup of any thread in qwait/qwait_sig
 * when it leaves the perimeter. See qwait(9E).)
 */
/* ARGSUSED */
static void dummy_callback(void *arg)
{}


/*
 * Open a keyboard.
 * Ttyopen sets line characteristics
 */
/* ARGSUSED */
static int
kbdopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
{
    register int  error;
    register struct kbddata *kbdd;
    mblk_t *mp;
    mblk_t *datap;
    register struct iocblk *iocb;
    register struct termios *cb;

    /* Set these up only once so that they could be changed from adb */
    if (!kbd_repeatrate) {
        kbd_repeatrate = (hz+29)/30;
        kbd_repeatdelay = hz/2;
    }

    if (q->q_ptr != NULL)
        return (0);     /* already attached */

    /*
     * Only allow open requests to succeed for privileged users.  This
     * necessary to prevent users from pushing the "kb" module again
     * on the stream associated with /dev/kbd.
     */
    if (secpolicy_console(crp) != 0) {
        return (EPERM);
    }


    switch (sflag) {

    case MODOPEN:
        break;

    case CLONEOPEN:
        return (EINVAL);    /* No Bozos! */
    }

    /* allocate keyboard */

    kbdd = kmem_zalloc(sizeof (struct kbddata), KM_SLEEP);


    /*
     * Set up queue pointers, so that the "put" procedure will accept
     * the reply to the "ioctl" message we send down.
     */
    q->q_ptr = kbdd;
    WR(q)->q_ptr = kbdd;

    qprocson(q);

    /*
     * Setup tty modes.
     */
    while ((mp = mkiocb(TCSETSF)) == NULL) {
        timeout_id_t id = qbufcall(q, sizeof (struct iocblk), BPRI_HI,
            dummy_callback, NULL);
        if (!qwait_sig(q)) {
            qunbufcall(q, id);
            kmem_free(kbdd, sizeof (struct kbddata));
            qprocsoff(q);

            return (EINTR);
        }
    }
    while ((datap = allocb(sizeof (struct termios), BPRI_HI)) ==
        NULL) {
        timeout_id_t id = qbufcall(q, sizeof (struct termios), BPRI_HI,
            dummy_callback, NULL);
        if (!qwait_sig(q)) {
            qunbufcall(q, id);
            freemsg(mp);
            kmem_free(kbdd, sizeof (struct kbddata));
            qprocsoff(q);

            return (EINTR);
        }
    }

    iocb        = (struct iocblk *)mp->b_rptr;
    iocb->ioc_count = sizeof (struct termios);

    cb = (struct termios *)datap->b_rptr;
    cb->c_iflag = 0;
    cb->c_oflag = 0;
    cb->c_cflag = CREAD|CS8|B1200;
    cb->c_lflag = 0;
    bzero(cb->c_cc, NCCS);
    datap->b_wptr += sizeof (struct termios);
    mp->b_cont = datap;
    kbdd->kbdd_flags |= KBD_IOCWAIT;    /* indicate that we're */
    kbdd->kbdd_iocid = iocb->ioc_id;    /* waiting for this response */
    putnext(WR(q), mp);

    /*
     * Now wait for it.  Let our read queue put routine wake us up
     * when it arrives.
     */
    while (kbdd->kbdd_flags & KBD_IOCWAIT) {
        if (!qwait_sig(q)) {
            error = EINTR;
            goto error;
        }
    }
    if ((error = kbdd->kbdd_iocerror) != 0)
        goto error;

    /*
     * Set up private data.
     */
    kbdd->kbdd_readq = q;
    kbdd->kbdd_writeq = WR(q);
    kbdd->kbdd_iocpending = NULL;
    kbdd->kbdd_translatable = TR_CAN;
    kbdd->kbdd_translate = TR_ASCII;
    kbdd->kbdd_compat = 1;
    kbdd->kbdd_ascii_addr = ASCII_FIRST;
    kbdd->kbdd_top_addr = TOP_FIRST;
    kbdd->kbdd_vkey_addr = VKEY_FIRST;
    /* Allocate dynamic memory for downs table */
    kbdd->kbdd_downs_entries = kbd_downs_size;
    kbdd->kbdd_downs_bytes = kbd_downs_size * sizeof (Key_event);
    kbdd->kbdd_downs = kmem_alloc(kbdd->kbdd_downs_bytes, KM_SLEEP);
    kbdd->kbdd_flags = KBD_OPEN;
    kbdd->led_state = 0;

    /*
     * Reset kbd.
     */
    kbdreset(kbdd, HARD_RESET);

    (void) beep_init((void *)WR(q), kbd_beep_on, kbd_beep_off, NULL);

    return (0);

error:
    qprocsoff(q);
    kmem_free(kbdd, sizeof (struct kbddata));
    return (error);
}

/*
 * Close a keyboard.
 */
/* ARGSUSED1 */
static int
kbdclose(register queue_t *q, int flag, cred_t *crp)
{
    register struct kbddata *kbdd = (struct kbddata *)q->q_ptr;
    register mblk_t *mp;

    qprocsoff(q);
    (void) beep_fini();
    /*
     * Since we're about to destroy our private data, turn off
     * our open flag first, so we don't accept any more input
     * and try to use that data.
     */
    kbdd->kbdd_flags = 0;

    if ((mp = kbdd->kbdd_replypending) != NULL) {
        /*
         * There was a KIOCLAYOUT pending; presumably, it timed out.
         * Throw the reply away.
         */
        kbdd->kbdd_replypending = NULL;
        freemsg(mp);
    }

    /* clear all timeouts */
    if (kbdd->kbdd_bufcallid)
        qunbufcall(q, kbdd->kbdd_bufcallid);
    if (kbdd->kbdd_rptid)
        (void) quntimeout(q, kbdd->kbdd_rptid);
    if (kbdd->kbdd_layoutid)
        (void) quntimeout(q, kbdd->kbdd_layoutid);
    kmem_free(kbdd->kbdd_downs, kbdd->kbdd_downs_bytes);
    kmem_free(kbdd, sizeof (struct kbddata));
    return (0);
}

/*
 * Line discipline output queue put procedure: handles M_IOCTL
 * messages.
 */
static void
kbdwput(register queue_t *q, register mblk_t *mp)
{
    /*
     * Process M_FLUSH, and some M_IOCTL, messages here; pass
     * everything else down.
     */
    switch (mp->b_datap->db_type) {

    case M_FLUSH:
        if (*mp->b_rptr & FLUSHW)
            flushq(q, FLUSHDATA);
        if (*mp->b_rptr & FLUSHR)
            flushq(RD(q), FLUSHDATA);

    default:
        putnext(q, mp); /* pass it down the line */
        break;

    case M_IOCTL:
        kbdioctl(q, mp);
        break;
    }
}


static void
kbdreioctl(void *kbdd_addr)
{
    struct kbddata *kbdd = kbdd_addr;
    queue_t *q;
    mblk_t *mp;

    kbdd->kbdd_bufcallid = 0;
    q = kbdd->kbdd_writeq;
    if ((mp = kbdd->kbdd_iocpending) != NULL) {
        kbdd->kbdd_iocpending = NULL;   /* not pending any more */
        kbdioctl(q, mp);
    }
}

static void
kbdioctl(register queue_t *q, register mblk_t *mp)
{
    register struct kbddata *kbdd = (struct kbddata *)q->q_ptr;
    register struct iocblk *iocp;
    register short  new_translate;
    register Vuid_addr_probe *addr_probe;
    register short  *addr_ptr;
    mblk_t *datap;
    size_t  ioctlrespsize;
    int err = 0;
    int tmp;
    int cycles;
    int frequency;
    int msecs;

    iocp = (struct iocblk *)mp->b_rptr;

    switch (iocp->ioc_cmd) {

    case VUIDSFORMAT:
        err = miocpullup(mp, sizeof (int));
        if (err != 0)
            break;

        new_translate = (*(int *)mp->b_cont->b_rptr == VUID_NATIVE) ?
            TR_ASCII : TR_EVENT;
        if (new_translate == kbdd->kbdd_translate)
            break;
        kbdd->kbdd_translate = new_translate;
        goto output_format_change;

    case KIOCTRANS:
        err = miocpullup(mp, sizeof (int));
        if (err != 0)
            break;

        new_translate = *(int *)mp->b_cont->b_rptr;
        if (new_translate == kbdd->kbdd_translate)
            break;
        kbdd->kbdd_translate = new_translate;
        goto output_format_change;

    case KIOCCMD:
        err = miocpullup(mp, sizeof (int));
        if (err != 0)
            break;

        tmp = (char)(*(int *)mp->b_cont->b_rptr);
        if (tmp == KBD_CMD_BELL)
            (void) beeper_on(BEEP_TYPE4);
        else if (tmp == KBD_CMD_NOBELL)
            (void) beeper_off();
        else
            kbdcmd(q, tmp);
        break;

    case KIOCMKTONE:
        if (iocp->ioc_count != TRANSPARENT) {
            /*
             * We don't support non-transparent ioctls,
             * i.e. I_STR ioctls
             */
            err = EINVAL;
            break;
        }
        tmp = (int)(*(intptr_t *)mp->b_cont->b_rptr);
        cycles = tmp & 0xffff;
        msecs = (tmp >> 16) & 0xffff;

        if (cycles == 0)
            frequency = UINT16_MAX;
        else if (cycles == UINT16_MAX)
            frequency = 0;
        else {
            frequency = (PIT_HZ + cycles / 2) / cycles;
            if (frequency > UINT16_MAX)
                frequency = UINT16_MAX;
        }

        err = beep_mktone(frequency, msecs);
        break;

    case KIOCSLED:
        err = miocpullup(mp, sizeof (uchar_t));
        if (err != 0)
            break;

        kbdd->led_state = *(uchar_t *)mp->b_cont->b_rptr;
        kbdsetled(kbdd);
        break;

    case KIOCGLED:
        if ((datap = allocb(sizeof (uchar_t), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(uchar_t *)datap->b_wptr = kbdd->led_state;
        datap->b_wptr += sizeof (uchar_t);
        if (mp->b_cont)  /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (uchar_t);
        break;

    case VUIDGFORMAT:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr =
            (kbdd->kbdd_translate == TR_EVENT ||
            kbdd->kbdd_translate == TR_UNTRANS_EVENT) ?
            VUID_FIRM_EVENT: VUID_NATIVE;
        datap->b_wptr += sizeof (int);
        if (mp->b_cont)  /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCGTRANS:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = kbdd->kbdd_translate;
        datap->b_wptr += sizeof (int);
        if (mp->b_cont)  /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case VUIDSADDR:
        err = miocpullup(mp, sizeof (Vuid_addr_probe));
        if (err != 0)
            break;

        addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr;
        switch (addr_probe->base) {

        case ASCII_FIRST:
            addr_ptr = &kbdd->kbdd_ascii_addr;
            break;

        case TOP_FIRST:
            addr_ptr = &kbdd->kbdd_top_addr;
            break;

        case VKEY_FIRST:
            addr_ptr = &kbdd->kbdd_vkey_addr;
            break;

        default:
            err = ENODEV;
        }
        if ((err == 0) && (*addr_ptr != addr_probe->data.next)) {
            *addr_ptr = addr_probe->data.next;
            goto output_format_change;
        }
        break;

    case VUIDGADDR:
        err = miocpullup(mp, sizeof (Vuid_addr_probe));
        if (err != 0)
            break;

        addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr;
        switch (addr_probe->base) {

        case ASCII_FIRST:
            addr_probe->data.current = kbdd->kbdd_ascii_addr;
            break;

        case TOP_FIRST:
            addr_probe->data.current = kbdd->kbdd_top_addr;
            break;

        case VKEY_FIRST:
            addr_probe->data.current = kbdd->kbdd_vkey_addr;
            break;

        default:
            err = ENODEV;
        }
        break;

    case KIOCTRANSABLE:
        err = miocpullup(mp, sizeof (int));
        if (err != 0)
            break;

        if (kbdd->kbdd_translatable != *(int *)mp->b_cont->b_rptr) {
            kbdd->kbdd_translatable = *(int *)mp->b_cont->b_rptr;
            kbdreset(kbdd, HARD_RESET);
            goto output_format_change;
        }
        break;

    case KIOCGTRANSABLE:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = kbdd->kbdd_translatable;
        datap->b_wptr += sizeof (int);
        if (mp->b_cont)  /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCSCOMPAT:
        err = miocpullup(mp, sizeof (int));
        if (err != 0)
            break;

        kbdd->kbdd_compat = *(int *)mp->b_cont->b_rptr;
        break;

    case KIOCGCOMPAT:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = kbdd->kbdd_compat;
        datap->b_wptr += sizeof (int);
        if (mp->b_cont)  /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCSETKEY:
        err = miocpullup(mp, sizeof (struct kiockey));
        if (err != 0)
            break;

        err = kbdsetkey(kbdd, (struct kiockey *)mp->b_cont->b_rptr,
            iocp->ioc_cr);
        /*
         * Since this only affects any subsequent key presses,
         * don't goto output_format_change.  One might want to
         * toggle the keytable entries dynamically.
         */
        break;

    case KIOCGETKEY:
        err = miocpullup(mp, sizeof (struct kiockey));
        if (err != 0)
            break;

        err = kbdgetkey(kbdd, (struct kiockey *)mp->b_cont->b_rptr);
        break;

    case KIOCSKEY:
        err = miocpullup(mp, sizeof (struct kiockeymap));
        if (err != 0)
            break;

        err = kbdskey(kbdd, (struct kiockeymap *)mp->b_cont->b_rptr,
            iocp->ioc_cr);
        /*
         * Since this only affects any subsequent key presses,
         * don't goto output_format_change.  One might want to
         * toggle the keytable entries dynamically.
         */
        break;

    case KIOCGKEY:
        err = miocpullup(mp, sizeof (struct kiockeymap));
        if (err != 0)
            break;

        err = kbdgkey(kbdd, (struct kiockeymap *)mp->b_cont->b_rptr);
        break;

    case KIOCSDIRECT:
        goto output_format_change;

    case KIOCGDIRECT:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = 1;  /* always direct */
        datap->b_wptr += sizeof (int);
        if (mp->b_cont) /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCTYPE:
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = kbdd->kbdd_state.k_id;
        datap->b_wptr += sizeof (int);
        if (mp->b_cont) /* free msg to prevent memory leak */
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCLAYOUT:
        if ((datap = kbdd->kbdd_replypending) != NULL) {
            /*
             * There was an earlier KIOCLAYOUT pending; presumably,
             * it timed out.  Throw the reply away.
             */
            kbdd->kbdd_replypending = NULL;
            freemsg(datap);
        }

        if (kbdd->kbdd_state.k_id == KB_SUN4 ||
            kbdd->kbdd_state.k_id == KB_PC) {
            if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
                ioctlrespsize = sizeof (int);
                goto allocfailure;
            }
            iocp->ioc_rval = 0;
            iocp->ioc_error = 0;    /* brain rot */
            iocp->ioc_count = sizeof (int);
            if (mp->b_cont)   /* free msg to prevent memory leak */
                freemsg(mp->b_cont);
            mp->b_cont = datap;
            mp->b_datap->db_type = M_IOCACK;
            kbdd->kbdd_replypending = mp;
            kbdcmd(q, (char)KBD_CMD_GETLAYOUT);
            if (kbdd->kbdd_layoutid)
                (void) quntimeout(q, kbdd->kbdd_layoutid);
            kbdd->kbdd_layoutid = qtimeout(q, kbdlayouttimeout,
                kbdd, hz / 5);
            return;     /* wait for reply from keyboard */
        } else {
            /*
             * Not a Type 4 keyboard; return an immediate error.
             */
            err = EINVAL;
            break;
        }

    case KIOCGRPTDELAY:
        /*
         * Report the autorepeat delay, unit in millisecond
         */
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = TICK_TO_MSEC(kbd_repeatdelay);
        datap->b_wptr += sizeof (int);

        /* free msg to prevent memory leak */
        if (mp->b_cont != NULL)
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCSRPTDELAY:
        /*
         * Set the autorepeat delay
         */
        err = miocpullup(mp, sizeof (int));

        if (err != 0)
            break;

        /* validate the input */
        if (*(int *)mp->b_cont->b_rptr < KIOCRPTDELAY_MIN) {
            err = EINVAL;
            break;
        }
        kbd_repeatdelay = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr);
        if (kbd_repeatdelay <= 0)
            kbd_repeatdelay = 1;
        break;

    case KIOCGRPTRATE:
        /*
         * Report the autorepeat rate
         */
        if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
            ioctlrespsize = sizeof (int);
            goto allocfailure;
        }
        *(int *)datap->b_wptr = TICK_TO_MSEC(kbd_repeatrate);
        datap->b_wptr += sizeof (int);

        /* free msg to prevent memory leak */
        if (mp->b_cont != NULL)
            freemsg(mp->b_cont);
        mp->b_cont = datap;
        iocp->ioc_count = sizeof (int);
        break;

    case KIOCSRPTRATE:
        /*
         * Set the autorepeat rate
         */
        err = miocpullup(mp, sizeof (int));

        if (err != 0)
            break;

        /* validate the input */
        if (*(int *)mp->b_cont->b_rptr < KIOCRPTRATE_MIN) {
            err = EINVAL;
            break;
        }
        kbd_repeatrate = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr);
        if (kbd_repeatrate <= 0)
            kbd_repeatrate = 1;
        break;

    default:
        putnext(q, mp); /* pass it down the line */
        return;
    }
    goto done;

output_format_change:
    kbdflush(kbdd);

done:
    if (err != 0) {
        iocp->ioc_rval = 0;
        iocp->ioc_error = err;
        mp->b_datap->db_type = M_IOCNAK;
    } else {
        iocp->ioc_rval = 0;
        iocp->ioc_error = 0;    /* brain rot */
        mp->b_datap->db_type = M_IOCACK;
    }
    qreply(q, mp);
    return;

allocfailure:
    /*
     * We needed to allocate something to handle this "ioctl", but
     * couldn't; save this "ioctl" and arrange to get called back when
     * it's more likely that we can get what we need.
     * If there's already one being saved, throw it out, since it
     * must have timed out.
     */
    if (kbdd->kbdd_iocpending != NULL)
        freemsg(kbdd->kbdd_iocpending);
    kbdd->kbdd_iocpending = mp;
    if (kbdd->kbdd_bufcallid)
        qunbufcall(q, kbdd->kbdd_bufcallid);
    kbdd->kbdd_bufcallid = qbufcall(q, ioctlrespsize, BPRI_HI,
        kbdreioctl, kbdd);
}

static void
kbdflush(register struct kbddata *kbdd)
{
    register queue_t *q;

    /* Flush pending data already sent upstream */
    if ((q = kbdd->kbdd_readq) != NULL && q->q_next != NULL)
        (void) putnextctl1(q, M_FLUSH, FLUSHR);
    /* Flush pending ups */
    bzero(kbdd->kbdd_downs, kbdd->kbdd_downs_bytes);
    kbdcancelrpt(kbdd);
}

/*
 * Pass keycode upstream, either translated or untranslated.
 */
static void
kbduse(register struct kbddata *kbdd, unsigned keycode)
{
    register queue_t *readq;

#ifdef  KBD_DEBUG
    if (kbd_input_debug) printf("KBD USE key=%d\n", keycode);
#endif

    if ((readq = kbdd->kbdd_readq) == NULL)
        return;
    if (!kbdd->kbdd_translatable ||
        kbdd->kbdd_translate == TR_NONE)
        kbdputcode(keycode, readq);
    else
        kbdtranslate(kbdd, keycode, readq);
}

static void
kbd_beep_on(void *arg)
{
    kbdcmd((queue_t *)arg, KBD_CMD_BELL);
}


static void
kbd_beep_off(void *arg)
{
    kbdcmd((queue_t *)arg, KBD_CMD_NOBELL);
}


/*
 * kbdclick is used to remember the current click value of the
 * Sun-3 keyboard.  This brain damaged keyboard will reset the
 * clicking to the "default" value after a reset command and
 * there is no way to read out the current click value.  We
 * cannot send a click command immediately after the reset
 * command or the keyboard gets screwed up.  So we wait until
 * we get the ID byte before we send back the click command.
 * Unfortunately, this means that there is a small window
 * where the keyboard can click when it really shouldn't be.
 * A value of -1 means that kbdclick has not been initialized yet.
 */
static int kbdclick = -1;

/*
 * Send command byte to keyboard, if you can.
 */
static void
kbdcmd(register queue_t *q, char cmd)
{
    register mblk_t *bp;

    if (canput(q)) {
        if ((bp = allocb(1, BPRI_MED)) == NULL)
            cmn_err(CE_WARN,
                "kbdcmd: Can't allocate block for command");
        else {
            *bp->b_wptr++ = cmd;
            putnext(q, bp);
            if (cmd == KBD_CMD_NOCLICK)
                kbdclick = 0;
            else if (cmd == KBD_CMD_CLICK)
                kbdclick = 1;
        }
    }
}

/*
 * Update the keyboard LEDs to match the current keyboard state.
 * Do this only on Type 4 keyboards; other keyboards don't support the
 * KBD_CMD_SETLED command (nor, for that matter, the appropriate LEDs).
 */
static void
kbdsetled(register struct kbddata *kbdd)
{
    if (kbdd->kbdd_state.k_id == KB_SUN4 ||
        kbdd->kbdd_state.k_id == KB_PC) {
        kbdcmd(kbdd->kbdd_writeq, KBD_CMD_SETLED);
        kbdcmd(kbdd->kbdd_writeq, kbdd->led_state);
    }
}

/*
 * Reset the keyboard
 */
static void
kbdreset(register struct kbddata *kbdd, uint_t hard_reset)
{
    register struct keyboardstate *k;

    k = &kbdd->kbdd_state;
    if (kbdd->kbdd_translatable) {
        k->k_idstate = KID_NONE;
        k->k_id = -1;
        k->k_state = NORMAL;
        if (hard_reset)
            kbdcmd(kbdd->kbdd_writeq, KBD_CMD_RESET);
    } else {
        bzero(k, sizeof (struct keyboardstate));
        k->k_id = KB_ASCII;
        k->k_idstate = KID_OK;
    }
}

/*
 * Old special codes.
 */
#define OLD_SHIFTKEYS   0x80
#define OLD_BUCKYBITS   0x90
#define OLD_FUNNY   0xA0
#define OLD_FA_UMLAUT   0xA9
#define OLD_FA_CFLEX    0xAA
#define OLD_FA_TILDE    0xAB
#define OLD_FA_CEDILLA  0xAC
#define OLD_FA_ACUTE    0xAD
#define OLD_FA_GRAVE    0xAE
#define OLD_ISOCHAR 0xAF
#define OLD_STRING  0xB0
#define OLD_LEFTFUNC    0xC0
#define OLD_RIGHTFUNC   0xD0
#define OLD_TOPFUNC 0xE0
#define OLD_BOTTOMFUNC  0xF0

/*
 * Map old special codes to new ones.
 * Indexed by ((old special code) >> 4) & 0x07; add (old special code) & 0x0F.
 */
static ushort_t special_old_to_new[] = {
    SHIFTKEYS,
    BUCKYBITS,
    FUNNY,
    STRING,
    LEFTFUNC,
    RIGHTFUNC,
    TOPFUNC,
    BOTTOMFUNC,
};

/*
 * Set individual keystation translation from old-style entry.
 * TODO: Have each keyboard own own translation tables.
 */
static int
kbdsetkey(register struct kbddata *kbdd, struct kiockey *key, cred_t *cr)
{
    int strtabindex, i;
    struct  keymap *km;
    register int tablemask;
    register ushort_t entry;

    if (key->kio_station >= KEYMAP_SIZE)
        return (EINVAL);
    if (kbdd->kbdd_state.k_curkeyboard == NULL)
        return (EINVAL);
    tablemask = key->kio_tablemask;
    if (tablemask == KIOCABORT1) {
        if (secpolicy_console(cr) != 0)
            return (EPERM);
        kbdd->kbdd_state.k_curkeyboard->k_abort1 = key->kio_station;
        return (0);
    }
    if (tablemask == KIOCABORT2) {
        if (secpolicy_console(cr) != 0)
            return (EPERM);
        kbdd->kbdd_state.k_curkeyboard->k_abort2 = key->kio_station;
        return (0);
    }
    if ((tablemask & ALTGRAPHMASK) ||
        (km = settable(kbdd, (uint_t)tablemask)) == NULL)
        return (EINVAL);
    if (key->kio_entry >= (uchar_t)OLD_STRING &&
        key->kio_entry <= (uchar_t)(OLD_STRING + 15)) {
        strtabindex = key->kio_entry - OLD_STRING;
        for (i = 0; i < KTAB_STRLEN; i++)
            keystringtab[strtabindex][i] = key->kio_string[i];
        keystringtab[strtabindex][KTAB_STRLEN-1] = '\0';
    }
    entry = key->kio_entry;
    /*
     * There's nothing we need do with OLD_ISOCHAR.
     */
    if (entry != OLD_ISOCHAR) {
        if (entry & 0x80) {
            if (entry >= OLD_FA_UMLAUT && entry <= OLD_FA_GRAVE)
                entry = FA_CLASS + (entry & 0x0F) - 9;
            else
                entry =
                    special_old_to_new[entry >> 4 & 0x07]
                    + (entry & 0x0F);
        }
    }
    km->keymap[key->kio_station] = entry;
    return (0);
}

/*
 * Map new special codes to old ones.
 * Indexed by (new special code) >> 8; add (new special code) & 0xFF.
 */
static uchar_t  special_new_to_old[] = {
    0,          /* normal */
    OLD_SHIFTKEYS,      /* SHIFTKEYS */
    OLD_BUCKYBITS,      /* BUCKYBITS */
    OLD_FUNNY,      /* FUNNY */
    OLD_FA_UMLAUT,      /* FA_CLASS */
    OLD_STRING,     /* STRING */
    OLD_LEFTFUNC,       /* FUNCKEYS */
};

/*
 * Get individual keystation translation as old-style entry.
 */
static int
kbdgetkey(register struct kbddata *kbdd, struct kiockey *key)
{
    int strtabindex, i;
    struct  keymap *km;
    register ushort_t entry;

    if (key->kio_station >= KEYMAP_SIZE)
        return (EINVAL);
    if (kbdd->kbdd_state.k_curkeyboard == NULL)
        return (EINVAL);
    if (key->kio_tablemask == KIOCABORT1) {
        key->kio_station = kbdd->kbdd_state.k_curkeyboard->k_abort1;
        return (0);
    }
    if (key->kio_tablemask == KIOCABORT2) {
        key->kio_station = kbdd->kbdd_state.k_curkeyboard->k_abort2;
        return (0);
    }
    if ((km = settable(kbdd, (uint_t)key->kio_tablemask)) == NULL)
        return (EINVAL);
    entry = km->keymap[key->kio_station];
    if (entry & 0xFF00)
        key->kio_entry =
            special_new_to_old[(ushort_t)(entry & 0xFF00) >> 8]
            + (entry & 0x00FF);
    else {
        if (entry & 0x80)
            key->kio_entry = (ushort_t)OLD_ISOCHAR; /* you lose */
        else
            key->kio_entry = (ushort_t)entry;
    }
    if (entry >= STRING && entry <= (uchar_t)(STRING + 15)) {
        strtabindex = entry - STRING;
        for (i = 0; i < KTAB_STRLEN; i++)
            key->kio_string[i] = keystringtab[strtabindex][i];
    }
    return (0);
}

/*
 * Set individual keystation translation from new-style entry.
 * TODO: Have each keyboard own own translation tables.
 */
static int
kbdskey(register struct kbddata *kbdd, struct kiockeymap *key, cred_t *cr)
{
    int strtabindex, i;
    struct  keymap *km;

    if (key->kio_station >= KEYMAP_SIZE)
        return (EINVAL);
    if (kbdd->kbdd_state.k_curkeyboard == NULL)
        return (EINVAL);
    if (key->kio_tablemask == KIOCABORT1) {
        if (secpolicy_console(cr) != 0)
            return (EPERM);
        kbdd->kbdd_state.k_curkeyboard->k_abort1 = key->kio_station;
        return (0);
    }
    if (key->kio_tablemask == KIOCABORT2) {
        if (secpolicy_console(cr) != 0)
            return (EPERM);
        kbdd->kbdd_state.k_curkeyboard->k_abort2 = key->kio_station;
        return (0);
    }
    if ((km = settable(kbdd, (uint_t)key->kio_tablemask)) == NULL)
        return (EINVAL);
    if (key->kio_entry >= STRING &&
        key->kio_entry <= (ushort_t)(STRING + 15)) {
        strtabindex = key->kio_entry-STRING;
        for (i = 0; i < KTAB_STRLEN; i++)
            keystringtab[strtabindex][i] = key->kio_string[i];
        keystringtab[strtabindex][KTAB_STRLEN-1] = '\0';
    }
    km->keymap[key->kio_station] = key->kio_entry;
    return (0);
}

/*
 * Get individual keystation translation as new-style entry.
 */
static int
kbdgkey(register struct kbddata *kbdd, struct   kiockeymap *key)
{
    int strtabindex, i;
    struct  keymap *km;

    if (key->kio_station >= KEYMAP_SIZE)
        return (EINVAL);
    if (kbdd->kbdd_state.k_curkeyboard == NULL)
        return (EINVAL);
    if (key->kio_tablemask == KIOCABORT1) {
        key->kio_station = kbdd->kbdd_state.k_curkeyboard->k_abort1;
        return (0);
    }
    if (key->kio_tablemask == KIOCABORT2) {
        key->kio_station = kbdd->kbdd_state.k_curkeyboard->k_abort2;
        return (0);
    }
    if ((km = settable(kbdd, (uint_t)key->kio_tablemask)) == NULL)
        return (EINVAL);
    key->kio_entry = km->keymap[key->kio_station];
    if (key->kio_entry >= STRING &&
        key->kio_entry <= (ushort_t)(STRING + 15)) {
        strtabindex = key->kio_entry-STRING;
        for (i = 0; i < KTAB_STRLEN; i++)
            key->kio_string[i] = keystringtab[strtabindex][i];
    }
    return (0);
}

static void
kbdlayouttimeout(void *arg)
{
    struct kbddata *kbdd = arg;
    mblk_t *mp;

    kbdd->kbdd_layoutid = 0;

    /*
     * Timed out waiting for reply to "get keyboard layout" command.
     * Return an ETIME error.
     */
    if ((mp = kbdd->kbdd_replypending) != NULL) {
        kbdd->kbdd_replypending = NULL;
        mp->b_datap->db_type = M_IOCNAK;
        ((struct iocblk *)mp->b_rptr)->ioc_error = ETIME;
        putnext(kbdd->kbdd_readq, mp);
    }
}

/*
 * Put procedure for input from driver end of stream (read queue).
 */
static void
kbdrput(register queue_t *q, register mblk_t *mp)
{
    struct kbddata *kbdd = (struct kbddata *)q->q_ptr;
    register mblk_t *bp;
    register uchar_t *readp;
    struct iocblk *iocp;

    if (kbdd == 0) {
        freemsg(mp);    /* nobody's listening */
        return;
    }

    switch (mp->b_datap->db_type) {

    case M_FLUSH:
        if (*mp->b_rptr & FLUSHW)
            flushq(WR(q), FLUSHDATA);
        if (*mp->b_rptr & FLUSHR)
            flushq(q, FLUSHDATA);

    default:
        putnext(q, mp);
        return;

    case M_BREAK:
        /*
         * Will get M_BREAK only if this is not the system
         * keyboard, otherwise serial port will eat break
         * and call kmdb/OBP, without passing anything up.
         */
        freemsg(mp);
        return;

    case M_IOCACK:
    case M_IOCNAK:
        /*
         * If we are doing an "ioctl" ourselves, check if this
         * is the reply to that code.  If so, wake up the
         * "open" routine, and toss the reply, otherwise just
         * pass it up.
         */
        iocp = (struct iocblk *)mp->b_rptr;
        if (!(kbdd->kbdd_flags & KBD_IOCWAIT) ||
            iocp->ioc_id != kbdd->kbdd_iocid) {
            /*
             * This isn't the reply we're looking for.  Move along.
             */
            if (kbdd->kbdd_flags & KBD_OPEN)
                putnext(q, mp);
            else
                freemsg(mp);    /* not ready to listen */
        } else {
            kbdd->kbdd_flags &= ~KBD_IOCWAIT;
            kbdd->kbdd_iocerror = iocp->ioc_error;
            freemsg(mp);
        }
        return;

    case M_DATA:
        if (!(kbdd->kbdd_flags & KBD_OPEN)) {
            freemsg(mp);    /* not read to listen */
            return;
        }
        break;
    }

    /*
     * A data message, consisting of bytes from the keyboard.
     * Ram them through our state machine.
     */
    bp = mp;

    do {
        readp = bp->b_rptr;
        while (readp < bp->b_wptr)
            kbdinput(kbdd, *readp++);
        bp->b_rptr = readp;
    } while ((bp = bp->b_cont) != NULL);    /* next block, if any */

    freemsg(mp);
}

/*
 * A keypress was received. Process it through the state machine
 * to check for aborts.
 */
static void
kbdinput(register struct kbddata *kbdd, register unsigned key)
{
    register struct keyboardstate *k;
    register mblk_t *mp;

    k = &kbdd->kbdd_state;
#ifdef  KBD_DEBUG
    if (kbd_input_debug)
        printf("kbdinput key %x\n", key);
#endif

    switch (k->k_idstate) {

    case KID_NONE:
        if (key == RESETKEY) {
            k->k_idstate = KID_GOT_PREFACE;
        } else  {
            kbdreset(kbdd, HARD_RESET);
            /* allows hot plug of kbd after booting without kbd */
        }
        return;

    case KID_GOT_PREFACE:
        kbdid(kbdd, (int)key);

        /*
         * We just did a reset command to a Type 3 or Type 4
         * keyboard which sets the click back to the default
         * (which is currently ON!).  We use the kbdclick
         * variable to see if the keyboard should be turned on
         * or off.  If it has not been set, then we use the
         * keyboard-click? property.
         */
        switch (kbdclick) {
        case 0:
            kbdcmd(kbdd->kbdd_writeq, KBD_CMD_NOCLICK);
            break;
        case 1:
            kbdcmd(kbdd->kbdd_writeq, KBD_CMD_CLICK);
            break;
        case -1:
        default:
            {
                char wrkbuf[8];
                int len;

                kbdcmd(kbdd->kbdd_writeq, KBD_CMD_NOCLICK);

                bzero(wrkbuf, 8);
                len = 7;
                if (ddi_getlongprop_buf(DDI_DEV_T_ANY,
                    ddi_root_node(), 0, "keyboard-click?",
                    (caddr_t)wrkbuf, &len) ==
                    DDI_PROP_SUCCESS &&
                    len > 0 && len < 8) {
                    if (strcmp(wrkbuf, "true") == 0) {
                        kbdcmd(kbdd->kbdd_writeq,
                            KBD_CMD_CLICK);
                    }
                }
            }
            break;
        }
        /*
         * A keyboard reset clears the LEDs.
         * Restore the LEDs from the last value we set
         * them to.
         */
        kbdsetled(kbdd);
        return;

    case KID_OK:
        switch (key) {

#if defined(KBD_PRESSED_PREFIX)
        case KBD_PRESSED_PREFIX:
            k->k_idstate = KID_GOT_PRESSED;
            return;
#endif

#if defined(KBD_RELEASED_PREFIX)
        case KBD_RELEASED_PREFIX:
            k->k_idstate = KID_GOT_RELEASED;
            return;
#endif

        case 0:
            kbdreset(kbdd, HARD_RESET);
            return;

        /*
         * we want to check for ID only if we are in
         * translatable mode.
         */
        case RESETKEY:
            kbdreset(kbdd, NO_HARD_RESET);
            if (k->k_idstate == KID_NONE) {
                k->k_idstate = KID_GOT_PREFACE;
            }
            return;

        case LAYOUTKEY:
            k->k_idstate = KID_GOT_LAYOUT;
            return;
        }
        break;

#if defined(KBD_PRESSED_PREFIX)
    case KID_GOT_PRESSED:
        key = BUILDKEY(key, PRESSED);
        k->k_idstate = KID_OK;
        break;
#endif
#if defined(KBD_RELEASED_PREFIX)
    case KID_GOT_RELEASED:
        key = BUILDKEY(key, RELEASED);
        k->k_idstate = KID_OK;
        break;
#endif

    case KID_GOT_LAYOUT:
        if (kbdd->kbdd_layoutid)
            (void) quntimeout(kbdd->kbdd_readq,
                kbdd->kbdd_layoutid);
        if ((mp = kbdd->kbdd_replypending) != NULL) {
            kbdd->kbdd_replypending = NULL;
            *(int *)mp->b_cont->b_wptr = key;
            mp->b_cont->b_wptr += sizeof (int);
            putnext(kbdd->kbdd_readq, mp);
        }
        k->k_idstate = KID_OK;
        return;
    }

    switch (k->k_state) {

#if defined(__sparc)
    normalstate:
        k->k_state = NORMAL;
        /* FALLTHRU */
#endif
    case NORMAL:
#if defined(__sparc)
        if (k->k_curkeyboard) {
            if (key == k->k_curkeyboard->k_abort1) {
                k->k_state = ABORT1;
                break;
            }
            if ((key == k->k_curkeyboard->k_newabort1) ||
                (key == k->k_curkeyboard->k_newabort1a)) {
                k->k_state = NEWABORT1;
                kbdd->shiftkey = key;
            }
        }
#endif
        kbduse(kbdd, key);
        break;

#if defined(__sparc)
    case ABORT1:
        if (k->k_curkeyboard) {
            /*
             * Only recognize this as an abort sequence if
             * the "hardware" console is set to be this device.
             */
            if (key == k->k_curkeyboard->k_abort2 &&
                rconsvp == wsconsvp) {
                DELAY(100000);
                abort_sequence_enter((char *)NULL);
                k->k_state = NORMAL;
                kbduse(kbdd, IDLEKEY);  /* fake */
                return;
            } else {
                kbduse(kbdd, k->k_curkeyboard->k_abort1);
                goto normalstate;
            }
        }
        break;
    case NEWABORT1:
        if (k->k_curkeyboard) {
            /*
             * Only recognize this as an abort sequence if
             * the "hardware" console is set to be this device.
             */
            if (key == k->k_curkeyboard->k_newabort2 &&
                rconsvp == wsconsvp) {
                DELAY(100000);
                abort_sequence_enter((char *)NULL);
                k->k_state = NORMAL;
                kbdd->shiftkey |= RELEASED;
                kbduse(kbdd, kbdd->shiftkey);
                kbduse(kbdd, IDLEKEY);  /* fake */
                return;
            } else {
                goto normalstate;
            }
        }
        break;
#endif

    case COMPOSE1:
    case COMPOSE2:
    case FLTACCENT:
        if (key != IDLEKEY)
            kbduse(kbdd, key);
        break;
    }
}

static void
kbdid(register struct kbddata *kbdd, int id)
{
    register struct keyboardstate *k;
    int i;

    k = &kbdd->kbdd_state;

    k->k_idstate = KID_OK;
    k->k_shiftmask = 0;
    k->k_buckybits = 0;

    /*
     * Reset k_rptkey to IDLEKEY. We need to cancel
     * the autorepeat feature, if any.
     */
    if (k->k_rptkey != IDLEKEY) {
        if (kbdd->kbdd_rptid)
            (void) quntimeout(kbdd->kbdd_readq, kbdd->kbdd_rptid);
        kbdd->kbdd_rptid = 0;
        k->k_rptkey = IDLEKEY;
    }

    k->k_curkeyboard = NULL;
    for (i = 0; keytables[i].table; i++) {
        if (keytables[i].id == id) {
            k->k_id = id;
            k->k_curkeyboard = keytables[i].table;
            break;
        }
    }
    if (!k->k_curkeyboard) {
        k->k_id = keytables[0].id;
        k->k_curkeyboard = keytables[0].table;
        cmn_err(CE_WARN, "kbd: Unknown keyboard type, "
            "Type %d assumed", k->k_id);
    }
}

/*
 * This routine determines which table we should look in to decode
 * the current keycode.
 */
static struct keymap *
settable(register struct kbddata *kbdd, register uint_t mask)
{
    register struct keyboard *kp;

    kp = kbdd->kbdd_state.k_curkeyboard;
    if (kp == NULL)
        return (NULL);
    if (mask & UPMASK)
        return (kp->k_up);
    if (mask & NUMLOCKMASK)
        return (kp->k_numlock);
    if (mask & CTRLMASK)
        return (kp->k_control);
    if (mask & ALTGRAPHMASK)
        return (kp->k_altgraph);
    if (mask & SHIFTMASK)
        return (kp->k_shifted);
    if (mask & CAPSMASK)
        return (kp->k_caps);
    return (kp->k_normal);
}

static void
kbdrpt(void *arg)
{
    struct kbddata *kbdd = arg;
    struct keyboardstate *k;

    k = &kbdd->kbdd_state;
#ifdef  KBD_DEBUG
    if (kbd_rpt_debug)
        printf("kbdrpt key %x\n", k->k_rptkey);
#endif
    kbdd->kbdd_rptid = 0;

    kbdkeyreleased(kbdd, KEYOF(k->k_rptkey));
    kbduse(kbdd, k->k_rptkey);
    if (k->k_rptkey != IDLEKEY) {
        kbdd->kbdd_rptid = qtimeout(kbdd->kbdd_readq, kbdrpt,
            kbdd, kbd_repeatrate);
    }
}

static void
kbdcancelrpt(register struct kbddata *kbdd)
{
    register struct keyboardstate *k;

    k = &kbdd->kbdd_state;
    if (k->k_rptkey != IDLEKEY) {
        if (kbdd->kbdd_rptid)
            (void) quntimeout(kbdd->kbdd_readq, kbdd->kbdd_rptid);
        kbdd->kbdd_rptid = 0;
        k->k_rptkey = IDLEKEY;
    }
    ASSERT(kbdd->kbdd_rptid == 0);
}

static void
kbdtranslate(struct kbddata *kbdd, unsigned keycode, queue_t *q)
{
    register uchar_t key;
    register unsigned newstate;
    unsigned shiftmask;
    register ushort_t entry, entrytype;
    register char *cp, *bufp;
    register struct keyboardstate *k;
    ushort_t result_iso;
    struct keymap *km;
    Firm_event fe;
    int i, ret_val;
    char buf[14];

    k = &kbdd->kbdd_state;
    newstate = STATEOF(keycode);
    key = KEYOF(keycode);

#ifdef  KBD_DEBUG
    if (kbd_input_debug) {
        printf("KBD TRANSLATE keycode=0x%x newstate=0x%x key=0x%x\n",
            keycode, newstate, key);
    }
#endif

    if (kbdd->kbdd_translate == TR_UNTRANS_EVENT) {
        if (newstate == PRESSED) {
            bzero(&fe, sizeof (fe));
            fe.id = key;
            fe.value = 1;
            kbdqueuepress(kbdd, key, &fe);
        } else {
            kbdkeyreleased(kbdd, key);
        }
        return;
    }

    shiftmask = k->k_shiftmask;
    if (newstate == RELEASED)
        shiftmask |= UPMASK;

    km = settable(kbdd, shiftmask);
    if (km == NULL) {       /* gross error */
        kbdcancelrpt(kbdd);
        return;
    }

    if (key >= KEYMAP_SIZE)
        return;
    entry = km->keymap[key];

    if (entry == NONL) {
        /*
         * NONL appears only in the Num Lock table, and indicates that
         * this key is not affected by Num Lock.  This means we should
         * ask for the table we would have gotten had Num Lock not been
         * down, and translate using that table.
         */
        km = settable(kbdd, shiftmask & ~NUMLOCKMASK);
        if (km == NULL) {       /* gross error */
            kbdcancelrpt(kbdd);
            return;
        }
        entry = km->keymap[key];
    }
    entrytype = (ushort_t)(entry & 0xFF00) >> 8;

    if (entrytype == (SHIFTKEYS >> 8)) {
        /*
         * Handle the state of toggle shifts specially.
         * Ups should be ignored, and downs should be mapped to ups if
         * that shift is currently on.
         */
        if ((1 << (entry & 0x0F)) & k->k_curkeyboard->k_toggleshifts) {
            if ((1 << (entry & 0x0F)) & k->k_togglemask) {
                newstate = RELEASED;    /* toggling off */
            } else {
                newstate = PRESSED; /* toggling on */
            }
        }
    } else {
        /*
         * Handle Compose and floating accent key sequences
         */
        if (k->k_state == COMPOSE1) {
            if (newstate == RELEASED)
                return;
            if (entry < ASCII_SET_SIZE) {
                if (kb_compose_map[entry] >= 0) {
                    kbdd->compose_key = entry;
                    k->k_state = COMPOSE2;
                    return;
                }
            }
            k->k_state = NORMAL;
            kbdd->led_state &= ~LED_COMPOSE;
            kbdsetled(kbdd);
            return;
        } else if (k->k_state == COMPOSE2) {
            if (newstate == RELEASED)
                return;
            k->k_state = NORMAL;    /* next state is "normal" */
            kbdd->led_state &= ~LED_COMPOSE;
            kbdsetled(kbdd);
            if (entry < ASCII_SET_SIZE) {
                if (kb_compose_map[entry] >= 0) {
                    if (kbdd->compose_key <= entry) {
                        ret_val = kbd_do_compose(
                            kbdd->compose_key,
                            entry,
                            &result_iso);
                    } else {
                        ret_val = kbd_do_compose(
                            entry,
                            kbdd->compose_key,
                            &result_iso);
                    }
                    if (ret_val == 1) {
                        if (kbdd->kbdd_translate ==
                            TR_EVENT) {
                            fe.id =
                                (kbdd->kbdd_compat ?
                                ISO_FIRST :
                                EUC_FIRST)
                                + result_iso;
                            fe.value = 1;
                            kbdqueueevent(
                                kbdd,
                                &fe);
                        } else if (
                            kbdd->kbdd_translate ==
                            TR_ASCII)
                            kbdputcode(
                                result_iso,
                                q);
                    }
                }
            }
            return;
        } else if (k->k_state == FLTACCENT) {
            if (newstate == RELEASED)
                return;
            k->k_state = NORMAL;    /* next state is "normal" */
            for (i = 0;
                (kb_fltaccent_table[i].fa_entry
                != kbdd->fltaccent_entry) ||
                (kb_fltaccent_table[i].ascii != entry);
                i++) {
                if (kb_fltaccent_table[i].fa_entry == 0)
                    /* Invalid second key: ignore key */
                    return;
            }
            if (kbdd->kbdd_translate == TR_EVENT) {
                fe.id = (kbdd->kbdd_compat ?
                    ISO_FIRST : EUC_FIRST)
                    + kb_fltaccent_table[i].iso;
                fe.value = 1;
                kbdqueueevent(kbdd, &fe);
            } else if (kbdd->kbdd_translate == TR_ASCII)
                kbdputcode(kb_fltaccent_table[i].iso, q);
            return;
        }
    }

    /*
     * If the key is going down, and it's not one of the keys that doesn't
     * auto-repeat, set up the auto-repeat timeout.
     *
     * The keys that don't auto-repeat are the Compose key,
     * the shift keys, the "bucky bit" keys, the "floating accent" keys,
     * and the function keys when in TR_EVENT mode.
     */
    if (newstate == PRESSED && entrytype != (SHIFTKEYS >> 8) &&
        entrytype != (BUCKYBITS >> 8) && entrytype != (FUNNY >> 8) &&
        entrytype != (FA_CLASS >> 8) &&
        !((entrytype == (FUNCKEYS >> 8) || entrytype == (PADKEYS >> 8)) &&
        kbdd->kbdd_translate == TR_EVENT)) {
        if (k->k_rptkey != keycode) {
            kbdcancelrpt(kbdd);
            kbdd->kbdd_rptid = qtimeout(q, kbdrpt, kbdd,
                kbd_repeatdelay);
            k->k_rptkey = keycode;
        }
    } else if (key == KEYOF(k->k_rptkey))       /* key going up */
        kbdcancelrpt(kbdd);
    if ((newstate == RELEASED) && (kbdd->kbdd_translate == TR_EVENT))
        kbdkeyreleased(kbdd, key);

    /*
     * We assume here that keys other than shift keys and bucky keys have
     * entries in the "up" table that cause nothing to be done, and thus we
     * don't have to check for newstate == RELEASED.
     */
    switch (entrytype) {

    case 0x0:       /* regular key */
        switch (kbdd->kbdd_translate) {

        case TR_EVENT:
            fe.id = entry | k->k_buckybits;
            fe.value = 1;
            kbdkeypressed(kbdd, key, &fe, entry);
            break;

        case TR_ASCII:
            kbdputcode(entry | k->k_buckybits, q);
            break;
        }
        break;

    case SHIFTKEYS >> 8: {
        uint_t shiftbit = 1 << (entry & 0x0F);

        /* Modify toggle state (see toggle processing above) */
        if (shiftbit & k->k_curkeyboard->k_toggleshifts) {
            if (newstate == RELEASED) {
                if (shiftbit == CAPSMASK) {
                    kbdd->led_state &= ~LED_CAPS_LOCK;
                    kbdsetled(kbdd);
                } else if (shiftbit == NUMLOCKMASK) {
                    kbdd->led_state &= ~LED_NUM_LOCK;
                    kbdsetled(kbdd);
                }
                k->k_togglemask &= ~shiftbit;
            } else {
                if (shiftbit == CAPSMASK) {
                    kbdd->led_state |= LED_CAPS_LOCK;
                    kbdsetled(kbdd);
                } else if (shiftbit == NUMLOCKMASK) {
                    kbdd->led_state |= LED_NUM_LOCK;
                    kbdsetled(kbdd);
                }
                k->k_togglemask |= shiftbit;
            }
        }

        if (newstate == RELEASED)
            k->k_shiftmask &= ~shiftbit;
        else
            k->k_shiftmask |= shiftbit;

        if (kbdd->kbdd_translate == TR_EVENT && newstate == PRESSED) {
            /*
             * Relying on ordinal correspondence between
             * vuid_event.h SHIFT_CAPSLOCK-SHIFT_RIGHTCTRL &
             * kbd.h CAPSLOCK-RIGHTCTRL in order to
             * correctly translate entry into fe.id.
             */
            fe.id = SHIFT_CAPSLOCK + (entry & 0x0F);
            fe.value = 1;
            kbdkeypressed(kbdd, key, &fe, fe.id);
        }
        break;
        }

    case BUCKYBITS >> 8:
        k->k_buckybits ^= 1 << (7 + (entry & 0x0F));
        if (kbdd->kbdd_translate == TR_EVENT && newstate == PRESSED) {
            /*
             * Relying on ordinal correspondence between
             * vuid_event.h SHIFT_META-SHIFT_TOP &
             * kbd.h METABIT-SYSTEMBIT in order to
             * correctly translate entry into fe.id.
             */
            fe.id = SHIFT_META + (entry & 0x0F);
            fe.value = 1;
            kbdkeypressed(kbdd, key, &fe, fe.id);
        }
        break;

    case FUNNY >> 8:
        switch (entry) {
        case NOP:
            break;

        case IDLE:
            /* Fall thru into RESET code */
            /* FALLTHRU */
        case RESET:
        gotreset:
            k->k_shiftmask &= k->k_curkeyboard->k_idleshifts;
            k->k_shiftmask |= k->k_togglemask;
            k->k_buckybits &= k->k_curkeyboard->k_idlebuckys;
            kbdcancelrpt(kbdd);
            kbdreleaseall(kbdd);
            break;

        case ERROR:
            cmn_err(CE_WARN, "kbd: Error detected");
            goto gotreset;

        case COMPOSE:
            k->k_state = COMPOSE1;
            kbdd->led_state |= LED_COMPOSE;
            kbdsetled(kbdd);
            break;
        /*
         * Remember when adding new entries that,
         * if they should NOT auto-repeat,
         * they should be put into the IF statement
         * just above this switch block.
         */
        default:
            goto badentry;
        }
        break;

    case FA_CLASS >> 8:
        if (k->k_state == NORMAL) {
            kbdd->fltaccent_entry = entry;
            k->k_state = FLTACCENT;
        }
        return;

    case STRING >> 8:
        cp = &keystringtab[entry & 0x0F][0];
        while (*cp != '\0') {
            switch (kbdd->kbdd_translate) {

            case TR_EVENT:
                kbd_send_esc_event(*cp, kbdd);
                break;

            case TR_ASCII:
                kbdputcode((uchar_t)*cp, q);
                break;
            }
            cp++;
        }
        break;

    case FUNCKEYS >> 8:
        switch (kbdd->kbdd_translate) {

        case TR_ASCII:
            bufp = buf;
            cp = strsetwithdecimal(bufp + 2,
                (uint_t)((entry & 0x003F) + 192),
                sizeof (buf) - 5);
            *bufp++ = '\033'; /* Escape */
            *bufp++ = '[';
            while (*cp != '\0')
                *bufp++ = *cp++;
            *bufp++ = 'z';
            *bufp = '\0';
            kbdputbuf(buf, q);
            break;

        case TR_EVENT:
            /*
             * Take advantage of the similar
             * ordering of kbd.h function keys and
             * vuid_event.h function keys to do a
             * simple translation to achieve a
             * mapping between the 2 different
             * address spaces.
             */
            fe.id = (entry & 0x003F) + KEY_LEFTFIRST;
            fe.value = 1;
            /*
             * Assume "up" table only generates
             * shift changes.
             */
            kbdkeypressed(kbdd, key, &fe, fe.id);
            /*
             * Function key events can be expanded
             * by terminal emulator software to
             * produce the standard escape sequence
             * generated by the TR_ASCII case above
             * if a function key event is not used
             * by terminal emulator software
             * directly.
             */
            break;
        }
        break;

    /*
     * Remember when adding new entries that,
     * if they should NOT auto-repeat,
     * they should be put into the IF statement
     * just above this switch block.
     */
    case PADKEYS >> 8:
        switch (kbdd->kbdd_translate) {

        case TR_ASCII:
            kbdputcode(kb_numlock_table[entry&0x1F], q);
            break;

        case TR_EVENT:
            /*
             * Take advantage of the similar
             * ordering of kbd.h keypad keys and
             * vuid_event.h keypad keys to do a
             * simple translation to achieve a
             * mapping between the 2 different
             * address spaces.
             */
            fe.id = (entry & 0x001F) + VKEY_FIRSTPAD;
            fe.value = 1;
            /*
             * Assume "up" table only generates
             * shift changes.
             */
            kbdkeypressed(kbdd, key, &fe, fe.id);
            /*
             * Keypad key events can be expanded
             * by terminal emulator software to
             * produce the standard ascii character
             * generated by the TR_ASCII case above
             * if a keypad key event is not used
             * by terminal emulator software
             * directly.
             */
            break;
        }

    badentry:
        break;
    }
}

static int
kbd_do_compose(ushort_t first_entry, ushort_t second_entry,
    ushort_t *result_iso_ptr)
{
    struct compose_sequence_t *ptr;

    ptr = &kb_compose_table[kb_compose_map[first_entry]];
    while (ptr->first == first_entry) {
        if (ptr->second == second_entry) {
            *result_iso_ptr = ptr->iso;
            return (1);
        }
        ptr++;
    }
    return (0);
}

static void
kbd_send_esc_event(char c, register struct kbddata *kbdd)
{
    Firm_event fe;

    fe.id = c;
    fe.value = 1;
    fe.pair_type = FE_PAIR_NONE;
    fe.pair = 0;
    /*
     * Pretend as if each cp pushed and released
     * Calling kbdqueueevent avoids addr translation
     * and pair base determination of kbdkeypressed.
     */
    kbdqueueevent(kbdd, &fe);
    fe.value = 0;
    kbdqueueevent(kbdd, &fe);
}

char *
strsetwithdecimal(char *buf, uint_t val, uint_t maxdigs)
{
    int hradix = 5;
    char    *bp;
    int lowbit;
    char    *tab = "0123456789abcdef";

    bp = buf + maxdigs;
    *(--bp) = '\0';
    while (val) {
        lowbit = val & 1;
        val = (val >> 1);
        *(--bp) = tab[val % hradix * 2 + lowbit];
        val /= hradix;
    }
    return (bp);
}

static void
kbdkeypressed(struct kbddata *kbdd, uchar_t key_station, Firm_event *fe,
    ushort_t base)
{
    register struct keyboardstate *k;
    register short id_addr;

    /* Set pair values */
    if (fe->id < (ushort_t)VKEY_FIRST) {
        /*
         * If CTRLed, find the ID that would have been used had it
         * not been CTRLed.
         */
        k = &kbdd->kbdd_state;
        if (k->k_shiftmask & (CTRLMASK | CTLSMASK)) {
            struct keymap *km;

            km = settable(kbdd,
                k->k_shiftmask & ~(CTRLMASK | CTLSMASK | UPMASK));
            if (km == NULL)
                return;
            base = km->keymap[key_station];
        }
        if (base != fe->id) {
            fe->pair_type = FE_PAIR_SET;
            fe->pair = base;
            goto send;
        }
    }
    fe->pair_type = FE_PAIR_NONE;
    fe->pair = 0;
send:
    /* Adjust event id address for multiple keyboard/workstation support */
    switch (vuid_id_addr(fe->id)) {
    case ASCII_FIRST:
        id_addr = kbdd->kbdd_ascii_addr;
        break;
    case TOP_FIRST:
        id_addr = kbdd->kbdd_top_addr;
        break;
    case VKEY_FIRST:
        id_addr = kbdd->kbdd_vkey_addr;
        break;
    default:
        id_addr = vuid_id_addr(fe->id);
    }
    fe->id = vuid_id_offset(fe->id) | id_addr;
    kbdqueuepress(kbdd, key_station, fe);
}

static void
kbdqueuepress(struct kbddata *kbdd, uchar_t key_station, Firm_event *fe)
{
    register struct key_event *ke, *ke_free;
    register int i;

    if (key_station == IDLEKEY)
        return;
#ifdef  KBD_DEBUG
    if (kbd_input_debug) printf("KBD PRESSED key=%d\n", key_station);
#endif
    ke_free = 0;
    /* Scan table of down key stations */
    if (kbdd->kbdd_translate == TR_EVENT ||
        kbdd->kbdd_translate == TR_UNTRANS_EVENT) {
        for (i = 0, ke = kbdd->kbdd_downs;
            i < kbdd->kbdd_downs_entries;
            i++, ke++) {
            /* Keycode already down? */
            if (ke->key_station == key_station) {
#ifdef  KBD_DEBUG
    printf("kbd: Double entry in downs table (%d,%d)!\n", key_station, i);
#endif
                goto add_event;
            }
            if (ke->key_station == 0)
                ke_free = ke;
        }
        if (ke_free) {
            ke = ke_free;
            goto add_event;
        }
        cmn_err(CE_WARN, "kbd: Too many keys down!");
        ke = kbdd->kbdd_downs;
    }
add_event:
    ke->key_station = key_station;
    ke->event = *fe;
    kbdqueueevent(kbdd, fe);
}

static void
kbdkeyreleased(register struct kbddata *kbdd, uchar_t key_station)
{
    register struct key_event *ke;
    register int i;

    if (key_station == IDLEKEY)
        return;
#ifdef  KBD_DEBUG
    if (kbd_input_debug)
        printf("KBD RELEASE key=%d\n", key_station);
#endif
    if (kbdd->kbdd_translate != TR_EVENT &&
        kbdd->kbdd_translate != TR_UNTRANS_EVENT)
        return;
    /* Scan table of down key stations */
    for (i = 0, ke = kbdd->kbdd_downs;
        i < kbdd->kbdd_downs_entries;
        i++, ke++) {
        /* Found? */
        if (ke->key_station == key_station) {
            ke->key_station = 0;
            ke->event.value = 0;
            kbdqueueevent(kbdd, &ke->event);
        }
    }

    /*
     * Ignore if couldn't find because may be called twice
     * for the same key station in the case of the kbdrpt
     * routine being called unnecessarily.
     */
}

static void
kbdreleaseall(struct kbddata *kbdd)
{
    register struct key_event *ke;
    register int i;

#ifdef  KBD_DEBUG
    if (kbd_debug && kbd_ra_debug) printf("KBD RELEASE ALL\n");
#endif
    /* Scan table of down key stations */
    for (i = 0, ke = kbdd->kbdd_downs;
        i < kbdd->kbdd_downs_entries; i++, ke++) {
        /* Key station not zero */
        if (ke->key_station)
            kbdkeyreleased(kbdd, ke->key_station);
            /* kbdkeyreleased resets kbdd_downs entry */
    }
}

/*
 * Pass a keycode up the stream, if you can, otherwise throw it away.
 */
static void
kbdputcode(uint_t code, queue_t *q)
{
    register mblk_t *bp;

    if (!canput(q))
        cmn_err(CE_WARN, "kbdputcode: Can't put block for keycode");
    else {
        if ((bp = allocb(sizeof (uint_t), BPRI_HI)) == NULL)
            cmn_err(CE_WARN,
                "kbdputcode: Can't allocate block for keycode");
        else {
            *bp->b_wptr++ = code;
            putnext(q, bp);
        }
    }
}

/*
 * Pass  generated keycode sequence to upstream, if possible.
 */
static void
kbdputbuf(char *buf, queue_t *q)
{
    register mblk_t *bp;

    if (!canput(q))
        cmn_err(CE_WARN, "kbdputbuf: Can't put block for keycode");
    else {
        if ((bp = allocb((int)strlen(buf), BPRI_HI)) == NULL)
            cmn_err(CE_WARN,
                "kbdputbuf: Can't allocate block for keycode");
        else {
            while (*buf) {
                *bp->b_wptr++ = *buf;
                buf++;
            }
            putnext(q, bp);
        }
    }
}

/*
 * Pass a VUID "firm event" up the stream, if you can.
 */
static void
kbdqueueevent(struct kbddata *kbdd, Firm_event *fe)
{
    register queue_t *q;
    register mblk_t *bp;

    if ((q = kbdd->kbdd_readq) == NULL)
        return;
    if (!canput(q)) {
        if (kbd_overflow_msg)
            cmn_err(CE_WARN,
                "kbd: Buffer flushed when overflowed");
        kbdflush(kbdd);
        kbd_overflow_cnt++;
    } else {
        if ((bp = allocb(sizeof (Firm_event), BPRI_HI)) == NULL)
            cmn_err(CE_WARN,
                "kbdqueueevent: Can't allocate block for event");
        else {
#if 1 /* XX64 */
            struct timeval now;

            /*
             * XX64: This is something of a compromise.  It
             * seems justifiable based on the usage of these
             * timestamps as an ordering relation as opposed
             * to a strict timing thing.
             *
             * But should we restore Firm_event's time stamp
             * to be a timeval, and send 32-bit and 64-bit
             * events up the pipe?
             */
            uniqtime(&now);
            TIMEVAL_TO_TIMEVAL32(&fe->time, &now);
#else
            uniqtime(&fe->time);
#endif
            *(Firm_event *)bp->b_wptr = *fe;
            bp->b_wptr += sizeof (Firm_event);
            putnext(q, bp);
        }
    }
}