xref: /illumos-gate/usr/src/uts/common/io/kb8042/kb8042.c (revision db335908e0bf7069476de0103b658d6962a6c751)

/*
 * 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 (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
/*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
/*	  All Rights Reserved	*/

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#define	KEYMAP_SIZE_VARIABLE

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/inline.h>
#include <sys/termio.h>
#include <sys/stropts.h>
#include <sys/termios.h>
#include <sys/stream.h>
#include <sys/strtty.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/note.h>
#include "sys/consdev.h"
#include <sys/kbd.h>
#include <sys/kbtrans.h>
#include "kb8042.h"

#include <sys/i8042.h>

#include "sys/kbio.h"		/* for KIOCSLAYOUT */
#include "sys/stat.h"
#include "sys/reboot.h"
#include <sys/promif.h>
#include <sys/beep.h>
#include <sys/inttypes.h>
#include <sys/policy.h>

/*
 * For any keyboard, there is a unique code describing the position
 * of the key on a keyboard. We refer to the code as "station number".
 * The following table is used to map the station numbers from ps2
 * AT/XT keyboards to that of a USB one.
 *
 * A mapping was added for entry K8042_STOP, to map to USB key code 120 (which
 * maps to the STOP key) when in KB_USB mode, and maps to a HOLE entry
 * when in KB_PC mode.  Note that this does not need to be made conditional
 * on the architecture for which this module is complied because there are no
 * keys that map to K8042_STOP on non-SPARC platforms.
 */
static kbtrans_key_t keytab_pc2usb[KBTRANS_KEYNUMS_MAX] = {
/*  0 */	0,	53,	30,	31,	32,	33,	34,	35,
/*  8 */	36,	37,	38,	39,	45,	46,	137,	42,
/* 16 */	43,	20,	26,	8,	21,	23,	28,	24,
/* 24 */	12,	18,	19,	47,	48,	49,	57,	4,
/* 32 */	22,	7,	9,	10,	11,	13,	14,	15,
/* 40 */	51,	52,	50,	40,	225,	100,	29,	27,
/* 48 */	6,	25,	5,	17,	16,	54,	55,	56,
/* 56 */	135,	229,	224,	227,	226,	44,	230,	231,
/* 64 */	228,	101,	0,	0,	0,	0,	0,	0,
/* 72 */	0,	0,	0,	73,	76,	0,	0,	80,
/* 80 */	74,	77,	0,	82,	81,	75,	78,	0,
/* 88 */	0,	79,	83,	95,	92,	89,	0,	84,
/* 96 */	96,	93,	90,	98,	85,	97,	94,	91,
/* 104 */	99,	86,	87,	133,	88,	0,	41,	0,
/* 112 */	58,	59,	60,	61,	62,	63,	64,	65,
/* 120 */	66,	67,	68,	69,	70,	71,	72,	0,
/* 128 */	0,	0,	0,	139,	138,	136,	0,	0,
/* 136 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 144 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 152 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 160 */	120,	0,	0,	0,	0,	0,	0,	0,
/* 168 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 176 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 184 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 192 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 200 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 208 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 216 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 224 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 232 */	0,	128,	129,	127,	0,	0,	0,	0,
/* 240 */	0,	0,	0,	0,	0,	0,	0,	0,
/* 248 */	0,	0,	0,	0
};

#ifdef __sparc
#define	USECS_PER_WAIT 100
#define	MAX_WAIT_USECS 100000 /* in usecs = 100 ms */
#define	MIN_DELAY_USECS USECS_PER_WAIT

boolean_t kb8042_warn_unknown_scanset = B_TRUE;
int kb8042_default_scanset = 2;

#endif

#define	MAX_KB8042_WAIT_MAX_MS	500		/* 500ms total */
#define	MAX_KB8042_RETRIES	5

enum state_return { STATE_NORMAL, STATE_INTERNAL };

static void kb8042_init(struct kb8042 *kb8042, boolean_t from_resume);
static uint_t kb8042_intr(caddr_t arg);
static void kb8042_wait_poweron(struct kb8042 *kb8042);
static void kb8042_send_to_keyboard(struct kb8042 *, int, boolean_t);
static int kb8042_xlate_leds(int);
static void kb8042_setled(struct kb8042 *, int led_state, boolean_t polled);
static void kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state);
static void kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state);
static boolean_t kb8042_polled_keycheck(
			struct kbtrans_hardware *hw, int *key,
			enum keystate *state);
static void kb8042_get_initial_leds(struct kb8042 *, int *, int *);
static boolean_t kb8042_autorepeat_detect(struct kb8042 *kb8042, int key_pos,
			enum keystate state);
static void kb8042_type4_cmd(struct kb8042 *kb8042, int cmd);
static void kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *, mblk_t *);
static void kb8042_iocdatamsg(queue_t *, mblk_t *);
static void kb8042_process_key(struct kb8042 *, kbtrans_key_t, enum keystate);
static int kb8042_polled_ischar(cons_polledio_arg_t arg);
static int kb8042_polled_getchar(cons_polledio_arg_t arg);
static void kb8042_cleanup(struct kb8042 *kb8042);
static void kb8042_received_byte(struct kb8042 *, int);

static struct kbtrans_callbacks kb8042_callbacks = {
	kb8042_streams_setled,
	kb8042_polled_setled,
	kb8042_polled_keycheck,
};

extern struct keyboard keyindex_pc;

#define	DRIVER_NAME(dip) ddi_driver_name(dip)

static	char	module_name[] = "kb8042";

static int kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag,
			cred_t *credp);
static int kb8042_close(queue_t *qp, int flag, cred_t *credp);
static int kb8042_rsrv(queue_t *);
static int kb8042_wsrv(queue_t *);

struct module_info kb8042_sinfo = {
	.mi_idnum = 42,			/* Module ID */
	.mi_idname = module_name,	/* Module name */
	.mi_minpsz = 0,			/* Minimum packet size */
	.mi_maxpsz = 32,		/* Maximum packet size */
	.mi_hiwat = 256,		/* High water mark */
	.mi_lowat = 128			/* Low water mark */
};

