1 files changed, 639 insertions, 156 deletions

diff --git a/sys/isa/kbdio.c b/sys/isa/kbdio.c
index 47eefc4..7f8633e 100644
--- a/sys/isa/kbdio.c
+++ b/sys/isa/kbdio.c
@@ -29,6 +29,10 @@
  * $FreeBSD$
  */
 
+#include "sc.h"
+#include "psm.h"
+#include "opt_kbdio.h"
+
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/syslog.h>
@@ -41,31 +45,254 @@
 #include <i386/isa/isa_device.h>
 #include <i386/isa/kbdio.h>
 
+/* 
+ * driver specific options: the following options may be set by
+ * `options' statements in the kernel configuration file. 
+ */
+
+/* retry count */
+#ifndef KBD_MAXRETRY
+#define KBD_MAXRETRY	3
+#endif
+
+/* timing parameters */
+#ifndef KBD_RESETDELAY
+#define KBD_RESETDELAY  200     /* wait 200msec after kbd/mouse reset */
+#endif
+#ifndef KBD_MAXWAIT
+#define KBD_MAXWAIT	5 	/* wait 5 times at most after reset */
+#endif
+
+/* I/O recovery time */
+#ifdef PC98
+#define KBDC_DELAYTIME	37
+#define KBDD_DELAYTIME	37
+#else
+#define KBDC_DELAYTIME	20
+#define KBDD_DELAYTIME	7
+#endif
+
+/* debug option */
 #ifndef KBDIO_DEBUG
 #define KBDIO_DEBUG	0
 #endif
 
+/* end of driver specific options */
+
+/* constants */
+
+#define NKBDC		max(NSC, NPSM)
+#define KBDQ_BUFSIZE	32
+
+/* macros */
+
+#ifndef max
+#define max(x,y)	((x) > (y) ? (x) : (y))
+#endif
+#ifndef min
+#define min(x,y)	((x) < (y) ? (x) : (y))
+#endif
+
+#define kbdcp(p)	((struct kbdc_softc *)(p))
+#define nextq(i)	(((i) + 1) % KBDQ_BUFSIZE)
+#define availq(q)	((q)->head != (q)->tail)
+#if KBDIO_DEBUG >= 2
+#define emptyq(q)	((q)->tail = (q)->head = (q)->qcount = 0)
+#else
+#define emptyq(q)	((q)->tail = (q)->head = 0)
+#endif
+
+/* local variables */
+
+typedef struct _kqueue {
+    int head;
+    int tail;
+    unsigned char q[KBDQ_BUFSIZE];
+#if KBDIO_DEBUG >= 2
+    int call_count;
+    int qcount;
+    int max_qcount;
+#endif
+} kqueue;
+
+struct kbdc_softc {
+    int port;			/* base port address */
+    int command_byte;		/* current command byte value */
+    int command_mask;		/* command byte mask bits for kbd/aux devices */
+    int lock;			/* FIXME: XXX not quite a semaphore... */
+    kqueue kbd;			/* keyboard data queue */
+    kqueue aux;			/* auxiliary data queue */
+}; 
+
+static struct kbdc_softc kbdc_softc[NKBDC] = { { 0 }, };
+
 static int verbose = KBDIO_DEBUG;
 
