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