xref: /illumos-gate/usr/src/uts/common/io/kb8042/kb8042.c (revision db335908e0bf7069476de0103b658d6962a6c751)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
22 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
23 /*	  All Rights Reserved	*/
24 
25 /*
26  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 #define	KEYMAP_SIZE_VARIABLE
31 
32 #include <sys/types.h>
33 #include <sys/errno.h>
34 #include <sys/inline.h>
35 #include <sys/termio.h>
36 #include <sys/stropts.h>
37 #include <sys/termios.h>
38 #include <sys/stream.h>
39 #include <sys/strtty.h>
40 #include <sys/strsubr.h>
41 #include <sys/strsun.h>
42 #include <sys/ddi.h>
43 #include <sys/sunddi.h>
44 #include <sys/note.h>
45 #include "sys/consdev.h"
46 #include <sys/kbd.h>
47 #include <sys/kbtrans.h>
48 #include "kb8042.h"
49 
50 #include <sys/i8042.h>
51 
52 #include "sys/kbio.h"		/* for KIOCSLAYOUT */
53 #include "sys/stat.h"
54 #include "sys/reboot.h"
55 #include <sys/promif.h>
56 #include <sys/beep.h>
57 #include <sys/inttypes.h>
58 #include <sys/policy.h>
59 
60 /*
61  * For any keyboard, there is a unique code describing the position
62  * of the key on a keyboard. We refer to the code as "station number".
63  * The following table is used to map the station numbers from ps2
64  * AT/XT keyboards to that of a USB one.
65  *
66  * A mapping was added for entry K8042_STOP, to map to USB key code 120 (which
67  * maps to the STOP key) when in KB_USB mode, and maps to a HOLE entry
68  * when in KB_PC mode.  Note that this does not need to be made conditional
69  * on the architecture for which this module is complied because there are no
70  * keys that map to K8042_STOP on non-SPARC platforms.
71  */
72 static kbtrans_key_t keytab_pc2usb[KBTRANS_KEYNUMS_MAX] = {
73 /*  0 */	0,	53,	30,	31,	32,	33,	34,	35,
74 /*  8 */	36,	37,	38,	39,	45,	46,	137,	42,
75 /* 16 */	43,	20,	26,	8,	21,	23,	28,	24,
76 /* 24 */	12,	18,	19,	47,	48,	49,	57,	4,
77 /* 32 */	22,	7,	9,	10,	11,	13,	14,	15,
78 /* 40 */	51,	52,	50,	40,	225,	100,	29,	27,
79 /* 48 */	6,	25,	5,	17,	16,	54,	55,	56,
80 /* 56 */	135,	229,	224,	227,	226,	44,	230,	231,
81 /* 64 */	228,	101,	0,	0,	0,	0,	0,	0,
82 /* 72 */	0,	0,	0,	73,	76,	0,	0,	80,
83 /* 80 */	74,	77,	0,	82,	81,	75,	78,	0,
84 /* 88 */	0,	79,	83,	95,	92,	89,	0,	84,
85 /* 96 */	96,	93,	90,	98,	85,	97,	94,	91,
86 /* 104 */	99,	86,	87,	133,	88,	0,	41,	0,
87 /* 112 */	58,	59,	60,	61,	62,	63,	64,	65,
88 /* 120 */	66,	67,	68,	69,	70,	71,	72,	0,
89 /* 128 */	0,	0,	0,	139,	138,	136,	0,	0,
90 /* 136 */	0,	0,	0,	0,	0,	0,	0,	0,
91 /* 144 */	0,	0,	0,	0,	0,	0,	0,	0,
92 /* 152 */	0,	0,	0,	0,	0,	0,	0,	0,
93 /* 160 */	120,	0,	0,	0,	0,	0,	0,	0,
94 /* 168 */	0,	0,	0,	0,	0,	0,	0,	0,
95 /* 176 */	0,	0,	0,	0,	0,	0,	0,	0,
96 /* 184 */	0,	0,	0,	0,	0,	0,	0,	0,
97 /* 192 */	0,	0,	0,	0,	0,	0,	0,	0,
98 /* 200 */	0,	0,	0,	0,	0,	0,	0,	0,
99 /* 208 */	0,	0,	0,	0,	0,	0,	0,	0,
100 /* 216 */	0,	0,	0,	0,	0,	0,	0,	0,
101 /* 224 */	0,	0,	0,	0,	0,	0,	0,	0,
102 /* 232 */	0,	128,	129,	127,	0,	0,	0,	0,
103 /* 240 */	0,	0,	0,	0,	0,	0,	0,	0,
104 /* 248 */	0,	0,	0,	0
105 };
106 
107 #ifdef __sparc
108 #define	USECS_PER_WAIT 100
109 #define	MAX_WAIT_USECS 100000 /* in usecs = 100 ms */
110 #define	MIN_DELAY_USECS USECS_PER_WAIT
111 
112 boolean_t kb8042_warn_unknown_scanset = B_TRUE;
113 int kb8042_default_scanset = 2;
114 
115 #endif
116 
117 #define	MAX_KB8042_WAIT_MAX_MS	500		/* 500ms total */
118 #define	MAX_KB8042_RETRIES	5
119 
120 enum state_return { STATE_NORMAL, STATE_INTERNAL };
121 
122 static void kb8042_init(struct kb8042 *kb8042, boolean_t from_resume);
123 static uint_t kb8042_intr(caddr_t arg);
124 static void kb8042_wait_poweron(struct kb8042 *kb8042);
125 static void kb8042_send_to_keyboard(struct kb8042 *, int, boolean_t);
126 static int kb8042_xlate_leds(int);
127 static void kb8042_setled(struct kb8042 *, int led_state, boolean_t polled);
128 static void kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state);
129 static void kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state);
130 static boolean_t kb8042_polled_keycheck(
131 			struct kbtrans_hardware *hw, int *key,
132 			enum keystate *state);
133 static void kb8042_get_initial_leds(struct kb8042 *, int *, int *);
134 static boolean_t kb8042_autorepeat_detect(struct kb8042 *kb8042, int key_pos,
135 			enum keystate state);
136 static void kb8042_type4_cmd(struct kb8042 *kb8042, int cmd);
137 static void kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *, mblk_t *);
138 static void kb8042_iocdatamsg(queue_t *, mblk_t *);
139 static void kb8042_process_key(struct kb8042 *, kbtrans_key_t, enum keystate);
140 static int kb8042_polled_ischar(cons_polledio_arg_t arg);
141 static int kb8042_polled_getchar(cons_polledio_arg_t arg);
142 static void kb8042_cleanup(struct kb8042 *kb8042);
143 static void kb8042_received_byte(struct kb8042 *, int);
144 
145 static struct kbtrans_callbacks kb8042_callbacks = {
146 	kb8042_streams_setled,
147 	kb8042_polled_setled,
148 	kb8042_polled_keycheck,
149 };
150 
151 extern struct keyboard keyindex_pc;
152 
153 #define	DRIVER_NAME(dip) ddi_driver_name(dip)
154 
155 static	char	module_name[] = "kb8042";
156 
157 static int kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag,
158 			cred_t *credp);
159 static int kb8042_close(queue_t *qp, int flag, cred_t *credp);
160 static int kb8042_rsrv(queue_t *);
161 static int kb8042_wsrv(queue_t *);
162 
163 struct module_info kb8042_sinfo = {
164 	.mi_idnum = 42,			/* Module ID */
165 	.mi_idname = module_name,	/* Module name */
166 	.mi_minpsz = 0,			/* Minimum packet size */
167 	.mi_maxpsz = 32,		/* Maximum packet size */
168 	.mi_hiwat = 256,		/* High water mark */
169 	.mi_lowat = 128			/* Low water mark */
170 };
171 
172 static struct qinit kb8042_rinit = {
173 	.qi_putp = NULL,
174 	.qi_srvp = kb8042_rsrv,
175 	.qi_qopen = kb8042_open,
176 	.qi_qclose = kb8042_close,
177 	.qi_qadmin = NULL,
178 	.qi_minfo = &kb8042_sinfo,
179 	.qi_mstat = NULL,
180 	.qi_rwp = NULL,
181 	.qi_infop = NULL,
182 	.qi_struiot = 0
183 };
184 
185 static struct qinit kb8042_winit = {
186 	.qi_putp = putq,
187 	.qi_srvp = kb8042_wsrv,
188 	.qi_qopen = kb8042_open,
189 	.qi_qclose = kb8042_close,
190 	.qi_qadmin = NULL,
191 	.qi_minfo = &kb8042_sinfo,
192 	.qi_mstat = NULL,
193 	.qi_rwp = NULL,
194 	.qi_infop = NULL,
195 	.qi_struiot = 0
196 };
197 
198 struct streamtab kb8042_str_info = {
199 	.st_rdinit = &kb8042_rinit,
200 	.st_wrinit = &kb8042_winit,
201 	.st_muxrinit = NULL,
202 	.st_muxwinit = NULL
203 };
204 
205 struct kb8042	Kdws = {0};
206 static dev_info_t *kb8042_dip = NULL;
207 
208 static int kb8042_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
209 		void **result);
210 static int kb8042_attach(dev_info_t *, ddi_attach_cmd_t);
211 static int kb8042_detach(dev_info_t *, ddi_detach_cmd_t);
212 
213 static struct cb_ops cb_kb8042_ops = {
214 	.cb_open = nulldev,
215 	.cb_close = nulldev,
216 	.cb_strategy = nodev,
217 	.cb_print = nodev,
218 	.cb_dump = nodev,
219 	.cb_read = nodev,
220 	.cb_write = nodev,
221 	.cb_ioctl = nodev,
222 	.cb_devmap = nodev,
223 	.cb_mmap = nodev,
224 	.cb_segmap = nodev,
225 	.cb_chpoll = nochpoll,
226 	.cb_prop_op = ddi_prop_op,
227 	.cb_str = &kb8042_str_info,
228 	.cb_flag = D_MP,
229 	.cb_rev = CB_REV,
230 	.cb_aread = nodev,
231 	.cb_awrite = nodev
232 };
233 
234 struct dev_ops kb8042_ops = {
235 	.devo_rev = DEVO_REV,
236 	.devo_refcnt = 0,
237 	.devo_getinfo = kb8042_getinfo,
238 	.devo_identify = nulldev,
239 	.devo_probe = nulldev,
240 	.devo_attach = kb8042_attach,
241 	.devo_detach = kb8042_detach,
242 	.devo_reset = nodev,
243 	.devo_cb_ops = &cb_kb8042_ops,
244 	.devo_bus_ops = NULL,
245 	.devo_power = NULL,
246 	.devo_quiesce = ddi_quiesce_not_needed
247 };
248 
249 
250 /*
251  * This is the loadable module wrapper.
252  */
253 #include <sys/modctl.h>
254 
255 /*
256  * Module linkage information for the kernel.
257  */
258 static struct modldrv modldrv = {
259 	.drv_modops = &mod_driverops,	/* Type of module. */
260 	.drv_linkinfo = "PS/2 keyboard driver",
261 	.drv_dev_ops = &kb8042_ops,	/* driver ops */
262 };
263 
264 static struct modlinkage modlinkage = {
265 	.ml_rev = MODREV_1,
266 	.ml_linkage = { &modldrv, NULL }
267 };
268 
269 int
_init(void)270 _init(void)
271 {
272 	int	rv;
273 
274 	rv = mod_install(&modlinkage);
275 	return (rv);
276 }
277 
278 
279 int
_fini(void)280 _fini(void)
281 {
282 	return (mod_remove(&modlinkage));
283 }
284 
285 int
_info(struct modinfo * modinfop)286 _info(struct modinfo *modinfop)
287 {
288 	return (mod_info(&modlinkage, modinfop));
289 }
290 
291 #ifdef __sparc
292 static boolean_t
kb8042_is_input_avail(struct kb8042 * kb8042,int timeout_usec,boolean_t polled)293 kb8042_is_input_avail(struct kb8042 *kb8042, int timeout_usec, boolean_t polled)
294 {
295 	int i;
296 	int port = (polled == B_TRUE) ? I8042_POLL_INPUT_AVAIL :
297 	    I8042_INT_INPUT_AVAIL;
298 	int reps = timeout_usec / USECS_PER_WAIT;
299 
300 	for (i = 0; i < reps; i++) {
301 		if (ddi_get8(kb8042->handle, kb8042->addr + port) != 0)
302 			return (B_TRUE);
303 
304 		if (i < (reps - 1))
305 			drv_usecwait(USECS_PER_WAIT);
306 	}
307 	return (B_FALSE);
308 }
309 
310 static void
kb8042_clear_input_buffer(struct kb8042 * kb8042,boolean_t polled)311 kb8042_clear_input_buffer(struct kb8042 *kb8042, boolean_t polled)
312 {
313 	int port = (polled == B_TRUE) ? I8042_POLL_INPUT_DATA :
314 	    I8042_INT_INPUT_DATA;
315 
316 	while (kb8042_is_input_avail(kb8042, MIN_DELAY_USECS, polled)) {
317 		(void) ddi_get8(kb8042->handle, kb8042->addr + port);
318 	}
319 }
320 
321 /*
322  * kb8042_send_and_expect does all its I/O via polling interfaces
323  */
324 static boolean_t
kb8042_send_and_expect(struct kb8042 * kb8042,uint8_t send,uint8_t expect,int timeout,int * error,uint8_t * got)325 kb8042_send_and_expect(struct kb8042 *kb8042, uint8_t send, uint8_t expect,
326     int timeout, int *error, uint8_t *got)
327 {
328 	uint8_t datab;
329 	int err;
330 	boolean_t rval;
331 
332 	ddi_put8(kb8042->handle,
333 	    kb8042->addr + I8042_POLL_OUTPUT_DATA, send);
334 
335 	if (kb8042_is_input_avail(kb8042, timeout, B_TRUE)) {
336 		err = 0;
337 		datab = ddi_get8(kb8042->handle,
338 		    kb8042->addr + I8042_POLL_INPUT_DATA);
339 		rval = ((datab == expect) ? B_TRUE : B_FALSE);
340 	} else {
341 		err = EAGAIN;
342 		rval = B_FALSE;
343 	}
344 
345 	if (error != NULL)
346 		*error = err;
347 	if (got != NULL)
348 		*got = datab;
349 	return (rval);
350 }
351 
352 static const char *
kb8042_error_string(int errcode)353 kb8042_error_string(int errcode)
354 {
355 	switch (errcode) {
356 	case EAGAIN:
357 		return ("Timed out");
358 	default:
359 		return ("Unknown error");
360 	}
361 }
362 
363 /*
364  * kb8042_read_scanset works properly because it is called before ddi_add_intr
365  * (if it is called after ddi_add_intr, i8042_intr would call kb8042_intr
366  * instead of just storing the data that comes in from the keyboard, which
367  * would prevent the code here from getting it.)
368  */
369 static int
kb8042_read_scanset(struct kb8042 * kb8042)370 kb8042_read_scanset(struct kb8042 *kb8042)
371 {
372 	int scanset = -1;
373 	int err;
374 	uint8_t got;
375 
376 	kb8042_clear_input_buffer(kb8042, B_TRUE);
377 
378 	/*
379 	 * Send a "change scan code set" command to the keyboard.
380 	 * It should respond with an ACK.
381 	 */
382 	if (kb8042_send_and_expect(kb8042, KB_SET_SCAN, KB_ACK, MAX_WAIT_USECS,
383 	    &err, &got) != B_TRUE) {
384 		goto fail_read_scanset;
385 	}
386 
387 	/*
388 	 * Send a 0.  The keyboard should ACK the 0, then it should send the
389 	 * scan code set in use.
390 	 */
391 	if (kb8042_send_and_expect(kb8042, 0, KB_ACK, MAX_WAIT_USECS, &err,
392 	    &got) != B_TRUE) {
393 		goto fail_read_scanset;
394 	}
395 
396 	/*
397 	 * The next input byte from the keyboard should be the scan code
398 	 * set in use, though some keyboards like to send a few more acks
399 	 * just for fun, so blow past those to get the keyboard scan code.
400 	 */
401 	while (kb8042_is_input_avail(kb8042, MAX_WAIT_USECS, B_TRUE) &&
402 	    (scanset = ddi_get8(kb8042->handle,
403 	    kb8042->addr + I8042_POLL_INPUT_DATA)) == KB_ACK)
404 		;
405 
406 #ifdef DEBUG
407 	cmn_err(CE_NOTE, "!Scan code set from keyboard is `%d'.",
408 	    scanset);
409 #endif
410 
411 	return (scanset);
412 
413 fail_read_scanset:
414 #ifdef DEBUG
415 	if (err == 0)
416 		cmn_err(CE_NOTE, "Could not read current scan set from "
417 		    "keyboard: %s. (Expected 0x%x, but got 0x%x).",
418 		    kb8042_error_string(err), KB_ACK, got);
419 	else
420 		cmn_err(CE_NOTE, "Could not read current scan set from "
421 		    "keyboard: %s.", kb8042_error_string(err));
422 #endif
423 	return (-1);
424 }
425 #endif
426 
427 static int
kb8042_attach(dev_info_t * devi,ddi_attach_cmd_t cmd)428 kb8042_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
429 {
430 	int	rc;
431 	int	scanset;
432 	int	leds;
433 
434 	struct kb8042	*kb8042 = &Kdws;
435 	static ddi_device_acc_attr_t attr = {
436 		DDI_DEVICE_ATTR_V0,
437 		DDI_NEVERSWAP_ACC,
438 		DDI_STRICTORDER_ACC,
439 	};
440 
441 	switch (cmd) {
442 	case DDI_RESUME:
443 		leds = kb8042->leds.commanded;
444 		kb8042->w_init = 0;
445 		kb8042_init(kb8042, B_TRUE);
446 		kb8042_setled(kb8042, leds, B_FALSE);
447 		mutex_enter(&kb8042->w_hw_mutex);
448 		kb8042->suspended = B_FALSE;
449 		if (kb8042->w_qp != NULL) {
450 			enableok(WR(kb8042->w_qp));
451 			qenable(WR(kb8042->w_qp));
452 		}
453 		cv_broadcast(&kb8042->suspend_cv);
454 		mutex_exit(&kb8042->w_hw_mutex);
455 		return (DDI_SUCCESS);
456 
457 	case DDI_ATTACH:
458 		if (kb8042_dip != NULL)
459 			return (DDI_FAILURE);
460 		/* The rest of the function is for attach */
461 		break;
462 
463 	default:
464 		return (DDI_FAILURE);
465 	}
466 
467 	kb8042->debugger.mod1 = 58;	/* Left Ctrl */
468 	kb8042->debugger.mod2 = 60;	/* Left Alt */
469 	kb8042->debugger.trigger = 33;	/* D */
470 	kb8042->debugger.mod1_down = B_FALSE;
471 	kb8042->debugger.mod2_down = B_FALSE;
472 	kb8042->debugger.enabled = B_FALSE;
473 
474 	kb8042_dip = devi;
475 	kb8042->init_state = KB8042_UNINITIALIZED;
476 
477 	kb8042->polled_synthetic_release_pending = B_FALSE;
478 
479 	if (ddi_create_minor_node(devi, module_name, S_IFCHR, 0,
480 	    DDI_NT_KEYBOARD, 0) == DDI_FAILURE) {
481 		goto failure;
482 	}
483 
484 	kb8042->init_state |= KB8042_MINOR_NODE_CREATED;
485 
486 	rc = ddi_regs_map_setup(devi, 0, (caddr_t *)&kb8042->addr,
487 	    (offset_t)0, (offset_t)0, &attr, &kb8042->handle);
488 	if (rc != DDI_SUCCESS) {
489 #ifdef DEBUG
490 		cmn_err(CE_WARN, "kb8042_attach:  can't map registers");
491 #endif
492 		goto failure;
493 	}
494 
495 	kb8042->init_state |= KB8042_REGS_MAPPED;
496 
497 	if (ddi_get_iblock_cookie(devi, 0, &kb8042->w_iblock) !=
498 	    DDI_SUCCESS) {
499 		cmn_err(CE_WARN, "kb8042_attach:  Can't get iblock cookie");
500 		goto failure;
501 	}
502 
503 	mutex_init(&kb8042->w_hw_mutex, NULL, MUTEX_DRIVER, kb8042->w_iblock);
504 	cv_init(&kb8042->ops_cv, NULL, CV_DRIVER, NULL);
505 	cv_init(&kb8042->suspend_cv, NULL, CV_DRIVER, NULL);
506 	cv_init(&kb8042->cmd_cv, NULL, CV_DRIVER, NULL);
507 	kb8042->init_state |= KB8042_HW_MUTEX_INITTED;
508 
509 	kb8042_init(kb8042, B_FALSE);
510 
511 #ifdef __sparc
512 	/* Detect the scan code set currently in use */
513 	scanset = kb8042_read_scanset(kb8042);
514 
515 	if (scanset < 0 && kb8042_warn_unknown_scanset) {
516 
517 		cmn_err(CE_WARN, "Cannot determine keyboard scan code set ");
518 		cmn_err(CE_CONT, "(is the keyboard plugged in?). ");
519 		cmn_err(CE_CONT, "Defaulting to scan code set %d.  If the "
520 		    "keyboard does not ", kb8042_default_scanset);
521 		cmn_err(CE_CONT, "work properly, add "
522 		    "`set kb8042:kb8042_default_scanset=%d' to /etc/system ",
523 		    (kb8042_default_scanset == 1) ? 2 : 1);
524 		cmn_err(CE_CONT, "(via network or with a USB keyboard) and "
525 		    "restart the system.  If you ");
526 		cmn_err(CE_CONT, "do not want to see this message in the "
527 		    "future, add ");
528 		cmn_err(CE_CONT, "`set kb8042:kb8042_warn_unknown_scanset=0' "
529 		    "to /etc/system.\n");
530 
531 		/* Use the default scan code set. */
532 		scanset = kb8042_default_scanset;
533 	}
534 #else
535 	/* x86 systems use scan code set 1 -- no detection required */
536 	scanset = 1;
537 #endif
538 	if (KeyboardConvertScan_init(kb8042, scanset) != DDI_SUCCESS) {
539 		cmn_err(CE_WARN, "Cannot initialize keyboard scan converter: "
540 		    "Unknown scan code set `%d'.", scanset);
541 		/* Scan code set is not supported */
542 		goto failure;
543 	}
544 
545 	/*
546 	 * Turn on interrupts...
547 	 */
548 	if (ddi_add_intr(devi, 0,
549 	    &kb8042->w_iblock, (ddi_idevice_cookie_t *)NULL,
550 	    kb8042_intr, (caddr_t)kb8042) != DDI_SUCCESS) {
551 		cmn_err(CE_WARN, "kb8042_attach: cannot add interrupt");
552 		goto failure;
553 	}
554 
555 	kb8042->init_state |= KB8042_INTR_ADDED;
556 
557 	ddi_report_dev(devi);
558 
559 #ifdef DEBUG
560 	cmn_err(CE_CONT, "?%s instance #%d READY\n",
561 	    DRIVER_NAME(devi), ddi_get_instance(devi));
562 #endif
563 
564 	return (DDI_SUCCESS);
565 
566 failure:
567 	kb8042_cleanup(kb8042);
568 	return (DDI_FAILURE);
569 }
570 
571 static int
kb8042_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)572 kb8042_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
573 {
574 	struct kb8042 *kb8042 = &Kdws;
575 
576 	switch (cmd) {
577 	case DDI_SUSPEND:
578 		mutex_enter(&kb8042->w_hw_mutex);
579 		ASSERT(kb8042->ops >= 0);
580 		while (kb8042->ops > 0)
581 			cv_wait(&kb8042->ops_cv, &kb8042->w_hw_mutex);
582 		kb8042->suspended = B_TRUE;
583 		mutex_exit(&kb8042->w_hw_mutex);
584 		return (DDI_SUCCESS);
585 
586 	case DDI_DETACH:
587 		/* If someone has a stream open, fail to detach */
588 		if (kb8042->w_qp != NULL)
589 			return (DDI_FAILURE);
590 
591 		ASSERT(kb8042_dip == dip);
592 
593 		kb8042_cleanup(kb8042);
594 
595 		return (DDI_SUCCESS);
596 
597 	default:
598 		return (DDI_FAILURE);
599 	}
600 }
601 
602 static int
kb8042_getinfo(dev_info_t * dip __unused,ddi_info_cmd_t infocmd,void * arg __unused,void ** result)603 kb8042_getinfo(dev_info_t *dip __unused, ddi_info_cmd_t infocmd,
604     void *arg __unused, void **result)
605 {
606 	int error;
607 
608 	switch (infocmd) {
609 	case DDI_INFO_DEVT2DEVINFO:
610 		if (kb8042_dip == NULL) {
611 			error = DDI_FAILURE;
612 		} else {
613 			*result = (void *) kb8042_dip;
614 			error = DDI_SUCCESS;
615 		}
616 		break;
617 	case DDI_INFO_DEVT2INSTANCE:
618 		if (kb8042_dip == NULL) {
619 			error = DDI_FAILURE;
620 		} else {
621 			int instance;
622 
623 			instance = ddi_get_instance(kb8042_dip);
624 			*result = (void *)(uintptr_t)instance;
625 			error = DDI_SUCCESS;
626 		}
627 		break;
628 	default:
629 		error = DDI_FAILURE;
630 		break;
631 	}
632 	return (error);
633 }
634 
635 static void
kb8042_cleanup(struct kb8042 * kb8042)636 kb8042_cleanup(struct kb8042 *kb8042)
637 {
638 	ASSERT(kb8042_dip != NULL);
639 
640 	if (kb8042->init_state & KB8042_INTR_ADDED)
641 		ddi_remove_intr(kb8042_dip, 0, kb8042->w_iblock);
642 
643 	if (kb8042->init_state & KB8042_HW_MUTEX_INITTED) {
644 		cv_destroy(&kb8042->cmd_cv);
645 		cv_destroy(&kb8042->suspend_cv);
646 		cv_destroy(&kb8042->ops_cv);
647 		mutex_destroy(&kb8042->w_hw_mutex);
648 	}
649 
650 	if (kb8042->init_state & KB8042_REGS_MAPPED)
651 		ddi_regs_map_free(&kb8042->handle);
652 
653 	if (kb8042->init_state & KB8042_MINOR_NODE_CREATED)
654 		ddi_remove_minor_node(kb8042_dip, NULL);
655 
656 	kb8042->init_state = KB8042_UNINITIALIZED;
657 	kb8042_dip = NULL;
658 }
659 
660 static void
kb8042_init(struct kb8042 * kb8042,boolean_t from_resume)661 kb8042_init(struct kb8042 *kb8042, boolean_t from_resume)
662 {
663 	if (kb8042->w_init)
664 		return;
665 
666 	if (!from_resume) {
667 		kb8042->w_kblayout = 0;	/* Default to US */
668 		kb8042->w_qp = (queue_t *)NULL;
669 		kb8042->simulated_kbd_type = KB_PC;
670 		kb8042->leds.commanded = -1;	/* Unknown initial state */
671 		kb8042->leds.desired = -1;	/* Unknown initial state */
672 	}
673 
674 	kb8042_wait_poweron(kb8042);
675 
676 	kb8042->kb_old_key_pos = 0;
677 
678 	/*
679 	 * Explicitly grab and release the 8042 lock outside of
680 	 * kb8042_send_to_keyboard, because this is the only situation
681 	 * where a polling interface is used with locking required.
682 	 */
683 	(void) ddi_get8(kb8042->handle, kb8042->addr + I8042_LOCK);
684 	/* Set up the command state machine and start it running. */
685 	kb8042_send_to_keyboard(kb8042, KB_ENABLE, B_TRUE);
686 	(void) ddi_get8(kb8042->handle, kb8042->addr + I8042_UNLOCK);
687 
688 	kb8042->w_init++;
689 
690 	(void) drv_setparm(SYSRINT, 1);	/* reset keyboard interrupts */
691 }
692 
693 /*ARGSUSED2*/
694 static int
kb8042_open(queue_t * qp,dev_t * devp,int flag,int sflag,cred_t * credp)695 kb8042_open(queue_t *qp, dev_t *devp, int flag, int sflag, cred_t *credp)
696 {
697 	struct kb8042	*kb8042;
698 	int err = 0;
699 	int initial_leds;
700 	int initial_led_mask;
701 
702 	kb8042 = &Kdws;
703 
704 	mutex_enter(&kb8042->w_hw_mutex);
705 	if (qp->q_ptr) {
706 		kb8042->w_dev = *devp;
707 		mutex_exit(&kb8042->w_hw_mutex);
708 		return (0);
709 	}
710 
711 	if (secpolicy_console(credp) != 0) {
712 		mutex_exit(&kb8042->w_hw_mutex);
713 		return (EPERM);
714 	}
715 
716 	while (kb8042->suspended) {
717 		if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) ==
718 		    0) {
719 			mutex_exit(&kb8042->w_hw_mutex);
720 			return (EINTR);
721 		}
722 	}
723 
724 	kb8042->w_dev = *devp;
725 	qp->q_ptr = (caddr_t)kb8042;
726 	WR(qp)->q_ptr = qp->q_ptr;
727 	if (!kb8042->w_qp)
728 		kb8042->w_qp = qp;
729 
730 	ASSERT(kb8042->ops >= 0);
731 	kb8042->ops++;
732 	mutex_exit(&kb8042->w_hw_mutex);
733 
734 	kb8042_get_initial_leds(kb8042, &initial_leds, &initial_led_mask);
735 	err = kbtrans_streams_init(qp, sflag,
736 	    (struct kbtrans_hardware *)kb8042, &kb8042_callbacks,
737 	    &kb8042->hw_kbtrans,
738 	    initial_leds, initial_led_mask);
739 	if (err != 0)
740 		goto out;
741 
742 	kbtrans_streams_set_keyboard(kb8042->hw_kbtrans, KB_PC, &keyindex_pc);
743 
744 	kb8042->polledio.cons_polledio_version = CONSPOLLEDIO_V1;
745 	kb8042->polledio.cons_polledio_argument =
746 	    (cons_polledio_arg_t)kb8042;
747 	kb8042->polledio.cons_polledio_putchar = NULL;
748 	kb8042->polledio.cons_polledio_getchar =
749 	    (int (*)(cons_polledio_arg_t))kb8042_polled_getchar;
750 	kb8042->polledio.cons_polledio_ischar =
751 	    (boolean_t (*)(cons_polledio_arg_t))kb8042_polled_ischar;
752 	kb8042->polledio.cons_polledio_enter = NULL;
753 	kb8042->polledio.cons_polledio_exit = NULL;
754 	kb8042->polledio.cons_polledio_setled =
755 	    (void (*)(cons_polledio_arg_t, int))kb8042_polled_setled;
756 	kb8042->polledio.cons_polledio_keycheck =
757 	    (boolean_t (*)(cons_polledio_arg_t, int *,
758 	    enum keystate *))kb8042_polled_keycheck;
759 
760 	qprocson(qp);
761 
762 	kbtrans_streams_enable(kb8042->hw_kbtrans);
763 
764 out:
765 	mutex_enter(&kb8042->w_hw_mutex);
766 	ASSERT(kb8042->ops > 0);
767 	kb8042->ops--;
768 	if (kb8042->ops == 0)
769 		cv_broadcast(&kb8042->ops_cv);
770 	mutex_exit(&kb8042->w_hw_mutex);
771 
772 	return (err);
773 }
774 
775 /*ARGSUSED1*/
776 static int
kb8042_close(queue_t * qp,int flag,cred_t * credp)777 kb8042_close(queue_t *qp, int flag, cred_t *credp)
778 {
779 	struct kb8042	*kb8042;
780 
781 	/* If a beep is in progress, stop that */
782 	(void) beeper_off();
783 
784 	kb8042 = (struct kb8042 *)qp->q_ptr;
785 
786 	mutex_enter(&kb8042->w_hw_mutex);
787 	while (kb8042->suspended) {
788 		if (cv_wait_sig(&kb8042->suspend_cv, &kb8042->w_hw_mutex) ==
789 		    0) {
790 			mutex_exit(&kb8042->w_hw_mutex);
791 			return (EINTR);
792 		}
793 	}
794 
795 	ASSERT(kb8042->ops >= 0);
796 	kb8042->ops++;
797 	mutex_exit(&kb8042->w_hw_mutex);
798 
799 	(void) kbtrans_streams_fini(kb8042->hw_kbtrans);
800 
801 	kb8042->w_qp = (queue_t *)NULL;
802 	qprocsoff(qp);
803 
804 	mutex_enter(&kb8042->w_hw_mutex);
805 	ASSERT(kb8042->ops > 0);
806 	kb8042->ops--;
807 	if (kb8042->ops == 0)
808 		cv_broadcast(&kb8042->ops_cv);
809 	mutex_exit(&kb8042->w_hw_mutex);
810 
811 	return (0);
812 }
813 
814 static int
kb8042_rsrv(queue_t * qp)815 kb8042_rsrv(queue_t *qp)
816 {
817 	mblk_t *mp;
818 	struct kb8042 *kb8042;
819 
820 	while ((mp = getq(qp)) != NULL) {
821 		if (mp->b_datap->db_type == M_DATA) {
822 			kb8042 = (struct kb8042 *)qp->q_ptr;
823 			kb8042_received_byte(kb8042, *mp->b_rptr);
824 		}
825 		freemsg(mp);
826 	}
827 	return (0);
828 }
829 
830 static int
kb8042_wsrv(queue_t * qp)831 kb8042_wsrv(queue_t *qp)
832 {
833 	struct kb8042 *kb8042;
834 
835 	mblk_t	*mp;
836 	boolean_t suspended;
837 
838 	kb8042 = (struct kb8042 *)qp->q_ptr;
839 
840 	mutex_enter(&kb8042->w_hw_mutex);
841 	suspended = kb8042->suspended;
842 	ASSERT(kb8042->ops >= 0);
843 	if (!suspended)
844 		kb8042->ops++;
845 	mutex_exit(&kb8042->w_hw_mutex);
846 
847 #ifdef NO_KB_DEBUG
848 	while (!suspended && (mp = getq(qp)) != NULL) {
849 #else
850 	/*
851 	 * Not taking keyboard input while suspending can make debugging
852 	 * difficult.  However, we still do the ops counting so that we
853 	 * don't suspend at a bad time.
854 	 */
855 	while ((mp = getq(qp))) {
856 #endif
857 		switch (kbtrans_streams_message(kb8042->hw_kbtrans, mp)) {
858 		case KBTRANS_MESSAGE_HANDLED:
859 			continue;
860 		case KBTRANS_MESSAGE_NOT_HANDLED:
861 			break;
862 		}
863 		switch (mp->b_datap->db_type) {
864 		case M_IOCTL:
865 			kb8042_ioctlmsg(kb8042, qp, mp);
866 			continue;
867 		case M_IOCDATA:
868 			kb8042_iocdatamsg(qp, mp);
869 			continue;
870 		case M_DELAY:
871 		case M_STARTI:
872 		case M_STOPI:
873 		case M_READ:	/* ignore, no buffered data */
874 			freemsg(mp);
875 			continue;
876 		case M_FLUSH:
877 			*mp->b_rptr &= ~FLUSHW;
878 			if (*mp->b_rptr & FLUSHR)
879 				qreply(qp, mp);
880 			else
881 				freemsg(mp);
882 			continue;
883 		default:
884 			cmn_err(CE_NOTE, "kb8042_wsrv: bad msg %x",
885 			    mp->b_datap->db_type);
886 			freemsg(mp);
887 			continue;
888 		}
889 	}
890 
891 	mutex_enter(&kb8042->w_hw_mutex);
892 	if (!suspended) {
893 		ASSERT(kb8042->ops > 0);
894 		kb8042->ops--;
895 		if (kb8042->ops == 0)
896 			cv_broadcast(&kb8042->ops_cv);
897 	}
898 	mutex_exit(&kb8042->w_hw_mutex);
899 
900 	return (0);
901 }
902 
903 static void
904 kb8042_ioctlmsg(struct kb8042 *kb8042, queue_t *qp, mblk_t *mp)
905 {
906 	struct iocblk	*iocp;
907 	mblk_t		*datap;
908 	int		error;
909 	int		tmp;
910 	int		cycles;
911 	int		frequency;
912 	int		msecs;
913 
914 	iocp = (struct iocblk *)mp->b_rptr;
915 
916 	switch (iocp->ioc_cmd) {
917 
918 	case CONSOPENPOLLEDIO:
919 		error = miocpullup(mp, sizeof (struct cons_polledio *));
920 		if (error != 0) {
921 			miocnak(qp, mp, 0, error);
922 			return;
923 		}
924 
925 		/*
926 		 * We are given an appropriate-sized data block,
927 		 * and return a pointer to our structure in it.
928 		 */
929 		*(struct cons_polledio **)mp->b_cont->b_rptr =
930 		    &kb8042->polledio;
931 		mp->b_datap->db_type = M_IOCACK;
932 		iocp->ioc_error = 0;
933 		qreply(qp, mp);
934 		break;
935 
936 	case CONSCLOSEPOLLEDIO:
937 		miocack(qp, mp, 0, 0);
938 		break;
939 
940 	case CONSSETABORTENABLE:
941 		if (iocp->ioc_count != TRANSPARENT) {
942 			miocnak(qp, mp, 0, EINVAL);
943 			return;
944 		}
945 
946 		kb8042->debugger.enabled = *(intptr_t *)mp->b_cont->b_rptr;
947 		miocack(qp, mp, 0, 0);
948 		break;
949 
950 	/*
951 	 * Valid only in TR_UNTRANS_MODE mode.
952 	 */
953 	case CONSSETKBDTYPE:
954 		error = miocpullup(mp, sizeof (int));
955 		if (error != 0) {
956 			miocnak(qp, mp, 0, error);
957 			return;
958 		}
959 		tmp =  *(int *)mp->b_cont->b_rptr;
960 		if (tmp != KB_PC && tmp != KB_USB) {
961 			miocnak(qp, mp, 0, EINVAL);
962 			break;
963 		}
964 		kb8042->simulated_kbd_type = tmp;
965 		miocack(qp, mp, 0, 0);
966 		break;
967 
968 	case KIOCLAYOUT:
969 		if (kb8042->w_kblayout == -1) {
970 			miocnak(qp, mp, 0, EINVAL);
971 			return;
972 		}
973 
974 		if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) {
975 			miocnak(qp, mp, 0, ENOMEM);
976 			return;
977 		}
978 
979 		if (kb8042->simulated_kbd_type == KB_USB)
980 			*(int *)datap->b_wptr = KBTRANS_USBKB_DEFAULT_LAYOUT;
981 		else
982 			*(int *)datap->b_wptr = kb8042->w_kblayout;
983 
984 		datap->b_wptr += sizeof (int);
985 		if (mp->b_cont)
986 			freemsg(mp->b_cont);
987 		mp->b_cont = datap;
988 		iocp->ioc_count = sizeof (int);
989 		mp->b_datap->db_type = M_IOCACK;
990 		iocp->ioc_error = 0;
991 		qreply(qp, mp);
992 		break;
993 
994 	case KIOCSLAYOUT:
995 		if (iocp->ioc_count != TRANSPARENT) {
996 			miocnak(qp, mp, 0, EINVAL);
997 			return;
998 		}
999 
1000 		kb8042->w_kblayout = *(intptr_t *)mp->b_cont->b_rptr;
1001 		miocack(qp, mp, 0, 0);
1002 		break;
1003 
1004 	case KIOCCMD:
1005 		error = miocpullup(mp, sizeof (int));
1006 		if (error != 0) {
1007 			miocnak(qp, mp, 0, error);
1008 			return;
1009 		}
1010 
1011 		kb8042_type4_cmd(kb8042, *(int *)mp->b_cont->b_rptr);
1012 		miocack(qp, mp, 0, 0);
1013 		break;
1014 
1015 	case KIOCMKTONE:
1016 		if (iocp->ioc_count != TRANSPARENT) {
1017 			miocnak(qp, mp, 0, EINVAL);
1018 			return;
1019 		}
1020 
1021 		tmp = (int)(*(intptr_t *)mp->b_cont->b_rptr);
1022 		cycles = tmp & 0xffff;
1023 		msecs = (tmp >> 16) & 0xffff;
1024 
1025 		if (cycles == 0)
1026 			frequency = UINT16_MAX;
1027 		else if (cycles == UINT16_MAX)
1028 			frequency = 0;
1029 		else {
1030 			frequency = (PIT_HZ + cycles / 2) / cycles;
1031 			if (frequency > UINT16_MAX)
1032 				frequency = UINT16_MAX;
1033 		}
1034 
1035 		error = beep_mktone(frequency, msecs);
1036 		if (error != 0)
1037 			miocnak(qp, mp, 0, error);
1038 		else
1039 			miocack(qp, mp, 0, 0);
1040 		break;
1041 
1042 	default:
1043 #ifdef DEBUG1
1044 		cmn_err(CE_NOTE, "!kb8042_ioctlmsg %x", iocp->ioc_cmd);
1045 #endif
1046 		miocnak(qp, mp, 0, EINVAL);
1047 		return;
1048 	}
1049 }
1050 
1051 /*
1052  * Process a byte received from the keyboard
1053  */
1054 static void
1055 kb8042_received_byte(
1056 	struct kb8042	*kb8042,
1057 	int		scancode)	/* raw scan code */
1058 {
1059 	boolean_t	legit;		/* is this a legit key pos'n? */
1060 	int		key_pos = -1;
1061 	enum keystate	state;
1062 	boolean_t	synthetic_release_needed;
1063 
1064 	if (!kb8042->w_init)	/* can't do anything anyway */
1065 		return;
1066 
1067 	legit = KeyboardConvertScan(kb8042, scancode, &key_pos, &state,
1068 	    &synthetic_release_needed);
1069 
1070 	if (legit == 0) {
1071 		/* Eaten by translation */
1072 		return;
1073 	}
1074 
1075 	/*
1076 	 * Don't know if we want this permanently, but it seems interesting
1077 	 * for the moment.
1078 	 */
1079 	if (key_pos == kb8042->debugger.mod1) {
1080 		kb8042->debugger.mod1_down = (state == KEY_PRESSED);
1081 	}
1082 	if (key_pos == kb8042->debugger.mod2) {
1083 		kb8042->debugger.mod2_down = (state == KEY_PRESSED);
1084 	}
1085 	if (kb8042->debugger.enabled &&
1086 	    key_pos == kb8042->debugger.trigger &&
1087 	    kb8042->debugger.mod1_down &&
1088 	    kb8042->debugger.mod2_down) {
1089 		/*
1090 		 * Require new presses of the modifiers.
1091 		 */
1092 		kb8042->debugger.mod1_down = B_FALSE;
1093 		kb8042->debugger.mod2_down = B_FALSE;
1094 		abort_sequence_enter(NULL);
1095 		return;
1096 	}
1097 
1098 	/*
1099 	 * If there's no queue above us - as can happen if we've been
1100 	 * attached but not opened - drop the keystroke.
1101 	 * Note that we do this here instead of above so that
1102 	 * Ctrl-Alt-D still works.
1103 	 */
1104 	if (kb8042->w_qp == NULL) {
1105 		return;
1106 	}
1107 
1108 	/*
1109 	 * This is to filter out auto repeat since it can't be
1110 	 * turned off at the hardware.  (Yeah, yeah, PS/2 keyboards
1111 	 * can.  Don't know whether they've taken over the world.
1112 	 * Don't think so.)
1113 	 */
1114 	if (kb8042_autorepeat_detect(kb8042, key_pos, state)) {
1115 		return;
1116 	}
1117 
1118 
1119 	kb8042_process_key(kb8042, key_pos, state);
1120 
1121 	/*
1122 	 * This is a total hack.  For some stupid reason, the two additional
1123 	 * keys on Korean keyboards (Hangul and Hangul/Hanja) report press
1124 	 * only.  We synthesize a release immediately.
1125 	 */
1126 	if (synthetic_release_needed) {
1127 		(void) kb8042_autorepeat_detect(kb8042, key_pos, KEY_RELEASED);
1128 		kb8042_process_key(kb8042, key_pos, state);
1129 	}
1130 }
1131 
1132 
1133 static void
1134 kb8042_process_key(struct kb8042 *kb8042, kbtrans_key_t key_pos,
1135     enum keystate state)
1136 {
1137 	kbtrans_key_t key;
1138 
1139 	ASSERT(key_pos >= 0 && key_pos <= 255);
1140 	if (kb8042->simulated_kbd_type == KB_PC) {
1141 		kbtrans_streams_key(kb8042->hw_kbtrans, key_pos, state);
1142 	} else if (kb8042->simulated_kbd_type == KB_USB) {
1143 		key = keytab_pc2usb[key_pos];
1144 		if (key != 0) {
1145 			kbtrans_streams_key(kb8042->hw_kbtrans, key, state);
1146 		}
1147 	}
1148 }
1149 
1150 /*
1151  * Called from interrupt handler when keyboard interrupt occurs.
1152  */
1153 static uint_t
1154 kb8042_intr(caddr_t arg)
1155 {
1156 	uchar_t scancode;	/* raw scan code */
1157 	int rc;
1158 	struct kb8042 *kb8042 = (struct kb8042 *)arg;
1159 
1160 	rc = DDI_INTR_UNCLAIMED;
1161 
1162 	if (kb8042->init_state == KB8042_UNINITIALIZED)
1163 		return (DDI_INTR_UNCLAIMED);
1164 
1165 	/* don't care if drv_setparm succeeds */
1166 	(void) drv_setparm(SYSRINT, 1);
1167 
1168 	while (ddi_get8(kb8042->handle, kb8042->addr + I8042_INT_INPUT_AVAIL)
1169 	    != 0) {
1170 		mblk_t *mp;
1171 
1172 		rc = DDI_INTR_CLAIMED;
1173 
1174 		scancode = ddi_get8(kb8042->handle,
1175 		    kb8042->addr + I8042_INT_INPUT_DATA);
1176 
1177 		/*
1178 		 * Intercept ACK and RESEND and signal the condition that
1179 		 * kb8042_send_and_wait is waiting for.
1180 		 */
1181 		switch (scancode) {
1182 		case KB_ACK:
1183 			mutex_enter(&kb8042->w_hw_mutex);
1184 			kb8042->acked = 1;
1185 			cv_signal(&kb8042->cmd_cv);
1186 			mutex_exit(&kb8042->w_hw_mutex);
1187 			return (rc);
1188 		case KB_RESEND:
1189 			mutex_enter(&kb8042->w_hw_mutex);
1190 			kb8042->need_retry = 1;
1191 			cv_signal(&kb8042->cmd_cv);
1192 			mutex_exit(&kb8042->w_hw_mutex);
1193 			return (rc);
1194 		default:
1195 			break;
1196 		}
1197 
1198 		if ((mp = allocb(sizeof (scancode), BPRI_HI)) == NULL)
1199 			return (rc);
1200 		*mp->b_wptr++ = scancode;
1201 		if (putq(RD(kb8042->w_qp), mp) == 0)
1202 			freemsg(mp);
1203 	}
1204 
1205 	return (rc);
1206 }
1207 
1208 static void
1209 kb8042_iocdatamsg(queue_t *qp, mblk_t *mp)
1210 {
1211 	struct copyresp	*csp;
1212 
1213 	csp = (struct copyresp *)mp->b_rptr;
1214 	if (csp->cp_rval) {
1215 		freemsg(mp);
1216 		return;
1217 	}
1218 
1219 	switch (csp->cp_cmd) {
1220 	default:
1221 		miocack(qp, mp, 0, 0);
1222 		break;
1223 	}
1224 }
1225 
1226 static boolean_t
1227 kb8042_polled_keycheck(
1228     struct kbtrans_hardware *hw,
1229     int *key,
1230     enum keystate *state)
1231 {
1232 	struct kb8042 *kb8042 = (struct kb8042 *)hw;
1233 	int	scancode;
1234 	boolean_t	legit;
1235 	boolean_t	synthetic_release_needed;
1236 
1237 	if (kb8042->polled_synthetic_release_pending) {
1238 		*key = kb8042->polled_synthetic_release_key;
1239 		*state = KEY_RELEASED;
1240 		kb8042->polled_synthetic_release_pending = B_FALSE;
1241 		(void) kb8042_autorepeat_detect(kb8042, *key, *state);
1242 		return (B_TRUE);
1243 	}
1244 
1245 	for (;;) {
1246 		if (ddi_get8(kb8042->handle,
1247 		    kb8042->addr + I8042_POLL_INPUT_AVAIL) == 0) {
1248 			return (B_FALSE);
1249 		}
1250 
1251 		scancode = ddi_get8(kb8042->handle,
1252 		    kb8042->addr + I8042_POLL_INPUT_DATA);
1253 
1254 		legit = KeyboardConvertScan(kb8042, scancode, key, state,
1255 		    &synthetic_release_needed);
1256 		if (!legit) {
1257 			continue;
1258 		}
1259 		/*
1260 		 * For the moment at least, we rely on hardware autorepeat
1261 		 * for polled I/O autorepeat.  However, for coordination
1262 		 * with the interrupt-driven code, maintain the last key
1263 		 * pressed.
1264 		 */
1265 		(void) kb8042_autorepeat_detect(kb8042, *key, *state);
1266 
1267 		/*
1268 		 * This is a total hack to support two additional keys
1269 		 * on Korean keyboards.  They report only on press, and
1270 		 * so we synthesize a release.  Most likely this will
1271 		 * never be important to polled  I/O, but if I do it
1272 		 * "right" the first time it _won't_ be an issue.
1273 		 */
1274 		if (synthetic_release_needed) {
1275 			kb8042->polled_synthetic_release_pending = B_TRUE;
1276 			kb8042->polled_synthetic_release_key = *key;
1277 		}
1278 
1279 		if (kb8042->simulated_kbd_type == KB_USB) {
1280 			*key = keytab_pc2usb[*key];
1281 		}
1282 		return (B_TRUE);
1283 	}
1284 }
1285 
1286 static void
1287 kb8042_setled(struct kb8042 *kb8042, int led_state, boolean_t polled)
1288 {
1289 	kb8042->leds.desired = led_state;
1290 
1291 	if (!polled)
1292 		mutex_enter(&kb8042->w_hw_mutex);
1293 
1294 	if (kb8042->leds.desired != kb8042->leds.commanded) {
1295 		kb8042_send_to_keyboard(kb8042, KB_SET_LED, polled);
1296 	}
1297 
1298 	if (!polled)
1299 		mutex_exit(&kb8042->w_hw_mutex);
1300 }
1301 
1302 static void
1303 kb8042_polled_setled(struct kbtrans_hardware *hw, int led_state)
1304 {
1305 	struct kb8042 *kb8042 = (struct kb8042 *)hw;
1306 	kb8042_setled(kb8042, led_state, B_TRUE);
1307 }
1308 
1309 static void
1310 kb8042_streams_setled(struct kbtrans_hardware *hw, int led_state)
1311 {
1312 	struct kb8042 *kb8042 = (struct kb8042 *)hw;
1313 	kb8042_setled(kb8042, led_state, B_FALSE);
1314 }
1315 
1316 
1317 static int
1318 kb8042_send_and_wait(struct kb8042 *kb8042, uint8_t u8, boolean_t polled)
1319 {
1320 	uint8_t *outp = kb8042->addr +
1321 	    (polled ? I8042_POLL_OUTPUT_DATA : I8042_INT_OUTPUT_DATA);
1322 	uint8_t *inavp = kb8042->addr +
1323 	    (polled ? I8042_POLL_INPUT_AVAIL : I8042_INT_INPUT_AVAIL);
1324 	uint8_t *inp = kb8042->addr +
1325 	    (polled ? I8042_POLL_INPUT_DATA : I8042_INT_INPUT_DATA);
1326 	uint8_t b;
1327 	int ms_waited;
1328 	int timedout;
1329 	int expire;
1330 	int retries = 0;
1331 
1332 	do {
1333 		kb8042->acked = 0;
1334 		kb8042->need_retry = 0;
1335 		ms_waited = 0;		/* Zero it whether polled or not */
1336 		timedout = 0;
1337 
1338 		ddi_put8(kb8042->handle, outp, u8);
1339 
1340 		while (!kb8042->acked && !kb8042->need_retry && !timedout) {
1341 
1342 			if (polled) {
1343 				if (ddi_get8(kb8042->handle, inavp)) {
1344 					b = ddi_get8(kb8042->handle, inp);
1345 					switch (b) {
1346 					case KB_ACK:
1347 						kb8042->acked = 1;
1348 						break;
1349 					case KB_RESEND:
1350 						kb8042->need_retry = 1;
1351 						break;
1352 					default:
1353 						/*
1354 						 * drop it: We should never
1355 						 * get scancodes while
1356 						 * we're in the middle of a
1357 						 * command anyway.
1358 						 */
1359 #ifdef DEBUG
1360 						cmn_err(CE_WARN, "!Unexpected "
1361 						    " byte 0x%x", b);
1362 #endif
1363 						break;
1364 					}
1365 				}
1366 
1367 				/*
1368 				 * Wait 1ms if an ACK wasn't received yet
1369 				 */
1370 				if (!kb8042->acked) {
1371 					drv_usecwait(1000);
1372 					ms_waited++;
1373 					if (ms_waited >= MAX_KB8042_WAIT_MAX_MS)
1374 						timedout = B_TRUE;
1375 				}
1376 			} else {
1377 				/* Interrupt-driven */
1378 				expire = ddi_get_lbolt() +
1379 				    drv_usectohz(MAX_KB8042_WAIT_MAX_MS * 1000);
1380 
1381 				/*
1382 				 * If cv_timedwait returned -1 and we neither
1383 				 * received an ACK nor a RETRY response, then
1384 				 * we timed out.
1385 				 */
1386 				if (cv_timedwait(&kb8042->cmd_cv,
1387 				    &kb8042->w_hw_mutex, expire) == -1 &&
1388 				    !kb8042->acked && !kb8042->need_retry) {
1389 					timedout = B_TRUE;
1390 				}
1391 			}
1392 
1393 		}
1394 	} while ((kb8042->need_retry || timedout) &&
1395 	    ++retries < MAX_KB8042_RETRIES);
1396 
1397 	return (kb8042->acked);
1398 }
1399 
1400 /*
1401  * kb8042_send_to_keyboard should be called with w_hw_mutex held if
1402  * polled is FALSE.
1403  */
1404 static void
1405 kb8042_send_to_keyboard(struct kb8042 *kb8042, int byte, boolean_t polled)
1406 {
1407 
1408 	/*
1409 	 * KB_SET_LED and KB_ENABLE are special commands which require blocking
1410 	 * other 8042 consumers while executing.
1411 	 *
1412 	 * Other commands/data are sent using the single put8 I/O access
1413 	 * function.
1414 	 */
1415 	if (byte == KB_SET_LED) {
1416 
1417 		if (!polled) {
1418 			(void) ddi_get8(kb8042->handle, kb8042->addr +
1419 			    I8042_LOCK);
1420 		}
1421 
1422 		if (kb8042_send_and_wait(kb8042, KB_SET_LED, polled)) {
1423 			/*
1424 			 * Ignore return value, as there's nothing we can
1425 			 * do about it if the SET LED command fails.
1426 			 */
1427 			(void) kb8042_send_and_wait(kb8042,
1428 			    kb8042_xlate_leds(kb8042->leds.desired), polled);
1429 		}
1430 
1431 		if (!polled) {
1432 			(void) ddi_get8(kb8042->handle, kb8042->addr +
1433 			    I8042_UNLOCK);
1434 		}
1435 		kb8042->leds.commanded = kb8042->leds.desired;
1436 
1437 	} else if (byte == KB_ENABLE) {
1438 
1439 		if (!polled) {
1440 			(void) ddi_get8(kb8042->handle, kb8042->addr +
1441 			    I8042_LOCK);
1442 		}
1443 
1444 		(void) kb8042_send_and_wait(kb8042, KB_ENABLE, polled);
1445 
1446 		if (!polled) {
1447 			(void) ddi_get8(kb8042->handle, kb8042->addr +
1448 			    I8042_UNLOCK);
1449 		}
1450 
1451 	} else {
1452 		/* All other commands use the "normal" virtual output port */
1453 		if (polled) {
1454 			ddi_put8(kb8042->handle,
1455 			    kb8042->addr + I8042_POLL_OUTPUT_DATA, byte);
1456 		} else {
1457 			ddi_put8(kb8042->handle,
1458 			    kb8042->addr + I8042_INT_OUTPUT_DATA, byte);
1459 		}
1460 	}
1461 }
1462 
1463 /*
1464  * Wait until the keyboard is fully up, maybe.
1465  * We may be the first person to talk to the keyboard, in which case
1466  * it's patiently waiting to say "AA" to us to tell us it's up.
1467  * In theory it sends the AA in 300ms < n < 9s, but it's a pretty
1468  * good bet that we've already spent that long getting to that point,
1469  * so we'll only wait long enough for the communications electronics to
1470  * run.
1471  */
1472 static void
1473 kb8042_wait_poweron(struct kb8042 *kb8042)
1474 {
1475 	int cnt;
1476 	int ready;
1477 
1478 	/* wait for up to 250 ms for a response */
1479 	for (cnt = 0; cnt < 250; cnt++) {
1480 		ready = ddi_get8(kb8042->handle,
1481 		    kb8042->addr + I8042_INT_INPUT_AVAIL);
1482 		if (ready != 0)
1483 			break;
1484 		drv_usecwait(1000);
1485 	}
1486 
1487 	/*
1488 	 * If there's something pending, read and discard it.  If not,
1489 	 * assume things are OK anyway - maybe somebody else ate it
1490 	 * already.  (On a PC, the BIOS almost certainly did.)
1491 	 */
1492 	if (ready != 0) {
1493 		(void) ddi_get8(kb8042->handle,
1494 		    kb8042->addr + I8042_INT_INPUT_DATA);
1495 	}
1496 }
1497 
1498 static int
1499 kb8042_xlate_leds(int led)
1500 {
1501 	int res;
1502 
1503 	res = 0;
1504 
1505 	if (led & LED_NUM_LOCK)
1506 		res |= LED_NUM;
1507 	if (led & LED_SCROLL_LOCK)
1508 		res |= LED_SCR;
1509 	if (led & LED_CAPS_LOCK)
1510 		res |= LED_CAP;
1511 
1512 	return (res);
1513 }
1514 
1515 /*ARGSUSED*/
1516 static void
1517 kb8042_get_initial_leds(
1518     struct kb8042 *kb8042,
1519     int *initial_leds,
1520     int *initial_led_mask)
1521 {
1522 #if defined(__x86)
1523 	extern caddr_t	p0_va;
1524 	uint8_t		bios_kb_flag;
1525 
1526 	bios_kb_flag = p0_va[BIOS_KB_FLAG];
1527 
1528 	*initial_led_mask = LED_CAPS_LOCK | LED_NUM_LOCK | LED_SCROLL_LOCK;
1529 	*initial_leds = 0;
1530 	if (bios_kb_flag & BIOS_CAPS_STATE)
1531 		*initial_leds |= LED_CAPS_LOCK;
1532 	if (bios_kb_flag & BIOS_NUM_STATE)
1533 		*initial_leds |= LED_NUM_LOCK;
1534 	if (bios_kb_flag & BIOS_SCROLL_STATE)
1535 		*initial_leds |= LED_SCROLL_LOCK;
1536 #else
1537 	*initial_leds = 0;
1538 	*initial_led_mask = 0;
1539 #endif
1540 }
1541 
1542 static boolean_t
1543 kb8042_autorepeat_detect(
1544     struct kb8042 *kb8042,
1545     int key_pos,
1546     enum keystate state)
1547 {
1548 	if (state == KEY_RELEASED) {
1549 		if (kb8042->kb_old_key_pos == key_pos)
1550 			kb8042->kb_old_key_pos = 0;
1551 	} else {
1552 		if (kb8042->kb_old_key_pos == key_pos) {
1553 			return (B_TRUE);
1554 		}
1555 		kb8042->kb_old_key_pos = key_pos;
1556 	}
1557 	return (B_FALSE);
1558 }
1559 
1560 /* ARGSUSED */
1561 static void
1562 kb8042_type4_cmd(struct kb8042 *kb8042, int cmd)
1563 {
1564 	switch (cmd) {
1565 	case KBD_CMD_BELL:
1566 		(void) beeper_on(BEEP_TYPE4);
1567 		break;
1568 	case KBD_CMD_NOBELL:
1569 		(void) beeper_off();
1570 		break;
1571 	}
1572 }
1573 
1574 
1575 /*
1576  * This is a pass-thru routine to get a character at poll time.
1577  */
1578 static int
1579 kb8042_polled_getchar(cons_polledio_arg_t arg)
1580 {
1581 	struct kb8042	*kb8042;
1582 
1583 	kb8042 = (struct kb8042 *)arg;
1584 
1585 	return (kbtrans_getchar(kb8042->hw_kbtrans));
1586 }
1587 
1588 /*
1589  * This is a pass-thru routine to get a character at poll time.
1590  */
1591 static int
1592 kb8042_polled_ischar(cons_polledio_arg_t arg)
1593 {
1594 	struct kb8042	*kb8042;
1595 
1596 	kb8042 = (struct kb8042 *)arg;
1597 
1598 	return (kbtrans_ischar(kb8042->hw_kbtrans));
1599 }
1600