static struct qinit kb8042_rinit = {
	.qi_putp = NULL,
	.qi_srvp = kb8042_rsrv,
	.qi_qopen = kb8042_open,
	.qi_qclose = kb8042_close,
	.qi_qadmin = NULL,
	.qi_minfo = &kb8042_sinfo,
	.qi_mstat = NULL,
	.qi_rwp = NULL,
	.qi_infop = NULL,
	.qi_struiot = 0
};

static struct qinit kb8042_winit = {
	.qi_putp = putq,
	.qi_srvp = kb8042_wsrv,
	.qi_qopen = kb8042_open,
	.qi_qclose = kb8042_close,
	.qi_qadmin = NULL,
	.qi_minfo = &kb8042_sinfo,
	.qi_mstat = NULL,
	.qi_rwp = NULL,
	.qi_infop = NULL,
	.qi_struiot = 0
};

struct streamtab kb8042_str_info = {
	.st_rdinit = &kb8042_rinit,
	.st_wrinit = &kb8042_winit,
	.st_muxrinit = NULL,
	.st_muxwinit = NULL
};

struct kb8042	Kdws = {0};
static dev_info_t *kb8042_dip = NULL;

static int kb8042_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
		void **result);
static int kb8042_attach(dev_info_t *, ddi_attach_cmd_t);
static int kb8042_detach(dev_info_t *, ddi_detach_cmd_t);

static struct cb_ops cb_kb8042_ops = {
	.cb_open = nulldev,
	.cb_close = nulldev,
	.cb_strategy = nodev,
	.cb_print = nodev,
	.cb_dump = nodev,
	.cb_read = nodev,
	.cb_write = nodev,
	.cb_ioctl = nodev,
	.cb_devmap = nodev,
	.cb_mmap = nodev,
	.cb_segmap = nodev,
	.cb_chpoll = nochpoll,
	.cb_prop_op = ddi_prop_op,
	.cb_str = &kb8042_str_info,
	.cb_flag = D_MP,
	.cb_rev = CB_REV,
	.cb_aread = nodev,
	.cb_awrite = nodev
};

struct dev_ops kb8042_ops = {
	.devo_rev = DEVO_REV,
	.devo_refcnt = 0,
	.devo_getinfo = kb8042_getinfo,
	.devo_identify = nulldev,
	.devo_probe = nulldev,
	.devo_attach = kb8042_attach,
	.devo_detach = kb8042_detach,
	.devo_reset = nodev,
	.devo_cb_ops = &cb_kb8042_ops,
	.devo_bus_ops = NULL,
	.devo_power = NULL,
	.devo_quiesce = ddi_quiesce_not_needed
};


/*
 * This is the loadable module wrapper.
 */
#include <sys/modctl.h>

/*
 * Module linkage information for the kernel.
 */
static struct modldrv modldrv = {
	.drv_modops = &mod_driverops,	/* Type of module. */
	.drv_linkinfo = "PS/2 keyboard driver",
	.drv_dev_ops = &kb8042_ops,	/* driver ops */
};

static struct modlinkage modlinkage = {
	.ml_rev = MODREV_1,
	.ml_linkage = { &modldrv, NULL }
};

int
_init(void)
{
	int	rv;

	rv = mod_install(&modlinkage);
	return (rv);
}


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

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

#ifdef __sparc
static boolean_t
kb8042_is_input_avail(struct kb8042 *kb8042, int timeout_usec, boolean_t polled)
{
	int i;
	int port = (polled == B_TRUE) ? I8042_POLL_INPUT_AVAIL :
	    I8042_INT_INPUT_AVAIL;
	int reps = timeout_usec / USECS_PER_WAIT;

	for (i = 0; i < reps; i++) {
		if (ddi_get8(kb8042->handle, kb8042->addr + port) != 0)
			return (B_TRUE);

		if (i < (reps - 1))
			drv_usecwait(USECS_PER_WAIT);
	}
	return (B_FALSE);
}

static void
kb8042_clear_input_buffer(struct kb8042 *kb8042, boolean_t polled)
{
	int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA :
	    I8042_INT_INPUT_DATA;

	while (kb8042_is_input_avail(kb8042, MIN_DELAY_USECS, polled)) {
		(void) ddi_get8(kb8042->handle, kb8042->addr + port);
	}
}

/*
 * kb8042_send_and_expect does all its I/O via polling interfaces
 */
static boolean_t
kb8042_send_and_expect(struct kb8042 *kb8042, uint8_t send, uint8_t expect,
    int timeout, int *error, uint8_t *got)
{
	uint8_t datab;
	int err;
	boolean_t rval;

	ddi_put8(kb8042->handle,
	    kb8042->addr + I8042_POLL_OUTPUT_DATA, send);

	if (kb8042_is_input_avail(kb8042, timeout, B_TRUE)) {
		err = 0;
		datab = ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_POLL_INPUT_DATA);
		rval = ((datab == expect) ? B_TRUE : B_FALSE);
	} else {
		err = EAGAIN;
		rval = B_FALSE;
	}

	if (error != NULL)
		*error = err;
	if (got != NULL)
		*got = datab;
	return (rval);
}

static const char *
kb8042_error_string(int errcode)
{
	switch (errcode) {
	case EAGAIN:
		return ("Timed out");
	default:
		return ("Unknown error");
	}
}

/*
 * kb8042_read_scanset works properly because it is called before ddi_add_intr
 * (if it is called after ddi_add_intr, i8042_intr would call kb8042_intr
 * instead of just storing the data that comes in from the keyboard, which
 * would prevent the code here from getting it.)
 */
