[Midnightbsd-cvs] src: dev/uart: Fix merge conflicts.
laffer1 at midnightbsd.org
laffer1 at midnightbsd.org
Sat Nov 29 12:53:46 EST 2008
Log Message:
-----------
Fix merge conflicts.
Modified Files:
--------------
src/sys/dev/uart:
uart_kbd_sun.c (r1.2 -> r1.3)
uart_tty.c (r1.2 -> r1.3)
-------------- next part --------------
Index: uart_tty.c
===================================================================
RCS file: /home/cvs/src/sys/dev/uart/uart_tty.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -L sys/dev/uart/uart_tty.c -L sys/dev/uart/uart_tty.c -u -r1.2 -r1.3
--- sys/dev/uart/uart_tty.c
+++ sys/dev/uart/uart_tty.c
@@ -25,7 +25,7 @@
*/
#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/sys/dev/uart/uart_tty.c,v 1.22.2.1 2006/03/10 19:37:32 jhb Exp $");
+__FBSDID("$FreeBSD: src/sys/dev/uart/uart_tty.c,v 1.29 2006/07/27 00:07:10 marcel Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@@ -54,11 +54,9 @@
static cn_init_t uart_cninit;
static cn_term_t uart_cnterm;
static cn_getc_t uart_cngetc;
-static cn_checkc_t uart_cncheckc;
static cn_putc_t uart_cnputc;
-CONS_DRIVER(uart, uart_cnprobe, uart_cninit, uart_cnterm, uart_cngetc,
- uart_cncheckc, uart_cnputc, NULL);
+CONSOLE_DRIVER(uart);
static struct uart_devinfo uart_console;
@@ -118,17 +116,10 @@
}
static int
-uart_cncheckc(struct consdev *cp)
-{
-
- return (uart_poll(cp->cn_arg));
-}
-
-static int
uart_cngetc(struct consdev *cp)
{
- return (uart_getc(cp->cn_arg));
+ return (uart_poll(cp->cn_arg));
}
static int
@@ -137,6 +128,10 @@
struct uart_softc *sc;
sc = tp->t_sc;
+
+ if (sc == NULL || sc->sc_leaving)
+ return (ENXIO);
+
sc->sc_opened = 1;
return (0);
}
@@ -307,30 +302,32 @@
return;
pend = atomic_readandclear_32(&sc->sc_ttypend);
- if (!(pend & UART_IPEND_MASK))
+ if (!(pend & SER_INT_MASK))
return;
tp = sc->sc_u.u_tty.tp;
- if (pend & UART_IPEND_RXREADY) {
+ if (pend & SER_INT_RXREADY) {
while (!uart_rx_empty(sc) && !(tp->t_state & TS_TBLOCK)) {
xc = uart_rx_get(sc);
c = xc & 0xff;
if (xc & UART_STAT_FRAMERR)
c |= TTY_FE;
+ if (xc & UART_STAT_OVERRUN)
+ c |= TTY_OE;
if (xc & UART_STAT_PARERR)
c |= TTY_PE;
ttyld_rint(tp, c);
}
}
- if (pend & UART_IPEND_BREAK) {
+ if (pend & SER_INT_BREAK) {
if (tp != NULL && !(tp->t_iflag & IGNBRK))
ttyld_rint(tp, 0);
}
- if (pend & UART_IPEND_SIGCHG) {
- sig = pend & UART_IPEND_SIGMASK;
+ if (pend & SER_INT_SIGCHG) {
+ sig = pend & SER_INT_SIGMASK;
if (sig & SER_DDCD)
ttyld_modem(tp, sig & SER_DCD);
if ((sig & SER_DCTS) && (tp->t_cflag & CCTS_OFLOW) &&
@@ -343,7 +340,7 @@
}
}
- if (pend & UART_IPEND_TXIDLE) {
+ if (pend & SER_INT_TXIDLE) {
tp->t_state &= ~TS_BUSY;
ttyld_start(tp);
}
@@ -380,7 +377,7 @@
swi_add(&tty_intr_event, uart_driver_name, uart_tty_intr, sc, SWI_TTY,
INTR_TYPE_TTY, &sc->sc_softih);
- ttycreate(tp, NULL, 0, MINOR_CALLOUT, "u%r", unit);
+ ttycreate(tp, TS_CALLOUT, "u%r", unit);
return (0);
}
Index: uart_kbd_sun.c
===================================================================
RCS file: /home/cvs/src/sys/dev/uart/uart_kbd_sun.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -L sys/dev/uart/uart_kbd_sun.c -L sys/dev/uart/uart_kbd_sun.c -u -r1.2 -r1.3
--- sys/dev/uart/uart_kbd_sun.c
+++ sys/dev/uart/uart_kbd_sun.c
@@ -25,9 +25,16 @@
*/
#include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/sys/dev/uart/uart_kbd_sun.c,v 1.5.2.1 2006/03/10 19:37:32 jhb Exp $");
+__FBSDID("$FreeBSD: src/sys/dev/uart/uart_kbd_sun.c,v 1.13 2007/05/01 14:14:52 marius Exp $");
+#include "opt_compat.h"
#include "opt_kbd.h"
+#include "opt_sunkbd.h"
+
+#if (defined(SUNKBD_EMULATE_ATKBD) && defined(SUNKBD_DFLT_KEYMAP)) || \
+ !defined(SUNKBD_EMULATE_ATKBD)
+#define KBD_DFLT_KEYMAP
+#endif
#include <sys/param.h>
#include <sys/systm.h>
@@ -35,26 +42,28 @@
#include <sys/interrupt.h>
#include <sys/kbio.h>
#include <sys/kernel.h>
-#include <sys/malloc.h>
-#include <sys/ktr.h>
+#include <sys/limits.h>
#include <machine/bus.h>
-#include <machine/resource.h>
-
-#include <sys/rman.h>
#include <dev/kbd/kbdreg.h>
+#include <dev/kbd/kbdtables.h>
#include <dev/uart/uart.h>
#include <dev/uart/uart_bus.h>
#include <dev/uart/uart_cpu.h>
#include <dev/uart/uart_kbd_sun.h>
+#if !defined(SUNKBD_EMULATE_ATKBD)
#include <dev/uart/uart_kbd_sun_tables.h>
+#endif
+#if defined(SUNKBD_EMULATE_ATKBD) && defined(SUNKBD_DFLT_KEYMAP)
+#include "sunkbdmap.h"
+#endif
#include "uart_if.h"
-#define SUNKBD_BUF_SIZE 128
+#define SUNKBD_DRIVER_NAME "sunkbd"
#define TODO printf("%s: unimplemented", __func__)
@@ -67,10 +76,17 @@
int sc_repeat_key;
int sc_accents;
+ int sc_composed_char;
+ int sc_flags;
+#define KPCOMPOSE (1 << 0)
int sc_mode;
int sc_polling;
int sc_repeating;
int sc_state;
+
+#if defined(SUNKBD_EMULATE_ATKBD)
+ int sc_buffered_char[2];
+#endif
};
static int sunkbd_configure(int flags);
@@ -96,6 +112,9 @@
static void sunkbd_diag(keyboard_t *kbd, int level);
static void sunkbd_repeat(void *v);
+#if defined(SUNKBD_EMULATE_ATKBD)
+static int keycode2scancode(int keycode, int shift, int up);
+#endif
static keyboard_switch_t sunkbdsw = {
sunkbd_probe,
@@ -124,41 +143,46 @@
static struct sunkbd_softc sunkbd_softc;
static struct uart_devinfo uart_keyboard;
-static fkeytab_t fkey_tab[96] = {
-/* 01-04 */ {"\033[M", 3}, {"\033[N", 3}, {"\033[O", 3}, {"\033[P", 3},
-/* 05-08 */ {"\033[Q", 3}, {"\033[R", 3}, {"\033[S", 3}, {"\033[T", 3},
-/* 09-12 */ {"\033[U", 3}, {"\033[V", 3}, {"\033[W", 3}, {"\033[X", 3},
-/* 13-16 */ {"\033[Y", 3}, {"\033[Z", 3}, {"\033[a", 3}, {"\033[b", 3},
-/* 17-20 */ {"\033[c", 3}, {"\033[d", 3}, {"\033[e", 3}, {"\033[f", 3},
-/* 21-24 */ {"\033[g", 3}, {"\033[h", 3}, {"\033[i", 3}, {"\033[j", 3},
-/* 25-28 */ {"\033[k", 3}, {"\033[l", 3}, {"\033[m", 3}, {"\033[n", 3},
-/* 29-32 */ {"\033[o", 3}, {"\033[p", 3}, {"\033[q", 3}, {"\033[r", 3},
-/* 33-36 */ {"\033[s", 3}, {"\033[t", 3}, {"\033[u", 3}, {"\033[v", 3},
-/* 37-40 */ {"\033[w", 3}, {"\033[x", 3}, {"\033[y", 3}, {"\033[z", 3},
-/* 41-44 */ {"\033[@", 3}, {"\033[[", 3}, {"\033[\\",3}, {"\033[]", 3},
-/* 45-48 */ {"\033[^", 3}, {"\033[_", 3}, {"\033[`", 3}, {"\033[{", 3},
-/* 49-52 */ {"\033[H", 3}, {"\033[A", 3}, {"\033[I", 3}, {"-" , 1},
-/* 53-56 */ {"\033[D", 3}, {"\033[E", 3}, {"\033[C", 3}, {"+" , 1},
-/* 57-60 */ {"\033[F", 3}, {"\033[B", 3}, {"\033[G", 3}, {"\033[L", 3},
-/* 61-64 */ {"\177", 1}, {"\033[J", 3}, {"\033[~", 3}, {"\033[}", 3},
-/* 65-68 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 69-72 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 73-76 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 77-80 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 81-84 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 85-88 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 89-92 */ {"", 0} , {"", 0} , {"", 0} , {"", 0} ,
-/* 93-96 */ {"", 0} , {"", 0} , {"", 0} , {"", 0}
+#if defined(SUNKBD_EMULATE_ATKBD)
+
+#define SCAN_PRESS 0x000
+#define SCAN_RELEASE 0x080
+#define SCAN_PREFIX_E0 0x100
+#define SCAN_PREFIX_E1 0x200
+#define SCAN_PREFIX_CTL 0x400
+#define SCAN_PREFIX_SHIFT 0x800
+#define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \
+ SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT)
+
+#define NOTR 0x0 /* no translation */
+
+static const uint8_t sunkbd_trtab[] = {
+ NOTR, 0x6d, 0x78, 0x6e, 0x79, 0x3b, 0x3c, 0x44, /* 0x00 - 0x07 */
+ 0x3d, 0x57, 0x3e, 0x58, 0x3f, 0x5d, 0x40, NOTR, /* 0x08 - 0x0f */
+ 0x41, 0x42, 0x43, 0x38, 0x5f, 0x68, 0x5c, 0x46, /* 0x10 - 0x17 */
+ 0x61, 0x6f, 0x70, 0x64, 0x62, 0x01, 0x02, 0x03, /* 0x18 - 0x1f */
+ 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, /* 0x20 - 0x27 */
+ 0x0c, 0x0d, 0x29, 0x0e, 0x66, 0x77, 0x5b, 0x37, /* 0x28 - 0x2f */
+ 0x7a, 0x71, 0x53, 0x74, 0x5e, 0x0f, 0x10, 0x11, /* 0x30 - 0x37 */
+ 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, /* 0x38 - 0x3f */
+ 0x1a, 0x1b, 0x67, 0x6b, 0x47, 0x48, 0x49, 0x4a, /* 0x40 - 0x47 */
+ 0x73, 0x72, 0x63, NOTR, 0x1d, 0x1e, 0x1f, 0x20, /* 0x48 - 0x4f */
+ 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, /* 0x50 - 0x57 */
+ 0x2b, 0x1c, 0x59, 0x4b, 0x4c, 0x4d, 0x52, 0x75, /* 0x58 - 0x5f */
+ 0x60, 0x76, 0x45, 0x2a, 0x2c, 0x2d, 0x2e, 0x2f, /* 0x60 - 0x67 */
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, NOTR, /* 0x68 - 0x6f */
+ 0x4f, 0x50, 0x51, NOTR, NOTR, NOTR, 0x6c, 0x3a, /* 0x70 - 0x77 */
+ 0x69, 0x39, 0x6a, 0x65, 0x56, 0x4e, NOTR, NOTR /* 0x78 - 0x7f */
};
+#endif
+
static int
sunkbd_probe_keyboard(struct uart_devinfo *di)
{
- int tries;
+ int c, id, ltries, tries;
for (tries = 5; tries != 0; tries--) {
- int ltries;
-
uart_putc(di, SKBD_CMD_RESET);
for (ltries = 1000; ltries != 0; ltries--) {
if (uart_poll(di) == SKBD_RSP_RESET)
@@ -167,17 +191,18 @@
}
if (ltries == 0)
continue;
+ id = -1;
for (ltries = 1000; ltries != 0; ltries--) {
- if (uart_poll(di) == SKBD_RSP_IDLE)
+ switch (c = uart_poll(di)) {
+ case -1:
break;
+ case SKBD_RSP_IDLE:
+ return (id);
+ default:
+ id = c;
+ }
DELAY(1000);
}
- if (ltries == 0)
- continue;
- uart_putc(di, SKBD_CMD_LAYOUT);
- if (uart_getc(di) != SKBD_RSP_LAYOUT)
- break;
- return (uart_getc(di));
}
return (-1);
}
@@ -211,18 +236,23 @@
uart_keyboard.attach = sunkbd_attach;
uart_add_sysdev(&uart_keyboard);
- if (sunkbd_probe_keyboard(&uart_keyboard) == -1)
+ if (sunkbd_probe_keyboard(&uart_keyboard) != KB_SUN4)
return (0);
sc = &sunkbd_softc;
callout_init(&sc->sc_repeat_callout, 0);
- sc->sc_repeat_key = -1;
- sc->sc_repeating = 0;
+ sunkbd_clear_state(&sc->sc_kbd);
- kbd_init_struct(&sc->sc_kbd, "sunkbd", KB_OTHER, 0, 0, 0, 0);
+#if defined(SUNKBD_EMULATE_ATKBD)
+ kbd_init_struct(&sc->sc_kbd, SUNKBD_DRIVER_NAME, KB_101, 0, 0, 0, 0);
+ kbd_set_maps(&sc->sc_kbd, &key_map, &accent_map, fkey_tab,
+ sizeof(fkey_tab) / sizeof(fkey_tab[0]));
+#else
+ kbd_init_struct(&sc->sc_kbd, SUNKBD_DRIVER_NAME, KB_OTHER, 0, 0, 0, 0);
kbd_set_maps(&sc->sc_kbd, &keymap_sun_us_unix_kbd,
&accentmap_sun_us_unix_kbd, fkey_tab,
sizeof(fkey_tab) / sizeof(fkey_tab[0]));
+#endif
sc->sc_mode = K_XLATE;
kbd_register(&sc->sc_kbd);
@@ -274,21 +304,21 @@
return;
pend = atomic_readandclear_32(&sc->sc_uart->sc_ttypend);
- if (!(pend & UART_IPEND_MASK))
+ if (!(pend & SER_INT_MASK))
return;
- if (pend & UART_IPEND_RXREADY) {
+ if (pend & SER_INT_RXREADY) {
if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) {
sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
}
}
-
}
static int
sunkbd_probe(int unit, void *arg, int flags)
{
+
TODO;
return (0);
}
@@ -296,6 +326,7 @@
static int
sunkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
{
+
TODO;
return (0);
}
@@ -303,6 +334,7 @@
static int
sunkbd_term(keyboard_t *kbd)
{
+
TODO;
return (0);
}
@@ -310,6 +342,7 @@
static int
sunkbd_intr(keyboard_t *kbd, void *arg)
{
+
TODO;
return (0);
}
@@ -317,6 +350,7 @@
static int
sunkbd_test_if(keyboard_t *kbd)
{
+
TODO;
return (0);
}
@@ -324,6 +358,7 @@
static int
sunkbd_enable(keyboard_t *kbd)
{
+
KBD_ACTIVATE(kbd);
return (0);
}
@@ -331,6 +366,7 @@
static int
sunkbd_disable(keyboard_t *kbd)
{
+
KBD_DEACTIVATE(kbd);
return (0);
}
@@ -338,6 +374,7 @@
static int
sunkbd_read(keyboard_t *kbd, int wait)
{
+
TODO;
return (0);
}
@@ -345,69 +382,250 @@
static int
sunkbd_check(keyboard_t *kbd)
{
- TODO;
- return (0);
+ struct sunkbd_softc *sc;
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (FALSE);
+
+ sc = (struct sunkbd_softc *)kbd;
+
+#if defined(SUNKBD_EMULATE_ATKBD)
+ if (sc->sc_buffered_char[0])
+ return (TRUE);
+#endif
+
+ if (sc->sc_repeating)
+ return (TRUE);
+
+ if (sc->sc_uart != NULL && !uart_rx_empty(sc->sc_uart))
+ return (TRUE);
+
+ if (sc->sc_polling != 0 && sc->sc_sysdev != NULL &&
+ uart_rxready(sc->sc_sysdev))
+ return (TRUE);
+
+ return (FALSE);
}
static u_int
sunkbd_read_char(keyboard_t *kbd, int wait)
{
struct sunkbd_softc *sc;
- int action;
- int key;
+ int key, release, repeated, suncode;
sc = (struct sunkbd_softc *)kbd;
+
+#if defined(SUNKBD_EMULATE_ATKBD)
+ if (sc->sc_mode == K_RAW && sc->sc_buffered_char[0]) {
+ key = sc->sc_buffered_char[0];
+ if (key & SCAN_PREFIX) {
+ sc->sc_buffered_char[0] = key & ~SCAN_PREFIX;
+ return ((key & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
+ } else {
+ sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
+ sc->sc_buffered_char[1] = 0;
+ return (key);
+ }
+ }
+#endif
+
+ repeated = 0;
if (sc->sc_repeating) {
+ repeated = 1;
sc->sc_repeating = 0;
callout_reset(&sc->sc_repeat_callout, hz / 10,
sunkbd_repeat, sc);
- key = sc->sc_repeat_key;
- if (sc->sc_mode == K_RAW)
- return (key);
- else
- return genkbd_keyaction(kbd, key & 0x7f, key & 0x80,
- &sc->sc_state, &sc->sc_accents);
+ suncode = sc->sc_repeat_key;
+ goto process_code;
}
for (;;) {
- /* XXX compose */
+ next_code:
+ if (!(sc->sc_flags & KPCOMPOSE) && (sc->sc_composed_char > 0)) {
+ key = sc->sc_composed_char;
+ sc->sc_composed_char = 0;
+ if (key > UCHAR_MAX)
+ return (ERRKEY);
+ return (key);
+ }
if (sc->sc_uart != NULL && !uart_rx_empty(sc->sc_uart)) {
- key = uart_rx_get(sc->sc_uart);
+ suncode = uart_rx_get(sc->sc_uart);
} else if (sc->sc_polling != 0 && sc->sc_sysdev != NULL) {
if (wait)
- key = uart_getc(sc->sc_sysdev);
- else if ((key = uart_poll(sc->sc_sysdev)) == -1)
+ suncode = uart_getc(sc->sc_sysdev);
+ else if ((suncode = uart_poll(sc->sc_sysdev)) == -1)
return (NOKEY);
} else {
return (NOKEY);
}
- switch (key) {
+ switch (suncode) {
case SKBD_RSP_IDLE:
break;
default:
+ process_code:
++kbd->kb_count;
-
- if ((key & 0x80) == 0) {
- callout_reset(&sc->sc_repeat_callout, hz / 2,
- sunkbd_repeat, sc);
- sc->sc_repeat_key = key;
- } else {
- if (sc->sc_repeat_key == (key & 0x7f)) {
+ key = SKBD_KEY_CHAR(suncode);
+ release = suncode & SKBD_KEY_RELEASE;
+ if (!repeated) {
+ if (release == 0) {
+ callout_reset(&sc->sc_repeat_callout,
+ hz / 2, sunkbd_repeat, sc);
+ sc->sc_repeat_key = suncode;
+ } else if (sc->sc_repeat_key == key) {
callout_stop(&sc->sc_repeat_callout);
sc->sc_repeat_key = -1;
}
}
- if (sc->sc_mode == K_RAW)
+#if defined(SUNKBD_EMULATE_ATKBD)
+ key = sunkbd_trtab[key];
+ if (key == NOTR)
+ return (NOKEY);
+
+ if (!repeated) {
+ switch (key) {
+ case 0x1d: /* ctrl */
+ if (release != 0)
+ sc->sc_flags &= ~CTLS;
+ else
+ sc->sc_flags |= CTLS;
+ break;
+ case 0x2a: /* left shift */
+ case 0x36: /* right shift */
+ if (release != 0)
+ sc->sc_flags &= ~SHIFTS;
+ else
+ sc->sc_flags |= SHIFTS;
+ break;
+ case 0x38: /* alt */
+ case 0x5d: /* altgr */
+ if (release != 0)
+ sc->sc_flags &= ~ALTS;
+ else
+ sc->sc_flags |= ALTS;
+ break;
+ }
+ }
+ if (sc->sc_mode == K_RAW) {
+ key = keycode2scancode(key, sc->sc_flags,
+ release);
+ if (key & SCAN_PREFIX) {
+ if (key & SCAN_PREFIX_CTL) {
+ sc->sc_buffered_char[0] =
+ 0x1d | (key & SCAN_RELEASE);
+ sc->sc_buffered_char[1] =
+ key & ~SCAN_PREFIX;
+ } else if (key & SCAN_PREFIX_SHIFT) {
+ sc->sc_buffered_char[0] =
+ 0x2a | (key & SCAN_RELEASE);
+ sc->sc_buffered_char[1] =
+ key & ~SCAN_PREFIX_SHIFT;
+ } else {
+ sc->sc_buffered_char[0] =
+ key & ~SCAN_PREFIX;
+ sc->sc_buffered_char[1] = 0;
+ }
+ return ((key & SCAN_PREFIX_E0) ?
+ 0xe0 : 0xe1);
+ }
return (key);
+ }
+ switch (key) {
+ case 0x5c: /* print screen */
+ if (sc->sc_flags & ALTS)
+ key = 0x54; /* sysrq */
+ break;
+ case 0x68: /* pause/break */
+ if (sc->sc_flags & CTLS)
+ key = 0x6c; /* break */
+ break;
+ }
+
+ if (sc->sc_mode == K_CODE)
+ return (key | release);
+#else
+ if (sc->sc_mode == K_RAW || sc->sc_mode == K_CODE)
+ return (suncode);
+#endif
- action = genkbd_keyaction(kbd, key & 0x7f, key & 0x80,
+#if defined(SUNKBD_EMULATE_ATKBD)
+ if (key == 0x38) { /* left alt (KP compose key) */
+#else
+ if (key == 0x13) { /* left alt (KP compose key) */
+#endif
+ if (release != 0) {
+ if (sc->sc_flags & KPCOMPOSE) {
+ sc->sc_flags &= ~KPCOMPOSE;
+ if (sc->sc_composed_char >
+ UCHAR_MAX)
+ sc->sc_composed_char =
+ 0;
+ }
+ } else {
+ if (!(sc->sc_flags & KPCOMPOSE)) {
+ sc->sc_flags |= KPCOMPOSE;
+ sc->sc_composed_char = 0;
+ }
+ }
+ }
+ if (sc->sc_flags & KPCOMPOSE) {
+ switch (suncode) {
+ case 0x44: /* KP 7 */
+ case 0x45: /* KP 8 */
+ case 0x46: /* KP 9 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += suncode - 0x3d;
+ if (sc->sc_composed_char > UCHAR_MAX)
+ return (ERRKEY);
+ goto next_code;
+ case 0x5b: /* KP 4 */
+ case 0x5c: /* KP 5 */
+ case 0x5d: /* KP 6 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += suncode - 0x58;
+ if (sc->sc_composed_char > UCHAR_MAX)
+ return (ERRKEY);
+ goto next_code;
+ case 0x70: /* KP 1 */
+ case 0x71: /* KP 2 */
+ case 0x72: /* KP 3 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += suncode - 0x6f;
+ if (sc->sc_composed_char > UCHAR_MAX)
+ return (ERRKEY);
+ goto next_code;
+ case 0x5e: /* KP 0 */
+ sc->sc_composed_char *= 10;
+ if (sc->sc_composed_char > UCHAR_MAX)
+ return (ERRKEY);
+ goto next_code;
+
+ case 0x44 | SKBD_KEY_RELEASE: /* KP 7 */
+ case 0x45 | SKBD_KEY_RELEASE: /* KP 8 */
+ case 0x46 | SKBD_KEY_RELEASE: /* KP 9 */
+ case 0x5b | SKBD_KEY_RELEASE: /* KP 4 */
+ case 0x5c | SKBD_KEY_RELEASE: /* KP 5 */
+ case 0x5d | SKBD_KEY_RELEASE: /* KP 6 */
+ case 0x70 | SKBD_KEY_RELEASE: /* KP 1 */
+ case 0x71 | SKBD_KEY_RELEASE: /* KP 2 */
+ case 0x72 | SKBD_KEY_RELEASE: /* KP 3 */
+ case 0x5e | SKBD_KEY_RELEASE: /* KP 0 */
+ goto next_code;
+ default:
+ if (sc->sc_composed_char > 0) {
+ sc->sc_flags &= ~KPCOMPOSE;
+ sc->sc_composed_char = 0;
+ return (ERRKEY);
+ }
+ }
+ }
+
+ key = genkbd_keyaction(kbd, key, release,
&sc->sc_state, &sc->sc_accents);
- if (action != NOKEY)
- return (action);
- break;
+ if (key != NOKEY || repeated)
+ return (key);
}
}
return (0);
@@ -416,15 +634,26 @@
static int
sunkbd_check_char(keyboard_t *kbd)
{
- TODO;
- return (0);
+ struct sunkbd_softc *sc;
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (FALSE);
+
+ sc = (struct sunkbd_softc *)kbd;
+ if (!(sc->sc_flags & KPCOMPOSE) && (sc->sc_composed_char > 0))
+ return (TRUE);
+
+ return (sunkbd_check(kbd));
}
static int
sunkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t data)
{
struct sunkbd_softc *sc;
- int error;
+ int c, error;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5)
+ int ival;
+#endif
sc = (struct sunkbd_softc *)kbd;
error = 0;
@@ -432,6 +661,12 @@
case KDGKBMODE:
*(int *)data = sc->sc_mode;
break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5)
+ case _IO('K', 7):
+ ival = IOCPARM_IVAL(data);
+ data = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
case KDSKBMODE:
switch (*(int *)data) {
case K_XLATE:
@@ -456,28 +691,41 @@
case KDGETLED:
*(int *)data = KBD_LED_VAL(kbd);
break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5)
+ case _IO('K', 66):
+ ival = IOCPARM_IVAL(data);
+ data = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
case KDSETLED:
if (*(int *)data & ~LOCK_MASK) {
error = EINVAL;
break;
}
- if (sc->sc_uart == NULL)
+ if (sc->sc_sysdev == NULL)
break;
- sc->sc_uart->sc_txdatasz = 2;
- sc->sc_uart->sc_txbuf[0] = SKBD_CMD_SETLED;
- sc->sc_uart->sc_txbuf[1] = 0;
+ c = 0;
if (*(int *)data & CLKED)
- sc->sc_uart->sc_txbuf[1] |= SKBD_LED_CAPSLOCK;
+ c |= SKBD_LED_CAPSLOCK;
if (*(int *)data & NLKED)
- sc->sc_uart->sc_txbuf[1] |= SKBD_LED_NUMLOCK;
+ c |= SKBD_LED_NUMLOCK;
if (*(int *)data & SLKED)
- sc->sc_uart->sc_txbuf[1] |= SKBD_LED_SCROLLLOCK;
- UART_TRANSMIT(sc->sc_uart);
+ c |= SKBD_LED_SCROLLLOCK;
+ uart_lock(sc->sc_sysdev->hwmtx);
+ sc->sc_sysdev->ops->putc(&sc->sc_sysdev->bas, SKBD_CMD_SETLED);
+ sc->sc_sysdev->ops->putc(&sc->sc_sysdev->bas, c);
+ uart_unlock(sc->sc_sysdev->hwmtx);
KBD_LED_VAL(kbd) = *(int *)data;
break;
case KDGKBSTATE:
*(int *)data = sc->sc_state & LOCK_MASK;
break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5)
+ case _IO('K', 20):
+ ival = IOCPARM_IVAL(data);
+ data = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
case KDSKBSTATE:
if (*(int *)data & ~LOCK_MASK) {
error = EINVAL;
@@ -485,7 +733,8 @@
}
sc->sc_state &= ~LOCK_MASK;
sc->sc_state |= *(int *)data;
- break;
+ /* set LEDs and quit */
+ return (sunkbd_ioctl(kbd, KDSETLED, data));
case KDSETREPEAT:
case KDSETRAD:
break;
@@ -501,6 +750,7 @@
static int
sunkbd_lock(keyboard_t *kbd, int lock)
{
+
TODO;
return (0);
}
@@ -508,12 +758,27 @@
static void
sunkbd_clear_state(keyboard_t *kbd)
{
- /* TODO; */
+ struct sunkbd_softc *sc;
+
+ sc = (struct sunkbd_softc *)kbd;
+ sc->sc_repeat_key = -1;
+ sc->sc_accents = 0;
+ sc->sc_composed_char = 0;
+ sc->sc_flags = 0;
+ sc->sc_polling = 0;
+ sc->sc_repeating = 0;
+ sc->sc_state &= LOCK_MASK; /* Preserve locking key state. */
+
+#if defined(SUNKBD_EMULATE_ATKBD)
+ sc->sc_buffered_char[0] = 0;
+ sc->sc_buffered_char[1] = 0;
+#endif
}
static int
sunkbd_get_state(keyboard_t *kbd, void *buf, size_t len)
{
+
TODO;
return (0);
}
@@ -521,6 +786,7 @@
static int
sunkbd_set_state(keyboard_t *kbd, void *buf, size_t len)
{
+
TODO;
return (0);
}
@@ -541,6 +807,7 @@
static void
sunkbd_diag(keyboard_t *kbd, int level)
{
+
TODO;
}
@@ -549,9 +816,53 @@
{
struct sunkbd_softc *sc = v;
- if (sc->sc_repeat_key != -1) {
- sc->sc_repeating = 1;
- sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
- KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
+ if (KBD_IS_ACTIVE(&sc->sc_kbd) && KBD_IS_BUSY(&sc->sc_kbd)) {
+ if (sc->sc_repeat_key != -1) {
+ sc->sc_repeating = 1;
+ sc->sc_kbd.kb_callback.kc_func(&sc->sc_kbd,
+ KBDIO_KEYINPUT, sc->sc_kbd.kb_callback.kc_arg);
+ }
}
}
+
+#if defined(SUNKBD_EMULATE_ATKBD)
+static int
+keycode2scancode(int keycode, int shift, int up)
+{
+ static const int scan[] = {
+ /* KP enter, right ctrl, KP divide */
+ 0x1c , 0x1d , 0x35 ,
+ /* print screen */
+ 0x37 | SCAN_PREFIX_SHIFT,
+ /* right alt, home, up, page up, left, right, end */
+ 0x38, 0x47, 0x48, 0x49, 0x4b, 0x4d, 0x4f,
+ /* down, page down, insert, delete */
+ 0x50, 0x51, 0x52, 0x53,
+ /* pause/break (see also below) */
+ 0x46,
+ /*
+ * MS: left window, right window, menu
+ * also Sun: left meta, right meta, compose
+ */
+ 0x5b, 0x5c, 0x5d,
+ /* Sun type 6 USB */
+ /* help, stop, again, props, undo, front, copy */
+ 0x68, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
+ /* open, paste, find, cut, audiomute, audiolower, audioraise */
+ 0x64, 0x65, 0x66, 0x67, 0x25, 0x1f, 0x1e,
+ /* power */
+ 0x20
+ };
+ int scancode;
+
+ scancode = keycode;
+ if ((keycode >= 89) && (keycode < 89 + sizeof(scan) / sizeof(scan[0])))
+ scancode = scan[keycode - 89] | SCAN_PREFIX_E0;
+ /* pause/break */
+ if ((keycode == 104) && !(shift & CTLS))
+ scancode = 0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL;
+ if (shift & SHIFTS)
+ scancode &= ~SCAN_PREFIX_SHIFT;
+ return (scancode | (up ? SCAN_RELEASE : SCAN_PRESS));
+}
+#endif
More information about the Midnightbsd-cvs
mailing list