clients/usbkbm/usbkbm.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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * USB keyboard input streams module - processes USB keypacket
 * received from HID driver below to either ASCII or event
 * format for windowing system.
 */
#include <sys/usb/usba/usbai_version.h>

#define	KEYMAP_SIZE_VARIABLE
#include <sys/usb/usba.h>
#include <sys/usb/clients/hid/hid.h>
#include <sys/usb/clients/hid/hid_polled.h>
#include <sys/usb/clients/hidparser/hidparser.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/kbio.h>
#include <sys/vuid_event.h>
#include <sys/kbd.h>
#include <sys/consdev.h>
#include <sys/kbtrans.h>
#include <sys/usb/clients/usbkbm/usbkbm.h>
#include <sys/beep.h>
#include <sys/inttypes.h>

/* debugging information */
uint_t	usbkbm_errmask = (uint_t)PRINT_MASK_ALL;
uint_t	usbkbm_errlevel = USB_LOG_L2;
static usb_log_handle_t usbkbm_log_handle;

typedef void (*process_key_callback_t)(usbkbm_state_t *, int, enum keystate);

/*
 * Internal Function Prototypes
 */
static void usbkbm_streams_setled(struct kbtrans_hardware *, int);
static void usbkbm_polled_setled(struct kbtrans_hardware *, int);
static boolean_t usbkbm_polled_keycheck(struct kbtrans_hardware *,
    int *, enum keystate *);
static void usbkbm_poll_callback(usbkbm_state_t *, int, enum keystate);
static void usbkbm_streams_callback(usbkbm_state_t *, int, enum keystate);
static void usbkbm_unpack_usb_packet(usbkbm_state_t *, process_key_callback_t,
    uchar_t *);
static boolean_t usbkbm_is_modkey(uchar_t);
static void usbkbm_reioctl(void	*);
static int usbkbm_polled_getchar(cons_polledio_arg_t);
static boolean_t usbkbm_polled_ischar(cons_polledio_arg_t);
static void usbkbm_polled_enter(cons_polledio_arg_t);
static void usbkbm_polled_exit(cons_polledio_arg_t);
static void usbkbm_mctl_receive(queue_t *, mblk_t *);
static enum kbtrans_message_response usbkbm_ioctl(queue_t *, mblk_t *);
static int usbkbm_kioccmd(usbkbm_state_t *, mblk_t *, char, size_t *);
static void	usbkbm_usb2pc_xlate(usbkbm_state_t *, int, enum keystate);
static void	usbkbm_wrap_kbtrans(usbkbm_state_t *, int, enum keystate);
static int	usbkbm_get_input_format(usbkbm_state_t *);
static int	usbkbm_get_vid_pid(usbkbm_state_t *);

/* stream qinit functions defined here */
static int	usbkbm_open(queue_t *, dev_t *, int, int, cred_t *);
static int	usbkbm_close(queue_t *, int, cred_t *);
static int	usbkbm_wput(queue_t *, mblk_t *);
static int	usbkbm_rput(queue_t *, mblk_t *);
static int	usbkbm_rsrv(queue_t *);
static ushort_t	usbkbm_get_state(usbkbm_state_t *);
static void	usbkbm_get_scancode(usbkbm_state_t *, int *, enum keystate *);

static struct keyboard *usbkbm_keyindex;

/* External Functions */
extern void space_free(char *);
extern uintptr_t space_fetch(char *);
extern int space_store(char *, uintptr_t);
extern struct keyboard *kbtrans_usbkb_maptab_init(void);
extern void kbtrans_usbkb_maptab_fini(struct keyboard **);
extern keymap_entry_t kbtrans_keycode_usb2pc(int);

/*
 * Structure to setup callbacks
 */
struct kbtrans_callbacks kbd_usb_callbacks = {
	usbkbm_streams_setled,
	usbkbm_polled_setled,
	usbkbm_polled_keycheck,
};

/*
 * Global Variables
 */

/* This variable saves the LED state across hotplugging. */
static uchar_t	usbkbm_led_state = 0;

/* This variable saves the layout state */
static uint16_t usbkbm_layout = 0;

/*
 * Function pointer array for mapping of scancodes.
 */
void (*usbkbm_xlate[2])(usbkbm_state_t *, int, enum keystate) = {
	usbkbm_wrap_kbtrans,
	usbkbm_usb2pc_xlate
};

static struct streamtab usbkbm_info;
static struct fmodsw fsw = {
	"usbkbm",
	&usbkbm_info,
	D_MP | D_MTPERMOD
};


/*
 * Module linkage information for the kernel.
 */
static struct modlstrmod modlstrmod = {
	&mod_strmodops,
	"USB keyboard streams 1.44",
	&fsw
};

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


int
_init(void)
{
	int	rval = mod_install(&modlinkage);
	usbkbm_save_state_t *sp;

	if (rval != 0) {

		return (rval);
	}

	usbkbm_keyindex = kbtrans_usbkb_maptab_init();

	usbkbm_log_handle = usb_alloc_log_hdl(NULL, "usbkbm",
	    &usbkbm_errlevel, &usbkbm_errmask, NULL, 0);

	sp = (usbkbm_save_state_t *)space_fetch("SUNW,usbkbm_state");

	if (sp == NULL) {

		return (0);
	}

	/* Restore LED information */
	usbkbm_led_state = sp->usbkbm_save_led;

	/* Restore the Layout */
	usbkbm_layout = sp->usbkbm_layout;

	/* Restore abort information */
	usbkbm_keyindex->k_abort1 =
	    sp->usbkbm_save_keyindex.k_abort1;

	usbkbm_keyindex->k_abort2 =
	    sp->usbkbm_save_keyindex.k_abort2;

	usbkbm_keyindex->k_newabort1 =
	    sp->usbkbm_save_keyindex.k_newabort1;

	usbkbm_keyindex->k_newabort2 =
	    sp->usbkbm_save_keyindex.k_newabort2;

	/* Restore keytables */
	bcopy(sp->usbkbm_save_keyindex.k_normal,
	    usbkbm_keyindex->k_normal, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_shifted,
	    usbkbm_keyindex->k_shifted, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_caps,
	    usbkbm_keyindex->k_caps, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_altgraph,
	    usbkbm_keyindex->k_altgraph, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_numlock,
	    usbkbm_keyindex->k_numlock, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_control,
	    usbkbm_keyindex->k_control, USB_KEYTABLE_SIZE);

	bcopy(sp->usbkbm_save_keyindex.k_up,
	    usbkbm_keyindex->k_up, USB_KEYTABLE_SIZE);

	kmem_free(sp->usbkbm_save_keyindex.k_normal,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_shifted,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_caps,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_altgraph,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_numlock,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_control,
	    USB_KEYTABLE_SIZE);
	kmem_free(sp->usbkbm_save_keyindex.k_up,
	    USB_KEYTABLE_SIZE);

	kmem_free(sp, sizeof (usbkbm_save_state_t));
	space_free("SUNW,usbkbm_state");

	return (0);
}

