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 5281f0747Slt200341 * Common Development and Distribution License (the "License"). 6281f0747Slt200341 * 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 */ 217c478bd9Sstevel@tonic-gate /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ 227c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ 237c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate /* 2648633f18SJan Setje-Eilers * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 277c478bd9Sstevel@tonic-gate * Use is subject to license terms. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate 30e8ed0869SJohn Beck #define KEYMAP_SIZE_VARIABLE 31e8ed0869SJohn Beck 327c478bd9Sstevel@tonic-gate #include <sys/types.h> 337c478bd9Sstevel@tonic-gate #include <sys/errno.h> 347c478bd9Sstevel@tonic-gate #include <sys/inline.h> 357c478bd9Sstevel@tonic-gate #include <sys/termio.h> 367c478bd9Sstevel@tonic-gate #include <sys/stropts.h> 377c478bd9Sstevel@tonic-gate #include <sys/termios.h> 387c478bd9Sstevel@tonic-gate #include <sys/stream.h> 397c478bd9Sstevel@tonic-gate #include <sys/strtty.h> 407c478bd9Sstevel@tonic-gate #include <sys/strsubr.h> 417c478bd9Sstevel@tonic-gate #include <sys/strsun.h> 427c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 437c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 447c478bd9Sstevel@tonic-gate #include <sys/note.h> 457c478bd9Sstevel@tonic-gate #include "sys/consdev.h" 467c478bd9Sstevel@tonic-gate #include <sys/kbd.h> 477c478bd9Sstevel@tonic-gate #include <sys/kbtrans.h> 487c478bd9Sstevel@tonic-gate #include "kb8042.h" 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate #include <sys/i8042.h> 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate #include "sys/kbio.h" /* for KIOCSLAYOUT */ 537c478bd9Sstevel@tonic-gate #include "sys/stat.h" 547c478bd9Sstevel@tonic-gate #include "sys/reboot.h" 557c478bd9Sstevel@tonic-gate #include <sys/promif.h> 567c478bd9Sstevel@tonic-gate #include <sys/beep.h> 57c35aa225Smarx #include <sys/inttypes.h> 58cd2135d0Spengcheng chen - Sun Microsystems - Beijing China #include <sys/policy.h> 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate /* 617c478bd9Sstevel@tonic-gate * For any keyboard, there is a unique code describing the position 627c478bd9Sstevel@tonic-gate * of the key on a keyboard. We refer to the code as "station number". 637c478bd9Sstevel@tonic-gate * The following table is used to map the station numbers from ps2 647c478bd9Sstevel@tonic-gate * AT/XT keyboards to that of a USB one. 65fd9cb95cSsethg * 66fd9cb95cSsethg * A mapping was added for entry K8042_STOP, to map to USB key code 120 (which 67fd9cb95cSsethg * maps to the STOP key) when in KB_USB mode, and maps to a HOLE entry 68fd9cb95cSsethg * when in KB_PC mode. Note that this does not need to be made conditional 69fd9cb95cSsethg * on the architecture for which this module is complied because there are no 70fd9cb95cSsethg * keys that map to K8042_STOP on non-SPARC platforms. 717c478bd9Sstevel@tonic-gate */ 727c478bd9Sstevel@tonic-gate static kbtrans_key_t keytab_pc2usb[KBTRANS_KEYNUMS_MAX] = { 737c478bd9Sstevel@tonic-gate /* 0 */ 0, 53, 30, 31, 32, 33, 34, 35, 747c478bd9Sstevel@tonic-gate /* 8 */ 36, 37, 38, 39, 45, 46, 137, 42, 757c478bd9Sstevel@tonic-gate /* 16 */ 43, 20, 26, 8, 21, 23, 28, 24, 767c478bd9Sstevel@tonic-gate /* 24 */ 12, 18, 19, 47, 48, 49, 57, 4, 777c478bd9Sstevel@tonic-gate /* 32 */ 22, 7, 9, 10, 11, 13, 14, 15, 787c478bd9Sstevel@tonic-gate /* 40 */ 51, 52, 50, 40, 225, 100, 29, 27, 797c478bd9Sstevel@tonic-gate /* 48 */ 6, 25, 5, 17, 16, 54, 55, 56, 807c478bd9Sstevel@tonic-gate /* 56 */ 135, 229, 224, 227, 226, 44, 230, 231, 817c478bd9Sstevel@tonic-gate /* 64 */ 228, 101, 0, 0, 0, 0, 0, 0, 827c478bd9Sstevel@tonic-gate /* 72 */ 0, 0, 0, 73, 76, 0, 0, 80, 837c478bd9Sstevel@tonic-gate /* 80 */ 74, 77, 0, 82, 81, 75, 78, 0, 847c478bd9Sstevel@tonic-gate /* 88 */ 0, 79, 83, 95, 92, 89, 0, 84, 857c478bd9Sstevel@tonic-gate /* 96 */ 96, 93, 90, 98, 85, 97, 94, 91, 867c478bd9Sstevel@tonic-gate /* 104 */ 99, 86, 87, 133, 88, 0, 41, 0, 877c478bd9Sstevel@tonic-gate /* 112 */ 58, 59, 60, 61, 62, 63, 64, 65, 887c478bd9Sstevel@tonic-gate /* 120 */ 66, 67, 68, 69, 70, 71, 72, 0, 897c478bd9Sstevel@tonic-gate /* 128 */ 0, 0, 0, 139, 138, 136, 0, 0, 907c478bd9Sstevel@tonic-gate /* 136 */ 0, 0, 0, 0, 0, 0, 0, 0, 917c478bd9Sstevel@tonic-gate /* 144 */ 0, 0, 0, 0, 0, 0, 0, 0, 927c478bd9Sstevel@tonic-gate /* 152 */ 0, 0, 0, 0, 0, 0, 0, 0, 93fd9cb95cSsethg /* 160 */ 120, 0, 0, 0, 0, 0, 0, 0, 947c478bd9Sstevel@tonic-gate /* 168 */ 0, 0, 0, 0, 0, 0, 0, 0, 957c478bd9Sstevel@tonic-gate /* 176 */ 0, 0, 0, 0, 0, 0, 0, 0, 967c478bd9Sstevel@tonic-gate /* 184 */ 0, 0, 0, 0, 0, 0, 0, 0, 977c478bd9Sstevel@tonic-gate /* 192 */ 0, 0, 0, 0, 0, 0, 0, 0, 987c478bd9Sstevel@tonic-gate /* 200 */ 0, 0, 0, 0, 0, 0, 0, 0, 997c478bd9Sstevel@tonic-gate /* 208 */ 0, 0, 0, 0, 0, 0, 0, 0, 1007c478bd9Sstevel@tonic-gate /* 216 */ 0, 0, 0, 0, 0, 0, 0, 0, 1017c478bd9Sstevel@tonic-gate /* 224 */ 0, 0, 0, 0, 0, 0, 0, 0, 1021841b879SSeth Goldberg /* 232 */ 0, 128, 129, 127, 0, 0, 0, 0, 1037c478bd9Sstevel@tonic-gate /* 240 */ 0, 0, 0, 0, 0, 0, 0, 0, 1047c478bd9Sstevel@tonic-gate /* 248 */ 0, 0, 0, 0 1057c478bd9Sstevel@tonic-gate }; 1067c478bd9Sstevel@tonic-gate 107fd9cb95cSsethg #ifdef __sparc 108fd9cb95cSsethg #define USECS_PER_WAIT 100 109fd9cb95cSsethg #define MAX_WAIT_USECS 100000 /* in usecs = 100 ms */ 110fd9cb95cSsethg #define MIN_DELAY_USECS USECS_PER_WAIT 111fd9cb95cSsethg 112fd9cb95cSsethg boolean_t kb8042_warn_unknown_scanset = B_TRUE; 113fd9cb95cSsethg int kb8042_default_scanset = 2; 114fd9cb95cSsethg 115fd9cb95cSsethg #endif 116fd9cb95cSsethg 11715bfc6b7SSeth Goldberg #define MAX_KB8042_WAIT_MAX_MS 500 /* 500ms total */ 11815bfc6b7SSeth Goldberg #define MAX_KB8042_RETRIES 5 11915bfc6b7SSeth Goldberg 1207c478bd9Sstevel@tonic-gate enum state_return { STATE_NORMAL, STATE_INTERNAL }; 1217c478bd9Sstevel@tonic-gate 122fd9cb95cSsethg static void kb8042_init(struct kb8042 *kb8042, boolean_t from_resume); 1237c478bd9Sstevel@tonic-gate static uint_t kb8042_intr(caddr_t arg); 1247c478bd9Sstevel@tonic-gate static void kb8042_wait_poweron(struct kb8042 *kb8042); 1257c478bd9Sstevel@tonic-gate static void kb8042_send_to_keyboard(struct kb8042 *, int, boolean_t); 1267c478bd9Sstevel@tonic-gate static int kb8042_xlate_leds(int); 127fd9cb95cSsethg static void kb8042_setled(struct kb8042 *, int led_state, boolean_t polled); 1287c478bd9Sstevel@tonic-gate static void kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state); 1297c478bd9Sstevel@tonic-gate static void kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state); 1307c478bd9Sstevel@tonic-gate static boolean_t kb8042_polled_keycheck( 1317c478bd9Sstevel@tonic-gate struct kbtrans_hardware *hw, int *key, 1327c478bd9Sstevel@tonic-gate enum keystate *state); 1337c478bd9Sstevel@tonic-gate static void kb8042_get_initial_leds(struct kb8042 *, int *, int *); 1347c478bd9Sstevel@tonic-gate static boolean_t kb8042_autorepeat_detect(struct kb8042 *kb8042, int key_pos, 1357c478bd9Sstevel@tonic-gate enum keystate state); 1367c478bd9Sstevel@tonic-gate static void kb8042_type4_cmd(struct kb8042 *kb8042, int cmd); 1377c478bd9Sstevel@tonic-gate static void kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *, mblk_t *); 1387c478bd9Sstevel@tonic-gate static void kb8042_iocdatamsg(queue_t *, mblk_t *); 1397c478bd9Sstevel@tonic-gate static void kb8042_process_key(struct kb8042 *, kbtrans_key_t, enum keystate); 140281f0747Slt200341 static int kb8042_polled_ischar(cons_polledio_arg_t arg); 141281f0747Slt200341 static int kb8042_polled_getchar(cons_polledio_arg_t arg); 142fd9cb95cSsethg static void kb8042_cleanup(struct kb8042 *kb8042); 143*2888301aSToomas Soome static void kb8042_received_byte(struct kb8042 *, int); 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate static struct kbtrans_callbacks kb8042_callbacks = { 1467c478bd9Sstevel@tonic-gate kb8042_streams_setled, 1477c478bd9Sstevel@tonic-gate kb8042_polled_setled, 1487c478bd9Sstevel@tonic-gate kb8042_polled_keycheck, 1497c478bd9Sstevel@tonic-gate }; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate extern struct keyboard keyindex_pc; 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate #define DRIVER_NAME(dip) ddi_driver_name(dip) 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate static char module_name[] = "kb8042"; 1567c478bd9Sstevel@tonic-gate 1577c478bd9Sstevel@tonic-gate static int kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, 1587c478bd9Sstevel@tonic-gate cred_t *credp); 1597c478bd9Sstevel@tonic-gate static int kb8042_close(queue_t *qp, int flag, cred_t *credp); 160*2888301aSToomas Soome static int kb8042_rsrv(queue_t *); 161*2888301aSToomas Soome static int kb8042_wsrv(queue_t *); 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate struct module_info kb8042_sinfo = { 164adc2b73dSToomas Soome .mi_idnum = 42, /* Module ID */ 165adc2b73dSToomas Soome .mi_idname = module_name, /* Module name */ 166adc2b73dSToomas Soome .mi_minpsz = 0, /* Minimum packet size */ 167adc2b73dSToomas Soome .mi_maxpsz = 32, /* Maximum packet size */ 168adc2b73dSToomas Soome .mi_hiwat = 256, /* High water mark */ 169adc2b73dSToomas Soome .mi_lowat = 128 /* Low water mark */ 1707c478bd9Sstevel@tonic-gate }; 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate static struct qinit kb8042_rinit = { 173adc2b73dSToomas Soome .qi_putp = NULL, 174*2888301aSToomas Soome .qi_srvp = kb8042_rsrv, 175adc2b73dSToomas Soome .qi_qopen = kb8042_open, 176adc2b73dSToomas Soome .qi_qclose = kb8042_close, 177adc2b73dSToomas Soome .qi_qadmin = NULL, 178adc2b73dSToomas Soome .qi_minfo = &kb8042_sinfo, 179adc2b73dSToomas Soome .qi_mstat = NULL, 180adc2b73dSToomas Soome .qi_rwp = NULL, 181adc2b73dSToomas Soome .qi_infop = NULL, 182adc2b73dSToomas Soome .qi_struiot = 0 1837c478bd9Sstevel@tonic-gate }; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate static struct qinit kb8042_winit = { 186adc2b73dSToomas Soome .qi_putp = putq, 187adc2b73dSToomas Soome .qi_srvp = kb8042_wsrv, 188adc2b73dSToomas Soome .qi_qopen = kb8042_open, 189adc2b73dSToomas Soome .qi_qclose = kb8042_close, 190adc2b73dSToomas Soome .qi_qadmin = NULL, 191adc2b73dSToomas Soome .qi_minfo = &kb8042_sinfo, 192adc2b73dSToomas Soome .qi_mstat = NULL, 193adc2b73dSToomas Soome .qi_rwp = NULL, 194adc2b73dSToomas Soome .qi_infop = NULL, 195adc2b73dSToomas Soome .qi_struiot = 0 1967c478bd9Sstevel@tonic-gate }; 1977c478bd9Sstevel@tonic-gate 198adc2b73dSToomas Soome struct streamtab kb8042_str_info = { 199adc2b73dSToomas Soome .st_rdinit = &kb8042_rinit, 200adc2b73dSToomas Soome .st_wrinit = &kb8042_winit, 201adc2b73dSToomas Soome .st_muxrinit = NULL, 202adc2b73dSToomas Soome .st_muxwinit = NULL 203adc2b73dSToomas Soome }; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate struct kb8042 Kdws = {0}; 206fd9cb95cSsethg static dev_info_t *kb8042_dip = NULL; 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate static int kb8042_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 2097c478bd9Sstevel@tonic-gate void **result); 2107c478bd9Sstevel@tonic-gate static int kb8042_attach(dev_info_t *, ddi_attach_cmd_t); 211fd9cb95cSsethg static int kb8042_detach(dev_info_t *, ddi_detach_cmd_t); 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate static struct cb_ops cb_kb8042_ops = { 214adc2b73dSToomas Soome .cb_open = nulldev, 215adc2b73dSToomas Soome .cb_close = nulldev, 216adc2b73dSToomas Soome .cb_strategy = nodev, 217adc2b73dSToomas Soome .cb_print = nodev, 218adc2b73dSToomas Soome .cb_dump = nodev, 219adc2b73dSToomas Soome .cb_read = nodev, 220adc2b73dSToomas Soome .cb_write = nodev, 221adc2b73dSToomas Soome .cb_ioctl = nodev, 222adc2b73dSToomas Soome .cb_devmap = nodev, 223adc2b73dSToomas Soome .cb_mmap = nodev, 224adc2b73dSToomas Soome .cb_segmap = nodev, 225adc2b73dSToomas Soome .cb_chpoll = nochpoll, 226adc2b73dSToomas Soome .cb_prop_op = ddi_prop_op, 227adc2b73dSToomas Soome .cb_str = &kb8042_str_info, 228adc2b73dSToomas Soome .cb_flag = D_MP, 229adc2b73dSToomas Soome .cb_rev = CB_REV, 230adc2b73dSToomas Soome .cb_aread = nodev, 231adc2b73dSToomas Soome .cb_awrite = nodev 2327c478bd9Sstevel@tonic-gate }; 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate struct dev_ops kb8042_ops = { 235adc2b73dSToomas Soome .devo_rev = DEVO_REV, 236adc2b73dSToomas Soome .devo_refcnt = 0, 237adc2b73dSToomas Soome .devo_getinfo = kb8042_getinfo, 238adc2b73dSToomas Soome .devo_identify = nulldev, 239adc2b73dSToomas Soome .devo_probe = nulldev, 240adc2b73dSToomas Soome .devo_attach = kb8042_attach, 241adc2b73dSToomas Soome .devo_detach = kb8042_detach, 242adc2b73dSToomas Soome .devo_reset = nodev, 243adc2b73dSToomas Soome .devo_cb_ops = &cb_kb8042_ops, 244adc2b73dSToomas Soome .devo_bus_ops = NULL, 245adc2b73dSToomas Soome .devo_power = NULL, 246adc2b73dSToomas Soome .devo_quiesce = ddi_quiesce_not_needed 2477c478bd9Sstevel@tonic-gate }; 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate /* 2517c478bd9Sstevel@tonic-gate * This is the loadable module wrapper. 2527c478bd9Sstevel@tonic-gate */ 2537c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate /* 2567c478bd9Sstevel@tonic-gate * Module linkage information for the kernel. 2577c478bd9Sstevel@tonic-gate */ 2587c478bd9Sstevel@tonic-gate static struct modldrv modldrv = { 259adc2b73dSToomas Soome .drv_modops = &mod_driverops, /* Type of module. */ 260adc2b73dSToomas Soome .drv_linkinfo = "PS/2 keyboard driver", 261adc2b73dSToomas Soome .drv_dev_ops = &kb8042_ops, /* driver ops */ 2627c478bd9Sstevel@tonic-gate }; 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = { 265adc2b73dSToomas Soome .ml_rev = MODREV_1, 266adc2b73dSToomas Soome .ml_linkage = { &modldrv, NULL } 2677c478bd9Sstevel@tonic-gate }; 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate int 2707c478bd9Sstevel@tonic-gate _init(void) 2717c478bd9Sstevel@tonic-gate { 2727c478bd9Sstevel@tonic-gate int rv; 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate rv = mod_install(&modlinkage); 2757c478bd9Sstevel@tonic-gate return (rv); 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate int 2807c478bd9Sstevel@tonic-gate _fini(void) 2817c478bd9Sstevel@tonic-gate { 2827c478bd9Sstevel@tonic-gate return (mod_remove(&modlinkage)); 2837c478bd9Sstevel@tonic-gate } 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate int 2867c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop) 2877c478bd9Sstevel@tonic-gate { 2887c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop)); 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 291fd9cb95cSsethg #ifdef __sparc 292fd9cb95cSsethg static boolean_t 293fd9cb95cSsethg kb8042_is_input_avail(struct kb8042 *kb8042, int timeout_usec, boolean_t polled) 294fd9cb95cSsethg { 295fd9cb95cSsethg int i; 296fd9cb95cSsethg int port = (polled == B_TRUE) ? I8042_POLL_INPUT_AVAIL : 297fd9cb95cSsethg I8042_INT_INPUT_AVAIL; 298fd9cb95cSsethg int reps = timeout_usec / USECS_PER_WAIT; 299fd9cb95cSsethg 300fd9cb95cSsethg for (i = 0; i < reps; i++) { 301fd9cb95cSsethg if (ddi_get8(kb8042->handle, kb8042->addr + port) != 0) 302fd9cb95cSsethg return (B_TRUE); 303fd9cb95cSsethg 304fd9cb95cSsethg if (i < (reps - 1)) 305fd9cb95cSsethg drv_usecwait(USECS_PER_WAIT); 306fd9cb95cSsethg } 307fd9cb95cSsethg return (B_FALSE); 308fd9cb95cSsethg } 309fd9cb95cSsethg 310fd9cb95cSsethg static void 311fd9cb95cSsethg kb8042_clear_input_buffer(struct kb8042 *kb8042, boolean_t polled) 312fd9cb95cSsethg { 313fd9cb95cSsethg int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA : 314fd9cb95cSsethg I8042_INT_INPUT_DATA; 315fd9cb95cSsethg 316fd9cb95cSsethg while (kb8042_is_input_avail(kb8042, MIN_DELAY_USECS, polled)) { 317fd9cb95cSsethg (void) ddi_get8(kb8042->handle, kb8042->addr + port); 318fd9cb95cSsethg } 319fd9cb95cSsethg } 320fd9cb95cSsethg 32115bfc6b7SSeth Goldberg /* 32215bfc6b7SSeth Goldberg * kb8042_send_and_expect does all its I/O via polling interfaces 32315bfc6b7SSeth Goldberg */ 324fd9cb95cSsethg static boolean_t 325fd9cb95cSsethg kb8042_send_and_expect(struct kb8042 *kb8042, uint8_t send, uint8_t expect, 32615bfc6b7SSeth Goldberg int timeout, int *error, uint8_t *got) 327fd9cb95cSsethg { 328fd9cb95cSsethg uint8_t datab; 329fd9cb95cSsethg int err; 330fd9cb95cSsethg boolean_t rval; 331fd9cb95cSsethg 33215bfc6b7SSeth Goldberg ddi_put8(kb8042->handle, 33315bfc6b7SSeth Goldberg kb8042->addr + I8042_POLL_OUTPUT_DATA, send); 334fd9cb95cSsethg 33515bfc6b7SSeth Goldberg if (kb8042_is_input_avail(kb8042, timeout, B_TRUE)) { 336fd9cb95cSsethg err = 0; 33715bfc6b7SSeth Goldberg datab = ddi_get8(kb8042->handle, 33815bfc6b7SSeth Goldberg kb8042->addr + I8042_POLL_INPUT_DATA); 339fd9cb95cSsethg rval = ((datab == expect) ? B_TRUE : B_FALSE); 340fd9cb95cSsethg } else { 341fd9cb95cSsethg err = EAGAIN; 342fd9cb95cSsethg rval = B_FALSE; 343fd9cb95cSsethg } 344fd9cb95cSsethg 345fd9cb95cSsethg if (error != NULL) 346fd9cb95cSsethg *error = err; 347fd9cb95cSsethg if (got != NULL) 348fd9cb95cSsethg *got = datab; 349fd9cb95cSsethg return (rval); 350fd9cb95cSsethg } 351fd9cb95cSsethg 352fd9cb95cSsethg static const char * 353fd9cb95cSsethg kb8042_error_string(int errcode) 354fd9cb95cSsethg { 355fd9cb95cSsethg switch (errcode) { 356fd9cb95cSsethg case EAGAIN: 357fd9cb95cSsethg return ("Timed out"); 358fd9cb95cSsethg default: 359fd9cb95cSsethg return ("Unknown error"); 360fd9cb95cSsethg } 361fd9cb95cSsethg } 362fd9cb95cSsethg 36315bfc6b7SSeth Goldberg /* 36415bfc6b7SSeth Goldberg * kb8042_read_scanset works properly because it is called before ddi_add_intr 36515bfc6b7SSeth Goldberg * (if it is called after ddi_add_intr, i8042_intr would call kb8042_intr 36615bfc6b7SSeth Goldberg * instead of just storing the data that comes in from the keyboard, which 36715bfc6b7SSeth Goldberg * would prevent the code here from getting it.) 36815bfc6b7SSeth Goldberg */ 369fd9cb95cSsethg static int 37015bfc6b7SSeth Goldberg kb8042_read_scanset(struct kb8042 *kb8042) 371fd9cb95cSsethg { 372fd9cb95cSsethg int scanset = -1; 373fd9cb95cSsethg int err; 374fd9cb95cSsethg uint8_t got; 375fd9cb95cSsethg 376fd9cb95cSsethg kb8042_clear_input_buffer(kb8042, B_TRUE); 377fd9cb95cSsethg 378fd9cb95cSsethg /* 379fd9cb95cSsethg * Send a "change scan code set" command to the keyboard. 380fd9cb95cSsethg * It should respond with an ACK. 381fd9cb95cSsethg */ 38215bfc6b7SSeth Goldberg if (kb8042_send_and_expect(kb8042, KB_SET_SCAN, KB_ACK, MAX_WAIT_USECS, 38315bfc6b7SSeth Goldberg &err, &got) != B_TRUE) { 384fd9cb95cSsethg goto fail_read_scanset; 385fd9cb95cSsethg } 386fd9cb95cSsethg 387fd9cb95cSsethg /* 388bb2d7d5eSSeth Goldberg * Send a 0. The keyboard should ACK the 0, then it should send the 389bb2d7d5eSSeth Goldberg * scan code set in use. 390fd9cb95cSsethg */ 39115bfc6b7SSeth Goldberg if (kb8042_send_and_expect(kb8042, 0, KB_ACK, MAX_WAIT_USECS, &err, 39215bfc6b7SSeth Goldberg &got) != B_TRUE) { 393fd9cb95cSsethg goto fail_read_scanset; 394fd9cb95cSsethg } 395fd9cb95cSsethg 396fd9cb95cSsethg /* 397fd9cb95cSsethg * The next input byte from the keyboard should be the scan code 398fd9cb95cSsethg * set in use, though some keyboards like to send a few more acks 399fd9cb95cSsethg * just for fun, so blow past those to get the keyboard scan code. 400fd9cb95cSsethg */ 401fd9cb95cSsethg while (kb8042_is_input_avail(kb8042, MAX_WAIT_USECS, B_TRUE) && 40215bfc6b7SSeth Goldberg (scanset = ddi_get8(kb8042->handle, 40315bfc6b7SSeth Goldberg kb8042->addr + I8042_POLL_INPUT_DATA)) == KB_ACK) 404fd9cb95cSsethg ; 405fd9cb95cSsethg 40615bfc6b7SSeth Goldberg #ifdef DEBUG 407fd9cb95cSsethg cmn_err(CE_NOTE, "!Scan code set from keyboard is `%d'.", 408fd9cb95cSsethg scanset); 409fd9cb95cSsethg #endif 410fd9cb95cSsethg 411fd9cb95cSsethg return (scanset); 412fd9cb95cSsethg 413fd9cb95cSsethg fail_read_scanset: 41415bfc6b7SSeth Goldberg #ifdef DEBUG 415fd9cb95cSsethg if (err == 0) 416fd9cb95cSsethg cmn_err(CE_NOTE, "Could not read current scan set from " 417fd9cb95cSsethg "keyboard: %s. (Expected 0x%x, but got 0x%x).", 418fd9cb95cSsethg kb8042_error_string(err), KB_ACK, got); 419fd9cb95cSsethg else 420fd9cb95cSsethg cmn_err(CE_NOTE, "Could not read current scan set from " 421fd9cb95cSsethg "keyboard: %s.", kb8042_error_string(err)); 422fd9cb95cSsethg #endif 423fd9cb95cSsethg return (-1); 424fd9cb95cSsethg } 425fd9cb95cSsethg #endif 426fd9cb95cSsethg 4277c478bd9Sstevel@tonic-gate static int 4287c478bd9Sstevel@tonic-gate kb8042_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 4297c478bd9Sstevel@tonic-gate { 4307c478bd9Sstevel@tonic-gate int rc; 431fd9cb95cSsethg int scanset; 432fd9cb95cSsethg int leds; 4337c478bd9Sstevel@tonic-gate 434fd9cb95cSsethg struct kb8042 *kb8042 = &Kdws; 4357c478bd9Sstevel@tonic-gate static ddi_device_acc_attr_t attr = { 4367c478bd9Sstevel@tonic-gate DDI_DEVICE_ATTR_V0, 4377c478bd9Sstevel@tonic-gate DDI_NEVERSWAP_ACC, 4387c478bd9Sstevel@tonic-gate DDI_STRICTORDER_ACC, 4397c478bd9Sstevel@tonic-gate }; 4407c478bd9Sstevel@tonic-gate 441fd9cb95cSsethg switch (cmd) { 442fd9cb95cSsethg case DDI_RESUME: 443fd9cb95cSsethg leds = kb8042->leds.commanded; 444fd9cb95cSsethg kb8042->w_init = 0; 445fd9cb95cSsethg kb8042_init(kb8042, B_TRUE); 446fd9cb95cSsethg kb8042_setled(kb8042, leds, B_FALSE); 4472df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 4482df1fe9cSrandyf kb8042->suspended = B_FALSE; 4492df1fe9cSrandyf if (kb8042->w_qp != NULL) { 4502df1fe9cSrandyf enableok(WR(kb8042->w_qp)); 4512df1fe9cSrandyf qenable(WR(kb8042->w_qp)); 4522df1fe9cSrandyf } 4532df1fe9cSrandyf cv_broadcast(&kb8042->suspend_cv); 4542df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 455fd9cb95cSsethg return (DDI_SUCCESS); 456fd9cb95cSsethg 457fd9cb95cSsethg case DDI_ATTACH: 458fd9cb95cSsethg if (kb8042_dip != NULL) 4597c478bd9Sstevel@tonic-gate return (DDI_FAILURE); 460fd9cb95cSsethg /* The rest of the function is for attach */ 461fd9cb95cSsethg break; 4627c478bd9Sstevel@tonic-gate 463fd9cb95cSsethg default: 464fd9cb95cSsethg return (DDI_FAILURE); 465fd9cb95cSsethg } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate kb8042->debugger.mod1 = 58; /* Left Ctrl */ 4687c478bd9Sstevel@tonic-gate kb8042->debugger.mod2 = 60; /* Left Alt */ 4697c478bd9Sstevel@tonic-gate kb8042->debugger.trigger = 33; /* D */ 4707c478bd9Sstevel@tonic-gate kb8042->debugger.mod1_down = B_FALSE; 4717c478bd9Sstevel@tonic-gate kb8042->debugger.mod2_down = B_FALSE; 4727c478bd9Sstevel@tonic-gate kb8042->debugger.enabled = B_FALSE; 4737c478bd9Sstevel@tonic-gate 474fd9cb95cSsethg kb8042_dip = devi; 475fd9cb95cSsethg kb8042->init_state = KB8042_UNINITIALIZED; 476fd9cb95cSsethg 4777c478bd9Sstevel@tonic-gate kb8042->polled_synthetic_release_pending = B_FALSE; 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate if (ddi_create_minor_node(devi, module_name, S_IFCHR, 0, 4807c478bd9Sstevel@tonic-gate DDI_NT_KEYBOARD, 0) == DDI_FAILURE) { 481fd9cb95cSsethg goto failure; 4827c478bd9Sstevel@tonic-gate } 483fd9cb95cSsethg 484fd9cb95cSsethg kb8042->init_state |= KB8042_MINOR_NODE_CREATED; 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate rc = ddi_regs_map_setup(devi, 0, (caddr_t *)&kb8042->addr, 4877c478bd9Sstevel@tonic-gate (offset_t)0, (offset_t)0, &attr, &kb8042->handle); 4887c478bd9Sstevel@tonic-gate if (rc != DDI_SUCCESS) { 48915bfc6b7SSeth Goldberg #ifdef DEBUG 4907c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kb8042_attach: can't map registers"); 4917c478bd9Sstevel@tonic-gate #endif 492fd9cb95cSsethg goto failure; 4937c478bd9Sstevel@tonic-gate } 4947c478bd9Sstevel@tonic-gate 495fd9cb95cSsethg kb8042->init_state |= KB8042_REGS_MAPPED; 496fd9cb95cSsethg 4977c478bd9Sstevel@tonic-gate if (ddi_get_iblock_cookie(devi, 0, &kb8042->w_iblock) != 4987c478bd9Sstevel@tonic-gate DDI_SUCCESS) { 4997c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kb8042_attach: Can't get iblock cookie"); 500fd9cb95cSsethg goto failure; 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate mutex_init(&kb8042->w_hw_mutex, NULL, MUTEX_DRIVER, kb8042->w_iblock); 5042df1fe9cSrandyf cv_init(&kb8042->ops_cv, NULL, CV_DRIVER, NULL); 5052df1fe9cSrandyf cv_init(&kb8042->suspend_cv, NULL, CV_DRIVER, NULL); 50615bfc6b7SSeth Goldberg cv_init(&kb8042->cmd_cv, NULL, CV_DRIVER, NULL); 507fd9cb95cSsethg kb8042->init_state |= KB8042_HW_MUTEX_INITTED; 508fd9cb95cSsethg 509fd9cb95cSsethg kb8042_init(kb8042, B_FALSE); 510fd9cb95cSsethg 511fd9cb95cSsethg #ifdef __sparc 512fd9cb95cSsethg /* Detect the scan code set currently in use */ 51315bfc6b7SSeth Goldberg scanset = kb8042_read_scanset(kb8042); 514fd9cb95cSsethg 515fd9cb95cSsethg if (scanset < 0 && kb8042_warn_unknown_scanset) { 516fd9cb95cSsethg 517fd9cb95cSsethg cmn_err(CE_WARN, "Cannot determine keyboard scan code set "); 518fd9cb95cSsethg cmn_err(CE_CONT, "(is the keyboard plugged in?). "); 519fd9cb95cSsethg cmn_err(CE_CONT, "Defaulting to scan code set %d. If the " 520fd9cb95cSsethg "keyboard does not ", kb8042_default_scanset); 521fd9cb95cSsethg cmn_err(CE_CONT, "work properly, add " 522fd9cb95cSsethg "`set kb8042:kb8042_default_scanset=%d' to /etc/system ", 523fd9cb95cSsethg (kb8042_default_scanset == 1) ? 2 : 1); 524fd9cb95cSsethg cmn_err(CE_CONT, "(via network or with a USB keyboard) and " 525fd9cb95cSsethg "restart the system. If you "); 526fd9cb95cSsethg cmn_err(CE_CONT, "do not want to see this message in the " 527fd9cb95cSsethg "future, add "); 528fd9cb95cSsethg cmn_err(CE_CONT, "`set kb8042:kb8042_warn_unknown_scanset=0' " 529fd9cb95cSsethg "to /etc/system.\n"); 530fd9cb95cSsethg 531fd9cb95cSsethg /* Use the default scan code set. */ 532fd9cb95cSsethg scanset = kb8042_default_scanset; 533fd9cb95cSsethg } 534fd9cb95cSsethg #else 535fd9cb95cSsethg /* x86 systems use scan code set 1 -- no detection required */ 536fd9cb95cSsethg scanset = 1; 537fd9cb95cSsethg #endif 538fd9cb95cSsethg if (KeyboardConvertScan_init(kb8042, scanset) != DDI_SUCCESS) { 539fd9cb95cSsethg cmn_err(CE_WARN, "Cannot initialize keyboard scan converter: " 540fd9cb95cSsethg "Unknown scan code set `%d'.", scanset); 541fd9cb95cSsethg /* Scan code set is not supported */ 542fd9cb95cSsethg goto failure; 543fd9cb95cSsethg } 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate /* 5467c478bd9Sstevel@tonic-gate * Turn on interrupts... 5477c478bd9Sstevel@tonic-gate */ 5487c478bd9Sstevel@tonic-gate if (ddi_add_intr(devi, 0, 5497c478bd9Sstevel@tonic-gate &kb8042->w_iblock, (ddi_idevice_cookie_t *)NULL, 5507c478bd9Sstevel@tonic-gate kb8042_intr, (caddr_t)kb8042) != DDI_SUCCESS) { 5517c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "kb8042_attach: cannot add interrupt"); 552fd9cb95cSsethg goto failure; 5537c478bd9Sstevel@tonic-gate } 5547c478bd9Sstevel@tonic-gate 555fd9cb95cSsethg kb8042->init_state |= KB8042_INTR_ADDED; 556fd9cb95cSsethg 5577c478bd9Sstevel@tonic-gate ddi_report_dev(devi); 558fd9cb95cSsethg 55915bfc6b7SSeth Goldberg #ifdef DEBUG 560bb2d7d5eSSeth Goldberg cmn_err(CE_CONT, "?%s instance #%d READY\n", 56119397407SSherry Moore DRIVER_NAME(devi), ddi_get_instance(devi)); 5627c478bd9Sstevel@tonic-gate #endif 563fd9cb95cSsethg 5647c478bd9Sstevel@tonic-gate return (DDI_SUCCESS); 565fd9cb95cSsethg 566fd9cb95cSsethg failure: 567fd9cb95cSsethg kb8042_cleanup(kb8042); 568fd9cb95cSsethg return (DDI_FAILURE); 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 571fd9cb95cSsethg static int 572fd9cb95cSsethg kb8042_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 573fd9cb95cSsethg { 574fd9cb95cSsethg struct kb8042 *kb8042 = &Kdws; 575fd9cb95cSsethg 576fd9cb95cSsethg switch (cmd) { 577fd9cb95cSsethg case DDI_SUSPEND: 5782df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 5792df1fe9cSrandyf ASSERT(kb8042->ops >= 0); 5802df1fe9cSrandyf while (kb8042->ops > 0) 5812df1fe9cSrandyf cv_wait(&kb8042->ops_cv, &kb8042->w_hw_mutex); 5822df1fe9cSrandyf kb8042->suspended = B_TRUE; 5832df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 584fd9cb95cSsethg return (DDI_SUCCESS); 585fd9cb95cSsethg 586fd9cb95cSsethg case DDI_DETACH: 587fd9cb95cSsethg /* If someone has a stream open, fail to detach */ 588fd9cb95cSsethg if (kb8042->w_qp != NULL) 589fd9cb95cSsethg return (DDI_FAILURE); 590fd9cb95cSsethg 591fd9cb95cSsethg ASSERT(kb8042_dip == dip); 592fd9cb95cSsethg 593fd9cb95cSsethg kb8042_cleanup(kb8042); 594fd9cb95cSsethg 595fd9cb95cSsethg return (DDI_SUCCESS); 596fd9cb95cSsethg 597fd9cb95cSsethg default: 598fd9cb95cSsethg return (DDI_FAILURE); 599fd9cb95cSsethg } 600fd9cb95cSsethg } 601fd9cb95cSsethg 6027c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6037c478bd9Sstevel@tonic-gate static int 6047c478bd9Sstevel@tonic-gate kb8042_getinfo( 6057c478bd9Sstevel@tonic-gate dev_info_t *dip, 6067c478bd9Sstevel@tonic-gate ddi_info_cmd_t infocmd, 6077c478bd9Sstevel@tonic-gate void *arg, 6087c478bd9Sstevel@tonic-gate void **result) 6097c478bd9Sstevel@tonic-gate { 6107c478bd9Sstevel@tonic-gate register int error; 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate switch (infocmd) { 6137c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2DEVINFO: 6147c478bd9Sstevel@tonic-gate if (kb8042_dip == NULL) { 6157c478bd9Sstevel@tonic-gate error = DDI_FAILURE; 6167c478bd9Sstevel@tonic-gate } else { 6177c478bd9Sstevel@tonic-gate *result = (void *) kb8042_dip; 6187c478bd9Sstevel@tonic-gate error = DDI_SUCCESS; 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate break; 6217c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2INSTANCE: 6227c478bd9Sstevel@tonic-gate *result = (void *)0; 6237c478bd9Sstevel@tonic-gate error = DDI_SUCCESS; 6247c478bd9Sstevel@tonic-gate break; 6257c478bd9Sstevel@tonic-gate default: 6267c478bd9Sstevel@tonic-gate error = DDI_FAILURE; 6277c478bd9Sstevel@tonic-gate break; 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate return (error); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate static void 633fd9cb95cSsethg kb8042_cleanup(struct kb8042 *kb8042) 634fd9cb95cSsethg { 6350eccbe1bSsethg ASSERT(kb8042_dip != NULL); 636fd9cb95cSsethg 63715bfc6b7SSeth Goldberg if (kb8042->init_state & KB8042_INTR_ADDED) 63815bfc6b7SSeth Goldberg ddi_remove_intr(kb8042_dip, 0, kb8042->w_iblock); 63915bfc6b7SSeth Goldberg 6402df1fe9cSrandyf if (kb8042->init_state & KB8042_HW_MUTEX_INITTED) { 64115bfc6b7SSeth Goldberg cv_destroy(&kb8042->cmd_cv); 6422df1fe9cSrandyf cv_destroy(&kb8042->suspend_cv); 6432df1fe9cSrandyf cv_destroy(&kb8042->ops_cv); 644fd9cb95cSsethg mutex_destroy(&kb8042->w_hw_mutex); 6452df1fe9cSrandyf } 646fd9cb95cSsethg 647fd9cb95cSsethg if (kb8042->init_state & KB8042_REGS_MAPPED) 648fd9cb95cSsethg ddi_regs_map_free(&kb8042->handle); 649fd9cb95cSsethg 650fd9cb95cSsethg if (kb8042->init_state & KB8042_MINOR_NODE_CREATED) 651fd9cb95cSsethg ddi_remove_minor_node(kb8042_dip, NULL); 652fd9cb95cSsethg 653fd9cb95cSsethg kb8042->init_state = KB8042_UNINITIALIZED; 6540eccbe1bSsethg kb8042_dip = NULL; 655fd9cb95cSsethg } 656fd9cb95cSsethg 657fd9cb95cSsethg static void 658fd9cb95cSsethg kb8042_init(struct kb8042 *kb8042, boolean_t from_resume) 6597c478bd9Sstevel@tonic-gate { 6607c478bd9Sstevel@tonic-gate if (kb8042->w_init) 6617c478bd9Sstevel@tonic-gate return; 6627c478bd9Sstevel@tonic-gate 663fd9cb95cSsethg if (!from_resume) { 6647c478bd9Sstevel@tonic-gate kb8042->w_kblayout = 0; /* Default to US */ 6657c478bd9Sstevel@tonic-gate kb8042->w_qp = (queue_t *)NULL; 666fd9cb95cSsethg kb8042->simulated_kbd_type = KB_PC; 667fd9cb95cSsethg kb8042->leds.commanded = -1; /* Unknown initial state */ 668fd9cb95cSsethg kb8042->leds.desired = -1; /* Unknown initial state */ 669fd9cb95cSsethg } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate kb8042_wait_poweron(kb8042); 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate kb8042->kb_old_key_pos = 0; 6747c478bd9Sstevel@tonic-gate 67515bfc6b7SSeth Goldberg /* 67615bfc6b7SSeth Goldberg * Explicitly grab and release the 8042 lock outside of 67715bfc6b7SSeth Goldberg * kb8042_send_to_keyboard, because this is the only situation 67815bfc6b7SSeth Goldberg * where a polling interface is used with locking required. 67915bfc6b7SSeth Goldberg */ 68015bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + I8042_LOCK); 6817c478bd9Sstevel@tonic-gate /* Set up the command state machine and start it running. */ 68215bfc6b7SSeth Goldberg kb8042_send_to_keyboard(kb8042, KB_ENABLE, B_TRUE); 68315bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + I8042_UNLOCK); 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate kb8042->w_init++; 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate (void) drv_setparm(SYSRINT, 1); /* reset keyboard interrupts */ 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate /*ARGSUSED2*/ 6917c478bd9Sstevel@tonic-gate static int 6927c478bd9Sstevel@tonic-gate kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, cred_t *credp) 6937c478bd9Sstevel@tonic-gate { 6947c478bd9Sstevel@tonic-gate struct kb8042 *kb8042; 695cd2135d0Spengcheng chen - Sun Microsystems - Beijing China int err = 0; 6967c478bd9Sstevel@tonic-gate int initial_leds; 6977c478bd9Sstevel@tonic-gate int initial_led_mask; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate kb8042 = &Kdws; 7007c478bd9Sstevel@tonic-gate 7012df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 702cd2135d0Spengcheng chen - Sun Microsystems - Beijing China if (qp->q_ptr) { 703cd2135d0Spengcheng chen - Sun Microsystems - Beijing China kb8042->w_dev = *devp; 704cd2135d0Spengcheng chen - Sun Microsystems - Beijing China mutex_exit(&kb8042->w_hw_mutex); 705cd2135d0Spengcheng chen - Sun Microsystems - Beijing China return (0); 706cd2135d0Spengcheng chen - Sun Microsystems - Beijing China } 707cd2135d0Spengcheng chen - Sun Microsystems - Beijing China 708cd2135d0Spengcheng chen - Sun Microsystems - Beijing China if (secpolicy_console(credp) != 0) { 709cd2135d0Spengcheng chen - Sun Microsystems - Beijing China mutex_exit(&kb8042->w_hw_mutex); 710cd2135d0Spengcheng chen - Sun Microsystems - Beijing China return (EPERM); 711cd2135d0Spengcheng chen - Sun Microsystems - Beijing China } 712cd2135d0Spengcheng chen - Sun Microsystems - Beijing China 7132df1fe9cSrandyf while (kb8042->suspended) { 7142df1fe9cSrandyf if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) == 7152df1fe9cSrandyf 0) { 7162df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 7172df1fe9cSrandyf return (EINTR); 7182df1fe9cSrandyf } 7192df1fe9cSrandyf } 7202df1fe9cSrandyf 7217c478bd9Sstevel@tonic-gate kb8042->w_dev = *devp; 7227c478bd9Sstevel@tonic-gate qp->q_ptr = (caddr_t)kb8042; 7237c478bd9Sstevel@tonic-gate WR(qp)->q_ptr = qp->q_ptr; 7247c478bd9Sstevel@tonic-gate if (!kb8042->w_qp) 7257c478bd9Sstevel@tonic-gate kb8042->w_qp = qp; 7267c478bd9Sstevel@tonic-gate 7272df1fe9cSrandyf ASSERT(kb8042->ops >= 0); 7282df1fe9cSrandyf kb8042->ops++; 7292df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 7302df1fe9cSrandyf 7317c478bd9Sstevel@tonic-gate kb8042_get_initial_leds(kb8042, &initial_leds, &initial_led_mask); 732cd2135d0Spengcheng chen - Sun Microsystems - Beijing China err = kbtrans_streams_init(qp, sflag, 7337c478bd9Sstevel@tonic-gate (struct kbtrans_hardware *)kb8042, &kb8042_callbacks, 7347c478bd9Sstevel@tonic-gate &kb8042->hw_kbtrans, 7357c478bd9Sstevel@tonic-gate initial_leds, initial_led_mask); 7367c478bd9Sstevel@tonic-gate if (err != 0) 737cd2135d0Spengcheng chen - Sun Microsystems - Beijing China goto out; 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate kbtrans_streams_set_keyboard(kb8042->hw_kbtrans, KB_PC, &keyindex_pc); 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_version = CONSPOLLEDIO_V1; 7427c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_argument = 743281f0747Slt200341 (cons_polledio_arg_t)kb8042; 7447c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_putchar = NULL; 7457c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_getchar = 746281f0747Slt200341 (int (*)(cons_polledio_arg_t))kb8042_polled_getchar; 7477c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_ischar = 748281f0747Slt200341 (boolean_t (*)(cons_polledio_arg_t))kb8042_polled_ischar; 7497c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_enter = NULL; 7507c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_exit = NULL; 7517c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_setled = 752281f0747Slt200341 (void (*)(cons_polledio_arg_t, int))kb8042_polled_setled; 7537c478bd9Sstevel@tonic-gate kb8042->polledio.cons_polledio_keycheck = 754281f0747Slt200341 (boolean_t (*)(cons_polledio_arg_t, int *, 7557c478bd9Sstevel@tonic-gate enum keystate *))kb8042_polled_keycheck; 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate qprocson(qp); 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate kbtrans_streams_enable(kb8042->hw_kbtrans); 7607c478bd9Sstevel@tonic-gate 761cd2135d0Spengcheng chen - Sun Microsystems - Beijing China out: 7622df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 7632df1fe9cSrandyf ASSERT(kb8042->ops > 0); 7642df1fe9cSrandyf kb8042->ops--; 7652df1fe9cSrandyf if (kb8042->ops == 0) 7662df1fe9cSrandyf cv_broadcast(&kb8042->ops_cv); 7672df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 7682df1fe9cSrandyf 769cd2135d0Spengcheng chen - Sun Microsystems - Beijing China return (err); 7707c478bd9Sstevel@tonic-gate } 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate /*ARGSUSED1*/ 7737c478bd9Sstevel@tonic-gate static int 7747c478bd9Sstevel@tonic-gate kb8042_close(queue_t *qp, int flag, cred_t *credp) 7757c478bd9Sstevel@tonic-gate { 7767c478bd9Sstevel@tonic-gate struct kb8042 *kb8042; 7777c478bd9Sstevel@tonic-gate 778c35aa225Smarx /* If a beep is in progress, stop that */ 779c35aa225Smarx (void) beeper_off(); 780c35aa225Smarx 7817c478bd9Sstevel@tonic-gate kb8042 = (struct kb8042 *)qp->q_ptr; 7827c478bd9Sstevel@tonic-gate 7832df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 7842df1fe9cSrandyf while (kb8042->suspended) { 7852df1fe9cSrandyf if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) == 7862df1fe9cSrandyf 0) { 7872df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 7882df1fe9cSrandyf return (EINTR); 7892df1fe9cSrandyf } 7902df1fe9cSrandyf } 7912df1fe9cSrandyf 7922df1fe9cSrandyf ASSERT(kb8042->ops >= 0); 7932df1fe9cSrandyf kb8042->ops++; 7942df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 7952df1fe9cSrandyf 796e1fec4f9Sry162471 (void) kbtrans_streams_fini(kb8042->hw_kbtrans); 797e1fec4f9Sry162471 7987c478bd9Sstevel@tonic-gate kb8042->w_qp = (queue_t *)NULL; 7997c478bd9Sstevel@tonic-gate qprocsoff(qp); 8007c478bd9Sstevel@tonic-gate 8012df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 8022df1fe9cSrandyf ASSERT(kb8042->ops > 0); 8032df1fe9cSrandyf kb8042->ops--; 8042df1fe9cSrandyf if (kb8042->ops == 0) 8052df1fe9cSrandyf cv_broadcast(&kb8042->ops_cv); 8062df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 8072df1fe9cSrandyf 8087c478bd9Sstevel@tonic-gate return (0); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate static int 812*2888301aSToomas Soome kb8042_rsrv(queue_t *qp) 813*2888301aSToomas Soome { 814*2888301aSToomas Soome mblk_t *mp; 815*2888301aSToomas Soome struct kb8042 *kb8042; 816*2888301aSToomas Soome 817*2888301aSToomas Soome while ((mp = getq(qp)) != NULL) { 818*2888301aSToomas Soome if (mp->b_datap->db_type == M_DATA) { 819*2888301aSToomas Soome kb8042 = (struct kb8042 *)qp->q_ptr; 820*2888301aSToomas Soome kb8042_received_byte(kb8042, *mp->b_rptr); 821*2888301aSToomas Soome } 822*2888301aSToomas Soome freemsg(mp); 823*2888301aSToomas Soome } 824*2888301aSToomas Soome return (0); 825*2888301aSToomas Soome } 826*2888301aSToomas Soome 827*2888301aSToomas Soome static int 8287c478bd9Sstevel@tonic-gate kb8042_wsrv(queue_t *qp) 8297c478bd9Sstevel@tonic-gate { 8307c478bd9Sstevel@tonic-gate struct kb8042 *kb8042; 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate mblk_t *mp; 8332df1fe9cSrandyf boolean_t suspended; 8347c478bd9Sstevel@tonic-gate 8357c478bd9Sstevel@tonic-gate kb8042 = (struct kb8042 *)qp->q_ptr; 8367c478bd9Sstevel@tonic-gate 8372df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 8382df1fe9cSrandyf suspended = kb8042->suspended; 8392df1fe9cSrandyf ASSERT(kb8042->ops >= 0); 8402df1fe9cSrandyf if (!suspended) 8412df1fe9cSrandyf kb8042->ops++; 8422df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 8432df1fe9cSrandyf 8442df1fe9cSrandyf #ifdef NO_KB_DEBUG 8452df1fe9cSrandyf while (!suspended && (mp = getq(qp)) != NULL) { 8462df1fe9cSrandyf #else 8472df1fe9cSrandyf /* 8482df1fe9cSrandyf * Not taking keyboard input while suspending can make debugging 8492df1fe9cSrandyf * difficult. However, we still do the ops counting so that we 8502df1fe9cSrandyf * don't suspend at a bad time. 8512df1fe9cSrandyf */ 8527c478bd9Sstevel@tonic-gate while ((mp = getq(qp))) { 8532df1fe9cSrandyf #endif 8547c478bd9Sstevel@tonic-gate switch (kbtrans_streams_message(kb8042->hw_kbtrans, mp)) { 8557c478bd9Sstevel@tonic-gate case KBTRANS_MESSAGE_HANDLED: 8567c478bd9Sstevel@tonic-gate continue; 8577c478bd9Sstevel@tonic-gate case KBTRANS_MESSAGE_NOT_HANDLED: 8587c478bd9Sstevel@tonic-gate break; 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) { 8617c478bd9Sstevel@tonic-gate case M_IOCTL: 8627c478bd9Sstevel@tonic-gate kb8042_ioctlmsg(kb8042, qp, mp); 8637c478bd9Sstevel@tonic-gate continue; 8647c478bd9Sstevel@tonic-gate case M_IOCDATA: 8657c478bd9Sstevel@tonic-gate kb8042_iocdatamsg(qp, mp); 8667c478bd9Sstevel@tonic-gate continue; 8677c478bd9Sstevel@tonic-gate case M_DELAY: 8687c478bd9Sstevel@tonic-gate case M_STARTI: 8697c478bd9Sstevel@tonic-gate case M_STOPI: 8707c478bd9Sstevel@tonic-gate case M_READ: /* ignore, no buffered data */ 8717c478bd9Sstevel@tonic-gate freemsg(mp); 8727c478bd9Sstevel@tonic-gate continue; 8737c478bd9Sstevel@tonic-gate case M_FLUSH: 8747c478bd9Sstevel@tonic-gate *mp->b_rptr &= ~FLUSHW; 8757c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) 8767c478bd9Sstevel@tonic-gate qreply(qp, mp); 8777c478bd9Sstevel@tonic-gate else 8787c478bd9Sstevel@tonic-gate freemsg(mp); 8797c478bd9Sstevel@tonic-gate continue; 8807c478bd9Sstevel@tonic-gate default: 8817c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "kb8042_wsrv: bad msg %x", 8827c478bd9Sstevel@tonic-gate mp->b_datap->db_type); 8837c478bd9Sstevel@tonic-gate freemsg(mp); 8847c478bd9Sstevel@tonic-gate continue; 8857c478bd9Sstevel@tonic-gate } 8867c478bd9Sstevel@tonic-gate } 8872df1fe9cSrandyf 8882df1fe9cSrandyf mutex_enter(&kb8042->w_hw_mutex); 8892df1fe9cSrandyf if (!suspended) { 8902df1fe9cSrandyf ASSERT(kb8042->ops > 0); 8912df1fe9cSrandyf kb8042->ops--; 8922df1fe9cSrandyf if (kb8042->ops == 0) 8932df1fe9cSrandyf cv_broadcast(&kb8042->ops_cv); 8942df1fe9cSrandyf } 8952df1fe9cSrandyf mutex_exit(&kb8042->w_hw_mutex); 8962df1fe9cSrandyf 8977c478bd9Sstevel@tonic-gate return (0); 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate static void 9017c478bd9Sstevel@tonic-gate kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *qp, mblk_t *mp) 9027c478bd9Sstevel@tonic-gate { 9037c478bd9Sstevel@tonic-gate struct iocblk *iocp; 9047c478bd9Sstevel@tonic-gate mblk_t *datap; 9057c478bd9Sstevel@tonic-gate int error; 9067c478bd9Sstevel@tonic-gate int tmp; 907c35aa225Smarx int cycles; 908c35aa225Smarx int frequency; 909c35aa225Smarx int msecs; 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate iocp = (struct iocblk *)mp->b_rptr; 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate switch (iocp->ioc_cmd) { 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate case CONSOPENPOLLEDIO: 9167c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (struct cons_polledio *)); 9177c478bd9Sstevel@tonic-gate if (error != 0) { 9187c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, error); 9197c478bd9Sstevel@tonic-gate return; 9207c478bd9Sstevel@tonic-gate } 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate /* 9237c478bd9Sstevel@tonic-gate * We are given an appropriate-sized data block, 9247c478bd9Sstevel@tonic-gate * and return a pointer to our structure in it. 9257c478bd9Sstevel@tonic-gate */ 9267c478bd9Sstevel@tonic-gate *(struct cons_polledio **)mp->b_cont->b_rptr = 9277c478bd9Sstevel@tonic-gate &kb8042->polledio; 9287c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK; 9297c478bd9Sstevel@tonic-gate iocp->ioc_error = 0; 9307c478bd9Sstevel@tonic-gate qreply(qp, mp); 9317c478bd9Sstevel@tonic-gate break; 9327c478bd9Sstevel@tonic-gate 9337c478bd9Sstevel@tonic-gate case CONSCLOSEPOLLEDIO: 9347c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 9357c478bd9Sstevel@tonic-gate break; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate case CONSSETABORTENABLE: 9387c478bd9Sstevel@tonic-gate if (iocp->ioc_count != TRANSPARENT) { 9397c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, EINVAL); 9407c478bd9Sstevel@tonic-gate return; 9417c478bd9Sstevel@tonic-gate } 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate kb8042->debugger.enabled = *(intptr_t *)mp->b_cont->b_rptr; 9447c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 9457c478bd9Sstevel@tonic-gate break; 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate /* 9487c478bd9Sstevel@tonic-gate * Valid only in TR_UNTRANS_MODE mode. 9497c478bd9Sstevel@tonic-gate */ 9507c478bd9Sstevel@tonic-gate case CONSSETKBDTYPE: 9517c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int)); 9527c478bd9Sstevel@tonic-gate if (error != 0) { 9537c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, error); 9547c478bd9Sstevel@tonic-gate return; 9557c478bd9Sstevel@tonic-gate } 9567c478bd9Sstevel@tonic-gate tmp = *(int *)mp->b_cont->b_rptr; 9577c478bd9Sstevel@tonic-gate if (tmp != KB_PC && tmp != KB_USB) { 9587c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, EINVAL); 9597c478bd9Sstevel@tonic-gate break; 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate kb8042->simulated_kbd_type = tmp; 9627c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 9637c478bd9Sstevel@tonic-gate break; 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate case KIOCLAYOUT: 9667c478bd9Sstevel@tonic-gate if (kb8042->w_kblayout == -1) { 9677c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, EINVAL); 9687c478bd9Sstevel@tonic-gate return; 9697c478bd9Sstevel@tonic-gate } 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { 9727c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, ENOMEM); 9737c478bd9Sstevel@tonic-gate return; 9747c478bd9Sstevel@tonic-gate } 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate if (kb8042->simulated_kbd_type == KB_USB) 9777c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = KBTRANS_USBKB_DEFAULT_LAYOUT; 9787c478bd9Sstevel@tonic-gate else 9797c478bd9Sstevel@tonic-gate *(int *)datap->b_wptr = kb8042->w_kblayout; 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate datap->b_wptr += sizeof (int); 9827c478bd9Sstevel@tonic-gate if (mp->b_cont) 9837c478bd9Sstevel@tonic-gate freemsg(mp->b_cont); 9847c478bd9Sstevel@tonic-gate mp->b_cont = datap; 9857c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int); 9867c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK; 9877c478bd9Sstevel@tonic-gate iocp->ioc_error = 0; 9887c478bd9Sstevel@tonic-gate qreply(qp, mp); 9897c478bd9Sstevel@tonic-gate break; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate case KIOCSLAYOUT: 9927c478bd9Sstevel@tonic-gate if (iocp->ioc_count != TRANSPARENT) { 9937c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, EINVAL); 9947c478bd9Sstevel@tonic-gate return; 9957c478bd9Sstevel@tonic-gate } 9967c478bd9Sstevel@tonic-gate 9977c478bd9Sstevel@tonic-gate kb8042->w_kblayout = *(intptr_t *)mp->b_cont->b_rptr; 9987c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 9997c478bd9Sstevel@tonic-gate break; 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate case KIOCCMD: 10027c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int)); 10037c478bd9Sstevel@tonic-gate if (error != 0) { 10047c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, error); 10057c478bd9Sstevel@tonic-gate return; 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate kb8042_type4_cmd(kb8042, *(int *)mp->b_cont->b_rptr); 10097c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 10107c478bd9Sstevel@tonic-gate break; 10117c478bd9Sstevel@tonic-gate 1012c35aa225Smarx case KIOCMKTONE: 1013c35aa225Smarx if (iocp->ioc_count != TRANSPARENT) { 1014c35aa225Smarx miocnak(qp, mp, 0, EINVAL); 1015c35aa225Smarx return; 1016c35aa225Smarx } 1017c35aa225Smarx 1018c35aa225Smarx tmp = (int)(*(intptr_t *)mp->b_cont->b_rptr); 1019c35aa225Smarx cycles = tmp & 0xffff; 1020c35aa225Smarx msecs = (tmp >> 16) & 0xffff; 1021c35aa225Smarx 1022c35aa225Smarx if (cycles == 0) 1023c35aa225Smarx frequency = UINT16_MAX; 1024c35aa225Smarx else if (cycles == UINT16_MAX) 1025c35aa225Smarx frequency = 0; 1026c35aa225Smarx else { 1027c35aa225Smarx frequency = (PIT_HZ + cycles / 2) / cycles; 1028c35aa225Smarx if (frequency > UINT16_MAX) 1029c35aa225Smarx frequency = UINT16_MAX; 1030c35aa225Smarx } 1031c35aa225Smarx 1032c35aa225Smarx error = beep_mktone(frequency, msecs); 1033c35aa225Smarx if (error != 0) 1034c35aa225Smarx miocnak(qp, mp, 0, error); 1035c35aa225Smarx else 1036c35aa225Smarx miocack(qp, mp, 0, 0); 1037c35aa225Smarx break; 1038c35aa225Smarx 10397c478bd9Sstevel@tonic-gate default: 10407c478bd9Sstevel@tonic-gate #ifdef DEBUG1 10417c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!kb8042_ioctlmsg %x", iocp->ioc_cmd); 10427c478bd9Sstevel@tonic-gate #endif 10437c478bd9Sstevel@tonic-gate miocnak(qp, mp, 0, EINVAL); 10447c478bd9Sstevel@tonic-gate return; 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate } 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate /* 10497c478bd9Sstevel@tonic-gate * Process a byte received from the keyboard 10507c478bd9Sstevel@tonic-gate */ 10517c478bd9Sstevel@tonic-gate static void 10527c478bd9Sstevel@tonic-gate kb8042_received_byte( 10537c478bd9Sstevel@tonic-gate struct kb8042 *kb8042, 10547c478bd9Sstevel@tonic-gate int scancode) /* raw scan code */ 10557c478bd9Sstevel@tonic-gate { 10567c478bd9Sstevel@tonic-gate boolean_t legit; /* is this a legit key pos'n? */ 10577c478bd9Sstevel@tonic-gate int key_pos = -1; 10587c478bd9Sstevel@tonic-gate enum keystate state; 10597c478bd9Sstevel@tonic-gate boolean_t synthetic_release_needed; 10607c478bd9Sstevel@tonic-gate 10617c478bd9Sstevel@tonic-gate if (!kb8042->w_init) /* can't do anything anyway */ 10627c478bd9Sstevel@tonic-gate return; 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate legit = KeyboardConvertScan(kb8042, scancode, &key_pos, &state, 10657c478bd9Sstevel@tonic-gate &synthetic_release_needed); 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate if (legit == 0) { 10687c478bd9Sstevel@tonic-gate /* Eaten by translation */ 10697c478bd9Sstevel@tonic-gate return; 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate /* 10737c478bd9Sstevel@tonic-gate * Don't know if we want this permanently, but it seems interesting 10747c478bd9Sstevel@tonic-gate * for the moment. 10757c478bd9Sstevel@tonic-gate */ 10767c478bd9Sstevel@tonic-gate if (key_pos == kb8042->debugger.mod1) { 10777c478bd9Sstevel@tonic-gate kb8042->debugger.mod1_down = (state == KEY_PRESSED); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate if (key_pos == kb8042->debugger.mod2) { 10807c478bd9Sstevel@tonic-gate kb8042->debugger.mod2_down = (state == KEY_PRESSED); 10817c478bd9Sstevel@tonic-gate } 10827c478bd9Sstevel@tonic-gate if (kb8042->debugger.enabled && 10837c478bd9Sstevel@tonic-gate key_pos == kb8042->debugger.trigger && 10847c478bd9Sstevel@tonic-gate kb8042->debugger.mod1_down && 10857c478bd9Sstevel@tonic-gate kb8042->debugger.mod2_down) { 10867c478bd9Sstevel@tonic-gate /* 10877c478bd9Sstevel@tonic-gate * Require new presses of the modifiers. 10887c478bd9Sstevel@tonic-gate */ 10897c478bd9Sstevel@tonic-gate kb8042->debugger.mod1_down = B_FALSE; 10907c478bd9Sstevel@tonic-gate kb8042->debugger.mod2_down = B_FALSE; 10917c478bd9Sstevel@tonic-gate abort_sequence_enter(NULL); 10927c478bd9Sstevel@tonic-gate return; 10937c478bd9Sstevel@tonic-gate } 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate /* 10967c478bd9Sstevel@tonic-gate * If there's no queue above us - as can happen if we've been 10977c478bd9Sstevel@tonic-gate * attached but not opened - drop the keystroke. 10987c478bd9Sstevel@tonic-gate * Note that we do this here instead of above so that 10997c478bd9Sstevel@tonic-gate * Ctrl-Alt-D still works. 11007c478bd9Sstevel@tonic-gate */ 11017c478bd9Sstevel@tonic-gate if (kb8042->w_qp == NULL) { 11027c478bd9Sstevel@tonic-gate return; 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate /* 11067c478bd9Sstevel@tonic-gate * This is to filter out auto repeat since it can't be 11077c478bd9Sstevel@tonic-gate * turned off at the hardware. (Yeah, yeah, PS/2 keyboards 11087c478bd9Sstevel@tonic-gate * can. Don't know whether they've taken over the world. 11097c478bd9Sstevel@tonic-gate * Don't think so.) 11107c478bd9Sstevel@tonic-gate */ 11117c478bd9Sstevel@tonic-gate if (kb8042_autorepeat_detect(kb8042, key_pos, state)) { 11127c478bd9Sstevel@tonic-gate return; 11137c478bd9Sstevel@tonic-gate } 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate kb8042_process_key(kb8042, key_pos, state); 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate /* 11197c478bd9Sstevel@tonic-gate * This is a total hack. For some stupid reason, the two additional 11207c478bd9Sstevel@tonic-gate * keys on Korean keyboards (Hangul and Hangul/Hanja) report press 11217c478bd9Sstevel@tonic-gate * only. We synthesize a release immediately. 11227c478bd9Sstevel@tonic-gate */ 11237c478bd9Sstevel@tonic-gate if (synthetic_release_needed) { 11247c478bd9Sstevel@tonic-gate (void) kb8042_autorepeat_detect(kb8042, key_pos, KEY_RELEASED); 11257c478bd9Sstevel@tonic-gate kb8042_process_key(kb8042, key_pos, state); 11267c478bd9Sstevel@tonic-gate } 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate static void 11317c478bd9Sstevel@tonic-gate kb8042_process_key(struct kb8042 *kb8042, kbtrans_key_t key_pos, 11327c478bd9Sstevel@tonic-gate enum keystate state) 11337c478bd9Sstevel@tonic-gate { 11347c478bd9Sstevel@tonic-gate kbtrans_key_t key; 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate ASSERT(key_pos >= 0 && key_pos <= 255); 11377c478bd9Sstevel@tonic-gate if (kb8042->simulated_kbd_type == KB_PC) { 11387c478bd9Sstevel@tonic-gate kbtrans_streams_key(kb8042->hw_kbtrans, key_pos, state); 11397c478bd9Sstevel@tonic-gate } else if (kb8042->simulated_kbd_type == KB_USB) { 11407c478bd9Sstevel@tonic-gate key = keytab_pc2usb[key_pos]; 11417c478bd9Sstevel@tonic-gate if (key != 0) { 11427c478bd9Sstevel@tonic-gate kbtrans_streams_key(kb8042->hw_kbtrans, key, state); 11437c478bd9Sstevel@tonic-gate } 11447c478bd9Sstevel@tonic-gate } 11457c478bd9Sstevel@tonic-gate } 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate /* 11487c478bd9Sstevel@tonic-gate * Called from interrupt handler when keyboard interrupt occurs. 11497c478bd9Sstevel@tonic-gate */ 11507c478bd9Sstevel@tonic-gate static uint_t 11517c478bd9Sstevel@tonic-gate kb8042_intr(caddr_t arg) 11527c478bd9Sstevel@tonic-gate { 11537c478bd9Sstevel@tonic-gate uchar_t scancode; /* raw scan code */ 11547c478bd9Sstevel@tonic-gate int rc; 11557c478bd9Sstevel@tonic-gate struct kb8042 *kb8042 = (struct kb8042 *)arg; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate rc = DDI_INTR_UNCLAIMED; 11587c478bd9Sstevel@tonic-gate 1159fd9cb95cSsethg if (kb8042->init_state == KB8042_UNINITIALIZED) 1160fd9cb95cSsethg return (DDI_INTR_UNCLAIMED); 1161fd9cb95cSsethg 11627c478bd9Sstevel@tonic-gate /* don't care if drv_setparm succeeds */ 11637c478bd9Sstevel@tonic-gate (void) drv_setparm(SYSRINT, 1); 11647c478bd9Sstevel@tonic-gate 11657c478bd9Sstevel@tonic-gate while (ddi_get8(kb8042->handle, kb8042->addr + I8042_INT_INPUT_AVAIL) 11667c478bd9Sstevel@tonic-gate != 0) { 1167*2888301aSToomas Soome mblk_t *mp; 1168*2888301aSToomas Soome 11697c478bd9Sstevel@tonic-gate rc = DDI_INTR_CLAIMED; 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate scancode = ddi_get8(kb8042->handle, 11727c478bd9Sstevel@tonic-gate kb8042->addr + I8042_INT_INPUT_DATA); 11737c478bd9Sstevel@tonic-gate 1174*2888301aSToomas Soome /* 1175*2888301aSToomas Soome * Intercept ACK and RESEND and signal the condition that 1176*2888301aSToomas Soome * kb8042_send_and_wait is waiting for. 1177*2888301aSToomas Soome */ 1178*2888301aSToomas Soome switch (scancode) { 1179*2888301aSToomas Soome case KB_ACK: 1180*2888301aSToomas Soome mutex_enter(&kb8042->w_hw_mutex); 1181*2888301aSToomas Soome kb8042->acked = 1; 1182*2888301aSToomas Soome cv_signal(&kb8042->cmd_cv); 1183*2888301aSToomas Soome mutex_exit(&kb8042->w_hw_mutex); 1184*2888301aSToomas Soome return (rc); 1185*2888301aSToomas Soome case KB_RESEND: 1186*2888301aSToomas Soome mutex_enter(&kb8042->w_hw_mutex); 1187*2888301aSToomas Soome kb8042->need_retry = 1; 1188*2888301aSToomas Soome cv_signal(&kb8042->cmd_cv); 1189*2888301aSToomas Soome mutex_exit(&kb8042->w_hw_mutex); 1190*2888301aSToomas Soome return (rc); 1191*2888301aSToomas Soome default: 1192*2888301aSToomas Soome break; 1193*2888301aSToomas Soome } 1194*2888301aSToomas Soome 1195*2888301aSToomas Soome if ((mp = allocb(sizeof (scancode), BPRI_HI)) == NULL) 1196*2888301aSToomas Soome return (rc); 1197*2888301aSToomas Soome *mp->b_wptr++ = scancode; 1198*2888301aSToomas Soome if (putq(RD(kb8042->w_qp), mp) == 0) 1199*2888301aSToomas Soome freemsg(mp); 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate return (rc); 12037c478bd9Sstevel@tonic-gate } 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate static void 12067c478bd9Sstevel@tonic-gate kb8042_iocdatamsg(queue_t *qp, mblk_t *mp) 12077c478bd9Sstevel@tonic-gate { 12087c478bd9Sstevel@tonic-gate struct copyresp *csp; 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate csp = (struct copyresp *)mp->b_rptr; 12117c478bd9Sstevel@tonic-gate if (csp->cp_rval) { 12127c478bd9Sstevel@tonic-gate freemsg(mp); 12137c478bd9Sstevel@tonic-gate return; 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate switch (csp->cp_cmd) { 12177c478bd9Sstevel@tonic-gate default: 12187c478bd9Sstevel@tonic-gate miocack(qp, mp, 0, 0); 12197c478bd9Sstevel@tonic-gate break; 12207c478bd9Sstevel@tonic-gate } 12217c478bd9Sstevel@tonic-gate } 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate static boolean_t 12247c478bd9Sstevel@tonic-gate kb8042_polled_keycheck( 12257c478bd9Sstevel@tonic-gate struct kbtrans_hardware *hw, 12267c478bd9Sstevel@tonic-gate int *key, 12277c478bd9Sstevel@tonic-gate enum keystate *state) 12287c478bd9Sstevel@tonic-gate { 12297c478bd9Sstevel@tonic-gate struct kb8042 *kb8042 = (struct kb8042 *)hw; 12307c478bd9Sstevel@tonic-gate int scancode; 12317c478bd9Sstevel@tonic-gate boolean_t legit; 12327c478bd9Sstevel@tonic-gate boolean_t synthetic_release_needed; 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate if (kb8042->polled_synthetic_release_pending) { 12357c478bd9Sstevel@tonic-gate *key = kb8042->polled_synthetic_release_key; 12367c478bd9Sstevel@tonic-gate *state = KEY_RELEASED; 12377c478bd9Sstevel@tonic-gate kb8042->polled_synthetic_release_pending = B_FALSE; 12387c478bd9Sstevel@tonic-gate (void) kb8042_autorepeat_detect(kb8042, *key, *state); 12397c478bd9Sstevel@tonic-gate return (B_TRUE); 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate for (;;) { 12437c478bd9Sstevel@tonic-gate if (ddi_get8(kb8042->handle, 12447c478bd9Sstevel@tonic-gate kb8042->addr + I8042_POLL_INPUT_AVAIL) == 0) { 12457c478bd9Sstevel@tonic-gate return (B_FALSE); 12467c478bd9Sstevel@tonic-gate } 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate scancode = ddi_get8(kb8042->handle, 12497c478bd9Sstevel@tonic-gate kb8042->addr + I8042_POLL_INPUT_DATA); 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate legit = KeyboardConvertScan(kb8042, scancode, key, state, 12527c478bd9Sstevel@tonic-gate &synthetic_release_needed); 12537c478bd9Sstevel@tonic-gate if (!legit) { 12547c478bd9Sstevel@tonic-gate continue; 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate /* 12577c478bd9Sstevel@tonic-gate * For the moment at least, we rely on hardware autorepeat 12587c478bd9Sstevel@tonic-gate * for polled I/O autorepeat. However, for coordination 12597c478bd9Sstevel@tonic-gate * with the interrupt-driven code, maintain the last key 12607c478bd9Sstevel@tonic-gate * pressed. 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate (void) kb8042_autorepeat_detect(kb8042, *key, *state); 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate /* 12657c478bd9Sstevel@tonic-gate * This is a total hack to support two additional keys 12667c478bd9Sstevel@tonic-gate * on Korean keyboards. They report only on press, and 12677c478bd9Sstevel@tonic-gate * so we synthesize a release. Most likely this will 12687c478bd9Sstevel@tonic-gate * never be important to polled I/O, but if I do it 12697c478bd9Sstevel@tonic-gate * "right" the first time it _won't_ be an issue. 12707c478bd9Sstevel@tonic-gate */ 12717c478bd9Sstevel@tonic-gate if (synthetic_release_needed) { 12727c478bd9Sstevel@tonic-gate kb8042->polled_synthetic_release_pending = B_TRUE; 12737c478bd9Sstevel@tonic-gate kb8042->polled_synthetic_release_key = *key; 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate if (kb8042->simulated_kbd_type == KB_USB) { 12777c478bd9Sstevel@tonic-gate *key = keytab_pc2usb[*key]; 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate return (B_TRUE); 12807c478bd9Sstevel@tonic-gate } 12817c478bd9Sstevel@tonic-gate } 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate static void 1284fd9cb95cSsethg kb8042_setled(struct kb8042 *kb8042, int led_state, boolean_t polled) 1285fd9cb95cSsethg { 1286fd9cb95cSsethg kb8042->leds.desired = led_state; 1287fd9cb95cSsethg 1288fd9cb95cSsethg if (!polled) 1289fd9cb95cSsethg mutex_enter(&kb8042->w_hw_mutex); 1290fd9cb95cSsethg 1291bb2d7d5eSSeth Goldberg if (kb8042->leds.desired != kb8042->leds.commanded) { 1292bb2d7d5eSSeth Goldberg kb8042_send_to_keyboard(kb8042, KB_SET_LED, polled); 1293bb2d7d5eSSeth Goldberg } 1294fd9cb95cSsethg 1295fd9cb95cSsethg if (!polled) 1296fd9cb95cSsethg mutex_exit(&kb8042->w_hw_mutex); 1297fd9cb95cSsethg } 1298fd9cb95cSsethg 1299fd9cb95cSsethg static void 13007c478bd9Sstevel@tonic-gate kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state) 13017c478bd9Sstevel@tonic-gate { 13027c478bd9Sstevel@tonic-gate struct kb8042 *kb8042 = (struct kb8042 *)hw; 1303fd9cb95cSsethg kb8042_setled(kb8042, led_state, B_TRUE); 1304fd9cb95cSsethg } 13057c478bd9Sstevel@tonic-gate 1306fd9cb95cSsethg static void 1307fd9cb95cSsethg kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state) 1308fd9cb95cSsethg { 1309fd9cb95cSsethg struct kb8042 *kb8042 = (struct kb8042 *)hw; 1310fd9cb95cSsethg kb8042_setled(kb8042, led_state, B_FALSE); 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate 131315bfc6b7SSeth Goldberg 131415bfc6b7SSeth Goldberg static int 131515bfc6b7SSeth Goldberg kb8042_send_and_wait(struct kb8042 *kb8042, uint8_t u8, boolean_t polled) 131615bfc6b7SSeth Goldberg { 131715bfc6b7SSeth Goldberg uint8_t *outp = kb8042->addr + 131815bfc6b7SSeth Goldberg (polled ? I8042_POLL_OUTPUT_DATA : I8042_INT_OUTPUT_DATA); 131915bfc6b7SSeth Goldberg uint8_t *inavp = kb8042->addr + 132015bfc6b7SSeth Goldberg (polled ? I8042_POLL_INPUT_AVAIL : I8042_INT_INPUT_AVAIL); 132115bfc6b7SSeth Goldberg uint8_t *inp = kb8042->addr + 132215bfc6b7SSeth Goldberg (polled ? I8042_POLL_INPUT_DATA : I8042_INT_INPUT_DATA); 132315bfc6b7SSeth Goldberg uint8_t b; 132415bfc6b7SSeth Goldberg int ms_waited; 132515bfc6b7SSeth Goldberg int timedout; 132615bfc6b7SSeth Goldberg int expire; 132715bfc6b7SSeth Goldberg int retries = 0; 132815bfc6b7SSeth Goldberg 132915bfc6b7SSeth Goldberg do { 133015bfc6b7SSeth Goldberg kb8042->acked = 0; 133115bfc6b7SSeth Goldberg kb8042->need_retry = 0; 133215bfc6b7SSeth Goldberg ms_waited = 0; /* Zero it whether polled or not */ 133315bfc6b7SSeth Goldberg timedout = 0; 133415bfc6b7SSeth Goldberg 133515bfc6b7SSeth Goldberg ddi_put8(kb8042->handle, outp, u8); 133615bfc6b7SSeth Goldberg 133715bfc6b7SSeth Goldberg while (!kb8042->acked && !kb8042->need_retry && !timedout) { 133815bfc6b7SSeth Goldberg 133915bfc6b7SSeth Goldberg if (polled) { 134015bfc6b7SSeth Goldberg if (ddi_get8(kb8042->handle, inavp)) { 134115bfc6b7SSeth Goldberg b = ddi_get8(kb8042->handle, inp); 134215bfc6b7SSeth Goldberg switch (b) { 134315bfc6b7SSeth Goldberg case KB_ACK: 134415bfc6b7SSeth Goldberg kb8042->acked = 1; 134515bfc6b7SSeth Goldberg break; 134615bfc6b7SSeth Goldberg case KB_RESEND: 134715bfc6b7SSeth Goldberg kb8042->need_retry = 1; 134815bfc6b7SSeth Goldberg break; 134915bfc6b7SSeth Goldberg default: 135015bfc6b7SSeth Goldberg /* 135115bfc6b7SSeth Goldberg * drop it: We should never 135215bfc6b7SSeth Goldberg * get scancodes while 135315bfc6b7SSeth Goldberg * we're in the middle of a 135415bfc6b7SSeth Goldberg * command anyway. 135515bfc6b7SSeth Goldberg */ 135615bfc6b7SSeth Goldberg #ifdef DEBUG 135715bfc6b7SSeth Goldberg cmn_err(CE_WARN, "!Unexpected " 135815bfc6b7SSeth Goldberg " byte 0x%x", b); 135915bfc6b7SSeth Goldberg #endif 136015bfc6b7SSeth Goldberg break; 136115bfc6b7SSeth Goldberg } 136215bfc6b7SSeth Goldberg } 136315bfc6b7SSeth Goldberg 136415bfc6b7SSeth Goldberg /* 136515bfc6b7SSeth Goldberg * Wait 1ms if an ACK wasn't received yet 136615bfc6b7SSeth Goldberg */ 136715bfc6b7SSeth Goldberg if (!kb8042->acked) { 136815bfc6b7SSeth Goldberg drv_usecwait(1000); 136915bfc6b7SSeth Goldberg ms_waited++; 137015bfc6b7SSeth Goldberg if (ms_waited >= MAX_KB8042_WAIT_MAX_MS) 137115bfc6b7SSeth Goldberg timedout = B_TRUE; 137215bfc6b7SSeth Goldberg } 137315bfc6b7SSeth Goldberg } else { 137415bfc6b7SSeth Goldberg /* Interrupt-driven */ 137515bfc6b7SSeth Goldberg expire = ddi_get_lbolt() + 137615bfc6b7SSeth Goldberg drv_usectohz(MAX_KB8042_WAIT_MAX_MS * 1000); 137715bfc6b7SSeth Goldberg 137815bfc6b7SSeth Goldberg /* 137915bfc6b7SSeth Goldberg * If cv_timedwait returned -1 and we neither 138015bfc6b7SSeth Goldberg * received an ACK nor a RETRY response, then 138115bfc6b7SSeth Goldberg * we timed out. 138215bfc6b7SSeth Goldberg */ 138315bfc6b7SSeth Goldberg if (cv_timedwait(&kb8042->cmd_cv, 138415bfc6b7SSeth Goldberg &kb8042->w_hw_mutex, expire) == -1 && 138515bfc6b7SSeth Goldberg !kb8042->acked && !kb8042->need_retry) { 138615bfc6b7SSeth Goldberg timedout = B_TRUE; 138715bfc6b7SSeth Goldberg } 138815bfc6b7SSeth Goldberg } 138915bfc6b7SSeth Goldberg 139015bfc6b7SSeth Goldberg } 139115bfc6b7SSeth Goldberg } while ((kb8042->need_retry || timedout) && 139215bfc6b7SSeth Goldberg ++retries < MAX_KB8042_RETRIES); 139315bfc6b7SSeth Goldberg 139415bfc6b7SSeth Goldberg return (kb8042->acked); 139515bfc6b7SSeth Goldberg } 139615bfc6b7SSeth Goldberg 139715bfc6b7SSeth Goldberg /* 139815bfc6b7SSeth Goldberg * kb8042_send_to_keyboard should be called with w_hw_mutex held if 139915bfc6b7SSeth Goldberg * polled is FALSE. 140015bfc6b7SSeth Goldberg */ 14017c478bd9Sstevel@tonic-gate static void 14027c478bd9Sstevel@tonic-gate kb8042_send_to_keyboard(struct kb8042 *kb8042, int byte, boolean_t polled) 14037c478bd9Sstevel@tonic-gate { 1404bb2d7d5eSSeth Goldberg 1405bb2d7d5eSSeth Goldberg /* 140615bfc6b7SSeth Goldberg * KB_SET_LED and KB_ENABLE are special commands which require blocking 140715bfc6b7SSeth Goldberg * other 8042 consumers while executing. 1408bb2d7d5eSSeth Goldberg * 1409bb2d7d5eSSeth Goldberg * Other commands/data are sent using the single put8 I/O access 1410bb2d7d5eSSeth Goldberg * function. 1411bb2d7d5eSSeth Goldberg */ 1412bb2d7d5eSSeth Goldberg if (byte == KB_SET_LED) { 141315bfc6b7SSeth Goldberg 141415bfc6b7SSeth Goldberg if (!polled) { 141515bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + 141615bfc6b7SSeth Goldberg I8042_LOCK); 141715bfc6b7SSeth Goldberg } 141815bfc6b7SSeth Goldberg 141915bfc6b7SSeth Goldberg if (kb8042_send_and_wait(kb8042, KB_SET_LED, polled)) { 1420bb2d7d5eSSeth Goldberg /* 142115bfc6b7SSeth Goldberg * Ignore return value, as there's nothing we can 142215bfc6b7SSeth Goldberg * do about it if the SET LED command fails. 1423bb2d7d5eSSeth Goldberg */ 142415bfc6b7SSeth Goldberg (void) kb8042_send_and_wait(kb8042, 142515bfc6b7SSeth Goldberg kb8042_xlate_leds(kb8042->leds.desired), polled); 142615bfc6b7SSeth Goldberg } 142715bfc6b7SSeth Goldberg 142815bfc6b7SSeth Goldberg if (!polled) { 142915bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + 143015bfc6b7SSeth Goldberg I8042_UNLOCK); 1431bb2d7d5eSSeth Goldberg } 1432bb2d7d5eSSeth Goldberg kb8042->leds.commanded = kb8042->leds.desired; 1433bb2d7d5eSSeth Goldberg 1434bb2d7d5eSSeth Goldberg } else if (byte == KB_ENABLE) { 1435bb2d7d5eSSeth Goldberg 143615bfc6b7SSeth Goldberg if (!polled) { 143715bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + 143815bfc6b7SSeth Goldberg I8042_LOCK); 1439bb2d7d5eSSeth Goldberg } 144015bfc6b7SSeth Goldberg 144115bfc6b7SSeth Goldberg (void) kb8042_send_and_wait(kb8042, KB_ENABLE, polled); 144215bfc6b7SSeth Goldberg 144315bfc6b7SSeth Goldberg if (!polled) { 144415bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, kb8042->addr + 144515bfc6b7SSeth Goldberg I8042_UNLOCK); 144615bfc6b7SSeth Goldberg } 144715bfc6b7SSeth Goldberg 1448bb2d7d5eSSeth Goldberg } else { 1449bb2d7d5eSSeth Goldberg /* All other commands use the "normal" virtual output port */ 14507c478bd9Sstevel@tonic-gate if (polled) { 14517c478bd9Sstevel@tonic-gate ddi_put8(kb8042->handle, 14527c478bd9Sstevel@tonic-gate kb8042->addr + I8042_POLL_OUTPUT_DATA, byte); 14537c478bd9Sstevel@tonic-gate } else { 14547c478bd9Sstevel@tonic-gate ddi_put8(kb8042->handle, 14557c478bd9Sstevel@tonic-gate kb8042->addr + I8042_INT_OUTPUT_DATA, byte); 14567c478bd9Sstevel@tonic-gate } 1457bb2d7d5eSSeth Goldberg } 14587c478bd9Sstevel@tonic-gate } 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate /* 14617c478bd9Sstevel@tonic-gate * Wait until the keyboard is fully up, maybe. 14627c478bd9Sstevel@tonic-gate * We may be the first person to talk to the keyboard, in which case 14637c478bd9Sstevel@tonic-gate * it's patiently waiting to say "AA" to us to tell us it's up. 14647c478bd9Sstevel@tonic-gate * In theory it sends the AA in 300ms < n < 9s, but it's a pretty 14657c478bd9Sstevel@tonic-gate * good bet that we've already spent that long getting to that point, 14667c478bd9Sstevel@tonic-gate * so we'll only wait long enough for the communications electronics to 14677c478bd9Sstevel@tonic-gate * run. 14687c478bd9Sstevel@tonic-gate */ 14697c478bd9Sstevel@tonic-gate static void 14707c478bd9Sstevel@tonic-gate kb8042_wait_poweron(struct kb8042 *kb8042) 14717c478bd9Sstevel@tonic-gate { 14727c478bd9Sstevel@tonic-gate int cnt; 14737c478bd9Sstevel@tonic-gate int ready; 14747c478bd9Sstevel@tonic-gate 1475fd9cb95cSsethg /* wait for up to 250 ms for a response */ 14767c478bd9Sstevel@tonic-gate for (cnt = 0; cnt < 250; cnt++) { 14777c478bd9Sstevel@tonic-gate ready = ddi_get8(kb8042->handle, 14787c478bd9Sstevel@tonic-gate kb8042->addr + I8042_INT_INPUT_AVAIL); 14797c478bd9Sstevel@tonic-gate if (ready != 0) 14807c478bd9Sstevel@tonic-gate break; 14817c478bd9Sstevel@tonic-gate drv_usecwait(1000); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate 14847c478bd9Sstevel@tonic-gate /* 14857c478bd9Sstevel@tonic-gate * If there's something pending, read and discard it. If not, 14867c478bd9Sstevel@tonic-gate * assume things are OK anyway - maybe somebody else ate it 14877c478bd9Sstevel@tonic-gate * already. (On a PC, the BIOS almost certainly did.) 14887c478bd9Sstevel@tonic-gate */ 14897c478bd9Sstevel@tonic-gate if (ready != 0) { 149015bfc6b7SSeth Goldberg (void) ddi_get8(kb8042->handle, 14917c478bd9Sstevel@tonic-gate kb8042->addr + I8042_INT_INPUT_DATA); 14927c478bd9Sstevel@tonic-gate } 14937c478bd9Sstevel@tonic-gate } 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate static int 14967c478bd9Sstevel@tonic-gate kb8042_xlate_leds(int led) 14977c478bd9Sstevel@tonic-gate { 14987c478bd9Sstevel@tonic-gate int res; 14997c478bd9Sstevel@tonic-gate 15007c478bd9Sstevel@tonic-gate res = 0; 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate if (led & LED_NUM_LOCK) 15037c478bd9Sstevel@tonic-gate res |= LED_NUM; 15047c478bd9Sstevel@tonic-gate if (led & LED_SCROLL_LOCK) 15057c478bd9Sstevel@tonic-gate res |= LED_SCR; 15067c478bd9Sstevel@tonic-gate if (led & LED_CAPS_LOCK) 15077c478bd9Sstevel@tonic-gate res |= LED_CAP; 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate return (res); 15107c478bd9Sstevel@tonic-gate } 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 15137c478bd9Sstevel@tonic-gate static void 15147c478bd9Sstevel@tonic-gate kb8042_get_initial_leds( 15157c478bd9Sstevel@tonic-gate struct kb8042 *kb8042, 15167c478bd9Sstevel@tonic-gate int *initial_leds, 15177c478bd9Sstevel@tonic-gate int *initial_led_mask) 15187c478bd9Sstevel@tonic-gate { 1519bb2d7d5eSSeth Goldberg #if defined(__i386) || defined(__amd64) 15207c478bd9Sstevel@tonic-gate extern caddr_t p0_va; 15217c478bd9Sstevel@tonic-gate uint8_t bios_kb_flag; 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate bios_kb_flag = p0_va[BIOS_KB_FLAG]; 15247c478bd9Sstevel@tonic-gate 15257c478bd9Sstevel@tonic-gate *initial_led_mask = LED_CAPS_LOCK | LED_NUM_LOCK | LED_SCROLL_LOCK; 15267c478bd9Sstevel@tonic-gate *initial_leds = 0; 15277c478bd9Sstevel@tonic-gate if (bios_kb_flag & BIOS_CAPS_STATE) 15287c478bd9Sstevel@tonic-gate *initial_leds |= LED_CAPS_LOCK; 15297c478bd9Sstevel@tonic-gate if (bios_kb_flag & BIOS_NUM_STATE) 15307c478bd9Sstevel@tonic-gate *initial_leds |= LED_NUM_LOCK; 15317c478bd9Sstevel@tonic-gate if (bios_kb_flag & BIOS_SCROLL_STATE) 15327c478bd9Sstevel@tonic-gate *initial_leds |= LED_SCROLL_LOCK; 15337c478bd9Sstevel@tonic-gate #else 15347c478bd9Sstevel@tonic-gate *initial_leds = 0; 15357c478bd9Sstevel@tonic-gate *initial_led_mask = 0; 15367c478bd9Sstevel@tonic-gate #endif 15377c478bd9Sstevel@tonic-gate } 15387c478bd9Sstevel@tonic-gate 15397c478bd9Sstevel@tonic-gate static boolean_t 15407c478bd9Sstevel@tonic-gate kb8042_autorepeat_detect( 15417c478bd9Sstevel@tonic-gate struct kb8042 *kb8042, 15427c478bd9Sstevel@tonic-gate int key_pos, 15437c478bd9Sstevel@tonic-gate enum keystate state) 15447c478bd9Sstevel@tonic-gate { 15457c478bd9Sstevel@tonic-gate if (state == KEY_RELEASED) { 15467c478bd9Sstevel@tonic-gate if (kb8042->kb_old_key_pos == key_pos) 15477c478bd9Sstevel@tonic-gate kb8042->kb_old_key_pos = 0; 15487c478bd9Sstevel@tonic-gate } else { 15497c478bd9Sstevel@tonic-gate if (kb8042->kb_old_key_pos == key_pos) { 15507c478bd9Sstevel@tonic-gate return (B_TRUE); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate kb8042->kb_old_key_pos = key_pos; 15537c478bd9Sstevel@tonic-gate } 15547c478bd9Sstevel@tonic-gate return (B_FALSE); 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate /* ARGSUSED */ 15587c478bd9Sstevel@tonic-gate static void 15597c478bd9Sstevel@tonic-gate kb8042_type4_cmd(struct kb8042 *kb8042, int cmd) 15607c478bd9Sstevel@tonic-gate { 15617c478bd9Sstevel@tonic-gate switch (cmd) { 15627c478bd9Sstevel@tonic-gate case KBD_CMD_BELL: 1563c35aa225Smarx (void) beeper_on(BEEP_TYPE4); 15647c478bd9Sstevel@tonic-gate break; 15657c478bd9Sstevel@tonic-gate case KBD_CMD_NOBELL: 1566c35aa225Smarx (void) beeper_off(); 15677c478bd9Sstevel@tonic-gate break; 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate } 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate /* 15737c478bd9Sstevel@tonic-gate * This is a pass-thru routine to get a character at poll time. 15747c478bd9Sstevel@tonic-gate */ 15757c478bd9Sstevel@tonic-gate static int 1576281f0747Slt200341 kb8042_polled_getchar(cons_polledio_arg_t arg) 15777c478bd9Sstevel@tonic-gate { 15787c478bd9Sstevel@tonic-gate struct kb8042 *kb8042; 15797c478bd9Sstevel@tonic-gate 15807c478bd9Sstevel@tonic-gate kb8042 = (struct kb8042 *)arg; 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate return (kbtrans_getchar(kb8042->hw_kbtrans)); 15837c478bd9Sstevel@tonic-gate } 15847c478bd9Sstevel@tonic-gate 15857c478bd9Sstevel@tonic-gate /* 15867c478bd9Sstevel@tonic-gate * This is a pass-thru routine to get a character at poll time. 15877c478bd9Sstevel@tonic-gate */ 15887c478bd9Sstevel@tonic-gate static int 1589281f0747Slt200341 kb8042_polled_ischar(cons_polledio_arg_t arg) 15907c478bd9Sstevel@tonic-gate { 15917c478bd9Sstevel@tonic-gate struct kb8042 *kb8042; 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate kb8042 = (struct kb8042 *)arg; 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate return (kbtrans_ischar(kb8042->hw_kbtrans)); 15967c478bd9Sstevel@tonic-gate } 1597