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>

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 */
};

#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	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);

	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);
	/*
	 * 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;

	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;

		kbdcmd(q, (char)(*(int *)mp->b_cont->b_rptr));
		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);
}

/*
 * 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;
				break;
			}
		}
#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;
				kbduse(kbdd, IDLEKEY);	/* fake */
				return;
			} else {
				kbduse(kbdd, k->k_curkeyboard->k_newabort1);
				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);
		}
	}
}