static int
kb8042_read_scanset(struct kb8042 *kb8042)
{
	int scanset = -1;
	int err;
	uint8_t got;

	kb8042_clear_input_buffer(kb8042, B_TRUE);

	/*
	 * Send a "change scan code set" command to the keyboard.
	 * It should respond with an ACK.
	 */
	if (kb8042_send_and_expect(kb8042, KB_SET_SCAN, KB_ACK, MAX_WAIT_USECS,
	    &err, &got) != B_TRUE) {
		goto fail_read_scanset;
	}

	/*
	 * Send a 0.  The keyboard should ACK the 0, then it should send the
	 * scan code set in use.
	 */
	if (kb8042_send_and_expect(kb8042, 0, KB_ACK, MAX_WAIT_USECS, &err,
	    &got) != B_TRUE) {
		goto fail_read_scanset;
	}

	/*
	 * The next input byte from the keyboard should be the scan code
	 * set in use, though some keyboards like to send a few more acks
	 * just for fun, so blow past those to get the keyboard scan code.
	 */
	while (kb8042_is_input_avail(kb8042, MAX_WAIT_USECS, B_TRUE) &&
	    (scanset = ddi_get8(kb8042->handle,
	    kb8042->addr + I8042_POLL_INPUT_DATA)) == KB_ACK)
		;

#ifdef DEBUG
	cmn_err(CE_NOTE, "!Scan code set from keyboard is `%d'.",
	    scanset);
#endif

	return (scanset);

fail_read_scanset:
#ifdef DEBUG
	if (err == 0)
		cmn_err(CE_NOTE, "Could not read current scan set from "
		    "keyboard: %s. (Expected 0x%x, but got 0x%x).",
		    kb8042_error_string(err), KB_ACK, got);
	else
		cmn_err(CE_NOTE, "Could not read current scan set from "
		    "keyboard: %s.", kb8042_error_string(err));
#endif
	return (-1);
}
#endif

static int
kb8042_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
	int	rc;
	int	scanset;
	int	leds;

	struct kb8042	*kb8042 = &Kdws;
	static ddi_device_acc_attr_t attr = {
		DDI_DEVICE_ATTR_V0,
		DDI_NEVERSWAP_ACC,
		DDI_STRICTORDER_ACC,
	};

	switch (cmd) {
	case DDI_RESUME:
		leds = kb8042->leds.commanded;
		kb8042->w_init = 0;
		kb8042_init(kb8042, B_TRUE);
		kb8042_setled(kb8042, leds, B_FALSE);
		mutex_enter(&kb8042->w_hw_mutex);
		kb8042->suspended = B_FALSE;
		if (kb8042->w_qp != NULL) {
			enableok(WR(kb8042->w_qp));
			qenable(WR(kb8042->w_qp));
		}
		cv_broadcast(&kb8042->suspend_cv);
		mutex_exit(&kb8042->w_hw_mutex);
		return (DDI_SUCCESS);

	case DDI_ATTACH:
		if (kb8042_dip != NULL)
			return (DDI_FAILURE);
		/* The rest of the function is for attach */
		break;

	default:
		return (DDI_FAILURE);
	}

	kb8042->debugger.mod1 = 58;	/* Left Ctrl */
	kb8042->debugger.mod2 = 60;	/* Left Alt */
	kb8042->debugger.trigger = 33;	/* D */
	kb8042->debugger.mod1_down = B_FALSE;
	kb8042->debugger.mod2_down = B_FALSE;
	kb8042->debugger.enabled = B_FALSE;

	kb8042_dip = devi;
	kb8042->init_state = KB8042_UNINITIALIZED;

	kb8042->polled_synthetic_release_pending = B_FALSE;

	if (ddi_create_minor_node(devi, module_name, S_IFCHR, 0,
	    DDI_NT_KEYBOARD, 0) == DDI_FAILURE) {
		goto failure;
	}

	kb8042->init_state |= KB8042_MINOR_NODE_CREATED;

	rc = ddi_regs_map_setup(devi, 0, (caddr_t *)&kb8042->addr,
	    (offset_t)0, (offset_t)0, &attr, &kb8042->handle);
	if (rc != DDI_SUCCESS) {
#ifdef DEBUG
		cmn_err(CE_WARN, "kb8042_attach:  can't map registers");
#endif
		goto failure;
	}

	kb8042->init_state |= KB8042_REGS_MAPPED;

	if (ddi_get_iblock_cookie(devi, 0, &kb8042->w_iblock) !=
	    DDI_SUCCESS) {
		cmn_err(CE_WARN, "kb8042_attach:  Can't get iblock cookie");
		goto failure;
	}

	mutex_init(&kb8042->w_hw_mutex, NULL, MUTEX_DRIVER, kb8042->w_iblock);
	cv_init(&kb8042->ops_cv, NULL, CV_DRIVER, NULL);
	cv_init(&kb8042->suspend_cv, NULL, CV_DRIVER, NULL);
	cv_init(&kb8042->cmd_cv, NULL, CV_DRIVER, NULL);
	kb8042->init_state |= KB8042_HW_MUTEX_INITTED;

	kb8042_init(kb8042, B_FALSE);

#ifdef __sparc
	/* Detect the scan code set currently in use */
	scanset = kb8042_read_scanset(kb8042);

	if (scanset < 0 && kb8042_warn_unknown_scanset) {

		cmn_err(CE_WARN, "Cannot determine keyboard scan code set ");
		cmn_err(CE_CONT, "(is the keyboard plugged in?). ");
		cmn_err(CE_CONT, "Defaulting to scan code set %d.  If the "
		    "keyboard does not ", kb8042_default_scanset);
		cmn_err(CE_CONT, "work properly, add "
		    "`set kb8042:kb8042_default_scanset=%d' to /etc/system ",
		    (kb8042_default_scanset == 1) ? 2 : 1);
		cmn_err(CE_CONT, "(via network or with a USB keyboard) and "
		    "restart the system.  If you ");
		cmn_err(CE_CONT, "do not want to see this message in the "
		    "future, add ");
		cmn_err(CE_CONT, "`set kb8042:kb8042_warn_unknown_scanset=0' "
		    "to /etc/system.\n");

		/* Use the default scan code set. */
		scanset = kb8042_default_scanset;
	}
#else
	/* x86 systems use scan code set 1 -- no detection required */
	scanset = 1;
#endif
	if (KeyboardConvertScan_init(kb8042, scanset) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "Cannot initialize keyboard scan converter: "
		    "Unknown scan code set `%d'.", scanset);
		/* Scan code set is not supported */
		goto failure;
	}

	/*
	 * Turn on interrupts...
	 */
	if (ddi_add_intr(devi, 0,
	    &kb8042->w_iblock, (ddi_idevice_cookie_t *)NULL,
	    kb8042_intr, (caddr_t)kb8042) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "kb8042_attach: cannot add interrupt");
		goto failure;
	}

	kb8042->init_state |= KB8042_INTR_ADDED;

	ddi_report_dev(devi);

