xref: /onnv/onnv-gate/usr/src/uts/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_S