/* $NetBSD: pckbd.c,v 1.39 2024/02/09 22:08:36 andvar Exp $ */ /*- * Copyright (c) 1998, 2009 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 __KERNEL_RCSID(0, "$NetBSD: pckbd.c,v 1.39 2024/02/09 22:08:36 andvar Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "locators.h" #include "opt_pckbd_layout.h" #include "opt_pckbd_cnattach_may_fail.h" #include "opt_wsdisplay_compat.h" struct pckbd_internal { int t_isconsole; pckbport_tag_t t_kbctag; pckbport_slot_t t_kbcslot; int t_translating; int t_lastchar; int t_extended0; int t_extended1; int t_releasing; struct pckbd_softc *t_sc; /* back pointer */ }; struct pckbd_softc { device_t sc_dev; struct pckbd_internal *id; int sc_enabled; int sc_ledstate; device_t sc_wskbddev; #ifdef WSDISPLAY_COMPAT_RAWKBD int rawkbd; #endif }; int pckbdprobe(device_t, cfdata_t, void *); void pckbdattach(device_t, device_t, void *); CFATTACH_DECL_NEW(pckbd, sizeof(struct pckbd_softc), pckbdprobe, pckbdattach, NULL, NULL); int pckbd_enable(void *, int); void pckbd_set_leds(void *, int); int pckbd_ioctl(void *, u_long, void *, int, struct lwp *); const struct wskbd_accessops pckbd_accessops = { .enable = pckbd_enable, .set_leds = pckbd_set_leds, .ioctl = 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 = { .getc = pckbd_cngetc, .pollc = pckbd_cnpollc, .bell = pckbd_cnbell, }; const struct wskbd_mapdata pckbd_keymapdata = { .keydesc = pckbd_keydesctab, #ifdef PCKBD_LAYOUT .layout = PCKBD_LAYOUT, #else .layout = KB_US, #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(pckbport_tag_t, pckbport_slot_t, struct pckbd_internal *); int pckbd_init(struct pckbd_internal *, pckbport_tag_t, pckbport_slot_t, int); void pckbd_input(void *, int); struct pckbd_internal pckbd_consdata; int pckbd_set_xtscancode(pckbport_tag_t kbctag, pckbport_slot_t kbcslot, struct pckbd_internal *id) { int xt, res = 0; u_char cmd[2]; /* * Some keyboard/8042 combinations do not seem to work if the keyboard * is set to table 1; in fact, it would appear that some keyboards just * ignore the command altogether. So by default, we use the AT scan * codes and have the 8042 translate them. Unfortunately, this is * known to not work on some PS/2 machines. We try desperately to deal * with this by checking the (lack of a) translate bit in the 8042 and * attempting to set the keyboard to XT mode. If this all fails, well, * tough luck. If the PCKBC_CANT_TRANSLATE pckbc flag was set, we * enable software translation. * * XXX It would perhaps be a better choice to just use AT scan codes * and not bother with this. */ xt = pckbport_xt_translation(kbctag, kbcslot, 1); if (xt == 1) { /* The 8042 is translating for us; use AT codes. */ cmd[0] = KBC_SETTABLE; cmd[1] = 2; res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0); if (res) { u_char cmdb[1]; aprint_debug("%s: error setting scanset 2\n", __func__); /* * XXX at least one keyboard is reported to lock up * if a "set table" is attempted, thus the "reset". * XXX ignore errors, scanset 2 should be * default anyway. */ cmdb[0] = KBC_RESET; (void)pckbport_poll_cmd(kbctag, kbcslot, cmdb, 1, 1, 0, 1); pckbport_flush(kbctag, kbcslot); res = 0; } if (id != NULL) id->t_translating = 1; } else if (xt == -1) { /* Software translation required */ if (id != NULL) id->t_translating = 0; } else { /* Stupid 8042; set keyboard to XT codes. */ cmd[0] = KBC_SETTABLE; cmd[1] = 1; res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 2, 0, 0, 0); if (res) aprint_debug("%s: error setting scanset 1\n", __func__); if (id != NULL) id->t_translating = 1; } return res; } static int pckbd_is_console(pckbport_tag_t tag, pckbport_slot_t slot) { return pckbd_consdata.t_isconsole && tag == pckbd_consdata.t_kbctag && slot == pckbd_consdata.t_kbcslot; } static bool pckbd_suspend(device_t dv, const pmf_qual_t *qual) { struct pckbd_softc *sc = device_private(dv); u_char cmd[1]; int res; /* XXX duped from pckbd_enable, but we want to disable * it even if it's the console kbd */ cmd[0] = KBC_DISABLE; res = pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, 1, 0); if (res) return false; pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0); sc->sc_enabled = 0; return true; } static bool pckbd_resume(device_t dv, const pmf_qual_t *qual) { struct pckbd_softc *sc = device_private(dv); u_char cmd[1], resp[1]; int res; /* XXX jmcneill reset the keyboard */ pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot); cmd[0] = KBC_RESET; res = pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 1, resp, 1); if (res) aprint_debug("%s: reset error %d\n", __func__, res); if (resp[0] != KBR_RSTDONE) printf("%s: reset response 0x%x\n", __func__, resp[0]); pckbport_flush(sc->id->t_kbctag, sc->id->t_kbcslot); pckbd_enable(sc, 1); return true; } /* * these are three bad jokes */ static bool check_keyboard_by_id(struct pckbport_attach_args *pa) { u_char cmd[1], resp[2]; int res; cmd[0] = KBC_GETID; res = pckbport_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 2, resp, 0); if (res) { aprint_debug("%s: getid failed with %d\n", __func__, res); return false; } switch (resp[0]) { case 0xab: case 0xac: /* Regular and NCD Sun keyboards */ case 0x2b: case 0x5d: /* Trust keyboard, raw and translated */ case 0x60: case 0x47: /* NMB SGI keyboard, raw and translated */ return true; default: aprint_debug("%s: getid returned %#x\n", __func__, resp[0]); return false; } } int pckbdprobe(device_t parent, cfdata_t cf, void *aux) { struct pckbport_attach_args *pa = aux; int res; u_char cmd[1], resp[1]; /* * 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 != PCKBPORT_KBD_SLOT) && (cf->cf_loc[PCKBPORTCF_SLOT] == PCKBPORTCF_SLOT_DEFAULT)) return 0; /* Flush any garbage. */ pckbport_flush(pa->pa_tag, pa->pa_slot); /* Reset the keyboard. */ cmd[0] = KBC_RESET; res = pckbport_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 1, resp, 1); if (res) { aprint_debug("%s: reset error %d\n", __func__, res); /* * On Chromebooks reset fails but otherwise the controller * works fine. * Check keyboard IDs similar to Linux and Haiku. * FreeBSD's approach here is to skip probing if * coreboot is detected which is suboptimal as coreboot * also supports some mac models which have no PC controller */ if (check_keyboard_by_id(pa)) { if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, NULL)) return 0; return 2; } /* * There is probably no keyboard connected. * Let the probe succeed if the keyboard is used * as console input - it can be connected later. */ return pckbd_is_console(pa->pa_tag, pa->pa_slot) ? 1 : 0; } if (resp[0] != KBR_RSTDONE) { printf("%s: reset response %#x\n", __func__, resp[0]); if (check_keyboard_by_id(pa)) { if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, NULL)) return 0; return 2; } return 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. */ pckbport_flush(pa->pa_tag, pa->pa_slot); if (pckbd_set_xtscancode(pa->pa_tag, pa->pa_slot, NULL)) return 0; return 2; } void pckbdattach(device_t parent, device_t self, void *aux) { struct pckbd_softc *sc = device_private(self); struct pckbport_attach_args *pa = aux; struct wskbddev_attach_args a; int isconsole; u_char cmd[1]; aprint_naive("\n"); aprint_normal("\n"); sc->sc_dev = self; isconsole = pckbd_is_console(pa->pa_tag, pa->pa_slot); if (isconsole) { sc->id = &pckbd_consdata; /* * Some keyboards are not enabled after a reset, * so make sure it is enabled now. */ cmd[0] = KBC_ENABLE; (void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, 0, 0); sc->sc_enabled = 1; } else { sc->id = malloc(sizeof(*sc->id), M_DEVBUF, M_WAITOK); (void) pckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0); /* no interrupts until enabled */ cmd[0] = KBC_DISABLE; (void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, 0, 0); sc->sc_enabled = 0; } sc->id->t_sc = sc; pckbport_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot, pckbd_input, sc, device_xname(sc->sc_dev)); a.console = isconsole; a.keymap = &pckbd_keymapdata; a.accessops = &pckbd_accessops; a.accesscookie = sc; if (!pmf_device_register(self, pckbd_suspend, pckbd_resume)) aprint_error_dev(self, "couldn't establish power handler\n"); /* * Attach the wskbd, saving a handle to it. * XXX XXX XXX */ sc->sc_wskbddev = config_found(self, &a, wskbddevprint, CFARGS_NONE); } int pckbd_enable(void *v, int on) { struct pckbd_softc *sc = v; int res; u_char cmd[1]; if (on) { if (sc->sc_enabled) { aprint_debug("%s: bad enable\n", __func__); return EBUSY; } pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 1); cmd[0] = KBC_ENABLE; res = pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, NULL, 0); if (res) { printf("%s: command error\n", __func__); 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 = pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmd, 1, 0, 1, 0); if (res) { printf("%s: command error\n", __func__); return res; } pckbport_slot_enable(sc->id->t_kbctag, sc->id->t_kbcslot, 0); sc->sc_enabled = 0; } return 0; } const u_int8_t pckbd_xtbl[] = { /* 0x00 */ 0, 0x43, /* F9 */ 0x89, /* SunStop */ 0x3f, /* F5 */ 0x3d, /* F3 */ 0x3b, /* F1 */ 0x3c, /* F2 */ 0x58, /* F12 */ 0, 0x44, /* F10 */ 0x42, /* F8 */ 0x40, /* F6 */ 0x3e, /* F4 */ 0x0f, /* Tab */ 0x29, /* ` ~ */ 0, /* 0x10 */ 0, 0x38, /* Left Alt */ 0x2a, /* Left Shift */ 0, 0x1d, /* Left Ctrl */ 0x10, /* q */ 0x02, /* 1 ! */ 0, 0, 0, 0x2c, /* z */ 0x1f, /* s */ 0x1e, /* a */ 0x11, /* w */ 0x03, /* 2 @ */ 0, /* 0x20 */ 0, 0x2e, /* c */ 0x2d, /* x */ 0x20, /* d */ 0x12, /* e */ 0x05, /* 4 $ */ 0x04, /* 3 # */ 0, 0, 0x39, /* Space */ 0x2f, /* v */ 0x21, /* f */ 0x14, /* t */ 0x13, /* r */ 0x06, /* 5 % */ 0, /* 0x30 */ 0, 0x31, /* n */ 0x30, /* b */ 0x23, /* h */ 0x22, /* g */ 0x15, /* y */ 0x07, /* 6 ^ */ 0, 0, 0, 0x32, /* m */ 0x24, /* j */ 0x16, /* u */ 0x08, /* 7 & */ 0x09, /* 8 * */ 0, /* 0x40 */ 0, 0x33, /* , < */ 0x25, /* k */ 0x17, /* i */ 0x18, /* o */ 0x0b, /* 0 ) */ 0x0a, /* 9 ( */ 0, 0, 0x34, /* . > */ 0x35, /* / ? */ 0x26, /* l */ 0x27, /* ; : */ 0x19, /* p */ 0x0c, /* - _ */ 0, /* 0x50 */ 0, 0, 0x28, /* ' " */ 0, 0x1a, /* [ { */ 0x0d, /* = + */ 0, 0, 0x3a, /* Caps Lock */ 0x36, /* Right Shift */ 0x1c, /* Return */ 0x1b, /* ] } */ 0, 0x2b, /* \ | */ 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, 0x0e, /* Back Space */ 0, 0, 0x4f, /* KP 1 */ 0, 0x4b, /* KP 4 */ 0x47, /* KP 7 */ 0, 0, 0, /* 0x70 */ 0x52, /* KP 0 */ 0x53, /* KP . */ 0x50, /* KP 2 */ 0x4c, /* KP 5 */ 0x4d, /* KP 6 */ 0x48, /* KP 8 */ 0x01, /* Escape */ 0x45, /* Num Lock */ 0x57, /* F11 */ 0x4e, /* KP + */ 0x51, /* KP 3 */ 0x4a, /* KP - */ 0x37, /* KP * */ 0x49, /* KP 9 */ 0x46, /* Scroll Lock */ 0, /* 0x80 */ 0, 0, 0, 0x41, /* F7 (produced as an actual 8 bit code) */ 0, /* Alt-Print Screen */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 */ 0xdb, /* Left Meta */ 0x88, /* SunHelp */ 0x8a, /* SunAgain */ 0x8c, /* SunUndo */ 0x8e, /* SunCopy */ 0x90, /* SunPaste */ 0x92, /* SunCut */ 0x8b, /* SunProps */ 0x8d, /* SunFront */ 0x8f, /* SunOpen */ 0x91 /* SunFind */ }; const u_int8_t pckbd_xtbl_ext[] = { /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */ 0, 0x38, /* Right Alt */ 0, /* E0 12, to be ignored */ 0, 0x1d, /* Right Ctrl */ 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, 0xdd, /* Compose */ /* 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, 0xb5, /* KP / */ 0, 0, 0, 0, 0, /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1c, /* KP Return */ 0, 0, 0, 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x4f, /* End */ 0, 0x4b, /* Left */ 0x47, /* Home */ 0, 0, 0, /* 0x70 */ 0x52, /* Insert */ 0x53, /* Delete */ 0x50, /* Down */ 0, 0x4d, /* Right */ 0x48, /* Up */ 0, 0, 0, 0, 0x51, /* Page Down */ 0, 0x37, /* Print Screen */ 0x49, /* Page Up */ 0x46, /* Ctrl-Break */ 0 }; /* * Translate scan codes from set 2 to set 1 */ int pckbd_scancode_translate(struct pckbd_internal *id, int datain) { if (id->t_translating != 0) return datain; if (datain == KBR_BREAK) { id->t_releasing = 0x80; /* next keycode is a release */ return 0; /* consume scancode */ } /* * Handle extended sequences */ if (datain == KBR_EXTENDED0 || datain == KBR_EXTENDED1) return datain; /* * 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_extended0 != 0) { if (datain >= sizeof pckbd_xtbl_ext) datain = 0; else datain = pckbd_xtbl_ext[datain]; } else { if (datain >= sizeof pckbd_xtbl) datain = 0; else datain = pckbd_xtbl[datain]; } /* * If we are mapping in the range 128-254, then make this * an extended keycode, as table 1 codes are limited to * the range 0-127 (the top bit is used for key up/break). */ if (datain > 0x7f) { datain &= 0x7f; id->t_extended0 = 0x80; } 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 bool pckbd_decode(struct pckbd_internal *id, int datain, u_int *type, int *dataout) { int key; int releasing; if (datain == KBR_EXTENDED0) { id->t_extended0 = 0x80; return false; } else if (datain == KBR_EXTENDED1) { id->t_extended1 = 2; return false; } releasing = datain & 0x80; datain &= 0x7f; if (id->t_extended0 == 0x80) { switch (datain) { case 0x2a: case 0x36: id->t_extended0 = 0; return false; default: break; } } /* map extended keys to (unused) codes 128-254 */ key = datain | id->t_extended0; id->t_extended0 = 0; /* * process PAUSE (also break) key (EXT1 1D 45 EXT1 9D C5): * map to (unused) code 7F */ if (id->t_extended1 == 2 && (datain == 0x1d || datain == 0x9d)) { id->t_extended1 = 1; return false; } else if (id->t_extended1 == 1 && (datain == 0x45 || datain == 0xc5)) { id->t_extended1 = 0; key = 0x7f; } else if (id->t_extended1 > 0) { id->t_extended1 = 0; } if (id->t_translating != 0) { id->t_releasing = releasing; } else { /* id->t_releasing computed in pckbd_scancode_translate() */ } 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 false; id->t_lastchar = key; *type = WSCONS_EVENT_KEY_DOWN; } *dataout = key; return true; } int pckbd_init(struct pckbd_internal *t, pckbport_tag_t kbctag, pckbport_slot_t kbcslot, int console) { memset(t, 0, sizeof(struct pckbd_internal)); t->t_isconsole = console; t->t_kbctag = kbctag; t->t_kbcslot = kbcslot; return pckbd_set_xtscancode(kbctag, kbcslot, t); } 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; } static int pckbd_led_decode(int led) { int res; res = 0; if (led & 0x01) res |= WSKBD_LED_SCROLL; if (led & 0x02) res |= WSKBD_LED_NUM; if (led & 0x04) res |= WSKBD_LED_CAPS; 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 = cmd[1]; (void)pckbport_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 key; u_int type; data = pckbd_scancode_translate(sc->id, data); if (data == 0) return; #ifdef WSDISPLAY_COMPAT_RAWKBD if (sc->rawkbd) { u_char d = data; wskbd_rawinput(sc->sc_wskbddev, &d, 1); return; } #endif if (pckbd_decode(sc->id, data, &type, &key)) wskbd_input(sc->sc_wskbddev, type, key); } int pckbd_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l) { struct pckbd_softc *sc = v; u_char cmdb[2]; switch (cmd) { case WSKBDIO_GTYPE: *(int *)data = WSKBD_TYPE_PC_XT; return 0; case WSKBDIO_SETLEDS: cmdb[0] = KBC_MODEIND; cmdb[1] = pckbd_led_encode(*(int *)data); sc->sc_ledstate = cmdb[1]; return pckbport_enqueue_cmd(sc->id->t_kbctag, sc->id->t_kbcslot, cmdb, 2, 0, 1, 0); case WSKBDIO_GETLEDS: *(int *)data = pckbd_led_decode(sc->sc_ledstate); return 0; #if 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; #endif #ifdef WSDISPLAY_COMPAT_RAWKBD case WSKBDIO_SETMODE: sc->rawkbd = (*(int *)data == WSKBD_RAW); return 0; #endif } return EPASSTHROUGH; } 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_unhook_bell(void (*fn)(void *, u_int, u_int, u_int, int), void *arg) { if (pckbd_bell_fn != fn && pckbd_bell_fn_arg != arg) return; pckbd_bell_fn = NULL; pckbd_bell_fn_arg = NULL; } 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(pckbport_tag_t kbctag, int kbcslot) { int res; u_char cmd[1]; res = pckbd_init(&pckbd_consdata, kbctag, kbcslot, 1); /* We may allow the console to be attached if no keyboard is present */ #if defined(PCKBD_CNATTACH_MAY_FAIL) if (res) return res; #endif /* Just to be sure. */ cmd[0] = KBC_ENABLE; res = pckbport_poll_cmd(kbctag, kbcslot, cmd, 1, 0, 0, 0); #if defined(PCKBD_CNATTACH_MAY_FAIL) if (res) return res; #endif wskbd_cnattach(&pckbd_consops, &pckbd_consdata, &pckbd_keymapdata); return res; } /* ARGSUSED */ void pckbd_cngetc(void *v, u_int *type, int *data) { struct pckbd_internal *t = v; int val; for (;;) { val = pckbport_poll_data(t->t_kbctag, t->t_kbcslot); if (val == -1) { *type = 0; *data = 0; return; } 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; pckbport_set_poll(t->t_kbctag, t->t_kbcslot, on); } void pckbd_cnbell(void *v, u_int pitch, u_int period, u_int volume) { pckbd_bell(pitch, period, volume, 1); }