#ifdef DEBUG
	cmn_err(CE_CONT, "?%s instance #%d READY\n",
	    DRIVER_NAME(devi), ddi_get_instance(devi));
#endif

	return (DDI_SUCCESS);

failure:
	kb8042_cleanup(kb8042);
	return (DDI_FAILURE);
}

static int
kb8042_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	struct kb8042 *kb8042 = &Kdws;

	switch (cmd) {
	case DDI_SUSPEND:
		mutex_enter(&kb8042->w_hw_mutex);
		ASSERT(kb8042->ops >= 0);
		while (kb8042->ops > 0)
			cv_wait(&kb8042->ops_cv, &kb8042->w_hw_mutex);
		kb8042->suspended = B_TRUE;
		mutex_exit(&kb8042->w_hw_mutex);
		return (DDI_SUCCESS);

	case DDI_DETACH:
		/* If someone has a stream open, fail to detach */
		if (kb8042->w_qp != NULL)
			return (DDI_FAILURE);

		ASSERT(kb8042_dip == dip);

		kb8042_cleanup(kb8042);

		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

static int
kb8042_getinfo(dev_info_t *dip __unused, ddi_info_cmd_t infocmd,
    void *arg __unused, void **result)
{
	int error;

	switch (infocmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (kb8042_dip == NULL) {
			error = DDI_FAILURE;
		} else {
			*result = (void *) kb8042_dip;
			error = DDI_SUCCESS;
		}
		break;
	case DDI_INFO_DEVT2INSTANCE:
		if (kb8042_dip == NULL) {
			error = DDI_FAILURE;
		} else {
			int instance;

			instance = ddi_get_instance(kb8042_dip);
			*result = (void *)(uintptr_t)instance;
			error = DDI_SUCCESS;
		}
		break;
	default:
		error = DDI_FAILURE;
		break;
	}
	return (error);
}

static void
kb8042_cleanup(struct kb8042 *kb8042)
{
	ASSERT(kb8042_dip != NULL);

	if (kb8042->init_state & KB8042_INTR_ADDED)
		ddi_remove_intr(kb8042_dip, 0, kb8042->w_iblock);

	if (kb8042->init_state & KB8042_HW_MUTEX_INITTED) {
		cv_destroy(&kb8042->cmd_cv);
		cv_destroy(&kb8042->suspend_cv);
		cv_destroy(&kb8042->ops_cv);
		mutex_destroy(&kb8042->w_hw_mutex);
	}

	if (kb8042->init_state & KB8042_REGS_MAPPED)
		ddi_regs_map_free(&kb8042->handle);

	if (kb8042->init_state & KB8042_MINOR_NODE_CREATED)
		ddi_remove_minor_node(kb8042_dip, NULL);

	kb8042->init_state = KB8042_UNINITIALIZED;
	kb8042_dip = NULL;
}

static void
kb8042_init(struct kb8042 *kb8042, boolean_t from_resume)
{
	if (kb8042->w_init)
		return;

	if (!from_resume) {
		kb8042->w_kblayout = 0;	/* Default to US */
		kb8042->w_qp = (queue_t *)NULL;
		kb8042->simulated_kbd_type = KB_PC;
		kb8042->leds.commanded = -1;	/* Unknown initial state */
		kb8042->leds.desired = -1;	/* Unknown initial state */
	}

	kb8042_wait_poweron(kb8042);

	kb8042->kb_old_key_pos = 0;

	/*
	 * Explicitly grab and release the 8042 lock outside of
	 * kb8042_send_to_keyboard, because this is the only situation
	 * where a polling interface is used with locking required.
	 */
	(void) ddi_get8(kb8042->handle, kb8042->addr + I8042_LOCK);
	/* Set up the command state machine and start it running. */
	kb8042_send_to_keyboard(kb8042, KB_ENABLE, B_TRUE);
	(void) ddi_get8(kb8042->handle, kb8042->addr + I8042_UNLOCK);

	kb8042->w_init++;

	(void) drv_setparm(SYSRINT, 1);	/* reset keyboard interrupts */
}

/*ARGSUSED2*/
static int
kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, cred_t *credp)
{
	struct kb8042	*kb8042;
	int err = 0;
	int initial_leds;
	int initial_led_mask;

	kb8042 = &Kdws;

	mutex_enter(&kb8042->w_hw_mutex);
	if (qp->q_ptr) {
		kb8042->w_dev = *devp;
		mutex_exit(&kb8042->w_hw_mutex);
		return (0);
	}

	if (secpolicy_console(credp) != 0) {
		mutex_exit(&kb8042->w_hw_mutex);
		return (EPERM);
	}

	while (kb8042->suspended) {
		if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) ==
		    0) {
			mutex_exit(&kb8042->w_hw_mutex);
			return (EINTR);
		}
	}

	kb8042->w_dev = *devp;
	qp->q_ptr = (caddr_t)kb8042;
	WR(qp)->q_ptr = qp->q_ptr;
	if (!kb8042->w_qp)
		kb8042->w_qp = qp;

	ASSERT(kb8042->ops >= 0);
	kb8042->ops++;
	mutex_exit(&kb8042->w_hw_mutex);

	kb8042_get_initial_leds(kb8042, &initial_leds, &initial_led_mask);
	err = kbtrans_streams_init(qp, sflag,
	    (struct kbtrans_hardware *)kb8042, &kb8042_callbacks,
	    &kb8042->hw_kbtrans,
	    initial_leds, initial_led_mask);
	if (err != 0)
		goto out;

	kbtrans_streams_set_keyboard(kb8042->hw_kbtrans, KB_PC, &keyindex_pc);

	kb8042->polledio.cons_polledio_version = CONSPOLLEDIO_V1;
	kb8042->polledio.cons_polledio_argument =
	    (cons_polledio_arg_t)kb8042;
	kb8042->polledio.cons_polledio_putchar = NULL;
	kb8042->polledio.cons_polledio_getchar =
	    (int (*)(cons_polledio_arg_t))kb8042_polled_getchar;
	kb8042->polledio.cons_polledio_ischar =
	    (boolean_t (*)(cons_polledio_arg_t))kb8042_polled_ischar;
	kb8042->polledio.cons_polledio_enter = NULL;
	kb8042->polledio.cons_polledio_exit = NULL;
	kb8042->polledio.cons_polledio_setled =
	    (void (*)(cons_polledio_arg_t, int))kb8042_polled_setled;
	kb8042->polledio.cons_polledio_keycheck =
	    (boolean_t (*)(cons_polledio_arg_t, int *,
	    enum keystate *))kb8042_polled_keycheck;

	qprocson(qp);

	kbtrans_streams_enable(kb8042->hw_kbtrans);