int
_fini(void)
{
	usbkbm_save_state_t *sp;
	int sval;
	int rval;

	sp = kmem_alloc(sizeof (usbkbm_save_state_t), KM_SLEEP);
	sval = space_store("SUNW,usbkbm_state", (uintptr_t)sp);

	/*
	 * If it's not possible to store the state, return
	 * EBUSY.
	 */
	if (sval != 0) {
		kmem_free(sp, sizeof (usbkbm_save_state_t));

		return (EBUSY);
	}

	rval = mod_remove(&modlinkage);

	if (rval != 0) {
		kmem_free(sp, sizeof (usbkbm_save_state_t));
		space_free("SUNW,usbkbm_state");

		return (rval);
	}

	usb_free_log_hdl(usbkbm_log_handle);

	/* Save the LED state */
	sp->usbkbm_save_led = usbkbm_led_state;

	/* Save the layout */
	sp->usbkbm_layout = (uchar_t)usbkbm_layout;

	/*
	 * Save entries of the keyboard structure that
	 * have changed.
	 */
	sp->usbkbm_save_keyindex.k_abort1 = usbkbm_keyindex->k_abort1;
	sp->usbkbm_save_keyindex.k_abort2 = usbkbm_keyindex->k_abort2;

	sp->usbkbm_save_keyindex.k_newabort1 = usbkbm_keyindex->k_newabort1;
	sp->usbkbm_save_keyindex.k_newabort2 = usbkbm_keyindex->k_newabort2;

	/* Allocate space for keytables to be stored */
	sp->usbkbm_save_keyindex.k_normal =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_shifted =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_caps =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_altgraph =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_numlock =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_control =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);
	sp->usbkbm_save_keyindex.k_up =
	    kmem_alloc(USB_KEYTABLE_SIZE, KM_SLEEP);

	/* Copy over the keytables */
	bcopy(usbkbm_keyindex->k_normal,
	    sp->usbkbm_save_keyindex.k_normal, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_shifted,
	    sp->usbkbm_save_keyindex.k_shifted, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_caps,
	    sp->usbkbm_save_keyindex.k_caps, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_altgraph,
	    sp->usbkbm_save_keyindex.k_altgraph, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_numlock,
	    sp->usbkbm_save_keyindex.k_numlock, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_control,
	    sp->usbkbm_save_keyindex.k_control, USB_KEYTABLE_SIZE);

	bcopy(usbkbm_keyindex->k_up,
	    sp->usbkbm_save_keyindex.k_up, USB_KEYTABLE_SIZE);

	kbtrans_usbkb_maptab_fini(&usbkbm_keyindex);

	return (0);
}

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

/*
 * Module qinit functions
 */

static struct module_info usbkbm_minfo = {
	0,		/* module id number */
	"usbkbm",	/* module name */
	0,		/* min packet size accepted */
	INFPSZ,		/* max packet size accepted */
	2048,		/* hi-water mark */
	128		/* lo-water mark */
	};

/* read side for key data and ioctl replies */
static struct qinit usbkbm_rinit = {
	usbkbm_rput,
	usbkbm_rsrv,
	usbkbm_open,
	usbkbm_close,
	NULL,
	&usbkbm_minfo
	};

/* write side for ioctls */
static struct qinit usbkbm_winit = {
	usbkbm_wput,
	NULL,
	usbkbm_open,
	usbkbm_close,
	NULL,
	&usbkbm_minfo
	};

static struct streamtab usbkbm_info = {
	&usbkbm_rinit,
	&usbkbm_winit,
	NULL,		/* for muxes */
	NULL,		/* for muxes */
};

/*
 * usbkbm_open :
 *	Open a keyboard
 */
/* ARGSUSED */
static int
usbkbm_open(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
{
	usbkbm_state_t	*usbkbmd;
	struct iocblk	mctlmsg;
	mblk_t		*mctl_ptr;
	uintptr_t	abortable = (uintptr_t)B_TRUE;
	int		error, ret;

	if (q->q_ptr) {
		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "usbkbm_open already opened");

		return (0); /* already opened */
	}

	switch (sflag) {

	case MODOPEN:
		break;

	case CLONEOPEN:
		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "usbkbm_open: Clone open not supported");

		/* FALLTHRU */
	default:

		return (EINVAL);
	}

	/* allocate usb keyboard state structure */

	usbkbmd = kmem_zalloc(sizeof (usbkbm_state_t), KM_SLEEP);

	USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
	    "usbkbm_state= %p", (void *)usbkbmd);

	/*
	 * Set up private data.
	 */
	usbkbmd->usbkbm_readq = q;
	usbkbmd->usbkbm_writeq = WR(q);

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

	error = kbtrans_streams_init(q, sflag,
	    (struct kbtrans_hardware *)usbkbmd, &kbd_usb_callbacks,
	    &usbkbmd->usbkbm_kbtrans, usbkbm_led_state, 0);

	if (error != 0) {
		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "kbdopen:  kbtrans_streams_init failed\n");
		kmem_free(usbkbmd, sizeof (*usbkbmd));

		return (error);
	}

	/*
	 * Set the polled information in the state structure.
	 * This information is set once, and doesn't change
	 */
	usbkbmd->usbkbm_polled_info.cons_polledio_version =
	    CONSPOLLEDIO_V1;

	usbkbmd->usbkbm_polled_info.cons_polledio_argument =
	    (cons_polledio_arg_t)usbkbmd;

	usbkbmd->usbkbm_polled_info.cons_polledio_putchar = NULL;

	usbkbmd->usbkbm_polled_info.cons_polledio_getchar =
	    usbkbm_polled_getchar;

	usbkbmd->usbkbm_polled_info.cons_polledio_ischar =
	    usbkbm_polled_ischar;

	usbkbmd->usbkbm_polled_info.cons_polledio_enter =
	    usbkbm_polled_enter;

	usbkbmd->usbkbm_polled_info.cons_polledio_exit =
	    usbkbm_polled_exit;

	usbkbmd->usbkbm_polled_info.cons_polledio_setled =
	    (void (*)(cons_polledio_arg_t, int))usbkbm_polled_setled;

	usbkbmd->usbkbm_polled_info.cons_polledio_keycheck =
	    (boolean_t (*)(cons_polledio_arg_t, int *,
	    enum keystate *))usbkbm_polled_keycheck;
	/*
	 * The head and the tail pointing at the same byte means empty or
	 * full. usbkbm_polled_buffer_num_characters is used to
	 * tell the difference.
	 */
	usbkbmd->usbkbm_polled_buffer_head =
	    usbkbmd->usbkbm_polled_scancode_buffer;
	usbkbmd->usbkbm_polled_buffer_tail =
	    usbkbmd->usbkbm_polled_scancode_buffer;
	usbkbmd->usbkbm_polled_buffer_num_characters = 0;

	qprocson(q);

	/* request hid report descriptor from HID */
	mctlmsg.ioc_cmd = HID_GET_PARSER_HANDLE;
	mctlmsg.ioc_count = 0;
	mctl_ptr = usba_mk_mctl(mctlmsg, NULL, 0);
	if (mctl_ptr == NULL) {
		/* failure to allocate M_CTL message */
		(void) kbtrans_streams_fini(usbkbmd->usbkbm_kbtrans);
		qprocsoff(q);
		kmem_free(usbkbmd, sizeof (*usbkbmd));

		return (ENOMEM);
	}

	/* send message to hid */
	putnext(usbkbmd->usbkbm_writeq, mctl_ptr);

	/*
	 * Now that M_CTL has been sent, wait for report descriptor.  Cleanup
	 * if user signals in the mean time (as when this gets opened in an
	 * inappropriate context and the user types a ^C).
	 */
	usbkbmd->usbkbm_flags |= USBKBM_QWAIT;
	while (usbkbmd->usbkbm_flags & USBKBM_QWAIT) {

		if (qwait_sig(q) == 0) {
			usbkbmd->usbkbm_flags = 0;
			(void) kbtrans_streams_fini(usbkbmd->usbkbm_kbtrans);
			qprocsoff(q);
			kmem_free(usbkbmd, sizeof (*usbkbmd));

			return (EINTR);
		}
	}


	/* get the input format from the hid descriptor */
	if (usbkbm_get_input_format(usbkbmd) != USB_SUCCESS) {

		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "usbkbm: Invalid HID Descriptor Tree."
		    "setting default report format");
	}

	/*
	 * Although Sun Japanese type6 and type7 keyboards have the same
	 * layout number(15), they should be recognized for loading the
	 * different keytables on upper apps (e.g. X). The new layout
	 * number (271) is defined for the Sun Japanese type6 keyboards.
	 * The layout number (15) specified in HID spec is used for other
	 * Japanese keyboards. It is a workaround for the old Sun Japanese
	 * type6 keyboards defect.
	 */
	if (usbkbmd->usbkbm_layout == SUN_JAPANESE_TYPE7) {

		if ((ret = usbkbm_get_vid_pid(usbkbmd)) != 0) {

			return (ret);
		}

		if ((usbkbmd->usbkbm_vid_pid.VendorId ==
		    HID_SUN_JAPANESE_TYPE6_KBD_VID) &&
		    (usbkbmd->usbkbm_vid_pid.ProductId ==
		    HID_SUN_JAPANESE_TYPE6_KBD_PID)) {
			usbkbmd->usbkbm_layout = SUN_JAPANESE_TYPE6;
		}
	}

	kbtrans_streams_set_keyboard(usbkbmd->usbkbm_kbtrans, KB_USB,
	    usbkbm_keyindex);

	usbkbmd->usbkbm_flags = USBKBM_OPEN;

	kbtrans_streams_enable(usbkbmd->usbkbm_kbtrans);

	/*
	 * Enable abort sequence on inital. For an internal open, conskbd
	 * will disable driver abort handling (later through M_IOCTL) and
	 * handle it by itself.
	 * For an external (aka. physical) open, this is necessary since
	 * no STREAMS module linked on top of usbkbm handles abort sequence.
	 */
	mctlmsg.ioc_cmd = CONSSETABORTENABLE;
	mctlmsg.ioc_count = TRANSPARENT;
	mctl_ptr = usba_mk_mctl(mctlmsg, &abortable, sizeof (abortable));
	if (mctl_ptr != NULL) {
		DB_TYPE(mctl_ptr) = M_IOCTL;
		if (kbtrans_streams_message(usbkbmd->usbkbm_kbtrans, mctl_ptr)
		    != KBTRANS_MESSAGE_HANDLED) {
			freemsg(mctl_ptr);
		}
	} else {
		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "usbkbm: enable abort sequence failed");
	}

	USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
	    "usbkbm_open exiting");
	return (0);
}


