1 /* $NetBSD: pckbc.c,v 1.59 2016/07/14 10:19:06 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 2004 Ben Harris.
5 * Copyright (c) 1998
6 * Matthias Drochner. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: pckbc.c,v 1.59 2016/07/14 10:19:06 msaitoh Exp $");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/callout.h>
35 #include <sys/kernel.h>
36 #include <sys/proc.h>
37 #include <sys/device.h>
38 #include <sys/malloc.h>
39 #include <sys/errno.h>
40 #include <sys/queue.h>
41
42 #include <sys/bus.h>
43
44 #include <dev/ic/i8042reg.h>
45 #include <dev/ic/pckbcvar.h>
46
47 #include <dev/pckbport/pckbportvar.h>
48
49 #include "locators.h"
50
51 #include <sys/rndsource.h>
52
53 /* data per slave device */
54 struct pckbc_slotdata {
55 int polling; /* don't process data in interrupt handler */
56 int poll_data; /* data read from inr handler if polling */
57 int poll_stat; /* status read from inr handler if polling */
58 krndsource_t rnd_source;
59 };
60
61 static void pckbc_init_slotdata(struct pckbc_slotdata *);
62 static int pckbc_attach_slot(struct pckbc_softc *, pckbc_slot_t);
63
64 struct pckbc_internal pckbc_consdata;
65 int pckbc_console_attached;
66
67 static int pckbc_console;
68 static struct pckbc_slotdata pckbc_cons_slotdata;
69
70 static int pckbc_xt_translation(void *, pckbport_slot_t, int);
71 static int pckbc_send_devcmd(void *, pckbport_slot_t, u_char);
72 static void pckbc_slot_enable(void *, pckbport_slot_t, int);
73 static void pckbc_intr_establish(void *, pckbport_slot_t);
74 static void pckbc_set_poll(void *, pckbc_slot_t, int on);
75
76 static int pckbc_wait_output(bus_space_tag_t, bus_space_handle_t);
77
78 static int pckbc_get8042cmd(struct pckbc_internal *);
79 static int pckbc_put8042cmd(struct pckbc_internal *);
80
81 void pckbc_cleanqueue(struct pckbc_slotdata *);
82 void pckbc_cleanup(void *);
83 int pckbc_cmdresponse(struct pckbc_internal *, pckbc_slot_t, u_char);
84 void pckbc_start(struct pckbc_internal *, pckbc_slot_t);
85
86 const char * const pckbc_slot_names[] = { "kbd", "aux" };
87
88 static struct pckbport_accessops const pckbc_ops = {
89 pckbc_xt_translation,
90 pckbc_send_devcmd,
91 pckbc_poll_data1,
92 pckbc_slot_enable,
93 pckbc_intr_establish,
94 pckbc_set_poll
95 };
96
97 #define KBD_DELAY DELAY(8)
98
99 static inline int
pckbc_wait_output(bus_space_tag_t iot,bus_space_handle_t ioh_c)100 pckbc_wait_output(bus_space_tag_t iot, bus_space_handle_t ioh_c)
101 {
102 u_int i;
103
104 for (i = 100000; i; i--)
105 if (!(bus_space_read_1(iot, ioh_c, 0) & KBS_IBF)) {
106 KBD_DELAY;
107 return (1);
108 }
109 return (0);
110 }
111
112 int
pckbc_send_cmd(bus_space_tag_t iot,bus_space_handle_t ioh_c,u_char val)113 pckbc_send_cmd(bus_space_tag_t iot, bus_space_handle_t ioh_c, u_char val)
114 {
115 if (!pckbc_wait_output(iot, ioh_c))
116 return (0);
117 bus_space_write_1(iot, ioh_c, 0, val);
118 return (1);
119 }
120
121 /*
122 * Note: the spl games here are to deal with some strange PC kbd controllers
123 * in some system configurations.
124 * This is not canonical way to handle polling input.
125 */
126 int
pckbc_poll_data1(void * pt,pckbc_slot_t slot)127 pckbc_poll_data1(void *pt, pckbc_slot_t slot)
128 {
129 struct pckbc_internal *t = pt;
130 struct pckbc_slotdata *q = t->t_slotdata[slot];
131 int s;
132 u_char stat, c;
133 int i = 100; /* polls for ~100ms */
134 int checkaux = t->t_haveaux;
135
136 s = splhigh();
137
138 if (q && q->polling && q->poll_data != -1 && q->poll_stat != -1) {
139 stat = q->poll_stat;
140 c = q->poll_data;
141 q->poll_data = -1;
142 q->poll_stat = -1;
143 goto process;
144 }
145
146 for (; i; i--, delay(1000)) {
147 stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0);
148 if (stat & KBS_DIB) {
149 KBD_DELAY;
150 c = bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
151
152 process:
153 if (checkaux && (stat & 0x20)) { /* aux data */
154 if (slot != PCKBC_AUX_SLOT) {
155 #ifdef PCKBCDEBUG
156 printf("pckbc: lost aux 0x%x\n", c);
157 #endif
158 continue;
159 }
160 } else {
161 if (slot == PCKBC_AUX_SLOT) {
162 #ifdef PCKBCDEBUG
163 printf("pckbc: lost kbd 0x%x\n", c);
164 #endif
165 continue;
166 }
167 }
168 splx(s);
169 return (c);
170 }
171 }
172
173 splx(s);
174 return (-1);
175 }
176
177 /*
178 * Get the current command byte.
179 */
180 static int
pckbc_get8042cmd(struct pckbc_internal * t)181 pckbc_get8042cmd(struct pckbc_internal *t)
182 {
183 bus_space_tag_t iot = t->t_iot;
184 bus_space_handle_t ioh_c = t->t_ioh_c;
185 int data;
186
187 if (!pckbc_send_cmd(iot, ioh_c, K_RDCMDBYTE))
188 return (0);
189 data = pckbc_poll_data1(t, PCKBC_KBD_SLOT);
190 if (data == -1)
191 return (0);
192 t->t_cmdbyte = data;
193 return (1);
194 }
195
196 /*
197 * Pass command byte to keyboard controller (8042).
198 */
199 static int
pckbc_put8042cmd(struct pckbc_internal * t)200 pckbc_put8042cmd(struct pckbc_internal *t)
201 {
202 bus_space_tag_t iot = t->t_iot;
203 bus_space_handle_t ioh_d = t->t_ioh_d;
204 bus_space_handle_t ioh_c = t->t_ioh_c;
205
206 if (!pckbc_send_cmd(iot, ioh_c, K_LDCMDBYTE))
207 return (0);
208 if (!pckbc_wait_output(iot, ioh_c))
209 return (0);
210 bus_space_write_1(iot, ioh_d, 0, t->t_cmdbyte);
211 return (1);
212 }
213
214 static int
pckbc_send_devcmd(void * pt,pckbc_slot_t slot,u_char val)215 pckbc_send_devcmd(void *pt, pckbc_slot_t slot, u_char val)
216 {
217 struct pckbc_internal *t = pt;
218 bus_space_tag_t iot = t->t_iot;
219 bus_space_handle_t ioh_d = t->t_ioh_d;
220 bus_space_handle_t ioh_c = t->t_ioh_c;
221
222 if (slot == PCKBC_AUX_SLOT) {
223 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE))
224 return (0);
225 }
226 if (!pckbc_wait_output(iot, ioh_c))
227 return (0);
228 bus_space_write_1(iot, ioh_d, 0, val);
229 return (1);
230 }
231
232 int
pckbc_is_console(bus_space_tag_t iot,bus_addr_t addr)233 pckbc_is_console(bus_space_tag_t iot, bus_addr_t addr)
234 {
235 if (pckbc_console && !pckbc_console_attached &&
236 bus_space_is_equal(pckbc_consdata.t_iot, iot) &&
237 pckbc_consdata.t_addr == addr)
238 return (1);
239 return (0);
240 }
241
242 static int
pckbc_attach_slot(struct pckbc_softc * sc,pckbc_slot_t slot)243 pckbc_attach_slot(struct pckbc_softc *sc, pckbc_slot_t slot)
244 {
245 struct pckbc_internal *t = sc->id;
246 void *sdata;
247 device_t child;
248 int alloced = 0;
249
250 if (t->t_slotdata[slot] == NULL) {
251 sdata = malloc(sizeof(struct pckbc_slotdata),
252 M_DEVBUF, M_NOWAIT);
253 if (sdata == NULL) {
254 aprint_error_dev(sc->sc_dv, "no memory\n");
255 return (0);
256 }
257 t->t_slotdata[slot] = sdata;
258 pckbc_init_slotdata(t->t_slotdata[slot]);
259 alloced++;
260 }
261
262 child = pckbport_attach_slot(sc->sc_dv, t->t_pt, slot);
263
264 if (child == NULL && alloced) {
265 free(t->t_slotdata[slot], M_DEVBUF);
266 t->t_slotdata[slot] = NULL;
267 }
268
269 if (child != NULL && t->t_slotdata[slot] != NULL)
270 rnd_attach_source(&t->t_slotdata[slot]->rnd_source,
271 device_xname(child), RND_TYPE_TTY, RND_FLAG_DEFAULT);
272
273 return child != NULL;
274 }
275
276 void
pckbc_attach(struct pckbc_softc * sc)277 pckbc_attach(struct pckbc_softc *sc)
278 {
279 struct pckbc_internal *t;
280 bus_space_tag_t iot;
281 bus_space_handle_t ioh_d, ioh_c;
282 int res;
283 u_char cmdbits = 0;
284
285 t = sc->id;
286 iot = t->t_iot;
287 ioh_d = t->t_ioh_d;
288 ioh_c = t->t_ioh_c;
289
290 t->t_pt = pckbport_attach(t, &pckbc_ops);
291 if (t->t_pt == NULL) {
292 aprint_error(": attach failed\n");
293 return;
294 }
295
296 /* flush */
297 (void) pckbc_poll_data1(t, PCKBC_KBD_SLOT);
298
299 /* set initial cmd byte */
300 if (!pckbc_put8042cmd(t)) {
301 aprint_error("pckbc: cmd word write error\n");
302 return;
303 }
304
305 /*
306 * XXX Don't check the keyboard port. There are broken keyboard controllers
307 * which don't pass the test but work normally otherwise.
308 */
309 #if 0
310 /*
311 * check kbd port ok
312 */
313 if (!pckbc_send_cmd(iot, ioh_c, KBC_KBDTEST))
314 return;
315 res = pckbc_poll_data1(t, PCKBC_KBD_SLOT, 0);
316
317 /*
318 * Normally, we should get a "0" here.
319 * But there are keyboard controllers behaving differently.
320 */
321 if (res == 0 || res == 0xfa || res == 0x01 || res == 0xab) {
322 #ifdef PCKBCDEBUG
323 if (res != 0)
324 printf("pckbc: returned %x on kbd slot test\n", res);
325 #endif
326 if (pckbc_attach_slot(sc, PCKBC_KBD_SLOT))
327 cmdbits |= KC8_KENABLE;
328 } else {
329 printf("pckbc: kbd port test: %x\n", res);
330 return;
331 }
332 #else
333 if (pckbc_attach_slot(sc, PCKBC_KBD_SLOT))
334 cmdbits |= KC8_KENABLE;
335 #endif /* 0 */
336
337 /*
338 * Check aux port ok.
339 * Avoid KBC_AUXTEST because it hangs some older controllers
340 * (eg UMC880?).
341 */
342 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXECHO)) {
343 aprint_error("pckbc: aux echo error 1\n");
344 goto nomouse;
345 }
346 if (!pckbc_wait_output(iot, ioh_c)) {
347 aprint_error("pckbc: aux echo error 2\n");
348 goto nomouse;
349 }
350 t->t_haveaux = 1;
351 bus_space_write_1(iot, ioh_d, 0, 0x5a); /* a random value */
352 res = pckbc_poll_data1(t, PCKBC_AUX_SLOT);
353
354 /*
355 * The following is needed to find the aux port on the Tadpole
356 * SPARCle.
357 */
358 if (res == -1 && ISSET(t->t_flags, PCKBC_NEED_AUXWRITE)) {
359 /* Read of aux echo timed out, try again */
360 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE))
361 goto nomouse;
362 if (!pckbc_wait_output(iot, ioh_c))
363 goto nomouse;
364 bus_space_write_1(iot, ioh_d, 0, 0x5a);
365 res = pckbc_poll_data1(t, PCKBC_AUX_SLOT);
366 }
367 if (res != -1) {
368 /*
369 * In most cases, the 0x5a gets echoed.
370 * Some older controllers (Gateway 2000 circa 1993)
371 * return 0xfe here.
372 * We are satisfied if there is anything in the
373 * aux output buffer.
374 */
375 if (pckbc_attach_slot(sc, PCKBC_AUX_SLOT))
376 cmdbits |= KC8_MENABLE;
377 } else {
378
379 #ifdef PCKBCDEBUG
380 printf("pckbc: aux echo test failed\n");
381 #endif
382 t->t_haveaux = 0;
383 }
384
385 nomouse:
386 /* enable needed interrupts */
387 t->t_cmdbyte |= cmdbits;
388 if (!pckbc_put8042cmd(t))
389 aprint_error("pckbc: cmd word write error\n");
390 }
391
392 static void
pckbc_init_slotdata(struct pckbc_slotdata * q)393 pckbc_init_slotdata(struct pckbc_slotdata *q)
394 {
395
396 q->polling = 0;
397 }
398
399 /*
400 * switch scancode translation on / off
401 * return nonzero on success
402 */
403 static int
pckbc_xt_translation(void * self,pckbc_slot_t slot,int on)404 pckbc_xt_translation(void *self, pckbc_slot_t slot, int on)
405 {
406 struct pckbc_internal *t = self;
407 int ison;
408
409 if (ISSET(t->t_flags, PCKBC_CANT_TRANSLATE))
410 return (-1);
411
412 if (slot != PCKBC_KBD_SLOT) {
413 /* translation only for kbd slot */
414 if (on)
415 return (0);
416 else
417 return (1);
418 }
419
420 ison = t->t_cmdbyte & KC8_TRANS;
421 if ((on && ison) || (!on && !ison))
422 return (1);
423
424 t->t_cmdbyte ^= KC8_TRANS;
425 if (!pckbc_put8042cmd(t))
426 return (0);
427
428 /* read back to be sure */
429 if (!pckbc_get8042cmd(t))
430 return (0);
431
432 ison = t->t_cmdbyte & KC8_TRANS;
433 if ((on && ison) || (!on && !ison))
434 return (1);
435 return (0);
436 }
437
438 static const struct pckbc_portcmd {
439 u_char cmd_en, cmd_dis;
440 } pckbc_portcmd[2] = {
441 {
442 KBC_KBDENABLE, KBC_KBDDISABLE,
443 }, {
444 KBC_AUXENABLE, KBC_AUXDISABLE,
445 }
446 };
447
448 void
pckbc_slot_enable(void * self,pckbc_slot_t slot,int on)449 pckbc_slot_enable(void *self, pckbc_slot_t slot, int on)
450 {
451 struct pckbc_internal *t = (struct pckbc_internal *)self;
452 const struct pckbc_portcmd *cmd;
453
454 cmd = &pckbc_portcmd[slot];
455
456 if (!pckbc_send_cmd(t->t_iot, t->t_ioh_c,
457 on ? cmd->cmd_en : cmd->cmd_dis))
458 printf("pckbc: pckbc_slot_enable(%d) failed\n", on);
459 }
460
461 static void
pckbc_set_poll(void * self,pckbc_slot_t slot,int on)462 pckbc_set_poll(void *self, pckbc_slot_t slot, int on)
463 {
464 struct pckbc_internal *t = (struct pckbc_internal *)self;
465
466 t->t_slotdata[slot]->polling = on;
467
468 if (on) {
469 t->t_slotdata[slot]->poll_data = -1;
470 t->t_slotdata[slot]->poll_stat = -1;
471 } else {
472 int s;
473
474 /*
475 * If disabling polling on a device that's been configured,
476 * make sure there are no bytes left in the FIFO, holding up
477 * the interrupt line. Otherwise we won't get any further
478 * interrupts.
479 */
480 if (t->t_sc) {
481 s = spltty();
482 pckbcintr(t->t_sc);
483 splx(s);
484 }
485 }
486 }
487
488 static void
pckbc_intr_establish(void * pt,pckbport_slot_t slot)489 pckbc_intr_establish(void *pt, pckbport_slot_t slot)
490 {
491 struct pckbc_internal *t = pt;
492
493 (*t->t_sc->intr_establish)(t->t_sc, slot);
494 }
495
496 int
pckbcintr_hard(void * vsc)497 pckbcintr_hard(void *vsc)
498 {
499 struct pckbc_softc *sc = (struct pckbc_softc *)vsc;
500 struct pckbc_internal *t = sc->id;
501 u_char stat;
502 pckbc_slot_t slot;
503 struct pckbc_slotdata *q;
504 int served = 0, data, next, s;
505
506 for(;;) {
507 stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0);
508 if (!(stat & KBS_DIB))
509 break;
510
511 served = 1;
512
513 slot = (t->t_haveaux && (stat & 0x20)) ?
514 PCKBC_AUX_SLOT : PCKBC_KBD_SLOT;
515 q = t->t_slotdata[slot];
516
517 if (!q) {
518 /* XXX do something for live insertion? */
519 printf("pckbc: no dev for slot %d\n", slot);
520 KBD_DELAY;
521 (void) bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
522 continue;
523 }
524
525 KBD_DELAY;
526 data = bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
527
528 rnd_add_uint32(&q->rnd_source, (stat<<8)|data);
529
530 if (q->polling) {
531 q->poll_data = data;
532 q->poll_stat = stat;
533 break; /* pckbc_poll_data() will get it */
534 }
535
536 #if 0 /* XXXBJH */
537 if (CMD_IN_QUEUE(q) && pckbc_cmdresponse(t, slot, data))
538 continue;
539 #endif
540
541 s = splhigh();
542 next = (t->rbuf_write+1) % PCKBC_RBUF_SIZE;
543 if (next == t->rbuf_read) {
544 splx(s);
545 break;
546 }
547 t->rbuf[t->rbuf_write].data = data;
548 t->rbuf[t->rbuf_write].slot = slot;
549 t->rbuf_write = next;
550 splx(s);
551 }
552
553 return (served);
554 }
555
556 void
pckbcintr_soft(void * vsc)557 pckbcintr_soft(void *vsc)
558 {
559 struct pckbc_softc *sc = vsc;
560 struct pckbc_internal *t = sc->id;
561 int data, slot, s;
562 #ifndef __GENERIC_SOFT_INTERRUPTS_ALL_LEVELS
563 int st;
564
565 st = spltty();
566 #endif
567
568 s = splhigh();
569 while (t->rbuf_read != t->rbuf_write) {
570 slot = t->rbuf[t->rbuf_read].slot;
571 data = t->rbuf[t->rbuf_read].data;
572 t->rbuf_read = (t->rbuf_read+1) % PCKBC_RBUF_SIZE;
573 splx(s);
574 pckbportintr(t->t_pt, slot, data);
575 s = splhigh();
576 }
577 splx(s);
578
579
580 #ifndef __GENERIC_SOFT_INTERRUPTS_ALL_LEVELS
581 splx(st);
582 #endif
583 }
584
585 int
pckbcintr(void * vsc)586 pckbcintr(void *vsc)
587 {
588 struct pckbc_softc *sc = (struct pckbc_softc *)vsc;
589 struct pckbc_internal *t = sc->id;
590 u_char stat;
591 pckbc_slot_t slot;
592 struct pckbc_slotdata *q;
593 int served = 0, data;
594
595 for(;;) {
596 stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0);
597 if (!(stat & KBS_DIB))
598 break;
599
600 slot = (t->t_haveaux && (stat & 0x20)) ?
601 PCKBC_AUX_SLOT : PCKBC_KBD_SLOT;
602 q = t->t_slotdata[slot];
603
604 if (q != NULL && q->polling)
605 return 0;
606
607 served = 1;
608 KBD_DELAY;
609 data = bus_space_read_1(t->t_iot, t->t_ioh_d, 0);
610
611 rnd_add_uint32(&q->rnd_source, (stat<<8)|data);
612
613 pckbportintr(t->t_pt, slot, data);
614 }
615
616 return (served);
617 }
618
619 int
pckbc_cnattach(bus_space_tag_t iot,bus_addr_t addr,bus_size_t cmd_offset,pckbc_slot_t slot,int flags)620 pckbc_cnattach(bus_space_tag_t iot, bus_addr_t addr,
621 bus_size_t cmd_offset, pckbc_slot_t slot, int flags)
622 {
623 bus_space_handle_t ioh_d, ioh_c;
624 #ifdef PCKBC_CNATTACH_SELFTEST
625 int reply;
626 #endif
627 int res = 0;
628
629 if (bus_space_map(iot, addr + KBDATAP, 1, 0, &ioh_d))
630 return (ENXIO);
631 if (bus_space_map(iot, addr + cmd_offset, 1, 0, &ioh_c)) {
632 bus_space_unmap(iot, ioh_d, 1);
633 return (ENXIO);
634 }
635
636 memset(&pckbc_consdata, 0, sizeof(pckbc_consdata));
637 pckbc_consdata.t_iot = iot;
638 pckbc_consdata.t_ioh_d = ioh_d;
639 pckbc_consdata.t_ioh_c = ioh_c;
640 pckbc_consdata.t_addr = addr;
641 pckbc_consdata.t_flags = flags;
642 callout_init(&pckbc_consdata.t_cleanup, 0);
643
644 /* flush */
645 (void) pckbc_poll_data1(&pckbc_consdata, PCKBC_KBD_SLOT);
646
647 #ifdef PCKBC_CNATTACH_SELFTEST
648 /*
649 * In some machines (e.g. netwinder) pckbc refuses to talk at
650 * all until we request a self-test.
651 */
652 if (!pckbc_send_cmd(iot, ioh_c, KBC_SELFTEST)) {
653 printf("pckbc: unable to request selftest\n");
654 res = EIO;
655 goto out;
656 }
657
658 reply = pckbc_poll_data1(&pckbc_consdata, PCKBC_KBD_SLOT);
659 if (reply != 0x55) {
660 printf("pckbc: selftest returned 0x%02x\n", reply);
661 res = EIO;
662 goto out;
663 }
664 #endif /* PCKBC_CNATTACH_SELFTEST */
665
666 /* init cmd byte, enable ports */
667 pckbc_consdata.t_cmdbyte = KC8_CPU;
668 if (!pckbc_put8042cmd(&pckbc_consdata)) {
669 printf("pckbc: cmd word write error\n");
670 res = EIO;
671 goto out;
672 }
673
674 res = pckbport_cnattach(&pckbc_consdata, &pckbc_ops, slot);
675
676 out:
677 if (res) {
678 bus_space_unmap(iot, pckbc_consdata.t_ioh_d, 1);
679 bus_space_unmap(iot, pckbc_consdata.t_ioh_c, 1);
680 } else {
681 pckbc_consdata.t_slotdata[slot] = &pckbc_cons_slotdata;
682 pckbc_init_slotdata(&pckbc_cons_slotdata);
683 pckbc_console = 1;
684 }
685
686 return (res);
687 }
688
689 bool
pckbc_resume(device_t dv,const pmf_qual_t * qual)690 pckbc_resume(device_t dv, const pmf_qual_t *qual)
691 {
692 struct pckbc_softc *sc = device_private(dv);
693 struct pckbc_internal *t;
694
695 t = sc->id;
696 (void)pckbc_poll_data1(t, PCKBC_KBD_SLOT);
697 if (!pckbc_send_cmd(t->t_iot, t->t_ioh_c, KBC_SELFTEST))
698 return false;
699 (void)pckbc_poll_data1(t, PCKBC_KBD_SLOT);
700 (void)pckbc_put8042cmd(t);
701 pckbcintr(t->t_sc);
702
703 return true;
704 }
705