out:
	mutex_enter(&kb8042->w_hw_mutex);
	ASSERT(kb8042->ops > 0);
	kb8042->ops--;
	if (kb8042->ops == 0)
		cv_broadcast(&kb8042->ops_cv);
	mutex_exit(&kb8042->w_hw_mutex);

	return (err);
}

/*ARGSUSED1*/
static int
kb8042_close(queue_t *qp, int flag, cred_t *credp)
{
	struct kb8042	*kb8042;

	/* If a beep is in progress, stop that */
	(void) beeper_off();

	kb8042 = (struct kb8042 *)qp->q_ptr;

	mutex_enter(&kb8042->w_hw_mutex);
	while (kb8042->suspended) {
		if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) ==
		    0) {
			mutex_exit(&kb8042->w_hw_mutex);
			return (EINTR);
		}
	}

	ASSERT(kb8042->ops >= 0);
	kb8042->ops++;
	mutex_exit(&kb8042->w_hw_mutex);

	(void) kbtrans_streams_fini(kb8042->hw_kbtrans);

	kb8042->w_qp = (queue_t *)NULL;
	qprocsoff(qp);

	mutex_enter(&kb8042->w_hw_mutex);
	ASSERT(kb8042->ops > 0);
	kb8042->ops--;
	if (kb8042->ops == 0)
		cv_broadcast(&kb8042->ops_cv);
	mutex_exit(&kb8042->w_hw_mutex);

	return (0);
}

static int
kb8042_rsrv(queue_t *qp)
{
	mblk_t *mp;
	struct kb8042 *kb8042;

	while ((mp = getq(qp)) != NULL) {
		if (mp->b_datap->db_type == M_DATA) {
			kb8042 = (struct kb8042 *)qp->q_ptr;
			kb8042_received_byte(kb8042, *mp->b_rptr);
		}
		freemsg(mp);
	}
	return (0);
}

static int
kb8042_wsrv(queue_t *qp)
{
	struct kb8042 *kb8042;

	mblk_t	*mp;
	boolean_t suspended;

	kb8042 = (struct kb8042 *)qp->q_ptr;

	mutex_enter(&kb8042->w_hw_mutex);
	suspended = kb8042->suspended;
	ASSERT(kb8042->ops >= 0);
	if (!suspended)
		kb8042->ops++;
	mutex_exit(&kb8042->w_hw_mutex);

#ifdef NO_KB_DEBUG
	while (!suspended && (mp = getq(qp)) != NULL) {
#else
	/*
	 * Not taking keyboard input while suspending can make debugging
	 * difficult.  However, we still do the ops counting so that we
	 * don't suspend at a bad time.
	 */
	while ((mp = getq(qp))) {
#endif
		switch (kbtrans_streams_message(kb8042->hw_kbtrans, mp)) {
		case KBTRANS_MESSAGE_HANDLED:
			continue;
		case KBTRANS_MESSAGE_NOT_HANDLED:
			break;
		}
		switch (mp->b_datap->db_type) {
		case M_IOCTL:
			kb8042_ioctlmsg(kb8042, qp, mp);
			continue;
		case M_IOCDATA:
			kb8042_iocdatamsg(qp, mp);
			continue;
		case M_DELAY:
		case M_STARTI:
		case M_STOPI:
		case M_READ:	/* ignore, no buffered data */
			freemsg(mp);
			continue;
		case M_FLUSH:
			*mp->b_rptr &= ~FLUSHW;
			if (*mp->b_rptr & FLUSHR)
				qreply(qp, mp);
			else
				freemsg(mp);
			continue;
		default:
			cmn_err(CE_NOTE, "kb8042_wsrv: bad msg %x",
			    mp->b_datap->db_type);
			freemsg(mp);
			continue;
		}
	}

	mutex_enter(&kb8042->w_hw_mutex);
	if (!suspended) {
		ASSERT(kb8042->ops > 0);
		kb8042->ops--;
		if (kb8042->ops == 0)
			cv_broadcast(&kb8042->ops_cv);
	}
	mutex_exit(&kb8042->w_hw_mutex);

	return (0);
}

static void
kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *qp, mblk_t *mp)
{
	struct iocblk	*iocp;
	mblk_t		*datap;
	int		error;
	int		tmp;
	int		cycles;
	int		frequency;
	int		msecs;

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

	switch (iocp->ioc_cmd) {

	case CONSOPENPOLLEDIO:
		error = miocpullup(mp, sizeof (struct cons_polledio *));
		if (error != 0) {
			miocnak(qp, mp, 0, error);
			return;
		}

		/*
		 * We are given an appropriate-sized data block,
		 * and return a pointer to our structure in it.
		 */
		*(struct cons_polledio **)mp->b_cont->b_rptr =
		    &kb8042->polledio;
		mp->b_datap->db_type = M_IOCACK;
		iocp->ioc_error = 0;
		qreply(qp, mp);
		break;

	case CONSCLOSEPOLLEDIO:
		miocack(qp, mp, 0, 0);
		break;

	case CONSSETABORTENABLE:
		if (iocp->ioc_count != TRANSPARENT) {
			miocnak(qp, mp, 0, EINVAL);
			return;
		}

		kb8042->debugger.enabled = *(intptr_t *)mp->b_cont->b_rptr;
		miocack(qp, mp, 0, 0);
		break;

	/*
	 * Valid only in TR_UNTRANS_MODE mode.
	 */
	case CONSSETKBDTYPE:
		error = miocpullup(mp, sizeof (int));
		if (error != 0) {
			miocnak(qp, mp, 0, error);
			return;
		}
		tmp =  *(int *)mp->b_cont->b_rptr;
		if (tmp != KB_PC && tmp != KB_USB) {
			miocnak(qp, mp, 0, EINVAL);
			break;
		}
		kb8042->simulated_kbd_type = tmp;
		miocack(qp, mp, 0, 0);
		break;

	case KIOCLAYOUT:
		if (kb8042->w_kblayout == -1) {
			miocnak(qp, mp, 0, EINVAL);
			return;
		}

		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
			miocnak(qp, mp, 0, ENOMEM);
			return;
		}

		if (kb8042->simulated_kbd_type == KB_USB)
			*(int *)datap->b_wptr = KBTRANS_USBKB_DEFAULT_LAYOUT;
		else
			*(int *)datap->b_wptr = kb8042->w_kblayout;

		datap->b_wptr += sizeof (int);
		if (mp->b_cont)
			freemsg(mp->b_cont);
		mp->b_cont = datap;
		iocp->ioc_count = sizeof (int);
		mp->b_datap->db_type = M_IOCACK;
		iocp->ioc_error = 0;
		qreply(qp, mp);
		break;

	case KIOCSLAYOUT:
		if (iocp->ioc_count != TRANSPARENT) {
			miocnak(qp, mp, 0, EINVAL);
			return;
		}

		kb8042->w_kblayout = *(intptr_t *)mp->b_cont->b_rptr;
		miocack(qp, mp, 0, 0);
		break;

	case KIOCCMD:
		error = miocpullup(mp, sizeof (int));
		if (error != 0) {
			miocnak(qp, mp, 0, error);
			return;
		}

		kb8042_type4_cmd(kb8042, *(int *)mp->b_cont->b_rptr);
		miocack(qp, mp, 0, 0);
		break;

	case KIOCMKTONE:
		if (iocp->ioc_count != TRANSPARENT) {
			miocnak(qp, mp, 0, EINVAL);
			return;
		}

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

		error = beep_mktone(frequency, msecs);
		if (error != 0)
			miocnak(qp, mp, 0, error);
		else
			miocack(qp, mp, 0, 0);
		break;

	default:
#ifdef DEBUG1
		cmn_err(CE_NOTE, "!kb8042_ioctlmsg %x", iocp->ioc_cmd);
#endif
		miocnak(qp, mp, 0, EINVAL);
		return;
	}
}