/*
 * usbkbm_close :
 *	Close a keyboard.
 */
/* ARGSUSED1 */
static int
usbkbm_close(register queue_t *q, int flag, cred_t *crp)
{
	usbkbm_state_t *usbkbmd = (usbkbm_state_t *)q->q_ptr;

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

	(void) kbtrans_streams_fini(usbkbmd->usbkbm_kbtrans);

	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.
	 */
	usbkbmd->usbkbm_flags = 0;

	kmem_free(usbkbmd, sizeof (usbkbm_state_t));

	USB_DPRINTF_L3(PRINT_MASK_CLOSE, usbkbm_log_handle,
	    "usbkbm_close exiting");

	return (0);
}


/*
 * usbkbm_wput :
 *	usb keyboard module output queue put procedure: handles M_IOCTL
 *	messages.
 */
static int
usbkbm_wput(register queue_t *q, register mblk_t *mp)
{
	usbkbm_state_t			*usbkbmd;
	enum kbtrans_message_response	ret;

	USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
	    "usbkbm_wput entering");

	usbkbmd = (usbkbm_state_t *)q->q_ptr;

	/* First, see if kbtrans will handle the message */
	ret = kbtrans_streams_message(usbkbmd->usbkbm_kbtrans, mp);

	if (ret == KBTRANS_MESSAGE_HANDLED) {

		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_wput exiting:2");

		return (0);
	}

	/* kbtrans didn't handle the message.  Try to handle it here */

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

		break;

	case M_IOCTL:
		ret = usbkbm_ioctl(q, mp);

		if (ret == KBTRANS_MESSAGE_HANDLED) {

			USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
			    "usbkbm_wput exiting:1");

			return (0);
		}
	default:
		break;
	}

	/*
	 * The message has not been handled
	 * by kbtrans or this module.  Pass it down the stream
	 */
	putnext(q, mp);

	USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
	    "usbkbm_wput exiting:3");
	return (0);
}

/*
 * usbkbm_ioctl :
 *	Handles the ioctls sent from upper module. Returns
 *	ACK/NACK back.
 */
