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 599d47a04Slq * Common Development and Distribution License (the "License"). 699d47a04Slq * 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 */ 2199d47a04Slq 227c478bd9Sstevel@tonic-gate /* 2348633f18SJan Setje-Eilers * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 25*7d724debSJoshua M. Clulow * Copyright 2019 Joyent, Inc. 267c478bd9Sstevel@tonic-gate */ 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate /* 29*7d724debSJoshua M. Clulow * Generic keyboard support: STREAMS and administration. 307c478bd9Sstevel@tonic-gate */ 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate #define KEYMAP_SIZE_VARIABLE 337c478bd9Sstevel@tonic-gate 347c478bd9Sstevel@tonic-gate #include <sys/types.h> 357c478bd9Sstevel@tonic-gate #include <sys/cred.h> 367c478bd9Sstevel@tonic-gate #include <sys/stream.h> 377c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 387c478bd9Sstevel@tonic-gate #include <sys/strsun.h> 397c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 407c478bd9Sstevel@tonic-gate #include <sys/vuid_event.h> 417c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 427c478bd9Sstevel@tonic-gate #include <sys/errno.h> 437c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 447c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 457c478bd9Sstevel@tonic-gate #include <sys/kbd.h> 467c478bd9Sstevel@tonic-gate #include <sys/kbio.h> 477c478bd9Sstevel@tonic-gate #include <sys/consdev.h> 487c478bd9Sstevel@tonic-gate #include <sys/kbtrans.h> 497c478bd9Sstevel@tonic-gate #include <sys/policy.h> 5048633f18SJan Setje-Eilers #include <sys/sunldi.h> 513bce8c8cSJan Setje-Eilers #include <sys/class.h> 523bce8c8cSJan Setje-Eilers #include <sys/spl.h> 537c478bd9Sstevel@tonic-gate #include "kbtrans_lower.h" 547c478bd9Sstevel@tonic-gate #include "kbtrans_streams.h" 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate #ifdef DEBUG 577c478bd9Sstevel@tonic-gate int kbtrans_errmask; 587c478bd9Sstevel@tonic-gate int kbtrans_errlevel; 597c478bd9Sstevel@tonic-gate #endif 607c478bd9Sstevel@tonic-gate 61aecfc01dSrui zang - Sun Microsystems - Beijing China #define KB_NR_FUNCKEYS 12 62aecfc01dSrui zang - Sun Microsystems - Beijing China 637c478bd9Sstevel@tonic-gate /* 64*7d724debSJoshua M. Clulow * Overrides for tuning keyboard autorepeat behaviour: 657c478bd9Sstevel@tonic-gate */ 66*7d724debSJoshua M. Clulow int kbtrans_repeat_count = -1; 67*7d724debSJoshua M. Clulow int kbtrans_repeat_rate; 68*7d724debSJoshua M. Clulow int kbtrans_repeat_delay; 697c478bd9Sstevel@tonic-gate 70*7d724debSJoshua M. Clulow /* 71*7d724debSJoshua M. Clulow * Override whether to print a message when the keyboard event queue overflows: 72*7d724debSJoshua M. Clulow */ 73*7d724debSJoshua M. Clulow int kbtrans_overflow_msg = 1; 74*7d724debSJoshua M. Clulow 75*7d724debSJoshua M. Clulow /* 76*7d724debSJoshua M. Clulow * Override whether to drop "Scroll Lock" key presses in TR_ASCII mode: 77*7d724debSJoshua M. Clulow */ 78*7d724debSJoshua M. Clulow int kbtrans_ignore_scroll_lock = 1; 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate /* 81*7d724debSJoshua M. Clulow * Override for the number of key stations we will track in the down state at 82*7d724debSJoshua M. Clulow * one time. By default we assume most keyboards will be operated by people 83*7d724debSJoshua M. Clulow * with up to ten fingers, plus some safety margin. This size is only read 84*7d724debSJoshua M. Clulow * once at attach time. 857c478bd9Sstevel@tonic-gate */ 86*7d724debSJoshua M. Clulow int kbtrans_downs_size = 15; 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate /* 897c478bd9Sstevel@tonic-gate * modload support 907c478bd9Sstevel@tonic-gate */ 917c478bd9Sstevel@tonic-gate extern struct mod_ops mod_miscops; 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate static struct modlmisc modlmisc = { 947c478bd9Sstevel@tonic-gate &mod_miscops, /* Type of module */ 95aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans (key translation)" 967c478bd9Sstevel@tonic-gate }; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = { 997c478bd9Sstevel@tonic-gate MODREV_1, (void *)&modlmisc, NULL 1007c478bd9Sstevel@tonic-gate }; 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate int 1037c478bd9Sstevel@tonic-gate _init(void) 1047c478bd9Sstevel@tonic-gate { 1057c478bd9Sstevel@tonic-gate return (mod_install(&modlinkage)); 1067c478bd9Sstevel@tonic-gate } 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate int 1097c478bd9Sstevel@tonic-gate _fini(void) 1107c478bd9Sstevel@tonic-gate { 1117c478bd9Sstevel@tonic-gate return (mod_remove(&modlinkage)); 1127c478bd9Sstevel@tonic-gate } 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate int 1157c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop) 1167c478bd9Sstevel@tonic-gate { 1177c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop)); 1187c478bd9Sstevel@tonic-gate } 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * Internal Function Prototypes 1227c478bd9Sstevel@tonic-gate */ 1235d420dfbSToomas Soome static char *kbtrans_strsetwithdecimal(char *, uint_t, uint_t); 1245d420dfbSToomas Soome static void kbtrans_set_translation_callback(struct kbtrans *); 1255d420dfbSToomas Soome static void kbtrans_reioctl(void *); 1265d420dfbSToomas Soome static void kbtrans_send_esc_event(char, struct kbtrans *); 1275d420dfbSToomas Soome static void kbtrans_keypressed(struct kbtrans *, uchar_t, Firm_event *, 1285d420dfbSToomas Soome ushort_t); 1295d420dfbSToomas Soome static void kbtrans_putbuf(char *, queue_t *); 1305d420dfbSToomas Soome static void kbtrans_cancelrpt(struct kbtrans *); 1315d420dfbSToomas Soome static void kbtrans_queuepress(struct kbtrans *, uchar_t, Firm_event *); 1325d420dfbSToomas Soome static void kbtrans_putcode(register struct kbtrans *, uint_t); 1335d420dfbSToomas Soome static void kbtrans_keyreleased(struct kbtrans *, uchar_t); 1345d420dfbSToomas Soome static void kbtrans_queueevent(struct kbtrans *, Firm_event *); 1355d420dfbSToomas Soome static void kbtrans_untrans_keypressed_raw(struct kbtrans *, kbtrans_key_t); 1365d420dfbSToomas Soome static void kbtrans_untrans_keyreleased_raw(struct kbtrans *, kbtrans_key_t); 1375d420dfbSToomas Soome static void kbtrans_ascii_keypressed(struct kbtrans *, uint_t, 1385d420dfbSToomas Soome kbtrans_key_t, uint_t); 1395d420dfbSToomas Soome static void kbtrans_ascii_keyreleased(struct kbtrans *, kbtrans_key_t); 1405d420dfbSToomas Soome static void kbtrans_ascii_setup_repeat(struct kbtrans *, uint_t, kbtrans_key_t); 1415d420dfbSToomas Soome static void kbtrans_trans_event_keypressed(struct kbtrans *, uint_t, 1425d420dfbSToomas Soome kbtrans_key_t, uint_t); 1435d420dfbSToomas Soome static void kbtrans_trans_event_keyreleased(struct kbtrans *, kbtrans_key_t); 1445d420dfbSToomas Soome static void kbtrans_trans_event_setup_repeat(struct kbtrans *, uint_t, 1455d420dfbSToomas Soome kbtrans_key_t); 1465d420dfbSToomas Soome static void kbtrans_rpt(void *); 1475d420dfbSToomas Soome static void kbtrans_setled(struct kbtrans *); 1485d420dfbSToomas Soome static void kbtrans_flush(struct kbtrans *); 1495d420dfbSToomas Soome static enum kbtrans_message_response kbtrans_ioctl(struct kbtrans *, mblk_t *); 1505d420dfbSToomas Soome static int kbtrans_setkey(struct kbtrans_lower *, struct kiockey *, cred_t *); 1515d420dfbSToomas Soome static int kbtrans_getkey(struct kbtrans_lower *, struct kiockey *); 1525d420dfbSToomas Soome static int kbtrans_skey(struct kbtrans_lower *, struct kiockeymap *, cred_t *); 1535d420dfbSToomas Soome static int kbtrans_gkey(struct kbtrans_lower *, struct kiockeymap *); 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * Keyboard Translation Mode (TR_NONE) 1577c478bd9Sstevel@tonic-gate * 1587c478bd9Sstevel@tonic-gate * Functions to be called when keyboard translation is turned off 1597c478bd9Sstevel@tonic-gate * and up/down key codes are reported. 1607c478bd9Sstevel@tonic-gate */ 1617c478bd9Sstevel@tonic-gate struct keyboard_callback untrans_event_callback = { 1627c478bd9Sstevel@tonic-gate kbtrans_untrans_keypressed_raw, 1637c478bd9Sstevel@tonic-gate kbtrans_untrans_keyreleased_raw, 1647c478bd9Sstevel@tonic-gate NULL, 1657c478bd9Sstevel@tonic-gate NULL, 1667c478bd9Sstevel@tonic-gate NULL, 1677c478bd9Sstevel@tonic-gate NULL, 1687c478bd9Sstevel@tonic-gate NULL, 1697c478bd9Sstevel@tonic-gate }; 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate /* 1727c478bd9Sstevel@tonic-gate * Keyboard Translation Mode (TR_ASCII) 1737c478bd9Sstevel@tonic-gate * 1747c478bd9Sstevel@tonic-gate * Functions to be called when ISO 8859/1 codes are reported 1757c478bd9Sstevel@tonic-gate */ 1767c478bd9Sstevel@tonic-gate struct keyboard_callback ascii_callback = { 1777c478bd9Sstevel@tonic-gate NULL, 1787c478bd9Sstevel@tonic-gate NULL, 1797c478bd9Sstevel@tonic-gate kbtrans_ascii_keypressed, 1807c478bd9Sstevel@tonic-gate kbtrans_ascii_keyreleased, 1817c478bd9Sstevel@tonic-gate kbtrans_ascii_setup_repeat, 1827c478bd9Sstevel@tonic-gate kbtrans_cancelrpt, 1837c478bd9Sstevel@tonic-gate kbtrans_setled, 1847c478bd9Sstevel@tonic-gate }; 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate /* 1877c478bd9Sstevel@tonic-gate * Keyboard Translation Mode (TR_EVENT) 1887c478bd9Sstevel@tonic-gate * 1897c478bd9Sstevel@tonic-gate * Functions to be called when firm_events are reported. 1907c478bd9Sstevel@tonic-gate */ 1917c478bd9Sstevel@tonic-gate struct keyboard_callback trans_event_callback = { 1927c478bd9Sstevel@tonic-gate NULL, 1937c478bd9Sstevel@tonic-gate NULL, 1947c478bd9Sstevel@tonic-gate kbtrans_trans_event_keypressed, 1957c478bd9Sstevel@tonic-gate kbtrans_trans_event_keyreleased, 1967c478bd9Sstevel@tonic-gate kbtrans_trans_event_setup_repeat, 1977c478bd9Sstevel@tonic-gate kbtrans_cancelrpt, 1987c478bd9Sstevel@tonic-gate kbtrans_setled, 1997c478bd9Sstevel@tonic-gate }; 2007c478bd9Sstevel@tonic-gate 2013bce8c8cSJan Setje-Eilers static void 2023bce8c8cSJan Setje-Eilers progressbar_key_abort_thread(struct kbtrans *upper) 2033bce8c8cSJan Setje-Eilers { 2043bce8c8cSJan Setje-Eilers ldi_ident_t li; 2053bce8c8cSJan Setje-Eilers extern void progressbar_key_abort(ldi_ident_t); 2063bce8c8cSJan Setje-Eilers 2073bce8c8cSJan Setje-Eilers if (ldi_ident_from_stream(upper->kbtrans_streams_readq, &li) != 0) { 2083bce8c8cSJan Setje-Eilers cmn_err(CE_NOTE, "!ldi_ident_from_stream failed"); 2093bce8c8cSJan Setje-Eilers } else { 2103bce8c8cSJan Setje-Eilers mutex_enter(&upper->progressbar_key_abort_lock); 2113bce8c8cSJan Setje-Eilers while (upper->progressbar_key_abort_flag == 0) 2123bce8c8cSJan Setje-Eilers cv_wait(&upper->progressbar_key_abort_cv, 2133bce8c8cSJan Setje-Eilers &upper->progressbar_key_abort_lock); 21463dd072cSJan Setje-Eilers if (upper->progressbar_key_abort_flag == 1) { 21563dd072cSJan Setje-Eilers mutex_exit(&upper->progressbar_key_abort_lock); 2163bce8c8cSJan Setje-Eilers progressbar_key_abort(li); 21763dd072cSJan Setje-Eilers } else { 21863dd072cSJan Setje-Eilers mutex_exit(&upper->progressbar_key_abort_lock); 21963dd072cSJan Setje-Eilers } 2203bce8c8cSJan Setje-Eilers ldi_ident_release(li); 2213bce8c8cSJan Setje-Eilers } 2223bce8c8cSJan Setje-Eilers 2233bce8c8cSJan Setje-Eilers thread_exit(); 2243bce8c8cSJan Setje-Eilers } 2253bce8c8cSJan Setje-Eilers 2267c478bd9Sstevel@tonic-gate /* 2277c478bd9Sstevel@tonic-gate * kbtrans_streams_init: 2287c478bd9Sstevel@tonic-gate * Initialize the stream, keytables, callbacks, etc. 2297c478bd9Sstevel@tonic-gate */ 2307c478bd9Sstevel@tonic-gate int 2315d420dfbSToomas Soome kbtrans_streams_init(queue_t *q, int sflag, struct kbtrans_hardware *hw, 2325d420dfbSToomas Soome struct kbtrans_callbacks *hw_cb, struct kbtrans **ret_kbd, 2335d420dfbSToomas Soome int initial_leds, int initial_led_mask) 2347c478bd9Sstevel@tonic-gate { 2357c478bd9Sstevel@tonic-gate struct kbtrans *upper; 2367c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower; 2376087c6ddSJan Setje-Eilers kthread_t *tid; 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate /* 2407c478bd9Sstevel@tonic-gate * Default to relatively generic tables. 2417c478bd9Sstevel@tonic-gate */ 2427c478bd9Sstevel@tonic-gate extern signed char kb_compose_map[]; 2437c478bd9Sstevel@tonic-gate extern struct compose_sequence_t kb_compose_table[]; 2447c478bd9Sstevel@tonic-gate extern struct fltaccent_sequence_t kb_fltaccent_table[]; 2457c478bd9Sstevel@tonic-gate extern char keystringtab[][KTAB_STRLEN]; 2467c478bd9Sstevel@tonic-gate extern unsigned char kb_numlock_table[]; 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* Set these up only once so that they could be changed from adb */ 2497c478bd9Sstevel@tonic-gate if (!kbtrans_repeat_rate) { 2505d420dfbSToomas Soome kbtrans_repeat_rate = (hz + 29) / 30; 2515d420dfbSToomas Soome kbtrans_repeat_delay = hz / 2; 2527c478bd9Sstevel@tonic-gate } 2537c478bd9Sstevel@tonic-gate 2547c478bd9Sstevel@tonic-gate switch (sflag) { 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate case MODOPEN: 2577c478bd9Sstevel@tonic-gate break; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate case CLONEOPEN: 2607c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (NULL, 261aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans_streams_init: Clone open not supported")); 2627c478bd9Sstevel@tonic-gate 2637c478bd9Sstevel@tonic-gate return (EINVAL); 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate /* allocate keyboard state structure */ 2677c478bd9Sstevel@tonic-gate upper = kmem_zalloc(sizeof (struct kbtrans), KM_SLEEP); 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate *ret_kbd = upper; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate upper->kbtrans_polled_buf[0] = '\0'; 2727c478bd9Sstevel@tonic-gate upper->kbtrans_polled_pending_chars = upper->kbtrans_polled_buf; 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate upper->kbtrans_streams_hw = hw; 2757c478bd9Sstevel@tonic-gate upper->kbtrans_streams_hw_callbacks = hw_cb; 2767c478bd9Sstevel@tonic-gate upper->kbtrans_streams_readq = q; 2777c478bd9Sstevel@tonic-gate upper->kbtrans_streams_iocpending = NULL; 2787c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translatable = TR_CAN; 2797c478bd9Sstevel@tonic-gate upper->kbtrans_overflow_cnt = 0; 2807c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translate_mode = TR_ASCII; 2817c478bd9Sstevel@tonic-gate 2827c478bd9Sstevel@tonic-gate /* Set the translation callback based on the translation type */ 2837c478bd9Sstevel@tonic-gate kbtrans_set_translation_callback(upper); 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate lower = &upper->kbtrans_lower; 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * Set defaults for relatively generic tables. 2897c478bd9Sstevel@tonic-gate */ 2907c478bd9Sstevel@tonic-gate lower->kbtrans_compose_map = kb_compose_map; 2917c478bd9Sstevel@tonic-gate lower->kbtrans_compose_table = kb_compose_table; 2927c478bd9Sstevel@tonic-gate lower->kbtrans_fltaccent_table = kb_fltaccent_table; 2937c478bd9Sstevel@tonic-gate lower->kbtrans_numlock_table = kb_numlock_table; 2947c478bd9Sstevel@tonic-gate lower->kbtrans_keystringtab = keystringtab; 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate lower->kbtrans_upper = upper; 2977c478bd9Sstevel@tonic-gate lower->kbtrans_compat = 1; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * We have a generic default for the LED state, and let the 3017c478bd9Sstevel@tonic-gate * hardware-specific driver supply overrides. 3027c478bd9Sstevel@tonic-gate */ 3037c478bd9Sstevel@tonic-gate lower->kbtrans_led_state = 0; 3047c478bd9Sstevel@tonic-gate lower->kbtrans_led_state &= ~initial_led_mask; 3057c478bd9Sstevel@tonic-gate lower->kbtrans_led_state |= initial_leds; 3067c478bd9Sstevel@tonic-gate lower->kbtrans_togglemask = 0; 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate if (lower->kbtrans_led_state & LED_CAPS_LOCK) 3097c478bd9Sstevel@tonic-gate lower->kbtrans_togglemask |= CAPSMASK; 3107c478bd9Sstevel@tonic-gate if (lower->kbtrans_led_state & LED_NUM_LOCK) 3117c478bd9Sstevel@tonic-gate lower->kbtrans_togglemask |= NUMLOCKMASK; 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate #if defined(SCROLLMASK) 3147c478bd9Sstevel@tonic-gate if (lower->kbtrans_led_state & LED_SCROLL_LOCK) 3157c478bd9Sstevel@tonic-gate lower->kbtrans_togglemask |= SCROLLMASK; 3167c478bd9Sstevel@tonic-gate #endif 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate lower->kbtrans_shiftmask = lower->kbtrans_togglemask; 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate upper->kbtrans_streams_vuid_addr.ascii = ASCII_FIRST; 3217c478bd9Sstevel@tonic-gate upper->kbtrans_streams_vuid_addr.top = TOP_FIRST; 3227c478bd9Sstevel@tonic-gate upper->kbtrans_streams_vuid_addr.vkey = VKEY_FIRST; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate /* Allocate dynamic memory for downs table */ 3257c478bd9Sstevel@tonic-gate upper->kbtrans_streams_num_downs_entries = kbtrans_downs_size; 3267c478bd9Sstevel@tonic-gate upper->kbtrans_streams_downs_bytes = 327aecfc01dSrui zang - Sun Microsystems - Beijing China (uint32_t)(kbtrans_downs_size * sizeof (Key_event)); 3287c478bd9Sstevel@tonic-gate upper->kbtrans_streams_downs = 329aecfc01dSrui zang - Sun Microsystems - Beijing China kmem_zalloc(upper->kbtrans_streams_downs_bytes, KM_SLEEP); 3307c478bd9Sstevel@tonic-gate upper->kbtrans_streams_abortable = B_FALSE; 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate upper->kbtrans_streams_flags = KBTRANS_STREAMS_OPEN; 3337c478bd9Sstevel@tonic-gate 3343bce8c8cSJan Setje-Eilers upper->progressbar_key_abort_flag = 0; 3353bce8c8cSJan Setje-Eilers cv_init(&upper->progressbar_key_abort_cv, NULL, CV_DEFAULT, NULL); 3363bce8c8cSJan Setje-Eilers /* this counts on no keyboards being above ipl 12 */ 3373bce8c8cSJan Setje-Eilers mutex_init(&upper->progressbar_key_abort_lock, NULL, MUTEX_SPIN, 3383bce8c8cSJan Setje-Eilers (void *)ipltospl(12)); 3396087c6ddSJan Setje-Eilers tid = thread_create(NULL, 0, progressbar_key_abort_thread, upper, 3406087c6ddSJan Setje-Eilers 0, &p0, TS_RUN, minclsyspri); 3416087c6ddSJan Setje-Eilers upper->progressbar_key_abort_t_did = tid->t_did; 3423bce8c8cSJan Setje-Eilers 3437c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L1, PRINT_MASK_OPEN, (upper, "kbtrans_streams_init " 344aecfc01dSrui zang - Sun Microsystems - Beijing China "exiting")); 3457c478bd9Sstevel@tonic-gate return (0); 3467c478bd9Sstevel@tonic-gate } 3477c478bd9Sstevel@tonic-gate 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * kbtrans_streams_fini: 3517c478bd9Sstevel@tonic-gate * Free structures and uninitialize the stream 3527c478bd9Sstevel@tonic-gate */ 3537c478bd9Sstevel@tonic-gate int 3547c478bd9Sstevel@tonic-gate kbtrans_streams_fini(struct kbtrans *upper) 3557c478bd9Sstevel@tonic-gate { 3567c478bd9Sstevel@tonic-gate /* 3577c478bd9Sstevel@tonic-gate * Since we're about to destroy our private data, turn off 3587c478bd9Sstevel@tonic-gate * our open flag first, so we don't accept any more input 3597c478bd9Sstevel@tonic-gate * and try to use that data. 3607c478bd9Sstevel@tonic-gate */ 3617c478bd9Sstevel@tonic-gate upper->kbtrans_streams_flags = 0; 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate /* clear all timeouts */ 3647c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_bufcallid) { 3657c478bd9Sstevel@tonic-gate qunbufcall(upper->kbtrans_streams_readq, 366aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_bufcallid); 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_rptid) { 3697c478bd9Sstevel@tonic-gate (void) quntimeout(upper->kbtrans_streams_readq, 370aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_rptid); 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate kmem_free(upper->kbtrans_streams_downs, 373aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_downs_bytes); 3743bce8c8cSJan Setje-Eilers 3753bce8c8cSJan Setje-Eilers mutex_enter(&upper->progressbar_key_abort_lock); 3763bce8c8cSJan Setje-Eilers if (upper->progressbar_key_abort_flag == 0) { 3773bce8c8cSJan Setje-Eilers upper->progressbar_key_abort_flag = 2; 3783bce8c8cSJan Setje-Eilers cv_signal(&upper->progressbar_key_abort_cv); 3796087c6ddSJan Setje-Eilers mutex_exit(&upper->progressbar_key_abort_lock); 3806087c6ddSJan Setje-Eilers thread_join(upper->progressbar_key_abort_t_did); 3816087c6ddSJan Setje-Eilers } else { 3826087c6ddSJan Setje-Eilers mutex_exit(&upper->progressbar_key_abort_lock); 3833bce8c8cSJan Setje-Eilers } 3843bce8c8cSJan Setje-Eilers cv_destroy(&upper->progressbar_key_abort_cv); 3853bce8c8cSJan Setje-Eilers mutex_destroy(&upper->progressbar_key_abort_lock); 3863bce8c8cSJan Setje-Eilers 3877c478bd9Sstevel@tonic-gate kmem_free(upper, sizeof (struct kbtrans)); 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L1, PRINT_MASK_CLOSE, (upper, "kbtrans_streams_fini " 390aecfc01dSrui zang - Sun Microsystems - Beijing China "exiting")); 3917c478bd9Sstevel@tonic-gate return (0); 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate /* 3957c478bd9Sstevel@tonic-gate * kbtrans_streams_releaseall : 3967c478bd9Sstevel@tonic-gate * This function releases all the held keys. 3977c478bd9Sstevel@tonic-gate */ 3987c478bd9Sstevel@tonic-gate void 3997c478bd9Sstevel@tonic-gate kbtrans_streams_releaseall(struct kbtrans *upper) 4007c478bd9Sstevel@tonic-gate { 4017c478bd9Sstevel@tonic-gate register struct key_event *ke; 4027c478bd9Sstevel@tonic-gate register int i; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "USBKBM RELEASE ALL\n")); 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate /* Scan table of down key stations */ 4077c478bd9Sstevel@tonic-gate for (i = 0, ke = upper->kbtrans_streams_downs; 4087c478bd9Sstevel@tonic-gate i < upper->kbtrans_streams_num_downs_entries; i++, ke++) { 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /* Key station not zero */ 4117c478bd9Sstevel@tonic-gate if (ke->key_station) { 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate kbtrans_keyreleased(upper, ke->key_station); 4147c478bd9Sstevel@tonic-gate /* kbtrans_keyreleased resets downs entry */ 4157c478bd9Sstevel@tonic-gate } 4167c478bd9Sstevel@tonic-gate } 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate 4197c478bd9Sstevel@tonic-gate /* 4207c478bd9Sstevel@tonic-gate * kbtrans_streams_message: 4217c478bd9Sstevel@tonic-gate * keyboard module output queue put procedure: handles M_IOCTL 4227c478bd9Sstevel@tonic-gate * messages. 4237c478bd9Sstevel@tonic-gate * 4245d420dfbSToomas Soome * Return KBTRANS_MESSAGE_HANDLED if the message was handled by 4257c478bd9Sstevel@tonic-gate * kbtrans and KBTRANS_MESSAGE_NOT_HANDLED otherwise. If 4267c478bd9Sstevel@tonic-gate * KBTRANS_MESSAGE_HANDLED is returned, no further action is required. 4277c478bd9Sstevel@tonic-gate * If KBTRANS_MESSAGE_NOT_HANDLED is returned, the hardware module 4287c478bd9Sstevel@tonic-gate * is responsible for any action. 4297c478bd9Sstevel@tonic-gate */ 4307c478bd9Sstevel@tonic-gate enum kbtrans_message_response 4317c478bd9Sstevel@tonic-gate kbtrans_streams_message(struct kbtrans *upper, register mblk_t *mp) 4327c478bd9Sstevel@tonic-gate { 4337c478bd9Sstevel@tonic-gate queue_t *q = upper->kbtrans_streams_readq; 4347c478bd9Sstevel@tonic-gate enum kbtrans_message_response ret; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper, 437aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans_streams_message entering")); 4387c478bd9Sstevel@tonic-gate /* 4397c478bd9Sstevel@tonic-gate * Process M_FLUSH, and some M_IOCTL, messages here; pass 4407c478bd9Sstevel@tonic-gate * everything else down. 4417c478bd9Sstevel@tonic-gate */ 4427c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) { 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate case M_IOCTL: 4457c478bd9Sstevel@tonic-gate ret = kbtrans_ioctl(upper, mp); 4467c478bd9Sstevel@tonic-gate break; 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate case M_FLUSH: 4497c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHW) 4507c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA); 4517c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) 4527c478bd9Sstevel@tonic-gate flushq(RD(q), FLUSHDATA); 4537c478bd9Sstevel@tonic-gate /* 4547c478bd9Sstevel@tonic-gate * White lie: we say we didn't handle the message, 4557c478bd9Sstevel@tonic-gate * so that it gets handled by our client. 4567c478bd9Sstevel@tonic-gate */ 4577c478bd9Sstevel@tonic-gate ret = KBTRANS_MESSAGE_NOT_HANDLED; 4587c478bd9Sstevel@tonic-gate break; 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate default: 4617c478bd9Sstevel@tonic-gate ret = KBTRANS_MESSAGE_NOT_HANDLED; 4627c478bd9Sstevel@tonic-gate break; 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L1, PRINT_MASK_ALL, (upper, 466aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans_streams_message exiting\n")); 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate return (ret); 4697c478bd9Sstevel@tonic-gate } 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate /* 4727c478bd9Sstevel@tonic-gate * kbtrans_streams_key: 4735d420dfbSToomas Soome * When a key is pressed or released, the hardware module should 4745d420dfbSToomas Soome * call kbtrans, passing the key number and its new 4755d420dfbSToomas Soome * state. kbtrans is responsible for autorepeat handling; 4765d420dfbSToomas Soome * the hardware module should report only actual press/release 4775d420dfbSToomas Soome * events, suppressing any hardware-generated autorepeat. 4787c478bd9Sstevel@tonic-gate */ 4797c478bd9Sstevel@tonic-gate void 4805d420dfbSToomas Soome kbtrans_streams_key(struct kbtrans *upper, kbtrans_key_t key, 4817c478bd9Sstevel@tonic-gate enum keystate state) 4827c478bd9Sstevel@tonic-gate { 4837c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower; 4847c478bd9Sstevel@tonic-gate struct keyboard *kp; 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate lower = &upper->kbtrans_lower; 4877c478bd9Sstevel@tonic-gate kp = lower->kbtrans_keyboard; 4887c478bd9Sstevel@tonic-gate 48948633f18SJan Setje-Eilers /* trigger switch back to text mode */ 4903bce8c8cSJan Setje-Eilers mutex_enter(&upper->progressbar_key_abort_lock); 4913bce8c8cSJan Setje-Eilers if (upper->progressbar_key_abort_flag == 0) { 4923bce8c8cSJan Setje-Eilers upper->progressbar_key_abort_flag = 1; 4933bce8c8cSJan Setje-Eilers cv_signal(&upper->progressbar_key_abort_cv); 49448633f18SJan Setje-Eilers } 4953bce8c8cSJan Setje-Eilers mutex_exit(&upper->progressbar_key_abort_lock); 49648633f18SJan Setje-Eilers 4977c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_abortable) { 4987c478bd9Sstevel@tonic-gate switch (upper->kbtrans_streams_abort_state) { 4997c478bd9Sstevel@tonic-gate case ABORT_NORMAL: 5007c478bd9Sstevel@tonic-gate if (state != KEY_PRESSED) 5017c478bd9Sstevel@tonic-gate break; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate if (key == (kbtrans_key_t)kp->k_abort1 || 5047c478bd9Sstevel@tonic-gate key == (kbtrans_key_t)kp->k_abort1a) { 5057c478bd9Sstevel@tonic-gate upper->kbtrans_streams_abort_state = 506aecfc01dSrui zang - Sun Microsystems - Beijing China ABORT_ABORT1_RECEIVED; 5077c478bd9Sstevel@tonic-gate upper->kbtrans_streams_abort1_key = key; 5087c478bd9Sstevel@tonic-gate return; 5097c478bd9Sstevel@tonic-gate } 510e57f7474Sqz /* Shift key needs to be sent to upper immediately */ 511e4603304Sqz if (key == (kbtrans_key_t)kp->k_newabort1 || 512e4603304Sqz key == (kbtrans_key_t)kp->k_newabort1a) { 513e4603304Sqz upper->kbtrans_streams_abort_state = 514aecfc01dSrui zang - Sun Microsystems - Beijing China NEW_ABORT_ABORT1_RECEIVED; 515e4603304Sqz upper->kbtrans_streams_new_abort1_key = key; 516e4603304Sqz } 5177c478bd9Sstevel@tonic-gate break; 5187c478bd9Sstevel@tonic-gate case ABORT_ABORT1_RECEIVED: 5197c478bd9Sstevel@tonic-gate upper->kbtrans_streams_abort_state = ABORT_NORMAL; 5207c478bd9Sstevel@tonic-gate if (state == KEY_PRESSED && 5217c478bd9Sstevel@tonic-gate key == (kbtrans_key_t)kp->k_abort2) { 5227c478bd9Sstevel@tonic-gate abort_sequence_enter((char *)NULL); 5237c478bd9Sstevel@tonic-gate return; 5247c478bd9Sstevel@tonic-gate } else { 5257c478bd9Sstevel@tonic-gate kbtrans_processkey(lower, 526aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_callback, 527aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_abort1_key, 528aecfc01dSrui zang - Sun Microsystems - Beijing China KEY_PRESSED); 5297c478bd9Sstevel@tonic-gate } 530e4603304Sqz break; 531e4603304Sqz case NEW_ABORT_ABORT1_RECEIVED: 532e4603304Sqz upper->kbtrans_streams_abort_state = ABORT_NORMAL; 533e4603304Sqz if (state == KEY_PRESSED && 534e4603304Sqz key == (kbtrans_key_t)kp->k_newabort2) { 535e4603304Sqz abort_sequence_enter((char *)NULL); 536e4603304Sqz kbtrans_processkey(lower, 537aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_callback, 538aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_new_abort1_key, 539aecfc01dSrui zang - Sun Microsystems - Beijing China KEY_RELEASED); 540e57f7474Sqz return; 541e4603304Sqz } 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate kbtrans_processkey(lower, upper->kbtrans_streams_callback, key, state); 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate /* 5497c478bd9Sstevel@tonic-gate * kbtrans_streams_set_keyboard: 5505d420dfbSToomas Soome * At any time after calling kbtrans_streams_init, the hardware 5515d420dfbSToomas Soome * module should make this call to report the id of the keyboard 5525d420dfbSToomas Soome * attached. id is the keyboard type, typically KB_SUN4, 5535d420dfbSToomas Soome * KB_PC, or KB_USB. 5547c478bd9Sstevel@tonic-gate */ 5557c478bd9Sstevel@tonic-gate void 5565d420dfbSToomas Soome kbtrans_streams_set_keyboard(struct kbtrans *upper, int id, struct keyboard *k) 5577c478bd9Sstevel@tonic-gate { 5587c478bd9Sstevel@tonic-gate upper->kbtrans_lower.kbtrans_keyboard = k; 5597c478bd9Sstevel@tonic-gate upper->kbtrans_streams_id = id; 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate /* 5637c478bd9Sstevel@tonic-gate * kbtrans_streams_has_reset: 5645d420dfbSToomas Soome * At any time between kbtrans_streams_init and kbtrans_streams_fini, 5655d420dfbSToomas Soome * the hardware module can call this routine to report that the 5665d420dfbSToomas Soome * keyboard has been reset, e.g. by being unplugged and reattached. 5677c478bd9Sstevel@tonic-gate */ 5687c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5697c478bd9Sstevel@tonic-gate void 5707c478bd9Sstevel@tonic-gate kbtrans_streams_has_reset(struct kbtrans *upper) 5717c478bd9Sstevel@tonic-gate { 5727c478bd9Sstevel@tonic-gate /* 5737c478bd9Sstevel@tonic-gate * If this routine is implemented it should probably (a) 5747c478bd9Sstevel@tonic-gate * simulate releases of all pressed keys and (b) call 5757c478bd9Sstevel@tonic-gate * the hardware module to set the LEDs. 5767c478bd9Sstevel@tonic-gate */ 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate /* 5807c478bd9Sstevel@tonic-gate * kbtrans_streams_enable: 5817c478bd9Sstevel@tonic-gate * This is the routine that is called back when the the stream is ready 5827c478bd9Sstevel@tonic-gate * to take messages. 5837c478bd9Sstevel@tonic-gate */ 5847c478bd9Sstevel@tonic-gate void 5857c478bd9Sstevel@tonic-gate kbtrans_streams_enable(struct kbtrans *upper) 5867c478bd9Sstevel@tonic-gate { 5877c478bd9Sstevel@tonic-gate /* Set the LED's */ 5887c478bd9Sstevel@tonic-gate kbtrans_setled(upper); 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate 59199d47a04Slq /* 59299d47a04Slq * kbtrans_streams_setled(): 59399d47a04Slq * This is the routine that is called to only update the led state 59499d47a04Slq * in kbtrans. 59599d47a04Slq */ 59699d47a04Slq void 59799d47a04Slq kbtrans_streams_setled(struct kbtrans *upper, int led_state) 59899d47a04Slq { 59999d47a04Slq struct kbtrans_lower *lower; 60099d47a04Slq 60199d47a04Slq lower = &upper->kbtrans_lower; 60299d47a04Slq lower->kbtrans_led_state = (uchar_t)led_state; 60399d47a04Slq 60499d47a04Slq if (lower->kbtrans_led_state & LED_CAPS_LOCK) 60599d47a04Slq lower->kbtrans_togglemask |= CAPSMASK; 60699d47a04Slq if (lower->kbtrans_led_state & LED_NUM_LOCK) 60799d47a04Slq lower->kbtrans_togglemask |= NUMLOCKMASK; 60899d47a04Slq 60999d47a04Slq #if defined(SCROLLMASK) 61099d47a04Slq if (lower->kbtrans_led_state & LED_SCROLL_LOCK) 61199d47a04Slq lower->kbtrans_togglemask |= SCROLLMASK; 61299d47a04Slq #endif 61399d47a04Slq 61499d47a04Slq lower->kbtrans_shiftmask = lower->kbtrans_togglemask; 61599d47a04Slq 61699d47a04Slq } 61799d47a04Slq 6187c478bd9Sstevel@tonic-gate /* 6197c478bd9Sstevel@tonic-gate * kbtrans_streams_set_queue: 6207c478bd9Sstevel@tonic-gate * Set the overlying queue, to support multiplexors. 6217c478bd9Sstevel@tonic-gate */ 6227c478bd9Sstevel@tonic-gate void 6237c478bd9Sstevel@tonic-gate kbtrans_streams_set_queue(struct kbtrans *upper, queue_t *q) 6247c478bd9Sstevel@tonic-gate { 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate upper->kbtrans_streams_readq = q; 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate /* 6307c478bd9Sstevel@tonic-gate * kbtrans_streams_get_queue: 6317c478bd9Sstevel@tonic-gate * Return the overlying queue. 6327c478bd9Sstevel@tonic-gate */ 6337c478bd9Sstevel@tonic-gate queue_t * 6347c478bd9Sstevel@tonic-gate kbtrans_streams_get_queue(struct kbtrans *upper) 6357c478bd9Sstevel@tonic-gate { 6367c478bd9Sstevel@tonic-gate return (upper->kbtrans_streams_readq); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /* 6407c478bd9Sstevel@tonic-gate * kbtrans_streams_untimeout 6417c478bd9Sstevel@tonic-gate * Cancell all timeout 6427c478bd9Sstevel@tonic-gate */ 6437c478bd9Sstevel@tonic-gate void 6447c478bd9Sstevel@tonic-gate kbtrans_streams_untimeout(struct kbtrans *upper) 6457c478bd9Sstevel@tonic-gate { 6467c478bd9Sstevel@tonic-gate /* clear all timeouts */ 6477c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_bufcallid) { 6487c478bd9Sstevel@tonic-gate qunbufcall(upper->kbtrans_streams_readq, 649aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_bufcallid); 6507c478bd9Sstevel@tonic-gate upper->kbtrans_streams_bufcallid = 0; 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_rptid) { 6537c478bd9Sstevel@tonic-gate (void) quntimeout(upper->kbtrans_streams_readq, 654aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_rptid); 6557c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = 0; 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate /* 6607c478bd9Sstevel@tonic-gate * kbtrans_reioctl: 6615d420dfbSToomas Soome * This function is set up as call-back function should an ioctl fail 6625d420dfbSToomas Soome * to allocate required resources. 6637c478bd9Sstevel@tonic-gate */ 6647c478bd9Sstevel@tonic-gate static void 6657c478bd9Sstevel@tonic-gate kbtrans_reioctl(void *arg) 6667c478bd9Sstevel@tonic-gate { 6677c478bd9Sstevel@tonic-gate struct kbtrans *upper = (struct kbtrans *)arg; 6687c478bd9Sstevel@tonic-gate mblk_t *mp; 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate upper->kbtrans_streams_bufcallid = 0; 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate if ((mp = upper->kbtrans_streams_iocpending) != NULL) { 6737c478bd9Sstevel@tonic-gate /* not pending any more */ 6747c478bd9Sstevel@tonic-gate upper->kbtrans_streams_iocpending = NULL; 6757c478bd9Sstevel@tonic-gate (void) kbtrans_ioctl(upper, mp); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate /* 6807c478bd9Sstevel@tonic-gate * kbtrans_ioctl: 6815d420dfbSToomas Soome * process ioctls we recognize and own. Otherwise, pass it down. 6827c478bd9Sstevel@tonic-gate */ 6837c478bd9Sstevel@tonic-gate static enum kbtrans_message_response 6847c478bd9Sstevel@tonic-gate kbtrans_ioctl(struct kbtrans *upper, register mblk_t *mp) 6857c478bd9Sstevel@tonic-gate { 6867c478bd9Sstevel@tonic-gate register struct iocblk *iocp; 6877c478bd9Sstevel@tonic-gate register short new_translate; 6887c478bd9Sstevel@tonic-gate register Vuid_addr_probe *addr_probe; 6897c478bd9Sstevel@tonic-gate register short *addr_ptr; 6907c478bd9Sstevel@tonic-gate size_t ioctlrespsize; 6917c478bd9Sstevel@tonic-gate int err = 0; 6927c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower; 6937c478bd9Sstevel@tonic-gate mblk_t *datap; 6947c478bd9Sstevel@tonic-gate int translate; 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate static int kiocgetkey, kiocsetkey; 6977c478bd9Sstevel@tonic-gate 6987c478bd9Sstevel@tonic-gate lower = &upper->kbtrans_lower; 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate iocp = (struct iocblk *)mp->b_rptr; 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, 703aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans_ioctl: ioc_cmd 0x%x - ", iocp->ioc_cmd)); 7047c478bd9Sstevel@tonic-gate switch (iocp->ioc_cmd) { 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate case VUIDSFORMAT: 7077c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSFORMAT\n")); 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 7107c478bd9Sstevel@tonic-gate if (err != 0) 7117c478bd9Sstevel@tonic-gate break; 7127c478bd9Sstevel@tonic-gate new_translate = (*(int *)mp->b_cont->b_rptr == VUID_NATIVE) ? 7137c478bd9Sstevel@tonic-gate TR_ASCII : TR_EVENT; 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate if (new_translate == upper->kbtrans_streams_translate_mode) 7167c478bd9Sstevel@tonic-gate break; 7177c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translate_mode = new_translate; 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate kbtrans_set_translation_callback(upper); 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate kbtrans_flush(upper); 7227c478bd9Sstevel@tonic-gate break; 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate case KIOCTRANS: 7257c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANS\n")); 7267c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 7277c478bd9Sstevel@tonic-gate if (err != 0) 7287c478bd9Sstevel@tonic-gate break; 7297c478bd9Sstevel@tonic-gate new_translate = *(int *)mp->b_cont->b_rptr; 7307c478bd9Sstevel@tonic-gate if (new_translate == upper->kbtrans_streams_translate_mode) 7317c478bd9Sstevel@tonic-gate break; 7327c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translate_mode = new_translate; 7337c478bd9Sstevel@tonic-gate kbtrans_set_translation_callback(upper); 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate kbtrans_flush(upper); 7367c478bd9Sstevel@tonic-gate break; 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate case KIOCSLED: 7397c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSLED\n")); 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (uchar_t)); 7427c478bd9Sstevel@tonic-gate if (err != 0) 7437c478bd9Sstevel@tonic-gate break; 7447c478bd9Sstevel@tonic-gate lower->kbtrans_led_state = *(uchar_t *)mp->b_cont->b_rptr; 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate kbtrans_setled(upper); 7477c478bd9Sstevel@tonic-gate break; 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate case KIOCGLED: 7507c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGLED\n")); 7517c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (uchar_t), BPRI_HI)) == NULL) { 7527c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 7537c478bd9Sstevel@tonic-gate goto allocfailure; 7547c478bd9Sstevel@tonic-gate } 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate *(uchar_t *)datap->b_wptr = lower->kbtrans_led_state; 7577c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (uchar_t); 7587c478bd9Sstevel@tonic-gate if (mp->b_cont) 7597c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 7607c478bd9Sstevel@tonic-gate mp->b_cont = datap; 7617c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (uchar_t); 7627c478bd9Sstevel@tonic-gate break; 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate case VUIDGFORMAT: 7657c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGFORMAT\n")); 7667c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 7677c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 7687c478bd9Sstevel@tonic-gate goto allocfailure; 7697c478bd9Sstevel@tonic-gate } 7707c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = 7717c478bd9Sstevel@tonic-gate (upper->kbtrans_streams_translate_mode == TR_EVENT || 7727c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translate_mode == TR_UNTRANS_EVENT) ? 773aecfc01dSrui zang - Sun Microsystems - Beijing China VUID_FIRM_EVENT: VUID_NATIVE; 7747c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 7757c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 7767c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 7777c478bd9Sstevel@tonic-gate mp->b_cont = datap; 7787c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 7797c478bd9Sstevel@tonic-gate break; 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate case KIOCGTRANS: 7827c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANS\n")); 7837c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 7847c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 7857c478bd9Sstevel@tonic-gate goto allocfailure; 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = upper->kbtrans_streams_translate_mode; 7887c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 7897c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 7907c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 7917c478bd9Sstevel@tonic-gate mp->b_cont = datap; 7927c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 7937c478bd9Sstevel@tonic-gate break; 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate case VUIDSADDR: 7967c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDSADDR\n")); 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (Vuid_addr_probe)); 7997c478bd9Sstevel@tonic-gate if (err != 0) 8007c478bd9Sstevel@tonic-gate break; 8017c478bd9Sstevel@tonic-gate addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr; 8027c478bd9Sstevel@tonic-gate switch (addr_probe->base) { 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate case ASCII_FIRST: 8057c478bd9Sstevel@tonic-gate addr_ptr = &upper->kbtrans_streams_vuid_addr.ascii; 8067c478bd9Sstevel@tonic-gate break; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate case TOP_FIRST: 8097c478bd9Sstevel@tonic-gate addr_ptr = &upper->kbtrans_streams_vuid_addr.top; 8107c478bd9Sstevel@tonic-gate break; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate case VKEY_FIRST: 8137c478bd9Sstevel@tonic-gate addr_ptr = &upper->kbtrans_streams_vuid_addr.vkey; 8147c478bd9Sstevel@tonic-gate break; 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate default: 8177c478bd9Sstevel@tonic-gate err = ENODEV; 8187c478bd9Sstevel@tonic-gate } 8197c478bd9Sstevel@tonic-gate 8207c478bd9Sstevel@tonic-gate if ((err == 0) && (*addr_ptr != addr_probe->data.next)) { 8217c478bd9Sstevel@tonic-gate *addr_ptr = addr_probe->data.next; 8227c478bd9Sstevel@tonic-gate kbtrans_flush(upper); 8237c478bd9Sstevel@tonic-gate } 8247c478bd9Sstevel@tonic-gate break; 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate case VUIDGADDR: 8277c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "VUIDGADDR\n")); 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (Vuid_addr_probe)); 8307c478bd9Sstevel@tonic-gate if (err != 0) 8317c478bd9Sstevel@tonic-gate break; 8327c478bd9Sstevel@tonic-gate addr_probe = (Vuid_addr_probe *)mp->b_cont->b_rptr; 8337c478bd9Sstevel@tonic-gate switch (addr_probe->base) { 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate case ASCII_FIRST: 8367c478bd9Sstevel@tonic-gate addr_probe->data.current = 837aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_vuid_addr.ascii; 8387c478bd9Sstevel@tonic-gate break; 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate case TOP_FIRST: 8417c478bd9Sstevel@tonic-gate addr_probe->data.current = 842aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_vuid_addr.top; 8437c478bd9Sstevel@tonic-gate break; 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate case VKEY_FIRST: 8467c478bd9Sstevel@tonic-gate addr_probe->data.current = 847aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_vuid_addr.vkey; 8487c478bd9Sstevel@tonic-gate break; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate default: 8517c478bd9Sstevel@tonic-gate err = ENODEV; 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate break; 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate case KIOCTRANSABLE: 8567c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTRANSABLE\n")); 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 8597c478bd9Sstevel@tonic-gate if (err != 0) 8607c478bd9Sstevel@tonic-gate break; 8617c478bd9Sstevel@tonic-gate /* 8627c478bd9Sstevel@tonic-gate * called during console setup in kbconfig() 8637c478bd9Sstevel@tonic-gate * If set to false, means we are a serial keyboard, 8647c478bd9Sstevel@tonic-gate * and we should pass all data up without modification. 8657c478bd9Sstevel@tonic-gate */ 8667c478bd9Sstevel@tonic-gate translate = *(int *)mp->b_cont->b_rptr; 8677c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_translatable != translate) 8687c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translatable = translate; 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate if (translate != TR_CAN) 8717c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L4, PRINT_MASK_ALL, (upper, 8727c478bd9Sstevel@tonic-gate "Cannot translate keyboard using tables.\n")); 8737c478bd9Sstevel@tonic-gate break; 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate case KIOCGTRANSABLE: 8767c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGTRANSABLE\n")); 8777c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 8787c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 8797c478bd9Sstevel@tonic-gate goto allocfailure; 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = upper->kbtrans_streams_translatable; 8827c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 8837c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 8847c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 8857c478bd9Sstevel@tonic-gate mp->b_cont = datap; 8867c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 8877c478bd9Sstevel@tonic-gate break; 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate case KIOCSCOMPAT: 8907c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSCOMPAT\n")); 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 8937c478bd9Sstevel@tonic-gate if (err != 0) 8947c478bd9Sstevel@tonic-gate break; 8957c478bd9Sstevel@tonic-gate lower->kbtrans_compat = *(int *)mp->b_cont->b_rptr; 8967c478bd9Sstevel@tonic-gate break; 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate case KIOCGCOMPAT: 8997c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGCOMPAT\n")); 9007c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 9017c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 9027c478bd9Sstevel@tonic-gate goto allocfailure; 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = lower->kbtrans_compat; 9057c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 9067c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 9077c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 9087c478bd9Sstevel@tonic-gate mp->b_cont = datap; 9097c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 9107c478bd9Sstevel@tonic-gate break; 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate case KIOCSETKEY: 9137c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSETKEY %d\n", 914aecfc01dSrui zang - Sun Microsystems - Beijing China kiocsetkey++)); 9157c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (struct kiockey)); 9167c478bd9Sstevel@tonic-gate if (err != 0) 9177c478bd9Sstevel@tonic-gate break; 9187c478bd9Sstevel@tonic-gate err = kbtrans_setkey(&upper->kbtrans_lower, 9197c478bd9Sstevel@tonic-gate (struct kiockey *)mp->b_cont->b_rptr, iocp->ioc_cr); 9207c478bd9Sstevel@tonic-gate /* 9217c478bd9Sstevel@tonic-gate * Since this only affects any subsequent key presses, 9227c478bd9Sstevel@tonic-gate * don't flush soft state. One might want to 9237c478bd9Sstevel@tonic-gate * toggle the keytable entries dynamically. 9247c478bd9Sstevel@tonic-gate */ 9257c478bd9Sstevel@tonic-gate break; 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate case KIOCGETKEY: 9287c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGETKEY %d\n", 929aecfc01dSrui zang - Sun Microsystems - Beijing China kiocgetkey++)); 9307c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (struct kiockey)); 9317c478bd9Sstevel@tonic-gate if (err != 0) 9327c478bd9Sstevel@tonic-gate break; 9337c478bd9Sstevel@tonic-gate err = kbtrans_getkey(&upper->kbtrans_lower, 9347c478bd9Sstevel@tonic-gate (struct kiockey *)mp->b_cont->b_rptr); 9357c478bd9Sstevel@tonic-gate break; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate case KIOCSKEY: 9387c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (struct kiockeymap)); 9397c478bd9Sstevel@tonic-gate if (err != 0) 9407c478bd9Sstevel@tonic-gate break; 9417c478bd9Sstevel@tonic-gate err = kbtrans_skey(&upper->kbtrans_lower, 9427c478bd9Sstevel@tonic-gate (struct kiockeymap *)mp->b_cont->b_rptr, iocp->ioc_cr); 9437c478bd9Sstevel@tonic-gate /* 9447c478bd9Sstevel@tonic-gate * Since this only affects any subsequent key presses, 9457c478bd9Sstevel@tonic-gate * don't flush soft state. One might want to 9467c478bd9Sstevel@tonic-gate * toggle the keytable entries dynamically. 9477c478bd9Sstevel@tonic-gate */ 9487c478bd9Sstevel@tonic-gate break; 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate case KIOCGKEY: 9517c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (struct kiockeymap)); 9527c478bd9Sstevel@tonic-gate if (err != 0) 9537c478bd9Sstevel@tonic-gate break; 9547c478bd9Sstevel@tonic-gate err = kbtrans_gkey(&upper->kbtrans_lower, 9557c478bd9Sstevel@tonic-gate (struct kiockeymap *)mp->b_cont->b_rptr); 9567c478bd9Sstevel@tonic-gate break; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate case KIOCSDIRECT: 9597c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSDIRECT\n")); 9607c478bd9Sstevel@tonic-gate kbtrans_flush(upper); 9617c478bd9Sstevel@tonic-gate break; 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate case KIOCGDIRECT: 9647c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSGDIRECT\n")); 9657c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 9667c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 9677c478bd9Sstevel@tonic-gate goto allocfailure; 9687c478bd9Sstevel@tonic-gate } 9697c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = 1; /* always direct */ 9707c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 9717c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 9727c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 9737c478bd9Sstevel@tonic-gate mp->b_cont = datap; 9747c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 9757c478bd9Sstevel@tonic-gate break; 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate case KIOCTYPE: 9787c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCTYPE\n")); 9797c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 9807c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 9817c478bd9Sstevel@tonic-gate goto allocfailure; 9827c478bd9Sstevel@tonic-gate } 9837c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = upper->kbtrans_streams_id; 9847c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 9857c478bd9Sstevel@tonic-gate if (mp->b_cont) /* free msg to prevent memory leak */ 9867c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 9877c478bd9Sstevel@tonic-gate mp->b_cont = datap; 9887c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 9897c478bd9Sstevel@tonic-gate break; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate case CONSSETABORTENABLE: 9927c478bd9Sstevel@tonic-gate /* 9937c478bd9Sstevel@tonic-gate * Peek as it goes by; must be a TRANSPARENT ioctl. 9947c478bd9Sstevel@tonic-gate */ 9957c478bd9Sstevel@tonic-gate if (iocp->ioc_count != TRANSPARENT) { 9967c478bd9Sstevel@tonic-gate err = EINVAL; 9977c478bd9Sstevel@tonic-gate break; 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate upper->kbtrans_streams_abortable = 10017c478bd9Sstevel@tonic-gate (boolean_t)*(intptr_t *)mp->b_cont->b_rptr; 10027c478bd9Sstevel@tonic-gate 10037c478bd9Sstevel@tonic-gate /* 10047c478bd9Sstevel@tonic-gate * Let the hardware module see it too. 10057c478bd9Sstevel@tonic-gate */ 10067c478bd9Sstevel@tonic-gate return (KBTRANS_MESSAGE_NOT_HANDLED); 10077c478bd9Sstevel@tonic-gate 1008c0423dd8SToomas Soome case KIOCGRPTCOUNT: 1009c0423dd8SToomas Soome /* 1010c0423dd8SToomas Soome * Report the autorepeat count 1011c0423dd8SToomas Soome */ 1012c0423dd8SToomas Soome DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTCOUNT\n")); 1013c0423dd8SToomas Soome if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 1014c0423dd8SToomas Soome ioctlrespsize = sizeof (int); 1015c0423dd8SToomas Soome goto allocfailure; 1016c0423dd8SToomas Soome } 1017c0423dd8SToomas Soome *(int *)datap->b_wptr = kbtrans_repeat_count; 1018c0423dd8SToomas Soome datap->b_wptr += sizeof (int); 1019c0423dd8SToomas Soome 1020c0423dd8SToomas Soome /* free msg to prevent memory leak */ 1021c0423dd8SToomas Soome if (mp->b_cont != NULL) 1022c0423dd8SToomas Soome freemsg(mp->b_cont); 1023c0423dd8SToomas Soome mp->b_cont = datap; 1024c0423dd8SToomas Soome iocp->ioc_count = sizeof (int); 1025c0423dd8SToomas Soome break; 1026c0423dd8SToomas Soome 1027c0423dd8SToomas Soome case KIOCSRPTCOUNT: 1028c0423dd8SToomas Soome /* 1029c0423dd8SToomas Soome * Set the autorepeat count 1030c0423dd8SToomas Soome */ 1031c0423dd8SToomas Soome DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTCOUNT\n")); 1032c0423dd8SToomas Soome err = miocpullup(mp, sizeof (int)); 1033c0423dd8SToomas Soome 1034c0423dd8SToomas Soome if (err != 0) 1035c0423dd8SToomas Soome break; 1036c0423dd8SToomas Soome 1037c0423dd8SToomas Soome /* validate the input */ 1038c0423dd8SToomas Soome if (*(int *)mp->b_cont->b_rptr < -1) { 1039c0423dd8SToomas Soome err = EINVAL; 1040c0423dd8SToomas Soome break; 1041c0423dd8SToomas Soome } 1042c0423dd8SToomas Soome kbtrans_repeat_count = (*(int *)mp->b_cont->b_rptr); 1043c0423dd8SToomas Soome break; 1044c0423dd8SToomas Soome 10457c478bd9Sstevel@tonic-gate case KIOCGRPTDELAY: 10467c478bd9Sstevel@tonic-gate /* 10477c478bd9Sstevel@tonic-gate * Report the autorepeat delay, unit in millisecond 10487c478bd9Sstevel@tonic-gate */ 10497c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTDELAY\n")); 10507c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 10517c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 10527c478bd9Sstevel@tonic-gate goto allocfailure; 10537c478bd9Sstevel@tonic-gate } 10547c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_delay); 10557c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate /* free msg to prevent memory leak */ 10587c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) 10597c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 10607c478bd9Sstevel@tonic-gate mp->b_cont = datap; 10617c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 10627c478bd9Sstevel@tonic-gate break; 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate case KIOCSRPTDELAY: 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * Set the autorepeat delay 10677c478bd9Sstevel@tonic-gate */ 10687c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTDELAY\n")); 10697c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate if (err != 0) 10727c478bd9Sstevel@tonic-gate break; 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate /* validate the input */ 10757c478bd9Sstevel@tonic-gate if (*(int *)mp->b_cont->b_rptr < KIOCRPTDELAY_MIN) { 10767c478bd9Sstevel@tonic-gate err = EINVAL; 10777c478bd9Sstevel@tonic-gate break; 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate kbtrans_repeat_delay = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr); 10807c478bd9Sstevel@tonic-gate if (kbtrans_repeat_delay <= 0) 10817c478bd9Sstevel@tonic-gate kbtrans_repeat_delay = 1; 10827c478bd9Sstevel@tonic-gate break; 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate case KIOCGRPTRATE: 10857c478bd9Sstevel@tonic-gate /* 10867c478bd9Sstevel@tonic-gate * Report the autorepeat rate 10877c478bd9Sstevel@tonic-gate */ 10887c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCGRPTRATE\n")); 10897c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 10907c478bd9Sstevel@tonic-gate ioctlrespsize = sizeof (int); 10917c478bd9Sstevel@tonic-gate goto allocfailure; 10927c478bd9Sstevel@tonic-gate } 10937c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = TICK_TO_MSEC(kbtrans_repeat_rate); 10947c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 10957c478bd9Sstevel@tonic-gate 10967c478bd9Sstevel@tonic-gate /* free msg to prevent memory leak */ 10977c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) 10987c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 10997c478bd9Sstevel@tonic-gate mp->b_cont = datap; 11007c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 11017c478bd9Sstevel@tonic-gate break; 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate case KIOCSRPTRATE: 11047c478bd9Sstevel@tonic-gate /* 11057c478bd9Sstevel@tonic-gate * Set the autorepeat rate 11067c478bd9Sstevel@tonic-gate */ 11077c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "KIOCSRPTRATE\n")); 11087c478bd9Sstevel@tonic-gate err = miocpullup(mp, sizeof (int)); 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate if (err != 0) 11117c478bd9Sstevel@tonic-gate break; 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate /* validate the input */ 11147c478bd9Sstevel@tonic-gate if (*(int *)mp->b_cont->b_rptr < KIOCRPTRATE_MIN) { 11157c478bd9Sstevel@tonic-gate err = EINVAL; 11167c478bd9Sstevel@tonic-gate break; 11177c478bd9Sstevel@tonic-gate } 11187c478bd9Sstevel@tonic-gate kbtrans_repeat_rate = MSEC_TO_TICK(*(int *)mp->b_cont->b_rptr); 11197c478bd9Sstevel@tonic-gate if (kbtrans_repeat_rate <= 0) 11207c478bd9Sstevel@tonic-gate kbtrans_repeat_rate = 1; 11217c478bd9Sstevel@tonic-gate break; 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate default: 11247c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (upper, "unknown\n")); 11257c478bd9Sstevel@tonic-gate return (KBTRANS_MESSAGE_NOT_HANDLED); 11267c478bd9Sstevel@tonic-gate } /* end switch */ 11277c478bd9Sstevel@tonic-gate 11287c478bd9Sstevel@tonic-gate if (err != 0) { 11297c478bd9Sstevel@tonic-gate iocp->ioc_rval = 0; 11307c478bd9Sstevel@tonic-gate iocp->ioc_error = err; 11317c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCNAK; 11327c478bd9Sstevel@tonic-gate } else { 11337c478bd9Sstevel@tonic-gate iocp->ioc_rval = 0; 11347c478bd9Sstevel@tonic-gate iocp->ioc_error = 0; /* brain rot */ 11357c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK; 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate putnext(upper->kbtrans_streams_readq, mp); 11387c478bd9Sstevel@tonic-gate 11397c478bd9Sstevel@tonic-gate return (KBTRANS_MESSAGE_HANDLED); 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate allocfailure: 11427c478bd9Sstevel@tonic-gate /* 11437c478bd9Sstevel@tonic-gate * We needed to allocate something to handle this "ioctl", but 11447c478bd9Sstevel@tonic-gate * couldn't; save this "ioctl" and arrange to get called back when 11457c478bd9Sstevel@tonic-gate * it's more likely that we can get what we need. 11467c478bd9Sstevel@tonic-gate * If there's already one being saved, throw it out, since it 11477c478bd9Sstevel@tonic-gate * must have timed out. 11487c478bd9Sstevel@tonic-gate */ 11497c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_iocpending != NULL) 11507c478bd9Sstevel@tonic-gate freemsg(upper->kbtrans_streams_iocpending); 11517c478bd9Sstevel@tonic-gate upper->kbtrans_streams_iocpending = mp; 11527c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_bufcallid) { 11537c478bd9Sstevel@tonic-gate qunbufcall(upper->kbtrans_streams_readq, 1154aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_bufcallid); 11557c478bd9Sstevel@tonic-gate } 11567c478bd9Sstevel@tonic-gate upper->kbtrans_streams_bufcallid = 1157aecfc01dSrui zang - Sun Microsystems - Beijing China qbufcall(upper->kbtrans_streams_readq, ioctlrespsize, BPRI_HI, 1158aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_reioctl, upper); 11597c478bd9Sstevel@tonic-gate /* 11607c478bd9Sstevel@tonic-gate * This is a white lie... we *will* handle it, eventually. 11617c478bd9Sstevel@tonic-gate */ 11627c478bd9Sstevel@tonic-gate return (KBTRANS_MESSAGE_HANDLED); 11637c478bd9Sstevel@tonic-gate } 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate * kbtrans_flush: 11677c478bd9Sstevel@tonic-gate * Flush data upstream 11687c478bd9Sstevel@tonic-gate */ 11697c478bd9Sstevel@tonic-gate static void 11707c478bd9Sstevel@tonic-gate kbtrans_flush(register struct kbtrans *upper) 11717c478bd9Sstevel@tonic-gate { 11727c478bd9Sstevel@tonic-gate register queue_t *q; 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate /* Flush pending data already sent upstream */ 11757c478bd9Sstevel@tonic-gate if ((q = upper->kbtrans_streams_readq) != NULL && q->q_next != NULL) 11767c478bd9Sstevel@tonic-gate (void) putnextctl1(q, M_FLUSH, FLUSHR); 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate /* Flush pending ups */ 11797c478bd9Sstevel@tonic-gate bzero(upper->kbtrans_streams_downs, upper->kbtrans_streams_downs_bytes); 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate kbtrans_cancelrpt(upper); 11827c478bd9Sstevel@tonic-gate } 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate /* 11857c478bd9Sstevel@tonic-gate * kbtrans_setled: 11867c478bd9Sstevel@tonic-gate * Update the keyboard LEDs to match the current keyboard state. 11877c478bd9Sstevel@tonic-gate */ 11887c478bd9Sstevel@tonic-gate static void 11897c478bd9Sstevel@tonic-gate kbtrans_setled(struct kbtrans *upper) 11907c478bd9Sstevel@tonic-gate { 11917c478bd9Sstevel@tonic-gate upper->kbtrans_streams_hw_callbacks->kbtrans_streams_setled( 1192aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_hw, 1193aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_lower.kbtrans_led_state); 11947c478bd9Sstevel@tonic-gate } 11957c478bd9Sstevel@tonic-gate 11967c478bd9Sstevel@tonic-gate /* 11977c478bd9Sstevel@tonic-gate * kbtrans_rpt: 11987c478bd9Sstevel@tonic-gate * If a key is held down, this function is set up to be called 11995d420dfbSToomas Soome * after kbtrans_repeat_rate time elapses. 12007c478bd9Sstevel@tonic-gate */ 12017c478bd9Sstevel@tonic-gate static void 12027c478bd9Sstevel@tonic-gate kbtrans_rpt(void *arg) 12037c478bd9Sstevel@tonic-gate { 12047c478bd9Sstevel@tonic-gate struct kbtrans *upper = arg; 12057c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, 1208aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans_rpt: repeat key %X\n", 1209aecfc01dSrui zang - Sun Microsystems - Beijing China lower->kbtrans_repeatkey)); 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = 0; 12125d420dfbSToomas Soome upper->kbtrans_streams_count++; 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * NB: polled code zaps kbtrans_repeatkey without cancelling 12167c478bd9Sstevel@tonic-gate * timeout. 12177c478bd9Sstevel@tonic-gate */ 12185d420dfbSToomas Soome if (kbtrans_repeat_count > 0) { 12195d420dfbSToomas Soome /* If limit is set and reached, stop there. */ 12205d420dfbSToomas Soome if (upper->kbtrans_streams_count > kbtrans_repeat_count) 12215d420dfbSToomas Soome lower->kbtrans_repeatkey = 0; 12225d420dfbSToomas Soome } 12235d420dfbSToomas Soome 12247c478bd9Sstevel@tonic-gate if (lower->kbtrans_repeatkey != 0) { 12257c478bd9Sstevel@tonic-gate kbtrans_keyreleased(upper, lower->kbtrans_repeatkey); 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate kbtrans_processkey(lower, 1228aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_callback, 1229aecfc01dSrui zang - Sun Microsystems - Beijing China lower->kbtrans_repeatkey, 1230aecfc01dSrui zang - Sun Microsystems - Beijing China KEY_PRESSED); 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = 1233aecfc01dSrui zang - Sun Microsystems - Beijing China qtimeout(upper->kbtrans_streams_readq, kbtrans_rpt, 1234aecfc01dSrui zang - Sun Microsystems - Beijing China (caddr_t)upper, kbtrans_repeat_rate); 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate /* 12397c478bd9Sstevel@tonic-gate * kbtrans_cancelrpt: 12405d420dfbSToomas Soome * Cancel the repeating key 12417c478bd9Sstevel@tonic-gate */ 12427c478bd9Sstevel@tonic-gate static void 12437c478bd9Sstevel@tonic-gate kbtrans_cancelrpt(struct kbtrans *upper) 12447c478bd9Sstevel@tonic-gate { 12457c478bd9Sstevel@tonic-gate upper->kbtrans_lower.kbtrans_repeatkey = 0; 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_rptid != 0) { 12487c478bd9Sstevel@tonic-gate (void) quntimeout(upper->kbtrans_streams_readq, 1249aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_streams_rptid); 12507c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = 0; 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate } 12537c478bd9Sstevel@tonic-gate 12547c478bd9Sstevel@tonic-gate /* 12557c478bd9Sstevel@tonic-gate * kbtrans_send_esc_event: 12567c478bd9Sstevel@tonic-gate * Send character up stream. Used for the case of 12577c478bd9Sstevel@tonic-gate * sending strings upstream. 12587c478bd9Sstevel@tonic-gate */ 12597c478bd9Sstevel@tonic-gate static void 12607c478bd9Sstevel@tonic-gate kbtrans_send_esc_event(char c, register struct kbtrans *upper) 12617c478bd9Sstevel@tonic-gate { 12627c478bd9Sstevel@tonic-gate Firm_event fe; 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate fe.id = c; 12657c478bd9Sstevel@tonic-gate fe.value = 1; 12667c478bd9Sstevel@tonic-gate fe.pair_type = FE_PAIR_NONE; 12677c478bd9Sstevel@tonic-gate fe.pair = 0; 12687c478bd9Sstevel@tonic-gate /* 12697c478bd9Sstevel@tonic-gate * Pretend as if each cp pushed and released 12707c478bd9Sstevel@tonic-gate * Calling kbtrans_queueevent avoids addr translation 12717c478bd9Sstevel@tonic-gate * and pair base determination of kbtrans_keypressed. 12727c478bd9Sstevel@tonic-gate */ 12737c478bd9Sstevel@tonic-gate kbtrans_queueevent(upper, &fe); 12747c478bd9Sstevel@tonic-gate fe.value = 0; 12757c478bd9Sstevel@tonic-gate kbtrans_queueevent(upper, &fe); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * kbtrans_strsetwithdecimal: 12807c478bd9Sstevel@tonic-gate * Used for expanding a function key to the ascii equivalent 12817c478bd9Sstevel@tonic-gate */ 12827c478bd9Sstevel@tonic-gate static char * 12837c478bd9Sstevel@tonic-gate kbtrans_strsetwithdecimal(char *buf, uint_t val, uint_t maxdigs) 12847c478bd9Sstevel@tonic-gate { 12857c478bd9Sstevel@tonic-gate int hradix = 5; 12867c478bd9Sstevel@tonic-gate char *bp; 12877c478bd9Sstevel@tonic-gate int lowbit; 12887c478bd9Sstevel@tonic-gate char *tab = "0123456789abcdef"; 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate bp = buf + maxdigs; 12917c478bd9Sstevel@tonic-gate *(--bp) = '\0'; 12927c478bd9Sstevel@tonic-gate while (val) { 12937c478bd9Sstevel@tonic-gate lowbit = val & 1; 12947c478bd9Sstevel@tonic-gate val = (val >> 1); 12957c478bd9Sstevel@tonic-gate *(--bp) = tab[val % hradix * 2 + lowbit]; 12967c478bd9Sstevel@tonic-gate val /= hradix; 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate return (bp); 12997c478bd9Sstevel@tonic-gate } 13007c478bd9Sstevel@tonic-gate 13017c478bd9Sstevel@tonic-gate /* 13027c478bd9Sstevel@tonic-gate * kbtrans_keypressed: 13037c478bd9Sstevel@tonic-gate * Modify Firm event to be sent up the stream 13047c478bd9Sstevel@tonic-gate */ 13057c478bd9Sstevel@tonic-gate static void 13067c478bd9Sstevel@tonic-gate kbtrans_keypressed(struct kbtrans *upper, uchar_t key_station, 1307adc2b73dSToomas Soome Firm_event *fe, ushort_t base) 13087c478bd9Sstevel@tonic-gate { 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate register short id_addr; 13117c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate /* Set pair values */ 13147c478bd9Sstevel@tonic-gate if (fe->id < (ushort_t)VKEY_FIRST) { 13157c478bd9Sstevel@tonic-gate /* 13167c478bd9Sstevel@tonic-gate * If CTRLed, find the ID that would have been used had it 13177c478bd9Sstevel@tonic-gate * not been CTRLed. 13187c478bd9Sstevel@tonic-gate */ 13197c478bd9Sstevel@tonic-gate if (lower->kbtrans_shiftmask & (CTRLMASK | CTLSMASK)) { 1320adc2b73dSToomas Soome keymap_entry_t *ke; 13217c478bd9Sstevel@tonic-gate unsigned int mask; 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate mask = lower->kbtrans_shiftmask & 1324aecfc01dSrui zang - Sun Microsystems - Beijing China ~(CTRLMASK | CTLSMASK | UPMASK); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate ke = kbtrans_find_entry(lower, mask, key_station); 13277c478bd9Sstevel@tonic-gate if (ke == NULL) 13287c478bd9Sstevel@tonic-gate return; 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate base = *ke; 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate if (base != fe->id) { 13337c478bd9Sstevel@tonic-gate fe->pair_type = FE_PAIR_SET; 13347c478bd9Sstevel@tonic-gate fe->pair = (uchar_t)base; 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate goto send; 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate } 13397c478bd9Sstevel@tonic-gate fe->pair_type = FE_PAIR_NONE; 13407c478bd9Sstevel@tonic-gate fe->pair = 0; 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate send: 13437c478bd9Sstevel@tonic-gate /* Adjust event id address for multiple keyboard/workstation support */ 13447c478bd9Sstevel@tonic-gate switch (vuid_id_addr(fe->id)) { 13457c478bd9Sstevel@tonic-gate case ASCII_FIRST: 13467c478bd9Sstevel@tonic-gate id_addr = upper->kbtrans_streams_vuid_addr.ascii; 13477c478bd9Sstevel@tonic-gate break; 13487c478bd9Sstevel@tonic-gate case TOP_FIRST: 13497c478bd9Sstevel@tonic-gate id_addr = upper->kbtrans_streams_vuid_addr.top; 13507c478bd9Sstevel@tonic-gate break; 13517c478bd9Sstevel@tonic-gate case VKEY_FIRST: 13527c478bd9Sstevel@tonic-gate id_addr = upper->kbtrans_streams_vuid_addr.vkey; 13537c478bd9Sstevel@tonic-gate break; 13547c478bd9Sstevel@tonic-gate default: 13557c478bd9Sstevel@tonic-gate id_addr = vuid_id_addr(fe->id); 13567c478bd9Sstevel@tonic-gate break; 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate fe->id = vuid_id_offset(fe->id) | id_addr; 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate kbtrans_queuepress(upper, key_station, fe); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate /* 13647c478bd9Sstevel@tonic-gate * kbtrans_queuepress: 13657c478bd9Sstevel@tonic-gate * Add keypress to the "downs" table 13667c478bd9Sstevel@tonic-gate */ 13677c478bd9Sstevel@tonic-gate static void 13687c478bd9Sstevel@tonic-gate kbtrans_queuepress(struct kbtrans *upper, 1369adc2b73dSToomas Soome uchar_t key_station, Firm_event *fe) 13707c478bd9Sstevel@tonic-gate { 13717c478bd9Sstevel@tonic-gate register struct key_event *ke, *ke_free; 13727c478bd9Sstevel@tonic-gate register int i; 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "kbtrans_queuepress:" 1375aecfc01dSrui zang - Sun Microsystems - Beijing China " key=%d", key_station)); 13767c478bd9Sstevel@tonic-gate 13777c478bd9Sstevel@tonic-gate ke_free = 0; 13787c478bd9Sstevel@tonic-gate 13797c478bd9Sstevel@tonic-gate /* Scan table of down key stations */ 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate for (i = 0, ke = upper->kbtrans_streams_downs; 13827c478bd9Sstevel@tonic-gate i < upper->kbtrans_streams_num_downs_entries; i++, ke++) { 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate /* Keycode already down? */ 13857c478bd9Sstevel@tonic-gate if (ke->key_station == key_station) { 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, 1388aecfc01dSrui zang - Sun Microsystems - Beijing China (NULL, "kbtrans: Double " 1389aecfc01dSrui zang - Sun Microsystems - Beijing China "entry in downs table (%d,%d)!\n", 1390aecfc01dSrui zang - Sun Microsystems - Beijing China key_station, i)); 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate goto add_event; 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate if (ke->key_station == 0) 13967c478bd9Sstevel@tonic-gate ke_free = ke; 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate if (ke_free) { 14007c478bd9Sstevel@tonic-gate ke = ke_free; 14017c478bd9Sstevel@tonic-gate goto add_event; 14027c478bd9Sstevel@tonic-gate } 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate ke = upper->kbtrans_streams_downs; 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate add_event: 14077c478bd9Sstevel@tonic-gate ke->key_station = key_station; 14087c478bd9Sstevel@tonic-gate ke->event = *fe; 14097c478bd9Sstevel@tonic-gate kbtrans_queueevent(upper, fe); 14107c478bd9Sstevel@tonic-gate } 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate /* 14137c478bd9Sstevel@tonic-gate * kbtrans_keyreleased: 14145d420dfbSToomas Soome * Remove entry from the downs table 14157c478bd9Sstevel@tonic-gate */ 14167c478bd9Sstevel@tonic-gate static void 14177c478bd9Sstevel@tonic-gate kbtrans_keyreleased(register struct kbtrans *upper, uchar_t key_station) 14187c478bd9Sstevel@tonic-gate { 14197c478bd9Sstevel@tonic-gate register struct key_event *ke; 14207c478bd9Sstevel@tonic-gate register int i; 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L0, PRINT_MASK_ALL, (NULL, "RELEASE key=%d\n", 1423aecfc01dSrui zang - Sun Microsystems - Beijing China key_station)); 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate if (upper->kbtrans_streams_translate_mode != TR_EVENT && 14267c478bd9Sstevel@tonic-gate upper->kbtrans_streams_translate_mode != TR_UNTRANS_EVENT) { 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate return; 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate /* Scan table of down key stations */ 14327c478bd9Sstevel@tonic-gate for (i = 0, ke = upper->kbtrans_streams_downs; 14337c478bd9Sstevel@tonic-gate i < upper->kbtrans_streams_num_downs_entries; 14347c478bd9Sstevel@tonic-gate i++, ke++) { 14357c478bd9Sstevel@tonic-gate /* Found? */ 14367c478bd9Sstevel@tonic-gate if (ke->key_station == key_station) { 14377c478bd9Sstevel@tonic-gate ke->key_station = 0; 14387c478bd9Sstevel@tonic-gate ke->event.value = 0; 14397c478bd9Sstevel@tonic-gate kbtrans_queueevent(upper, &ke->event); 14407c478bd9Sstevel@tonic-gate } 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * Ignore if couldn't find because may be called twice 14457c478bd9Sstevel@tonic-gate * for the same key station in the case of the kbtrans_rpt 14467c478bd9Sstevel@tonic-gate * routine being called unnecessarily. 14477c478bd9Sstevel@tonic-gate */ 14487c478bd9Sstevel@tonic-gate } 14497c478bd9Sstevel@tonic-gate 14507c478bd9Sstevel@tonic-gate 14517c478bd9Sstevel@tonic-gate /* 14527c478bd9Sstevel@tonic-gate * kbtrans_putcode: 14537c478bd9Sstevel@tonic-gate * Pass a keycode up the stream, if you can, otherwise throw it away. 14547c478bd9Sstevel@tonic-gate */ 14557c478bd9Sstevel@tonic-gate static void 14567c478bd9Sstevel@tonic-gate kbtrans_putcode(register struct kbtrans *upper, uint_t code) 14577c478bd9Sstevel@tonic-gate { 14587c478bd9Sstevel@tonic-gate register mblk_t *bp; 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate /* 14617c478bd9Sstevel@tonic-gate * If we can't send it up, then we just drop it. 14627c478bd9Sstevel@tonic-gate */ 14637c478bd9Sstevel@tonic-gate if (!canputnext(upper->kbtrans_streams_readq)) { 14647c478bd9Sstevel@tonic-gate 14657c478bd9Sstevel@tonic-gate return; 14667c478bd9Sstevel@tonic-gate } 14677c478bd9Sstevel@tonic-gate 14687c478bd9Sstevel@tonic-gate /* 14697c478bd9Sstevel@tonic-gate * Allocate a messsage block to send up. 14707c478bd9Sstevel@tonic-gate */ 14717c478bd9Sstevel@tonic-gate if ((bp = allocb(sizeof (uint_t), BPRI_HI)) == NULL) { 14727c478bd9Sstevel@tonic-gate 14737c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kbtrans_putcode: Can't allocate block\ 14747c478bd9Sstevel@tonic-gate for keycode."); 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate return; 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate /* 14807c478bd9Sstevel@tonic-gate * We will strip out any high order information here. 1481adc2b73dSToomas Soome * Convert to UTF-8. 14827c478bd9Sstevel@tonic-gate */ 1483adc2b73dSToomas Soome code = KEYCHAR(code); 1484adc2b73dSToomas Soome if (code < 0x80) { 1485adc2b73dSToomas Soome *bp->b_wptr++ = (char)code; 1486adc2b73dSToomas Soome } else if (code < 0x800) { 1487adc2b73dSToomas Soome *bp->b_wptr++ = 0xc0 | (code >> 6); 1488adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | (code & 0x3f); 1489adc2b73dSToomas Soome } else if (code < 0x10000) { 1490adc2b73dSToomas Soome *bp->b_wptr++ = 0xe0 | (code >> 12); 1491adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | ((code >> 6) & 0x3f); 1492adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | (code & 0x3f); 1493adc2b73dSToomas Soome } else { 1494adc2b73dSToomas Soome *bp->b_wptr++ = 0xf0 | (code >> 18); 1495adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | ((code >> 12) & 0x3f); 1496adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | ((code >> 6) & 0x3f); 1497adc2b73dSToomas Soome *bp->b_wptr++ = 0x80 | (code & 0x3f); 1498adc2b73dSToomas Soome } 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate /* 15017c478bd9Sstevel@tonic-gate * Send the message up. 15027c478bd9Sstevel@tonic-gate */ 15037c478bd9Sstevel@tonic-gate (void) putnext(upper->kbtrans_streams_readq, bp); 15047c478bd9Sstevel@tonic-gate } 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate /* 15087c478bd9Sstevel@tonic-gate * kbtrans_putbuf: 15097c478bd9Sstevel@tonic-gate * Pass generated keycode sequence to upstream, if possible. 15107c478bd9Sstevel@tonic-gate */ 15117c478bd9Sstevel@tonic-gate static void 15127c478bd9Sstevel@tonic-gate kbtrans_putbuf(char *buf, queue_t *q) 15137c478bd9Sstevel@tonic-gate { 15147c478bd9Sstevel@tonic-gate register mblk_t *bp; 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate if (!canputnext(q)) { 15177c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kbtrans_putbuf: Can't put block for keycode"); 15187c478bd9Sstevel@tonic-gate } else { 15197c478bd9Sstevel@tonic-gate if ((bp = allocb((int)strlen(buf), BPRI_HI)) == NULL) { 15207c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kbtrans_putbuf: " 15217c478bd9Sstevel@tonic-gate "Can't allocate block for keycode"); 15227c478bd9Sstevel@tonic-gate } else { 15237c478bd9Sstevel@tonic-gate while (*buf) { 15247c478bd9Sstevel@tonic-gate *bp->b_wptr++ = *buf; 15257c478bd9Sstevel@tonic-gate buf++; 15267c478bd9Sstevel@tonic-gate } 15277c478bd9Sstevel@tonic-gate putnext(q, bp); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate } 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate /* 15337c478bd9Sstevel@tonic-gate * kbtrans_queueevent: 15347c478bd9Sstevel@tonic-gate * Pass a VUID "firm event" up the stream, if you can. 15357c478bd9Sstevel@tonic-gate */ 15367c478bd9Sstevel@tonic-gate static void 15377c478bd9Sstevel@tonic-gate kbtrans_queueevent(struct kbtrans *upper, Firm_event *fe) 15387c478bd9Sstevel@tonic-gate { 15397c478bd9Sstevel@tonic-gate register queue_t *q; 15407c478bd9Sstevel@tonic-gate register mblk_t *bp; 15417c478bd9Sstevel@tonic-gate 15427c478bd9Sstevel@tonic-gate if ((q = upper->kbtrans_streams_readq) == NULL) 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate return; 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate if (!canputnext(q)) { 15477c478bd9Sstevel@tonic-gate if (kbtrans_overflow_msg) { 15487c478bd9Sstevel@tonic-gate DPRINTF(PRINT_L2, PRINT_MASK_ALL, (NULL, 1549aecfc01dSrui zang - Sun Microsystems - Beijing China "kbtrans: Buffer flushed when overflowed.")); 15507c478bd9Sstevel@tonic-gate } 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate kbtrans_flush(upper); 15537c478bd9Sstevel@tonic-gate upper->kbtrans_overflow_cnt++; 15547c478bd9Sstevel@tonic-gate } else { 15557c478bd9Sstevel@tonic-gate if ((bp = allocb(sizeof (Firm_event), BPRI_HI)) == NULL) { 15567c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kbtrans_queueevent: Can't allocate \ 15577c478bd9Sstevel@tonic-gate block for event."); 15587c478bd9Sstevel@tonic-gate } else { 15597c478bd9Sstevel@tonic-gate uniqtime32(&fe->time); 1560aecfc01dSrui zang - Sun Microsystems - Beijing China *(Firm_event *)bp->b_wptr = *fe; 15617c478bd9Sstevel@tonic-gate bp->b_wptr += sizeof (Firm_event); 15627c478bd9Sstevel@tonic-gate (void) putnext(q, bp); 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate } 15667c478bd9Sstevel@tonic-gate } 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate 15697c478bd9Sstevel@tonic-gate /* 15707c478bd9Sstevel@tonic-gate * kbtrans_set_translation_callback: 15717c478bd9Sstevel@tonic-gate * This code sets the translation_callback pointer based on the 15725d420dfbSToomas Soome * translation mode. 15737c478bd9Sstevel@tonic-gate */ 15747c478bd9Sstevel@tonic-gate static void 15757c478bd9Sstevel@tonic-gate kbtrans_set_translation_callback(register struct kbtrans *upper) 15767c478bd9Sstevel@tonic-gate { 15777c478bd9Sstevel@tonic-gate switch (upper->kbtrans_streams_translate_mode) { 15787c478bd9Sstevel@tonic-gate 15797c478bd9Sstevel@tonic-gate default: 15807c478bd9Sstevel@tonic-gate case TR_ASCII: 1581aecfc01dSrui zang - Sun Microsystems - Beijing China upper->vt_switch_keystate = VT_SWITCH_KEY_NONE; 1582aecfc01dSrui zang - Sun Microsystems - Beijing China 1583aecfc01dSrui zang - Sun Microsystems - Beijing China /* Discard any obsolete CTRL/ALT/SHIFT keys */ 1584aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_lower.kbtrans_shiftmask &= 1585aecfc01dSrui zang - Sun Microsystems - Beijing China ~(CTRLMASK | ALTMASK | SHIFTMASK); 1586aecfc01dSrui zang - Sun Microsystems - Beijing China upper->kbtrans_lower.kbtrans_togglemask &= 1587aecfc01dSrui zang - Sun Microsystems - Beijing China ~(CTRLMASK | ALTMASK | SHIFTMASK); 1588aecfc01dSrui zang - Sun Microsystems - Beijing China 15897c478bd9Sstevel@tonic-gate upper->kbtrans_streams_callback = &ascii_callback; 15907c478bd9Sstevel@tonic-gate 15917c478bd9Sstevel@tonic-gate break; 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate case TR_EVENT: 15947c478bd9Sstevel@tonic-gate upper->kbtrans_streams_callback = &trans_event_callback; 15957c478bd9Sstevel@tonic-gate 15967c478bd9Sstevel@tonic-gate break; 15977c478bd9Sstevel@tonic-gate 15987c478bd9Sstevel@tonic-gate case TR_UNTRANS_EVENT: 15997c478bd9Sstevel@tonic-gate upper->kbtrans_streams_callback = &untrans_event_callback; 16007c478bd9Sstevel@tonic-gate 16017c478bd9Sstevel@tonic-gate break; 16027c478bd9Sstevel@tonic-gate } 16037c478bd9Sstevel@tonic-gate } 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate /* 16067c478bd9Sstevel@tonic-gate * kbtrans_untrans_keypressed_raw: 16077c478bd9Sstevel@tonic-gate * This is the callback we get if we are in TR_UNTRANS_EVENT and a 16085d420dfbSToomas Soome * key is pressed. This code will just send the scancode up the 16095d420dfbSToomas Soome * stream. 16107c478bd9Sstevel@tonic-gate */ 16117c478bd9Sstevel@tonic-gate static void 16127c478bd9Sstevel@tonic-gate kbtrans_untrans_keypressed_raw(struct kbtrans *upper, kbtrans_key_t key) 16137c478bd9Sstevel@tonic-gate { 16147c478bd9Sstevel@tonic-gate Firm_event fe; 16157c478bd9Sstevel@tonic-gate 16167c478bd9Sstevel@tonic-gate bzero(&fe, sizeof (fe)); 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate /* 16197c478bd9Sstevel@tonic-gate * fill in the event 16207c478bd9Sstevel@tonic-gate */ 16217c478bd9Sstevel@tonic-gate fe.id = (unsigned short)key; 16227c478bd9Sstevel@tonic-gate fe.value = 1; 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate /* 16257c478bd9Sstevel@tonic-gate * Send the event upstream. 16267c478bd9Sstevel@tonic-gate */ 16277c478bd9Sstevel@tonic-gate kbtrans_queuepress(upper, key, &fe); 16287c478bd9Sstevel@tonic-gate } 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate /* 16317c478bd9Sstevel@tonic-gate * kbtrans_untrans_keyreleased_raw: 16327c478bd9Sstevel@tonic-gate * This is the callback we get if we are in TR_UNTRANS_EVENT mode 16335d420dfbSToomas Soome * and a key is released. This code will just send the scancode up 16345d420dfbSToomas Soome * the stream. 16357c478bd9Sstevel@tonic-gate */ 16367c478bd9Sstevel@tonic-gate static void 16377c478bd9Sstevel@tonic-gate kbtrans_untrans_keyreleased_raw(struct kbtrans *upper, kbtrans_key_t key) 16387c478bd9Sstevel@tonic-gate { 16397c478bd9Sstevel@tonic-gate /* 16407c478bd9Sstevel@tonic-gate * Deal with a key released event. 16417c478bd9Sstevel@tonic-gate */ 16427c478bd9Sstevel@tonic-gate kbtrans_keyreleased(upper, key); 16437c478bd9Sstevel@tonic-gate } 16447c478bd9Sstevel@tonic-gate 1645aecfc01dSrui zang - Sun Microsystems - Beijing China /* 1646aecfc01dSrui zang - Sun Microsystems - Beijing China * kbtrans_vt_compose: 1647aecfc01dSrui zang - Sun Microsystems - Beijing China * To compose the key sequences for virtual terminal switching. 1648aecfc01dSrui zang - Sun Microsystems - Beijing China * 1649aecfc01dSrui zang - Sun Microsystems - Beijing China * 'ALTL + F#' for 1-12 terminals 1650aecfc01dSrui zang - Sun Microsystems - Beijing China * 'ALTGR + F#' for 13-24 terminals 1651aecfc01dSrui zang - Sun Microsystems - Beijing China * 'ALT + UPARROW' for last terminal 1652aecfc01dSrui zang - Sun Microsystems - Beijing China * 'ALT + LEFTARROW' for previous terminal 1653aecfc01dSrui zang - Sun Microsystems - Beijing China * 'ALT + RIGHTARROW' for next terminal 1654aecfc01dSrui zang - Sun Microsystems - Beijing China * 1655aecfc01dSrui zang - Sun Microsystems - Beijing China * the vt switching message is encoded as: 1656aecfc01dSrui zang - Sun Microsystems - Beijing China * 1657aecfc01dSrui zang - Sun Microsystems - Beijing China * ------------------------------------------------------------- 1658aecfc01dSrui zang - Sun Microsystems - Beijing China * | \033 | 'Q' | vtno + 'A' | opcode | 'z' | '\0' | 1659aecfc01dSrui zang - Sun Microsystems - Beijing China * ------------------------------------------------------------- 1660aecfc01dSrui zang - Sun Microsystems - Beijing China * 1661aecfc01dSrui zang - Sun Microsystems - Beijing China * opcode: 1662aecfc01dSrui zang - Sun Microsystems - Beijing China * 'B' to switch to previous terminal 1663aecfc01dSrui zang - Sun Microsystems - Beijing China * 'F' to switch to next terminal 1664aecfc01dSrui zang - Sun Microsystems - Beijing China * 'L' to switch to last terminal 1665aecfc01dSrui zang - Sun Microsystems - Beijing China * 'H' to switch to the terminal as specified by vtno, 1666aecfc01dSrui zang - Sun Microsystems - Beijing China * which is from 1 to 24. 1667aecfc01dSrui zang - Sun Microsystems - Beijing China * 1668aecfc01dSrui zang - Sun Microsystems - Beijing China * Here keyid is the keycode of UPARROW, LEFTARROW, or RIGHTARROW 1669aecfc01dSrui zang - Sun Microsystems - Beijing China * when it is a kind of arrow key as indicated by is_arrow_key, 1670aecfc01dSrui zang - Sun Microsystems - Beijing China * otherwise it indicates a function key and keyid is the number 1671aecfc01dSrui zang - Sun Microsystems - Beijing China * corresponding to that function key. 1672aecfc01dSrui zang - Sun Microsystems - Beijing China */ 1673aecfc01dSrui zang - Sun Microsystems - Beijing China static void 1674aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_vt_compose(struct kbtrans *upper, unsigned short keyid, 1675aecfc01dSrui zang - Sun Microsystems - Beijing China boolean_t is_arrow_key, char *buf) 1676aecfc01dSrui zang - Sun Microsystems - Beijing China { 1677aecfc01dSrui zang - Sun Microsystems - Beijing China char *bufp; 1678aecfc01dSrui zang - Sun Microsystems - Beijing China 1679aecfc01dSrui zang - Sun Microsystems - Beijing China bufp = buf; 1680aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = '\033'; /* Escape */ 1681aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'Q'; 1682aecfc01dSrui zang - Sun Microsystems - Beijing China if (is_arrow_key) { 1683aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'A'; 1684aecfc01dSrui zang - Sun Microsystems - Beijing China switch (keyid) { 1685aecfc01dSrui zang - Sun Microsystems - Beijing China case UPARROW: /* last vt */ 1686aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'L'; 1687aecfc01dSrui zang - Sun Microsystems - Beijing China break; 1688aecfc01dSrui zang - Sun Microsystems - Beijing China case LEFTARROW: /* previous vt */ 1689aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'B'; 1690aecfc01dSrui zang - Sun Microsystems - Beijing China break; 1691aecfc01dSrui zang - Sun Microsystems - Beijing China case RIGHTARROW: /* next vt */ 1692aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'F'; 1693aecfc01dSrui zang - Sun Microsystems - Beijing China break; 1694aecfc01dSrui zang - Sun Microsystems - Beijing China default: 1695aecfc01dSrui zang - Sun Microsystems - Beijing China break; 1696aecfc01dSrui zang - Sun Microsystems - Beijing China } 1697aecfc01dSrui zang - Sun Microsystems - Beijing China } else { 1698aecfc01dSrui zang - Sun Microsystems - Beijing China /* this is funckey specifying vtno for switch */ 1699aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = keyid + 1700aecfc01dSrui zang - Sun Microsystems - Beijing China (upper->vt_switch_keystate - VT_SWITCH_KEY_ALT) * 1701aecfc01dSrui zang - Sun Microsystems - Beijing China KB_NR_FUNCKEYS + 'A'; 1702aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'H'; 1703aecfc01dSrui zang - Sun Microsystems - Beijing China } 1704aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp++ = 'z'; 1705aecfc01dSrui zang - Sun Microsystems - Beijing China *bufp = '\0'; 1706aecfc01dSrui zang - Sun Microsystems - Beijing China 1707aecfc01dSrui zang - Sun Microsystems - Beijing China /* 1708aecfc01dSrui zang - Sun Microsystems - Beijing China * Send the result upstream. 1709aecfc01dSrui zang - Sun Microsystems - Beijing China */ 1710aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_putbuf(buf, upper->kbtrans_streams_readq); 1711aecfc01dSrui zang - Sun Microsystems - Beijing China 1712aecfc01dSrui zang - Sun Microsystems - Beijing China } 1713aecfc01dSrui zang - Sun Microsystems - Beijing China 17147c478bd9Sstevel@tonic-gate /* 17157c478bd9Sstevel@tonic-gate * kbtrans_ascii_keypressed: 17167c478bd9Sstevel@tonic-gate * This is the code if we are in TR_ASCII mode and a key 17175d420dfbSToomas Soome * is pressed. This is where we will do any special processing that 17185d420dfbSToomas Soome * is specific to ASCII key translation. 17197c478bd9Sstevel@tonic-gate */ 17207c478bd9Sstevel@tonic-gate /* ARGSUSED */ 17217c478bd9Sstevel@tonic-gate static void 17225d420dfbSToomas Soome kbtrans_ascii_keypressed(struct kbtrans *upper, uint_t entrytype, 17235d420dfbSToomas Soome kbtrans_key_t key, uint_t entry) 17247c478bd9Sstevel@tonic-gate { 17257c478bd9Sstevel@tonic-gate register char *cp; 17267c478bd9Sstevel@tonic-gate register char *bufp; 17277c478bd9Sstevel@tonic-gate char buf[14]; 1728aecfc01dSrui zang - Sun Microsystems - Beijing China unsigned short keyid; 17297c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate /* 17327c478bd9Sstevel@tonic-gate * Based on the type of key, we may need to do some ASCII 1733aecfc01dSrui zang - Sun Microsystems - Beijing China * specific post processing. Note that the translated entry 17345d420dfbSToomas Soome * is constructed as the actual keycode plus entrytype. See 1735aecfc01dSrui zang - Sun Microsystems - Beijing China * sys/kbd.h for details of each entrytype. 17367c478bd9Sstevel@tonic-gate */ 17377c478bd9Sstevel@tonic-gate switch (entrytype) { 17387c478bd9Sstevel@tonic-gate case BUCKYBITS: 1739aecfc01dSrui zang - Sun Microsystems - Beijing China return; 1740aecfc01dSrui zang - Sun Microsystems - Beijing China 17417c478bd9Sstevel@tonic-gate case SHIFTKEYS: 1742aecfc01dSrui zang - Sun Microsystems - Beijing China keyid = entry & 0xFF; 1743aecfc01dSrui zang - Sun Microsystems - Beijing China if (keyid == ALT) { 1744aecfc01dSrui zang - Sun Microsystems - Beijing China upper->vt_switch_keystate = VT_SWITCH_KEY_ALT; 1745aecfc01dSrui zang - Sun Microsystems - Beijing China } else if (keyid == ALTGRAPH) { 1746aecfc01dSrui zang - Sun Microsystems - Beijing China upper->vt_switch_keystate = VT_SWITCH_KEY_ALTGR; 1747aecfc01dSrui zang - Sun Microsystems - Beijing China } 1748aecfc01dSrui zang - Sun Microsystems - Beijing China return; 1749aecfc01dSrui zang - Sun Microsystems - Beijing China 17507c478bd9Sstevel@tonic-gate case FUNNY: 17517c478bd9Sstevel@tonic-gate /* 17527c478bd9Sstevel@tonic-gate * There is no ascii equivalent. We will ignore these 17537c478bd9Sstevel@tonic-gate * keys 17547c478bd9Sstevel@tonic-gate */ 17557c478bd9Sstevel@tonic-gate return; 17567c478bd9Sstevel@tonic-gate 17577c478bd9Sstevel@tonic-gate case FUNCKEYS: 1758aecfc01dSrui zang - Sun Microsystems - Beijing China if (upper->vt_switch_keystate > VT_SWITCH_KEY_NONE) { 1759aecfc01dSrui zang - Sun Microsystems - Beijing China if (entry >= TOPFUNC && 1760aecfc01dSrui zang - Sun Microsystems - Beijing China entry < (TOPFUNC + KB_NR_FUNCKEYS)) { 1761aecfc01dSrui zang - Sun Microsystems - Beijing China 1762aecfc01dSrui zang - Sun Microsystems - Beijing China /* 1763aecfc01dSrui zang - Sun Microsystems - Beijing China * keyid is the number correspoding to F# 1764aecfc01dSrui zang - Sun Microsystems - Beijing China * and its value is from 1 to 12. 1765aecfc01dSrui zang - Sun Microsystems - Beijing China */ 1766aecfc01dSrui zang - Sun Microsystems - Beijing China keyid = (entry & 0xF) + 1; 1767aecfc01dSrui zang - Sun Microsystems - Beijing China 1768aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_vt_compose(upper, keyid, B_FALSE, buf); 1769aecfc01dSrui zang - Sun Microsystems - Beijing China return; 1770aecfc01dSrui zang - Sun Microsystems - Beijing China } 1771aecfc01dSrui zang - Sun Microsystems - Beijing China } 1772aecfc01dSrui zang - Sun Microsystems - Beijing China 1773*7d724debSJoshua M. Clulow if (kbtrans_ignore_scroll_lock && entry == RF(3)) { 1774*7d724debSJoshua M. Clulow /* 1775*7d724debSJoshua M. Clulow * We do not perform full handling of the "Scroll Lock" 1776*7d724debSJoshua M. Clulow * key. It does not change the console scrolling mode 1777*7d724debSJoshua M. Clulow * or even impact the keyboard indicator light. 1778*7d724debSJoshua M. Clulow * 1779*7d724debSJoshua M. Clulow * Some hypervisor keyboard emulators (e.g., SPICE in 1780*7d724debSJoshua M. Clulow * QEMU) seek to keep the scroll lock state in sync 1781*7d724debSJoshua M. Clulow * with the local client keyboard state by aggressively 1782*7d724debSJoshua M. Clulow * generating emulated Scroll Lock press and release 1783*7d724debSJoshua M. Clulow * events. Emitting the function key control sequence 1784*7d724debSJoshua M. Clulow * (which is already of dubious utility) makes the 1785*7d724debSJoshua M. Clulow * console unusable; instead, we ignore Scroll Lock 1786*7d724debSJoshua M. Clulow * completely here. 1787*7d724debSJoshua M. Clulow */ 1788*7d724debSJoshua M. Clulow return; 1789*7d724debSJoshua M. Clulow } 1790*7d724debSJoshua M. Clulow 17917c478bd9Sstevel@tonic-gate /* 17927c478bd9Sstevel@tonic-gate * We need to expand this key to get the ascii 17937c478bd9Sstevel@tonic-gate * equivalent. These are the function keys (F1, F2 ...) 17947c478bd9Sstevel@tonic-gate */ 17957c478bd9Sstevel@tonic-gate bufp = buf; 17967c478bd9Sstevel@tonic-gate cp = kbtrans_strsetwithdecimal(bufp + 2, 1797aecfc01dSrui zang - Sun Microsystems - Beijing China (uint_t)((entry & 0x003F) + 192), 1798aecfc01dSrui zang - Sun Microsystems - Beijing China sizeof (buf) - 5); 17997c478bd9Sstevel@tonic-gate *bufp++ = '\033'; /* Escape */ 18007c478bd9Sstevel@tonic-gate *bufp++ = '['; 18017c478bd9Sstevel@tonic-gate while (*cp != '\0') 18027c478bd9Sstevel@tonic-gate *bufp++ = *cp++; 18037c478bd9Sstevel@tonic-gate *bufp++ = 'z'; 18047c478bd9Sstevel@tonic-gate *bufp = '\0'; 18057c478bd9Sstevel@tonic-gate 18067c478bd9Sstevel@tonic-gate /* 18077c478bd9Sstevel@tonic-gate * Send the result upstream. 18087c478bd9Sstevel@tonic-gate */ 18097c478bd9Sstevel@tonic-gate kbtrans_putbuf(buf, upper->kbtrans_streams_readq); 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate return; 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate case STRING: 1814aecfc01dSrui zang - Sun Microsystems - Beijing China if (upper->vt_switch_keystate > VT_SWITCH_KEY_NONE) { 1815aecfc01dSrui zang - Sun Microsystems - Beijing China keyid = entry & 0xFF; 1816aecfc01dSrui zang - Sun Microsystems - Beijing China if (keyid == UPARROW || 1817aecfc01dSrui zang - Sun Microsystems - Beijing China keyid == RIGHTARROW || 1818aecfc01dSrui zang - Sun Microsystems - Beijing China keyid == LEFTARROW) { 1819aecfc01dSrui zang - Sun Microsystems - Beijing China 1820aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_vt_compose(upper, keyid, B_TRUE, buf); 1821aecfc01dSrui zang - Sun Microsystems - Beijing China return; 1822aecfc01dSrui zang - Sun Microsystems - Beijing China } 1823aecfc01dSrui zang - Sun Microsystems - Beijing China } 1824aecfc01dSrui zang - Sun Microsystems - Beijing China 18257c478bd9Sstevel@tonic-gate /* 18267c478bd9Sstevel@tonic-gate * These are the multi byte keys (Home, Up, Down ...) 18277c478bd9Sstevel@tonic-gate */ 18287c478bd9Sstevel@tonic-gate cp = &lower->kbtrans_keystringtab[entry & 0x0F][0]; 18297c478bd9Sstevel@tonic-gate 18307c478bd9Sstevel@tonic-gate /* 18317c478bd9Sstevel@tonic-gate * Copy the string from the keystringtable, and send it 18327c478bd9Sstevel@tonic-gate * upstream a character at a time. 18337c478bd9Sstevel@tonic-gate */ 18347c478bd9Sstevel@tonic-gate while (*cp != '\0') { 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate kbtrans_putcode(upper, (uchar_t)*cp); 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate cp++; 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate return; 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate case PADKEYS: 18447c478bd9Sstevel@tonic-gate /* 18457c478bd9Sstevel@tonic-gate * These are the keys on the keypad. Look up the 18467c478bd9Sstevel@tonic-gate * answer in the kb_numlock_table and send it upstream. 18477c478bd9Sstevel@tonic-gate */ 18487c478bd9Sstevel@tonic-gate kbtrans_putcode(upper, 1849aecfc01dSrui zang - Sun Microsystems - Beijing China lower->kbtrans_numlock_table[entry&0x1F]); 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate return; 18527c478bd9Sstevel@tonic-gate 18537c478bd9Sstevel@tonic-gate case 0: /* normal character */ 18547c478bd9Sstevel@tonic-gate default: 18557c478bd9Sstevel@tonic-gate break; 18567c478bd9Sstevel@tonic-gate } 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate /* 1859adc2b73dSToomas Soome * Send the char upstream. 18607c478bd9Sstevel@tonic-gate */ 18617c478bd9Sstevel@tonic-gate kbtrans_putcode(upper, entry); 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate } 18647c478bd9Sstevel@tonic-gate 1865aecfc01dSrui zang - Sun Microsystems - Beijing China #define KB_SCANCODE_ALT 0xe2 1866aecfc01dSrui zang - Sun Microsystems - Beijing China #define KB_SCANCODE_ALTGRAPH 0xe6 1867aecfc01dSrui zang - Sun Microsystems - Beijing China 18687c478bd9Sstevel@tonic-gate /* 18697c478bd9Sstevel@tonic-gate * kbtrans_ascii_keyreleased: 18707c478bd9Sstevel@tonic-gate * This is the function if we are in TR_ASCII mode and a key 18715d420dfbSToomas Soome * is released. ASCII doesn't have the concept of released keys, 18725d420dfbSToomas Soome * or make/break codes. So there is nothing for us to do except 1873aecfc01dSrui zang - Sun Microsystems - Beijing China * checking 'Alt/AltGraph' release key in order to reset the state 1874aecfc01dSrui zang - Sun Microsystems - Beijing China * of vt switch key sequence. 18757c478bd9Sstevel@tonic-gate */ 18767c478bd9Sstevel@tonic-gate /* ARGSUSED */ 18777c478bd9Sstevel@tonic-gate static void 18787c478bd9Sstevel@tonic-gate kbtrans_ascii_keyreleased(struct kbtrans *upper, kbtrans_key_t key) 18797c478bd9Sstevel@tonic-gate { 1880aecfc01dSrui zang - Sun Microsystems - Beijing China if (key == KB_SCANCODE_ALT || key == KB_SCANCODE_ALTGRAPH) { 1881aecfc01dSrui zang - Sun Microsystems - Beijing China upper->vt_switch_keystate = VT_SWITCH_KEY_NONE; 1882aecfc01dSrui zang - Sun Microsystems - Beijing China } 18837c478bd9Sstevel@tonic-gate } 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate /* 18867c478bd9Sstevel@tonic-gate * kbtrans_ascii_setup_repeat: 18877c478bd9Sstevel@tonic-gate * This is the function if we are in TR_ASCII mode and the 18885d420dfbSToomas Soome * translation module has decided that a key needs to be repeated. 18897c478bd9Sstevel@tonic-gate */ 18907c478bd9Sstevel@tonic-gate /* ARGSUSED */ 18917c478bd9Sstevel@tonic-gate static void 18925d420dfbSToomas Soome kbtrans_ascii_setup_repeat(struct kbtrans *upper, uint_t entrytype, 18937c478bd9Sstevel@tonic-gate kbtrans_key_t key) 18947c478bd9Sstevel@tonic-gate { 18957c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 18967c478bd9Sstevel@tonic-gate 18977c478bd9Sstevel@tonic-gate /* 18987c478bd9Sstevel@tonic-gate * Cancel any currently repeating keys. This will be a new 18997c478bd9Sstevel@tonic-gate * key to repeat. 19007c478bd9Sstevel@tonic-gate */ 19017c478bd9Sstevel@tonic-gate kbtrans_cancelrpt(upper); 19027c478bd9Sstevel@tonic-gate 19037c478bd9Sstevel@tonic-gate /* 19047c478bd9Sstevel@tonic-gate * Set the value of the key to be repeated. 19057c478bd9Sstevel@tonic-gate */ 19067c478bd9Sstevel@tonic-gate lower->kbtrans_repeatkey = key; 19077c478bd9Sstevel@tonic-gate 19087c478bd9Sstevel@tonic-gate /* 19097c478bd9Sstevel@tonic-gate * Start the timeout for repeating this key. kbtrans_rpt will 19107c478bd9Sstevel@tonic-gate * be called to repeat the key. 19117c478bd9Sstevel@tonic-gate */ 19125d420dfbSToomas Soome upper->kbtrans_streams_count = 0; 19137c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq, 1914aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay); 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate /* 19187c478bd9Sstevel@tonic-gate * kbtrans_trans_event_keypressed: 19197c478bd9Sstevel@tonic-gate * This is the function if we are in TR_EVENT mode and a key 19205d420dfbSToomas Soome * is pressed. This is where we will do any special processing that 19215d420dfbSToomas Soome * is specific to EVENT key translation. 19227c478bd9Sstevel@tonic-gate */ 19237c478bd9Sstevel@tonic-gate static void 19245d420dfbSToomas Soome kbtrans_trans_event_keypressed(struct kbtrans *upper, uint_t entrytype, 19255d420dfbSToomas Soome kbtrans_key_t key, uint_t entry) 19267c478bd9Sstevel@tonic-gate { 19277c478bd9Sstevel@tonic-gate Firm_event fe; 19287c478bd9Sstevel@tonic-gate register char *cp; 19297c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 19307c478bd9Sstevel@tonic-gate 19317c478bd9Sstevel@tonic-gate /* 19327c478bd9Sstevel@tonic-gate * Based on the type of key, we may need to do some EVENT 19337c478bd9Sstevel@tonic-gate * specific post processing. 19347c478bd9Sstevel@tonic-gate */ 19357c478bd9Sstevel@tonic-gate switch (entrytype) { 19367c478bd9Sstevel@tonic-gate 19377c478bd9Sstevel@tonic-gate case SHIFTKEYS: 19387c478bd9Sstevel@tonic-gate /* 19397c478bd9Sstevel@tonic-gate * Relying on ordinal correspondence between 19407c478bd9Sstevel@tonic-gate * vuid_event.h SHIFT_META-SHIFT_TOP & 19417c478bd9Sstevel@tonic-gate * kbd.h METABIT-SYSTEMBIT in order to 19427c478bd9Sstevel@tonic-gate * correctly translate entry into fe.id. 19437c478bd9Sstevel@tonic-gate */ 19447c478bd9Sstevel@tonic-gate fe.id = SHIFT_CAPSLOCK + (entry & 0x0F); 19457c478bd9Sstevel@tonic-gate fe.value = 1; 19467c478bd9Sstevel@tonic-gate kbtrans_keypressed(upper, key, &fe, fe.id); 19477c478bd9Sstevel@tonic-gate 19487c478bd9Sstevel@tonic-gate return; 19497c478bd9Sstevel@tonic-gate 19507c478bd9Sstevel@tonic-gate case BUCKYBITS: 19517c478bd9Sstevel@tonic-gate /* 19527c478bd9Sstevel@tonic-gate * Relying on ordinal correspondence between 19537c478bd9Sstevel@tonic-gate * vuid_event.h SHIFT_CAPSLOCK-SHIFT_RIGHTCTRL & 19547c478bd9Sstevel@tonic-gate * kbd.h CAPSLOCK-RIGHTCTRL in order to 19557c478bd9Sstevel@tonic-gate * correctly translate entry into fe.id. 19567c478bd9Sstevel@tonic-gate */ 19577c478bd9Sstevel@tonic-gate fe.id = SHIFT_META + (entry & 0x0F); 19587c478bd9Sstevel@tonic-gate fe.value = 1; 19597c478bd9Sstevel@tonic-gate kbtrans_keypressed(upper, key, &fe, fe.id); 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate return; 19627c478bd9Sstevel@tonic-gate 19637c478bd9Sstevel@tonic-gate case FUNCKEYS: 19647c478bd9Sstevel@tonic-gate /* 19657c478bd9Sstevel@tonic-gate * Take advantage of the similar 19667c478bd9Sstevel@tonic-gate * ordering of kbd.h function keys and 19677c478bd9Sstevel@tonic-gate * vuid_event.h function keys to do a 19687c478bd9Sstevel@tonic-gate * simple translation to achieve a 19697c478bd9Sstevel@tonic-gate * mapping between the 2 different 19707c478bd9Sstevel@tonic-gate * address spaces. 19717c478bd9Sstevel@tonic-gate */ 19727c478bd9Sstevel@tonic-gate fe.id = KEY_LEFTFIRST + (entry & 0x003F); 19737c478bd9Sstevel@tonic-gate fe.value = 1; 19747c478bd9Sstevel@tonic-gate 19757c478bd9Sstevel@tonic-gate /* 19767c478bd9Sstevel@tonic-gate * Assume "up" table only generates 19777c478bd9Sstevel@tonic-gate * shift changes. 19787c478bd9Sstevel@tonic-gate */ 19797c478bd9Sstevel@tonic-gate kbtrans_keypressed(upper, key, &fe, fe.id); 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate /* 19827c478bd9Sstevel@tonic-gate * Function key events can be expanded 19837c478bd9Sstevel@tonic-gate * by terminal emulator software to 19847c478bd9Sstevel@tonic-gate * produce the standard escape sequence 19857c478bd9Sstevel@tonic-gate * generated by the TR_ASCII case above 19867c478bd9Sstevel@tonic-gate * if a function key event is not used 19877c478bd9Sstevel@tonic-gate * by terminal emulator software 19887c478bd9Sstevel@tonic-gate * directly. 19897c478bd9Sstevel@tonic-gate */ 19907c478bd9Sstevel@tonic-gate return; 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate case STRING: 19937c478bd9Sstevel@tonic-gate /* 19947c478bd9Sstevel@tonic-gate * These are the multi byte keys (Home, Up, Down ...) 19957c478bd9Sstevel@tonic-gate */ 19967c478bd9Sstevel@tonic-gate cp = &lower->kbtrans_keystringtab[entry & 0x0F][0]; 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate /* 19997c478bd9Sstevel@tonic-gate * Copy the string from the keystringtable, and send it 20007c478bd9Sstevel@tonic-gate * upstream a character at a time. 20017c478bd9Sstevel@tonic-gate */ 20027c478bd9Sstevel@tonic-gate while (*cp != '\0') { 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate kbtrans_send_esc_event(*cp, upper); 20057c478bd9Sstevel@tonic-gate 20067c478bd9Sstevel@tonic-gate cp++; 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate 20097c478bd9Sstevel@tonic-gate return; 20107c478bd9Sstevel@tonic-gate 20117c478bd9Sstevel@tonic-gate case PADKEYS: 20127c478bd9Sstevel@tonic-gate /* 20137c478bd9Sstevel@tonic-gate * Take advantage of the similar 20147c478bd9Sstevel@tonic-gate * ordering of kbd.h keypad keys and 20157c478bd9Sstevel@tonic-gate * vuid_event.h keypad keys to do a 20167c478bd9Sstevel@tonic-gate * simple translation to achieve a 20177c478bd9Sstevel@tonic-gate * mapping between the 2 different 20187c478bd9Sstevel@tonic-gate * address spaces. 20197c478bd9Sstevel@tonic-gate */ 20207c478bd9Sstevel@tonic-gate fe.id = VKEY_FIRSTPAD + (entry & 0x001F); 20217c478bd9Sstevel@tonic-gate fe.value = 1; 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate /* 20247c478bd9Sstevel@tonic-gate * Assume "up" table only generates 20257c478bd9Sstevel@tonic-gate * shift changes. 20267c478bd9Sstevel@tonic-gate */ 20277c478bd9Sstevel@tonic-gate kbtrans_keypressed(upper, key, &fe, fe.id); 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate /* 20307c478bd9Sstevel@tonic-gate * Keypad key events can be expanded 20317c478bd9Sstevel@tonic-gate * by terminal emulator software to 20327c478bd9Sstevel@tonic-gate * produce the standard ascii character 20337c478bd9Sstevel@tonic-gate * generated by the TR_ASCII case above 20347c478bd9Sstevel@tonic-gate * if a keypad key event is not used 20357c478bd9Sstevel@tonic-gate * by terminal emulator software 20367c478bd9Sstevel@tonic-gate * directly. 20377c478bd9Sstevel@tonic-gate */ 20387c478bd9Sstevel@tonic-gate return; 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate case FUNNY: 20417c478bd9Sstevel@tonic-gate /* 20427c478bd9Sstevel@tonic-gate * These are not events. 20437c478bd9Sstevel@tonic-gate */ 20447c478bd9Sstevel@tonic-gate switch (entry) { 20457c478bd9Sstevel@tonic-gate case IDLE: 20467c478bd9Sstevel@tonic-gate case RESET: 20477c478bd9Sstevel@tonic-gate case ERROR: 20487c478bd9Sstevel@tonic-gate /* 20497c478bd9Sstevel@tonic-gate * Something has happened. Mark all keys as released. 20507c478bd9Sstevel@tonic-gate */ 20517c478bd9Sstevel@tonic-gate kbtrans_streams_releaseall(upper); 20527c478bd9Sstevel@tonic-gate break; 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate 20557c478bd9Sstevel@tonic-gate return; 20567c478bd9Sstevel@tonic-gate 20577c478bd9Sstevel@tonic-gate case 0: /* normal character */ 20587c478bd9Sstevel@tonic-gate default: 20597c478bd9Sstevel@tonic-gate break; 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate /* 20637c478bd9Sstevel@tonic-gate * Send the event upstream. 20647c478bd9Sstevel@tonic-gate */ 20657c478bd9Sstevel@tonic-gate fe.id = entry; 20667c478bd9Sstevel@tonic-gate 20677c478bd9Sstevel@tonic-gate fe.value = 1; 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate kbtrans_queueevent(upper, &fe); 20707c478bd9Sstevel@tonic-gate } 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate /* 20737c478bd9Sstevel@tonic-gate * kbtrans_trans_event_keyreleased: 20747c478bd9Sstevel@tonic-gate * This is the function if we are in TR_EVENT mode and a key 20755d420dfbSToomas Soome * is released. 20767c478bd9Sstevel@tonic-gate */ 20777c478bd9Sstevel@tonic-gate /* ARGSUSED */ 20787c478bd9Sstevel@tonic-gate static void 20797c478bd9Sstevel@tonic-gate kbtrans_trans_event_keyreleased(struct kbtrans *upper, kbtrans_key_t key) 20807c478bd9Sstevel@tonic-gate { 20817c478bd9Sstevel@tonic-gate /* 20827c478bd9Sstevel@tonic-gate * Mark the key as released and send an event upstream. 20837c478bd9Sstevel@tonic-gate */ 20847c478bd9Sstevel@tonic-gate kbtrans_keyreleased(upper, key); 20857c478bd9Sstevel@tonic-gate } 20867c478bd9Sstevel@tonic-gate 20877c478bd9Sstevel@tonic-gate /* 20887c478bd9Sstevel@tonic-gate * kbtrans_trans_event_setup_repeat: 20897c478bd9Sstevel@tonic-gate * This is the function if we are in TR_EVENT mode and the 20907c478bd9Sstevel@tonic-gate * translation module has decided that a key needs to be repeated. 20915d420dfbSToomas Soome * We will set a timeout to retranslate the repeat key. 20927c478bd9Sstevel@tonic-gate */ 20937c478bd9Sstevel@tonic-gate static void 20945d420dfbSToomas Soome kbtrans_trans_event_setup_repeat(struct kbtrans *upper, uint_t entrytype, 20955d420dfbSToomas Soome kbtrans_key_t key) 20967c478bd9Sstevel@tonic-gate { 20977c478bd9Sstevel@tonic-gate struct kbtrans_lower *lower = &upper->kbtrans_lower; 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate /* 21007c478bd9Sstevel@tonic-gate * Function keys and keypad keys do not repeat when we are in 21017c478bd9Sstevel@tonic-gate * EVENT mode. 21027c478bd9Sstevel@tonic-gate */ 21037c478bd9Sstevel@tonic-gate if (entrytype == FUNCKEYS || entrytype == PADKEYS) { 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate return; 21067c478bd9Sstevel@tonic-gate } 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate /* 21097c478bd9Sstevel@tonic-gate * Cancel any currently repeating keys. This will be a new 21107c478bd9Sstevel@tonic-gate * key to repeat. 21117c478bd9Sstevel@tonic-gate */ 21127c478bd9Sstevel@tonic-gate kbtrans_cancelrpt(upper); 21137c478bd9Sstevel@tonic-gate 21147c478bd9Sstevel@tonic-gate /* 21157c478bd9Sstevel@tonic-gate * Set the value of the key to be repeated. 21167c478bd9Sstevel@tonic-gate */ 21177c478bd9Sstevel@tonic-gate lower->kbtrans_repeatkey = key; 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate /* 21207c478bd9Sstevel@tonic-gate * Start the timeout for repeating this key. kbtrans_rpt will 21217c478bd9Sstevel@tonic-gate * be called to repeat the key. 21227c478bd9Sstevel@tonic-gate */ 21235d420dfbSToomas Soome upper->kbtrans_streams_count = 0; 21247c478bd9Sstevel@tonic-gate upper->kbtrans_streams_rptid = qtimeout(upper->kbtrans_streams_readq, 2125aecfc01dSrui zang - Sun Microsystems - Beijing China kbtrans_rpt, (caddr_t)upper, kbtrans_repeat_delay); 21267c478bd9Sstevel@tonic-gate } 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate /* 21297c478bd9Sstevel@tonic-gate * Administer the key tables. 21307c478bd9Sstevel@tonic-gate */ 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate /* 21337c478bd9Sstevel@tonic-gate * Old special codes. 21347c478bd9Sstevel@tonic-gate */ 21357c478bd9Sstevel@tonic-gate #define OLD_SHIFTKEYS 0x80 21367c478bd9Sstevel@tonic-gate #define OLD_BUCKYBITS 0x90 21377c478bd9Sstevel@tonic-gate #define OLD_FUNNY 0xA0 21387c478bd9Sstevel@tonic-gate #define OLD_FA_UMLAUT 0xA9 21397c478bd9Sstevel@tonic-gate #define OLD_FA_CFLEX 0xAA 21407c478bd9Sstevel@tonic-gate #define OLD_FA_TILDE 0xAB 21417c478bd9Sstevel@tonic-gate #define OLD_FA_CEDILLA 0xAC 21427c478bd9Sstevel@tonic-gate #define OLD_FA_ACUTE 0xAD 21437c478bd9Sstevel@tonic-gate #define OLD_FA_GRAVE 0xAE 21447c478bd9Sstevel@tonic-gate #define OLD_ISOCHAR 0xAF 21457c478bd9Sstevel@tonic-gate #define OLD_STRING 0xB0 21467c478bd9Sstevel@tonic-gate #define OLD_LEFTFUNC 0xC0 21477c478bd9Sstevel@tonic-gate #define OLD_RIGHTFUNC 0xD0 21487c478bd9Sstevel@tonic-gate #define OLD_TOPFUNC 0xE0 21497c478bd9Sstevel@tonic-gate #define OLD_BOTTOMFUNC 0xF0 21507c478bd9Sstevel@tonic-gate 21517c478bd9Sstevel@tonic-gate /* 21527c478bd9Sstevel@tonic-gate * Map old special codes to new ones. 21537c478bd9Sstevel@tonic-gate * Indexed by ((old special code) >> 4) & 0x07; add (old special code) & 0x0F. 21547c478bd9Sstevel@tonic-gate */ 2155adc2b73dSToomas Soome static keymap_entry_t special_old_to_new[] = { 21567c478bd9Sstevel@tonic-gate SHIFTKEYS, 21577c478bd9Sstevel@tonic-gate BUCKYBITS, 21587c478bd9Sstevel@tonic-gate FUNNY, 21597c478bd9Sstevel@tonic-gate STRING, 21607c478bd9Sstevel@tonic-gate LEFTFUNC, 21617c478bd9Sstevel@tonic-gate RIGHTFUNC, 21627c478bd9Sstevel@tonic-gate TOPFUNC, 21637c478bd9Sstevel@tonic-gate BOTTOMFUNC, 21647c478bd9Sstevel@tonic-gate }; 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate 21677c478bd9Sstevel@tonic-gate /* 21687c478bd9Sstevel@tonic-gate * kbtrans_setkey: 21697c478bd9Sstevel@tonic-gate * Set individual keystation translation from old-style entry. 21707c478bd9Sstevel@tonic-gate */ 21717c478bd9Sstevel@tonic-gate static int 21727c478bd9Sstevel@tonic-gate kbtrans_setkey(struct kbtrans_lower *lower, struct kiockey *key, cred_t *cr) 21737c478bd9Sstevel@tonic-gate { 21747c478bd9Sstevel@tonic-gate int strtabindex, i; 2175adc2b73dSToomas Soome keymap_entry_t *ke; 21767c478bd9Sstevel@tonic-gate register int tablemask; 2177adc2b73dSToomas Soome register keymap_entry_t entry; 21787c478bd9Sstevel@tonic-gate register struct keyboard *kp; 21797c478bd9Sstevel@tonic-gate 21807c478bd9Sstevel@tonic-gate kp = lower->kbtrans_keyboard; 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate if (key->kio_station >= kp->k_keymap_size) 21837c478bd9Sstevel@tonic-gate return (EINVAL); 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate if (lower->kbtrans_keyboard == NULL) 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate return (EINVAL); 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate tablemask = key->kio_tablemask; 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate switch (tablemask) { 21927c478bd9Sstevel@tonic-gate case KIOCABORT1: 21937c478bd9Sstevel@tonic-gate case KIOCABORT1A: 21947c478bd9Sstevel@tonic-gate case KIOCABORT2: 21957c478bd9Sstevel@tonic-gate i = secpolicy_console(cr); 21967c478bd9Sstevel@tonic-gate if (i != 0) 21977c478bd9Sstevel@tonic-gate return (i); 21987c478bd9Sstevel@tonic-gate 21997c478bd9Sstevel@tonic-gate switch (tablemask) { 22007c478bd9Sstevel@tonic-gate case KIOCABORT1: 22017c478bd9Sstevel@tonic-gate kp->k_abort1 = key->kio_station; 22027c478bd9Sstevel@tonic-gate break; 22037c478bd9Sstevel@tonic-gate case KIOCABORT1A: 22047c478bd9Sstevel@tonic-gate kp->k_abort1a = key->kio_station; 22057c478bd9Sstevel@tonic-gate break; 22067c478bd9Sstevel@tonic-gate case KIOCABORT2: 22077c478bd9Sstevel@tonic-gate kp->k_abort2 = key->kio_station; 22087c478bd9Sstevel@tonic-gate break; 22097c478bd9Sstevel@tonic-gate } 22107c478bd9Sstevel@tonic-gate return (0); 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate if (tablemask & ALTGRAPHMASK) 22147c478bd9Sstevel@tonic-gate return (EINVAL); 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate ke = kbtrans_find_entry(lower, (uint_t)tablemask, key->kio_station); 22177c478bd9Sstevel@tonic-gate if (ke == NULL) 22187c478bd9Sstevel@tonic-gate return (EINVAL); 22197c478bd9Sstevel@tonic-gate 22207c478bd9Sstevel@tonic-gate if (key->kio_entry >= (uchar_t)OLD_STRING && 22217c478bd9Sstevel@tonic-gate key->kio_entry <= (uchar_t)(OLD_STRING + 15)) { 22227c478bd9Sstevel@tonic-gate strtabindex = key->kio_entry - OLD_STRING; 22237c478bd9Sstevel@tonic-gate bcopy(key->kio_string, 2224aecfc01dSrui zang - Sun Microsystems - Beijing China lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN); 22257c478bd9Sstevel@tonic-gate lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0'; 22267c478bd9Sstevel@tonic-gate } 22277c478bd9Sstevel@tonic-gate 22287c478bd9Sstevel@tonic-gate entry = key->kio_entry; 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate /* 22317c478bd9Sstevel@tonic-gate * There's nothing we need do with OLD_ISOCHAR. 22327c478bd9Sstevel@tonic-gate */ 22337c478bd9Sstevel@tonic-gate if (entry != OLD_ISOCHAR) { 22347c478bd9Sstevel@tonic-gate if (entry & 0x80) { 22357c478bd9Sstevel@tonic-gate if (entry >= OLD_FA_UMLAUT && entry <= OLD_FA_GRAVE) 22367c478bd9Sstevel@tonic-gate entry = FA_CLASS + (entry & 0x0F) - 9; 22377c478bd9Sstevel@tonic-gate else 22387c478bd9Sstevel@tonic-gate entry = 22397c478bd9Sstevel@tonic-gate special_old_to_new[entry >> 4 & 0x07] 22407c478bd9Sstevel@tonic-gate + (entry & 0x0F); 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate } 22437c478bd9Sstevel@tonic-gate 22447c478bd9Sstevel@tonic-gate *ke = entry; 22457c478bd9Sstevel@tonic-gate 22467c478bd9Sstevel@tonic-gate return (0); 22477c478bd9Sstevel@tonic-gate } 22487c478bd9Sstevel@tonic-gate 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate /* 22517c478bd9Sstevel@tonic-gate * Map new special codes to old ones. 22527c478bd9Sstevel@tonic-gate * Indexed by (new special code) >> 8; add (new special code) & 0xFF. 22537c478bd9Sstevel@tonic-gate */ 22547c478bd9Sstevel@tonic-gate static uchar_t special_new_to_old[] = { 22557c478bd9Sstevel@tonic-gate 0, /* normal */ 22567c478bd9Sstevel@tonic-gate OLD_SHIFTKEYS, /* SHIFTKEYS */ 22577c478bd9Sstevel@tonic-gate OLD_BUCKYBITS, /* BUCKYBITS */ 22587c478bd9Sstevel@tonic-gate OLD_FUNNY, /* FUNNY */ 22597c478bd9Sstevel@tonic-gate OLD_FA_UMLAUT, /* FA_CLASS */ 22607c478bd9Sstevel@tonic-gate OLD_STRING, /* STRING */ 22617c478bd9Sstevel@tonic-gate OLD_LEFTFUNC, /* FUNCKEYS */ 22627c478bd9Sstevel@tonic-gate }; 22637c478bd9Sstevel@tonic-gate 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate /* 22667c478bd9Sstevel@tonic-gate * kbtrans_getkey: 22677c478bd9Sstevel@tonic-gate * Get individual keystation translation as old-style entry. 22687c478bd9Sstevel@tonic-gate */ 22697c478bd9Sstevel@tonic-gate static int 22707c478bd9Sstevel@tonic-gate kbtrans_getkey(struct kbtrans_lower *lower, struct kiockey *key) 22717c478bd9Sstevel@tonic-gate { 22727c478bd9Sstevel@tonic-gate int strtabindex; 2273adc2b73dSToomas Soome keymap_entry_t *ke; 2274adc2b73dSToomas Soome register keymap_entry_t entry; 22757c478bd9Sstevel@tonic-gate struct keyboard *kp; 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate kp = lower->kbtrans_keyboard; 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate if (key->kio_station >= kp->k_keymap_size) 22807c478bd9Sstevel@tonic-gate return (EINVAL); 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate if (lower->kbtrans_keyboard == NULL) 22837c478bd9Sstevel@tonic-gate return (EINVAL); 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate switch (key->kio_tablemask) { 22867c478bd9Sstevel@tonic-gate case KIOCABORT1: 22877c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort1; 22887c478bd9Sstevel@tonic-gate return (0); 22897c478bd9Sstevel@tonic-gate case KIOCABORT1A: 22907c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort1a; 22917c478bd9Sstevel@tonic-gate return (0); 22927c478bd9Sstevel@tonic-gate case KIOCABORT2: 22937c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort2; 22947c478bd9Sstevel@tonic-gate return (0); 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2298aecfc01dSrui zang - Sun Microsystems - Beijing China key->kio_station); 22997c478bd9Sstevel@tonic-gate if (ke == NULL) 23007c478bd9Sstevel@tonic-gate return (EINVAL); 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate entry = *ke; 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate if (entry & 0xFF00) 23057c478bd9Sstevel@tonic-gate key->kio_entry = 23067c478bd9Sstevel@tonic-gate special_new_to_old[(ushort_t)(entry & 0xFF00) >> 8] 23077c478bd9Sstevel@tonic-gate + (entry & 0x00FF); 23087c478bd9Sstevel@tonic-gate else { 23097c478bd9Sstevel@tonic-gate if (entry & 0x80) 23107c478bd9Sstevel@tonic-gate key->kio_entry = (ushort_t)OLD_ISOCHAR; /* you lose */ 23117c478bd9Sstevel@tonic-gate else 23127c478bd9Sstevel@tonic-gate key->kio_entry = (ushort_t)entry; 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate 23157c478bd9Sstevel@tonic-gate if (entry >= STRING && entry <= (uchar_t)(STRING + 15)) { 23167c478bd9Sstevel@tonic-gate strtabindex = entry - STRING; 23177c478bd9Sstevel@tonic-gate bcopy(lower->kbtrans_keystringtab[strtabindex], 2318aecfc01dSrui zang - Sun Microsystems - Beijing China key->kio_string, KTAB_STRLEN); 23197c478bd9Sstevel@tonic-gate } 23207c478bd9Sstevel@tonic-gate return (0); 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate /* 23257c478bd9Sstevel@tonic-gate * kbtrans_skey: 23267c478bd9Sstevel@tonic-gate * Set individual keystation translation from new-style entry. 23277c478bd9Sstevel@tonic-gate */ 23287c478bd9Sstevel@tonic-gate static int 23297c478bd9Sstevel@tonic-gate kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr) 23307c478bd9Sstevel@tonic-gate { 23317c478bd9Sstevel@tonic-gate int strtabindex, i; 2332adc2b73dSToomas Soome keymap_entry_t *ke; 23337c478bd9Sstevel@tonic-gate struct keyboard *kp; 23347c478bd9Sstevel@tonic-gate 23357c478bd9Sstevel@tonic-gate kp = lower->kbtrans_keyboard; 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate if (key->kio_station >= kp->k_keymap_size) { 23387c478bd9Sstevel@tonic-gate return (EINVAL); 23397c478bd9Sstevel@tonic-gate 23407c478bd9Sstevel@tonic-gate } 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate if (lower->kbtrans_keyboard == NULL) { 23437c478bd9Sstevel@tonic-gate return (EINVAL); 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate 23467c478bd9Sstevel@tonic-gate switch (key->kio_tablemask) { 23477c478bd9Sstevel@tonic-gate case KIOCABORT1: 23487c478bd9Sstevel@tonic-gate case KIOCABORT1A: 23497c478bd9Sstevel@tonic-gate case KIOCABORT2: 23507c478bd9Sstevel@tonic-gate i = secpolicy_console(cr); 23517c478bd9Sstevel@tonic-gate if (i != 0) 23527c478bd9Sstevel@tonic-gate return (i); 23537c478bd9Sstevel@tonic-gate switch (key->kio_tablemask) { 23547c478bd9Sstevel@tonic-gate case KIOCABORT1: 23557c478bd9Sstevel@tonic-gate kp->k_abort1 = key->kio_station; 23567c478bd9Sstevel@tonic-gate break; 23577c478bd9Sstevel@tonic-gate case KIOCABORT1A: 23587c478bd9Sstevel@tonic-gate kp->k_abort1a = key->kio_station; 23597c478bd9Sstevel@tonic-gate break; 23607c478bd9Sstevel@tonic-gate case KIOCABORT2: 23617c478bd9Sstevel@tonic-gate kp->k_abort2 = key->kio_station; 23627c478bd9Sstevel@tonic-gate break; 23637c478bd9Sstevel@tonic-gate } 23647c478bd9Sstevel@tonic-gate return (0); 23657c478bd9Sstevel@tonic-gate } 23667c478bd9Sstevel@tonic-gate 23677c478bd9Sstevel@tonic-gate ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2368aecfc01dSrui zang - Sun Microsystems - Beijing China key->kio_station); 23697c478bd9Sstevel@tonic-gate if (ke == NULL) 23707c478bd9Sstevel@tonic-gate return (EINVAL); 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate if (key->kio_entry >= STRING && 2373adc2b73dSToomas Soome key->kio_entry <= (STRING + 15)) { 23747c478bd9Sstevel@tonic-gate strtabindex = key->kio_entry-STRING; 23757c478bd9Sstevel@tonic-gate bcopy(key->kio_string, 2376aecfc01dSrui zang - Sun Microsystems - Beijing China lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN); 23777c478bd9Sstevel@tonic-gate lower->kbtrans_keystringtab[strtabindex][KTAB_STRLEN-1] = '\0'; 23787c478bd9Sstevel@tonic-gate } 23797c478bd9Sstevel@tonic-gate 23807c478bd9Sstevel@tonic-gate *ke = key->kio_entry; 23817c478bd9Sstevel@tonic-gate 23827c478bd9Sstevel@tonic-gate return (0); 23837c478bd9Sstevel@tonic-gate } 23847c478bd9Sstevel@tonic-gate 23857c478bd9Sstevel@tonic-gate 23867c478bd9Sstevel@tonic-gate /* 23877c478bd9Sstevel@tonic-gate * kbtrans_gkey: 23887c478bd9Sstevel@tonic-gate * Get individual keystation translation as new-style entry. 23897c478bd9Sstevel@tonic-gate */ 23907c478bd9Sstevel@tonic-gate static int 2391adc2b73dSToomas Soome kbtrans_gkey(struct kbtrans_lower *lower, struct kiockeymap *key) 23927c478bd9Sstevel@tonic-gate { 23937c478bd9Sstevel@tonic-gate int strtabindex; 2394adc2b73dSToomas Soome keymap_entry_t *ke; 23957c478bd9Sstevel@tonic-gate struct keyboard *kp; 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate kp = lower->kbtrans_keyboard; 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate if (key->kio_station >= kp->k_keymap_size) 24007c478bd9Sstevel@tonic-gate return (EINVAL); 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate if (lower->kbtrans_keyboard == NULL) 24037c478bd9Sstevel@tonic-gate return (EINVAL); 24047c478bd9Sstevel@tonic-gate 24057c478bd9Sstevel@tonic-gate switch (key->kio_tablemask) { 24067c478bd9Sstevel@tonic-gate case KIOCABORT1: 24077c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort1; 24087c478bd9Sstevel@tonic-gate return (0); 24097c478bd9Sstevel@tonic-gate case KIOCABORT1A: 24107c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort1a; 24117c478bd9Sstevel@tonic-gate return (0); 24127c478bd9Sstevel@tonic-gate case KIOCABORT2: 24137c478bd9Sstevel@tonic-gate key->kio_station = kp->k_abort2; 24147c478bd9Sstevel@tonic-gate return (0); 24157c478bd9Sstevel@tonic-gate } 24167c478bd9Sstevel@tonic-gate 24177c478bd9Sstevel@tonic-gate ke = kbtrans_find_entry(lower, (uint_t)key->kio_tablemask, 2418aecfc01dSrui zang - Sun Microsystems - Beijing China key->kio_station); 24197c478bd9Sstevel@tonic-gate if (ke == NULL) 24207c478bd9Sstevel@tonic-gate return (EINVAL); 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate key->kio_entry = *ke; 24237c478bd9Sstevel@tonic-gate 24247c478bd9Sstevel@tonic-gate if (key->kio_entry >= STRING && 2425adc2b73dSToomas Soome key->kio_entry <= (STRING + 15)) { 24267c478bd9Sstevel@tonic-gate strtabindex = key->kio_entry-STRING; 24277c478bd9Sstevel@tonic-gate bcopy(lower->kbtrans_keystringtab[strtabindex], 2428aecfc01dSrui zang - Sun Microsystems - Beijing China key->kio_string, KTAB_STRLEN); 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate return (0); 24317c478bd9Sstevel@tonic-gate } 2432