/*
 * Process a byte received from the keyboard
 */
static void
kb8042_received_byte(
	struct kb8042	*kb8042,
	int		scancode)	/* raw scan code */
{
	boolean_t	legit;		/* is this a legit key pos'n? */
	int		key_pos = -1;
	enum keystate	state;
	boolean_t	synthetic_release_needed;

	if (!kb8042->w_init)	/* can't do anything anyway */
		return;

	legit = KeyboardConvertScan(kb8042, scancode, &key_pos, &state,
	    &synthetic_release_needed);

	if (legit == 0) {
		/* Eaten by translation */
		return;
	}

	/*
	 * Don't know if we want this permanently, but it seems interesting
	 * for the moment.
	 */
	if (key_pos == kb8042->debugger.mod1) {
		kb8042->debugger.mod1_down = (state == KEY_PRESSED);
	}
	if (key_pos == kb8042->debugger.mod2) {
		kb8042->debugger.mod2_down = (state == KEY_PRESSED);
	}
	if (kb8042->debugger.enabled &&
	    key_pos == kb8042->debugger.trigger &&
	    kb8042->debugger.mod1_down &&
	    kb8042->debugger.mod2_down) {
		/*
		 * Require new presses of the modifiers.
		 */
		kb8042->debugger.mod1_down = B_FALSE;
		kb8042->debugger.mod2_down = B_FALSE;
		abort_sequence_enter(NULL);
		return;
	}

	/*
	 * If there's no queue above us - as can happen if we've been
	 * attached but not opened - drop the keystroke.
	 * Note that we do this here instead of above so that
	 * Ctrl-Alt-D still works.
	 */
	if (kb8042->w_qp == NULL) {
		return;
	}

	/*
	 * This is to filter out auto repeat since it can't be
	 * turned off at the hardware.  (Yeah, yeah, PS/2 keyboards
	 * can.  Don't know whether they've taken over the world.
	 * Don't think so.)
	 */
	if (kb8042_autorepeat_detect(kb8042, key_pos, state)) {
		return;
	}


	kb8042_process_key(kb8042, key_pos, state);

	/*
	 * This is a total hack.  For some stupid reason, the two additional
	 * keys on Korean keyboards (Hangul and Hangul/Hanja) report press
	 * only.  We synthesize a release immediately.
	 */
	if (synthetic_release_needed) {
		(void) kb8042_autorepeat_detect(kb8042, key_pos, KEY_RELEASED);
		kb8042_process_key(kb8042, key_pos, state);
	}
}


static void
kb8042_process_key(struct kb8042 *kb8042, kbtrans_key_t key_pos,
    enum keystate state)
{
	kbtrans_key_t key;

	ASSERT(key_pos >= 0 && key_pos <= 255);
	if (kb8042->simulated_kbd_type == KB_PC) {
		kbtrans_streams_key(kb8042->hw_kbtrans, key_pos, state);
	} else if (kb8042->simulated_kbd_type == KB_USB) {
		key = keytab_pc2usb[key_pos];
		if (key != 0) {
			kbtrans_streams_key(kb8042->hw_kbtrans, key, state);
		}
	}
}

/*
 * Called from interrupt handler when keyboard interrupt occurs.
 */