static enum kbtrans_message_response
usbkbm_ioctl(register queue_t *q, register mblk_t *mp)
{
	usbkbm_state_t		*usbkbmd;
	struct iocblk		mctlmsg;
	struct iocblk		*iocp;
	mblk_t			*datap, *mctl_ptr;
	size_t			ioctlrespsize;
	int			err;
	int			tmp;
	int			cycles;
	int			frequency;
	int			msecs;
	char			command;

	err = 0;

	usbkbmd = (usbkbm_state_t *)q->q_ptr;
	iocp = (struct iocblk *)mp->b_rptr;

	switch (iocp->ioc_cmd) {
	case CONSSETKBDTYPE:
		err = miocpullup(mp, sizeof (int));
		if (err != 0) {
			break;
		}
		tmp = *(int *)mp->b_cont->b_rptr;
		if (tmp != KB_PC && tmp != KB_USB) {
			err = EINVAL;
			break;
		}
		usbkbmd->usbkbm_vkbd_type = tmp;
		break;
	case KIOCLAYOUT:

		datap = allocb(sizeof (int), BPRI_HI);
		if (datap == NULL) {
			ioctlrespsize = sizeof (int);

			goto allocfailure;
		}

		*(int *)datap->b_wptr = usbkbmd->usbkbm_layout;
		datap->b_wptr += sizeof (int);

		freemsg(mp->b_cont);

		mp->b_cont = datap;
		iocp->ioc_count = sizeof (int);
		break;

	case KIOCSLAYOUT:
		/*
		 * Supply a layout if not specified by the hardware, or
		 * override any that was specified.
		 */
		if (iocp->ioc_count != TRANSPARENT) {
			err = EINVAL;
			break;
		}

		usbkbmd->usbkbm_layout = *(intptr_t *)mp->b_cont->b_rptr;

		/*
		 * Save the layout in usbkbm_layout so as to handle the
		 * the case when the user has re-plugged in the non-self
		 * identifying non US keyboard. In this the layout is saved
		 * in global variable, so the user does not have to run
		 * kdmconfig again after the X server reset
		 */

		usbkbm_layout = usbkbmd->usbkbm_layout;
		break;

	case KIOCCMD:
		/*
		 * Check if we have at least the subcommand field; any
		 * other argument validation has to occur inside
		 * usbkbm_kioccmd().
		 */
		err = miocpullup(mp, sizeof (int));
		if (err != 0)
			break;

		/* Subcommand */
		command = (char)(*(int *)mp->b_cont->b_rptr);

		/*
		 * Check if this ioctl is followed by a previous
		 * KBD_CMD_SETLED command, in which case we take
		 * the command byte as the data for setting the LED
		 */
		if (usbkbmd->usbkbm_setled_second_byte) {
			usbkbm_streams_setled((struct kbtrans_hardware *)
			    usbkbmd, command);
			usbkbmd->usbkbm_setled_second_byte = 0;
			break;
		}

		/*
		 * In  case of allocb failure, this will
		 * return the size of the allocation which
		 * failed so that it can be allocated later
		 * through bufcall.
		 */
		ioctlrespsize = 0;

		err = usbkbm_kioccmd(usbkbmd, mp, command, &ioctlrespsize);

		if (ioctlrespsize != 0) {

			goto allocfailure;
		}

		break;

	case CONSOPENPOLLEDIO:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_ioctl CONSOPENPOLLEDIO");

		err = miocpullup(mp, sizeof (struct cons_polledio *));
		if (err != 0) {
			USB_DPRINTF_L2(PRINT_MASK_ALL, usbkbm_log_handle,
			    "usbkbm_ioctl: malformed request");
			break;
		}

		usbkbmd->usbkbm_pending_link = mp;

		/*
		 * Get the polled input structure from hid
		 */
		mctlmsg.ioc_cmd = HID_OPEN_POLLED_INPUT;
		mctlmsg.ioc_count = 0;
		mctl_ptr = usba_mk_mctl(mctlmsg, NULL, 0);
		if (mctl_ptr == NULL) {
			ioctlrespsize = sizeof (mctlmsg);

			goto allocfailure;
		}

		putnext(usbkbmd->usbkbm_writeq, mctl_ptr);

		/*
		 * Do not ack or nack the message, we will wait for the
		 * result of HID_OPEN_POLLED_INPUT
		 */

		return (KBTRANS_MESSAGE_HANDLED);

	case CONSCLOSEPOLLEDIO:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_ioctl CONSCLOSEPOLLEDIO mp = 0x%p", (void *)mp);

		usbkbmd->usbkbm_pending_link = mp;

		/*
		 * Get the polled input structure from hid
		 */
		mctlmsg.ioc_cmd = HID_CLOSE_POLLED_INPUT;
		mctlmsg.ioc_count = 0;
		mctl_ptr = usba_mk_mctl(mctlmsg, NULL, 0);
		if (mctl_ptr == NULL) {
			ioctlrespsize = sizeof (mctlmsg);

			goto allocfailure;
		}

		putnext(usbkbmd->usbkbm_writeq, mctl_ptr);

		/*
		 * Do not ack or nack the message, we will wait for the
		 * result of HID_CLOSE_POLLED_INPUT
		 */

		return (KBTRANS_MESSAGE_HANDLED);

	case CONSSETABORTENABLE:
		/*
		 * Nothing special to do for USB.
		 */
		break;


	case KIOCMKTONE:
		if (iocp->ioc_count != TRANSPARENT) {
			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;

	default:

		return (KBTRANS_MESSAGE_NOT_HANDLED);
	}

	/*
	 * Send ACK/NACK to upper module for
	 * the messages that have been handled.
	 */
	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;
	}

	/* Send the response back up the stream */
	putnext(usbkbmd->usbkbm_readq, mp);

	return (KBTRANS_MESSAGE_HANDLED);

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.
	 */
	freemsg(usbkbmd->usbkbm_streams_iocpending);
	usbkbmd->usbkbm_streams_iocpending = mp;

	if (usbkbmd->usbkbm_streams_bufcallid) {

		qunbufcall(usbkbmd->usbkbm_readq,
		    usbkbmd->usbkbm_streams_bufcallid);
	}
	usbkbmd->usbkbm_streams_bufcallid =
	    qbufcall(usbkbmd->usbkbm_readq, ioctlrespsize, BPRI_HI,
	    usbkbm_reioctl, usbkbmd);

	return (KBTRANS_MESSAGE_HANDLED);
}

/*
 * usbkbm_kioccmd :
 *	Handles KIOCCMD ioctl.
 */
static int
usbkbm_kioccmd(usbkbm_state_t *usbkbmd, register mblk_t *mp,
    char command, size_t *ioctlrepsize)
{
	register mblk_t			*datap;
	register struct iocblk		*iocp;
	int				err = 0;

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

	switch (command) {

		/* Keyboard layout command */
		case KBD_CMD_GETLAYOUT:
			/* layout learned at attached time. */
			datap = allocb(sizeof (int), BPRI_HI);

			/* Return error  on allocation failure */
			if (datap == NULL) {
				*ioctlrepsize = sizeof (int);

				return (EIO);
			}

			*(int *)datap->b_wptr = usbkbmd->usbkbm_layout;
			datap->b_wptr += sizeof (int);
			freemsg(mp->b_cont);
			mp->b_cont = datap;
			iocp->ioc_count = sizeof (int);
			break;

		case KBD_CMD_SETLED:
			/*
			 * Emulate type 4 keyboard :
			 * Ignore this ioctl; the following
			 * ioctl will specify the data byte for
			 * setting the LEDs; setting usbkbm_setled_second_byte
			 * will help recognizing that ioctl
			 */
			usbkbmd->usbkbm_setled_second_byte = 1;
			break;

		case KBD_CMD_RESET:
			break;

		case KBD_CMD_BELL:
			/*
			 * USB keyboards do not have a beeper
			 * in it, the generic beeper interface
			 * is used. Turn the beeper on.
			 */
			(void) beeper_on(BEEP_TYPE4);
			break;

		case KBD_CMD_NOBELL:
			/*
			 * USB keyboards do not have a beeper
			 * in it, the generic beeper interface
			 * is used. Turn the beeper off.
			 */
			(void) beeper_off();
			break;

		case KBD_CMD_CLICK:
			/* FALLTHRU */
		case KBD_CMD_NOCLICK:
			break;

		default:
			err = EIO;
			break;

	}

	return (err);
}

/*
 * usbkbm_rput :
 *	Put procedure for input from driver end of stream (read queue).
 */
static int
usbkbm_rput(queue_t *q, mblk_t *mp)
{
	usbkbm_state_t		*usbkbmd;

	usbkbmd = (usbkbm_state_t *)q->q_ptr;

	USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
	    "usbkbm_rput");

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

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

		freemsg(mp);

		return (0);
	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 (0);
	case M_DATA:
		if (!(usbkbmd->usbkbm_flags & USBKBM_OPEN)) {
			freemsg(mp);	/* not ready to listen */

			return (0);
		}

		break;
	case M_CTL:
		usbkbm_mctl_receive(q, mp);

		return (0);
	case M_ERROR:
		usbkbmd->usbkbm_flags &= ~USBKBM_QWAIT;
		if (*mp->b_rptr == ENODEV) {
			putnext(q, mp);
		} else {
			freemsg(mp);
		}

		return (0);
	case M_IOCACK:
	case M_IOCNAK:
		putnext(q, mp);

		return (0);
	default:
		putnext(q, mp);

		return (0);
	}

	if (putq(q, mp) == 0)
		freemsg(mp);
	return (0);
}

static int
usbkbm_rsrv(queue_t *q)
{
	usbkbm_state_t		*usbkbmd;
	mblk_t *mp;

	usbkbmd = (usbkbm_state_t *)q->q_ptr;

	if (usbkbmd == NULL)
		return (0);

	while ((mp = getq(q)) != NULL) {
		/* usbkbm_rput() should have filtered anything but M_DATA. */

		if (mp->b_datap->db_type != M_DATA) {
			freemsg(mp);
			continue;
		}

		/*
		 * A data message, consisting of bytes from the keyboard.
		 * Ram them through the translator, only if there are
		 * correct no. of bytes.
		 */
		if (MBLKL(mp) == usbkbmd->usbkbm_report_format.tlen) {
			if (usbkbmd->usbkbm_report_format.keyid !=
			    HID_REPORT_ID_UNDEFINED) {
				if (*(mp->b_rptr) !=
				    usbkbmd->usbkbm_report_format.keyid) {
					freemsg(mp);
					continue;
				} else {
					/* We skip the report id prefix */
					mp->b_rptr++;
				}
			}
			usbkbm_unpack_usb_packet(usbkbmd,
			    usbkbm_streams_callback, mp->b_rptr);
		}

		freemsg(mp);
	}
	return (0);
}