-/* 
- * device I/O routines
+/* function prototypes */
+
+static int addq(kqueue *q, int c);
+static int removeq(kqueue *q);
+static int wait_while_controller_busy(struct kbdc_softc *kbdc);
+static int wait_for_data(struct kbdc_softc *kbdc);
+static int wait_for_kbd_data(struct kbdc_softc *kbdc);
+static int wait_for_kbd_ack(struct kbdc_softc *kbdc);
+static int wait_for_aux_data(struct kbdc_softc *kbdc);
+static int wait_for_aux_ack(struct kbdc_softc *kbdc);
+
+/* associate a port number with a KBDC */
+
+KBDC 
+kbdc_open(int port)
+{
+    int s;
+    int i;
+
+    s = spltty();
+    for (i = 0; i < NKBDC; ++i) {
+        if (kbdc_softc[i].port == port) {
+	    splx(s);
+	    return (KBDC) &kbdc_softc[i];
+	}
+        if (kbdc_softc[i].port <= 0) {
+	    kbdc_softc[i].port = port;
+	    kbdc_softc[i].command_byte = -1;
+	    kbdc_softc[i].command_mask = 0;
+	    kbdc_softc[i].lock = FALSE;
+	    kbdc_softc[i].kbd.head = kbdc_softc[i].kbd.tail = 0;
+	    kbdc_softc[i].aux.head = kbdc_softc[i].aux.tail = 0;
+#if KBDIO_DEBUG >= 2
+	    kbdc_softc[i].kbd.call_count = 0;
+	    kbdc_softc[i].kbd.qcount = kbdc_softc[i].kbd.max_qcount = 0;
+	    kbdc_softc[i].aux.call_count = 0;
+	    kbdc_softc[i].aux.qcount = kbdc_softc[i].aux.max_qcount = 0;
+#endif
+	    splx(s);
+	    return (KBDC) &kbdc_softc[i];
+	}
+    }
+    splx(s);
+    return NULL;
+}
+
+/*
+ * I/O access arbitration in `kbdio'
+ *
+ * The `kbdio' module uses a simplistic convention to arbitrate
+ * I/O access to the controller/keyboard/mouse. The convention requires
+ * close cooperation of the calling device driver.
+ *
+ * The device driver which utilizes the `kbdio' module are assumed to
+ * have the following set of routines.
+ *    a. An interrupt handler (the bottom half of the driver).
+ *    b. Timeout routines which may briefly polls the keyboard controller.
+ *    c. Routines outside interrupt context (the top half of the driver).
+ * They should follow the rules below:
+ *    1. The interrupt handler may assume that it always has full access 
+ *       to the controller/keyboard/mouse.
+ *    2. The other routines must issue `spltty()' if they wish to 
+ *       prevent the interrupt handler from accessing 
+ *       the controller/keyboard/mouse.
+ *    3. The timeout routines and the top half routines of the device driver
+ *       arbitrate I/O access by observing the lock flag in `kbdio'.
+ *       The flag is manipulated via `kbdc_lock()'; when one wants to
+ *       perform I/O, call `kbdc_lock(kbdc, TRUE)' and proceed only if
+ *       the call returns with TRUE. Otherwise the caller must back off.
+ *       Call `kbdc_lock(kbdc, FALSE)' when necessary I/O operaion
+ *       is finished. This mechanism does not prevent the interrupt 
+ *       handler from being invoked at any time and carrying out I/O.
+ *       Therefore, `spltty()' must be strategically placed in the device
+ *       driver code. Also note that the timeout routine may interrupt
+ *       `kbdc_lock()' called by the top half of the driver, but this
+ *       interruption is OK so long as the timeout routine observes the
+ *       the rule 4 below.
+ *    4. The interrupt and timeout routines should not extend I/O operation
+ *       across more than one interrupt or timeout; they must complete
+ *       necessary I/O operation within one invokation of the routine.
+ *       This measns that if the timeout routine acquires the lock flag,
+ *       it must reset the flag to FALSE before it returns.
  */
 
+/* set/reset polling lock */
+int 
+kbdc_lock(KBDC p, int lock)
+{
+    int prevlock;
+
+    prevlock = kbdcp(p)->lock;
+    kbdcp(p)->lock = lock;
+
+    return (prevlock != lock);
+}
 
+/* check if any data is waiting to be processed */
 int
