sys/dev/misc/kbd/atkbdc.c

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