static uint_t
kb8042_intr(caddr_t arg)
{
	uchar_t scancode;	/* raw scan code */
	int rc;
	struct kb8042 *kb8042 = (struct kb8042 *)arg;

	rc = DDI_INTR_UNCLAIMED;

	if (kb8042->init_state == KB8042_UNINITIALIZED)
		return (DDI_INTR_UNCLAIMED);

	/* don't care if drv_setparm succeeds */
	(void) drv_setparm(SYSRINT, 1);

	while (ddi_get8(kb8042->handle, kb8042->addr + I8042_INT_INPUT_AVAIL)
	    != 0) {
		mblk_t *mp;

		rc = DDI_INTR_CLAIMED;

		scancode = ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_INT_INPUT_DATA);

		/*
		 * Intercept ACK and RESEND and signal the condition that
		 * kb8042_send_and_wait is waiting for.
		 */
		switch (scancode) {
		case KB_ACK:
			mutex_enter(&kb8042->w_hw_mutex);
			kb8042->acked = 1;
			cv_signal(&kb8042->cmd_cv);
			mutex_exit(&kb8042->w_hw_mutex);
			return (rc);
		case KB_RESEND:
			mutex_enter(&kb8042->w_hw_mutex);
			kb8042->need_retry = 1;
			cv_signal(&kb8042->cmd_cv);
			mutex_exit(&kb8042->w_hw_mutex);
			return (rc);
		default:
			break;
		}

		if ((mp = allocb(sizeof (scancode), BPRI_HI)) == NULL)
			return (rc);
		*mp->b_wptr++ = scancode;
		if (putq(RD(kb8042->w_qp), mp) == 0)
			freemsg(mp);
	}

	return (rc);
}

static void
kb8042_iocdatamsg(queue_t *qp, mblk_t *mp)
{
	struct copyresp	*csp;

	csp = (struct copyresp *)mp->b_rptr;
	if (csp->cp_rval) {
		freemsg(mp);
		return;
	}

	switch (csp->cp_cmd) {
	default:
		miocack(qp, mp, 0, 0);
		break;
	}
}

static boolean_t
kb8042_polled_keycheck(
    struct kbtrans_hardware *hw,
    int *key,
    enum keystate *state)
{
	struct kb8042 *kb8042 = (struct kb8042 *)hw;
	int	scancode;
	boolean_t	legit;
	boolean_t	synthetic_release_needed;

	if (kb8042->polled_synthetic_release_pending) {
		*key = kb8042->polled_synthetic_release_key;
		*state = KEY_RELEASED;
		kb8042->polled_synthetic_release_pending = B_FALSE;
		(void) kb8042_autorepeat_detect(kb8042, *key, *state);
		return (B_TRUE);
	}

	for (;;) {
		if (ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_POLL_INPUT_AVAIL) == 0) {
			return (B_FALSE);
		}

		scancode = ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_POLL_INPUT_DATA);

		legit = KeyboardConvertScan(kb8042, scancode, key, state,
		    &synthetic_release_needed);
		if (!legit) {
			continue;
		}
		/*
		 * For the moment at least, we rely on hardware autorepeat
		 * for polled I/O autorepeat.  However, for coordination
		 * with the interrupt-driven code, maintain the last key
		 * pressed.
		 */
		(void) kb8042_autorepeat_detect(kb8042, *key, *state);

		/*
		 * This is a total hack to support two additional keys
		 * on Korean keyboards.  They report only on press, and
		 * so we synthesize a release.  Most likely this will
		 * never be important to polled  I/O, but if I do it
		 * "right" the first time it _won't_ be an issue.
		 */
		if (synthetic_release_needed) {
			kb8042->polled_synthetic_release_pending = B_TRUE;
			kb8042->polled_synthetic_release_key = *key;
		}

		if (kb8042->simulated_kbd_type == KB_USB) {
			*key = keytab_pc2usb[*key];
		}
		return (B_TRUE);
	}
}

static void
kb8042_setled(struct kb8042 *kb8042, int led_state, boolean_t polled)
{
	kb8042->leds.desired = led_state;

	if (!polled)
		mutex_enter(&kb8042->w_hw_mutex);

	if (kb8042->leds.desired != kb8042->leds.commanded) {
		kb8042_send_to_keyboard(kb8042, KB_SET_LED, polled);
	}

	if (!polled)
		mutex_exit(&kb8042->w_hw_mutex);
}

static void
kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state)
{
	struct kb8042 *kb8042 = (struct kb8042 *)hw;
	kb8042_setled(kb8042, led_state, B_TRUE);
}

static void
kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state)
{
	struct kb8042 *kb8042 = (struct kb8042 *)hw;
	kb8042_setled(kb8042, led_state, B_FALSE);
}


static int
kb8042_send_and_wait(struct kb8042 *kb8042, uint8_t u8, boolean_t polled)
{
	uint8_t *outp = kb8042->addr +
	    (polled ? I8042_POLL_OUTPUT_DATA : I8042_INT_OUTPUT_DATA);
	uint8_t *inavp = kb8042->addr +
	    (polled ? I8042_POLL_INPUT_AVAIL : I8042_INT_INPUT_AVAIL);
	uint8_t *inp = kb8042->addr +
	    (polled ? I8042_POLL_INPUT_DATA : I8042_INT_INPUT_DATA);
	uint8_t b;
	int ms_waited;
	int timedout;
	int expire;
	int retries = 0;

	do {
		kb8042->acked = 0;
		kb8042->need_retry = 0;
		ms_waited = 0;		/* Zero it whether polled or not */
		timedout = 0;

		ddi_put8(kb8042->handle, outp, u8);

		while (!kb8042->acked && !kb8042->need_retry && !timedout) {

			if (polled) {
				if (ddi_get8(kb8042->handle, inavp)) {
					b = ddi_get8(kb8042->handle, inp);
					switch (b) {
					case KB_ACK:
						kb8042->acked = 1;
						break;
					case KB_RESEND:
						kb8042->need_retry = 1;
						break;
					default:
						/*
						 * drop it: We should never
						 * get scancodes while
						 * we're in the middle of a
						 * command anyway.
						 */
#ifdef DEBUG
						cmn_err(CE_WARN, "!Unexpected "
						    " byte 0x%x", b);
#endif
						break;
					}
				}

				/*
				 * Wait 1ms if an ACK wasn't received yet
				 */
				if (!kb8042->acked) {
					drv_usecwait(1000);
					ms_waited++;
					if (ms_waited >= MAX_KB8042_WAIT_MAX_MS)
						timedout = B_TRUE;
				}
			} else {
				/* Interrupt-driven */
				expire = ddi_get_lbolt() +
				    drv_usectohz(MAX_KB8042_WAIT_MAX_MS * 1000);

				/*
				 * If cv_timedwait returned -1 and we neither
				 * received an ACK nor a RETRY response, then
				 * we timed out.
				 */
				if (cv_timedwait(&kb8042->cmd_cv,
				    &kb8042->w_hw_mutex, expire) == -1 &&
				    !kb8042->acked && !kb8042->need_retry) {
					timedout = B_TRUE;
				}
			}

		}
	} while ((kb8042->need_retry || timedout) &&
	    ++retries < MAX_KB8042_RETRIES);

	return (kb8042->acked);
}