/*
 * usbkbm_mctl_receive :
 *	Handle M_CTL messages from hid. If we don't understand
 *	the command, send it up.
 */
static void
usbkbm_mctl_receive(register queue_t *q, register mblk_t *mp)
{
	register usbkbm_state_t *usbkbmd = (usbkbm_state_t *)q->q_ptr;
	register struct iocblk *iocp;
	caddr_t  data = NULL;
	mblk_t	*reply_mp;
	uchar_t	new_buffer[USBKBM_MAXPKTSIZE];
	size_t	 size;

	iocp = (struct iocblk *)mp->b_rptr;
	if (mp->b_cont != NULL)
		data = (caddr_t)mp->b_cont->b_rptr;

	switch (iocp->ioc_cmd) {

	case HID_SET_REPORT:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive HID_SET mctl");
		freemsg(mp);
		/* Setting of the LED is not waiting for this message */

		break;
	case HID_GET_PARSER_HANDLE:
		if ((data != NULL) &&
		    (iocp->ioc_count == sizeof (hidparser_handle_t)) &&
		    (MBLKL(mp->b_cont) == iocp->ioc_count)) {
			usbkbmd->usbkbm_report_descr =
			    *(hidparser_handle_t *)data;
		} else {
			usbkbmd->usbkbm_report_descr = NULL;
		}
		freemsg(mp);
		usbkbmd->usbkbm_flags &= ~USBKBM_QWAIT;

		break;
	case HID_GET_VID_PID:
		if ((data != NULL) &&
		    (iocp->ioc_count == sizeof (hid_vid_pid_t)) &&
		    (MBLKL(mp->b_cont) == iocp->ioc_count)) {
			bcopy(data, &usbkbmd->usbkbm_vid_pid, iocp->ioc_count);
		}
		freemsg(mp);
		usbkbmd->usbkbm_flags &= ~USBKBM_QWAIT;

		break;
	case HID_OPEN_POLLED_INPUT:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive HID_OPEN_POLLED_INPUT");

		size = sizeof (hid_polled_input_callback_t);
		reply_mp = usbkbmd->usbkbm_pending_link;
		if ((data != NULL) &&
		    (iocp->ioc_count == size) &&
		    (MBLKL(mp->b_cont) == size)) {
			/*
			 *  Copy the information from hid into the
			 * state structure
			 */
			bcopy(data, &usbkbmd->usbkbm_hid_callback, size);
			reply_mp->b_datap->db_type = M_IOCACK;

			/*
			 * We are given an appropriate-sized data block,
			 * and return a pointer to our structure in it.
			 * The structure is saved in the states structure
			 */
			*(cons_polledio_t **)reply_mp->b_cont->b_rptr =
			    &usbkbmd->usbkbm_polled_info;

		} else {
			reply_mp->b_datap->db_type = M_IOCNAK;
		}
		freemsg(mp);

		usbkbmd->usbkbm_pending_link = NULL;

		putnext(q, reply_mp);

		break;
	case HID_CLOSE_POLLED_INPUT:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive HID_CLOSE_POLLED_INPUT");


		bzero(&usbkbmd->usbkbm_hid_callback,
		    sizeof (hid_polled_input_callback_t));

		freemsg(mp);

		reply_mp = usbkbmd->usbkbm_pending_link;

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

		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive reply reply_mp 0x%p cmd 0x%x",
		    (void *)reply_mp, iocp->ioc_cmd);


		reply_mp->b_datap->db_type = M_IOCACK;

		usbkbmd->usbkbm_pending_link = NULL;

		putnext(q, reply_mp);

		break;
	case HID_DISCONNECT_EVENT :
	case HID_POWER_OFF:
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive HID_DISCONNECT_EVENT/HID_POWER_OFF");

		/* Indicate all keys have been released */
		bzero(new_buffer, USBKBM_MAXPKTSIZE);
		usbkbm_unpack_usb_packet(usbkbmd, usbkbm_streams_callback,
		    new_buffer);
		freemsg(mp);

		break;
	case HID_CONNECT_EVENT:
	case HID_FULL_POWER :
		USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
		    "usbkbm_mctl_receive restore LEDs");

		/* send setled command down to restore LED states */
		usbkbm_streams_setled((struct kbtrans_hardware *)usbkbmd,
		    usbkbm_led_state);

		freemsg(mp);

		break;
	default:
		putnext(q, mp);

		break;
	}
}


/*
 * usbkbm_streams_setled :
 *	Update the keyboard LEDs to match the current keyboard state.
 *	Send LED state downstreams to hid driver.
 */
static void
usbkbm_streams_setled(struct kbtrans_hardware *kbtrans_hw, int state)
{
	struct iocblk	mctlmsg;
	mblk_t		*mctl_ptr;
	hid_req_t	*LED_report;
	usbkbm_state_t	*usbkbmd;
	uchar_t		led_id, led_state;

	usbkbm_led_state = (uchar_t)state;

	usbkbmd = (usbkbm_state_t *)kbtrans_hw;

	LED_report = kmem_zalloc(sizeof (hid_req_t), KM_NOSLEEP);
	if (LED_report == NULL) {

		return;
	}

	/*
	 * Send the request to the hid driver to set LED.
	 */
	led_id = usbkbmd->usbkbm_report_format.keyid;
	led_state = 0;

	/*
	 * Set the led state based on the state that is passed in.
	 */
	if (state & LED_NUM_LOCK) {
		led_state |= USB_LED_NUM_LOCK;
	}

	if (state & LED_COMPOSE) {
		led_state |= USB_LED_COMPOSE;
	}

	if (state & LED_SCROLL_LOCK) {
		led_state |= USB_LED_SCROLL_LOCK;
	}

	if (state & LED_CAPS_LOCK) {
		led_state |= USB_LED_CAPS_LOCK;
	}

	if (state & LED_KANA) {
		led_state |= USB_LED_KANA;
	}

	LED_report->hid_req_version_no = HID_VERSION_V_0;
	LED_report->hid_req_wValue = REPORT_TYPE_OUTPUT | led_id;
	LED_report->hid_req_wLength = sizeof (uchar_t);
	LED_report->hid_req_data[0] = led_state;

	mctlmsg.ioc_cmd = HID_SET_REPORT;
	mctlmsg.ioc_count = sizeof (LED_report);
	mctl_ptr = usba_mk_mctl(mctlmsg, LED_report, sizeof (hid_req_t));
	if (mctl_ptr != NULL) {
		putnext(usbkbmd->usbkbm_writeq, mctl_ptr);
	}

	/*
	 * We are not waiting for response of HID_SET_REPORT
	 * mctl for setting the LED.
	 */
	kmem_free(LED_report, sizeof (hid_req_t));
}


/*
 * usbkbm_polled_keycheck :
 *	This routine is called to determine if there is a scancode that
 *	is available for input.  This routine is called at poll time and
 *	returns a key/state pair to the caller.  If there are characters
 *	buffered up, the routine returns right away with the key/state pair.
 *	Otherwise, the routine calls down to check for characters and returns
 *	the first key/state pair if there are any characters pending.
 */
