17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5*99d47a04Slq  * Common Development and Distribution License (the "License").
6*99d47a04Slq  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21*99d47a04Slq 
227c478bd9Sstevel@tonic-gate /*
23*99d47a04Slq  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate /*
307c478bd9Sstevel@tonic-gate  * Generic keyboard support:  streams and administration.
317c478bd9Sstevel@tonic-gate  */
327c478bd9Sstevel@tonic-gate 
337c478bd9Sstevel@tonic-gate #define	KEYMAP_SIZE_VARIABLE
347c478bd9Sstevel@tonic-gate 
357c478bd9Sstevel@tonic-gate #include <sys/types.h>
367c478bd9Sstevel@tonic-gate #include <sys/cred.h>
377c478bd9Sstevel@tonic-gate #include <sys/stream.h>
387c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
397c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
407c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
417c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h>
427c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
437c478bd9Sstevel@tonic-gate #include <sys/errno.h>
447c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
457c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
467c478bd9Sstevel@tonic-gate #include <sys/kbd.h>
477c478bd9Sstevel@tonic-gate #include <sys/kbio.h>
487c478bd9Sstevel@tonic-gate #include <sys/consdev.h>
497c478bd9Sstevel@tonic-gate #include <sys/kbtrans.h>
507c478bd9Sstevel@tonic-gate #include <sys/policy.h>
517c478bd9Sstevel@tonic-gate #include "kbtrans_lower.h"
527c478bd9Sstevel@tonic-gate #include "kbtrans_streams.h"
537c478bd9Sstevel@tonic-gate 
547c478bd9Sstevel@tonic-gate #ifdef DEBUG
557c478bd9Sstevel@tonic-gate int	kbtrans_errmask;
567c478bd9Sstevel@tonic-gate int	kbtrans_errlevel;
577c478bd9Sstevel@tonic-gate #endif
587c478bd9Sstevel@tonic-gate 
597c478bd9Sstevel@tonic-gate /*
607c478bd9Sstevel@tonic-gate  * Repeat rates set in static variables so they can be tweeked with
617c478bd9Sstevel@tonic-gate  * debugger.
627c478bd9Sstevel@tonic-gate  */
637c478bd9Sstevel@tonic-gate static int kbtrans_repeat_rate;
647c478bd9Sstevel@tonic-gate static int kbtrans_repeat_delay;
657c478bd9Sstevel@tonic-gate 
667c478bd9Sstevel@tonic-gate /* Printing message on q overflow */
677c478bd9Sstevel@tonic-gate static int kbtrans_overflow_msg = 1;
687c478bd9Sstevel@tonic-gate 
697c478bd9Sstevel@tonic-gate /*
707c478bd9Sstevel@tonic-gate  * This value corresponds approximately to max 10 fingers
717c478bd9Sstevel@tonic-gate  */
727c478bd9Sstevel@tonic-gate static int	kbtrans_downs_size = 15;
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate /*
757c478bd9Sstevel@tonic-gate  * modload support
767c478bd9Sstevel@tonic-gate  */
777c478bd9Sstevel@tonic-gate extern struct mod_ops mod_miscops;
787c478bd9Sstevel@tonic-gate 
797c478bd9Sstevel@tonic-gate static struct modlmisc modlmisc	= {
807c478bd9Sstevel@tonic-gate 	&mod_miscops,	/* Type	of module */
817c478bd9Sstevel@tonic-gate 	"kbtrans (key translation) 1.32"
827c478bd9Sstevel@tonic-gate };
837c478bd9Sstevel@tonic-gate 
847c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = {
857c478bd9Sstevel@tonic-gate 	MODREV_1, (void	*)&modlmisc, NULL
867c478bd9Sstevel@tonic-gate };
877c478bd9Sstevel@tonic-gate 
887c478bd9Sstevel@tonic-gate int
897c478bd9Sstevel@tonic-gate _init(void)
907c478bd9Sstevel@tonic-gate {
917c478bd9Sstevel@tonic-gate 	return (mod_install(&modlinkage));
927c478bd9Sstevel@tonic-gate }
937c478bd9Sstevel@tonic-gate 
947c478bd9Sstevel@tonic-gate int
957c478bd9Sstevel@tonic-gate _fini(void)
967c478bd9Sstevel@tonic-gate {
977c478bd9Sstevel@tonic-gate 	return (mod_remove(&modlinkage));
987c478bd9Sstevel@tonic-gate }
997c478bd9Sstevel@tonic-gate 
1007c478bd9Sstevel@tonic-gate int
1017c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop)
1027c478bd9Sstevel@tonic-gate {
1037c478bd9Sstevel@tonic-gate 	return (mod_info(&modlinkage, modinfop));
1047c478bd9Sstevel@tonic-gate }
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate /*
1077c478bd9Sstevel@tonic-gate  * Internal Function Prototypes
1087c478bd9Sstevel@tonic-gate  */
1097c478bd9Sstevel@tonic-gate static char	*kbtrans_strsetwithdecimal(char *, uint_t, uint_t);
1107c478bd9Sstevel@tonic-gate static void	kbtrans_set_translation_callback(struct kbtrans *);
1117c478bd9Sstevel@tonic-gate static void	kbtrans_reioctl(void *);
1127c478bd9Sstevel@tonic-gate static void	kbtrans_send_esc_event(char, struct kbtrans *);
1137c478bd9Sstevel@tonic-gate static void	kbtrans_keypressed(struct kbtrans *, uchar_t, Firm_event *,
1147c478bd9Sstevel@tonic-gate 			ushort_t);
1157c478bd9Sstevel@tonic-gate static void	kbtrans_putbuf(char *, queue_t *);
1167c478bd9Sstevel@tonic-gate static void	kbtrans_cancelrpt(struct kbtrans *);
1177c478bd9Sstevel@tonic-gate static void	kbtrans_queuepress(struct kbtrans *, uchar_t, Firm_event *);
1187c478bd9Sstevel@tonic-gate static void	kbtrans_putcode(register struct kbtrans *, uint_t);
1197c478bd9Sstevel@tonic-gate static void	kbtrans_keyreleased(struct kbtrans *, uchar_t);
1207c478bd9Sstevel@tonic-gate static void	kbtrans_queueevent(struct kbtrans *, Firm_event *);
1217c478bd9Sstevel@tonic-gate static void	kbtrans_untrans_keypressed_raw(struct kbtrans *, kbtrans_key_t);
1227c478bd9Sstevel@tonic-gate static void	kbtrans_untrans_keyreleased_raw(struct kbtrans *,
1237c478bd9Sstevel@tonic-gate 			    kbtrans_key_t);
1247c478bd9Sstevel@tonic-gate static void	kbtrans_ascii_keypressed(struct kbtrans *, uint_t,
1257c478bd9Sstevel@tonic-gate 			kbtrans_key_t, uint_t);
1267c478bd9Sstevel@tonic-gate static void	kbtrans_ascii_keyreleased(struct kbtrans *, kbtrans_key_t);
1277c478bd9Sstevel@tonic-gate static void	kbtrans_ascii_setup_repeat(struct kbtrans *, uint_t,
1287c478bd9Sstevel@tonic-gate 			kbtrans_key_t);
1297c478bd9Sstevel@tonic-gate static void	kbtrans_trans_event_keypressed(struct kbtrans *, uint_t,
1307c478bd9Sstevel@tonic-gate 			kbtrans_key_t, uint_t);
1317c478bd9Sstevel@tonic-gate static void	kbtrans_trans_event_keyreleased(struct kbtrans *,
1327c478bd9Sstevel@tonic-gate 			kbtrans_key_t);
1337c478bd9Sstevel@tonic-gate static void	kbtrans_trans_event_setup_repeat(struct kbtrans *, uint_t,
1347c478bd9Sstevel@tonic-gate 			kbtrans_key_t);
1357c478bd9Sstevel@tonic-gate static void	kbtrans_rpt(void *);
1367c478bd9Sstevel@tonic-gate static void	kbtrans_setled(struct kbtrans *);
1377c478bd9Sstevel@tonic-gate static void	kbtrans_flush(struct kbtrans *);
1387c478bd9Sstevel@tonic-gate static enum kbtrans_message_response 	kbtrans_ioctl(struct kbtrans *upper,
1397c478bd9Sstevel@tonic-gate 						mblk_t *mp);
1407c478bd9Sstevel@tonic-gate static int	kbtrans_setkey(struct kbtrans_lower *, struct kiockey *,
1417c478bd9Sstevel@tonic-gate 			cred_t *);
1427c478bd9Sstevel@tonic-gate static int	kbtrans_getkey(struct kbtrans_lower *, struct kiockey *);
1437c478bd9Sstevel@tonic-gate static int	kbtrans_skey(struct kbtrans_lower *, struct kiockeymap *,
1447c478bd9Sstevel@tonic-gate 				cred_t *cr);
1457c478bd9Sstevel@tonic-gate static int 	kbtrans_gkey(struct kbtrans_lower *, struct kiockeymap *);
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate /*
1487c478bd9Sstevel@tonic-gate  * Keyboard Translation Mode (TR_NONE)
1497c478bd9Sstevel@tonic-gate  *
1507c478bd9Sstevel@tonic-gate  * Functions to be called when keyboard translation is turned off
1517c478bd9Sstevel@tonic-gate  * and up/down key codes are reported.
1527c478bd9Sstevel@tonic-gate  */
1537c478bd9Sstevel@tonic-gate struct keyboard_callback	untrans_event_callback  = {
1547c478bd9Sstevel@tonic-gate 	kbtrans_untrans_keypressed_raw,
1557c478bd9Sstevel@tonic-gate 	kbtrans_untrans_keyreleased_raw,
1567c478bd9Sstevel@tonic-gate 	NULL,
1577c478bd9Sstevel@tonic-gate 	NULL,
1587c478bd9Sstevel@tonic-gate 	NULL,
1597c478bd9Sstevel@tonic-gate 	NULL,
1607c478bd9Sstevel@tonic-gate 	NULL,
1617c478bd9Sstevel@tonic-gate };
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate /*
1647c478bd9Sstevel@tonic-gate  * Keyboard Translation Mode (TR_ASCII)
1657c478bd9Sstevel@tonic-gate  *
1667c478bd9Sstevel@tonic-gate  * Functions to be called when ISO 8859/1 codes are reported
1677c478bd9Sstevel@tonic-gate  */
1687c478bd9Sstevel@tonic-gate struct keyboard_callback	ascii_callback  = {
1697c478bd9Sstevel@tonic-gate 	NULL,
1707c478bd9Sstevel@tonic-gate 	NULL,
1717c478bd9Sstevel@tonic-gate 	kbtrans_ascii_keypressed,
1727c478bd9Sstevel@tonic-gate 	kbtrans_ascii_keyreleased,
1737c478bd9Sstevel@tonic-gate 	kbtrans_ascii_setup_repeat,
1747c478bd9Sstevel@tonic-gate 	kbtrans_cancelrpt,
1757c478bd9Sstevel@tonic-gate 	kbtrans_setled,
1767c478bd9Sstevel@tonic-gate };
1777c478bd9Sstevel@tonic-gate 
1787c478bd9Sstevel@tonic-gate /*
1797c478bd9Sstevel@tonic-gate  * Keyboard Translation Mode (TR_EVENT)
1807c478bd9Sstevel@tonic-gate  *
1817c478bd9Sstevel@tonic-gate  * Functions to be called when firm_events are reported.
1827c478bd9Sstevel@tonic-gate  */
1837c478bd9Sstevel@tonic-gate struct keyboard_callback	trans_event_callback  = {
1847c478bd9Sstevel@tonic-gate 	NULL,
1857c478bd9Sstevel@tonic-gate 	NULL,
1867c478bd9Sstevel@tonic-gate 	kbtrans_trans_event_keypressed,
1877c478bd9Sstevel@tonic-gate 	kbtrans_trans_event_keyreleased,
1887c478bd9Sstevel@tonic-gate 	kbtrans_trans_event_setup_repeat,
1897c478bd9Sstevel@tonic-gate 	kbtrans_cancelrpt,
1907c478bd9Sstevel@tonic-gate 	kbtrans_setled,
1917c478bd9Sstevel@tonic-gate };
1927c478bd9Sstevel@tonic-gate 
1937c478bd9Sstevel@tonic-gate /*
1947c478bd9Sstevel@tonic-gate  * kbtrans_streams_init:
1957c478bd9Sstevel@tonic-gate  *	Initialize the stream, keytables, callbacks, etc.
1967c478bd9Sstevel@tonic-gate  */
1977c478bd9Sstevel@tonic-gate int
1987c478bd9Sstevel@tonic-gate kbtrans_streams_init(
1997c478bd9Sstevel@tonic-gate 	queue_t 			*q,
2007c478bd9Sstevel@tonic-gate 	int 				sflag,
2017c478bd9Sstevel@tonic-gate 	cred_t				*crp,
2027c478bd9Sstevel@tonic-gate 	struct kbtrans_hardware 	*hw,
2037c478bd9Sstevel@tonic-gate 	struct kbtrans_callbacks 	*hw_cb,
2047c478bd9Sstevel@tonic-gate 	struct kbtrans 			**ret_kbd,
2057c478bd9Sstevel@tonic-gate 	int 				initial_leds,
2067c478bd9Sstevel@tonic-gate 	int 				initial_led_mask)
2077c478bd9Sstevel@tonic-gate {
2087c478bd9Sstevel@tonic-gate 	struct kbtrans *upper;
2097c478bd9Sstevel@tonic-gate 	struct kbtrans_lower *lower;
2107c478bd9Sstevel@tonic-gate 	int err;
2117c478bd9Sstevel@tonic-gate 
2127c478bd9Sstevel@tonic-gate 	/*
2137c478bd9Sstevel@tonic-gate 	 * Default to relatively generic tables.
2147c478bd9Sstevel@tonic-gate 	 */
2157c478bd9Sstevel@tonic-gate 	extern signed char			kb_compose_map[];
2167c478bd9Sstevel@tonic-gate 	extern struct compose_sequence_t	kb_compose_table[];
2177c478bd9Sstevel@tonic-gate 	extern struct fltaccent_sequence_t	kb_fltaccent_table[];
2187c478bd9Sstevel@tonic-gate 	extern char				keystringtab[][KTAB_STRLEN];
2197c478bd9Sstevel@tonic-gate 	extern unsigned char			kb_numlock_table[];
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate 	/* Set these up only once so that they could be changed from adb */
2227c478bd9Sstevel@tonic-gate 	if (!kbtrans_repeat_rate) {
2237c478bd9Sstevel@tonic-gate 		kbtrans_repeat_rate = (hz+29)/30;
2247c478bd9Sstevel@tonic-gate 		kbtrans_repeat_delay = hz/2;
2257c478bd9Sstevel@tonic-gate 	}
2267c478bd9Sstevel@tonic-gate 
2277c478bd9Sstevel@tonic-gate 	/*
2287c478bd9Sstevel@tonic-gate 	 * Only allow open requests to succeed for privileged users.  This
2297c478bd9Sstevel@tonic-gate 	 * necessary to prevent users from pushing the this module again
2307c478bd9Sstevel@tonic-gate 	 * on the stream associated with /dev/kbd.
2317c478bd9Sstevel@tonic-gate 	 */
2327c478bd9Sstevel@tonic-gate 	err = secpolicy_console(crp);
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate 	if (err != 0) {
2357c478bd9Sstevel@tonic-gate 		return (err);
2367c478bd9Sstevel@tonic-gate 	}
2377c478bd9Sstevel@tonic-gate 
2387c478bd9Sstevel@tonic-gate 	switch (sflag) {
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 	case MODOPEN:
2417c478bd9Sstevel@tonic-gate 		break;
2427c478bd9Sstevel@tonic-gate 
2437c478bd9Sstevel@tonic-gate 	case CLONEOPEN:
2447c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (NULL,
2457c478bd9Sstevel@tonic-gate 			"kbtrans_streams_init: Clone open not supported"));
2467c478bd9Sstevel@tonic-gate 
2477c478bd9Sstevel@tonic-gate 		return (EINVAL);
2487c478bd9Sstevel@tonic-gate 	}
2497c478bd9Sstevel@tonic-gate 
2507c478bd9Sstevel@tonic-gate 	/* allocate keyboard state structure */
2517c478bd9Sstevel@tonic-gate 	upper = kmem_zalloc(sizeof (struct kbtrans), KM_SLEEP);
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	*ret_kbd = upper;
2547c478bd9Sstevel@tonic-gate 
2557c478bd9Sstevel@tonic-gate 	upper->kbtrans_polled_buf[0] = '\0';
2567c478bd9Sstevel@tonic-gate 	upper->kbtrans_polled_pending_chars = upper->kbtrans_polled_buf;
2577c478bd9Sstevel@tonic-gate 
2587c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_hw = hw;
2597c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_hw_callbacks = hw_cb;
2607c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_readq = q;
2617c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_iocpending = NULL;
2627c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_translatable = TR_CAN;
2637c478bd9Sstevel@tonic-gate 	upper->kbtrans_overflow_cnt = 0;
2647c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_translate_mode = TR_ASCII;
2657c478bd9Sstevel@tonic-gate 
2667c478bd9Sstevel@tonic-gate 	/* Set the translation callback based on the translation type */
2677c478bd9Sstevel@tonic-gate 	kbtrans_set_translation_callback(upper);
2687c478bd9Sstevel@tonic-gate 
2697c478bd9Sstevel@tonic-gate 	lower = &upper->kbtrans_lower;
2707c478bd9Sstevel@tonic-gate 
2717c478bd9Sstevel@tonic-gate 	/*
2727c478bd9Sstevel@tonic-gate 	 * Set defaults for relatively generic tables.
2737c478bd9Sstevel@tonic-gate 	 */
2747c478bd9Sstevel@tonic-gate 	lower->kbtrans_compose_map = kb_compose_map;
2757c478bd9Sstevel@tonic-gate 	lower->kbtrans_compose_table = kb_compose_table;
2767c478bd9Sstevel@tonic-gate 	lower->kbtrans_fltaccent_table = kb_fltaccent_table;
2777c478bd9Sstevel@tonic-gate 	lower->kbtrans_numlock_table = kb_numlock_table;
2787c478bd9Sstevel@tonic-gate 	lower->kbtrans_keystringtab = keystringtab;
2797c478bd9Sstevel@tonic-gate 
2807c478bd9Sstevel@tonic-gate 	lower->kbtrans_upper = upper;
2817c478bd9Sstevel@tonic-gate 	lower->kbtrans_compat = 1;
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate 	/*
2847c478bd9Sstevel@tonic-gate 	 * We have a generic default for the LED state, and let the
2857c478bd9Sstevel@tonic-gate 	 * hardware-specific driver supply overrides.
2867c478bd9Sstevel@tonic-gate 	 */
2877c478bd9Sstevel@tonic-gate 	lower->kbtrans_led_state = 0;
2887c478bd9Sstevel@tonic-gate 	lower->kbtrans_led_state &= ~initial_led_mask;
2897c478bd9Sstevel@tonic-gate 	lower->kbtrans_led_state |= initial_leds;
2907c478bd9Sstevel@tonic-gate 	lower->kbtrans_togglemask = 0;
2917c478bd9Sstevel@tonic-gate 
2927c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_led_state & LED_CAPS_LOCK)
2937c478bd9Sstevel@tonic-gate 		lower->kbtrans_togglemask |= CAPSMASK;
2947c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_led_state & LED_NUM_LOCK)
2957c478bd9Sstevel@tonic-gate 		lower->kbtrans_togglemask |= NUMLOCKMASK;
2967c478bd9Sstevel@tonic-gate 
2977c478bd9Sstevel@tonic-gate #if	defined(SCROLLMASK)
2987c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_led_state & LED_SCROLL_LOCK)
2997c478bd9Sstevel@tonic-gate 		lower->kbtrans_togglemask |= SCROLLMASK;
3007c478bd9Sstevel@tonic-gate #endif
3017c478bd9Sstevel@tonic-gate 
3027c478bd9Sstevel@tonic-gate 	lower->kbtrans_shiftmask = lower->kbtrans_togglemask;
3037c478bd9Sstevel@tonic-gate 
3047c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_vuid_addr.ascii = ASCII_FIRST;
3057c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_vuid_addr.top = TOP_FIRST;
3067c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_vuid_addr.vkey = VKEY_FIRST;
3077c478bd9Sstevel@tonic-gate 
3087c478bd9Sstevel@tonic-gate 	/* Allocate dynamic memory for downs table */
3097c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_num_downs_entries = kbtrans_downs_size;
3107c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_downs_bytes =
3117c478bd9Sstevel@tonic-gate 			(uint32_t)(kbtrans_downs_size * sizeof (Key_event));
3127c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_downs =
3137c478bd9Sstevel@tonic-gate 		kmem_zalloc(upper->kbtrans_streams_downs_bytes, KM_SLEEP);
3147c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_abortable = B_FALSE;
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_flags = KBTRANS_STREAMS_OPEN;
3177c478bd9Sstevel@tonic-gate 
3187c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (upper, "kbtrans_streams_init "
3197c478bd9Sstevel@tonic-gate 					    "exiting"));
3207c478bd9Sstevel@tonic-gate 	return (0);
3217c478bd9Sstevel@tonic-gate }
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate 
3247c478bd9Sstevel@tonic-gate /*
3257c478bd9Sstevel@tonic-gate  * kbtrans_streams_fini:
3267c478bd9Sstevel@tonic-gate  *	Free structures and uninitialize the stream
3277c478bd9Sstevel@tonic-gate  */
3287c478bd9Sstevel@tonic-gate int
3297c478bd9Sstevel@tonic-gate kbtrans_streams_fini(struct kbtrans *upper)
3307c478bd9Sstevel@tonic-gate {
3317c478bd9Sstevel@tonic-gate 	/*
3327c478bd9Sstevel@tonic-gate 	 * Since we're about to destroy our private data, turn off
3337c478bd9Sstevel@tonic-gate 	 * our open flag first, so we don't accept any more input
3347c478bd9Sstevel@tonic-gate 	 * and try to use that data.
3357c478bd9Sstevel@tonic-gate 	 */
3367c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_flags = 0;
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	/* clear all timeouts */
3397c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_bufcallid) {
3407c478bd9Sstevel@tonic-gate 		qunbufcall(upper->kbtrans_streams_readq,
3417c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_bufcallid);
3427c478bd9Sstevel@tonic-gate 	}
3437c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_rptid) {
3447c478bd9Sstevel@tonic-gate 		(void) quntimeout(upper->kbtrans_streams_readq,
3457c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_rptid);
3467c478bd9Sstevel@tonic-gate 	}
3477c478bd9Sstevel@tonic-gate 	kmem_free(upper->kbtrans_streams_downs,
3487c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_downs_bytes);
3497c478bd9Sstevel@tonic-gate 	kmem_free(upper, sizeof (struct kbtrans));
3507c478bd9Sstevel@tonic-gate 
3517c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L1, PRINT_MASK_CLOSE, (upper, "kbtrans_streams_fini "
3527c478bd9Sstevel@tonic-gate 					    "exiting"));
3537c478bd9Sstevel@tonic-gate 	return (0);
3547c478bd9Sstevel@tonic-gate }
3557c478bd9Sstevel@tonic-gate 
3567c478bd9Sstevel@tonic-gate /*
3577c478bd9Sstevel@tonic-gate  * kbtrans_streams_releaseall :
3587c478bd9Sstevel@tonic-gate  *	This function releases all the held keys.
3597c478bd9Sstevel@tonic-gate  */
3607c478bd9Sstevel@tonic-gate void
3617c478bd9Sstevel@tonic-gate kbtrans_streams_releaseall(struct kbtrans *upper)
3627c478bd9Sstevel@tonic-gate {
3637c478bd9Sstevel@tonic-gate 	register struct key_event *ke;
3647c478bd9Sstevel@tonic-gate 	register int i;
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "USBKBM RELEASE ALL\n"));
3677c478bd9Sstevel@tonic-gate 
3687c478bd9Sstevel@tonic-gate 	/* Scan table of down key stations */
3697c478bd9Sstevel@tonic-gate 	for (i = 0, ke = upper->kbtrans_streams_downs;
3707c478bd9Sstevel@tonic-gate 	    i < upper->kbtrans_streams_num_downs_entries; i++, ke++) {
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate 		/* Key station not zero */
3737c478bd9Sstevel@tonic-gate 		if (ke->key_station) {
3747c478bd9Sstevel@tonic-gate 
3757c478bd9Sstevel@tonic-gate 			kbtrans_keyreleased(upper, ke->key_station);
3767c478bd9Sstevel@tonic-gate 			/* kbtrans_keyreleased resets downs entry */
3777c478bd9Sstevel@tonic-gate 		}
3787c478bd9Sstevel@tonic-gate 	}
3797c478bd9Sstevel@tonic-gate }
3807c478bd9Sstevel@tonic-gate 
3817c478bd9Sstevel@tonic-gate /*
3827c478bd9Sstevel@tonic-gate  * kbtrans_streams_message:
3837c478bd9Sstevel@tonic-gate  *	keyboard module output queue put procedure: handles M_IOCTL
3847c478bd9Sstevel@tonic-gate  *	messages.
3857c478bd9Sstevel@tonic-gate  *
3867c478bd9Sstevel@tonic-gate  * 	Return KBTRANS_MESSAGE_HANDLED if the message was handled by
3877c478bd9Sstevel@tonic-gate  *	kbtrans and KBTRANS_MESSAGE_NOT_HANDLED otherwise. If
3887c478bd9Sstevel@tonic-gate  *	KBTRANS_MESSAGE_HANDLED is returned, no further action is required.
3897c478bd9Sstevel@tonic-gate  *	If KBTRANS_MESSAGE_NOT_HANDLED is returned, the hardware module
3907c478bd9Sstevel@tonic-gate  *	is responsible for any action.
3917c478bd9Sstevel@tonic-gate  */
3927c478bd9Sstevel@tonic-gate enum kbtrans_message_response
3937c478bd9Sstevel@tonic-gate kbtrans_streams_message(struct kbtrans *upper, register mblk_t *mp)
3947c478bd9Sstevel@tonic-gate {
3957c478bd9Sstevel@tonic-gate 	queue_t *q = upper->kbtrans_streams_readq;
3967c478bd9Sstevel@tonic-gate 	enum kbtrans_message_response ret;
3977c478bd9Sstevel@tonic-gate 
3987c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper,
3997c478bd9Sstevel@tonic-gate 		"kbtrans_streams_message entering"));
4007c478bd9Sstevel@tonic-gate 	/*
4017c478bd9Sstevel@tonic-gate 	 * Process M_FLUSH, and some M_IOCTL, messages here; pass
4027c478bd9Sstevel@tonic-gate 	 * everything else down.
4037c478bd9Sstevel@tonic-gate 	 */
4047c478bd9Sstevel@tonic-gate 	switch (mp->b_datap->db_type) {
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate 	case M_IOCTL:
4077c478bd9Sstevel@tonic-gate 		ret = kbtrans_ioctl(upper, mp);
4087c478bd9Sstevel@tonic-gate 		break;
4097c478bd9Sstevel@tonic-gate 
4107c478bd9Sstevel@tonic-gate 	case M_FLUSH:
4117c478bd9Sstevel@tonic-gate 		if (*mp->b_rptr & FLUSHW)
4127c478bd9Sstevel@tonic-gate 			flushq(q, FLUSHDATA);
4137c478bd9Sstevel@tonic-gate 		if (*mp->b_rptr & FLUSHR)
4147c478bd9Sstevel@tonic-gate 			flushq(RD(q), FLUSHDATA);
4157c478bd9Sstevel@tonic-gate 		/*
4167c478bd9Sstevel@tonic-gate 		 * White lie:  we say we didn't handle the message,
4177c478bd9Sstevel@tonic-gate 		 * so that it gets handled by our client.
4187c478bd9Sstevel@tonic-gate 		 */
4197c478bd9Sstevel@tonic-gate 		ret = KBTRANS_MESSAGE_NOT_HANDLED;
4207c478bd9Sstevel@tonic-gate 		break;
4217c478bd9Sstevel@tonic-gate 
4227c478bd9Sstevel@tonic-gate 	default:
4237c478bd9Sstevel@tonic-gate 		ret = KBTRANS_MESSAGE_NOT_HANDLED;
4247c478bd9Sstevel@tonic-gate 		break;
4257c478bd9Sstevel@tonic-gate 
4267c478bd9Sstevel@tonic-gate 	}
4277c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper,
4287c478bd9Sstevel@tonic-gate 		"kbtrans_streams_message exiting\n"));
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 	return (ret);
4317c478bd9Sstevel@tonic-gate }
4327c478bd9Sstevel@tonic-gate 
4337c478bd9Sstevel@tonic-gate /*
4347c478bd9Sstevel@tonic-gate  * kbtrans_streams_key:
4357c478bd9Sstevel@tonic-gate  * 	When a key is pressed or released, the hardware module should
4367c478bd9Sstevel@tonic-gate  * 	call kbtrans, passing the key number and its new
4377c478bd9Sstevel@tonic-gate  * 	state.  kbtrans is responsible for autorepeat handling;
4387c478bd9Sstevel@tonic-gate  * 	the hardware module should report only actual press/release
4397c478bd9Sstevel@tonic-gate  * 	events, suppressing any hardware-generated autorepeat.
4407c478bd9Sstevel@tonic-gate  */
4417c478bd9Sstevel@tonic-gate void
4427c478bd9Sstevel@tonic-gate kbtrans_streams_key(
4437c478bd9Sstevel@tonic-gate     struct kbtrans *upper,
4447c478bd9Sstevel@tonic-gate     kbtrans_key_t key,
4457c478bd9Sstevel@tonic-gate     enum keystate state)
4467c478bd9Sstevel@tonic-gate {
4477c478bd9Sstevel@tonic-gate 	struct kbtrans_lower *lower;
4487c478bd9Sstevel@tonic-gate 	struct keyboard *kp;
4497c478bd9Sstevel@tonic-gate 
4507c478bd9Sstevel@tonic-gate 	lower = &upper->kbtrans_lower;
4517c478bd9Sstevel@tonic-gate 	kp = lower->kbtrans_keyboard;
4527c478bd9Sstevel@tonic-gate 
4537c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_abortable) {
4547c478bd9Sstevel@tonic-gate 		switch (upper->kbtrans_streams_abort_state) {
4557c478bd9Sstevel@tonic-gate 		case ABORT_NORMAL:
4567c478bd9Sstevel@tonic-gate 			if (state != KEY_PRESSED)
4577c478bd9Sstevel@tonic-gate 				break;
4587c478bd9Sstevel@tonic-gate 
4597c478bd9Sstevel@tonic-gate 			if (key == (kbtrans_key_t)kp->k_abort1 ||
4607c478bd9Sstevel@tonic-gate 			    key == (kbtrans_key_t)kp->k_abort1a) {
4617c478bd9Sstevel@tonic-gate 				upper->kbtrans_streams_abort_state =
4627c478bd9Sstevel@tonic-gate 					ABORT_ABORT1_RECEIVED;
4637c478bd9Sstevel@tonic-gate 				upper->kbtrans_streams_abort1_key = key;
4647c478bd9Sstevel@tonic-gate 				return;
4657c478bd9Sstevel@tonic-gate 			}
4667c478bd9Sstevel@tonic-gate 			break;
4677c478bd9Sstevel@tonic-gate 		case ABORT_ABORT1_RECEIVED:
4687c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_abort_state = ABORT_NORMAL;
4697c478bd9Sstevel@tonic-gate 			if (state == KEY_PRESSED &&
4707c478bd9Sstevel@tonic-gate 			    key == (kbtrans_key_t)kp->k_abort2) {
4717c478bd9Sstevel@tonic-gate 				abort_sequence_enter((char *)NULL);
4727c478bd9Sstevel@tonic-gate 				return;
4737c478bd9Sstevel@tonic-gate 			} else {
4747c478bd9Sstevel@tonic-gate 				kbtrans_processkey(lower,
4757c478bd9Sstevel@tonic-gate 					upper->kbtrans_streams_callback,
4767c478bd9Sstevel@tonic-gate 					upper->kbtrans_streams_abort1_key,
4777c478bd9Sstevel@tonic-gate 					KEY_PRESSED);
4787c478bd9Sstevel@tonic-gate 			}
4797c478bd9Sstevel@tonic-gate 		}
4807c478bd9Sstevel@tonic-gate 	}
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate 	kbtrans_processkey(lower, upper->kbtrans_streams_callback, key, state);
4837c478bd9Sstevel@tonic-gate }
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate /*
4867c478bd9Sstevel@tonic-gate  * kbtrans_streams_set_keyboard:
4877c478bd9Sstevel@tonic-gate  * 	At any time after calling kbtrans_streams_init, the hardware
4887c478bd9Sstevel@tonic-gate  * 	module should make this call to report the id of the keyboard
4897c478bd9Sstevel@tonic-gate  * 	attached. id is the keyboard type, typically KB_SUN4,
4907c478bd9Sstevel@tonic-gate  * 	KB_PC, or KB_USB.
4917c478bd9Sstevel@tonic-gate  */
4927c478bd9Sstevel@tonic-gate void
4937c478bd9Sstevel@tonic-gate kbtrans_streams_set_keyboard(
4947c478bd9Sstevel@tonic-gate     struct kbtrans 	*upper,
4957c478bd9Sstevel@tonic-gate     int 		id,
4967c478bd9Sstevel@tonic-gate     struct keyboard 	*k)
4977c478bd9Sstevel@tonic-gate {
4987c478bd9Sstevel@tonic-gate 	upper->kbtrans_lower.kbtrans_keyboard = k;
4997c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_id = id;
5007c478bd9Sstevel@tonic-gate }
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate /*
5037c478bd9Sstevel@tonic-gate  * kbtrans_streams_has_reset:
5047c478bd9Sstevel@tonic-gate  * 	At any time between kbtrans_streams_init and kbtrans_streams_fini,
5057c478bd9Sstevel@tonic-gate  * 	the hardware module can call this routine to report that the
5067c478bd9Sstevel@tonic-gate  * 	keyboard has been reset, e.g. by being unplugged and reattached.
5077c478bd9Sstevel@tonic-gate  */
5087c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5097c478bd9Sstevel@tonic-gate void
5107c478bd9Sstevel@tonic-gate kbtrans_streams_has_reset(struct kbtrans *upper)
5117c478bd9Sstevel@tonic-gate {
5127c478bd9Sstevel@tonic-gate 	/*
5137c478bd9Sstevel@tonic-gate 	 * If this routine is implemented it should probably (a)
5147c478bd9Sstevel@tonic-gate 	 * simulate releases of all pressed keys and (b) call
5157c478bd9Sstevel@tonic-gate 	 * the hardware module to set the LEDs.
5167c478bd9Sstevel@tonic-gate 	 */
5177c478bd9Sstevel@tonic-gate }
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate /*
5207c478bd9Sstevel@tonic-gate  * kbtrans_streams_enable:
5217c478bd9Sstevel@tonic-gate  *	This is the routine that is called back when the the stream is ready
5227c478bd9Sstevel@tonic-gate  *	to take messages.
5237c478bd9Sstevel@tonic-gate  */
5247c478bd9Sstevel@tonic-gate void
5257c478bd9Sstevel@tonic-gate kbtrans_streams_enable(struct kbtrans *upper)
5267c478bd9Sstevel@tonic-gate {
5277c478bd9Sstevel@tonic-gate 	/* Set the LED's */
5287c478bd9Sstevel@tonic-gate 	kbtrans_setled(upper);
5297c478bd9Sstevel@tonic-gate }
5307c478bd9Sstevel@tonic-gate 
531*99d47a04Slq /*
532*99d47a04Slq  * kbtrans_streams_setled():
533*99d47a04Slq  *	This is the routine that is called to only update the led state
534*99d47a04Slq  *	in kbtrans.
535*99d47a04Slq  */
536*99d47a04Slq void
537*99d47a04Slq kbtrans_streams_setled(struct kbtrans *upper, int led_state)
538*99d47a04Slq {
539*99d47a04Slq 	struct kbtrans_lower *lower;
540*99d47a04Slq 
541*99d47a04Slq 	lower = &upper->kbtrans_lower;
542*99d47a04Slq 	lower->kbtrans_led_state = (uchar_t)led_state;
543*99d47a04Slq 
544*99d47a04Slq 	if (lower->kbtrans_led_state & LED_CAPS_LOCK)
545*99d47a04Slq 		lower->kbtrans_togglemask |= CAPSMASK;
546*99d47a04Slq 	if (lower->kbtrans_led_state & LED_NUM_LOCK)
547*99d47a04Slq 		lower->kbtrans_togglemask |= NUMLOCKMASK;
548*99d47a04Slq 
549*99d47a04Slq #if	defined(SCROLLMASK)
550*99d47a04Slq 	if (lower->kbtrans_led_state & LED_SCROLL_LOCK)
551*99d47a04Slq 		lower->kbtrans_togglemask |= SCROLLMASK;
552*99d47a04Slq #endif
553*99d47a04Slq 
554*99d47a04Slq 	lower->kbtrans_shiftmask = lower->kbtrans_togglemask;
555*99d47a04Slq 
556*99d47a04Slq }
557*99d47a04Slq 
5587c478bd9Sstevel@tonic-gate /*
5597c478bd9Sstevel@tonic-gate  * kbtrans_streams_set_queue:
5607c478bd9Sstevel@tonic-gate  *      Set the overlying queue, to support multiplexors.
5617c478bd9Sstevel@tonic-gate  */
5627c478bd9Sstevel@tonic-gate void
5637c478bd9Sstevel@tonic-gate kbtrans_streams_set_queue(struct kbtrans *upper, queue_t *q)
5647c478bd9Sstevel@tonic-gate {
5657c478bd9Sstevel@tonic-gate 
5667c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_readq = q;
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate /*
5707c478bd9Sstevel@tonic-gate  * kbtrans_streams_get_queue:
5717c478bd9Sstevel@tonic-gate  *      Return the overlying queue.
5727c478bd9Sstevel@tonic-gate  */
5737c478bd9Sstevel@tonic-gate queue_t *
5747c478bd9Sstevel@tonic-gate kbtrans_streams_get_queue(struct kbtrans *upper)
5757c478bd9Sstevel@tonic-gate {
5767c478bd9Sstevel@tonic-gate 	return (upper->kbtrans_streams_readq);
5777c478bd9Sstevel@tonic-gate }
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate /*
5807c478bd9Sstevel@tonic-gate  * kbtrans_streams_untimeout
5817c478bd9Sstevel@tonic-gate  *      Cancell all timeout
5827c478bd9Sstevel@tonic-gate  */
5837c478bd9Sstevel@tonic-gate void
5847c478bd9Sstevel@tonic-gate kbtrans_streams_untimeout(struct kbtrans *upper)
5857c478bd9Sstevel@tonic-gate {
5867c478bd9Sstevel@tonic-gate 	/* clear all timeouts */
5877c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_bufcallid) {
5887c478bd9Sstevel@tonic-gate 		qunbufcall(upper->kbtrans_streams_readq,
5897c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_bufcallid);
5907c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_bufcallid = 0;
5917c478bd9Sstevel@tonic-gate 	}
5927c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_rptid) {
5937c478bd9Sstevel@tonic-gate 		(void) quntimeout(upper->kbtrans_streams_readq,
5947c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_rptid);
5957c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_rptid = 0;
5967c478bd9Sstevel@tonic-gate 	}
5977c478bd9Sstevel@tonic-gate }
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate /*
6007c478bd9Sstevel@tonic-gate  * kbtrans_reioctl:
6017c478bd9Sstevel@tonic-gate  * 	This function is set up as call-back function should an ioctl fail
6027c478bd9Sstevel@tonic-gate  * 	to allocate required resources.
6037c478bd9Sstevel@tonic-gate  */
6047c478bd9Sstevel@tonic-gate static void
6057c478bd9Sstevel@tonic-gate kbtrans_reioctl(void	*arg)
6067c478bd9Sstevel@tonic-gate {
6077c478bd9Sstevel@tonic-gate 	struct kbtrans *upper = (struct kbtrans *)arg;
6087c478bd9Sstevel@tonic-gate 	mblk_t *mp;
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_bufcallid = 0;
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	if ((mp = upper->kbtrans_streams_iocpending) != NULL) {
6137c478bd9Sstevel@tonic-gate 		/* not pending any more */
6147c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_iocpending = NULL;
6157c478bd9Sstevel@tonic-gate 		(void) kbtrans_ioctl(upper, mp);
6167c478bd9Sstevel@tonic-gate 	}
6177c478bd9Sstevel@tonic-gate }
6187c478bd9Sstevel@tonic-gate 
6197c478bd9Sstevel@tonic-gate /*
6207c478bd9Sstevel@tonic-gate  * kbtrans_ioctl:
6217c478bd9Sstevel@tonic-gate  * 	process ioctls we recognize and own.  Otherwise, pass it down.
6227c478bd9Sstevel@tonic-gate  */
6237c478bd9Sstevel@tonic-gate static enum kbtrans_message_response
6247c478bd9Sstevel@tonic-gate kbtrans_ioctl(struct kbtrans *upper, register mblk_t *mp)
6257c478bd9Sstevel@tonic-gate {
6267c478bd9Sstevel@tonic-gate 	register struct iocblk *iocp;
6277c478bd9Sstevel@tonic-gate 	register short	new_translate;
6287c478bd9Sstevel@tonic-gate 	register Vuid_addr_probe *addr_probe;
6297c478bd9Sstevel@tonic-gate 	register short	*addr_ptr;
6307c478bd9Sstevel@tonic-gate 	size_t	ioctlrespsize;
6317c478bd9Sstevel@tonic-gate 	int	err = 0;
6327c478bd9Sstevel@tonic-gate 	struct kbtrans_lower *lower;
6337c478bd9Sstevel@tonic-gate 	mblk_t *datap;
6347c478bd9Sstevel@tonic-gate 	int	translate;
6357c478bd9Sstevel@tonic-gate 
6367c478bd9Sstevel@tonic-gate 	static int kiocgetkey, kiocsetkey;
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate 	lower = &upper->kbtrans_lower;
6397c478bd9Sstevel@tonic-gate 
6407c478bd9Sstevel@tonic-gate 	iocp = (struct iocblk *)mp->b_rptr;
6417c478bd9Sstevel@tonic-gate 
6427c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper,
6437c478bd9Sstevel@tonic-gate 		"kbtrans_ioctl: ioc_cmd 0x%x - ", iocp->ioc_cmd));
6447c478bd9Sstevel@tonic-gate 	switch (iocp->ioc_cmd) {
6457c478bd9Sstevel@tonic-gate 
6467c478bd9Sstevel@tonic-gate 	case VUIDSFORMAT:
6477c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSFORMAT\n"));
6487c478bd9Sstevel@tonic-gate 
6497c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
6507c478bd9Sstevel@tonic-gate 		if (err != 0)
6517c478bd9Sstevel@tonic-gate 			break;
6527c478bd9Sstevel@tonic-gate 		new_translate = (*(int *)mp->b_cont->b_rptr == VUID_NATIVE) ?
6537c478bd9Sstevel@tonic-gate 		    TR_ASCII : TR_EVENT;
6547c478bd9Sstevel@tonic-gate 
6557c478bd9Sstevel@tonic-gate 		if (new_translate == upper->kbtrans_streams_translate_mode)
6567c478bd9Sstevel@tonic-gate 			break;
6577c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_translate_mode = new_translate;
6587c478bd9Sstevel@tonic-gate 
6597c478bd9Sstevel@tonic-gate 		kbtrans_set_translation_callback(upper);
6607c478bd9Sstevel@tonic-gate 
6617c478bd9Sstevel@tonic-gate 		kbtrans_flush(upper);
6627c478bd9Sstevel@tonic-gate 		break;
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate 	case KIOCTRANS:
6657c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANS\n"));
6667c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
6677c478bd9Sstevel@tonic-gate 		if (err != 0)
6687c478bd9Sstevel@tonic-gate 			break;
6697c478bd9Sstevel@tonic-gate 		new_translate = *(int *)mp->b_cont->b_rptr;
6707c478bd9Sstevel@tonic-gate 		if (new_translate == upper->kbtrans_streams_translate_mode)
6717c478bd9Sstevel@tonic-gate 			break;
6727c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_translate_mode = new_translate;
6737c478bd9Sstevel@tonic-gate 		kbtrans_set_translation_callback(upper);
6747c478bd9Sstevel@tonic-gate 
6757c478bd9Sstevel@tonic-gate 		kbtrans_flush(upper);
6767c478bd9Sstevel@tonic-gate 		break;
6777c478bd9Sstevel@tonic-gate 
6787c478bd9Sstevel@tonic-gate 	case KIOCSLED:
6797c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSLED\n"));
6807c478bd9Sstevel@tonic-gate 
6817c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (uchar_t));
6827c478bd9Sstevel@tonic-gate 		if (err != 0)
6837c478bd9Sstevel@tonic-gate 			break;
6847c478bd9Sstevel@tonic-gate 		lower->kbtrans_led_state = *(uchar_t *)mp->b_cont->b_rptr;
6857c478bd9Sstevel@tonic-gate 
6867c478bd9Sstevel@tonic-gate 		kbtrans_setled(upper);
6877c478bd9Sstevel@tonic-gate 		break;
6887c478bd9Sstevel@tonic-gate 
6897c478bd9Sstevel@tonic-gate 	case KIOCGLED:
6907c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGLED\n"));
6917c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (uchar_t), BPRI_HI)) == NULL) {
6927c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
6937c478bd9Sstevel@tonic-gate 			goto allocfailure;
6947c478bd9Sstevel@tonic-gate 		}
6957c478bd9Sstevel@tonic-gate 
6967c478bd9Sstevel@tonic-gate 		*(uchar_t *)datap->b_wptr = lower->kbtrans_led_state;
6977c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (uchar_t);
6987c478bd9Sstevel@tonic-gate 		if (mp->b_cont)
6997c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
7007c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
7017c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (uchar_t);
7027c478bd9Sstevel@tonic-gate 		break;
7037c478bd9Sstevel@tonic-gate 
7047c478bd9Sstevel@tonic-gate 	case VUIDGFORMAT:
7057c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGFORMAT\n"));
7067c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
7077c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
7087c478bd9Sstevel@tonic-gate 			goto allocfailure;
7097c478bd9Sstevel@tonic-gate 		}
7107c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr =
7117c478bd9Sstevel@tonic-gate 		    (upper->kbtrans_streams_translate_mode == TR_EVENT ||
7127c478bd9Sstevel@tonic-gate 		    upper->kbtrans_streams_translate_mode == TR_UNTRANS_EVENT) ?
7137c478bd9Sstevel@tonic-gate 			VUID_FIRM_EVENT: VUID_NATIVE;
7147c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
7157c478bd9Sstevel@tonic-gate 		if (mp->b_cont)  /* free msg to prevent memory leak */
7167c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
7177c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
7187c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
7197c478bd9Sstevel@tonic-gate 		break;
7207c478bd9Sstevel@tonic-gate 
7217c478bd9Sstevel@tonic-gate 	case KIOCGTRANS:
7227c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANS\n"));
7237c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
7247c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
7257c478bd9Sstevel@tonic-gate 			goto allocfailure;
7267c478bd9Sstevel@tonic-gate 		}
7277c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = upper->kbtrans_streams_translate_mode;
7287c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
7297c478bd9Sstevel@tonic-gate 		if (mp->b_cont)  /* free msg to prevent memory leak */
7307c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
7317c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
7327c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
7337c478bd9Sstevel@tonic-gate 		break;
7347c478bd9Sstevel@tonic-gate 
7357c478bd9Sstevel@tonic-gate 	case VUIDSADDR:
7367c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSADDR\n"));
7377c478bd9Sstevel@tonic-gate 
7387c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (Vuid_addr_probe));
7397c478bd9Sstevel@tonic-gate 		if (err != 0)
7407c478bd9Sstevel@tonic-gate 			break;
7417c478bd9Sstevel@tonic-gate 		addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr;
7427c478bd9Sstevel@tonic-gate 		switch (addr_probe->base) {
7437c478bd9Sstevel@tonic-gate 
7447c478bd9Sstevel@tonic-gate 		case ASCII_FIRST:
7457c478bd9Sstevel@tonic-gate 			addr_ptr = &upper->kbtrans_streams_vuid_addr.ascii;
7467c478bd9Sstevel@tonic-gate 			break;
7477c478bd9Sstevel@tonic-gate 
7487c478bd9Sstevel@tonic-gate 		case TOP_FIRST:
7497c478bd9Sstevel@tonic-gate 			addr_ptr = &upper->kbtrans_streams_vuid_addr.top;
7507c478bd9Sstevel@tonic-gate 			break;
7517c478bd9Sstevel@tonic-gate 
7527c478bd9Sstevel@tonic-gate 		case VKEY_FIRST:
7537c478bd9Sstevel@tonic-gate 			addr_ptr = &upper->kbtrans_streams_vuid_addr.vkey;
7547c478bd9Sstevel@tonic-gate 			break;
7557c478bd9Sstevel@tonic-gate 
7567c478bd9Sstevel@tonic-gate 		default:
7577c478bd9Sstevel@tonic-gate 			err = ENODEV;
7587c478bd9Sstevel@tonic-gate 		}
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 		if ((err == 0) && (*addr_ptr != addr_probe->data.next)) {
7617c478bd9Sstevel@tonic-gate 			*addr_ptr = addr_probe->data.next;
7627c478bd9Sstevel@tonic-gate 			kbtrans_flush(upper);
7637c478bd9Sstevel@tonic-gate 		}
7647c478bd9Sstevel@tonic-gate 		break;
7657c478bd9Sstevel@tonic-gate 
7667c478bd9Sstevel@tonic-gate 	case VUIDGADDR:
7677c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGADDR\n"));
7687c478bd9Sstevel@tonic-gate 
7697c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (Vuid_addr_probe));
7707c478bd9Sstevel@tonic-gate 		if (err != 0)
7717c478bd9Sstevel@tonic-gate 			break;
7727c478bd9Sstevel@tonic-gate 		addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr;
7737c478bd9Sstevel@tonic-gate 		switch (addr_probe->base) {
7747c478bd9Sstevel@tonic-gate 
7757c478bd9Sstevel@tonic-gate 		case ASCII_FIRST:
7767c478bd9Sstevel@tonic-gate 			addr_probe->data.current =
7777c478bd9Sstevel@tonic-gate 				upper->kbtrans_streams_vuid_addr.ascii;
7787c478bd9Sstevel@tonic-gate 			break;
7797c478bd9Sstevel@tonic-gate 
7807c478bd9Sstevel@tonic-gate 		case TOP_FIRST:
7817c478bd9Sstevel@tonic-gate 			addr_probe->data.current =
7827c478bd9Sstevel@tonic-gate 				upper->kbtrans_streams_vuid_addr.top;
7837c478bd9Sstevel@tonic-gate 			break;
7847c478bd9Sstevel@tonic-gate 
7857c478bd9Sstevel@tonic-gate 		case VKEY_FIRST:
7867c478bd9Sstevel@tonic-gate 			addr_probe->data.current =
7877c478bd9Sstevel@tonic-gate 				upper->kbtrans_streams_vuid_addr.vkey;
7887c478bd9Sstevel@tonic-gate 			break;
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate 		default:
7917c478bd9Sstevel@tonic-gate 			err = ENODEV;
7927c478bd9Sstevel@tonic-gate 		}
7937c478bd9Sstevel@tonic-gate 		break;
7947c478bd9Sstevel@tonic-gate 
7957c478bd9Sstevel@tonic-gate 	case KIOCTRANSABLE:
7967c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANSABLE\n"));
7977c478bd9Sstevel@tonic-gate 
7987c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
7997c478bd9Sstevel@tonic-gate 		if (err != 0)
8007c478bd9Sstevel@tonic-gate 			break;
8017c478bd9Sstevel@tonic-gate 		/*
8027c478bd9Sstevel@tonic-gate 		 * called during console setup in kbconfig()
8037c478bd9Sstevel@tonic-gate 		 * If set to false, means we are a serial keyboard,
8047c478bd9Sstevel@tonic-gate 		 * and we should pass all data up without modification.
8057c478bd9Sstevel@tonic-gate 		 */
8067c478bd9Sstevel@tonic-gate 		translate = *(int *)mp->b_cont->b_rptr;
8077c478bd9Sstevel@tonic-gate 		if (upper->kbtrans_streams_translatable != translate)
8087c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_translatable = translate;
8097c478bd9Sstevel@tonic-gate 
8107c478bd9Sstevel@tonic-gate 		if (translate != TR_CAN)
8117c478bd9Sstevel@tonic-gate 			DPRINTF(PRINT_L4, PRINT_MASK_ALL, (upper,
8127c478bd9Sstevel@tonic-gate 			    "Cannot translate keyboard using tables.\n"));
8137c478bd9Sstevel@tonic-gate 		break;
8147c478bd9Sstevel@tonic-gate 
8157c478bd9Sstevel@tonic-gate 	case KIOCGTRANSABLE:
8167c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANSABLE\n"));
8177c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
8187c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
8197c478bd9Sstevel@tonic-gate 			goto allocfailure;
8207c478bd9Sstevel@tonic-gate 		}
8217c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = upper->kbtrans_streams_translatable;
8227c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
8237c478bd9Sstevel@tonic-gate 		if (mp->b_cont)  /* free msg to prevent memory leak */
8247c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
8257c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
8267c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
8277c478bd9Sstevel@tonic-gate 		break;
8287c478bd9Sstevel@tonic-gate 
8297c478bd9Sstevel@tonic-gate 	case KIOCSCOMPAT:
8307c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSCOMPAT\n"));
8317c478bd9Sstevel@tonic-gate 
8327c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
8337c478bd9Sstevel@tonic-gate 		if (err != 0)
8347c478bd9Sstevel@tonic-gate 			break;
8357c478bd9Sstevel@tonic-gate 		lower->kbtrans_compat = *(int *)mp->b_cont->b_rptr;
8367c478bd9Sstevel@tonic-gate 		break;
8377c478bd9Sstevel@tonic-gate 
8387c478bd9Sstevel@tonic-gate 	case KIOCGCOMPAT:
8397c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGCOMPAT\n"));
8407c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
8417c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
8427c478bd9Sstevel@tonic-gate 			goto allocfailure;
8437c478bd9Sstevel@tonic-gate 		}
8447c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = lower->kbtrans_compat;
8457c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
8467c478bd9Sstevel@tonic-gate 		if (mp->b_cont)  /* free msg to prevent memory leak */
8477c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
8487c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
8497c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
8507c478bd9Sstevel@tonic-gate 		break;
8517c478bd9Sstevel@tonic-gate 
8527c478bd9Sstevel@tonic-gate 	case KIOCSETKEY:
8537c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSETKEY %d\n",
8547c478bd9Sstevel@tonic-gate 							kiocsetkey++));
8557c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (struct kiockey));
8567c478bd9Sstevel@tonic-gate 		if (err != 0)
8577c478bd9Sstevel@tonic-gate 			break;
8587c478bd9Sstevel@tonic-gate 		err = kbtrans_setkey(&upper->kbtrans_lower,
8597c478bd9Sstevel@tonic-gate 		    (struct kiockey *)mp->b_cont->b_rptr, iocp->ioc_cr);
8607c478bd9Sstevel@tonic-gate 		/*
8617c478bd9Sstevel@tonic-gate 		 * Since this only affects any subsequent key presses,
8627c478bd9Sstevel@tonic-gate 		 * don't flush soft state.  One might want to
8637c478bd9Sstevel@tonic-gate 		 * toggle the keytable entries dynamically.
8647c478bd9Sstevel@tonic-gate 		 */
8657c478bd9Sstevel@tonic-gate 		break;
8667c478bd9Sstevel@tonic-gate 
8677c478bd9Sstevel@tonic-gate 	case KIOCGETKEY:
8687c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGETKEY %d\n",
8697c478bd9Sstevel@tonic-gate 							kiocgetkey++));
8707c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (struct kiockey));
8717c478bd9Sstevel@tonic-gate 		if (err != 0)
8727c478bd9Sstevel@tonic-gate 			break;
8737c478bd9Sstevel@tonic-gate 		err = kbtrans_getkey(&upper->kbtrans_lower,
8747c478bd9Sstevel@tonic-gate 		    (struct kiockey *)mp->b_cont->b_rptr);
8757c478bd9Sstevel@tonic-gate 		break;
8767c478bd9Sstevel@tonic-gate 
8777c478bd9Sstevel@tonic-gate 	case KIOCSKEY:
8787c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (struct kiockeymap));
8797c478bd9Sstevel@tonic-gate 		if (err != 0)
8807c478bd9Sstevel@tonic-gate 			break;
8817c478bd9Sstevel@tonic-gate 		err = kbtrans_skey(&upper->kbtrans_lower,
8827c478bd9Sstevel@tonic-gate 		    (struct kiockeymap *)mp->b_cont->b_rptr, iocp->ioc_cr);
8837c478bd9Sstevel@tonic-gate 		/*
8847c478bd9Sstevel@tonic-gate 		 * Since this only affects any subsequent key presses,
8857c478bd9Sstevel@tonic-gate 		 * don't flush soft state.  One might want to
8867c478bd9Sstevel@tonic-gate 		 * toggle the keytable entries dynamically.
8877c478bd9Sstevel@tonic-gate 		 */
8887c478bd9Sstevel@tonic-gate 		break;
8897c478bd9Sstevel@tonic-gate 
8907c478bd9Sstevel@tonic-gate 	case KIOCGKEY:
8917c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (struct kiockeymap));
8927c478bd9Sstevel@tonic-gate 		if (err != 0)
8937c478bd9Sstevel@tonic-gate 			break;
8947c478bd9Sstevel@tonic-gate 		err = kbtrans_gkey(&upper->kbtrans_lower,
8957c478bd9Sstevel@tonic-gate 		    (struct kiockeymap *)mp->b_cont->b_rptr);
8967c478bd9Sstevel@tonic-gate 		break;
8977c478bd9Sstevel@tonic-gate 
8987c478bd9Sstevel@tonic-gate 	case KIOCSDIRECT:
8997c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSDIRECT\n"));
9007c478bd9Sstevel@tonic-gate 		kbtrans_flush(upper);
9017c478bd9Sstevel@tonic-gate 		break;
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 	case KIOCGDIRECT:
9047c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSGDIRECT\n"));
9057c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
9067c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
9077c478bd9Sstevel@tonic-gate 			goto allocfailure;
9087c478bd9Sstevel@tonic-gate 		}
9097c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = 1;	/* always direct */
9107c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
9117c478bd9Sstevel@tonic-gate 		if (mp->b_cont) /* free msg to prevent memory leak */
9127c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
9137c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
9147c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
9157c478bd9Sstevel@tonic-gate 		break;
9167c478bd9Sstevel@tonic-gate 
9177c478bd9Sstevel@tonic-gate 	case KIOCTYPE:
9187c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTYPE\n"));
9197c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
9207c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
9217c478bd9Sstevel@tonic-gate 			goto allocfailure;
9227c478bd9Sstevel@tonic-gate 		}
9237c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = upper->kbtrans_streams_id;
9247c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
9257c478bd9Sstevel@tonic-gate 		if (mp->b_cont) /* free msg to prevent memory leak */
9267c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
9277c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
9287c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
9297c478bd9Sstevel@tonic-gate 		break;
9307c478bd9Sstevel@tonic-gate 
9317c478bd9Sstevel@tonic-gate 	case CONSSETABORTENABLE:
9327c478bd9Sstevel@tonic-gate 		/*
9337c478bd9Sstevel@tonic-gate 		 * Peek as it goes by; must be a TRANSPARENT ioctl.
9347c478bd9Sstevel@tonic-gate 		 */
9357c478bd9Sstevel@tonic-gate 		if (iocp->ioc_count != TRANSPARENT) {
9367c478bd9Sstevel@tonic-gate 			err = EINVAL;
9377c478bd9Sstevel@tonic-gate 			break;
9387c478bd9Sstevel@tonic-gate 		}
9397c478bd9Sstevel@tonic-gate 
9407c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_abortable =
9417c478bd9Sstevel@tonic-gate 		    (boolean_t)*(intptr_t *)mp->b_cont->b_rptr;
9427c478bd9Sstevel@tonic-gate 
9437c478bd9Sstevel@tonic-gate 		/*
9447c478bd9Sstevel@tonic-gate 		 * Let the hardware module see it too.
9457c478bd9Sstevel@tonic-gate 		 */
9467c478bd9Sstevel@tonic-gate 		return (KBTRANS_MESSAGE_NOT_HANDLED);
9477c478bd9Sstevel@tonic-gate 
9487c478bd9Sstevel@tonic-gate 	case KIOCGRPTDELAY:
9497c478bd9Sstevel@tonic-gate 		/*
9507c478bd9Sstevel@tonic-gate 		 * Report the autorepeat delay, unit in millisecond
9517c478bd9Sstevel@tonic-gate 		 */
9527c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTDELAY\n"));
9537c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
9547c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
9557c478bd9Sstevel@tonic-gate 			goto allocfailure;
9567c478bd9Sstevel@tonic-gate 		}
9577c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_delay);
9587c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
9597c478bd9Sstevel@tonic-gate 
9607c478bd9Sstevel@tonic-gate 		/* free msg to prevent memory leak */
9617c478bd9Sstevel@tonic-gate 		if (mp->b_cont != NULL)
9627c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
9637c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
9647c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
9657c478bd9Sstevel@tonic-gate 		break;
9667c478bd9Sstevel@tonic-gate 
9677c478bd9Sstevel@tonic-gate 	case KIOCSRPTDELAY:
9687c478bd9Sstevel@tonic-gate 		/*
9697c478bd9Sstevel@tonic-gate 		 * Set the autorepeat delay
9707c478bd9Sstevel@tonic-gate 		 */
9717c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTDELAY\n"));
9727c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
9737c478bd9Sstevel@tonic-gate 
9747c478bd9Sstevel@tonic-gate 		if (err != 0)
9757c478bd9Sstevel@tonic-gate 			break;
9767c478bd9Sstevel@tonic-gate 
9777c478bd9Sstevel@tonic-gate 		/* validate the input */
9787c478bd9Sstevel@tonic-gate 		if (*(int *)mp->b_cont->b_rptr < KIOCRPTDELAY_MIN) {
9797c478bd9Sstevel@tonic-gate 			err = EINVAL;
9807c478bd9Sstevel@tonic-gate 			break;
9817c478bd9Sstevel@tonic-gate 		}
9827c478bd9Sstevel@tonic-gate 		kbtrans_repeat_delay = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr);
9837c478bd9Sstevel@tonic-gate 		if (kbtrans_repeat_delay <= 0)
9847c478bd9Sstevel@tonic-gate 			kbtrans_repeat_delay = 1;
9857c478bd9Sstevel@tonic-gate 		break;
9867c478bd9Sstevel@tonic-gate 
9877c478bd9Sstevel@tonic-gate 	case KIOCGRPTRATE:
9887c478bd9Sstevel@tonic-gate 		/*
9897c478bd9Sstevel@tonic-gate 		 * Report the autorepeat rate
9907c478bd9Sstevel@tonic-gate 		 */
9917c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTRATE\n"));
9927c478bd9Sstevel@tonic-gate 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
9937c478bd9Sstevel@tonic-gate 			ioctlrespsize = sizeof (int);
9947c478bd9Sstevel@tonic-gate 			goto allocfailure;
9957c478bd9Sstevel@tonic-gate 		}
9967c478bd9Sstevel@tonic-gate 		*(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_rate);
9977c478bd9Sstevel@tonic-gate 		datap->b_wptr += sizeof (int);
9987c478bd9Sstevel@tonic-gate 
9997c478bd9Sstevel@tonic-gate 		/* free msg to prevent memory leak */
10007c478bd9Sstevel@tonic-gate 		if (mp->b_cont != NULL)
10017c478bd9Sstevel@tonic-gate 			freemsg(mp->b_cont);
10027c478bd9Sstevel@tonic-gate 		mp->b_cont = datap;
10037c478bd9Sstevel@tonic-gate 		iocp->ioc_count = sizeof (int);
10047c478bd9Sstevel@tonic-gate 		break;
10057c478bd9Sstevel@tonic-gate 
10067c478bd9Sstevel@tonic-gate 	case KIOCSRPTRATE:
10077c478bd9Sstevel@tonic-gate 		/*
10087c478bd9Sstevel@tonic-gate 		 * Set the autorepeat rate
10097c478bd9Sstevel@tonic-gate 		 */
10107c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTRATE\n"));
10117c478bd9Sstevel@tonic-gate 		err = miocpullup(mp, sizeof (int));
10127c478bd9Sstevel@tonic-gate 
10137c478bd9Sstevel@tonic-gate 		if (err != 0)
10147c478bd9Sstevel@tonic-gate 			break;
10157c478bd9Sstevel@tonic-gate 
10167c478bd9Sstevel@tonic-gate 		/* validate the input */
10177c478bd9Sstevel@tonic-gate 		if (*(int *)mp->b_cont->b_rptr < KIOCRPTRATE_MIN) {
10187c478bd9Sstevel@tonic-gate 			err = EINVAL;
10197c478bd9Sstevel@tonic-gate 			break;
10207c478bd9Sstevel@tonic-gate 		}
10217c478bd9Sstevel@tonic-gate 		kbtrans_repeat_rate = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr);
10227c478bd9Sstevel@tonic-gate 		if (kbtrans_repeat_rate <= 0)
10237c478bd9Sstevel@tonic-gate 			kbtrans_repeat_rate = 1;
10247c478bd9Sstevel@tonic-gate 		break;
10257c478bd9Sstevel@tonic-gate 
10267c478bd9Sstevel@tonic-gate 	default:
10277c478bd9Sstevel@tonic-gate 		DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "unknown\n"));
10287c478bd9Sstevel@tonic-gate 		return (KBTRANS_MESSAGE_NOT_HANDLED);
10297c478bd9Sstevel@tonic-gate 	} /* end switch */
10307c478bd9Sstevel@tonic-gate 
10317c478bd9Sstevel@tonic-gate 	if (err != 0) {
10327c478bd9Sstevel@tonic-gate 		iocp->ioc_rval = 0;
10337c478bd9Sstevel@tonic-gate 		iocp->ioc_error = err;
10347c478bd9Sstevel@tonic-gate 		mp->b_datap->db_type = M_IOCNAK;
10357c478bd9Sstevel@tonic-gate 	} else {
10367c478bd9Sstevel@tonic-gate 		iocp->ioc_rval = 0;
10377c478bd9Sstevel@tonic-gate 		iocp->ioc_error = 0;	/* brain rot */
10387c478bd9Sstevel@tonic-gate 		mp->b_datap->db_type = M_IOCACK;
10397c478bd9Sstevel@tonic-gate 	}
10407c478bd9Sstevel@tonic-gate 	putnext(upper->kbtrans_streams_readq, mp);
10417c478bd9Sstevel@tonic-gate 
10427c478bd9Sstevel@tonic-gate 	return (KBTRANS_MESSAGE_HANDLED);
10437c478bd9Sstevel@tonic-gate 
10447c478bd9Sstevel@tonic-gate allocfailure:
10457c478bd9Sstevel@tonic-gate 	/*
10467c478bd9Sstevel@tonic-gate 	 * We needed to allocate something to handle this "ioctl", but
10477c478bd9Sstevel@tonic-gate 	 * couldn't; save this "ioctl" and arrange to get called back when
10487c478bd9Sstevel@tonic-gate 	 * it's more likely that we can get what we need.
10497c478bd9Sstevel@tonic-gate 	 * If there's already one being saved, throw it out, since it
10507c478bd9Sstevel@tonic-gate 	 * must have timed out.
10517c478bd9Sstevel@tonic-gate 	 */
10527c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_iocpending != NULL)
10537c478bd9Sstevel@tonic-gate 		freemsg(upper->kbtrans_streams_iocpending);
10547c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_iocpending = mp;
10557c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_bufcallid) {
10567c478bd9Sstevel@tonic-gate 		qunbufcall(upper->kbtrans_streams_readq,
10577c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_bufcallid);
10587c478bd9Sstevel@tonic-gate 	}
10597c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_bufcallid =
10607c478bd9Sstevel@tonic-gate 		qbufcall(upper->kbtrans_streams_readq, ioctlrespsize, BPRI_HI,
10617c478bd9Sstevel@tonic-gate 			kbtrans_reioctl, upper);
10627c478bd9Sstevel@tonic-gate 	/*
10637c478bd9Sstevel@tonic-gate 	 * This is a white lie... we *will* handle it, eventually.
10647c478bd9Sstevel@tonic-gate 	 */
10657c478bd9Sstevel@tonic-gate 	return (KBTRANS_MESSAGE_HANDLED);
10667c478bd9Sstevel@tonic-gate }
10677c478bd9Sstevel@tonic-gate 
10687c478bd9Sstevel@tonic-gate /*
10697c478bd9Sstevel@tonic-gate  * kbtrans_flush:
10707c478bd9Sstevel@tonic-gate  *	Flush data upstream
10717c478bd9Sstevel@tonic-gate  */
10727c478bd9Sstevel@tonic-gate static void
10737c478bd9Sstevel@tonic-gate kbtrans_flush(register struct kbtrans *upper)
10747c478bd9Sstevel@tonic-gate {
10757c478bd9Sstevel@tonic-gate 	register queue_t *q;
10767c478bd9Sstevel@tonic-gate 
10777c478bd9Sstevel@tonic-gate 	/* Flush pending data already sent upstream */
10787c478bd9Sstevel@tonic-gate 	if ((q = upper->kbtrans_streams_readq) != NULL && q->q_next != NULL)
10797c478bd9Sstevel@tonic-gate 		(void) putnextctl1(q, M_FLUSH, FLUSHR);
10807c478bd9Sstevel@tonic-gate 
10817c478bd9Sstevel@tonic-gate 	/* Flush pending ups */
10827c478bd9Sstevel@tonic-gate 	bzero(upper->kbtrans_streams_downs, upper->kbtrans_streams_downs_bytes);
10837c478bd9Sstevel@tonic-gate 
10847c478bd9Sstevel@tonic-gate 	kbtrans_cancelrpt(upper);
10857c478bd9Sstevel@tonic-gate }
10867c478bd9Sstevel@tonic-gate 
10877c478bd9Sstevel@tonic-gate /*
10887c478bd9Sstevel@tonic-gate  * kbtrans_setled:
10897c478bd9Sstevel@tonic-gate  *	 Update the keyboard LEDs to match the current keyboard state.
10907c478bd9Sstevel@tonic-gate  */
10917c478bd9Sstevel@tonic-gate static void
10927c478bd9Sstevel@tonic-gate kbtrans_setled(struct kbtrans *upper)
10937c478bd9Sstevel@tonic-gate {
10947c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_hw_callbacks->kbtrans_streams_setled(
10957c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_hw,
10967c478bd9Sstevel@tonic-gate 		upper->kbtrans_lower.kbtrans_led_state);
10977c478bd9Sstevel@tonic-gate }
10987c478bd9Sstevel@tonic-gate 
10997c478bd9Sstevel@tonic-gate /*
11007c478bd9Sstevel@tonic-gate  * kbtrans_rpt:
11017c478bd9Sstevel@tonic-gate  *	If a key is held down, this function is set up to be called
11027c478bd9Sstevel@tonic-gate  * 	after kbtrans_repeat_rate time elapses.
11037c478bd9Sstevel@tonic-gate  */
11047c478bd9Sstevel@tonic-gate static void
11057c478bd9Sstevel@tonic-gate kbtrans_rpt(void *arg)
11067c478bd9Sstevel@tonic-gate {
11077c478bd9Sstevel@tonic-gate 	struct kbtrans	*upper = arg;
11087c478bd9Sstevel@tonic-gate 	struct kbtrans_lower	*lower = &upper->kbtrans_lower;
11097c478bd9Sstevel@tonic-gate 
11107c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL,
11117c478bd9Sstevel@tonic-gate 		"kbtrans_rpt: repeat key %X\n",
11127c478bd9Sstevel@tonic-gate 		lower->kbtrans_repeatkey));
11137c478bd9Sstevel@tonic-gate 
11147c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_rptid = 0;
11157c478bd9Sstevel@tonic-gate 
11167c478bd9Sstevel@tonic-gate 	/*
11177c478bd9Sstevel@tonic-gate 	 * NB:  polled code zaps kbtrans_repeatkey without cancelling
11187c478bd9Sstevel@tonic-gate 	 * timeout.
11197c478bd9Sstevel@tonic-gate 	 */
11207c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_repeatkey != 0) {
11217c478bd9Sstevel@tonic-gate 		kbtrans_keyreleased(upper, lower->kbtrans_repeatkey);
11227c478bd9Sstevel@tonic-gate 
11237c478bd9Sstevel@tonic-gate 		kbtrans_processkey(lower,
11247c478bd9Sstevel@tonic-gate 			upper->kbtrans_streams_callback,
11257c478bd9Sstevel@tonic-gate 			lower->kbtrans_repeatkey,
11267c478bd9Sstevel@tonic-gate 			KEY_PRESSED);
11277c478bd9Sstevel@tonic-gate 
11287c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_rptid =
11297c478bd9Sstevel@tonic-gate 			qtimeout(upper->kbtrans_streams_readq, kbtrans_rpt,
11307c478bd9Sstevel@tonic-gate 			    (caddr_t)upper, kbtrans_repeat_rate);
11317c478bd9Sstevel@tonic-gate 	}
11327c478bd9Sstevel@tonic-gate }
11337c478bd9Sstevel@tonic-gate 
11347c478bd9Sstevel@tonic-gate /*
11357c478bd9Sstevel@tonic-gate  * kbtrans_cancelrpt:
11367c478bd9Sstevel@tonic-gate  * 	Cancel the repeating key
11377c478bd9Sstevel@tonic-gate  */
11387c478bd9Sstevel@tonic-gate static void
11397c478bd9Sstevel@tonic-gate kbtrans_cancelrpt(struct kbtrans	*upper)
11407c478bd9Sstevel@tonic-gate {
11417c478bd9Sstevel@tonic-gate 	upper->kbtrans_lower.kbtrans_repeatkey = 0;
11427c478bd9Sstevel@tonic-gate 
11437c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_rptid != 0) {
11447c478bd9Sstevel@tonic-gate 		(void) quntimeout(upper->kbtrans_streams_readq,
11457c478bd9Sstevel@tonic-gate 				    upper->kbtrans_streams_rptid);
11467c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_rptid = 0;
11477c478bd9Sstevel@tonic-gate 	}
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate 
11507c478bd9Sstevel@tonic-gate /*
11517c478bd9Sstevel@tonic-gate  * kbtrans_send_esc_event:
11527c478bd9Sstevel@tonic-gate  *	Send character up stream. Used for the case of
11537c478bd9Sstevel@tonic-gate  *	sending strings upstream.
11547c478bd9Sstevel@tonic-gate  */
11557c478bd9Sstevel@tonic-gate static void
11567c478bd9Sstevel@tonic-gate kbtrans_send_esc_event(char c, register struct kbtrans *upper)
11577c478bd9Sstevel@tonic-gate {
11587c478bd9Sstevel@tonic-gate 	Firm_event fe;
11597c478bd9Sstevel@tonic-gate 
11607c478bd9Sstevel@tonic-gate 	fe.id = c;
11617c478bd9Sstevel@tonic-gate 	fe.value = 1;
11627c478bd9Sstevel@tonic-gate 	fe.pair_type = FE_PAIR_NONE;
11637c478bd9Sstevel@tonic-gate 	fe.pair = 0;
11647c478bd9Sstevel@tonic-gate 	/*
11657c478bd9Sstevel@tonic-gate 	 * Pretend as if each cp pushed and released
11667c478bd9Sstevel@tonic-gate 	 * Calling kbtrans_queueevent avoids addr translation
11677c478bd9Sstevel@tonic-gate 	 * and pair base determination of kbtrans_keypressed.
11687c478bd9Sstevel@tonic-gate 	 */
11697c478bd9Sstevel@tonic-gate 	kbtrans_queueevent(upper, &fe);
11707c478bd9Sstevel@tonic-gate 	fe.value = 0;
11717c478bd9Sstevel@tonic-gate 	kbtrans_queueevent(upper, &fe);
11727c478bd9Sstevel@tonic-gate }
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate /*
11757c478bd9Sstevel@tonic-gate  * kbtrans_strsetwithdecimal:
11767c478bd9Sstevel@tonic-gate  *	Used for expanding a function key to the ascii equivalent
11777c478bd9Sstevel@tonic-gate  */
11787c478bd9Sstevel@tonic-gate static char *
11797c478bd9Sstevel@tonic-gate kbtrans_strsetwithdecimal(char *buf, uint_t val, uint_t maxdigs)
11807c478bd9Sstevel@tonic-gate {
11817c478bd9Sstevel@tonic-gate 	int	hradix = 5;
11827c478bd9Sstevel@tonic-gate 	char	*bp;
11837c478bd9Sstevel@tonic-gate 	int	lowbit;
11847c478bd9Sstevel@tonic-gate 	char	*tab = "0123456789abcdef";
11857c478bd9Sstevel@tonic-gate 
11867c478bd9Sstevel@tonic-gate 	bp = buf + maxdigs;
11877c478bd9Sstevel@tonic-gate 	*(--bp) = '\0';
11887c478bd9Sstevel@tonic-gate 	while (val) {
11897c478bd9Sstevel@tonic-gate 		lowbit = val & 1;
11907c478bd9Sstevel@tonic-gate 		val = (val >> 1);
11917c478bd9Sstevel@tonic-gate 		*(--bp) = tab[val % hradix * 2 + lowbit];
11927c478bd9Sstevel@tonic-gate 		val /= hradix;
11937c478bd9Sstevel@tonic-gate 	}
11947c478bd9Sstevel@tonic-gate 	return (bp);
11957c478bd9Sstevel@tonic-gate }
11967c478bd9Sstevel@tonic-gate 
11977c478bd9Sstevel@tonic-gate /*
11987c478bd9Sstevel@tonic-gate  * kbtrans_keypressed:
11997c478bd9Sstevel@tonic-gate  *	Modify Firm event to be sent up the stream
12007c478bd9Sstevel@tonic-gate  */
12017c478bd9Sstevel@tonic-gate static void
12027c478bd9Sstevel@tonic-gate kbtrans_keypressed(struct kbtrans *upper, uchar_t key_station,
12037c478bd9Sstevel@tonic-gate 		    Firm_event *fe, ushort_t base)
12047c478bd9Sstevel@tonic-gate {
12057c478bd9Sstevel@tonic-gate 
12067c478bd9Sstevel@tonic-gate 	register short	id_addr;
12077c478bd9Sstevel@tonic-gate 	struct kbtrans_lower	*lower = &upper->kbtrans_lower;
12087c478bd9Sstevel@tonic-gate 
12097c478bd9Sstevel@tonic-gate 	/* Set pair values */
12107c478bd9Sstevel@tonic-gate 	if (fe->id < (ushort_t)VKEY_FIRST) {
12117c478bd9Sstevel@tonic-gate 		/*
12127c478bd9Sstevel@tonic-gate 		 * If CTRLed, find the ID that would have been used had it
12137c478bd9Sstevel@tonic-gate 		 * not been CTRLed.
12147c478bd9Sstevel@tonic-gate 		 */
12157c478bd9Sstevel@tonic-gate 		if (lower->kbtrans_shiftmask & (CTRLMASK | CTLSMASK)) {
12167c478bd9Sstevel@tonic-gate 			unsigned short *ke;
12177c478bd9Sstevel@tonic-gate 			unsigned int mask;
12187c478bd9Sstevel@tonic-gate 
12197c478bd9Sstevel@tonic-gate 			mask = lower->kbtrans_shiftmask &
12207c478bd9Sstevel@tonic-gate 				~(CTRLMASK | CTLSMASK | UPMASK);
12217c478bd9Sstevel@tonic-gate 
12227c478bd9Sstevel@tonic-gate 			ke = kbtrans_find_entry(lower, mask, key_station);
12237c478bd9Sstevel@tonic-gate 			if (ke == NULL)
12247c478bd9Sstevel@tonic-gate 				return;
12257c478bd9Sstevel@tonic-gate 
12267c478bd9Sstevel@tonic-gate 			base = *ke;
12277c478bd9Sstevel@tonic-gate 		}
12287c478bd9Sstevel@tonic-gate 		if (base != fe->id) {
12297c478bd9Sstevel@tonic-gate 			fe->pair_type = FE_PAIR_SET;
12307c478bd9Sstevel@tonic-gate 			fe->pair = (uchar_t)base;
12317c478bd9Sstevel@tonic-gate 
12327c478bd9Sstevel@tonic-gate 			goto send;
12337c478bd9Sstevel@tonic-gate 		}
12347c478bd9Sstevel@tonic-gate 	}
12357c478bd9Sstevel@tonic-gate 	fe->pair_type = FE_PAIR_NONE;
12367c478bd9Sstevel@tonic-gate 	fe->pair = 0;
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate send:
12397c478bd9Sstevel@tonic-gate 	/* Adjust event id address for multiple keyboard/workstation support */
12407c478bd9Sstevel@tonic-gate 	switch (vuid_id_addr(fe->id)) {
12417c478bd9Sstevel@tonic-gate 	case ASCII_FIRST:
12427c478bd9Sstevel@tonic-gate 		id_addr = upper->kbtrans_streams_vuid_addr.ascii;
12437c478bd9Sstevel@tonic-gate 		break;
12447c478bd9Sstevel@tonic-gate 	case TOP_FIRST:
12457c478bd9Sstevel@tonic-gate 		id_addr = upper->kbtrans_streams_vuid_addr.top;
12467c478bd9Sstevel@tonic-gate 		break;
12477c478bd9Sstevel@tonic-gate 	case VKEY_FIRST:
12487c478bd9Sstevel@tonic-gate 		id_addr = upper->kbtrans_streams_vuid_addr.vkey;
12497c478bd9Sstevel@tonic-gate 		break;
12507c478bd9Sstevel@tonic-gate 	default:
12517c478bd9Sstevel@tonic-gate 		id_addr = vuid_id_addr(fe->id);
12527c478bd9Sstevel@tonic-gate 		break;
12537c478bd9Sstevel@tonic-gate 	}
12547c478bd9Sstevel@tonic-gate 	fe->id = vuid_id_offset(fe->id) | id_addr;
12557c478bd9Sstevel@tonic-gate 
12567c478bd9Sstevel@tonic-gate 	kbtrans_queuepress(upper, key_station, fe);
12577c478bd9Sstevel@tonic-gate }
12587c478bd9Sstevel@tonic-gate 
12597c478bd9Sstevel@tonic-gate /*
12607c478bd9Sstevel@tonic-gate  * kbtrans_queuepress:
12617c478bd9Sstevel@tonic-gate  *	Add keypress to the "downs" table
12627c478bd9Sstevel@tonic-gate  */
12637c478bd9Sstevel@tonic-gate static void
12647c478bd9Sstevel@tonic-gate kbtrans_queuepress(struct kbtrans *upper,
12657c478bd9Sstevel@tonic-gate 		    uchar_t key_station, Firm_event *fe)
12667c478bd9Sstevel@tonic-gate {
12677c478bd9Sstevel@tonic-gate 	register struct key_event *ke, *ke_free;
12687c478bd9Sstevel@tonic-gate 	register int i;
12697c478bd9Sstevel@tonic-gate 
12707c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "kbtrans_queuepress:"
12717c478bd9Sstevel@tonic-gate 		" key=%d", key_station));
12727c478bd9Sstevel@tonic-gate 
12737c478bd9Sstevel@tonic-gate 	ke_free = 0;
12747c478bd9Sstevel@tonic-gate 
12757c478bd9Sstevel@tonic-gate 	/* Scan table of down key stations */
12767c478bd9Sstevel@tonic-gate 
12777c478bd9Sstevel@tonic-gate 	for (i = 0, ke = upper->kbtrans_streams_downs;
12787c478bd9Sstevel@tonic-gate 	    i < upper->kbtrans_streams_num_downs_entries; i++, ke++) {
12797c478bd9Sstevel@tonic-gate 
12807c478bd9Sstevel@tonic-gate 		/* Keycode already down? */
12817c478bd9Sstevel@tonic-gate 		if (ke->key_station == key_station) {
12827c478bd9Sstevel@tonic-gate 
12837c478bd9Sstevel@tonic-gate 			DPRINTF(PRINT_L0, PRINT_MASK_ALL,
12847c478bd9Sstevel@tonic-gate 				(NULL, "kbtrans: Double "
12857c478bd9Sstevel@tonic-gate 				"entry in downs table (%d,%d)!\n",
12867c478bd9Sstevel@tonic-gate 				key_station, i));
12877c478bd9Sstevel@tonic-gate 
12887c478bd9Sstevel@tonic-gate 			goto add_event;
12897c478bd9Sstevel@tonic-gate 		}
12907c478bd9Sstevel@tonic-gate 
12917c478bd9Sstevel@tonic-gate 		if (ke->key_station == 0)
12927c478bd9Sstevel@tonic-gate 			ke_free = ke;
12937c478bd9Sstevel@tonic-gate 	}
12947c478bd9Sstevel@tonic-gate 
12957c478bd9Sstevel@tonic-gate 	if (ke_free) {
12967c478bd9Sstevel@tonic-gate 		ke = ke_free;
12977c478bd9Sstevel@tonic-gate 		goto add_event;
12987c478bd9Sstevel@tonic-gate 	}
12997c478bd9Sstevel@tonic-gate 
13007c478bd9Sstevel@tonic-gate 	ke = upper->kbtrans_streams_downs;
13017c478bd9Sstevel@tonic-gate 
13027c478bd9Sstevel@tonic-gate add_event:
13037c478bd9Sstevel@tonic-gate 	ke->key_station = key_station;
13047c478bd9Sstevel@tonic-gate 	ke->event = *fe;
13057c478bd9Sstevel@tonic-gate 	kbtrans_queueevent(upper, fe);
13067c478bd9Sstevel@tonic-gate }
13077c478bd9Sstevel@tonic-gate 
13087c478bd9Sstevel@tonic-gate /*
13097c478bd9Sstevel@tonic-gate  * kbtrans_keyreleased:
13107c478bd9Sstevel@tonic-gate  * 	Remove entry from the downs table
13117c478bd9Sstevel@tonic-gate  */
13127c478bd9Sstevel@tonic-gate static void
13137c478bd9Sstevel@tonic-gate kbtrans_keyreleased(register struct kbtrans *upper, uchar_t key_station)
13147c478bd9Sstevel@tonic-gate {
13157c478bd9Sstevel@tonic-gate 	register struct key_event *ke;
13167c478bd9Sstevel@tonic-gate 	register int i;
13177c478bd9Sstevel@tonic-gate 
13187c478bd9Sstevel@tonic-gate 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "RELEASE key=%d\n",
13197c478bd9Sstevel@tonic-gate 		key_station));
13207c478bd9Sstevel@tonic-gate 
13217c478bd9Sstevel@tonic-gate 	if (upper->kbtrans_streams_translate_mode != TR_EVENT &&
13227c478bd9Sstevel@tonic-gate 	    upper->kbtrans_streams_translate_mode != TR_UNTRANS_EVENT) {
13237c478bd9Sstevel@tonic-gate 
13247c478bd9Sstevel@tonic-gate 		return;
13257c478bd9Sstevel@tonic-gate 	}
13267c478bd9Sstevel@tonic-gate 
13277c478bd9Sstevel@tonic-gate 	/* Scan table of down key stations */
13287c478bd9Sstevel@tonic-gate 	for (i = 0, ke = upper->kbtrans_streams_downs;
13297c478bd9Sstevel@tonic-gate 	    i < upper->kbtrans_streams_num_downs_entries;
13307c478bd9Sstevel@tonic-gate 	    i++, ke++) {
13317c478bd9Sstevel@tonic-gate 		/* Found? */
13327c478bd9Sstevel@tonic-gate 		if (ke->key_station == key_station) {
13337c478bd9Sstevel@tonic-gate 			ke->key_station = 0;
13347c478bd9Sstevel@tonic-gate 			ke->event.value = 0;
13357c478bd9Sstevel@tonic-gate 			kbtrans_queueevent(upper, &ke->event);
13367c478bd9Sstevel@tonic-gate 		}
13377c478bd9Sstevel@tonic-gate 	}
13387c478bd9Sstevel@tonic-gate 
13397c478bd9Sstevel@tonic-gate 	/*
13407c478bd9Sstevel@tonic-gate 	 * Ignore if couldn't find because may be called twice
13417c478bd9Sstevel@tonic-gate 	 * for the same key station in the case of the kbtrans_rpt
13427c478bd9Sstevel@tonic-gate 	 * routine being called unnecessarily.
13437c478bd9Sstevel@tonic-gate 	 */
13447c478bd9Sstevel@tonic-gate }
13457c478bd9Sstevel@tonic-gate 
13467c478bd9Sstevel@tonic-gate 
13477c478bd9Sstevel@tonic-gate /*
13487c478bd9Sstevel@tonic-gate  * kbtrans_putcode:
13497c478bd9Sstevel@tonic-gate  *	 Pass a keycode up the stream, if you can, otherwise throw it away.
13507c478bd9Sstevel@tonic-gate  */
13517c478bd9Sstevel@tonic-gate static void
13527c478bd9Sstevel@tonic-gate kbtrans_putcode(register struct kbtrans *upper, uint_t code)
13537c478bd9Sstevel@tonic-gate {
13547c478bd9Sstevel@tonic-gate 	register mblk_t *bp;
13557c478bd9Sstevel@tonic-gate 
13567c478bd9Sstevel@tonic-gate 	/*
13577c478bd9Sstevel@tonic-gate 	 * If we can't send it up, then we just drop it.
13587c478bd9Sstevel@tonic-gate 	 */
13597c478bd9Sstevel@tonic-gate 	if (!canputnext(upper->kbtrans_streams_readq)) {
13607c478bd9Sstevel@tonic-gate 
13617c478bd9Sstevel@tonic-gate 		return;
13627c478bd9Sstevel@tonic-gate 	}
13637c478bd9Sstevel@tonic-gate 
13647c478bd9Sstevel@tonic-gate 	/*
13657c478bd9Sstevel@tonic-gate 	 * Allocate a messsage block to send up.
13667c478bd9Sstevel@tonic-gate 	 */
13677c478bd9Sstevel@tonic-gate 	if ((bp = allocb(sizeof (uint_t), BPRI_HI)) == NULL) {
13687c478bd9Sstevel@tonic-gate 
13697c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN, "kbtrans_putcode: Can't allocate block\
13707c478bd9Sstevel@tonic-gate 			for keycode.");
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate 		return;
13737c478bd9Sstevel@tonic-gate 	}
13747c478bd9Sstevel@tonic-gate 
13757c478bd9Sstevel@tonic-gate 	/*
13767c478bd9Sstevel@tonic-gate 	 * We will strip out any high order information here.
13777c478bd9Sstevel@tonic-gate 	 */
13787c478bd9Sstevel@tonic-gate 	/* NOTE the implicit cast here */
13797c478bd9Sstevel@tonic-gate 	*bp->b_wptr++ = (uchar_t)code;
13807c478bd9Sstevel@tonic-gate 
13817c478bd9Sstevel@tonic-gate 	/*
13827c478bd9Sstevel@tonic-gate 	 * Send the message up.
13837c478bd9Sstevel@tonic-gate 	 */
13847c478bd9Sstevel@tonic-gate 	(void) putnext(upper->kbtrans_streams_readq, bp);
13857c478bd9Sstevel@tonic-gate }
13867c478bd9Sstevel@tonic-gate 
13877c478bd9Sstevel@tonic-gate 
13887c478bd9Sstevel@tonic-gate /*
13897c478bd9Sstevel@tonic-gate  * kbtrans_putbuf:
13907c478bd9Sstevel@tonic-gate  *	Pass generated keycode sequence to upstream, if possible.
13917c478bd9Sstevel@tonic-gate  */
13927c478bd9Sstevel@tonic-gate static void
13937c478bd9Sstevel@tonic-gate kbtrans_putbuf(char *buf, queue_t *q)
13947c478bd9Sstevel@tonic-gate {
13957c478bd9Sstevel@tonic-gate 	register mblk_t *bp;
13967c478bd9Sstevel@tonic-gate 
13977c478bd9Sstevel@tonic-gate 	if (!canputnext(q)) {
13987c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN, "kbtrans_putbuf: Can't put block for keycode");
13997c478bd9Sstevel@tonic-gate 	} else {
14007c478bd9Sstevel@tonic-gate 		if ((bp = allocb((int)strlen(buf), BPRI_HI)) == NULL) {
14017c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "kbtrans_putbuf: "
14027c478bd9Sstevel@tonic-gate 			    "Can't allocate block for keycode");
14037c478bd9Sstevel@tonic-gate 		} else {
14047c478bd9Sstevel@tonic-gate 			while (*buf) {
14057c478bd9Sstevel@tonic-gate 				*bp->b_wptr++ = *buf;
14067c478bd9Sstevel@tonic-gate 				buf++;
14077c478bd9Sstevel@tonic-gate 			}
14087c478bd9Sstevel@tonic-gate 			putnext(q, bp);
14097c478bd9Sstevel@tonic-gate 		}
14107c478bd9Sstevel@tonic-gate 	}
14117c478bd9Sstevel@tonic-gate }
14127c478bd9Sstevel@tonic-gate 
14137c478bd9Sstevel@tonic-gate /*
14147c478bd9Sstevel@tonic-gate  * kbtrans_queueevent:
14157c478bd9Sstevel@tonic-gate  *	 Pass a VUID "firm event" up the stream, if you can.
14167c478bd9Sstevel@tonic-gate  */
14177c478bd9Sstevel@tonic-gate static void
14187c478bd9Sstevel@tonic-gate kbtrans_queueevent(struct kbtrans *upper, Firm_event *fe)
14197c478bd9Sstevel@tonic-gate {
14207c478bd9Sstevel@tonic-gate 	register queue_t *q;
14217c478bd9Sstevel@tonic-gate 	register mblk_t *bp;
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 	if ((q = upper->kbtrans_streams_readq) == NULL)
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 		return;
14267c478bd9Sstevel@tonic-gate 
14277c478bd9Sstevel@tonic-gate 	if (!canputnext(q)) {
14287c478bd9Sstevel@tonic-gate 		if (kbtrans_overflow_msg) {
14297c478bd9Sstevel@tonic-gate 			DPRINTF(PRINT_L2, PRINT_MASK_ALL, (NULL,
14307c478bd9Sstevel@tonic-gate 				"kbtrans: Buffer flushed when overflowed."));
14317c478bd9Sstevel@tonic-gate 		}
14327c478bd9Sstevel@tonic-gate 
14337c478bd9Sstevel@tonic-gate 		kbtrans_flush(upper);
14347c478bd9Sstevel@tonic-gate 		upper->kbtrans_overflow_cnt++;
14357c478bd9Sstevel@tonic-gate 	} else {
14367c478bd9Sstevel@tonic-gate 		if ((bp = allocb(sizeof (Firm_event), BPRI_HI)) == NULL) {
14377c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN, "kbtrans_queueevent: Can't allocate \
14387c478bd9Sstevel@tonic-gate 					block for event.");
14397c478bd9Sstevel@tonic-gate 		} else {
14407c478bd9Sstevel@tonic-gate 			uniqtime32(&fe->time);
14417c478bd9Sstevel@tonic-gate 			 *(Firm_event *)bp->b_wptr = *fe;
14427c478bd9Sstevel@tonic-gate 			bp->b_wptr += sizeof (Firm_event);
14437c478bd9Sstevel@tonic-gate 			(void) putnext(q, bp);
14447c478bd9Sstevel@tonic-gate 
14457c478bd9Sstevel@tonic-gate 
14467c478bd9Sstevel@tonic-gate 		}
14477c478bd9Sstevel@tonic-gate 	}
14487c478bd9Sstevel@tonic-gate }
14497c478bd9Sstevel@tonic-gate 
14507c478bd9Sstevel@tonic-gate /*
14517c478bd9Sstevel@tonic-gate  * kbtrans_set_translation_callback:
14527c478bd9Sstevel@tonic-gate  *	This code sets the translation_callback pointer based on the
14537c478bd9Sstevel@tonic-gate  * 	translation mode.
14547c478bd9Sstevel@tonic-gate  */
14557c478bd9Sstevel@tonic-gate static void
14567c478bd9Sstevel@tonic-gate kbtrans_set_translation_callback(register struct kbtrans *upper)
14577c478bd9Sstevel@tonic-gate {
14587c478bd9Sstevel@tonic-gate 	switch (upper->kbtrans_streams_translate_mode) {
14597c478bd9Sstevel@tonic-gate 
14607c478bd9Sstevel@tonic-gate 	default:
14617c478bd9Sstevel@tonic-gate 	case TR_ASCII:
14627c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_callback = &ascii_callback;
14637c478bd9Sstevel@tonic-gate 
14647c478bd9Sstevel@tonic-gate 		break;
14657c478bd9Sstevel@tonic-gate 
14667c478bd9Sstevel@tonic-gate 	case TR_EVENT:
14677c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_callback = &trans_event_callback;
14687c478bd9Sstevel@tonic-gate 
14697c478bd9Sstevel@tonic-gate 		break;
14707c478bd9Sstevel@tonic-gate 
14717c478bd9Sstevel@tonic-gate 	case TR_UNTRANS_EVENT:
14727c478bd9Sstevel@tonic-gate 		upper->kbtrans_streams_callback = &untrans_event_callback;
14737c478bd9Sstevel@tonic-gate 
14747c478bd9Sstevel@tonic-gate 		break;
14757c478bd9Sstevel@tonic-gate 	}
14767c478bd9Sstevel@tonic-gate }
14777c478bd9Sstevel@tonic-gate 
14787c478bd9Sstevel@tonic-gate /*
14797c478bd9Sstevel@tonic-gate  * kbtrans_untrans_keypressed_raw:
14807c478bd9Sstevel@tonic-gate  *	This is the callback we get if we are in TR_UNTRANS_EVENT and a
14817c478bd9Sstevel@tonic-gate  * 	key is pressed.  This code will just send the scancode up the
14827c478bd9Sstevel@tonic-gate  * 	stream.
14837c478bd9Sstevel@tonic-gate  */
14847c478bd9Sstevel@tonic-gate static void
14857c478bd9Sstevel@tonic-gate kbtrans_untrans_keypressed_raw(struct kbtrans *upper, kbtrans_key_t key)
14867c478bd9Sstevel@tonic-gate {
14877c478bd9Sstevel@tonic-gate 	Firm_event	fe;
14887c478bd9Sstevel@tonic-gate 
14897c478bd9Sstevel@tonic-gate 	bzero(&fe, sizeof (fe));
14907c478bd9Sstevel@tonic-gate 
14917c478bd9Sstevel@tonic-gate 	/*
14927c478bd9Sstevel@tonic-gate 	 * fill in the event
14937c478bd9Sstevel@tonic-gate 	 */
14947c478bd9Sstevel@tonic-gate 	fe.id = (unsigned short)key;
14957c478bd9Sstevel@tonic-gate 	fe.value = 1;
14967c478bd9Sstevel@tonic-gate 
14977c478bd9Sstevel@tonic-gate 	/*
14987c478bd9Sstevel@tonic-gate 	 * Send the event upstream.
14997c478bd9Sstevel@tonic-gate 	 */
15007c478bd9Sstevel@tonic-gate 	kbtrans_queuepress(upper, key, &fe);
15017c478bd9Sstevel@tonic-gate }
15027c478bd9Sstevel@tonic-gate 
15037c478bd9Sstevel@tonic-gate /*
15047c478bd9Sstevel@tonic-gate  * kbtrans_untrans_keyreleased_raw:
15057c478bd9Sstevel@tonic-gate  *	This is the callback we get if we are in TR_UNTRANS_EVENT mode
15067c478bd9Sstevel@tonic-gate  * 	and a key is released.  This code will just send the scancode up
15077c478bd9Sstevel@tonic-gate  * 	the stream.
15087c478bd9Sstevel@tonic-gate  */
15097c478bd9Sstevel@tonic-gate static void
15107c478bd9Sstevel@tonic-gate kbtrans_untrans_keyreleased_raw(struct kbtrans *upper, kbtrans_key_t key)
15117c478bd9Sstevel@tonic-gate {
15127c478bd9Sstevel@tonic-gate 	/*
15137c478bd9Sstevel@tonic-gate 	 * Deal with a key released event.
15147c478bd9Sstevel@tonic-gate 	 */
15157c478bd9Sstevel@tonic-gate 	kbtrans_keyreleased(upper, key);
15167c478bd9Sstevel@tonic-gate }
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate /*
15197c478bd9Sstevel@tonic-gate  * kbtrans_ascii_keypressed:
15207c478bd9Sstevel@tonic-gate  *	This is the code if we are in TR_ASCII mode and a key
15217c478bd9Sstevel@tonic-gate  * 	is pressed.  This is where we will do any special processing that
15227c478bd9Sstevel@tonic-gate  * 	is specific to ASCII key translation.
15237c478bd9Sstevel@tonic-gate  */
15247c478bd9Sstevel@tonic-gate /* ARGSUSED */
15257c478bd9Sstevel@tonic-gate static void
15267c478bd9Sstevel@tonic-gate kbtrans_ascii_keypressed(
15277c478bd9Sstevel@tonic-gate     struct kbtrans	*upper,
15287c478bd9Sstevel@tonic-gate     uint_t 		entrytype,
15297c478bd9Sstevel@tonic-gate     kbtrans_key_t 	key,
15307c478bd9Sstevel@tonic-gate     uint_t 		entry)
15317c478bd9Sstevel@tonic-gate {
15327c478bd9Sstevel@tonic-gate 	register char	*cp;
15337c478bd9Sstevel@tonic-gate 	register char	*bufp;
15347c478bd9Sstevel@tonic-gate 	char		buf[14];
15357c478bd9Sstevel@tonic-gate 	struct kbtrans_lower	*lower = &upper->kbtrans_lower;
15367c478bd9Sstevel@tonic-gate 
15377c478bd9Sstevel@tonic-gate 	/*
15387c478bd9Sstevel@tonic-gate 	 * Based on the type of key, we may need to do some ASCII
15397c478bd9Sstevel@tonic-gate 	 * specific post processing.
15407c478bd9Sstevel@tonic-gate 	 */
15417c478bd9Sstevel@tonic-gate 	switch (entrytype) {
15427c478bd9Sstevel@tonic-gate 
15437c478bd9Sstevel@tonic-gate 	case BUCKYBITS:
15447c478bd9Sstevel@tonic-gate 	case SHIFTKEYS:
15457c478bd9Sstevel@tonic-gate 	case FUNNY:
15467c478bd9Sstevel@tonic-gate 		/*
15477c478bd9Sstevel@tonic-gate 		 * There is no ascii equivalent.  We will ignore these
15487c478bd9Sstevel@tonic-gate 		 * keys
15497c478bd9Sstevel@tonic-gate 		 */
15507c478bd9Sstevel@tonic-gate 		return;
15517c478bd9Sstevel@tonic-gate 
15527c478bd9Sstevel@tonic-gate 	case FUNCKEYS:
15537c478bd9Sstevel@tonic-gate 		/*
15547c478bd9Sstevel@tonic-gate 		 * We need to expand this key to get the ascii
15557c478bd9Sstevel@tonic-gate 		 * equivalent.  These are the function keys (F1, F2 ...)
15567c478bd9Sstevel@tonic-gate 		 */
15577c478bd9Sstevel@tonic-gate 		bufp = buf;
15587c478bd9Sstevel@tonic-gate 		cp = kbtrans_strsetwithdecimal(bufp + 2,
15597c478bd9Sstevel@tonic-gate 			(uint_t)((entry & 0x003F) + 192),
15607c478bd9Sstevel@tonic-gate 			sizeof (buf) - 5);
15617c478bd9Sstevel@tonic-gate 		*bufp++ = '\033'; /* Escape */
15627c478bd9Sstevel@tonic-gate 		*bufp++ = '[';
15637c478bd9Sstevel@tonic-gate 		while (*cp != '\0')
15647c478bd9Sstevel@tonic-gate 			*bufp++ = *cp++;
15657c478bd9Sstevel@tonic-gate 		*bufp++ = 'z';
15667c478bd9Sstevel@tonic-gate 		*bufp = '\0';
15677c478bd9Sstevel@tonic-gate 
15687c478bd9Sstevel@tonic-gate 		/*
15697c478bd9Sstevel@tonic-gate 		 * Send the result upstream.
15707c478bd9Sstevel@tonic-gate 		 */
15717c478bd9Sstevel@tonic-gate 		kbtrans_putbuf(buf, upper->kbtrans_streams_readq);
15727c478bd9Sstevel@tonic-gate 
15737c478bd9Sstevel@tonic-gate 		return;
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	case STRING:
15767c478bd9Sstevel@tonic-gate 		/*
15777c478bd9Sstevel@tonic-gate 		 * These are the multi byte keys (Home, Up, Down ...)
15787c478bd9Sstevel@tonic-gate 		 */
15797c478bd9Sstevel@tonic-gate 		cp = &lower->kbtrans_keystringtab[entry & 0x0F][0];
15807c478bd9Sstevel@tonic-gate 
15817c478bd9Sstevel@tonic-gate 		/*
15827c478bd9Sstevel@tonic-gate 		 * Copy the string from the keystringtable, and send it
15837c478bd9Sstevel@tonic-gate 		 * upstream a character at a time.
15847c478bd9Sstevel@tonic-gate 		 */
15857c478bd9Sstevel@tonic-gate 		while (*cp != '\0') {
15867c478bd9Sstevel@tonic-gate 
15877c478bd9Sstevel@tonic-gate 			kbtrans_putcode(upper, (uchar_t)*cp);
15887c478bd9Sstevel@tonic-gate 
15897c478bd9Sstevel@tonic-gate 			cp++;
15907c478bd9Sstevel@tonic-gate 		}
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate 		return;
15937c478bd9Sstevel@tonic-gate 
15947c478bd9Sstevel@tonic-gate 	case PADKEYS:
15957c478bd9Sstevel@tonic-gate 		/*
15967c478bd9Sstevel@tonic-gate 		 * These are the keys on the keypad.  Look up the
15977c478bd9Sstevel@tonic-gate 		 * answer in the kb_numlock_table and send it upstream.
15987c478bd9Sstevel@tonic-gate 		 */
15997c478bd9Sstevel@tonic-gate 		kbtrans_putcode(upper,
16007c478bd9Sstevel@tonic-gate 			    lower->kbtrans_numlock_table[entry&0x1F]);
16017c478bd9Sstevel@tonic-gate 
16027c478bd9Sstevel@tonic-gate 		return;
16037c478bd9Sstevel@tonic-gate 
16047c478bd9Sstevel@tonic-gate 	case 0:	/* normal character */
16057c478bd9Sstevel@tonic-gate 	default:
16067c478bd9Sstevel@tonic-gate 		break;
16077c478bd9Sstevel@tonic-gate 	}
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 	/*
16107c478bd9Sstevel@tonic-gate 	 * Send the byte upstream.
16117c478bd9Sstevel@tonic-gate 	 */
16127c478bd9Sstevel@tonic-gate 	kbtrans_putcode(upper, entry);
16137c478bd9Sstevel@tonic-gate 
16147c478bd9Sstevel@tonic-gate }
16157c478bd9Sstevel@tonic-gate 
16167c478bd9Sstevel@tonic-gate /*
16177c478bd9Sstevel@tonic-gate  * kbtrans_ascii_keyreleased:
16187c478bd9Sstevel@tonic-gate  *	This is the function if we are in TR_ASCII mode and a key
16197c478bd9Sstevel@tonic-gate  * 	is released.  ASCII doesn't have the concept of released keys,
16207c478bd9Sstevel@tonic-gate  * 	or make/break codes.  So there is nothing for us to do.
16217c478bd9Sstevel@tonic-gate  */
16227c478bd9Sstevel@tonic-gate /* ARGSUSED */
16237c478bd9Sstevel@tonic-gate static void
16247c478bd9Sstevel@tonic-gate kbtrans_ascii_keyreleased(struct kbtrans *upper, kbtrans_key_t key)
16257c478bd9Sstevel@tonic-gate {
16267c478bd9Sstevel@tonic-gate 	/* Nothing to do ... for now */
16277c478bd9Sstevel@tonic-gate }
16287c478bd9Sstevel@tonic-gate 
16297c478bd9Sstevel@tonic-gate /*
16307c478bd9Sstevel@tonic-gate  * kbtrans_ascii_setup_repeat:
16317c478bd9Sstevel@tonic-gate  *	This is the function if we are in TR_ASCII mode and the
16327c478bd9Sstevel@tonic-gate  * 	translation module has decided that a key needs to be repeated.
16337c478bd9Sstevel@tonic-gate  */
16347c478bd9Sstevel@tonic-gate /* ARGSUSED */
16357c478bd9Sstevel@tonic-gate static void
16367c478bd9Sstevel@tonic-gate kbtrans_ascii_setup_repeat(
16377c478bd9Sstevel@tonic-gate     struct kbtrans *upper,
16387c478bd9Sstevel@tonic-gate     uint_t entrytype,
16397c478bd9Sstevel@tonic-gate     kbtrans_key_t key)
16407c478bd9Sstevel@tonic-gate {
16417c478bd9Sstevel@tonic-gate 	struct kbtrans_lower *lower = &upper->kbtrans_lower;
16427c478bd9Sstevel@tonic-gate 
16437c478bd9Sstevel@tonic-gate 	/*
16447c478bd9Sstevel@tonic-gate 	 * Cancel any currently repeating keys.  This will be a new
16457c478bd9Sstevel@tonic-gate 	 * key to repeat.
16467c478bd9Sstevel@tonic-gate 	 */
16477c478bd9Sstevel@tonic-gate 	kbtrans_cancelrpt(upper);
16487c478bd9Sstevel@tonic-gate 
16497c478bd9Sstevel@tonic-gate 	/*
16507c478bd9Sstevel@tonic-gate 	 * Set the value of the key to be repeated.
16517c478bd9Sstevel@tonic-gate 	 */
16527c478bd9Sstevel@tonic-gate 	lower->kbtrans_repeatkey = key;
16537c478bd9Sstevel@tonic-gate 
16547c478bd9Sstevel@tonic-gate 	/*
16557c478bd9Sstevel@tonic-gate 	 * Start the timeout for repeating this key.  kbtrans_rpt will
16567c478bd9Sstevel@tonic-gate 	 * be called to repeat the key.
16577c478bd9Sstevel@tonic-gate 	 */
16587c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq,
16597c478bd9Sstevel@tonic-gate 		kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay);
16607c478bd9Sstevel@tonic-gate }
16617c478bd9Sstevel@tonic-gate 
16627c478bd9Sstevel@tonic-gate /*
16637c478bd9Sstevel@tonic-gate  * kbtrans_trans_event_keypressed:
16647c478bd9Sstevel@tonic-gate  *	This is the function if we are in TR_EVENT mode and a key
16657c478bd9Sstevel@tonic-gate  * 	is pressed.  This is where we will do any special processing that
16667c478bd9Sstevel@tonic-gate  * 	is specific to EVENT key translation.
16677c478bd9Sstevel@tonic-gate  */
16687c478bd9Sstevel@tonic-gate static void
16697c478bd9Sstevel@tonic-gate kbtrans_trans_event_keypressed(
16707c478bd9Sstevel@tonic-gate 	struct kbtrans 	*upper,
16717c478bd9Sstevel@tonic-gate 	uint_t 		entrytype,
16727c478bd9Sstevel@tonic-gate 	kbtrans_key_t 	key,
16737c478bd9Sstevel@tonic-gate 	uint_t 		entry)
16747c478bd9Sstevel@tonic-gate {
16757c478bd9Sstevel@tonic-gate 	Firm_event	fe;
16767c478bd9Sstevel@tonic-gate 	register char	*cp;
16777c478bd9Sstevel@tonic-gate 	struct kbtrans_lower	*lower = &upper->kbtrans_lower;
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate 	/*
16807c478bd9Sstevel@tonic-gate 	 * Based on the type of key, we may need to do some EVENT
16817c478bd9Sstevel@tonic-gate 	 * specific post processing.
16827c478bd9Sstevel@tonic-gate 	 */
16837c478bd9Sstevel@tonic-gate 	switch (entrytype) {
16847c478bd9Sstevel@tonic-gate 
16857c478bd9Sstevel@tonic-gate 	case SHIFTKEYS:
16867c478bd9Sstevel@tonic-gate 		/*
16877c478bd9Sstevel@tonic-gate 		 * Relying on ordinal correspondence between
16887c478bd9Sstevel@tonic-gate 		 * vuid_event.h SHIFT_META-SHIFT_TOP &
16897c478bd9Sstevel@tonic-gate 		 * kbd.h METABIT-SYSTEMBIT in order to
16907c478bd9Sstevel@tonic-gate 		 * correctly translate entry into fe.id.
16917c478bd9Sstevel@tonic-gate 		 */
16927c478bd9Sstevel@tonic-gate 		fe.id = SHIFT_CAPSLOCK + (entry & 0x0F);
16937c478bd9Sstevel@tonic-gate 		fe.value = 1;
16947c478bd9Sstevel@tonic-gate 		kbtrans_keypressed(upper, key, &fe, fe.id);
16957c478bd9Sstevel@tonic-gate 
16967c478bd9Sstevel@tonic-gate 		return;
16977c478bd9Sstevel@tonic-gate 
16987c478bd9Sstevel@tonic-gate 	case BUCKYBITS:
16997c478bd9Sstevel@tonic-gate 		/*
17007c478bd9Sstevel@tonic-gate 		 * Relying on ordinal correspondence between
17017c478bd9Sstevel@tonic-gate 		 * vuid_event.h SHIFT_CAPSLOCK-SHIFT_RIGHTCTRL &
17027c478bd9Sstevel@tonic-gate 		 * kbd.h CAPSLOCK-RIGHTCTRL in order to
17037c478bd9Sstevel@tonic-gate 		 * correctly translate entry into fe.id.
17047c478bd9Sstevel@tonic-gate 		 */
17057c478bd9Sstevel@tonic-gate 		fe.id = SHIFT_META + (entry & 0x0F);
17067c478bd9Sstevel@tonic-gate 		fe.value = 1;
17077c478bd9Sstevel@tonic-gate 		kbtrans_keypressed(upper, key, &fe, fe.id);
17087c478bd9Sstevel@tonic-gate 
17097c478bd9Sstevel@tonic-gate 		return;
17107c478bd9Sstevel@tonic-gate 
17117c478bd9Sstevel@tonic-gate 	case FUNCKEYS:
17127c478bd9Sstevel@tonic-gate 		/*
17137c478bd9Sstevel@tonic-gate 		 * Take advantage of the similar
17147c478bd9Sstevel@tonic-gate 		 * ordering of kbd.h function keys and
17157c478bd9Sstevel@tonic-gate 		 * vuid_event.h function keys to do a
17167c478bd9Sstevel@tonic-gate 		 * simple translation to achieve a
17177c478bd9Sstevel@tonic-gate 		 * mapping between the 2 different
17187c478bd9Sstevel@tonic-gate 		 * address spaces.
17197c478bd9Sstevel@tonic-gate 		 */
17207c478bd9Sstevel@tonic-gate 		fe.id = KEY_LEFTFIRST + (entry & 0x003F);
17217c478bd9Sstevel@tonic-gate 		fe.value = 1;
17227c478bd9Sstevel@tonic-gate 
17237c478bd9Sstevel@tonic-gate 		/*
17247c478bd9Sstevel@tonic-gate 		 * Assume "up" table only generates
17257c478bd9Sstevel@tonic-gate 		 * shift changes.
17267c478bd9Sstevel@tonic-gate 		 */
17277c478bd9Sstevel@tonic-gate 		kbtrans_keypressed(upper, key, &fe, fe.id);
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 		/*
17307c478bd9Sstevel@tonic-gate 		 * Function key events can be expanded
17317c478bd9Sstevel@tonic-gate 		 * by terminal emulator software to
17327c478bd9Sstevel@tonic-gate 		 * produce the standard escape sequence
17337c478bd9Sstevel@tonic-gate 		 * generated by the TR_ASCII case above
17347c478bd9Sstevel@tonic-gate 		 * if a function key event is not used
17357c478bd9Sstevel@tonic-gate 		 * by terminal emulator software
17367c478bd9Sstevel@tonic-gate 		 * directly.
17377c478bd9Sstevel@tonic-gate 		 */
17387c478bd9Sstevel@tonic-gate 		return;
17397c478bd9Sstevel@tonic-gate 
17407c478bd9Sstevel@tonic-gate 	case STRING:
17417c478bd9Sstevel@tonic-gate 		/*
17427c478bd9Sstevel@tonic-gate 		 * These are the multi byte keys (Home, Up, Down ...)
17437c478bd9Sstevel@tonic-gate 		 */
17447c478bd9Sstevel@tonic-gate 		cp = &lower->kbtrans_keystringtab[entry & 0x0F][0];
17457c478bd9Sstevel@tonic-gate 
17467c478bd9Sstevel@tonic-gate 		/*
17477c478bd9Sstevel@tonic-gate 		 * Copy the string from the keystringtable, and send it
17487c478bd9Sstevel@tonic-gate 		 * upstream a character at a time.
17497c478bd9Sstevel@tonic-gate 		 */
17507c478bd9Sstevel@tonic-gate 		while (*cp != '\0') {
17517c478bd9Sstevel@tonic-gate 
17527c478bd9Sstevel@tonic-gate 			kbtrans_send_esc_event(*cp, upper);
17537c478bd9Sstevel@tonic-gate 
17547c478bd9Sstevel@tonic-gate 			cp++;
17557c478bd9Sstevel@tonic-gate 		}
17567c478bd9Sstevel@tonic-gate 
17577c478bd9Sstevel@tonic-gate 		return;
17587c478bd9Sstevel@tonic-gate 
17597c478bd9Sstevel@tonic-gate 	case PADKEYS:
17607c478bd9Sstevel@tonic-gate 		/*
17617c478bd9Sstevel@tonic-gate 		 * Take advantage of the similar
17627c478bd9Sstevel@tonic-gate 		 * ordering of kbd.h keypad keys and
17637c478bd9Sstevel@tonic-gate 		 * vuid_event.h keypad keys to do a
17647c478bd9Sstevel@tonic-gate 		 * simple translation to achieve a
17657c478bd9Sstevel@tonic-gate 		 * mapping between the 2 different
17667c478bd9Sstevel@tonic-gate 		 * address spaces.
17677c478bd9Sstevel@tonic-gate 		 */
17687c478bd9Sstevel@tonic-gate 		fe.id = VKEY_FIRSTPAD + (entry & 0x001F);
17697c478bd9Sstevel@tonic-gate 		fe.value = 1;
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 		/*
17727c478bd9Sstevel@tonic-gate 		 * Assume "up" table only generates
17737c478bd9Sstevel@tonic-gate 		 * shift changes.
17747c478bd9Sstevel@tonic-gate 		 */
17757c478bd9Sstevel@tonic-gate 		kbtrans_keypressed(upper, key, &fe, fe.id);
17767c478bd9Sstevel@tonic-gate 
17777c478bd9Sstevel@tonic-gate 		/*
17787c478bd9Sstevel@tonic-gate 		 * Keypad key events can be expanded
17797c478bd9Sstevel@tonic-gate 		 * by terminal emulator software to
17807c478bd9Sstevel@tonic-gate 		 * produce the standard ascii character
17817c478bd9Sstevel@tonic-gate 		 * generated by the TR_ASCII case above
17827c478bd9Sstevel@tonic-gate 		 * if a keypad key event is not used
17837c478bd9Sstevel@tonic-gate 		 * by terminal emulator software
17847c478bd9Sstevel@tonic-gate 		 * directly.
17857c478bd9Sstevel@tonic-gate 		 */
17867c478bd9Sstevel@tonic-gate 		return;
17877c478bd9Sstevel@tonic-gate 
17887c478bd9Sstevel@tonic-gate 	case FUNNY:
17897c478bd9Sstevel@tonic-gate 		/*
17907c478bd9Sstevel@tonic-gate 		 * These are not events.
17917c478bd9Sstevel@tonic-gate 		 */
17927c478bd9Sstevel@tonic-gate 		switch (entry) {
17937c478bd9Sstevel@tonic-gate 		case IDLE:
17947c478bd9Sstevel@tonic-gate 		case RESET:
17957c478bd9Sstevel@tonic-gate 		case ERROR:
17967c478bd9Sstevel@tonic-gate 			/*
17977c478bd9Sstevel@tonic-gate 			 * Something has happened.  Mark all keys as released.
17987c478bd9Sstevel@tonic-gate 			 */
17997c478bd9Sstevel@tonic-gate 			kbtrans_streams_releaseall(upper);
18007c478bd9Sstevel@tonic-gate 			break;
18017c478bd9Sstevel@tonic-gate 		}
18027c478bd9Sstevel@tonic-gate 
18037c478bd9Sstevel@tonic-gate 		return;
18047c478bd9Sstevel@tonic-gate 
18057c478bd9Sstevel@tonic-gate 	case 0: /* normal character */
18067c478bd9Sstevel@tonic-gate 	default:
18077c478bd9Sstevel@tonic-gate 		break;
18087c478bd9Sstevel@tonic-gate 	}
18097c478bd9Sstevel@tonic-gate 
18107c478bd9Sstevel@tonic-gate 	/*
18117c478bd9Sstevel@tonic-gate 	 * Send the event upstream.
18127c478bd9Sstevel@tonic-gate 	 */
18137c478bd9Sstevel@tonic-gate 	fe.id = entry;
18147c478bd9Sstevel@tonic-gate 
18157c478bd9Sstevel@tonic-gate 	fe.value = 1;
18167c478bd9Sstevel@tonic-gate 
18177c478bd9Sstevel@tonic-gate 	kbtrans_queueevent(upper, &fe);
18187c478bd9Sstevel@tonic-gate }
18197c478bd9Sstevel@tonic-gate 
18207c478bd9Sstevel@tonic-gate /*
18217c478bd9Sstevel@tonic-gate  * kbtrans_trans_event_keyreleased:
18227c478bd9Sstevel@tonic-gate  *	This is the function if we are in TR_EVENT mode and a key
18237c478bd9Sstevel@tonic-gate  * 	is released.
18247c478bd9Sstevel@tonic-gate  */
18257c478bd9Sstevel@tonic-gate /* ARGSUSED */
18267c478bd9Sstevel@tonic-gate static void
18277c478bd9Sstevel@tonic-gate kbtrans_trans_event_keyreleased(struct kbtrans *upper, kbtrans_key_t key)
18287c478bd9Sstevel@tonic-gate {
18297c478bd9Sstevel@tonic-gate 	/*
18307c478bd9Sstevel@tonic-gate 	 * Mark the key as released and send an event upstream.
18317c478bd9Sstevel@tonic-gate 	 */
18327c478bd9Sstevel@tonic-gate 	kbtrans_keyreleased(upper, key);
18337c478bd9Sstevel@tonic-gate }
18347c478bd9Sstevel@tonic-gate 
18357c478bd9Sstevel@tonic-gate /*
18367c478bd9Sstevel@tonic-gate  * kbtrans_trans_event_setup_repeat:
18377c478bd9Sstevel@tonic-gate  *	This is the function if we are in TR_EVENT mode and the
18387c478bd9Sstevel@tonic-gate  *	translation module has decided that a key needs to be repeated.
18397c478bd9Sstevel@tonic-gate  * 	We will set a timeout to retranslate the repeat key.
18407c478bd9Sstevel@tonic-gate  */
18417c478bd9Sstevel@tonic-gate static void
18427c478bd9Sstevel@tonic-gate kbtrans_trans_event_setup_repeat(
18437c478bd9Sstevel@tonic-gate 	struct kbtrans	*upper,
18447c478bd9Sstevel@tonic-gate 	uint_t 		entrytype,
18457c478bd9Sstevel@tonic-gate 	kbtrans_key_t	key)
18467c478bd9Sstevel@tonic-gate {
18477c478bd9Sstevel@tonic-gate 	struct kbtrans_lower *lower = &upper->kbtrans_lower;
18487c478bd9Sstevel@tonic-gate 
18497c478bd9Sstevel@tonic-gate 	/*
18507c478bd9Sstevel@tonic-gate 	 * Function keys and keypad keys do not repeat when we are in
18517c478bd9Sstevel@tonic-gate 	 * EVENT mode.
18527c478bd9Sstevel@tonic-gate 	 */
18537c478bd9Sstevel@tonic-gate 	if (entrytype == FUNCKEYS || entrytype == PADKEYS) {
18547c478bd9Sstevel@tonic-gate 
18557c478bd9Sstevel@tonic-gate 		return;
18567c478bd9Sstevel@tonic-gate 	}
18577c478bd9Sstevel@tonic-gate 
18587c478bd9Sstevel@tonic-gate 	/*
18597c478bd9Sstevel@tonic-gate 	 * Cancel any currently repeating keys.  This will be a new
18607c478bd9Sstevel@tonic-gate 	 * key to repeat.
18617c478bd9Sstevel@tonic-gate 	 */
18627c478bd9Sstevel@tonic-gate 	kbtrans_cancelrpt(upper);
18637c478bd9Sstevel@tonic-gate 
18647c478bd9Sstevel@tonic-gate 	/*
18657c478bd9Sstevel@tonic-gate 	 * Set the value of the key to be repeated.
18667c478bd9Sstevel@tonic-gate 	 */
18677c478bd9Sstevel@tonic-gate 	lower->kbtrans_repeatkey = key;
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate 	/*
18707c478bd9Sstevel@tonic-gate 	 * Start the timeout for repeating this key.  kbtrans_rpt will
18717c478bd9Sstevel@tonic-gate 	 * be called to repeat the key.
18727c478bd9Sstevel@tonic-gate 	 */
18737c478bd9Sstevel@tonic-gate 	upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq,
18747c478bd9Sstevel@tonic-gate 		kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay);
18757c478bd9Sstevel@tonic-gate }
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate /*
18787c478bd9Sstevel@tonic-gate  * Administer the key tables.
18797c478bd9Sstevel@tonic-gate  */
18807c478bd9Sstevel@tonic-gate 
18817c478bd9Sstevel@tonic-gate /*
18827c478bd9Sstevel@tonic-gate  * Old special codes.
18837c478bd9Sstevel@tonic-gate  */
18847c478bd9Sstevel@tonic-gate #define	OLD_SHIFTKEYS	0x80
18857c478bd9Sstevel@tonic-gate #define	OLD_BUCKYBITS	0x90
18867c478bd9Sstevel@tonic-gate #define	OLD_FUNNY	0xA0
18877c478bd9Sstevel@tonic-gate #define	OLD_FA_UMLAUT	0xA9
18887c478bd9Sstevel@tonic-gate #define	OLD_FA_CFLEX	0xAA
18897c478bd9Sstevel@tonic-gate #define	OLD_FA_TILDE	0xAB
18907c478bd9Sstevel@tonic-gate #define	OLD_FA_CEDILLA	0xAC
18917c478bd9Sstevel@tonic-gate #define	OLD_FA_ACUTE	0xAD
18927c478bd9Sstevel@tonic-gate #define	OLD_FA_GRAVE	0xAE
18937c478bd9Sstevel@tonic-gate #define	OLD_ISOCHAR	0xAF
18947c478bd9Sstevel@tonic-gate #define	OLD_STRING	0xB0
18957c478bd9Sstevel@tonic-gate #define	OLD_LEFTFUNC	0xC0
18967c478bd9Sstevel@tonic-gate #define	OLD_RIGHTFUNC	0xD0
18977c478bd9Sstevel@tonic-gate #define	OLD_TOPFUNC	0xE0
18987c478bd9Sstevel@tonic-gate #define	OLD_BOTTOMFUNC	0xF0
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate /*
19017c478bd9Sstevel@tonic-gate  * Map old special codes to new ones.
19027c478bd9Sstevel@tonic-gate  * Indexed by ((old special code) >> 4) & 0x07; add (old special code) & 0x0F.
19037c478bd9Sstevel@tonic-gate  */
19047c478bd9Sstevel@tonic-gate static ushort_t  special_old_to_new[] = {
19057c478bd9Sstevel@tonic-gate 	SHIFTKEYS,
19067c478bd9Sstevel@tonic-gate 	BUCKYBITS,
19077c478bd9Sstevel@tonic-gate 	FUNNY,
19087c478bd9Sstevel@tonic-gate 	STRING,
19097c478bd9Sstevel@tonic-gate 	LEFTFUNC,
19107c478bd9Sstevel@tonic-gate 	RIGHTFUNC,
19117c478bd9Sstevel@tonic-gate 	TOPFUNC,
19127c478bd9Sstevel@tonic-gate 	BOTTOMFUNC,
19137c478bd9Sstevel@tonic-gate };
19147c478bd9Sstevel@tonic-gate 
19157c478bd9Sstevel@tonic-gate 
19167c478bd9Sstevel@tonic-gate /*
19177c478bd9Sstevel@tonic-gate  * kbtrans_setkey:
19187c478bd9Sstevel@tonic-gate  *	 Set individual keystation translation from old-style entry.
19197c478bd9Sstevel@tonic-gate  */
19207c478bd9Sstevel@tonic-gate static int
19217c478bd9Sstevel@tonic-gate kbtrans_setkey(struct kbtrans_lower *lower, struct kiockey *key, cred_t *cr)
19227c478bd9Sstevel@tonic-gate {
19237c478bd9Sstevel@tonic-gate 	int	strtabindex, i;
19247c478bd9Sstevel@tonic-gate 	unsigned short	*ke;
19257c478bd9Sstevel@tonic-gate 	register int tablemask;
19267c478bd9Sstevel@tonic-gate 	register ushort_t entry;
19277c478bd9Sstevel@tonic-gate 	register struct keyboard *kp;
19287c478bd9Sstevel@tonic-gate 
19297c478bd9Sstevel@tonic-gate 	kp = lower->kbtrans_keyboard;
19307c478bd9Sstevel@tonic-gate 
19317c478bd9Sstevel@tonic-gate 	if (key->kio_station >= kp->k_keymap_size)
19327c478bd9Sstevel@tonic-gate 
19337c478bd9Sstevel@tonic-gate 		return (EINVAL);
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_keyboard == NULL)
19367c478bd9Sstevel@tonic-gate 
19377c478bd9Sstevel@tonic-gate 		return (EINVAL);
19387c478bd9Sstevel@tonic-gate 
19397c478bd9Sstevel@tonic-gate 	tablemask = key->kio_tablemask;
19407c478bd9Sstevel@tonic-gate 
19417c478bd9Sstevel@tonic-gate 	switch (tablemask) {
19427c478bd9Sstevel@tonic-gate 	case KIOCABORT1:
19437c478bd9Sstevel@tonic-gate 	case KIOCABORT1A:
19447c478bd9Sstevel@tonic-gate 	case KIOCABORT2:
19457c478bd9Sstevel@tonic-gate 		i = secpolicy_console(cr);
19467c478bd9Sstevel@tonic-gate 		if (i != 0)
19477c478bd9Sstevel@tonic-gate 			return (i);
19487c478bd9Sstevel@tonic-gate 
19497c478bd9Sstevel@tonic-gate 		switch (tablemask) {
19507c478bd9Sstevel@tonic-gate 		case KIOCABORT1:
19517c478bd9Sstevel@tonic-gate 			kp->k_abort1 = key->kio_station;
19527c478bd9Sstevel@tonic-gate 			break;
19537c478bd9Sstevel@tonic-gate 		case KIOCABORT1A:
19547c478bd9Sstevel@tonic-gate 			kp->k_abort1a = key->kio_station;
19557c478bd9Sstevel@tonic-gate 			break;
19567c478bd9Sstevel@tonic-gate 		case KIOCABORT2:
19577c478bd9Sstevel@tonic-gate 			kp->k_abort2 = key->kio_station;
19587c478bd9Sstevel@tonic-gate 			break;
19597c478bd9Sstevel@tonic-gate 		}
19607c478bd9Sstevel@tonic-gate 		return (0);
19617c478bd9Sstevel@tonic-gate 	}
19627c478bd9Sstevel@tonic-gate 
19637c478bd9Sstevel@tonic-gate 	if (tablemask & ALTGRAPHMASK)
19647c478bd9Sstevel@tonic-gate 		return (EINVAL);
19657c478bd9Sstevel@tonic-gate 
19667c478bd9Sstevel@tonic-gate 	ke = kbtrans_find_entry(lower, (uint_t)tablemask, key->kio_station);
19677c478bd9Sstevel@tonic-gate 	if (ke == NULL)
19687c478bd9Sstevel@tonic-gate 		return (EINVAL);
19697c478bd9Sstevel@tonic-gate 
19707c478bd9Sstevel@tonic-gate 	if (key->kio_entry >= (uchar_t)OLD_STRING &&
19717c478bd9Sstevel@tonic-gate 	    key->kio_entry <= (uchar_t)(OLD_STRING + 15)) {
19727c478bd9Sstevel@tonic-gate 		strtabindex = key->kio_entry - OLD_STRING;
19737c478bd9Sstevel@tonic-gate 		bcopy(key->kio_string,
19747c478bd9Sstevel@tonic-gate 			lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN);
19757c478bd9Sstevel@tonic-gate 		lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0';
19767c478bd9Sstevel@tonic-gate 	}
19777c478bd9Sstevel@tonic-gate 
19787c478bd9Sstevel@tonic-gate 	entry = key->kio_entry;
19797c478bd9Sstevel@tonic-gate 
19807c478bd9Sstevel@tonic-gate 	/*
19817c478bd9Sstevel@tonic-gate 	 * There's nothing we need do with OLD_ISOCHAR.
19827c478bd9Sstevel@tonic-gate 	 */
19837c478bd9Sstevel@tonic-gate 	if (entry != OLD_ISOCHAR) {
19847c478bd9Sstevel@tonic-gate 		if (entry & 0x80) {
19857c478bd9Sstevel@tonic-gate 			if (entry >= OLD_FA_UMLAUT && entry <= OLD_FA_GRAVE)
19867c478bd9Sstevel@tonic-gate 				entry = FA_CLASS + (entry & 0x0F) - 9;
19877c478bd9Sstevel@tonic-gate 			else
19887c478bd9Sstevel@tonic-gate 				entry =
19897c478bd9Sstevel@tonic-gate 				    special_old_to_new[entry >> 4 & 0x07]
19907c478bd9Sstevel@tonic-gate 				    + (entry & 0x0F);
19917c478bd9Sstevel@tonic-gate 		}
19927c478bd9Sstevel@tonic-gate 	}
19937c478bd9Sstevel@tonic-gate 
19947c478bd9Sstevel@tonic-gate 	*ke = entry;
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate 	return (0);
19977c478bd9Sstevel@tonic-gate }
19987c478bd9Sstevel@tonic-gate 
19997c478bd9Sstevel@tonic-gate 
20007c478bd9Sstevel@tonic-gate /*
20017c478bd9Sstevel@tonic-gate  * Map new special codes to old ones.
20027c478bd9Sstevel@tonic-gate  * Indexed by (new special code) >> 8; add (new special code) & 0xFF.
20037c478bd9Sstevel@tonic-gate  */
20047c478bd9Sstevel@tonic-gate static uchar_t   special_new_to_old[] = {
20057c478bd9Sstevel@tonic-gate 	0,			/* normal */
20067c478bd9Sstevel@tonic-gate 	OLD_SHIFTKEYS,		/* SHIFTKEYS */
20077c478bd9Sstevel@tonic-gate 	OLD_BUCKYBITS,		/* BUCKYBITS */
20087c478bd9Sstevel@tonic-gate 	OLD_FUNNY,		/* FUNNY */
20097c478bd9Sstevel@tonic-gate 	OLD_FA_UMLAUT,		/* FA_CLASS */
20107c478bd9Sstevel@tonic-gate 	OLD_STRING,		/* STRING */
20117c478bd9Sstevel@tonic-gate 	OLD_LEFTFUNC,		/* FUNCKEYS */
20127c478bd9Sstevel@tonic-gate };
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 
20157c478bd9Sstevel@tonic-gate /*
20167c478bd9Sstevel@tonic-gate  * kbtrans_getkey:
20177c478bd9Sstevel@tonic-gate  *	Get individual keystation translation as old-style entry.
20187c478bd9Sstevel@tonic-gate  */
20197c478bd9Sstevel@tonic-gate static int
20207c478bd9Sstevel@tonic-gate kbtrans_getkey(struct kbtrans_lower *lower, struct kiockey *key)
20217c478bd9Sstevel@tonic-gate {
20227c478bd9Sstevel@tonic-gate 	int	strtabindex;
20237c478bd9Sstevel@tonic-gate 	unsigned short	*ke;
20247c478bd9Sstevel@tonic-gate 	register ushort_t entry;
20257c478bd9Sstevel@tonic-gate 	struct keyboard *kp;
20267c478bd9Sstevel@tonic-gate 
20277c478bd9Sstevel@tonic-gate 	kp = lower->kbtrans_keyboard;
20287c478bd9Sstevel@tonic-gate 
20297c478bd9Sstevel@tonic-gate 	if (key->kio_station >= kp->k_keymap_size)
20307c478bd9Sstevel@tonic-gate 		return (EINVAL);
20317c478bd9Sstevel@tonic-gate 
20327c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_keyboard == NULL)
20337c478bd9Sstevel@tonic-gate 		return (EINVAL);
20347c478bd9Sstevel@tonic-gate 
20357c478bd9Sstevel@tonic-gate 	switch (key->kio_tablemask) {
20367c478bd9Sstevel@tonic-gate 	case KIOCABORT1:
20377c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort1;
20387c478bd9Sstevel@tonic-gate 		return (0);
20397c478bd9Sstevel@tonic-gate 	case KIOCABORT1A:
20407c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort1a;
20417c478bd9Sstevel@tonic-gate 		return (0);
20427c478bd9Sstevel@tonic-gate 	case KIOCABORT2:
20437c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort2;
20447c478bd9Sstevel@tonic-gate 		return (0);
20457c478bd9Sstevel@tonic-gate 	}
20467c478bd9Sstevel@tonic-gate 
20477c478bd9Sstevel@tonic-gate 	ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask,
20487c478bd9Sstevel@tonic-gate 		key->kio_station);
20497c478bd9Sstevel@tonic-gate 	if (ke == NULL)
20507c478bd9Sstevel@tonic-gate 		return (EINVAL);
20517c478bd9Sstevel@tonic-gate 
20527c478bd9Sstevel@tonic-gate 	entry = *ke;
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 	if (entry & 0xFF00)
20557c478bd9Sstevel@tonic-gate 		key->kio_entry =
20567c478bd9Sstevel@tonic-gate 		    special_new_to_old[(ushort_t)(entry & 0xFF00) >> 8]
20577c478bd9Sstevel@tonic-gate 		    + (entry & 0x00FF);
20587c478bd9Sstevel@tonic-gate 	else {
20597c478bd9Sstevel@tonic-gate 		if (entry & 0x80)
20607c478bd9Sstevel@tonic-gate 			key->kio_entry = (ushort_t)OLD_ISOCHAR;	/* you lose */
20617c478bd9Sstevel@tonic-gate 		else
20627c478bd9Sstevel@tonic-gate 			key->kio_entry = (ushort_t)entry;
20637c478bd9Sstevel@tonic-gate 	}
20647c478bd9Sstevel@tonic-gate 
20657c478bd9Sstevel@tonic-gate 	if (entry >= STRING && entry <= (uchar_t)(STRING + 15)) {
20667c478bd9Sstevel@tonic-gate 		strtabindex = entry - STRING;
20677c478bd9Sstevel@tonic-gate 		bcopy(lower->kbtrans_keystringtab[strtabindex],
20687c478bd9Sstevel@tonic-gate 			key->kio_string, KTAB_STRLEN);
20697c478bd9Sstevel@tonic-gate 	}
20707c478bd9Sstevel@tonic-gate 	return (0);
20717c478bd9Sstevel@tonic-gate }
20727c478bd9Sstevel@tonic-gate 
20737c478bd9Sstevel@tonic-gate 
20747c478bd9Sstevel@tonic-gate /*
20757c478bd9Sstevel@tonic-gate  * kbtrans_skey:
20767c478bd9Sstevel@tonic-gate  *	Set individual keystation translation from new-style entry.
20777c478bd9Sstevel@tonic-gate  */
20787c478bd9Sstevel@tonic-gate static int
20797c478bd9Sstevel@tonic-gate kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr)
20807c478bd9Sstevel@tonic-gate {
20817c478bd9Sstevel@tonic-gate 	int	strtabindex, i;
20827c478bd9Sstevel@tonic-gate 	unsigned short *ke;
20837c478bd9Sstevel@tonic-gate 	struct keyboard *kp;
20847c478bd9Sstevel@tonic-gate 
20857c478bd9Sstevel@tonic-gate 	kp = lower->kbtrans_keyboard;
20867c478bd9Sstevel@tonic-gate 
20877c478bd9Sstevel@tonic-gate 	if (key->kio_station >= kp->k_keymap_size) {
20887c478bd9Sstevel@tonic-gate 		return (EINVAL);
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	}
20917c478bd9Sstevel@tonic-gate 
20927c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_keyboard == NULL) {
20937c478bd9Sstevel@tonic-gate 		return (EINVAL);
20947c478bd9Sstevel@tonic-gate 	}
20957c478bd9Sstevel@tonic-gate 
20967c478bd9Sstevel@tonic-gate 	switch (key->kio_tablemask) {
20977c478bd9Sstevel@tonic-gate 	case KIOCABORT1:
20987c478bd9Sstevel@tonic-gate 	case KIOCABORT1A:
20997c478bd9Sstevel@tonic-gate 	case KIOCABORT2:
21007c478bd9Sstevel@tonic-gate 		i = secpolicy_console(cr);
21017c478bd9Sstevel@tonic-gate 		if (i != 0)
21027c478bd9Sstevel@tonic-gate 			return (i);
21037c478bd9Sstevel@tonic-gate 		switch (key->kio_tablemask) {
21047c478bd9Sstevel@tonic-gate 		case KIOCABORT1:
21057c478bd9Sstevel@tonic-gate 			kp->k_abort1 = key->kio_station;
21067c478bd9Sstevel@tonic-gate 			break;
21077c478bd9Sstevel@tonic-gate 		case KIOCABORT1A:
21087c478bd9Sstevel@tonic-gate 			kp->k_abort1a = key->kio_station;
21097c478bd9Sstevel@tonic-gate 			break;
21107c478bd9Sstevel@tonic-gate 		case KIOCABORT2:
21117c478bd9Sstevel@tonic-gate 			kp->k_abort2 = key->kio_station;
21127c478bd9Sstevel@tonic-gate 			break;
21137c478bd9Sstevel@tonic-gate 		}
21147c478bd9Sstevel@tonic-gate 		return (0);
21157c478bd9Sstevel@tonic-gate 	}
21167c478bd9Sstevel@tonic-gate 
21177c478bd9Sstevel@tonic-gate 	ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask,
21187c478bd9Sstevel@tonic-gate 		key->kio_station);
21197c478bd9Sstevel@tonic-gate 	if (ke == NULL)
21207c478bd9Sstevel@tonic-gate 		return (EINVAL);
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 	if (key->kio_entry >= STRING &&
21237c478bd9Sstevel@tonic-gate 	    key->kio_entry <= (ushort_t)(STRING + 15)) {
21247c478bd9Sstevel@tonic-gate 		strtabindex = key->kio_entry-STRING;
21257c478bd9Sstevel@tonic-gate 		bcopy(key->kio_string,
21267c478bd9Sstevel@tonic-gate 			lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN);
21277c478bd9Sstevel@tonic-gate 		lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0';
21287c478bd9Sstevel@tonic-gate 	}
21297c478bd9Sstevel@tonic-gate 
21307c478bd9Sstevel@tonic-gate 	*ke = key->kio_entry;
21317c478bd9Sstevel@tonic-gate 
21327c478bd9Sstevel@tonic-gate 	return (0);
21337c478bd9Sstevel@tonic-gate }
21347c478bd9Sstevel@tonic-gate 
21357c478bd9Sstevel@tonic-gate 
21367c478bd9Sstevel@tonic-gate /*
21377c478bd9Sstevel@tonic-gate  * kbtrans_gkey:
21387c478bd9Sstevel@tonic-gate  *	Get individual keystation translation as new-style entry.
21397c478bd9Sstevel@tonic-gate  */
21407c478bd9Sstevel@tonic-gate static int
21417c478bd9Sstevel@tonic-gate kbtrans_gkey(struct kbtrans_lower *lower, struct	kiockeymap *key)
21427c478bd9Sstevel@tonic-gate {
21437c478bd9Sstevel@tonic-gate 	int	strtabindex;
21447c478bd9Sstevel@tonic-gate 	unsigned short *ke;
21457c478bd9Sstevel@tonic-gate 	struct keyboard *kp;
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 	kp = lower->kbtrans_keyboard;
21487c478bd9Sstevel@tonic-gate 
21497c478bd9Sstevel@tonic-gate 	if (key->kio_station >= kp->k_keymap_size)
21507c478bd9Sstevel@tonic-gate 		return (EINVAL);
21517c478bd9Sstevel@tonic-gate 
21527c478bd9Sstevel@tonic-gate 	if (lower->kbtrans_keyboard == NULL)
21537c478bd9Sstevel@tonic-gate 		return (EINVAL);
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	switch (key->kio_tablemask) {
21567c478bd9Sstevel@tonic-gate 	case KIOCABORT1:
21577c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort1;
21587c478bd9Sstevel@tonic-gate 		return (0);
21597c478bd9Sstevel@tonic-gate 	case KIOCABORT1A:
21607c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort1a;
21617c478bd9Sstevel@tonic-gate 		return (0);
21627c478bd9Sstevel@tonic-gate 	case KIOCABORT2:
21637c478bd9Sstevel@tonic-gate 		key->kio_station = kp->k_abort2;
21647c478bd9Sstevel@tonic-gate 		return (0);
21657c478bd9Sstevel@tonic-gate 	}
21667c478bd9Sstevel@tonic-gate 
21677c478bd9Sstevel@tonic-gate 	ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask,
21687c478bd9Sstevel@tonic-gate 		key->kio_station);
21697c478bd9Sstevel@tonic-gate 	if (ke == NULL)
21707c478bd9Sstevel@tonic-gate 		return (EINVAL);
21717c478bd9Sstevel@tonic-gate 
21727c478bd9Sstevel@tonic-gate 	key->kio_entry = *ke;
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 	if (key->kio_entry >= STRING &&
21757c478bd9Sstevel@tonic-gate 	    key->kio_entry <= (ushort_t)(STRING + 15)) {
21767c478bd9Sstevel@tonic-gate 		strtabindex = key->kio_entry-STRING;
21777c478bd9Sstevel@tonic-gate 		bcopy(lower->kbtrans_keystringtab[strtabindex],
21787c478bd9Sstevel@tonic-gate 			key->kio_string, KTAB_STRLEN);
21797c478bd9Sstevel@tonic-gate 	}
21807c478bd9Sstevel@tonic-gate 	return (0);
21817c478bd9Sstevel@tonic-gate }
2182