/*
 * kb8042_send_to_keyboard should be called with w_hw_mutex held if
 * polled is FALSE.
 */
static void
kb8042_send_to_keyboard(struct kb8042 *kb8042, int byte, boolean_t polled)
{

	/*
	 * KB_SET_LED and KB_ENABLE are special commands which require blocking
	 * other 8042 consumers while executing.
	 *
	 * Other commands/data are sent using the single put8 I/O access
	 * function.
	 */
	if (byte == KB_SET_LED) {

		if (!polled) {
			(void) ddi_get8(kb8042->handle, kb8042->addr +
			    I8042_LOCK);
		}

		if (kb8042_send_and_wait(kb8042, KB_SET_LED, polled)) {
			/*
			 * Ignore return value, as there's nothing we can
			 * do about it if the SET LED command fails.
			 */
			(void) kb8042_send_and_wait(kb8042,
			    kb8042_xlate_leds(kb8042->leds.desired), polled);
		}

		if (!polled) {
			(void) ddi_get8(kb8042->handle, kb8042->addr +
			    I8042_UNLOCK);
		}
		kb8042->leds.commanded = kb8042->leds.desired;

	} else if (byte == KB_ENABLE) {

		if (!polled) {
			(void) ddi_get8(kb8042->handle, kb8042->addr +
			    I8042_LOCK);
		}

		(void) kb8042_send_and_wait(kb8042, KB_ENABLE, polled);

		if (!polled) {
			(void) ddi_get8(kb8042->handle, kb8042->addr +
			    I8042_UNLOCK);
		}

	} else {
		/* All other commands use the "normal" virtual output port */
		if (polled) {
			ddi_put8(kb8042->handle,
			    kb8042->addr + I8042_POLL_OUTPUT_DATA, byte);
		} else {
			ddi_put8(kb8042->handle,
			    kb8042->addr + I8042_INT_OUTPUT_DATA, byte);
		}
	}
}

/*
 * Wait until the keyboard is fully up, maybe.
 * We may be the first person to talk to the keyboard, in which case
 * it's patiently waiting to say "AA" to us to tell us it's up.
 * In theory it sends the AA in 300ms < n < 9s, but it's a pretty
 * good bet that we've already spent that long getting to that point,
 * so we'll only wait long enough for the communications electronics to
 * run.
 */
static void
kb8042_wait_poweron(struct kb8042 *kb8042)
{
	int cnt;
	int ready;

	/* wait for up to 250 ms for a response */
	for (cnt = 0; cnt < 250; cnt++) {
		ready = ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_INT_INPUT_AVAIL);
		if (ready != 0)
			break;
		drv_usecwait(1000);
	}

	/*
	 * If there's something pending, read and discard it.  If not,
	 * assume things are OK anyway - maybe somebody else ate it
	 * already.  (On a PC, the BIOS almost certainly did.)
	 */
	if (ready != 0) {
		(void) ddi_get8(kb8042->handle,
		    kb8042->addr + I8042_INT_INPUT_DATA);
	}
}

static int
kb8042_xlate_leds(int led)
{
	int res;

	res = 0;

	if (led & LED_NUM_LOCK)
		res |= LED_NUM;
	if (led & LED_SCROLL_LOCK)
		res |= LED_SCR;
	if (led & LED_CAPS_LOCK)
		res |= LED_CAP;

	return (res);
}

/*ARGSUSED*/
static void
kb8042_get_initial_leds(
    struct kb8042 *kb8042,
    int *initial_leds,
    int *initial_led_mask)
{
#if defined(__x86)
	extern caddr_t	p0_va;
	uint8_t		bios_kb_flag;

	bios_kb_flag = p0_va[BIOS_KB_FLAG];

	*initial_led_mask = LED_CAPS_LOCK | LED_NUM_LOCK | LED_SCROLL_LOCK;
	*initial_leds = 0;
	if (bios_kb_flag & BIOS_CAPS_STATE)
		*initial_leds |= LED_CAPS_LOCK;
	if (bios_kb_flag & BIOS_NUM_STATE)
		*initial_leds |= LED_NUM_LOCK;
	if (bios_kb_flag & BIOS_SCROLL_STATE)
		*initial_leds |= LED_SCROLL_LOCK;
#else
	*initial_leds = 0;
	*initial_led_mask = 0;
#endif
}

static boolean_t
kb8042_autorepeat_detect(
    struct kb8042 *kb8042,
    int key_pos,
    enum keystate state)
{
	if (state == KEY_RELEASED) {
		if (kb8042->kb_old_key_pos == key_pos)
			kb8042->kb_old_key_pos = 0;
	} else {
		if (kb8042->kb_old_key_pos == key_pos) {
			return (B_TRUE);
		}
		kb8042->kb_old_key_pos = key_pos;
	}
	return (B_FALSE);
}

/* ARGSUSED */
static void
kb8042_type4_cmd(struct kb8042 *kb8042, int cmd)
{
	switch (cmd) {
	case KBD_CMD_BELL:
		(void) beeper_on(BEEP_TYPE4);
		break;
	case KBD_CMD_NOBELL:
		(void) beeper_off();
		break;
	}
}


/*
 * This is a pass-thru routine to get a character at poll time.
 */
static int
kb8042_polled_getchar(cons_polledio_arg_t arg)
{
	struct kb8042	*kb8042;

	kb8042 = (struct kb8042 *)arg;

	return (kbtrans_getchar(kb8042->hw_kbtrans));
}

/*
 * This is a pass-thru routine to get a character at poll time.
 */
static int
kb8042_polled_ischar(cons_polledio_arg_t arg)
{
	struct kb8042	*kb8042;

	kb8042 = (struct kb8042 *)arg;

	return (kbtrans_ischar(kb8042->hw_kbtrans));
}