static boolean_t
usbkbm_polled_keycheck(struct kbtrans_hardware *hw,
    int *key, enum keystate *state)
{
	usbkbm_state_t			*usbkbmd;
	uchar_t				*buffer;
	unsigned			size;
	hid_polled_handle_t		hid_polled_handle;

	usbkbmd = (usbkbm_state_t *)hw;

	/*
	 * If there are already characters buffered up, then we are done.
	 */
	if (usbkbmd->usbkbm_polled_buffer_num_characters != 0) {

		usbkbm_get_scancode(usbkbmd, key, state);

		return (B_TRUE);
	}

	hid_polled_handle =
	    usbkbmd->usbkbm_hid_callback.hid_polled_input_handle;

	size = (usbkbmd->usbkbm_hid_callback.hid_polled_read)
	    (hid_polled_handle, &buffer);

	/*
	 * If we don't get a valid input report then indicate that,
	 * and we are done.
	 */
	if (size != usbkbmd->usbkbm_report_format.tlen) {
		return (B_FALSE);
	}

	/*
	 * We have a usb packet, so pass this packet to
	 * usbkbm_unpack_usb_packet so that it can be broken up into
	 * individual key/state values.
	 */
	if (usbkbmd->usbkbm_report_format.keyid != HID_REPORT_ID_UNDEFINED) {
		if (*buffer != usbkbmd->usbkbm_report_format.keyid) {
			return (B_FALSE);
		} else {
			/* We skip the report id prefix */
			buffer++;
		}
	}
	usbkbm_unpack_usb_packet(usbkbmd, usbkbm_poll_callback, buffer);

	/*
	 * If a scancode was returned as a result of this packet,
	 * then translate the scancode.
	 */
	if (usbkbmd->usbkbm_polled_buffer_num_characters != 0) {

		usbkbm_get_scancode(usbkbmd, key, state);

		return (B_TRUE);
	}

	return (B_FALSE);
}

static ushort_t	usbkbm_get_state(usbkbm_state_t *usbkbmd)
{
	ushort_t	ret;

	ASSERT(usbkbmd->usbkbm_vkbd_type == KB_PC ||
	    usbkbmd->usbkbm_vkbd_type == KB_USB);

	if (usbkbmd->usbkbm_vkbd_type == KB_PC)
		ret = INDEXTO_PC;
	else
		ret = INDEXTO_USB;

	return (ret);
}
/*
 * usbkbm_streams_callback :
 *	This is the routine that is going to be called when unpacking
 *	usb packets for normal streams-based input.  We pass a pointer
 *	to this routine to usbkbm_unpack_usb_packet.  This routine will
 *	get called with an unpacked key (scancode) and state (press/release).
 *	We pass it to the generic keyboard module.
 *
 *	'index' and the function pointers:
 *	Map USB scancodes to PC scancodes by lookup table.
 *	This fix is mainly meant for x86 platforms. For SPARC systems
 *	this fix doesn't change the way in which the scancodes are processed.
 */
static void
usbkbm_streams_callback(usbkbm_state_t *usbkbmd, int key, enum keystate state)
{
	ushort_t index = usbkbm_get_state(usbkbmd);
	(*usbkbm_xlate[index])(usbkbmd, key, state);
}

/*
 * Don't do any translations. Send to 'kbtrans' for processing.
 */
static void
usbkbm_wrap_kbtrans(usbkbm_state_t *usbkbmd, int key, enum keystate state)
{
	kbtrans_streams_key(usbkbmd->usbkbm_kbtrans, key, state);
}

/*
 * Translate USB scancodes to PC scancodes before sending it to 'kbtrans'
 */
void
usbkbm_usb2pc_xlate(usbkbm_state_t *usbkbmd, int key, enum keystate state)
{
	key = kbtrans_keycode_usb2pc(key);
	kbtrans_streams_key(usbkbmd->usbkbm_kbtrans, key, state);
}

/*
 * usbkbm_poll_callback :
 *	This is the routine that is going to be called when unpacking
 *	usb packets for polled input.  We pass a pointer to this routine
 *	to usbkbm_unpack_usb_packet.  This routine will get called with
 *	an unpacked key (scancode) and state (press/release).  We will
 *	store the key/state pair into a circular buffer so that it can
 *	be translated into an ascii key later.
 */
static void
usbkbm_poll_callback(usbkbm_state_t *usbkbmd, int key, enum keystate state)
{
	/*
	 * Check to make sure that the buffer isn't already full
	 */
	if (usbkbmd->usbkbm_polled_buffer_num_characters ==
	    USB_POLLED_BUFFER_SIZE) {

		/*
		 * The buffer is full, we will drop this character.
		 */
		return;
	}

	/*
	 * Save the scancode in the buffer
	 */
	usbkbmd->usbkbm_polled_buffer_head->poll_key = key;
	usbkbmd->usbkbm_polled_buffer_head->poll_state = state;

	/*
	 * We have one more character in the buffer
	 */
	usbkbmd->usbkbm_polled_buffer_num_characters++;

	/*
	 * Increment to the next available slot.
	 */
	usbkbmd->usbkbm_polled_buffer_head++;

	/*
	 * Check to see if the tail has wrapped.
	 */
	if (usbkbmd->usbkbm_polled_buffer_head -
	    usbkbmd->usbkbm_polled_scancode_buffer ==
	    USB_POLLED_BUFFER_SIZE) {

		usbkbmd->usbkbm_polled_buffer_head =
		    usbkbmd->usbkbm_polled_scancode_buffer;
	}
}

/*
 * usbkbm_get_scancode :
 *	This routine retreives a key/state pair from the circular buffer.
 *	The pair was put in the buffer by usbkbm_poll_callback when a
 *	USB packet was translated into a key/state by usbkbm_unpack_usb_packet.
 */
static void
usbkbm_get_scancode(usbkbm_state_t *usbkbmd, int *key, enum keystate *state)
{
	/*
	 * Copy the character.
	 */
	*key = usbkbmd->usbkbm_polled_buffer_tail->poll_key;
	*state = usbkbmd->usbkbm_polled_buffer_tail->poll_state;

	/*
	 * Increment to the next character to be copied from
	 * and to.
	 */
	usbkbmd->usbkbm_polled_buffer_tail++;

	/*
	 * Check to see if the tail has wrapped.
	 */
	if (usbkbmd->usbkbm_polled_buffer_tail -
	    usbkbmd->usbkbm_polled_scancode_buffer ==
	    USB_POLLED_BUFFER_SIZE) {

		usbkbmd->usbkbm_polled_buffer_tail =
		    usbkbmd->usbkbm_polled_scancode_buffer;
	}

	/*
	 * We have one less character in the buffer.
	 */
	usbkbmd->usbkbm_polled_buffer_num_characters--;
}

/*
 * usbkbm_polled_setled :
 *	This routine is a place holder.  Someday, we may want to allow led
 *	state to be updated from within polled mode.
 */
/* ARGSUSED */
static void
usbkbm_polled_setled(struct kbtrans_hardware *hw, int led_state)
{
	/* nothing to do for now */
}

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

	usbkbmd = (usbkbm_state_t *)arg;

	return (kbtrans_getchar(usbkbmd->usbkbm_kbtrans));
}

/*
 * This is a pass-thru routine to test if character is available for reading
 * at poll time.
 */
static boolean_t
usbkbm_polled_ischar(cons_polledio_arg_t arg)
{
	usbkbm_state_t			*usbkbmd;

	usbkbmd = (usbkbm_state_t *)arg;

	return (kbtrans_ischar(usbkbmd->usbkbm_kbtrans));
}

/*
 * usbkbm_polled_input_enter :
 *	This is a pass-thru initialization routine for the lower layer drivers.
 *	This routine is called at poll time to set the state for polled input.
 */
