/* $OpenBSD: pckbd.c,v 1.51 2023/08/13 21:54:02 miod Exp $ */ /* $NetBSD: pckbd.c,v 1.24 2000/06/05 22:20:57 sommerfeld Exp $ */ /*- * Copyright (c) 1998 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Charles M. Hannum. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /*- * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz and Don Ahn. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)pccons.c 5.11 (Berkeley) 5/21/91 */ /* * code to work keyboard for PC-style console */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include struct pckbd_internal { int t_isconsole; pckbc_tag_t t_kbctag; pckbc_slot_t t_kbcslot; int t_translating; /* nonzero if hardware performs translation */ int t_table; /* scan code set in use */ int t_lastchar; int t_extended; int t_extended1; int t_releasing; struct pckbd_softc *t_sc; /* back pointer */ }; struct pckbd_softc { struct device sc_dev; struct pckbd_internal *id; int sc_enabled; int sc_ledstate; struct device *sc_wskbddev; #ifdef WSDISPLAY_COMPAT_RAWKBD int rawkbd; u_int sc_rawcnt; char sc_rawbuf[3]; #endif }; static int pckbd_is_console(pckbc_tag_t, pckbc_slot_t); int pckbdprobe(struct device *, void *, void *); void pckbdattach(struct device *, struct device *, void *); int pckbdactivate(struct device *, int); const struct cfattach pckbd_ca = { sizeof(struct pckbd_softc), pckbdprobe, pckbdattach, NULL, pckbdactivate }; int pckbd_enable(void *, int); void pckbd_set_leds(void *, int); int pckbd_ioctl(void *, u_long, caddr_t, int, struct proc *); const struct wskbd_accessops pckbd_accessops = { pckbd_enable, pckbd_set_leds, pckbd_ioctl, }; void pckbd_cngetc(void *, u_int *, int *); void pckbd_cnpollc(void *, int); void pckbd_cnbell(void *, u_int, u_int, u_int); const struct wskbd_consops pckbd_consops = { pckbd_cngetc, pckbd_cnpollc, pckbd_cnbell, }; const struct wskbd_mapdata pckbd_keymapdata = { pckbd_keydesctab, #ifdef PCKBD_LAYOUT PCKBD_LAYOUT, #else KB_US | KB_DEFAULT, #endif }; /* * Hackish support for a bell on the PC Keyboard; when a suitable beeper * is found, it attaches itself into the pckbd driver here. */ void (*pckbd_bell_fn)(void *, u_int, u_int, u_int, int); void *pckbd_bell_fn_arg; void pckbd_bell(u_int, u_int, u_int, int); int pckbd_scancode_translate(struct pckbd_internal *, int); int pckbd_set_xtscancode(pckbc_tag_t, pckbc_slot_t, struct pckbd_internal *); void pckbd_init(struct pckbd_internal *, pckbc_tag_t, pckbc_slot_t, int); void pckbd_input(void *, int); static int pckbd_decode(struct pckbd_internal *, int, u_int *, int *); static int pckbd_led_encode(int); struct pckbd_internal pckbd_consdata; int pckbdactivate(struct device *self, int act) { struct pckbd_softc *sc = (struct pckbd_softc *)self; int rv = 0; u_char cmd[1]; switch(act) { case DVACT_RESUME: if (sc->sc_enabled) { /* * Some keyboards are not enabled after a reset, * so make sure it is enabled now. */ cmd[0] = KBC_ENABLE; (void) pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, NULL, 0); /* XXX - also invoke pckbd_set_xtscancode() too? */ } break; } rv = config_activate_children(self, act); return (rv); } int pckbd_set_xtscancode(pckbc_tag_t kbctag, pckbc_slot_t kbcslot, struct pckbd_internal *id) { int table = 0; if (pckbc_xt_translation(kbctag, &table)) { #ifdef DEBUG printf("pckbd: enabling of translation failed\n"); #endif #ifdef __sparc64__ /* only pckbc@ebus on sparc64 uses this */ /* * If hardware lacks translation capability, stick to the * table it is using. */ if (table != 0) { id->t_translating = 0; id->t_table = table; return 0; } #endif /* * Since the keyboard controller can not translate scan * codes to the XT set (#1), we would like to request * this exact set. However it is likely that the * controller does not support it either. * * So try scan code set #2 as well, which this driver * knows how to translate. */ table = 2; if (id != NULL) id->t_translating = 0; } else { table = 3; if (id != NULL) { id->t_translating = 1; if (id->t_table == 0) { /* * Don't bother explicitly setting into set 2, * it's the default. */ id->t_table = 2; return (0); } } } /* keep falling back until we hit a table that looks usable. */ for (; table >= 1; table--) { u_char cmd[2]; #ifdef DEBUG printf("pckbd: trying table %d\n", table); #endif cmd[0] = KBC_SETTABLE; cmd[1] = table; if (pckbc_poll_cmd(kbctag, kbcslot, cmd, 2, 0, NULL, 0)) { #ifdef DEBUG printf("pckbd: table set of %d failed\n", table); #endif if (table > 1) { cmd[0] = KBC_RESET; (void)pckbc_poll_cmd(kbctag, kbcslot, cmd, 1, 1, NULL, 1); pckbc_flush(kbctag, kbcslot); continue; } } /* * the 8042 took the table set request, however, not all that * report they can work with table 3 actually work, so ask what * table it reports it's in. */ if (table == 3) { u_char resp[1]; cmd[0] = KBC_SETTABLE; cmd[1] = 0; if (pckbc_poll_cmd(kbctag, kbcslot, cmd, 2, 1, resp, 0)) { /* * query failed, step down to table 2 to be * safe. */ #ifdef DEBUG printf("pckbd: table 3 verification failed\n"); #endif continue; } else if (resp[0] == 3) { #ifdef DEBUG printf("pckbd: settling on table 3\n"); #endif break; } #ifdef DEBUG else printf("pckbd: table \"%x\" != 3, trying 2\n", resp[0]); #endif } else { #ifdef DEBUG printf("pckbd: settling on table %d\n", table); #endif break; } } if (table == 0) return (1); if (id != NULL) id->t_table = table; return (0); } static int pckbd_is_console(pckbc_tag_t tag, pckbc_slot_t slot) { return (pckbd_consdata.t_isconsole && (tag == pckbd_consdata.t_kbctag) && (slot == pckbd_consdata.t_kbcslot)); } /* * these are both bad jokes */ int pckbdprobe(struct device *parent, void *match, void *aux) { struct cfdata *cf = match; struct pckbc_attach_args *pa = aux; u_char cmd[1], resp[2]; int res; /* * XXX There are rumours that a keyboard can be connected * to the aux port as well. For me, this didn't work. * For further experiments, allow it if explicitly * wired in the config file. */ if ((pa->pa_slot != PCKBC_KBD_SLOT) && (cf->cf_loc[PCKBCCF_SLOT] == PCKBCCF_SLOT_DEFAULT)) return (0); /* Flush any garbage. */ pckbc_flush(pa->pa_tag, pa->pa_slot); /* Reset the keyboard. */ cmd[0] = KBC_RESET; res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1); if (res != 0) { #ifdef DEBUG printf("pckbdprobe: reset error %d\n", res); #endif } else if (resp[0] != KBR_RSTDONE) { #ifdef DEBUG printf("pckbdprobe: reset response 0x%x\n", resp[0]); #endif res = EINVAL; } #if defined(__i386__) || defined(__amd64__) if (res) { /* * The 8042 emulation on Chromebooks fails the reset * command but otherwise appears to work correctly. * Try a "get ID" command to give it a second chance. */ cmd[0] = KBC_GETID; res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 2, resp, 0); if (res != 0) { #ifdef DEBUG printf("pckbdprobe: getid error %d\n", res); #endif } else if (resp[0] != 0xab || resp[1] != 0x83) { #ifdef DEBUG printf("pckbdprobe: unexpected id 0x%x/0x%x\n", resp[0], resp[1]); #endif res = EINVAL; } } #endif if (res) { /* * There is probably no keyboard connected. * Let the probe succeed if the keyboard is used * as console input - it can be connected later. */ #if defined(__i386__) || defined(__amd64__) /* * However, on legacy-free PCs, there might really * be no PS/2 connector at all; in that case, do not * even try to attach; ukbd will take over as console. */ if (res == ENXIO) { /* check cf_flags from parent */ struct cfdata *cf = parent->dv_cfdata; if (!ISSET(cf->cf_flags, PCKBCF_FORCE_KEYBOARD_PRESENT)) return 0; } #endif return (pckbd_is_console(pa->pa_tag, pa->pa_slot) ? 1 : 0); } /* * Some keyboards seem to leave a second ack byte after the reset. * This is kind of stupid, but we account for them anyway by just * flushing the buffer. */ pckbc_flush(pa->pa_tag, pa->pa_slot); return (2); } void pckbdattach(struct device *parent, struct device *self, void *aux) { struct pckbd_softc *sc = (void *)self; struct pckbc_attach_args *pa = aux; int isconsole; struct wskbddev_attach_args a; u_char cmd[1]; isconsole = pckbd_is_console(pa->pa_tag, pa->pa_slot); if (isconsole) { sc->id = &pckbd_consdata; if (sc->id->t_table == 0) pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, sc->id); /* * Some keyboards are not enabled after a reset, * so make sure it is enabled now. */ cmd[0] = KBC_ENABLE; (void) pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, NULL, 0); sc->sc_enabled = 1; } else { sc->id = malloc(sizeof(struct pckbd_internal), M_DEVBUF, M_WAITOK); pckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0); pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, sc->id); /* no interrupts until enabled */ cmd[0] = KBC_DISABLE; (void) pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, NULL, 0); sc->sc_enabled = 0; } sc->id->t_sc = sc; pckbc_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot, pckbd_input, sc, sc->sc_dev.dv_xname); a.console = isconsole; a.keymap = &pckbd_keymapdata; a.accessops = &pckbd_accessops; a.accesscookie = sc; printf("\n"); /* * Attach the wskbd, saving a handle to it. */ sc->sc_wskbddev = config_found(self, &a, wskbddevprint); } int pckbd_enable(void *v, int on) { struct pckbd_softc *sc = v; u_char cmd[1]; int res; if (on) { if (sc->sc_enabled) return (EBUSY); pckbc_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 1); cmd[0] = KBC_ENABLE; res = pckbc_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, NULL, 0); if (res) { printf("pckbd_enable: command error\n"); return (res); } res = pckbd_set_xtscancode(sc->id->t_kbctag, sc->id->t_kbcslot, sc->id); if (res) return (res); sc->sc_enabled = 1; } else { if (sc->id->t_isconsole) return (EBUSY); cmd[0] = KBC_DISABLE; res = pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, 1, 0); if (res) { printf("pckbd_disable: command error\n"); return (res); } pckbc_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0); sc->sc_enabled = 0; } return (0); } /* * Scan code set #2 translation tables */ const u_int8_t pckbd_xtbl2[] = { /* 0x00 */ 0, RAWKEY_f9, 0, RAWKEY_f5, RAWKEY_f3, RAWKEY_f1, RAWKEY_f2, RAWKEY_f12, RAWKEY_f6, /* F6 according to documentation */ RAWKEY_f10, RAWKEY_f8, RAWKEY_f6, /* F6 according to experimentation */ RAWKEY_f4, RAWKEY_Tab, RAWKEY_grave, 0, /* 0x10 */ 0, RAWKEY_Alt_L, RAWKEY_Shift_L, 0, RAWKEY_Control_L, RAWKEY_q, RAWKEY_1, 0, 0, 0, RAWKEY_z, RAWKEY_s, RAWKEY_a, RAWKEY_w, RAWKEY_2, RAWKEY_Meta_L, /* 0x20 */ 0, RAWKEY_c, RAWKEY_x, RAWKEY_d, RAWKEY_e, RAWKEY_4, RAWKEY_3, 0, RAWKEY_Meta_R, RAWKEY_space, RAWKEY_v, RAWKEY_f, RAWKEY_t, RAWKEY_r, RAWKEY_5, 0, /* 0x30 */ 0, RAWKEY_n, RAWKEY_b, RAWKEY_h, RAWKEY_g, RAWKEY_y, RAWKEY_6, 0, 0, 0, RAWKEY_m, RAWKEY_j, RAWKEY_u, RAWKEY_7, RAWKEY_8, 0, /* 0x40 */ 0, RAWKEY_comma, RAWKEY_k, RAWKEY_i, RAWKEY_o, RAWKEY_0, RAWKEY_9, 0, 0, RAWKEY_period, RAWKEY_slash, RAWKEY_l, RAWKEY_semicolon, RAWKEY_p, RAWKEY_minus, 0, /* 0x50 */ 0, 0, RAWKEY_apostrophe, 0, RAWKEY_bracketleft, RAWKEY_equal, 0, 0, RAWKEY_Caps_Lock, RAWKEY_Shift_R, RAWKEY_Return, RAWKEY_bracketright, 0, RAWKEY_backslash, 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, RAWKEY_BackSpace, 0, 0, RAWKEY_KP_End, 0, RAWKEY_KP_Left, RAWKEY_KP_Home, 0, 0, 0, /* 0x70 */ RAWKEY_KP_Insert, RAWKEY_KP_Delete, RAWKEY_KP_Down, RAWKEY_KP_Begin, RAWKEY_KP_Right, RAWKEY_KP_Up, RAWKEY_Escape, RAWKEY_Num_Lock, RAWKEY_f11, RAWKEY_KP_Add, RAWKEY_KP_Next, RAWKEY_KP_Subtract, RAWKEY_KP_Multiply, RAWKEY_KP_Prior, RAWKEY_Hold_Screen, 0, /* 0x80 */ 0, 0, 0, RAWKEY_f7, 0 /* Alt-Print Screen */ }; const u_int8_t pckbd_xtbl2_ext[] = { /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */ 0, RAWKEY_Alt_R, 0, /* E0 12, to be ignored */ 0, RAWKEY_Control_R, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RAWKEY_KP_Divide, 0, 0, 0, 0, 0, /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RAWKEY_KP_Enter, 0, 0, 0, 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, RAWKEY_End, 0, RAWKEY_Left, RAWKEY_Home, 0, 0, 0, /* 0x70 */ RAWKEY_Insert, RAWKEY_Delete, RAWKEY_Down, 0, RAWKEY_Right, RAWKEY_Up, 0, 0, 0, 0, RAWKEY_Next, 0, RAWKEY_Print_Screen, RAWKEY_Prior, 0xc6, /* Ctrl-Break */ 0 }; #ifdef __sparc64__ /* only pckbc@ebus on sparc64 uses this */ /* * Scan code set #3 translation table */ const u_int8_t pckbd_xtbl3[] = { /* 0x00 */ 0, RAWKEY_L5, /* Front */ RAWKEY_L1, /* Stop */ RAWKEY_L3, /* Props */ 0, RAWKEY_L7, /* Open */ RAWKEY_L9, /* Find */ RAWKEY_f1, RAWKEY_Escape, RAWKEY_L10, /* Cut */ 0, 0, 0, RAWKEY_Tab, RAWKEY_grave, RAWKEY_f2, /* 0x10 */ RAWKEY_Help, RAWKEY_Control_L, RAWKEY_Shift_L, 0, RAWKEY_Caps_Lock, RAWKEY_q, RAWKEY_1, RAWKEY_f3, 0, RAWKEY_Alt_L, RAWKEY_z, RAWKEY_s, RAWKEY_a, RAWKEY_w, RAWKEY_2, RAWKEY_f4, /* 0x20 */ 0, RAWKEY_c, RAWKEY_x, RAWKEY_d, RAWKEY_e, RAWKEY_4, RAWKEY_3, RAWKEY_f5, RAWKEY_L4, /* Undo */ RAWKEY_space, RAWKEY_v, RAWKEY_f, RAWKEY_t, RAWKEY_r, RAWKEY_5, RAWKEY_f6, /* 0x30 */ RAWKEY_L2, /* Again */ RAWKEY_n, RAWKEY_b, RAWKEY_h, RAWKEY_g, RAWKEY_y, RAWKEY_6, RAWKEY_f7, 0, RAWKEY_Alt_R, RAWKEY_m, RAWKEY_j, RAWKEY_u, RAWKEY_7, RAWKEY_8, RAWKEY_f8, /* 0x40 */ 0, RAWKEY_comma, RAWKEY_k, RAWKEY_i, RAWKEY_o, RAWKEY_0, RAWKEY_9, RAWKEY_f9, RAWKEY_L6, /* Copy */ RAWKEY_period, RAWKEY_slash, RAWKEY_l, RAWKEY_semicolon, RAWKEY_p, RAWKEY_minus, RAWKEY_f10, /* 0x50 */ 0, 0, RAWKEY_apostrophe, 0, RAWKEY_bracketleft, RAWKEY_equal, RAWKEY_f11, RAWKEY_Print_Screen, RAWKEY_Control_R, RAWKEY_Shift_R, RAWKEY_Return, RAWKEY_bracketright, RAWKEY_backslash, 0, RAWKEY_f12, RAWKEY_Hold_Screen, /* 0x60 */ RAWKEY_Down, RAWKEY_Left, RAWKEY_Pause, RAWKEY_Up, RAWKEY_Delete, RAWKEY_End, RAWKEY_BackSpace, RAWKEY_Insert, RAWKEY_L8, /* Paste */ RAWKEY_KP_End, RAWKEY_Right, RAWKEY_KP_Left, RAWKEY_KP_Home, RAWKEY_Next, RAWKEY_Home, RAWKEY_Prior, /* 0x70 */ RAWKEY_KP_Insert, RAWKEY_KP_Delete, RAWKEY_KP_Down, RAWKEY_KP_Begin, RAWKEY_KP_Right, RAWKEY_KP_Up, RAWKEY_Num_Lock, RAWKEY_KP_Divide, 0, RAWKEY_KP_Enter, RAWKEY_KP_Next, 0, RAWKEY_KP_Add, RAWKEY_KP_Prior, RAWKEY_KP_Multiply, 0, /* 0x80 */ 0, 0, 0, 0, RAWKEY_KP_Subtract, 0, 0, 0, 0, 0, 0, RAWKEY_Meta_L, RAWKEY_Meta_R }; #endif /* * Translate scan codes from set 2 or 3 to set 1 */ int pckbd_scancode_translate(struct pckbd_internal *id, int datain) { if (id->t_translating != 0 || id->t_table == 1) return datain; if (datain == KBR_BREAK) { id->t_releasing = 0x80; /* next keycode is a release */ return 0; /* consume scancode */ } switch (id->t_table) { case 2: /* * Convert BREAK sequence (14 77 -> 1D 45) */ if (id->t_extended1 == 2 && datain == 0x14) return 0x1d | id->t_releasing; else if (id->t_extended1 == 1 && datain == 0x77) return 0x45 | id->t_releasing; if (id->t_extended != 0) { if (datain >= sizeof pckbd_xtbl2_ext) datain = 0; else datain = pckbd_xtbl2_ext[datain]; /* xtbl2_ext already has the upper bit set */ id->t_extended = 0; } else { if (datain >= sizeof pckbd_xtbl2) datain = 0; else datain = pckbd_xtbl2[datain] & ~0x80; } break; #ifdef __sparc64__ /* only pckbc@ebus on sparc64 uses this */ case 3: if (datain >= sizeof pckbd_xtbl3) datain = 0; else datain = pckbd_xtbl3[datain] & ~0x80; break; #endif } if (datain == 0) { /* * We don't know how to translate this scan code, but * we can't silently eat it either (because there might * have been an extended byte transmitted already). * Hopefully this value will be harmless to the upper * layers. */ return 0xff; } return datain | id->t_releasing; } static int pckbd_decode(struct pckbd_internal *id, int datain, u_int *type, int *dataout) { int key; int releasing; if (datain == KBR_EXTENDED0) { id->t_extended = 0x80; return 0; } else if (datain == KBR_EXTENDED1) { id->t_extended1 = 2; return 0; } releasing = datain & 0x80; datain &= 0x7f; /* * process BREAK key sequence (EXT1 1D 45 / EXT1 9D C5): * map to (unused) code 7F */ if (id->t_extended1 == 2 && datain == 0x1d) { id->t_extended1 = 1; return 0; } else if (id->t_extended1 == 1 && datain == 0x45) { id->t_extended1 = 0; datain = 0x7f; } else id->t_extended1 = 0; if (id->t_translating != 0 || id->t_table == 1) { id->t_releasing = releasing; } else { /* id->t_releasing computed in pckbd_scancode_translate() */ } /* map extended keys to (unused) codes 128-254 */ key = datain | id->t_extended; id->t_extended = 0; if (id->t_releasing) { id->t_releasing = 0; id->t_lastchar = 0; *type = WSCONS_EVENT_KEY_UP; } else { /* Always ignore typematic keys */ if (key == id->t_lastchar) return 0; id->t_lastchar = key; *type = WSCONS_EVENT_KEY_DOWN; } *dataout = key; return 1; } void pckbd_init(struct pckbd_internal *t, pckbc_tag_t kbctag, pckbc_slot_t kbcslot, int console) { bzero(t, sizeof(struct pckbd_internal)); t->t_isconsole = console; t->t_kbctag = kbctag; t->t_kbcslot = kbcslot; } static int pckbd_led_encode(int led) { int res; res = 0; if (led & WSKBD_LED_SCROLL) res |= 0x01; if (led & WSKBD_LED_NUM) res |= 0x02; if (led & WSKBD_LED_CAPS) res |= 0x04; return(res); } void pckbd_set_leds(void *v, int leds) { struct pckbd_softc *sc = v; u_char cmd[2]; cmd[0] = KBC_MODEIND; cmd[1] = pckbd_led_encode(leds); sc->sc_ledstate = leds; (void) pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 2, 0, 0, 0); } /* * Got a console receive interrupt - * the console processor wants to give us a character. */ void pckbd_input(void *vsc, int data) { struct pckbd_softc *sc = vsc; int rc, type, key; data = pckbd_scancode_translate(sc->id, data); if (data == 0) return; rc = pckbd_decode(sc->id, data, &type, &key); #ifdef WSDISPLAY_COMPAT_RAWKBD if (sc->rawkbd) { sc->sc_rawbuf[sc->sc_rawcnt++] = (char)data; if (rc != 0 || sc->sc_rawcnt == sizeof(sc->sc_rawbuf)) { wskbd_rawinput(sc->sc_wskbddev, sc->sc_rawbuf, sc->sc_rawcnt); sc->sc_rawcnt = 0; } /* * Pass audio keys to wskbd_input anyway. */ if (rc == 0 || (key != 160 && key != 174 && key != 176)) return; } #endif if (rc != 0) wskbd_input(sc->sc_wskbddev, type, key); } int pckbd_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p) { struct pckbd_softc *sc = v; switch (cmd) { case WSKBDIO_GTYPE: *(int *)data = WSKBD_TYPE_PC_XT; return 0; case WSKBDIO_SETLEDS: { char cmd[2]; int res; cmd[0] = KBC_MODEIND; cmd[1] = pckbd_led_encode(*(int *)data); sc->sc_ledstate = *(int *)data & (WSKBD_LED_SCROLL | WSKBD_LED_NUM | WSKBD_LED_CAPS); res = pckbc_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 2, 0, 1, 0); return (res); } case WSKBDIO_GETLEDS: *(int *)data = sc->sc_ledstate; return (0); case WSKBDIO_COMPLEXBELL: #define d ((struct wskbd_bell_data *)data) /* * Keyboard can't beep directly; we have an * externally-provided global hook to do this. */ pckbd_bell(d->pitch, d->period, d->volume, 0); #undef d return (0); #ifdef WSDISPLAY_COMPAT_RAWKBD case WSKBDIO_SETMODE: sc->rawkbd = (*(int *)data == WSKBD_RAW); return (0); #endif } return -1; } void pckbd_bell(u_int pitch, u_int period, u_int volume, int poll) { if (pckbd_bell_fn != NULL) (*pckbd_bell_fn)(pckbd_bell_fn_arg, pitch, period, volume, poll); } void pckbd_hookup_bell(void (*fn)(void *, u_int, u_int, u_int, int), void *arg) { if (pckbd_bell_fn == NULL) { pckbd_bell_fn = fn; pckbd_bell_fn_arg = arg; } } int pckbd_cnattach(pckbc_tag_t kbctag) { pckbd_init(&pckbd_consdata, kbctag, PCKBC_KBD_SLOT, 1); wskbd_cnattach(&pckbd_consops, &pckbd_consdata, &pckbd_keymapdata); return (0); } void pckbd_cngetc(void *v, u_int *type, int *data) { struct pckbd_internal *t = v; int val; for (;;) { val = pckbc_poll_data(t->t_kbctag, t->t_kbcslot); if (val == -1) continue; val = pckbd_scancode_translate(t, val); if (val == 0) continue; if (pckbd_decode(t, val, type, data)) return; } } void pckbd_cnpollc(void *v, int on) { struct pckbd_internal *t = v; pckbc_set_poll(t->t_kbctag, t->t_kbcslot, on); /* * If we enter ukc or ddb before having attached the console * keyboard we need to probe its scan code set. */ if (t->t_table == 0) { char cmd[1]; pckbc_flush(t->t_kbctag, t->t_kbcslot); pckbd_set_xtscancode(t->t_kbctag, t->t_kbcslot, t); /* Just to be sure. */ cmd[0] = KBC_ENABLE; pckbc_poll_cmd(t->t_kbctag, PCKBC_KBD_SLOT, cmd, 1, 0, NULL, 0); } } void pckbd_cnbell(void *v, u_int pitch, u_int period, u_int volume) { pckbd_bell(pitch, period, volume, 1); } struct cfdriver pckbd_cd = { NULL, "pckbd", DV_DULL };