summaryrefslogtreecommitdiffstats
path: root/sys/isa
diff options
context:
space:
mode:
Diffstat (limited to 'sys/isa')
-rw-r--r--sys/isa/kbdio.c795
-rw-r--r--sys/isa/kbdio.h120
-rw-r--r--sys/isa/syscons.c206
-rw-r--r--sys/isa/syscons.h4
4 files changed, 840 insertions, 285 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;
}
diff --git a/sys/isa/kbdio.h b/sys/isa/kbdio.h
index 546e21b..3703443 100644
--- a/sys/isa/kbdio.h
+++ b/sys/isa/kbdio.h
@@ -39,15 +39,18 @@
#define KBD_STATUS_PORT 2 /* status port, read */
#define KBD_COMMAND_PORT 2 /* controller command port, write */
#define KBD_DATA_PORT 0 /* data port, read/write
- also used as keyboard command
- and mouse command port */
+ * also used as keyboard command
+ * and mouse command port
+ */
#else
#define KBD_STATUS_PORT 4 /* status port, read */
#define KBD_COMMAND_PORT 4 /* controller command port, write */
#define KBD_DATA_PORT 0 /* data port, read/write
- also used as keyboard command
- and mouse command port */
+ * also used as keyboard command
+ * and mouse command port
+ */
#endif /* PC98 */
+
/* FIXME: `IO_PSMSIZE' should really be in `isa.h'. */
#define IO_PSMSIZE (KBD_COMMAND_PORT - KBD_DATA_PORT + 1) /* 5 */
@@ -86,13 +89,14 @@
#define KBDC_SEND_DEV_ID 0x00f2
#define KBDC_SET_LEDS 0x00ed
#define KBDC_ECHO 0x00ee
-#define KBDC_SET_SCAN_CODESET 0x00f0
+#define KBDC_SET_SCANCODE_SET 0x00f0
#define KBDC_SET_TYPEMATIC 0x00f3
/* aux device commands (sent to KBD_DATA_PORT) */
#define PSMC_RESET_DEV 0x00ff
#define PSMC_ENABLE_DEV 0x00f4
#define PSMC_DISABLE_DEV 0x00f5
+#define PSMC_SET_DEFAULTS 0x00f6
#define PSMC_SEND_DEV_ID 0x00f2
#define PSMC_SEND_DEV_STATUS 0x00e9
#define PSMC_SEND_DEV_DATA 0x00eb
@@ -104,15 +108,11 @@
#define PSMC_SET_SAMPLING_RATE 0x00f3
/* PSMC_SET_RESOLUTION argument */
-#define PSMD_RESOLUTION_25 0 /* 25ppi */
-#define PSMD_RESOLUTION_50 1 /* 50ppi */
-#define PSMD_RESOLUTION_100 2 /* 100ppi (default after reset) */
-#define PSMD_RESOLUTION_200 3 /* 200ppi */
-/* FIXME: I don't know if it's possible to go beyond 200ppi.
- The values below are of my wild guess. */
-#define PSMD_RESOLUTION_400 4 /* 400ppi */
-#define PSMD_RESOLUTION_800 5 /* 800ppi */
-#define PSMD_MAX_RESOLUTION PSMD_RESOLUTION_800
+#define PSMD_RES_LOW 0 /* typically 25ppi */
+#define PSMD_RES_MEDIUM_LOW 1 /* typically 50ppi */
+#define PSMD_RES_MEDIUM_HIGH 2 /* typically 100ppi (default) */
+#define PSMD_RES_HIGH 3 /* typically 200ppi */
+#define PSMD_MAX_RESOLUTION PSMD_RES_HIGH
/* PSMC_SET_SAMPLING_RATE */
#define PSMD_MAX_RATE 255 /* FIXME: not sure if it's possible */
@@ -151,79 +151,57 @@
#ifdef KERNEL
-/* 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
-
-/* debugging */
-/* #define KBDIO_DEBUG produces debugging output */
-
-/* end of driver specific options */
-
-/* misc */
#ifndef TRUE
-#define TRUE (-1)
+#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
+/* types/structures */
+
+typedef caddr_t KBDC;
+
/* function prototypes */
-int wait_while_controller_busy __P((int port));
+KBDC kbdc_open __P((int port));
+
+int kbdc_lock __P((KBDC kbdc, int lock));
+
+int kbdc_data_ready __P((KBDC kbdc));
-int wait_for_data __P((int port));
-int wait_for_kbd_data __P((int port));
-int wait_for_aux_data __P((int port));
+int write_controller_command __P((KBDC kbdc,int c));
+int write_controller_data __P((KBDC kbdc,int c));
-int write_controller_command __P((int port,int c));
-int write_controller_data __P((int port,int c));
+int write_kbd_command __P((KBDC kbdc,int c));
+int write_aux_command __P((KBDC kbdc,int c));
+int send_kbd_command __P((KBDC kbdc,int c));
+int send_aux_command __P((KBDC kbdc,int c));
+int send_kbd_command_and_data __P((KBDC kbdc,int c,int d));
+int send_aux_command_and_data __P((KBDC kbdc,int c,int d));
-int write_kbd_command __P((int port,int c));
-int write_aux_command __P((int port,int c));
-int send_kbd_command __P((int port,int c));
-int send_aux_command __P((int port,int c));
-int send_kbd_command_and_data __P((int port,int c,int d));
-int send_aux_command_and_data __P((int port,int c,int d));
+int read_controller_data __P((KBDC kbdc));
+int read_kbd_data __P((KBDC kbdc));
+int read_kbd_data_no_wait __P((KBDC kbdc));
+int read_aux_data __P((KBDC kbdc));
+int read_aux_data_no_wait __P((KBDC kbdc));
-int read_controller_data __P((int port));
-int read_kbd_data __P((int port));
-int read_kbd_data_no_wait __P((int port));
-int read_aux_data __P((int port));
+void empty_kbd_buffer __P((KBDC kbdc, int t));
+void empty_aux_buffer __P((KBDC kbdc, int t));
+void empty_both_buffers __P((KBDC kbdc, int t));
-void empty_kbd_buffer __P((int port, int t));
-void empty_aux_buffer __P((int port, int t));
-void empty_both_buffers __P((int port, int t));
+int reset_kbd __P((KBDC kbdc));
+int reset_aux_dev __P((KBDC kbdc));
-int reset_kbd __P((int port));
-int reset_aux_dev __P((int port));
+int test_controller __P((KBDC kbdc));
+int test_kbd_port __P((KBDC kbdc));
+int test_aux_port __P((KBDC kbdc));
-int test_controller __P((int port));
-int test_kbd_port __P((int port));
-int test_aux_port __P((int port));
+int kbdc_get_device_mask __P((KBDC kbdc));
+void kbdc_set_device_mask __P((KBDC kbdc, int mask));
-int set_controller_command_byte __P((int port,int command,int flag));
+int get_controller_command_byte __P((KBDC kbdc));
+int set_controller_command_byte __P((KBDC kbdc, int command, int flag));
#endif /* KERNEL */
diff --git a/sys/isa/syscons.c b/sys/isa/syscons.c
index 853efd6..68b5f01 100644
--- a/sys/isa/syscons.c
+++ b/sys/isa/syscons.c
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 1992-1996 Søren Schmidt
+ * Copyright (c) 1992-1997 Søren Schmidt
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -103,6 +103,7 @@ static term_stat kernel_console;
static default_attr *current_default;
static int flags = 0;
static int sc_port = IO_KBD;
+static KBDC sc_kbdc = NULL;
static char init_done = COLD;
static u_short sc_buffer[ROW*COL];
static char switch_in_progress = FALSE;
@@ -113,9 +114,6 @@ static int blinkrate = 0;
char crtc_vga = FALSE;
static u_char shfts = 0, ctls = 0, alts = 0, agrs = 0, metas = 0;
static u_char nlkcnt = 0, clkcnt = 0, slkcnt = 0, alkcnt = 0;
- char *font_8 = NULL, *font_14 = NULL, *font_16 = NULL;
- int fonts_loaded = 0;
- char *palette;
static const u_int n_fkey_tab = sizeof(fkey_tab) / sizeof(*fkey_tab);
static int delayed_next_scr = FALSE;
static long scrn_blank_time = 0; /* screen saver timeout value */
@@ -124,6 +122,11 @@ static long scrn_time_stamp;
u_char scr_map[256];
u_char scr_rmap[256];
char *video_mode_ptr = NULL;
+ int fonts_loaded = 0;
+ char font_8[256*8];
+ char font_14[256*14];
+ char font_16[256*16];
+ char palette[256*3];
static char *cut_buffer;
static u_short mouse_and_mask[16] = {
0xc000, 0xe000, 0xf000, 0xf800,
@@ -194,6 +197,7 @@ static void history_to_screen(scr_stat *scp);
static int history_up_line(scr_stat *scp);
static int history_down_line(scr_stat *scp);
static int mask2attr(struct term_stat *term);
+static void set_keyboard(int command, int data);
static void update_leds(int which);
static void set_vgaregs(char *modetable);
static void set_font_mode(void);
@@ -294,28 +298,34 @@ move_crsr(scr_stat *scp, int x, int y)
static int
scprobe(struct isa_device *dev)
{
- int c;
+ int codeset;
+ int c = -1;
+ int m;
sc_port = dev->id_iobase;
+ sc_kbdc = kbdc_open(sc_port);
+
+ if (!kbdc_lock(sc_kbdc, TRUE)) {
+ /* driver error? */
+ printf("sc%d: unable to lock the controller.\n", dev->id_unit);
+ return ((dev->id_flags & DETECT_KBD) ? 0 : IO_KBDSIZE);
+ }
/* discard anything left after UserConfig */
- empty_both_buffers(sc_port, 10);
+ empty_both_buffers(sc_kbdc, 10);
/* save the current keyboard controller command byte */
- c = -1;
- if (!write_controller_command(sc_port, KBDC_GET_COMMAND_BYTE)) {
- /* CONTROLLER ERROR */
- printf("sc%d: unable to get the current command byte value.\n",
- dev->id_unit);
- goto fail;
- }
- c = read_controller_data(sc_port);
+ m = kbdc_get_device_mask(sc_kbdc) & ~KBD_KBD_CONTROL_BITS;
+ c = get_controller_command_byte(sc_kbdc);
if (c == -1) {
/* CONTROLLER ERROR */
printf("sc%d: unable to get the current command byte value.\n",
dev->id_unit);
goto fail;
}
+ if (bootverbose)
+ printf("sc%d: the current keyboard controller command byte %04x\n",
+ dev->id_unit, c);
#if 0
/* override the keyboard lock switch */
c |= KBD_OVERRIDE_KBD_LOCK;
@@ -325,19 +335,40 @@ scprobe(struct isa_device *dev)
* enable the keyboard port, but disable the keyboard intr.
* the aux port (mouse port) is disabled too.
*/
- if (!set_controller_command_byte(sc_port,
- c & ~(KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS),
+ if (!set_controller_command_byte(sc_kbdc,
+ KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS,
KBD_ENABLE_KBD_PORT | KBD_DISABLE_KBD_INT
- | KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
+ | KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
/* CONTROLLER ERROR
* there is very little we can do...
*/
printf("sc%d: unable to set the command byte.\n", dev->id_unit);
goto fail;
}
+
+ /*
+ * Check if we have an XT keyboard before we attempt to reset it.
+ * The procedure assumes that the keyboard and the controller have
+ * been set up properly by BIOS and have not been messed up
+ * during the boot process.
+ */
+ codeset = -1;
+ if (dev->id_flags & XT_KEYBD)
+ /* the user says there is a XT keyboard */
+ codeset = 1;
+#ifdef DETECT_XT_KEYBOARD
+ else if ((c & KBD_TRANSLATION) == 0) {
+ /* SET_SCANCODE_SET is not always supported; ignore error */
+ if (send_kbd_command_and_data(sc_kbdc, KBDC_SET_SCANCODE_SET, 0)
+ == KBD_ACK)
+ codeset = read_kbd_data(sc_kbdc);
+ }
+ if (bootverbose)
+ printf("sc%d: keyboard scancode set %d\n", dev->id_unit, codeset);
+#endif /* DETECT_XT_KEYBOARD */
/* reset keyboard hardware */
- if (!reset_kbd(sc_port)) {
+ if (!reset_kbd(sc_kbdc)) {
/* KEYBOARD ERROR
* Keyboard reset may fail either because the keyboard doen't exist,
* or because the keyboard doesn't pass the self-test, or the keyboard
@@ -347,14 +378,14 @@ scprobe(struct isa_device *dev)
* test_controller() and test_kbd_port() appear to bring the keyboard
* controller back (I don't know why and how, though.)
*/
- empty_both_buffers(sc_port, 10);
- test_controller(sc_port);
- test_kbd_port(sc_port);
+ empty_both_buffers(sc_kbdc, 10);
+ test_controller(sc_kbdc);
+ test_kbd_port(sc_kbdc);
/* We could disable the keyboard port and interrupt... but,
* the keyboard may still exist (see above).
*/
- if (bootverbose)
- printf("sc%d: failed to reset the keyboard.\n", dev->id_unit);
+ if (bootverbose)
+ printf("sc%d: failed to reset the keyboard.\n", dev->id_unit);
goto fail;
}
@@ -363,9 +394,9 @@ scprobe(struct isa_device *dev)
* such as those on the IBM ThinkPad laptop computers can be used
* with the standard console driver.
*/
- if (dev->id_flags & XT_KEYBD) {
+ if (codeset == 1) {
if (send_kbd_command_and_data(
- sc_port, KBDC_SET_SCAN_CODESET, 1) == KBD_ACK) {
+ sc_kbdc, KBDC_SET_SCANCODE_SET, codeset) == KBD_ACK) {
/* XT kbd doesn't need scan code translation */
c &= ~KBD_TRANSLATION;
} else {
@@ -378,8 +409,10 @@ scprobe(struct isa_device *dev)
}
}
/* enable the keyboard port and intr. */
- if (!set_controller_command_byte(sc_port, c & ~KBD_KBD_CONTROL_BITS,
- KBD_ENABLE_KBD_PORT | KBD_ENABLE_KBD_INT)) {
+ if (!set_controller_command_byte(sc_kbdc,
+ KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS | KBD_OVERRIDE_KBD_LOCK,
+ (c & (KBD_AUX_CONTROL_BITS | KBD_OVERRIDE_KBD_LOCK))
+ | KBD_ENABLE_KBD_PORT | KBD_ENABLE_KBD_INT)) {
/* CONTROLLER ERROR
* This is serious; we are left with the disabled keyboard intr.
*/
@@ -389,12 +422,17 @@ scprobe(struct isa_device *dev)
}
succeed:
+ kbdc_set_device_mask(sc_kbdc, m | KBD_KBD_CONTROL_BITS),
+ kbdc_lock(sc_kbdc, FALSE);
return (IO_KBDSIZE);
fail:
if (c != -1)
- /* try to restore the command byte as before, if possible */
- set_controller_command_byte(sc_port, c, 0);
+ /* try to restore the command byte as before, if possible */
+ set_controller_command_byte(sc_kbdc, 0xff, c);
+ kbdc_set_device_mask(sc_kbdc,
+ (dev->id_flags & DETECT_KBD) ? m : m | KBD_KBD_CONTROL_BITS);
+ kbdc_lock(sc_kbdc, FALSE);
return ((dev->id_flags & DETECT_KBD) ? 0 : IO_KBDSIZE);
}
@@ -423,14 +461,6 @@ scattach(struct isa_device *dev)
if (crtc_vga) {
cut_buffer = (char *)malloc(scp->xsize*scp->ysize, M_DEVBUF, M_NOWAIT);
- font_8 = (char *)malloc(8*256, M_DEVBUF, M_NOWAIT);
- font_14 = (char *)malloc(14*256, M_DEVBUF, M_NOWAIT);
- font_16 = (char *)malloc(16*256, M_DEVBUF, M_NOWAIT);
- copy_font(SAVE, FONT_16, font_16);
- fonts_loaded = FONT_16;
- scp->font_size = FONT_16;
- palette = (char *)malloc(3*256, M_DEVBUF, M_NOWAIT);
- save_palette();
}
scp->scr_buf = (u_short *)malloc(scp->xsize*scp->ysize*sizeof(u_short),
@@ -1106,7 +1136,7 @@ scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
copy_font(LOAD, FONT_16, font_16);
if (flags & CHAR_CURSOR)
set_destructive_cursor(scp);
- load_palette();
+ load_palette(palette);
}
/* FALL THROUGH */
@@ -1155,9 +1185,8 @@ scioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
case KDSETRAD: /* set keyboard repeat & delay rates */
if (*data & 0x80)
return EINVAL;
- i = spltty();
- send_kbd_command_and_data(sc_port, KBDC_SET_TYPEMATIC, *data);
- splx(i);
+ if (sc_kbdc != NULL)
+ set_keyboard(KBDC_SET_TYPEMATIC, *data);
return 0;
case KDSKBMODE: /* set keyboard mode */
@@ -1405,6 +1434,8 @@ sccnprobe(struct consdev *cp)
/* initialize required fields */
cp->cn_dev = makedev(CDEV_MAJOR, SC_CONSOLE);
cp->cn_pri = CN_INTERNAL;
+
+ sc_kbdc = kbdc_open(sc_port);
}
void
@@ -1499,8 +1530,21 @@ scrn_timer()
* This ugly hack calls scintr if input is ready for the keyboard
* and conveniently hides the problem. XXX
*/
- if ((inb(sc_port+KBD_STATUS_PORT)&KBDS_BUFFER_FULL) == KBDS_KBD_BUFFER_FULL)
- scintr(0);
+ /* Try removing anything stuck in the keyboard controller; whether
+ * it's a keyboard scan code or mouse data. `scintr()' doesn't
+ * read the mouse data directly, but `kbdio' routines will, as a
+ * side effect.
+ */
+ if (kbdc_lock(sc_kbdc, TRUE)) {
+ /*
+ * We have seen the lock flag is not set. Let's reset the flag early;
+ * otherwise `update_led()' failes which may want the lock
+ * during `scintr()'.
+ */
+ kbdc_lock(sc_kbdc, FALSE);
+ if (kbdc_data_ready(sc_kbdc))
+ scintr(0);
+ }
/* should we just return ? */
if ((scp->status&UNKNOWN_MODE) || blink_in_progress || switch_in_progress) {
@@ -1659,7 +1703,7 @@ exchange_scr(void)
if ((old_scp->status & UNKNOWN_MODE) && crtc_vga) {
if (flags & CHAR_CURSOR)
set_destructive_cursor(new_scp);
- load_palette();
+ load_palette(palette);
}
if (old_scp->status & KBD_RAW_MODE || new_scp->status & KBD_RAW_MODE)
shfts = ctls = alts = agrs = metas = 0;
@@ -2354,9 +2398,8 @@ scinit(void)
u_long segoff;
crtc_vga = TRUE;
- /*
- * Get the BIOS video mode pointer.
- */
+
+ /* Get the BIOS video mode pointer */
segoff = *(u_long *)pa_to_va(0x4a8);
pa = (((segoff & 0xffff0000) >> 12) + (segoff & 0xffff));
if (ISMAPPED(pa, sizeof(u_long))) {
@@ -2374,6 +2417,13 @@ scinit(void)
bcopyw(Crtat, sc_buffer,
console[0]->xsize * console[0]->ysize * sizeof(u_short));
+ /* Save font and palette if VGA */
+ if (crtc_vga) {
+ copy_font(SAVE, FONT_16, font_16);
+ fonts_loaded = FONT_16;
+ save_palette();
+ }
+
console[0]->scr_buf = console[0]->mouse_pos = sc_buffer;
console[0]->cursor_pos = console[0]->cursor_oldpos = sc_buffer + hw_cursor;
console[0]->xpos = hw_cursor % COL;
@@ -2387,6 +2437,7 @@ scinit(void)
kernel_console.cur_color = kernel_console.std_color =
kernel_default.std_color;
kernel_console.rev_color = kernel_default.rev_color;
+
/* initialize mapscrn arrays to a one to one map */
for (i=0; i<sizeof(scr_map); i++) {
scr_map[i] = scr_rmap[i] = i;
@@ -2433,7 +2484,7 @@ init_scp(scr_stat *scp)
if (crtc_addr == MONO_BASE)
scp->mode = M_VGA_M80x25;
else
- scp->mode = M_VGA_C80x25;
+ scp->mode = M_VGA_C80x25;
else
if (crtc_addr == MONO_BASE)
scp->mode = M_B80x25;
@@ -2542,12 +2593,12 @@ scgetc(u_int flags)
next_code:
/* first see if there is something in the keyboard port */
if (flags & SCGETC_NONBLOCK) {
- c = read_kbd_data_no_wait(sc_port);
+ c = read_kbd_data_no_wait(sc_kbdc);
if (c == -1)
return(NOKEY);
} else {
do {
- c = read_kbd_data(sc_port);
+ c = read_kbd_data(sc_kbdc);
} while(c == -1);
}
scancode = (u_char)c;
@@ -3001,9 +3052,54 @@ mask2attr(struct term_stat *term)
}
static void
-update_leds(int which)
+set_keyboard(int command, int data)
{
int s;
+ int c;
+
+ if (sc_kbdc == NULL)
+ return;
+
+ /* prevent the timeout routine from polling the keyboard */
+ if (!kbdc_lock(sc_kbdc, TRUE))
+ return;
+
+ /* disable the keyboard and mouse interrupt */
+ s = spltty();
+ c = get_controller_command_byte(sc_kbdc);
+ if ((c == -1)
+ || !set_controller_command_byte(sc_kbdc,
+ kbdc_get_device_mask(sc_kbdc),
+ KBD_ENABLE_KBD_PORT | KBD_DISABLE_KBD_INT
+ | KBD_DISABLE_AUX_PORT | KBD_DISABLE_AUX_INT)) {
+ /* CONTROLLER ERROR */
+ kbdc_lock(sc_kbdc, FALSE);
+ splx(s);
+ return;
+ }
+ /*
+ * Now that the keyboard controller is told not to generate
+ * the keyboard and mouse interrupts, call `splx()' to allow
+ * the other tty interrupts. The clock interrupt may also occur,
+ * but the timeout routine (`scrn_timer()') will be blocked
+ * by the lock flag set via `kbdc_lock()'
+ */
+ splx(s);
+
+ send_kbd_command_and_data(sc_kbdc, command, data);
+
+ /* restore the interrupts */
+ if (!set_controller_command_byte(sc_kbdc,
+ kbdc_get_device_mask(sc_kbdc),
+ c & (KBD_KBD_CONTROL_BITS | KBD_AUX_CONTROL_BITS))) {
+ /* CONTROLLER ERROR */
+ }
+ kbdc_lock(sc_kbdc, FALSE);
+}
+
+static void
+update_leds(int which)
+{
static u_char xlate_leds[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
/* replace CAPS led with ALTGR led for ALTGR keyboards */
@@ -3014,10 +3110,7 @@ update_leds(int which)
which &= ~CLKED;
}
- s = spltty();
- send_kbd_command_and_data(sc_port, KBDC_SET_LEDS,
- xlate_leds[which & LED_MASK]);
- splx(s);
+ set_keyboard(KBDC_SET_LEDS, xlate_leds[which & LED_MASK]);
}
void
@@ -3595,7 +3688,7 @@ save_palette(void)
}
void
-load_palette(void)
+load_palette(char *palette)
{
int i;
@@ -3658,6 +3751,7 @@ toggle_splash_screen(scr_stat *scp)
scp->mode = save_mode;
scp->status &= ~UNKNOWN_MODE;
set_mode(scp);
+ load_palette(palette);
toggle = 0;
}
else {
diff --git a/sys/isa/syscons.h b/sys/isa/syscons.h
index a9d5a04..9af7e26 100644
--- a/sys/isa/syscons.h
+++ b/sys/isa/syscons.h
@@ -1,5 +1,5 @@
/*-
- * Copyright (c) 1995-1996 Søren Schmidt
+ * Copyright (c) 1995-1997 Søren Schmidt
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@@ -192,6 +192,6 @@ typedef struct default_attr {
void set_border(u_char color);
void set_mode(scr_stat *scp);
void copy_font(int operation, int font_type, char* font_image);
-void load_palette(void);
+void load_palette(char *palette);
#endif /* !_I386_ISA_SYSCONS_H_ */
OpenPOWER on IntegriCloud