static void
usbkbm_polled_enter(cons_polledio_arg_t arg)
{
	usbkbm_state_t		*usbkbmd = (usbkbm_state_t *)arg;
	hid_polled_handle_t	hid_polled_handle;
	int			kbstart, kbend, uindex;

	kbstart = usbkbmd->usbkbm_report_format.kpos;
	kbend = kbstart + usbkbmd->usbkbm_report_format.klen;

	/*
	 * Before switching to POLLED mode, copy the contents of
	 * usbkbm_pendingusbpacket to usbkbm_lastusbpacket since
	 * usbkbm_pendingusbpacket field has currently processed
	 * key events of the current OS mode usb keyboard packet.
	 */
	for (uindex = kbstart + 2; uindex < kbend; uindex++) {
		usbkbmd->usbkbm_lastusbpacket[uindex] =
		    usbkbmd->usbkbm_pendingusbpacket[uindex];

		usbkbmd->usbkbm_pendingusbpacket[uindex] = 0;
	}

	hid_polled_handle =
	    usbkbmd->usbkbm_hid_callback.hid_polled_input_handle;

	(void) (usbkbmd->usbkbm_hid_callback.hid_polled_input_enter)
	    (hid_polled_handle);
}

/*
 * usbkbm_polled_input_exit :
 *	This is a pass-thru restoration routine for the lower layer drivers.
 *	This routine is called at poll time to reset the state back to streams
 *	input.
 */
static void
usbkbm_polled_exit(cons_polledio_arg_t arg)
{
	usbkbm_state_t		*usbkbmd = (usbkbm_state_t *)arg;
	hid_polled_handle_t	hid_polled_handle;
	int			kbstart, kbend, uindex;

	kbstart = usbkbmd->usbkbm_report_format.kpos;
	kbend = kbstart + usbkbmd->usbkbm_report_format.klen;

	/*
	 * Before returning to OS mode, copy the contents of
	 * usbkbm_lastusbpacket to usbkbm_pendingusbpacket since
	 * usbkbm_lastusbpacket field has processed key events
	 * of the last POLLED mode usb keyboard packet.
	 */
	for (uindex = kbstart + 2; uindex < kbend; uindex ++) {
		usbkbmd->usbkbm_pendingusbpacket[uindex] =
		    usbkbmd->usbkbm_lastusbpacket[uindex];

		usbkbmd->usbkbm_lastusbpacket[uindex] = 0;
	}

	hid_polled_handle =
	    usbkbmd->usbkbm_hid_callback.hid_polled_input_handle;

	(void) (usbkbmd->usbkbm_hid_callback.hid_polled_input_exit)
	    (hid_polled_handle);
}

/*
 * usbkbm_unpack_usb_packet :
 *	USB key packets contain 8 bytes while in boot-protocol mode.
 *	The first byte contains bit packed modifier key information.
 *	Second byte is reserved. The last 6 bytes contain bytes of
 *	currently pressed keys. If a key was not recorded on the
 *	previous packet, but present in the current packet, then set
 *	state to KEY_PRESSED. If a key was recorded in the previous packet,
 *	but not present in the current packet, then state to KEY_RELEASED
 *	Follow a similar algorithm for bit packed modifier keys.
 */
static void
usbkbm_unpack_usb_packet(usbkbm_state_t *usbkbmd, process_key_callback_t func,
    uchar_t *usbpacket)
{
	uchar_t		mkb;
	uchar_t		lastmkb;
	uchar_t		*lastusbpacket = usbkbmd->usbkbm_lastusbpacket;
	int		packet_size, kbstart, kbend;
	int		uindex, lindex, rollover;

	packet_size = usbkbmd->usbkbm_report_format.tlen;
	kbstart = usbkbmd->usbkbm_report_format.kpos;
	kbend = kbstart + usbkbmd->usbkbm_report_format.klen;
	mkb = usbpacket[kbstart];
	lastmkb = lastusbpacket[kbstart];

	for (uindex = 0; uindex < packet_size; uindex++) {

		USB_DPRINTF_L3(PRINT_MASK_PACKET, usbkbm_log_handle,
		    " %x ", usbpacket[uindex]);
	}

	USB_DPRINTF_L3(PRINT_MASK_PACKET, usbkbm_log_handle,
	    " is the usbkeypacket");

	/* check to see if modifier keys are different */
	if (mkb != lastmkb) {

		if ((mkb & USB_LSHIFTBIT) != (lastmkb & USB_LSHIFTBIT)) {
			(*func)(usbkbmd, USB_LSHIFTKEY, (mkb & USB_LSHIFTBIT) ?
			    KEY_PRESSED : KEY_RELEASED);
			USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
			    "unpack: sending USB_LSHIFTKEY");
		}

		if ((mkb & USB_LCTLBIT) != (lastmkb & USB_LCTLBIT)) {
			(*func)(usbkbmd, USB_LCTLCKEY, mkb & USB_LCTLBIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_LALTBIT) != (lastmkb & USB_LALTBIT)) {
			(*func)(usbkbmd, USB_LALTKEY, mkb & USB_LALTBIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_LMETABIT) != (lastmkb & USB_LMETABIT)) {
			(*func)(usbkbmd, USB_LMETAKEY, mkb & USB_LMETABIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_RMETABIT) != (lastmkb & USB_RMETABIT)) {
			(*func)(usbkbmd, USB_RMETAKEY, mkb & USB_RMETABIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_RALTBIT) != (lastmkb & USB_RALTBIT)) {
			(*func)(usbkbmd, USB_RALTKEY, mkb & USB_RALTBIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_RCTLBIT) != (lastmkb & USB_RCTLBIT)) {
			(*func)(usbkbmd, USB_RCTLCKEY, mkb & USB_RCTLBIT ?
			    KEY_PRESSED : KEY_RELEASED);
		}

		if ((mkb & USB_RSHIFTBIT) != (lastmkb & USB_RSHIFTBIT)) {
			(*func)(usbkbmd, USB_RSHIFTKEY, mkb & USB_RSHIFTBIT ?
			    KEY_PRESSED : KEY_RELEASED);
			USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
			    "unpack: sending USB_RSHIFTKEY");
		}
	}

	/* save modifier bits */
	lastusbpacket[kbstart] = usbpacket[kbstart];

	/* Check Keyboard rollover error. */
	if (usbpacket[kbstart + 2] == USB_ERRORROLLOVER) {
		rollover = 1;
		for (uindex = kbstart + 3; uindex < kbend;
		    uindex++) {
			if (usbpacket[uindex] != USB_ERRORROLLOVER) {
				rollover = 0;
				break;
			}
		}
		if (rollover) {
			USB_DPRINTF_L3(PRINT_MASK_ALL, usbkbm_log_handle,
			    "unpack: errorrollover");
			return;
		}
	}

	/* check for released keys */
	for (lindex = kbstart + 2; lindex < kbend; lindex++) {
		int released = 1;

		if (lastusbpacket[lindex] == 0) {
			continue;
		}
		for (uindex = kbstart + 2; uindex < kbend; uindex++)
			if (usbpacket[uindex] == lastusbpacket[lindex]) {
				released = 0;
				break;
			}
		if (released) {
			(*func)(usbkbmd, lastusbpacket[lindex], KEY_RELEASED);
		}
	}

	/* check for new presses */
	for (uindex = kbstart + 2; uindex < kbend; uindex++) {
		int newkey = 1;

		usbkbmd->usbkbm_pendingusbpacket[uindex] = usbpacket[uindex];

		if (usbpacket[uindex] == 0) {
			continue;
		}

		for (lindex = kbstart + 2; lindex < kbend; lindex++) {
			if (usbpacket[uindex] == lastusbpacket[lindex]) {
				newkey = 0;
				break;
			}
		}

		if (newkey) {
			/*
			 * Modifier keys can be present as part of both the
			 * first byte and as separate key bytes. In the sec-
			 * ond case ignore it.
			 */

			if (!usbkbm_is_modkey(usbpacket[uindex])) {
				(*func)(usbkbmd, usbpacket[uindex],
				    KEY_PRESSED);
			} else {
				usbkbmd->usbkbm_pendingusbpacket[uindex] = 0;

				continue;
			}
		}
	}

	/*
	 * Copy the processed key events of the current usb keyboard
	 * packet, which is saved in the usbkbm_pendingusbpacket field
	 * to the usbkbm_lastusbpacket field.
	 */
	for (uindex = kbstart + 2; uindex < kbend; uindex++) {
		lastusbpacket[uindex] =
		    usbkbmd->usbkbm_pendingusbpacket[uindex];
		usbkbmd->usbkbm_pendingusbpacket[uindex] = 0;
	}
}

