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