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