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