1 /* $NetBSD: pckbc.c,v 1.65 2022/11/17 23:57:20 riastradh 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.65 2022/11/17 23:57:20 riastradh 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 const struct pckbport_accessops pckbc_ops = { 89 .t_xt_translation = pckbc_xt_translation, 90 .t_send_devcmd = pckbc_send_devcmd, 91 .t_poll_data1 = pckbc_poll_data1, 92 .t_slot_enable = pckbc_slot_enable, 93 .t_intr_establish = pckbc_intr_establish, 94 .t_set_poll = pckbc_set_poll, 95 }; 96 97 #define KBD_DELAY DELAY(8) 98 99 static inline int 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 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 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 c = bus_space_read_1(t->t_iot, t->t_ioh_d, 0); 150 151 process: 152 if (checkaux && (stat & 0x20)) { /* aux data */ 153 if (slot != PCKBC_AUX_SLOT) { 154 #ifdef PCKBCDEBUG 155 printf("pckbc: lost aux 0x%x\n", c); 156 #endif 157 continue; 158 } 159 } else { 160 if (slot == PCKBC_AUX_SLOT) { 161 #ifdef PCKBCDEBUG 162 printf("pckbc: lost kbd 0x%x\n", c); 163 #endif 164 continue; 165 } 166 } 167 splx(s); 168 return (c); 169 } 170 } 171 172 splx(s); 173 return (-1); 174 } 175 176 /* 177 * Get the current command byte. 178 */ 179 static int 180 pckbc_get8042cmd(struct pckbc_internal *t) 181 { 182 bus_space_tag_t iot = t->t_iot; 183 bus_space_handle_t ioh_c = t->t_ioh_c; 184 int data; 185 186 if (!pckbc_send_cmd(iot, ioh_c, K_RDCMDBYTE)) 187 return (0); 188 data = pckbc_poll_data1(t, PCKBC_KBD_SLOT); 189 if (data == -1) 190 return (0); 191 t->t_cmdbyte = data; 192 return (1); 193 } 194 195 /* 196 * Pass command byte to keyboard controller (8042). 197 */ 198 static int 199 pckbc_put8042cmd(struct pckbc_internal *t) 200 { 201 bus_space_tag_t iot = t->t_iot; 202 bus_space_handle_t ioh_d = t->t_ioh_d; 203 bus_space_handle_t ioh_c = t->t_ioh_c; 204 205 if (!pckbc_send_cmd(iot, ioh_c, K_LDCMDBYTE)) 206 return (0); 207 if (!pckbc_wait_output(iot, ioh_c)) 208 return (0); 209 bus_space_write_1(iot, ioh_d, 0, t->t_cmdbyte); 210 return (1); 211 } 212 213 static int 214 pckbc_send_devcmd(void *pt, pckbc_slot_t slot, u_char val) 215 { 216 struct pckbc_internal *t = pt; 217 bus_space_tag_t iot = t->t_iot; 218 bus_space_handle_t ioh_d = t->t_ioh_d; 219 bus_space_handle_t ioh_c = t->t_ioh_c; 220 221 if (slot == PCKBC_AUX_SLOT) { 222 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE)) 223 return (0); 224 } 225 if (!pckbc_wait_output(iot, ioh_c)) 226 return (0); 227 bus_space_write_1(iot, ioh_d, 0, val); 228 return (1); 229 } 230 231 int 232 pckbc_is_console(bus_space_tag_t iot, bus_addr_t addr) 233 { 234 if (pckbc_console && !pckbc_console_attached && 235 bus_space_is_equal(pckbc_consdata.t_iot, iot) && 236 pckbc_consdata.t_addr == addr) 237 return (1); 238 return (0); 239 } 240 241 static int 242 pckbc_attach_slot(struct pckbc_softc *sc, pckbc_slot_t slot) 243 { 244 struct pckbc_internal *t = sc->id; 245 void *sdata; 246 device_t child; 247 int alloced = 0; 248 249 if (t->t_slotdata[slot] == NULL) { 250 sdata = malloc(sizeof(struct pckbc_slotdata), 251 M_DEVBUF, M_WAITOK); 252 t->t_slotdata[slot] = sdata; 253 pckbc_init_slotdata(t->t_slotdata[slot]); 254 alloced++; 255 } 256 257 child = pckbport_attach_slot(sc->sc_dv, t->t_pt, slot); 258 259 if (child == NULL && alloced) { 260 free(t->t_slotdata[slot], M_DEVBUF); 261 t->t_slotdata[slot] = NULL; 262 } 263 264 if (child != NULL && t->t_slotdata[slot] != NULL) { 265 memset(&t->t_slotdata[slot]->rnd_source, 0, 266 sizeof(t->t_slotdata[slot]->rnd_source)); 267 rnd_attach_source(&t->t_slotdata[slot]->rnd_source, 268 device_xname(child), RND_TYPE_TTY, RND_FLAG_DEFAULT); 269 } 270 271 return child != NULL; 272 } 273 274 void 275 pckbc_attach(struct pckbc_softc *sc) 276 { 277 struct pckbc_internal *t; 278 bus_space_tag_t iot; 279 bus_space_handle_t ioh_d, ioh_c; 280 int res; 281 u_char cmdbits = 0; 282 283 t = sc->id; 284 iot = t->t_iot; 285 ioh_d = t->t_ioh_d; 286 ioh_c = t->t_ioh_c; 287 288 t->t_pt = pckbport_attach(t, &pckbc_ops); 289 if (t->t_pt == NULL) { 290 aprint_error(": attach failed\n"); 291 return; 292 } 293 294 /* flush */ 295 (void) pckbc_poll_data1(t, PCKBC_KBD_SLOT); 296 297 /* set initial cmd byte */ 298 if (!pckbc_put8042cmd(t)) { 299 aprint_error("pckbc: cmd word write error\n"); 300 return; 301 } 302 303 /* 304 * XXX Don't check the keyboard port. There are broken keyboard controllers 305 * which don't pass the test but work normally otherwise. 306 */ 307 #if 0 308 /* 309 * check kbd port ok 310 */ 311 if (!pckbc_send_cmd(iot, ioh_c, KBC_KBDTEST)) 312 return; 313 res = pckbc_poll_data1(t, PCKBC_KBD_SLOT); 314 315 /* 316 * Normally, we should get a "0" here. 317 * But there are keyboard controllers behaving differently. 318 */ 319 if (!(res == 0 || res == 0xfa || res == 0x01 || res == 0xab)) { 320 printf("pckbc: kbd port test: %x\n", res); 321 return; 322 } 323 #ifdef PCKBCDEBUG 324 if (res != 0) 325 printf("pckbc: returned %x on kbd slot test\n", res); 326 #endif 327 #endif /* 0 */ 328 if (pckbc_attach_slot(sc, PCKBC_KBD_SLOT)) 329 cmdbits |= KC8_KENABLE; 330 331 /* 332 * Check aux port ok. 333 * Avoid KBC_AUXTEST because it hangs some older controllers 334 * (eg UMC880?). 335 */ 336 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXECHO)) { 337 aprint_error("pckbc: aux echo error 1\n"); 338 goto nomouse; 339 } 340 if (!pckbc_wait_output(iot, ioh_c)) { 341 aprint_error("pckbc: aux echo error 2\n"); 342 goto nomouse; 343 } 344 t->t_haveaux = 1; 345 bus_space_write_1(iot, ioh_d, 0, 0x5a); /* a random value */ 346 res = pckbc_poll_data1(t, PCKBC_AUX_SLOT); 347 348 /* 349 * The following is needed to find the aux port on the Tadpole 350 * SPARCle. 351 */ 352 if (res == -1 && ISSET(t->t_flags, PCKBC_NEED_AUXWRITE)) { 353 /* Read of aux echo timed out, try again */ 354 if (!pckbc_send_cmd(iot, ioh_c, KBC_AUXWRITE)) 355 goto nomouse; 356 if (!pckbc_wait_output(iot, ioh_c)) 357 goto nomouse; 358 bus_space_write_1(iot, ioh_d, 0, 0x5a); 359 res = pckbc_poll_data1(t, PCKBC_AUX_SLOT); 360 } 361 if (res != -1) { 362 /* 363 * In most cases, the 0x5a gets echoed. 364 * Some older controllers (Gateway 2000 circa 1993) 365 * return 0xfe here. 366 * We are satisfied if there is anything in the 367 * aux output buffer. 368 */ 369 if (pckbc_attach_slot(sc, PCKBC_AUX_SLOT)) 370 cmdbits |= KC8_MENABLE; 371 } else { 372 373 #ifdef PCKBCDEBUG 374 printf("pckbc: aux echo test failed\n"); 375 #endif 376 t->t_haveaux = 0; 377 } 378 379 nomouse: 380 /* enable needed interrupts */ 381 t->t_cmdbyte |= cmdbits; 382 if (!pckbc_put8042cmd(t)) 383 aprint_error("pckbc: cmd word write error\n"); 384 } 385 386 static void 387 pckbc_init_slotdata(struct pckbc_slotdata *q) 388 { 389 390 q->polling = 0; 391 } 392 393 /* 394 * switch scancode translation on / off 395 * return nonzero on success 396 */ 397 static int 398 pckbc_xt_translation(void *self, pckbc_slot_t slot, int on) 399 { 400 struct pckbc_internal *t = self; 401 int ison; 402 403 if (ISSET(t->t_flags, PCKBC_CANT_TRANSLATE)) 404 return (-1); 405 406 if (slot != PCKBC_KBD_SLOT) { 407 /* translation only for kbd slot */ 408 if (on) 409 return (0); 410 else 411 return (1); 412 } 413 414 ison = t->t_cmdbyte & KC8_TRANS; 415 if ((on && ison) || (!on && !ison)) 416 return (1); 417 418 t->t_cmdbyte ^= KC8_TRANS; 419 if (!pckbc_put8042cmd(t)) 420 return (0); 421 422 /* read back to be sure */ 423 if (!pckbc_get8042cmd(t)) 424 return (0); 425 426 ison = t->t_cmdbyte & KC8_TRANS; 427 if ((on && ison) || (!on && !ison)) 428 return (1); 429 return (0); 430 } 431 432 static const struct pckbc_portcmd { 433 u_char cmd_en, cmd_dis; 434 } pckbc_portcmd[2] = { 435 { 436 KBC_KBDENABLE, KBC_KBDDISABLE, 437 }, { 438 KBC_AUXENABLE, KBC_AUXDISABLE, 439 } 440 }; 441 442 void 443 pckbc_slot_enable(void *self, pckbc_slot_t slot, int on) 444 { 445 struct pckbc_internal *t = (struct pckbc_internal *)self; 446 const struct pckbc_portcmd *cmd; 447 448 cmd = &pckbc_portcmd[slot]; 449 450 if (!pckbc_send_cmd(t->t_iot, t->t_ioh_c, 451 on ? cmd->cmd_en : cmd->cmd_dis)) 452 printf("pckbc: pckbc_slot_enable(%d) failed\n", on); 453 } 454 455 static void 456 pckbc_set_poll(void *self, pckbc_slot_t slot, int on) 457 { 458 struct pckbc_internal *t = (struct pckbc_internal *)self; 459 460 t->t_slotdata[slot]->polling = on; 461 462 if (on) { 463 t->t_slotdata[slot]->poll_data = -1; 464 t->t_slotdata[slot]->poll_stat = -1; 465 } else { 466 int s; 467 468 /* 469 * If disabling polling on a device that's been configured, 470 * make sure there are no bytes left in the FIFO, holding up 471 * the interrupt line. Otherwise we won't get any further 472 * interrupts. 473 */ 474 if (t->t_sc) { 475 s = spltty(); 476 pckbcintr(t->t_sc); 477 splx(s); 478 } 479 } 480 } 481 482 static void 483 pckbc_intr_establish(void *pt, pckbport_slot_t slot) 484 { 485 struct pckbc_internal *t = pt; 486 487 (*t->t_sc->intr_establish)(t->t_sc, slot); 488 } 489 490 int 491 pckbcintr_hard(void *vsc) 492 { 493 struct pckbc_softc *sc = (struct pckbc_softc *)vsc; 494 struct pckbc_internal *t = sc->id; 495 u_char stat; 496 pckbc_slot_t slot; 497 struct pckbc_slotdata *q; 498 int served = 0, data, next, s; 499 500 for(;;) { 501 stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0); 502 if (!(stat & KBS_DIB)) 503 break; 504 505 served = 1; 506 507 slot = (t->t_haveaux && (stat & 0x20)) ? 508 PCKBC_AUX_SLOT : PCKBC_KBD_SLOT; 509 q = t->t_slotdata[slot]; 510 511 if (!q) { 512 /* XXX do something for live insertion? */ 513 printf("pckbc: no dev for slot %d\n", slot); 514 (void) bus_space_read_1(t->t_iot, t->t_ioh_d, 0); 515 continue; 516 } 517 518 data = bus_space_read_1(t->t_iot, t->t_ioh_d, 0); 519 520 rnd_add_uint32(&q->rnd_source, (stat<<8)|data); 521 522 if (q->polling) { 523 q->poll_data = data; 524 q->poll_stat = stat; 525 break; /* pckbc_poll_data() will get it */ 526 } 527 528 #if 0 /* XXXBJH */ 529 if (CMD_IN_QUEUE(q) && pckbc_cmdresponse(t, slot, data)) 530 continue; 531 #endif 532 533 s = splhigh(); 534 next = (t->rbuf_write+1) % PCKBC_RBUF_SIZE; 535 if (next == t->rbuf_read) { 536 splx(s); 537 break; 538 } 539 t->rbuf[t->rbuf_write].data = data; 540 t->rbuf[t->rbuf_write].slot = slot; 541 t->rbuf_write = next; 542 splx(s); 543 } 544 545 return (served); 546 } 547 548 void 549 pckbcintr_soft(void *vsc) 550 { 551 struct pckbc_softc *sc = vsc; 552 struct pckbc_internal *t = sc->id; 553 int data, slot, s; 554 #ifndef __GENERIC_SOFT_INTERRUPTS_ALL_LEVELS 555 int st; 556 557 st = spltty(); 558 #endif 559 560 s = splhigh(); 561 while (t->rbuf_read != t->rbuf_write) { 562 slot = t->rbuf[t->rbuf_read].slot; 563 data = t->rbuf[t->rbuf_read].data; 564 t->rbuf_read = (t->rbuf_read+1) % PCKBC_RBUF_SIZE; 565 splx(s); 566 pckbportintr(t->t_pt, slot, data); 567 s = splhigh(); 568 } 569 splx(s); 570 571 572 #ifndef __GENERIC_SOFT_INTERRUPTS_ALL_LEVELS 573 splx(st); 574 #endif 575 } 576 577 int 578 pckbcintr(void *vsc) 579 { 580 struct pckbc_softc *sc = (struct pckbc_softc *)vsc; 581 struct pckbc_internal *t = sc->id; 582 u_char stat; 583 pckbc_slot_t slot; 584 struct pckbc_slotdata *q; 585 int served = 0, data; 586 587 for(;;) { 588 stat = bus_space_read_1(t->t_iot, t->t_ioh_c, 0); 589 if (!(stat & KBS_DIB)) 590 break; 591 592 slot = (t->t_haveaux && (stat & 0x20)) ? 593 PCKBC_AUX_SLOT : PCKBC_KBD_SLOT; 594 q = t->t_slotdata[slot]; 595 596 if (q != NULL && q->polling) 597 return 0; 598 599 served = 1; 600 data = bus_space_read_1(t->t_iot, t->t_ioh_d, 0); 601 602 if (q != NULL) 603 rnd_add_uint32(&q->rnd_source, (stat<<8)|data); 604 605 pckbportintr(t->t_pt, slot, data); 606 } 607 608 return (served); 609 } 610 611 int 612 pckbc_cnattach(bus_space_tag_t iot, bus_addr_t addr, 613 bus_size_t cmd_offset, pckbc_slot_t slot, int flags) 614 { 615 bus_space_handle_t ioh_d, ioh_c; 616 #ifdef PCKBC_CNATTACH_SELFTEST 617 int reply; 618 #endif 619 int res = 0; 620 621 if (bus_space_map(iot, addr + KBDATAP, 1, 0, &ioh_d)) 622 return (ENXIO); 623 if (bus_space_map(iot, addr + cmd_offset, 1, 0, &ioh_c)) { 624 bus_space_unmap(iot, ioh_d, 1); 625 return (ENXIO); 626 } 627 628 memset(&pckbc_consdata, 0, sizeof(pckbc_consdata)); 629 pckbc_consdata.t_iot = iot; 630 pckbc_consdata.t_ioh_d = ioh_d; 631 pckbc_consdata.t_ioh_c = ioh_c; 632 pckbc_consdata.t_addr = addr; 633 pckbc_consdata.t_flags = flags; 634 callout_init(&pckbc_consdata.t_cleanup, 0); 635 636 /* flush */ 637 (void) pckbc_poll_data1(&pckbc_consdata, PCKBC_KBD_SLOT); 638 639 #ifdef PCKBC_CNATTACH_SELFTEST 640 /* 641 * In some machines (e.g. netwinder) pckbc refuses to talk at 642 * all until we request a self-test. 643 */ 644 if (!pckbc_send_cmd(iot, ioh_c, KBC_SELFTEST)) { 645 printf("pckbc: unable to request selftest\n"); 646 res = EIO; 647 goto out; 648 } 649 650 reply = pckbc_poll_data1(&pckbc_consdata, PCKBC_KBD_SLOT); 651 if (reply != 0x55) { 652 printf("pckbc: selftest returned 0x%02x\n", reply); 653 res = EIO; 654 goto out; 655 } 656 #endif /* PCKBC_CNATTACH_SELFTEST */ 657 658 /* init cmd byte, enable ports */ 659 pckbc_consdata.t_cmdbyte = KC8_CPU; 660 if (!pckbc_put8042cmd(&pckbc_consdata)) { 661 printf("pckbc: cmd word write error\n"); 662 res = EIO; 663 goto out; 664 } 665 666 res = pckbport_cnattach(&pckbc_consdata, &pckbc_ops, slot); 667 668 out: 669 if (res) { 670 bus_space_unmap(iot, pckbc_consdata.t_ioh_d, 1); 671 bus_space_unmap(iot, pckbc_consdata.t_ioh_c, 1); 672 } else { 673 pckbc_consdata.t_slotdata[slot] = &pckbc_cons_slotdata; 674 pckbc_init_slotdata(&pckbc_cons_slotdata); 675 pckbc_console = 1; 676 } 677 678 return (res); 679 } 680 681 bool 682 pckbc_resume(device_t dv, const pmf_qual_t *qual) 683 { 684 struct pckbc_softc *sc = device_private(dv); 685 struct pckbc_internal *t; 686 687 t = sc->id; 688 (void)pckbc_poll_data1(t, PCKBC_KBD_SLOT); 689 if (!pckbc_send_cmd(t->t_iot, t->t_ioh_c, KBC_SELFTEST)) 690 return false; 691 (void)pckbc_poll_data1(t, PCKBC_KBD_SLOT); 692 (void)pckbc_put8042cmd(t); 693 pckbcintr(t->t_sc); 694 695 return true; 696 } 697
Indexes created Sat Sep 20 22:09:52 GMT 2025