-wait_while_controller_busy(int port)
+kbdc_data_ready(KBDC p)
 {
-#ifdef PC98
-	DELAY(KBDC_DELAYTIME);
+    return (availq(&kbdcp(p)->kbd) || availq(&kbdcp(p)->aux) 
+	|| (inb(kbdcp(p)->port + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL));
+}
+
+/* queuing functions */
+
+static int
+addq(kqueue *q, int c)
+{
+    if (nextq(q->tail) != q->head) {
+	q->q[q->tail] = c;
+	q->tail = nextq(q->tail);
+#if KBDIO_DEBUG >= 2
+        ++q->call_count;
+        ++q->qcount;
+	if (q->qcount > q->max_qcount)
+            q->max_qcount = q->qcount;
+#endif
 	return TRUE;
+    }
+    return FALSE;
+}
+
+static int
+removeq(kqueue *q)
+{
+    int c;
+
+    if (q->tail != q->head) {
+	c = q->q[q->head];
+	q->head = nextq(q->head);
+#if KBDIO_DEBUG >= 2
+        --q->qcount;
+#endif
+	return c;
+    }
+    return -1;
+}
+
+/* 
+ * device I/O routines
+ */
+static int
+wait_while_controller_busy(struct kbdc_softc *kbdc)
+{
+#ifdef PC98
+    DELAY(KBDC_DELAYTIME);
+    return TRUE;
 #else
     /* CPU will stay inside the loop for 100msec at most */
     int retry = 5000;
+    int port = kbdc->port;
+    int f;
 
-    while (inb(port + KBD_STATUS_PORT) & KBDS_INPUT_BUFFER_FULL) {
+    while ((f = inb(port + KBD_STATUS_PORT)) & KBDS_INPUT_BUFFER_FULL) {
+	if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+	    addq(&kbdc->kbd, inb(port + KBD_DATA_PORT));
+	} else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+	    addq(&kbdc->aux, inb(port + KBD_DATA_PORT));
+	}
         DELAY(KBDC_DELAYTIME);
         if (--retry < 0)
-    	return FALSE;
+    	    return FALSE;
     }
     return TRUE;
 #endif
@@ -75,174 +302,269 @@ wait_while_controller_busy(int port)
  * wait for any data; whether it's from the controller, 
  * the keyboard, or the aux device.
  */
-int
-wait_for_data(int port)
+static int
+wait_for_data(struct kbdc_softc *kbdc)
 {
     /* CPU will stay inside the loop for 200msec at most */
     int retry = 10000;
+    int port = kbdc->port;
+    int f;
 
-    while ((inb(port + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) == 0) {
+    while ((f = inb(port + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) == 0) {
         DELAY(KBDC_DELAYTIME);
         if (--retry < 0)
-    	return FALSE;
+    	    return 0;
     }
     DELAY(KBDD_DELAYTIME);
-    return TRUE;
+    return f;
 }
 
 /* wait for data from the keyboard */
-int
-wait_for_kbd_data(int port)
+static int
+wait_for_kbd_data(struct kbdc_softc *kbdc)
 {
     /* CPU will stay inside the loop for 200msec at most */
     int retry = 10000;
+    int port = kbdc->port;
+    int f;
 
-    while ((inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
-           != KBDS_KBD_BUFFER_FULL) {
+    while ((f = inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL) 
+	    != KBDS_KBD_BUFFER_FULL) {
+        if (f == KBDS_AUX_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+	    addq(&kbdc->aux, inb(port + KBD_DATA_PORT));
+	}
         DELAY(KBDC_DELAYTIME);
         if (--retry < 0)
-    	return FALSE;
+    	    return 0;
     }
     DELAY(KBDD_DELAYTIME);
-    return TRUE;
+    return f;
+}
+
+/* 
+ * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the keyboard.
+ * queue anything else.
+ */
+static int
+wait_for_kbd_ack(struct kbdc_softc *kbdc)
+{
+    /* CPU will stay inside the loop for 200msec at most */
+    int retry = 10000;
+    int port = kbdc->port;
+    int f;
+    int b;
+
+    while (retry-- > 0) {
+        if ((f = inb(port + KBD_STATUS_PORT)) & KBDS_ANY_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+            b = inb(port + KBD_DATA_PORT);
+	    if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
+		if ((b == KBD_ACK) || (b == KBD_RESEND) 
+		    || (b == KBD_RESET_FAIL))
+		    return b;
+		addq(&kbdc->kbd, b);
+	    } else if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
+		addq(&kbdc->aux, b);
+	    }
+	}
+        DELAY(KBDC_DELAYTIME);
+    }
+    return -1;
 }
 
 /* wait for data from the aux device */
-int
-wait_for_aux_data(int port)
+static int
+wait_for_aux_data(struct kbdc_softc *kbdc)
 {
     /* CPU will stay inside the loop for 200msec at most */
     int retry = 10000;
+    int port = kbdc->port;
+    int f;
 
-    while ((inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
-           != KBDS_AUX_BUFFER_FULL) {
+    while ((f = inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL) 
+	    != KBDS_AUX_BUFFER_FULL) {
+        if (f == KBDS_KBD_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+	    addq(&kbdc->kbd, inb(port + KBD_DATA_PORT));
+	}
         DELAY(KBDC_DELAYTIME);
         if (--retry < 0)
-    	return FALSE;
+    	    return 0;
     }
     DELAY(KBDD_DELAYTIME);
-    return TRUE;
+    return f;
 }
 
+/* 
+ * wait for an ACK(FAh), RESEND(FEh), or RESET_FAIL(FCh) from the aux device.
+ * queue anything else.
+ */
+static int
+wait_for_aux_ack(struct kbdc_softc *kbdc)
+{
+    /* CPU will stay inside the loop for 200msec at most */
+    int retry = 10000;
+    int port = kbdc->port;
+    int f;
+    int b;
+
+    while (retry-- > 0) {
+        if ((f = inb(port + KBD_STATUS_PORT)) & KBDS_ANY_BUFFER_FULL) {
+	    DELAY(KBDD_DELAYTIME);
+            b = inb(port + KBD_DATA_PORT);
+	    if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
+		if ((b == PSM_ACK) || (b == PSM_RESEND) 
+		    || (b == PSM_RESET_FAIL))
+		    return b;
+		addq(&kbdc->aux, b);
+	    } else if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
+		addq(&kbdc->kbd, b);
+	    }
+	}
+        DELAY(KBDC_DELAYTIME);
+    }
+    return -1;
+}
+
+/* write a one byte command to the controller */
 int
-write_controller_command(int port, int c)
+write_controller_command(KBDC p, int c)
 {
-    if (!wait_while_controller_busy(port))
+    if (!wait_while_controller_busy(kbdcp(p)))
 	return FALSE;
-    outb(port + KBD_COMMAND_PORT, c);
+    outb(kbdcp(p)->port + KBD_COMMAND_PORT, c);
     return TRUE;
 }
 
+/* write a one byte data to the controller */
 int
-write_controller_data(int port, int c)
+write_controller_data(KBDC p, int c)
 {
-    if (!wait_while_controller_busy(port))
+    if (!wait_while_controller_busy(kbdcp(p)))
 	return FALSE;
-    outb(port + KBD_DATA_PORT, c);
+    outb(kbdcp(p)->port + KBD_DATA_PORT, c);
     return TRUE;
 }
 
+/* write a one byte keyboard command */
 int
-write_kbd_command(int port, int c)
+write_kbd_command(KBDC p, int c)
 {
-    if (!wait_while_controller_busy(port))
+    if (!wait_while_controller_busy(kbdcp(p)))
 	return FALSE;
-    outb(port + KBD_DATA_PORT, c);
+    outb(kbdcp(p)->port + KBD_DATA_PORT, c);
     return TRUE;
 }
 
+/* write a one byte auxiliary device command */
 int
-write_aux_command(int port, int c)
+write_aux_command(KBDC p, int c)
 {
-    if (!write_controller_command(port,KBDC_WRITE_TO_AUX))
+    if (!write_controller_command(p, KBDC_WRITE_TO_AUX))
 	return FALSE;
-    return write_controller_data(port, c);
+    return write_controller_data(p, c);
 }
 
+/* send a command to the keyboard and wait for ACK */
 int
-send_kbd_command(int port, int c)
+send_kbd_command(KBDC p, int c)
 {
     int retry = KBD_MAXRETRY;
     int res = -1;
 
     while (retry-- > 0) {
-	if (!write_kbd_command(port, c))
+	if (!write_kbd_command(p, c))
 	    continue;
-        res = read_controller_data(port);
+        res = wait_for_kbd_ack(kbdcp(p));
         if (res == KBD_ACK)
-    	break;
+    	    break;
     }
     return res;
 }
 
+/* send a command to the auxiliary device and wait for ACK */
 int
-send_aux_command(int port, int c)
+send_aux_command(KBDC p, int c)
 {
     int retry = KBD_MAXRETRY;
     int res = -1;
 
     while (retry-- > 0) {
-	if (!write_aux_command(port, c))
+	if (!write_aux_command(p, c))
 	    continue;
-        res = read_aux_data(port);
+	/*
+	 * FIXME: XXX
+	 * The aux device may have already sent one or two bytes of 
+	 * status data, when a command is received. It will immediately 
+	 * stop data transmission, thus, leaving an incomplete data 
+	 * packet in our buffer. We have to discard any unprocessed
+	 * data in order to remove such packets. Well, we may remove 
+	 * unprocessed, but necessary data byte as well... 
+	 */
+	emptyq(&kbdcp(p)->aux);
+        res = wait_for_aux_ack(kbdcp(p));
         if (res == PSM_ACK)
-    	break;
+    	    break;
     }
     return res;
 }
 
+/* send a command and a data to the keyboard, wait for ACKs */
 int
-send_kbd_command_and_data(int port, int c, int d)
+send_kbd_command_and_data(KBDC p, int c, int d)
 {
     int retry;
     int res = -1;
 
     for (retry = KBD_MAXRETRY; retry > 0; --retry) {
-	if (!write_kbd_command(port, c))
+	if (!write_kbd_command(p, c))
 	    continue;
-        res = read_controller_data(port);
+        res = wait_for_kbd_ack(kbdcp(p));
         if (res == KBD_ACK)
-    	break;
-        else if (res != PSM_RESEND)
+    	    break;
+        else if (res != KBD_RESEND)
     	    return res;
     }
     if (retry <= 0)
 	return res;
 
     for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) {
-	if (!write_kbd_command(port, d))
+	if (!write_kbd_command(p, d))
 	    continue;
-        res = read_controller_data(port);
+        res = wait_for_kbd_ack(kbdcp(p));
         if (res != KBD_RESEND)
-    	break;
+    	    break;
     }
     return res;
 }
 
+/* send a command and a data to the auxiliary device, wait for ACKs */
 int
-send_aux_command_and_data(int port, int c, int d)
+send_aux_command_and_data(KBDC p, int c, int d)
 {
     int retry;
     int res = -1;
 
     for (retry = KBD_MAXRETRY; retry > 0; --retry) {
-	if (!write_aux_command(port, c))
+	if (!write_aux_command(p, c))
 	    continue;
-        res = read_aux_data(port);
+	emptyq(&kbdcp(p)->aux);
+        res = wait_for_aux_ack(kbdcp(p));
         if (res == PSM_ACK)
-    	break;
+    	    break;
         else if (res != PSM_RESEND)
-    	return res;
+    	    return res;
     }
     if (retry <= 0)
 	return res;
 
     for (retry = KBD_MAXRETRY, res = -1; retry > 0; --retry) {
-	if (!write_aux_command(port, d))
+	if (!write_aux_command(p, d))
 	    continue;
-        res = read_aux_data(port);
+        res = wait_for_aux_ack(kbdcp(p));
         if (res != PSM_RESEND)
-    	break;
+    	    break;
     }
     return res;
 }
@@ -252,107 +574,225 @@ send_aux_command_and_data(int port, int c, int d)
  * the keyboard, or the aux device
  */
 int
-read_controller_data(int port)
+read_controller_data(KBDC p)
 {
-    if (!wait_for_data(port))
+    if (availq(&kbdcp(p)->kbd)) 
+        return removeq(&kbdcp(p)->kbd);
+    if (availq(&kbdcp(p)->aux)) 
+        return removeq(&kbdcp(p)->aux);
+    if (!wait_for_data(kbdcp(p)))
         return -1;		/* timeout */
-    return inb(port + KBD_DATA_PORT);
+    return inb(kbdcp(p)->port + KBD_DATA_PORT);
 }
 
+#if KBDIO_DEBUG >= 2
+static int call = 0;
+#endif
+
 /* read one byte from the keyboard */
 int
-read_kbd_data(int port)
+read_kbd_data(KBDC p)
 {
-    if (!wait_for_kbd_data(port))
+#if KBDIO_DEBUG >= 2
+    if (++call > 2000) {
+	call = 0;
+	log(LOG_DEBUG, "KBDIO: kbd q: %d calls, max %d chars, "
+	                      "aux q: %d calls, max %d chars\n",
+		       kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount,
+		       kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount);
+    }
+#endif
+
+    if (availq(&kbdcp(p)->kbd)) 
+        return removeq(&kbdcp(p)->kbd);
+    if (!wait_for_kbd_data(kbdcp(p)))
         return -1;		/* timeout */
 #ifdef PC98
-	DELAY(KBDC_DELAYTIME);
+    DELAY(KBDC_DELAYTIME);
 #endif
-    return inb(port + KBD_DATA_PORT);
+    return inb(kbdcp(p)->port + KBD_DATA_PORT);
 }
 
 /* read one byte from the keyboard, but return immediately if 
  * no data is waiting
  */
 int
-read_kbd_data_no_wait(int port)
+read_kbd_data_no_wait(KBDC p)
 {
-    if ((inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
-    	!= KBDS_KBD_BUFFER_FULL) 
-        return -1;		/* no data */
-    DELAY(KBDD_DELAYTIME);
-    return inb(port + KBD_DATA_PORT);
+    int f;
+
+#if KBDIO_DEBUG >= 2
+    if (++call > 2000) {
+	call = 0;
+	log(LOG_DEBUG, "KBDIO: kbd q: %d calls, max %d chars, "
+	                      "aux q: %d calls, max %d chars\n",
+		       kbdcp(p)->kbd.call_count, kbdcp(p)->kbd.max_qcount,
+		       kbdcp(p)->aux.call_count, kbdcp(p)->aux.max_qcount);
+    }
+#endif
+
+    if (availq(&kbdcp(p)->kbd)) 
+        return removeq(&kbdcp(p)->kbd);
+    f = inb(kbdcp(p)->port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL;
+    if (f == KBDS_AUX_BUFFER_FULL) {
+        DELAY(KBDD_DELAYTIME);
+        addq(&kbdcp(p)->aux, inb(kbdcp(p)->port + KBD_DATA_PORT));
+        f = inb(kbdcp(p)->port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL;
+    }
+    if (f == KBDS_KBD_BUFFER_FULL) {
+        DELAY(KBDD_DELAYTIME);
+        return inb(kbdcp(p)->port + KBD_DATA_PORT);
+    }
+    return -1;		/* no data */
 }
 
 /* read one byte from the aux device */
 int
-read_aux_data(int port)
+read_aux_data(KBDC p)
 {
-    if (!wait_for_aux_data(port))
+    if (availq(&kbdcp(p)->aux)) 
+        return removeq(&kbdcp(p)->aux);
+    if (!wait_for_aux_data(kbdcp(p)))
         return -1;		/* timeout */
-    return inb(port + KBD_DATA_PORT);
+    return inb(kbdcp(p)->port + KBD_DATA_PORT);
+}
+
+/* read one byte from the aux device, but return immediately if 
+ * no data is waiting
+ */
+int
+read_aux_data_no_wait(KBDC p)
+{
+    int f;
+
+    if (availq(&kbdcp(p)->aux)) 
+        return removeq(&kbdcp(p)->aux);
+    f = inb(kbdcp(p)->port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL;
+    if (f == KBDS_KBD_BUFFER_FULL) {
+        DELAY(KBDD_DELAYTIME);
+        addq(&kbdcp(p)->kbd, inb(kbdcp(p)->port + KBD_DATA_PORT));
+        f = inb(kbdcp(p)->port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL;
+    }
+    if (f == KBDS_AUX_BUFFER_FULL) {
+        DELAY(KBDD_DELAYTIME);
+        return inb(kbdcp(p)->port + KBD_DATA_PORT);
+    }
+    return -1;		/* no data */
 }
 
 /* discard data from the keyboard */
 void
-empty_kbd_buffer(int port, int t)
+empty_kbd_buffer(KBDC p, int wait)
 {
+    int t;
     int b;
-    int c = 0;
+    int f;
+#if KBDIO_DEBUG >= 2
+    int c1 = 0;
+    int c2 = 0;
+#endif
     int delta = 2;
 
-    for (; t > 0; t -= delta) { 
-        if ((inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
-    	   == KBDS_KBD_BUFFER_FULL) {
+    for (t = wait; t > 0; ) { 
+        if ((f = inb(kbdcp(p)->port + KBD_STATUS_PORT)) & KBDS_ANY_BUFFER_FULL) {
 	    DELAY(KBDD_DELAYTIME);
-        b = inb(port + KBD_DATA_PORT);
-        ++c;
-    }
+            b = inb(kbdcp(p)->port + KBD_DATA_PORT);
+	    if ((f & KBDS_BUFFER_FULL) == KBDS_AUX_BUFFER_FULL) {
+		addq(&kbdcp(p)->aux, b);
+#if KBDIO_DEBUG >= 2
+		++c2;
+            } else {
+		++c1;
+#endif
+	    }
+	    t = wait;
+	} else {
+	    t -= delta;
+	}
         DELAY(delta*1000);
     }
-    if ((verbose >= 2) && (c > 0))
-    log(LOG_DEBUG,"kbdio: %d char read (empty_kbd_buffer)\n",c);
+#if KBDIO_DEBUG >= 2
+    if ((c1 > 0) || (c2 > 0))
+        log(LOG_DEBUG, "kbdio: %d:%d char read (empty_kbd_buffer)\n", c1, c2);
+#endif
+
+    emptyq(&kbdcp(p)->kbd);
 }
 
 /* discard data from the aux device */
 void
-empty_aux_buffer(int port, int t)
+empty_aux_buffer(KBDC p, int wait)
 {
+    int t;
     int b;
-    int c = 0;
+    int f;
+#if KBDIO_DEBUG >= 2
+    int c1 = 0;
+    int c2 = 0;
+#endif
     int delta = 2;
 
-    for (; t > 0; t -= delta) { 
-        if ((inb(port + KBD_STATUS_PORT) & KBDS_BUFFER_FULL)
-    	    == KBDS_AUX_BUFFER_FULL) {
+    for (t = wait; t > 0; ) { 
+        if ((f = inb(kbdcp(p)->port + KBD_STATUS_PORT)) & KBDS_ANY_BUFFER_FULL) {
 	    DELAY(KBDD_DELAYTIME);
-        b = inb(port + KBD_DATA_PORT);
-        ++c;
-    }
+            b = inb(kbdcp(p)->port + KBD_DATA_PORT);
+	    if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL) {
+		addq(&kbdcp(p)->kbd, b);
+#if KBDIO_DEBUG >= 2
+		++c1;
+            } else {
+		++c2;
+#endif
+	    }
+	    t = wait;
+	} else {
+	    t -= delta;
+	}
 	DELAY(delta*1000);
     }
-    if ((verbose >= 2) && (c > 0))
-    log(LOG_DEBUG,"kbdio: %d char read (empty_aux_buffer)\n",c);
+#if KBDIO_DEBUG >= 2
+    if ((c1 > 0) || (c2 > 0))
+        log(LOG_DEBUG, "kbdio: %d:%d char read (empty_aux_buffer)\n", c1, c2);
+#endif
+
+    emptyq(&kbdcp(p)->aux);
 }
 
 /* discard any data from the keyboard or the aux device */
 void
-empty_both_buffers(int port, int t)
+empty_both_buffers(KBDC p, int wait)
 {
-    int b;
-    int c = 0;
+    int t;
+    int f;
+#if KBDIO_DEBUG >= 2
+    int c1 = 0;
+    int c2 = 0;
+#endif
     int delta = 2;
 
-    for (; t > 0; t -= delta) { 
-        if (inb(port + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) {
+    for (t = wait; t > 0; ) { 
+        if ((f = inb(kbdcp(p)->port + KBD_STATUS_PORT)) & KBDS_ANY_BUFFER_FULL) {
 	    DELAY(KBDD_DELAYTIME);
-        b = inb(port + KBD_DATA_PORT);
-        ++c;
-    }
+            (void)inb(kbdcp(p)->port + KBD_DATA_PORT);
+#if KBDIO_DEBUG >= 2
+	    if ((f & KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL)
+		++c1;
+            else
+		++c2;
+#endif
+	    t = wait;
+	} else {
+	    t -= delta;
+	}
 	DELAY(delta*1000);
     }
-    if ((verbose >= 2) && (c > 0))
-    log(LOG_DEBUG,"kbdio: %d char read (empty_both_buffers)\n",c);
+#if KBDIO_DEBUG >= 2
+    if ((c1 > 0) || (c2 > 0))
+        log(LOG_DEBUG, "kbdio: %d:%d char read (empty_both_buffers)\n", c1, c2);
+#endif
+
+    emptyq(&kbdcp(p)->kbd);
+    emptyq(&kbdcp(p)->aux);
 }
 
 /* keyboard and mouse device control */
@@ -361,21 +801,22 @@ empty_both_buffers(int port, int t)
  * interrupt before calling "reset_kbd()".
  */
 int
-reset_kbd(int port)
+reset_kbd(KBDC p)
 {
     int retry = KBD_MAXRETRY;
     int again = KBD_MAXWAIT;
     int c = KBD_RESEND;		/* keep the compiler happy */
 
     while (retry-- > 0) {
-        empty_both_buffers(port, 10);
-        if (!write_kbd_command(port, KBDC_RESET_KBD))
+        empty_both_buffers(p, 10);
+        if (!write_kbd_command(p, KBDC_RESET_KBD))
 	    continue;
-        c = read_controller_data(port);
-	if (verbose)
-        log(LOG_DEBUG,"kbdio: RESET_KBD return code:%04x\n",c);
+	emptyq(&kbdcp(p)->kbd);
+        c = read_controller_data(p);
+	if (verbose || bootverbose)
+            log(LOG_DEBUG, "kbdio: RESET_KBD return code:%04x\n", c);
         if (c == KBD_ACK)	/* keyboard has agreed to reset itself... */
-    	break;
+    	    break;
     }
     if (retry < 0)
         return FALSE;
@@ -383,12 +824,12 @@ reset_kbd(int port)
     while (again-- > 0) {
         /* wait awhile, well, in fact we must wait quite loooooooooooong */
         DELAY(KBD_RESETDELAY*1000);
-        c = read_controller_data(port);	/* RESET_DONE/RESET_FAIL */
+        c = read_controller_data(p);	/* RESET_DONE/RESET_FAIL */
         if (c != -1) 	/* wait again if the controller is not ready */
-    	break;
+    	    break;
     }
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: RESET_KBD status:%04x\n",c);
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: RESET_KBD status:%04x\n", c);
     if (c != KBD_RESET_DONE)
         return FALSE;
     return TRUE;
@@ -398,21 +839,22 @@ reset_kbd(int port)
  * before calling `reset_aux_dev()'.
  */
 int
-reset_aux_dev(int port)
+reset_aux_dev(KBDC p)
 {
     int retry = KBD_MAXRETRY;
     int again = KBD_MAXWAIT;
     int c = PSM_RESEND;		/* keep the compiler happy */
 
     while (retry-- > 0) {
-        empty_both_buffers(port, 10);
-        if (!write_aux_command(port, PSMC_RESET_DEV))
+        empty_both_buffers(p, 10);
+        if (!write_aux_command(p, PSMC_RESET_DEV))
 	    continue;
-        c = read_controller_data(port);
-        if (verbose)
-        log(LOG_DEBUG,"kbdio: RESET_AUX return code:%04x\n",c);
+	emptyq(&kbdcp(p)->aux);
+        c = read_aux_data(p);
+        if (verbose || bootverbose)
+            log(LOG_DEBUG, "kbdio: RESET_AUX return code:%04x\n", c);
         if (c == PSM_ACK)	/* aux dev is about to reset... */
-    	break;
+    	    break;
     }
     if (retry < 0)
         return FALSE;
@@ -420,112 +862,153 @@ reset_aux_dev(int port)
     while (again-- > 0) {
         /* wait awhile, well, quite looooooooooooong */
         DELAY(KBD_RESETDELAY*1000);
-        c = read_aux_data(port);	/* RESET_DONE/RESET_FAIL */
+        c = read_aux_data(p);	/* RESET_DONE/RESET_FAIL */
         if (c != -1) 	/* wait again if the controller is not ready */
-    	break;
+    	    break;
     }
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: RESET_AUX status:%04x\n",c);
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: RESET_AUX status:%04x\n", c);
     if (c != PSM_RESET_DONE)	/* reset status */
         return FALSE;
 
-    c = read_aux_data(port);	/* device ID */
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: RESET_AUX ID:%04x\n",c);
-	/* NOTE: we could check the device ID now, but leave it later... */
+    c = read_aux_data(p);	/* device ID */
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: RESET_AUX ID:%04x\n", c);
+    /* NOTE: we could check the device ID now, but leave it later... */
     return TRUE;
 }
 
 /* controller diagnostics and setup */
 
 int
-test_controller(int port)
+test_controller(KBDC p)
 {
     int retry = KBD_MAXRETRY;
     int again = KBD_MAXWAIT;
     int c = KBD_DIAG_FAIL;
 
     while (retry-- > 0) {
-        empty_both_buffers(port, 10);
-        if (write_controller_command(port, KBDC_DIAGNOSE))
+        empty_both_buffers(p, 10);
+        if (write_controller_command(p, KBDC_DIAGNOSE))
     	    break;
     }
     if (retry < 0)
         return FALSE;
 
+    emptyq(&kbdcp(p)->kbd);
     while (again-- > 0) {
         /* wait awhile */
         DELAY(KBD_RESETDELAY*1000);
-    c = read_controller_data(port);	/* DIAG_DONE/DIAG_FAIL */
+        c = read_controller_data(p);	/* DIAG_DONE/DIAG_FAIL */
         if (c != -1) 	/* wait again if the controller is not ready */
     	    break;
     }
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: DIAGNOSE status:%04x\n",c);
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: DIAGNOSE status:%04x\n", c);
     return (c == KBD_DIAG_DONE);
 }
 
 int
-test_kbd_port(int port)
+test_kbd_port(KBDC p)
 {
     int retry = KBD_MAXRETRY;
     int again = KBD_MAXWAIT;
     int c = -1;
 
     while (retry-- > 0) {
-        empty_both_buffers(port, 10);
-        if (write_controller_command(port, KBDC_TEST_KBD_PORT))
+        empty_both_buffers(p, 10);
+        if (write_controller_command(p, KBDC_TEST_KBD_PORT))
     	    break;
     }
     if (retry < 0)
         return FALSE;
 
+    emptyq(&kbdcp(p)->kbd);
     while (again-- > 0) {
-    c = read_controller_data(port);
+        c = read_controller_data(p);
         if (c != -1) 	/* try again if the controller is not ready */
     	    break;
     }
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: TEST_KBD_PORT status:%04x\n",c);
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: TEST_KBD_PORT status:%04x\n", c);
     return c;
 }
 
 int
-test_aux_port(int port)
+test_aux_port(KBDC p)
 {
     int retry = KBD_MAXRETRY;
     int again = KBD_MAXWAIT;
     int c = -1;
 
     while (retry-- > 0) {
-        empty_both_buffers(port, 10);
-        if (write_controller_command(port, KBDC_TEST_AUX_PORT))
+        empty_both_buffers(p, 10);
+        if (write_controller_command(p, KBDC_TEST_AUX_PORT))
     	    break;
     }
     if (retry < 0)
         return FALSE;
 
+    emptyq(&kbdcp(p)->kbd);
     while (again-- > 0) {
-    c = read_controller_data(port);
+        c = read_controller_data(p);
         if (c != -1) 	/* try again if the controller is not ready */
     	    break;
     }
-    if (verbose)
-    log(LOG_DEBUG,"kbdio: TEST_AUX_PORT status:%04x\n",c);
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: TEST_AUX_PORT status:%04x\n", c);
     return c;
 }
 
 int
-set_controller_command_byte(int port, int command, int flag)
+kbdc_get_device_mask(KBDC p)
+{
+    return kbdcp(p)->command_mask;
+}
+
+void
+kbdc_set_device_mask(KBDC p, int mask)
+{
+    kbdcp(p)->command_mask = 
+	mask & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS);
+}
+
+int
+get_controller_command_byte(KBDC p)
 {
-    if ((command | flag) & KBD_DISABLE_KBD_PORT) {
-	if (!write_controller_command(port, KBDC_DISABLE_KBD_PORT))
+    if (kbdcp(p)->command_byte != -1)
+	return kbdcp(p)->command_byte;
+    if (!write_controller_command(p, KBDC_GET_COMMAND_BYTE))
+	return -1;
+    emptyq(&kbdcp(p)->kbd);
+    kbdcp(p)->command_byte = read_controller_data(p);
+    return kbdcp(p)->command_byte;
+}
+
+int
+set_controller_command_byte(KBDC p, int mask, int command)
+{
+    if (get_controller_command_byte(p) == -1)
+	return FALSE;
+
+    command = (kbdcp(p)->command_byte & ~mask) | (command & mask);
+#if 0
+    if (command == kbdcp(p)->command_byte)
+	return TRUE;
+#endif
+    if (command & KBD_DISABLE_KBD_PORT) {
+	if (!write_controller_command(p, KBDC_DISABLE_KBD_PORT))
 	    return FALSE;
     }
-    if (!write_controller_command(port, KBDC_SET_COMMAND_BYTE))
+    if (!write_controller_command(p, KBDC_SET_COMMAND_BYTE))
 	return FALSE;
-    if (!write_controller_data(port, command | flag))
+    if (!write_controller_data(p, command))
 	return FALSE;
-    wait_while_controller_busy(port);
+    kbdcp(p)->command_byte = command;
+
+    if (verbose || bootverbose)
+        log(LOG_DEBUG, "kbdio: new command byte:%04x (set_controller...)\n",
+	    command);
+
     return TRUE;
 }