static boolean_t
usbkbm_is_modkey(uchar_t key)
{

	switch (key) {

	case USB_LSHIFTKEY:
	case USB_LCTLCKEY:
	case USB_LALTKEY:
	case USB_LMETAKEY:
	case USB_RCTLCKEY:
	case USB_RSHIFTKEY:
	case USB_RMETAKEY:
	case USB_RALTKEY:

		return (B_TRUE);

	default:

		break;
	}

	return (B_FALSE);
}

/*
 * usbkbm_reioctl :
 *	This function is set up as call-back function should an ioctl fail.
 *	It retries the ioctl
 */
static void
usbkbm_reioctl(void	*arg)
{
	usbkbm_state_t	*usbkbmd;
	mblk_t *mp;

	usbkbmd = (usbkbm_state_t *)arg;

	usbkbmd->usbkbm_streams_bufcallid = 0;

	if ((mp = usbkbmd->usbkbm_streams_iocpending) != NULL) {

		/* not pending any more */
		usbkbmd->usbkbm_streams_iocpending = NULL;

		(void) usbkbm_ioctl(usbkbmd->usbkbm_writeq, mp);
	}
}

/*
 * usbkbm_get_vid_pid
 *	Issue a M_CTL to hid to get the device info
 */
static int
usbkbm_get_vid_pid(usbkbm_state_t *usbkbmd)
{
	struct iocblk mctlmsg;
	mblk_t *mctl_ptr;
	queue_t *q = usbkbmd->usbkbm_readq;

	mctlmsg.ioc_cmd = HID_GET_VID_PID;
	mctlmsg.ioc_count = 0;

	mctl_ptr = usba_mk_mctl(mctlmsg, NULL, 0);
	if (mctl_ptr == NULL) {
		(void) kbtrans_streams_fini(usbkbmd->usbkbm_kbtrans);
		qprocsoff(q);
		kmem_free(usbkbmd, sizeof (usbkbm_state_t));

		return (ENOMEM);
	}

	putnext(usbkbmd->usbkbm_writeq, mctl_ptr);
	usbkbmd->usbkbm_flags |= USBKBM_QWAIT;
	while (usbkbmd->usbkbm_flags & USBKBM_QWAIT) {
		if (qwait_sig(q) == 0) {
			usbkbmd->usbkbm_flags = 0;
			(void) kbtrans_streams_fini(usbkbmd->usbkbm_kbtrans);
			qprocsoff(q);
			kmem_free(usbkbmd, sizeof (usbkbm_state_t));

			return (EINTR);
		}
	}

	return (0);
}

/*
 * usbkbm_get_input_format() :
 *     Get the input report format of keyboard
 */
static int
usbkbm_get_input_format(usbkbm_state_t *usbkbmd)
{

	hidparser_rpt_t *kb_rpt;
	uint_t i, kbd_page = 0, kpos = 0, klen = 0, limit = 0;
	uint32_t rptcnt, rptsz;
	usbkbm_report_format_t *kbd_fmt = &usbkbmd->usbkbm_report_format;
	int rptid, rval;

	/* Setup default input report format */
	kbd_fmt->keyid = HID_REPORT_ID_UNDEFINED;
	kbd_fmt->tlen = USB_KBD_BOOT_PROTOCOL_PACKET_SIZE;
	kbd_fmt->klen = kbd_fmt->tlen;
	kbd_fmt->kpos = 0;

	if (usbkbmd->usbkbm_report_descr == NULL) {
		return (USB_FAILURE);
	}

	/* Get keyboard layout */
	if (hidparser_get_country_code(usbkbmd->usbkbm_report_descr,
	    (uint16_t *)&usbkbmd->usbkbm_layout) == HIDPARSER_FAILURE) {

		USB_DPRINTF_L3(PRINT_MASK_OPEN,
		    usbkbm_log_handle, "get_country_code failed"
		    "setting default layout(0)");

		usbkbmd->usbkbm_layout = usbkbm_layout;
	}

	/* Get the id of the report which contains keyboard data */
	if (hidparser_get_usage_attribute(
	    usbkbmd->usbkbm_report_descr,
	    0, /* Doesn't matter */
	    HIDPARSER_ITEM_INPUT,
	    HID_KEYBOARD_KEYPAD_KEYS,
	    0,
	    HIDPARSER_ITEM_REPORT_ID,
	    &rptid) == HIDPARSER_NOT_FOUND) {

		return (USB_SUCCESS);
	}

	/* Allocate hidparser report structure */
	kb_rpt = kmem_zalloc(sizeof (hidparser_rpt_t), KM_SLEEP);

	/*
	 * Check what is the total length of the keyboard packet
	 * and get the usages and their lengths in order
	 */
	rval = hidparser_get_usage_list_in_order(
	    usbkbmd->usbkbm_report_descr,
	    rptid,
	    HIDPARSER_ITEM_INPUT,
	    kb_rpt);
	if (rval != HIDPARSER_SUCCESS) {

		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "get_usage_list_in_order failed");
		kmem_free(kb_rpt, sizeof (hidparser_rpt_t));
		return (USB_FAILURE);
	}

	for (i = 0; i < kb_rpt->no_of_usages; i++) {
		rptcnt = kb_rpt->usage_descr[i].rptcnt;
		rptsz = kb_rpt->usage_descr[i].rptsz;

		switch (kb_rpt->usage_descr[i].usage_page) {
		case HID_KEYBOARD_KEYPAD_KEYS:
			if (!kbd_page) {
				kpos = limit;
				kbd_page = 1;
			}
			klen += rptcnt * rptsz;
			/*FALLTHRU*/
		default:
			limit += rptcnt * rptsz;
			break;
		}
	}

	kmem_free(kb_rpt, sizeof (hidparser_rpt_t));

	/* Invalid input report format */
	if (!kbd_page || limit > USBKBM_MAXPKTSIZE * 8 ||
	    kpos + klen > limit || (kpos % 8 != 0)) {

		USB_DPRINTF_L3(PRINT_MASK_OPEN, usbkbm_log_handle,
		    "Invalid input report format: kbd_page (%d), limit (%d), "
		    "kpos (%d), klen (%d)", kbd_page, limit, kpos, klen);
		return (USB_FAILURE);
	}

	/* Set report format */
	kbd_fmt->keyid = (uint8_t)rptid;
	kbd_fmt->tlen = limit / 8 + 1;
	kbd_fmt->klen = klen / 8;
	kbd_fmt->kpos = kpos / 8;

	return (USB_SUCCESS);
}