1 /* 2 * (MPSAFE) 3 * 4 * Copyright (c) 1996-1999 5 * Kazutaka YOKOTA (yokota@zodiac.mech.utsunomiya-u.ac.jp) 6 * 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 * 3. The name of the author may not be used to endorse or promote 17 * products derived from this software without specific prior written 18 * permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD: src/sys/dev/kbd/atkbdc.c,v 1.5.2.2 2002/03/31 11:02:02 murray Exp $ 33 * $DragonFly: src/sys/dev/misc/kbd/atkbdc.c,v 1.11 2007/04/22 10:54:43 y0netan1 Exp $ 34 * from kbdio.c,v 1.13 1998/09/25 11:55:46 yokota Exp 35 */ 36 37 #include "opt_kbd.h" 38 #include "use_atkbdc.h" 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/bus.h> 43 #include <sys/malloc.h> 44 #include <sys/syslog.h> 45 #include <sys/rman.h> 46 47 #include <machine/clock.h> 48 49 #include "atkbdcreg.h" 50 51 #include <bus/isa/isareg.h> 52 53 #if 0 54 #define lwkt_gettoken(x) 55 #define lwkt_reltoken(x) 56 #endif 57 58 /* constants */ 59 60 #define MAXKBDC MAX(NATKBDC, 1) /* XXX */ 61 62 /* macros */ 63 64 #ifndef MAX 65 #define MAX(x, y) ((x) > (y) ? (x) : (y)) 66 #endif 67 68 #define kbdcp(p) ((atkbdc_softc_t *)(p)) 69 #define nextq(i) (((i) + 1) % KBDQ_BUFSIZE) 70 #define availq(q) ((q)->head != (q)->tail) 71 #if KBDIO_DEBUG >= 2 72 #define emptyq(q) ((q)->tail = (q)->head = (q)->qcount = 0) 73 #else 74 #define emptyq(q) ((q)->tail = (q)->head = 0) 75 #endif 76 77 #define read_data(k) (bus_space_read_1((k)->iot, (k)->ioh0, 0)) 78 #define read_status(k) (bus_space_read_1((k)->iot, (k)->ioh1, 0)) 79 #define write_data(k, d) \ 80 (bus_space_write_1((k)->iot, (k)->ioh0, 0, (d))) 81 #define write_command(k, d) \ 82 (bus_space_write_1((k)->iot, (k)->ioh1, 0, (d))) 83 84 /* local variables */ 85 86 /* 87 * We always need at least one copy of the kbdc_softc struct for the 88 * low-level console. As the low-level console accesses the keyboard 89 * controller before kbdc, and all other devices, is probed, we 90 * statically allocate one entry. XXX 91 */ 92 static atkbdc_softc_t default_kbdc; 93 static atkbdc_softc_t *atkbdc_softc[MAXKBDC] = { &default_kbdc }; 94 95 static int verbose = KBDIO_DEBUG; 96 97 /* function prototypes */ 98 99 static int atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag, 100 bus_space_handle_t h0, bus_space_handle_t h1); 101 static int addq(kbdkqueue *q, int c); 102 static int removeq(kbdkqueue *q); 103 static int wait_while_controller_busy(atkbdc_softc_t *kbdc); 104 static int wait_for_data(atkbdc_softc_t *kbdc); 105 static int wait_for_kbd_data(atkbdc_softc_t *kbdc); 106 static int wait_for_kbd_ack(atkbdc_softc_t *kbdc); 107 static int wait_for_aux_data(atkbdc_softc_t *kbdc); 108 static int wait_for_aux_ack(atkbdc_softc_t *kbdc); 109 110 atkbdc_softc_t * 111 atkbdc_get_softc(int unit) 112 { 113 atkbdc_softc_t *sc; 114 115 if (unit >= sizeof(atkbdc_softc)/sizeof(atkbdc_softc[0])) 116 return NULL; 117 sc = atkbdc_softc[unit]; 118 if (sc == NULL) { 119 sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 120 atkbdc_softc[unit] = sc; 121 } 122 return sc; 123 } 124 125 int 126 atkbdc_probe_unit(int unit, struct resource *port0, struct resource *port1) 127 { 128 if (rman_get_start(port0) <= 0) 129 return ENXIO; 130 if (rman_get_start(port1) <= 0) 131 return ENXIO; 132 return 0; 133 } 134 135 int 136 atkbdc_attach_unit(int unit, atkbdc_softc_t *sc, struct resource *port0, 137 struct resource *port1) 138 { 139 return atkbdc_setup(sc, rman_get_bustag(port0), 140 rman_get_bushandle(port0), 141 rman_get_bushandle(port1)); 142 } 143 144 /* the backdoor to the keyboard controller! XXX */ 145 int 146 atkbdc_configure(void) 147 { 148 bus_space_tag_t tag; 149 bus_space_handle_t h0; 150 bus_space_handle_t h1; 151 int port0; 152 int port1; 153 #if defined(__i386__) || defined(__x86_64__) 154 int i; 155 #endif 156 157 port0 = IO_KBD; 158 resource_int_value("atkbdc", 0, "port", &port0); 159 port1 = IO_KBD + KBD_STATUS_PORT; 160 #if 0 161 resource_int_value("atkbdc", 0, "port", &port0); 162 #endif 163 164 /* XXX: tag should be passed from the caller */ 165 #if defined(__i386__) 166 tag = I386_BUS_SPACE_IO; 167 #else 168 tag = 0; /* XXX */ 169 #endif 170 171 #if notyet 172 bus_space_map(tag, port0, IO_KBDSIZE, 0, &h0); 173 bus_space_map(tag, port1, IO_KBDSIZE, 0, &h1); 174 #else 175 h0 = (bus_space_handle_t)port0; 176 h1 = (bus_space_handle_t)port1; 177 #endif 178 179 #if defined(__i386__) || defined(__x86_64__) 180 /* 181 * Check if we really have AT keyboard controller. Poll status 182 * register until we get "all clear" indication. If no such 183 * indication comes, it probably means that there is no AT 184 * keyboard controller present. Give up in such case. Check relies 185 * on the fact that reading from non-existing in/out port returns 186 * 0xff on i386. May or may not be true on other platforms. 187 */ 188 for (i = 65536; i != 0; --i) { 189 if ((bus_space_read_1(tag, h1, 0) & 0x2) == 0) 190 break; 191 DELAY(16); 192 } 193 if (i == 0) 194 return ENXIO; 195 #endif 196 197 return atkbdc_setup(atkbdc_softc[0], tag, h0, h1); 198 } 199 200 static int 201 atkbdc_setup(atkbdc_softc_t *sc, bus_space_tag_t tag, bus_space_handle_t h0, 202 bus_space_handle_t h1) 203 { 204 if (sc->ioh0 == 0) { /* XXX */ 205 sc->command_byte = -1; 206 sc->command_mask = 0; 207 sc->lock = FALSE; 208 sc->kbd.head = sc->kbd.tail = 0; 209 sc->aux.head = sc->aux.tail = 0; 210 #if KBDIO_DEBUG >= 2 211 sc->kbd.call_count = 0; 212 sc->kbd.qcount = sc->kbd.max_qcount = 0; 213 sc->aux.call_count = 0; 214 sc->aux.qcount = sc->aux.max_qcount = 0; 215 #endif 216 } 217 sc->iot = tag; 218 sc->ioh0 = h0; 219 sc->ioh1 = h1; 220 return 0; 221 } 222 223 /* open a keyboard controller */ 224 KBDC 225 atkbdc_open(int unit) 226 { 227 if (unit <= 0) 228 unit = 0; 229 if (unit >= MAXKBDC) 230 return NULL; 231 if ((atkbdc_softc[unit]->port0 != NULL) 232 || (atkbdc_softc[unit]->ioh0 != 0)) /* XXX */ 233 return (KBDC)atkbdc_softc[unit]; 234 return NULL; 235 } 236 237 /* 238 * I/O access arbitration in `kbdio' 239 * 240 * The `kbdio' module uses a simplistic convention to arbitrate 241 * I/O access to the controller/keyboard/mouse. The convention requires 242 * close cooperation of the calling device driver. 243 * 244 * The device drivers which utilize the `kbdio' module are assumed to 245 * have the following set of routines. 246 * a. An interrupt handler (the bottom half of the driver). 247 * b. Timeout routines which may briefly poll the keyboard controller. 248 * c. Routines outside interrupt context (the top half of the driver). 249 * They should follow the rules below: 250 * 1. The interrupt handler may assume that it always has full access 251 * to the controller/keyboard/mouse. 252 * 2. The other routines must issue `spltty()' if they wish to 253 * prevent the interrupt handler from accessing 254 * the controller/keyboard/mouse. 255 * 3. The timeout routines and the top half routines of the device driver 256 * arbitrate I/O access by observing the lock flag in `kbdio'. 257 * The flag is manipulated via `kbdc_lock()'; when one wants to 258 * perform I/O, call `kbdc_lock(kbdc, TRUE)' and proceed only if 259 * the call returns with TRUE. Otherwise the caller must back off. 260 * Call `kbdc_lock(kbdc, FALSE)' when necessary I/O operaion 261 * is finished. This mechanism does not prevent the interrupt 262 * handler from being invoked at any time and carrying out I/O. 263 * Therefore, `spltty()' must be strategically placed in the device 264 * driver code. Also note that the timeout routine may interrupt 265 * `kbdc_lock()' called by the top half of the driver, but this 266 * interruption is OK so long as the timeout routine observes 267 * rule 4 below. 268 * 4. The interrupt and timeout routines should not extend I/O operation 269 * across more than one interrupt or timeout; they must complete any 270 * necessary I/O operation within one invocation of the routine. 271 * This means that if the timeout routine acquires the lock flag, 272 * it must reset the flag to FALSE before it returns. 273 */ 274 275 /* set/reset polling lock */ 276 int 277 kbdc_lock(KBDC p, int lock) 278 { 279 int prevlock; 280 281 prevlock = kbdcp(p)->lock; 282 kbdcp(p)->lock = lock; 283 284 return (prevlock != lock); 285 } 286 287 /* check if any data is waiting to be processed */ 288 int 289 kbdc_data_ready(KBDC p) 290 { 291 return (availq(&kbdcp(p)->kbd) || availq(&kbdcp(p)->aux) 292 || (read_status(kbdcp(p)) & KBDS_ANY_BUFFER_FULL)); 293 } 294 295 /* queuing functions */ 296 297 static int 298 addq(kbdkqueue *q, int c) 299 { 300 if (nextq(q->tail) != q->head) { 301 q->q[q->tail] = c; 302 q->tail = nextq(q->tail); 303 #if KBDIO_DEBUG >= 2 304 ++q->call_count; 305 ++q->qcount; 306 if (q->qcount > q->max_qcount) 307 q->max_qcount = q->qcount; 308 #endif 309 return TRUE; 310 } 311 return FALSE; 312 } 313 314 static int 315 removeq(kbdkqueue *q) 316 { 317 int c; 318 319 if (q->tail != q->head) { 320 c = q->q[q->head]; 321 q->head = nextq(q->head); 322 #if KBDIO_DEBUG >= 2 323 --q->qcount; 324 #endif 325 return c; 326 } 327 return -1; 328 } 329 330 /* 331 * device I/O routines 332 */ 333 static int 334 wait_while_controller_busy(struct atkbdc_softc *kbdc) 335 { 336 /* CPU will stay inside the loop for 100msec at most */ 337 TOTALDELAY retry = { .us = 70000, .last_clock =0 }; /* 70ms */ 338 int f; 339 340 while ((f = read_status(kbdc)) & KBDS_INPUT_BUFFER_FULL) { 341 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 342 DELAY(KBDD_DELAYTIME); 343 addq(&kbdc->kbd, read_data(kbdc)); 344 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 345 DELAY(KBDD_DELAYTIME); 346 addq(&kbdc->aux, read_data(kbdc)); 347 } 348 DELAY(KBDC_DELAYTIME); 349 if (CHECKTIMEOUT(&retry)) 350 return FALSE; 351 } 352 return TRUE; 353 } 354 355 /* 356 * wait for any data; whether it's from the controller, 357 * the keyboard, or the aux device. 358 */ 359 static int 360 wait_for_data(struct atkbdc_softc *kbdc) 361 { 362 /* CPU will stay inside the loop for 200msec at most */ 363 TOTALDELAY retry = { 200000, 0 }; /* 200ms */ 364 int f; 365 366 while ((f = read_status(kbdc) & KBDS_ANY_BUFFER_FULL) == 0) { 367 DELAY(KBDC_DELAYTIME); 368 if (CHECKTIMEOUT(&retry)) 369 return 0; 370 } 371 DELAY(KBDD_DELAYTIME); 372 return f; 373 } 374 375 /* wait for data from the keyboard */ 376 static int 377 wait_for_kbd_data(struct atkbdc_softc *kbdc) 378 { 379 /* CPU will stay inside the loop for 200msec at most */ 380 TOTALDELAY retry = { 200000, 0 }; /* 200ms */ 381 int f; 382 383 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL) 384 != KBDS_KBD_BUFFER_FULL) { 385 if (f == KBDS_AUX_BUFFER_FULL) { 386 DELAY(KBDD_DELAYTIME); 387 addq(&kbdc->aux, read_data(kbdc)); 388 } 389 DELAY(KBDC_DELAYTIME); 390 if (CHECKTIMEOUT(&retry)) 391 return 0; 392 } 393 DELAY(KBDD_DELAYTIME); 394 return f; 395 } 396 397 /* 398 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the keyboard. 399 * queue anything else. 400 */ 401 static int 402 wait_for_kbd_ack(struct atkbdc_softc *kbdc) 403 { 404 /* CPU will stay inside the loop for 200msec at most */ 405 TOTALDELAY retry = { 200000, 0 }; /* 200ms */ 406 int f; 407 int b; 408 409 while (CHECKTIMEOUT(&retry) == 0) { 410 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) { 411 DELAY(KBDD_DELAYTIME); 412 b = read_data(kbdc); 413 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 414 if ((b == KBD_ACK) || (b == KBD_RESEND) 415 || (b == KBD_RESET_FAIL)) 416 return b; 417 addq(&kbdc->kbd, b); 418 } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 419 addq(&kbdc->aux, b); 420 } 421 } 422 DELAY(KBDC_DELAYTIME); 423 } 424 return -1; 425 } 426 427 /* wait for data from the aux device */ 428 static int 429 wait_for_aux_data(struct atkbdc_softc *kbdc) 430 { 431 /* CPU will stay inside the loop for 200msec at most */ 432 TOTALDELAY retry = { 200000, 0 }; /* 200ms */ 433 int f; 434 435 while ((f = read_status(kbdc) & KBDS_BUFFER_FULL) 436 != KBDS_AUX_BUFFER_FULL) { 437 if (f == KBDS_KBD_BUFFER_FULL) { 438 DELAY(KBDD_DELAYTIME); 439 addq(&kbdc->kbd, read_data(kbdc)); 440 } 441 DELAY(KBDC_DELAYTIME); 442 if (CHECKTIMEOUT(&retry)) 443 return 0; 444 } 445 DELAY(KBDD_DELAYTIME); 446 return f; 447 } 448 449 /* 450 * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the aux device. 451 * queue anything else. 452 */ 453 static int 454 wait_for_aux_ack(struct atkbdc_softc *kbdc) 455 { 456 /* CPU will stay inside the loop for 200msec at most */ 457 TOTALDELAY retry = { 200000, 0 }; /* 200ms */ 458 int f; 459 int b; 460 461 while (CHECKTIMEOUT(&retry) == 0) { 462 if ((f = read_status(kbdc)) & KBDS_ANY_BUFFER_FULL) { 463 DELAY(KBDD_DELAYTIME); 464 b = read_data(kbdc); 465 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 466 if ((b == PSM_ACK) || (b == PSM_RESEND) 467 || (b == PSM_RESET_FAIL)) 468 return b; 469 addq(&kbdc->aux, b); 470 } else if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 471 addq(&kbdc->kbd, b); 472 } 473 } 474 DELAY(KBDC_DELAYTIME); 475 } 476 return -1; 477 } 478 479 /* write a one byte command to the controller */ 480 int 481 write_controller_command(KBDC p, int c) 482 { 483 if (!wait_while_controller_busy(kbdcp(p))) 484 return FALSE; 485 write_command(kbdcp(p), c); 486 return TRUE; 487 } 488 489 /* write a one byte data to the controller */ 490 int 491 write_controller_data(KBDC p, int c) 492 { 493 if (!wait_while_controller_busy(kbdcp(p))) 494 return FALSE; 495 write_data(kbdcp(p), c); 496 return TRUE; 497 } 498 499 /* write a one byte keyboard command */ 500 int 501 write_kbd_command(KBDC p, int c) 502 { 503 if (!wait_while_controller_busy(kbdcp(p))) 504 return FALSE; 505 write_data(kbdcp(p), c); 506 return TRUE; 507 } 508 509 /* write a one byte auxiliary device command */ 510 int 511 write_aux_command(KBDC p, int c) 512 { 513 if (!write_controller_command(p, KBDC_WRITE_TO_AUX)) 514 return FALSE; 515 return write_controller_data(p, c); 516 } 517 518 /* send a command to the keyboard and wait for ACK */ 519 int 520 send_kbd_command(KBDC p, int c) 521 { 522 int retry = KBD_MAXRETRY; 523 int res = -1; 524 525 while (retry-- > 0) { 526 if (!write_kbd_command(p, c)) 527 continue; 528 res = wait_for_kbd_ack(kbdcp(p)); 529 if (res == KBD_ACK) 530 break; 531 } 532 return res; 533 } 534 535 /* send a command to the auxiliary device and wait for ACK */ 536 int 537 send_aux_command(KBDC p, int c) 538 { 539 int retry = KBD_MAXRETRY; 540 int res = -1; 541 542 while (retry-- > 0) { 543 if (!write_aux_command(p, c)) 544 continue; 545 /* 546 * FIXME: XXX 547 * The aux device may have already sent one or two bytes of 548 * status data, when a command is received. It will immediately 549 * stop data transmission, thus, leaving an incomplete data 550 * packet in our buffer. We have to discard any unprocessed 551 * data in order to remove such packets. Well, we may remove 552 * unprocessed, but necessary data byte as well... 553 */ 554 emptyq(&kbdcp(p)->aux); 555 res = wait_for_aux_ack(kbdcp(p)); 556 if (res == PSM_ACK) 557 break; 558 } 559 return res; 560 } 561 562 /* send a command and a data to the keyboard, wait for ACKs */ 563 int 564 send_kbd_command_and_data(KBDC p, int c, int d) 565 { 566 int retry; 567 int res = -1; 568 569 for (retry = KBD_MAXRETRY; retry > 0; --retry) { 570 if (!write_kbd_command(p, c)) 571 continue; 572 res = wait_for_kbd_ack(kbdcp(p)); 573 if (res == KBD_ACK) 574 break; 575 else if (res != KBD_RESEND) 576 return res; 577 } 578 if (retry <= 0) 579 return res; 580 581 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) { 582 if (!write_kbd_command(p, d)) 583 continue; 584 res = wait_for_kbd_ack(kbdcp(p)); 585 if (res != KBD_RESEND) 586 break; 587 } 588 return res; 589 } 590 591 /* send a command and a data to the auxiliary device, wait for ACKs */ 592 int 593 send_aux_command_and_data(KBDC p, int c, int d) 594 { 595 int retry; 596 int res = -1; 597 598 for (retry = KBD_MAXRETRY; retry > 0; --retry) { 599 if (!write_aux_command(p, c)) 600 continue; 601 emptyq(&kbdcp(p)->aux); 602 res = wait_for_aux_ack(kbdcp(p)); 603 if (res == PSM_ACK) 604 break; 605 else if (res != PSM_RESEND) 606 return res; 607 } 608 if (retry <= 0) 609 return res; 610 611 for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) { 612 if (!write_aux_command(p, d)) 613 continue; 614 res = wait_for_aux_ack(kbdcp(p)); 615 if (res != PSM_RESEND) 616 break; 617 } 618 return res; 619 } 620 621 /* 622 * read one byte from any source; whether from the controller, 623 * the keyboard, or the aux device 624 */ 625 int 626 read_controller_data(KBDC p) 627 { 628 if (availq(&kbdcp(p)->kbd)) 629 return removeq(&kbdcp(p)->kbd); 630 if (availq(&kbdcp(p)->aux)) 631 return removeq(&kbdcp(p)->aux); 632 if (!wait_for_data(kbdcp(p))) 633 return -1; /* timeout */ 634 return read_data(kbdcp(p)); 635 } 636 637 #if KBDIO_DEBUG >= 2 638 static int call = 0; 639 #endif 640 641 /* read one byte from the keyboard */ 642 int 643 read_kbd_data(KBDC p) 644 { 645 #if KBDIO_DEBUG >= 2 646 if (++call > 2000) { 647 call = 0; 648 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, " 649 "aux q: %d calls, max %d chars\n", 650 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount, 651 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount); 652 } 653 #endif 654 655 if (availq(&kbdcp(p)->kbd)) 656 return removeq(&kbdcp(p)->kbd); 657 if (!wait_for_kbd_data(kbdcp(p))) 658 return -1; /* timeout */ 659 return read_data(kbdcp(p)); 660 } 661 662 /* read one byte from the keyboard, but return immediately if 663 * no data is waiting 664 */ 665 int 666 read_kbd_data_no_wait(KBDC p) 667 { 668 int f; 669 670 #if KBDIO_DEBUG >= 2 671 if (++call > 2000) { 672 call = 0; 673 log(LOG_DEBUG, "kbdc: kbd q: %d calls, max %d chars, " 674 "aux q: %d calls, max %d chars\n", 675 kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount, 676 kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount); 677 } 678 #endif 679 680 if (availq(&kbdcp(p)->kbd)) 681 return removeq(&kbdcp(p)->kbd); 682 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 683 if (f == KBDS_AUX_BUFFER_FULL) { 684 DELAY(KBDD_DELAYTIME); 685 addq(&kbdcp(p)->aux, read_data(kbdcp(p))); 686 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 687 } 688 if (f == KBDS_KBD_BUFFER_FULL) { 689 DELAY(KBDD_DELAYTIME); 690 return read_data(kbdcp(p)); 691 } 692 return -1; /* no data */ 693 } 694 695 /* read one byte from the aux device */ 696 int 697 read_aux_data(KBDC p) 698 { 699 if (availq(&kbdcp(p)->aux)) 700 return removeq(&kbdcp(p)->aux); 701 if (!wait_for_aux_data(kbdcp(p))) 702 return -1; /* timeout */ 703 return read_data(kbdcp(p)); 704 } 705 706 /* read one byte from the aux device, but return immediately if 707 * no data is waiting 708 */ 709 int 710 read_aux_data_no_wait(KBDC p) 711 { 712 int f; 713 714 if (availq(&kbdcp(p)->aux)) 715 return removeq(&kbdcp(p)->aux); 716 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 717 if (f == KBDS_KBD_BUFFER_FULL) { 718 DELAY(KBDD_DELAYTIME); 719 addq(&kbdcp(p)->kbd, read_data(kbdcp(p))); 720 f = read_status(kbdcp(p)) & KBDS_BUFFER_FULL; 721 } 722 if (f == KBDS_AUX_BUFFER_FULL) { 723 DELAY(KBDD_DELAYTIME); 724 return read_data(kbdcp(p)); 725 } 726 return -1; /* no data */ 727 } 728 729 /* discard data from the keyboard */ 730 void 731 empty_kbd_buffer(KBDC p, int wait) 732 { 733 int t; 734 int b; 735 int f; 736 #if KBDIO_DEBUG >= 2 737 int c1 = 0; 738 int c2 = 0; 739 #endif 740 int delta = 2; 741 742 for (t = wait; t > 0; ) { 743 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 744 DELAY(KBDD_DELAYTIME); 745 b = read_data(kbdcp(p)); 746 if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) { 747 addq(&kbdcp(p)->aux, b); 748 #if KBDIO_DEBUG >= 2 749 ++c2; 750 } else { 751 ++c1; 752 #endif 753 } 754 t = wait; 755 } else { 756 t -= delta; 757 } 758 DELAY(delta*1000); 759 } 760 #if KBDIO_DEBUG >= 2 761 if ((c1 > 0) || (c2 > 0)) 762 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_kbd_buffer)\n", c1, c2); 763 #endif 764 765 emptyq(&kbdcp(p)->kbd); 766 } 767 768 /* discard data from the aux device */ 769 void 770 empty_aux_buffer(KBDC p, int wait) 771 { 772 int t; 773 int b; 774 int f; 775 #if KBDIO_DEBUG >= 2 776 int c1 = 0; 777 int c2 = 0; 778 #endif 779 int delta = 2; 780 781 for (t = wait; t > 0; ) { 782 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 783 DELAY(KBDD_DELAYTIME); 784 b = read_data(kbdcp(p)); 785 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) { 786 addq(&kbdcp(p)->kbd, b); 787 #if KBDIO_DEBUG >= 2 788 ++c1; 789 } else { 790 ++c2; 791 #endif 792 } 793 t = wait; 794 } else { 795 t -= delta; 796 } 797 DELAY(delta*1000); 798 } 799 #if KBDIO_DEBUG >= 2 800 if ((c1 > 0) || (c2 > 0)) 801 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_aux_buffer)\n", c1, c2); 802 #endif 803 804 emptyq(&kbdcp(p)->aux); 805 } 806 807 /* discard any data from the keyboard or the aux device */ 808 void 809 empty_both_buffers(KBDC p, int wait) 810 { 811 int t; 812 int f; 813 #if KBDIO_DEBUG >= 2 814 int c1 = 0; 815 int c2 = 0; 816 #endif 817 int delta = 2; 818 819 for (t = wait; t > 0; ) { 820 if ((f = read_status(kbdcp(p))) & KBDS_ANY_BUFFER_FULL) { 821 DELAY(KBDD_DELAYTIME); 822 (void)read_data(kbdcp(p)); 823 #if KBDIO_DEBUG >= 2 824 if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) 825 ++c1; 826 else 827 ++c2; 828 #endif 829 t = wait; 830 } else { 831 t -= delta; 832 } 833 DELAY(delta*1000); 834 } 835 #if KBDIO_DEBUG >= 2 836 if ((c1 > 0) || (c2 > 0)) 837 log(LOG_DEBUG, "kbdc: %d:%d char read (empty_both_buffers)\n", c1, c2); 838 #endif 839 840 emptyq(&kbdcp(p)->kbd); 841 emptyq(&kbdcp(p)->aux); 842 } 843 844 /* keyboard and mouse device control */ 845 846 /* NOTE: enable the keyboard port but disable the keyboard 847 * interrupt before calling "reset_kbd()". 848 */ 849 int 850 reset_kbd(KBDC p) 851 { 852 int retry = KBD_MAXRETRY; 853 int again = KBD_MAXWAIT; 854 int c = KBD_RESEND; /* keep the compiler happy */ 855 856 while (retry-- > 0) { 857 empty_both_buffers(p, 10); 858 if (!write_kbd_command(p, KBDC_RESET_KBD)) 859 continue; 860 emptyq(&kbdcp(p)->kbd); 861 c = read_controller_data(p); 862 if (verbose || bootverbose) 863 log(LOG_DEBUG, "kbdc: RESET_KBD return code:%04x\n", c); 864 if (c == KBD_ACK) /* keyboard has agreed to reset itself... */ 865 break; 866 } 867 if (retry < 0) 868 return FALSE; 869 870 while (again-- > 0) { 871 /* wait awhile, well, in fact we must wait quite loooooooooooong */ 872 DELAY(KBD_RESETDELAY*1000); 873 c = read_controller_data(p); /* RESET_DONE/RESET_FAIL */ 874 if (c != -1) /* wait again if the controller is not ready */ 875 break; 876 } 877 if (verbose || bootverbose) 878 log(LOG_DEBUG, "kbdc: RESET_KBD status:%04x\n", c); 879 if (c != KBD_RESET_DONE) 880 return FALSE; 881 return TRUE; 882 } 883 884 /* NOTE: enable the aux port but disable the aux interrupt 885 * before calling `reset_aux_dev()'. 886 */ 887 int 888 reset_aux_dev(KBDC p) 889 { 890 int retry = KBD_MAXRETRY; 891 int again = KBD_MAXWAIT; 892 int c = PSM_RESEND; /* keep the compiler happy */ 893 894 while (retry-- > 0) { 895 empty_both_buffers(p, 10); 896 if (!write_aux_command(p, PSMC_RESET_DEV)) 897 continue; 898 emptyq(&kbdcp(p)->aux); 899 /* NOTE: Compaq Armada laptops require extra delay here. XXX */ 900 for (again = KBD_MAXWAIT; again > 0; --again) { 901 DELAY(KBD_RESETDELAY*1000); 902 c = read_aux_data_no_wait(p); 903 if (c != -1) 904 break; 905 } 906 if (verbose || bootverbose) 907 log(LOG_DEBUG, "kbdc: RESET_AUX return code:%04x\n", c); 908 if (c == PSM_ACK) /* aux dev is about to reset... */ 909 break; 910 } 911 if (retry < 0) 912 return FALSE; 913 914 for (again = KBD_MAXWAIT; again > 0; --again) { 915 /* wait awhile, well, quite looooooooooooong */ 916 DELAY(KBD_RESETDELAY*1000); 917 c = read_aux_data_no_wait(p); /* RESET_DONE/RESET_FAIL */ 918 if (c != -1) /* wait again if the controller is not ready */ 919 break; 920 } 921 if (verbose || bootverbose) 922 log(LOG_DEBUG, "kbdc: RESET_AUX status:%04x\n", c); 923 if (c != PSM_RESET_DONE) /* reset status */ 924 return FALSE; 925 926 c = read_aux_data(p); /* device ID */ 927 if (verbose || bootverbose) 928 log(LOG_DEBUG, "kbdc: RESET_AUX ID:%04x\n", c); 929 /* NOTE: we could check the device ID now, but leave it later... */ 930 return TRUE; 931 } 932 933 /* controller diagnostics and setup */ 934 935 int 936 test_controller(KBDC p) 937 { 938 int retry = KBD_MAXRETRY; 939 int again = KBD_MAXWAIT; 940 int c = KBD_DIAG_FAIL; 941 942 while (retry-- > 0) { 943 empty_both_buffers(p, 10); 944 if (write_controller_command(p, KBDC_DIAGNOSE)) 945 break; 946 } 947 if (retry < 0) 948 return FALSE; 949 950 emptyq(&kbdcp(p)->kbd); 951 while (again-- > 0) { 952 /* wait awhile */ 953 DELAY(KBD_RESETDELAY*1000); 954 c = read_controller_data(p); /* DIAG_DONE/DIAG_FAIL */ 955 if (c != -1) /* wait again if the controller is not ready */ 956 break; 957 } 958 if (verbose || bootverbose) 959 log(LOG_DEBUG, "kbdc: DIAGNOSE status:%04x\n", c); 960 return (c == KBD_DIAG_DONE); 961 } 962 963 int 964 test_kbd_port(KBDC p) 965 { 966 int retry = KBD_MAXRETRY; 967 int again = KBD_MAXWAIT; 968 int c = -1; 969 970 while (retry-- > 0) { 971 empty_both_buffers(p, 10); 972 if (write_controller_command(p, KBDC_TEST_KBD_PORT)) 973 break; 974 } 975 if (retry < 0) 976 return FALSE; 977 978 emptyq(&kbdcp(p)->kbd); 979 while (again-- > 0) { 980 c = read_controller_data(p); 981 if (c != -1) /* try again if the controller is not ready */ 982 break; 983 } 984 if (verbose || bootverbose) 985 log(LOG_DEBUG, "kbdc: TEST_KBD_PORT status:%04x\n", c); 986 return c; 987 } 988 989 int 990 test_aux_port(KBDC p) 991 { 992 int retry = KBD_MAXRETRY; 993 int again = KBD_MAXWAIT; 994 int c = -1; 995 996 while (retry-- > 0) { 997 empty_both_buffers(p, 10); 998 if (write_controller_command(p, KBDC_TEST_AUX_PORT)) 999 break; 1000 } 1001 if (retry < 0) 1002 return FALSE; 1003 1004 emptyq(&kbdcp(p)->kbd); 1005 while (again-- > 0) { 1006 c = read_controller_data(p); 1007 if (c != -1) /* try again if the controller is not ready */ 1008 break; 1009 } 1010 if (verbose || bootverbose) 1011 log(LOG_DEBUG, "kbdc: TEST_AUX_PORT status:%04x\n", c); 1012 return c; 1013 } 1014 1015 int 1016 kbdc_get_device_mask(KBDC p) 1017 { 1018 return kbdcp(p)->command_mask; 1019 } 1020 1021 void 1022 kbdc_set_device_mask(KBDC p, int mask) 1023 { 1024 kbdcp(p)->command_mask = 1025 mask & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS); 1026 } 1027 1028 int 1029 get_controller_command_byte(KBDC p) 1030 { 1031 if (kbdcp(p)->command_byte != -1) 1032 return kbdcp(p)->command_byte; 1033 if (!write_controller_command(p, KBDC_GET_COMMAND_BYTE)) 1034 return -1; 1035 emptyq(&kbdcp(p)->kbd); 1036 kbdcp(p)->command_byte = read_controller_data(p); 1037 return kbdcp(p)->command_byte; 1038 } 1039 1040 int 1041 set_controller_command_byte(KBDC p, int mask, int command) 1042 { 1043 if (get_controller_command_byte(p) == -1) 1044 return FALSE; 1045 1046 command = (kbdcp(p)->command_byte & ~mask) | (command & mask); 1047 if (command & KBD_DISABLE_KBD_PORT) { 1048 if (!write_controller_command(p, KBDC_DISABLE_KBD_PORT)) 1049 return FALSE; 1050 } 1051 if (!write_controller_command(p, KBDC_SET_COMMAND_BYTE)) 1052 return FALSE; 1053 if (!write_controller_data(p, command)) 1054 return FALSE; 1055 kbdcp(p)->command_byte = command; 1056 1057 if (verbose) 1058 log(LOG_DEBUG, "kbdc: new command byte:%04x (set_controller...)\n", 1059 command); 1060 1061 return TRUE; 1062 } 1063