Index: uspace/srv/hid/input/Makefile =================================================================== --- uspace/srv/hid/input/Makefile (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/Makefile (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,69 @@ +# +# Copyright (c) 2005 Martin Decky +# Copyright (c) 2007 Jakub Jermar +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - 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. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. +# + +USPACE_PREFIX = ../../.. +ROOT_PATH = $(USPACE_PREFIX)/.. + +COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common +CONFIG_MAKEFILE = $(ROOT_PATH)/Makefile.config + +EXTRA_CFLAGS = -Iinclude +BINARY = input + +-include $(COMMON_MAKEFILE) +-include $(CONFIG_MAKEFILE) + +## Sources +# + +SOURCES = \ + generic/input.c \ + genarch/gsp.c \ + genarch/stroke.c \ + layout/cz.c \ + layout/us_qwerty.c \ + layout/us_dvorak.c \ + port/adb.c \ + port/chardev.c \ + port/gxemul.c \ + port/msim.c \ + port/niagara.c \ + port/ns16550.c \ + port/pl050.c \ + port/sgcn.c \ + port/ski.c \ + port/z8530.c \ + ctl/apple.c \ + ctl/gxe_fb.c \ + ctl/kbdev.c \ + ctl/pc.c \ + ctl/stty.c \ + ctl/sun.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/hid/input/ctl/apple.c =================================================================== --- uspace/srv/hid/input/ctl/apple.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/ctl/apple.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_ctl + * @ingroup input + * @{ + */ +/** + * @file + * @brief Apple ADB keyboard controller driver. + */ + +#include +#include +#include +#include +#include + +static void apple_ctl_parse_scancode(int); +static int apple_ctl_init(kbd_dev_t *); +static void apple_ctl_set_ind(unsigned); + +kbd_ctl_ops_t apple_ctl = { + .parse_scancode = apple_ctl_parse_scancode, + .init = apple_ctl_init, + .set_ind = apple_ctl_set_ind +}; + +#define KBD_KEY_RELEASE 0x80 + +static kbd_dev_t *kbd_dev; + +static int scanmap[]; + +static int apple_ctl_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + return 0; +} + +static void apple_ctl_parse_scancode(int scancode) +{ + kbd_event_type_t type; + unsigned int key; + + if (scancode < 0 || scancode >= 0x100) + return; + + if (scancode & KBD_KEY_RELEASE) { + scancode &= ~KBD_KEY_RELEASE; + type = KEY_RELEASE; + } else { + type = KEY_PRESS; + } + + key = scanmap[scancode]; + if (key != 0) + kbd_push_ev(kbd_dev, type, key); +} + +static void apple_ctl_set_ind(unsigned mods) +{ + (void) mods; +} + +static int scanmap[] = { + [0x00] = KC_A, + [0x01] = KC_S, + [0x02] = KC_D, + [0x03] = KC_F, + [0x04] = KC_H, + [0x05] = KC_G, + [0x06] = KC_Z, + [0x07] = KC_X, + [0x08] = KC_C, + [0x09] = KC_V, + [0x0a] = KC_BACKSLASH, + [0x0b] = KC_B, + [0x0c] = KC_Q, + [0x0d] = KC_W, + [0x0e] = KC_E, + [0x0f] = KC_R, + [0x10] = KC_Y, + [0x11] = KC_T, + [0x12] = KC_1, + [0x13] = KC_2, + [0x14] = KC_3, + [0x15] = KC_4, + [0x16] = KC_6, + [0x17] = KC_5, + [0x18] = KC_EQUALS, + [0x19] = KC_9, + [0x1a] = KC_7, + [0x1b] = KC_MINUS, + [0x1c] = KC_8, + [0x1d] = KC_0, + [0x1e] = KC_RBRACKET, + [0x1f] = KC_O, + [0x20] = KC_U, + [0x21] = KC_LBRACKET, + [0x22] = KC_I, + [0x23] = KC_P, + [0x24] = KC_ENTER, + [0x25] = KC_L, + [0x26] = KC_J, + [0x27] = KC_QUOTE, + [0x28] = KC_K, + [0x29] = KC_SEMICOLON, + [0x2a] = KC_BACKSLASH, + [0x2b] = KC_COMMA, + [0x2c] = KC_SLASH, + [0x2d] = KC_N, + [0x2e] = KC_M, + [0x2f] = KC_PERIOD, + [0x30] = KC_TAB, + [0x31] = KC_SPACE, + [0x32] = KC_BACKTICK, + [0x33] = KC_BACKSPACE, + [0x34] = 0, + [0x35] = KC_ESCAPE, + [0x36] = KC_LCTRL, + [0x37] = 0, + [0x38] = KC_LSHIFT, + [0x39] = KC_CAPS_LOCK, + [0x3a] = KC_LALT, + [0x3b] = KC_LEFT, + [0x3c] = KC_RIGHT, + [0x3d] = KC_DOWN, + [0x3e] = KC_UP, + [0x3f] = 0, + [0x40] = 0, + [0x41] = KC_NPERIOD, + [0x42] = 0, + [0x43] = KC_NTIMES, + [0x44] = 0, + [0x45] = KC_NPLUS, + [0x46] = 0, + [0x47] = KC_NUM_LOCK, + [0x48] = 0, + [0x49] = 0, + [0x4a] = 0, + [0x4b] = KC_NSLASH, + [0x4c] = KC_NENTER, + [0x4d] = 0, + [0x4e] = KC_NMINUS, + [0x4f] = 0, + [0x50] = 0, + [0x51] = 0, + [0x52] = KC_N0, + [0x53] = KC_N1, + [0x54] = KC_N2, + [0x55] = KC_N3, + [0x56] = KC_N4, + [0x57] = KC_N5, + [0x58] = KC_N6, + [0x59] = KC_N7, + [0x5a] = 0, + [0x5b] = KC_N8, + [0x5c] = KC_N9, + [0x5d] = 0, + [0x5e] = 0, + [0x5f] = 0, + [0x60] = KC_F5, + [0x61] = KC_F6, + [0x62] = KC_F7, + [0x63] = KC_F3, + [0x64] = KC_F8, + [0x65] = KC_F9, + [0x66] = 0, + [0x67] = KC_F11, + [0x68] = 0, + [0x69] = 0, + [0x6a] = 0, + [0x6b] = KC_SCROLL_LOCK, + [0x6c] = 0, + [0x6d] = KC_F10, + [0x6e] = 0, + [0x6f] = KC_F12, + [0x70] = 0, + [0x71] = 0, + [0x72] = KC_INSERT, + [0x73] = KC_HOME, + [0x74] = KC_PAGE_UP, + [0x75] = KC_DELETE, + [0x76] = KC_F4, + [0x77] = KC_END, + [0x78] = KC_F2, + [0x79] = KC_PAGE_DOWN, + [0x7a] = KC_F1, + [0x7b] = KC_RSHIFT, + [0x7c] = KC_RALT, + [0x7d] = KC_RCTRL, + [0x7e] = 0, + [0x7f] = 0 +}; + +/** @} + */ Index: uspace/srv/hid/input/ctl/gxe_fb.c =================================================================== --- uspace/srv/hid/input/ctl/gxe_fb.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/ctl/gxe_fb.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_ctl + * @ingroup input + * @{ + */ +/** + * @file + * @brief GXEmul framebuffer-mode keyboard controller driver. + */ + +#include +#include +#include +#include +#include +#include +#include + +static void gxe_fb_ctl_parse_scancode(int); +static int gxe_fb_ctl_init(kbd_dev_t *); +static void gxe_fb_ctl_set_ind(unsigned); + +kbd_ctl_ops_t gxe_fb_ctl = { + .parse_scancode = gxe_fb_ctl_parse_scancode, + .init = gxe_fb_ctl_init, + .set_ind = gxe_fb_ctl_set_ind +}; + +static kbd_dev_t *kbd_dev; + +/** Scancode parser */ +static gsp_t sp; + +/** Current parser state */ +static int ds; + +#include + +static int seq_defs[] = { + /* Not shifted */ + + 0, KC_BACKTICK, 0x60, GSP_END, + + 0, KC_1, 0x31, GSP_END, + 0, KC_2, 0x32, GSP_END, + 0, KC_3, 0x33, GSP_END, + 0, KC_4, 0x34, GSP_END, + 0, KC_5, 0x35, GSP_END, + 0, KC_6, 0x36, GSP_END, + 0, KC_7, 0x37, GSP_END, + 0, KC_8, 0x38, GSP_END, + 0, KC_9, 0x39, GSP_END, + 0, KC_0, 0x30, GSP_END, + + 0, KC_MINUS, 0x2d, GSP_END, + 0, KC_EQUALS, 0x3d, GSP_END, + 0, KC_BACKSPACE, 0x08, GSP_END, + + 0, KC_TAB, 0x09, GSP_END, + + 0, KC_Q, 0x71, GSP_END, + 0, KC_W, 0x77, GSP_END, + 0, KC_E, 0x65, GSP_END, + 0, KC_R, 0x72, GSP_END, + 0, KC_T, 0x74, GSP_END, + 0, KC_Y, 0x79, GSP_END, + 0, KC_U, 0x75, GSP_END, + 0, KC_I, 0x69, GSP_END, + 0, KC_O, 0x6f, GSP_END, + 0, KC_P, 0x70, GSP_END, + + 0, KC_LBRACKET, 0x5b, GSP_END, + 0, KC_RBRACKET, 0x5d, GSP_END, + + 0, KC_A, 0x61, GSP_END, + 0, KC_S, 0x73, GSP_END, + 0, KC_D, 0x64, GSP_END, + 0, KC_F, 0x66, GSP_END, + 0, KC_G, 0x67, GSP_END, + 0, KC_H, 0x68, GSP_END, + 0, KC_J, 0x6a, GSP_END, + 0, KC_K, 0x6b, GSP_END, + 0, KC_L, 0x6c, GSP_END, + + 0, KC_SEMICOLON, 0x3b, GSP_END, + 0, KC_QUOTE, 0x27, GSP_END, + 0, KC_BACKSLASH, 0x5c, GSP_END, + + 0, KC_Z, 0x7a, GSP_END, + 0, KC_X, 0x78, GSP_END, + 0, KC_C, 0x63, GSP_END, + 0, KC_V, 0x76, GSP_END, + 0, KC_B, 0x62, GSP_END, + 0, KC_N, 0x6e, GSP_END, + 0, KC_M, 0x6d, GSP_END, + + 0, KC_COMMA, 0x2c, GSP_END, + 0, KC_PERIOD, 0x2e, GSP_END, + 0, KC_SLASH, 0x2f, GSP_END, + + /* Shifted */ + + KM_SHIFT, KC_BACKTICK, 0x7e, GSP_END, + + KM_SHIFT, KC_1, 0x21, GSP_END, + KM_SHIFT, KC_2, 0x40, GSP_END, + KM_SHIFT, KC_3, 0x23, GSP_END, + KM_SHIFT, KC_4, 0x24, GSP_END, + KM_SHIFT, KC_5, 0x25, GSP_END, + KM_SHIFT, KC_6, 0x5e, GSP_END, + KM_SHIFT, KC_7, 0x26, GSP_END, + KM_SHIFT, KC_8, 0x2a, GSP_END, + KM_SHIFT, KC_9, 0x28, GSP_END, + KM_SHIFT, KC_0, 0x29, GSP_END, + + KM_SHIFT, KC_MINUS, 0x5f, GSP_END, + KM_SHIFT, KC_EQUALS, 0x2b, GSP_END, + + KM_SHIFT, KC_Q, 0x51, GSP_END, + KM_SHIFT, KC_W, 0x57, GSP_END, + KM_SHIFT, KC_E, 0x45, GSP_END, + KM_SHIFT, KC_R, 0x52, GSP_END, + KM_SHIFT, KC_T, 0x54, GSP_END, + KM_SHIFT, KC_Y, 0x59, GSP_END, + KM_SHIFT, KC_U, 0x55, GSP_END, + KM_SHIFT, KC_I, 0x49, GSP_END, + KM_SHIFT, KC_O, 0x4f, GSP_END, + KM_SHIFT, KC_P, 0x50, GSP_END, + + KM_SHIFT, KC_LBRACKET, 0x7b, GSP_END, + KM_SHIFT, KC_RBRACKET, 0x7d, GSP_END, + + KM_SHIFT, KC_A, 0x41, GSP_END, + KM_SHIFT, KC_S, 0x53, GSP_END, + KM_SHIFT, KC_D, 0x44, GSP_END, + KM_SHIFT, KC_F, 0x46, GSP_END, + KM_SHIFT, KC_G, 0x47, GSP_END, + KM_SHIFT, KC_H, 0x48, GSP_END, + KM_SHIFT, KC_J, 0x4a, GSP_END, + KM_SHIFT, KC_K, 0x4b, GSP_END, + KM_SHIFT, KC_L, 0x4c, GSP_END, + + KM_SHIFT, KC_SEMICOLON, 0x3a, GSP_END, + KM_SHIFT, KC_QUOTE, 0x22, GSP_END, + KM_SHIFT, KC_BACKSLASH, 0x7c, GSP_END, + + KM_SHIFT, KC_Z, 0x5a, GSP_END, + KM_SHIFT, KC_X, 0x58, GSP_END, + KM_SHIFT, KC_C, 0x43, GSP_END, + KM_SHIFT, KC_V, 0x56, GSP_END, + KM_SHIFT, KC_B, 0x42, GSP_END, + KM_SHIFT, KC_N, 0x4e, GSP_END, + KM_SHIFT, KC_M, 0x4d, GSP_END, + + KM_SHIFT, KC_COMMA, 0x3c, GSP_END, + KM_SHIFT, KC_PERIOD, 0x3e, GSP_END, + KM_SHIFT, KC_SLASH, 0x3f, GSP_END, + + /* ... */ + + 0, KC_SPACE, 0x20, GSP_END, + 0, KC_ENTER, 0x0a, GSP_END, + 0, KC_ENTER, 0x0d, GSP_END, + + 0, KC_ESCAPE, 0x1b, 0x1b, GSP_END, + + 0, KC_F1, 0x1b, 0x5b, 0x4f, 0x50, GSP_END, + 0, KC_F2, 0x1b, 0x5b, 0x4f, 0x51, GSP_END, + 0, KC_F3, 0x1b, 0x5b, 0x4f, 0x52, GSP_END, + 0, KC_F4, 0x1b, 0x5b, 0x4f, 0x53, GSP_END, + 0, KC_F5, 0x1b, 0x5b, 0x31, 0x35, GSP_END, + 0, KC_F6, 0x1b, 0x5b, 0x31, 0x37, GSP_END, + 0, KC_F7, 0x1b, 0x5b, 0x31, 0x38, GSP_END, + 0, KC_F8, 0x1b, 0x5b, 0x31, 0x39, GSP_END, + 0, KC_F9, 0x1b, 0x5b, 0x32, 0x38, GSP_END, + 0, KC_F10, 0x1b, 0x5b, 0x32, 0x39, GSP_END, + 0, KC_F11, 0x1b, 0x5b, 0x32, 0x33, GSP_END, + 0, KC_F12, 0x1b, 0x5b, 0x32, 0x34, GSP_END, + + 0, KC_INSERT, 0x1b, 0x5b, 0x32, 0x7e, GSP_END, + 0, KC_HOME, 0x1b, 0x5b, 0x48, GSP_END, + 0, KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END, + 0, KC_DELETE, 0x1b, 0x5b, 0x33, 0x7e, GSP_END, + 0, KC_END, 0x1b, 0x5b, 0x46, GSP_END, + 0, KC_PAGE_DOWN, 0x1b, 0x5b, 0x36, 0x7e, GSP_END, + + 0, KC_UP, 0x1b, 0x5b, 0x41, GSP_END, + 0, KC_LEFT, 0x1b, 0x5b, 0x44, GSP_END, + 0, KC_DOWN, 0x1b, 0x5b, 0x42, GSP_END, + 0, KC_RIGHT, 0x1b, 0x5b, 0x43, GSP_END, + + 0, 0 +}; + +static int gxe_fb_ctl_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + ds = 0; + + gsp_init(&sp); + return gsp_insert_defs(&sp, seq_defs); +} + +static void gxe_fb_ctl_parse_scancode(int scancode) +{ + unsigned mods, key; + + ds = gsp_step(&sp, ds, scancode, &mods, &key); + if (key != 0) { + stroke_sim(kbd_dev, mods, key); + } +} + +static void gxe_fb_ctl_set_ind(unsigned mods) +{ + (void) mods; +} + +/** + * @} + */ Index: uspace/srv/hid/input/ctl/pc.c =================================================================== --- uspace/srv/hid/input/ctl/pc.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/ctl/pc.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,285 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_ctl + * @ingroup input + * @{ + */ +/** + * @file + * @brief PC keyboard controller driver. + */ + +#include +#include +#include +#include +#include +#include + +static void pc_ctl_parse_scancode(int); +static int pc_ctl_init(kbd_dev_t *); +static void pc_ctl_set_ind(unsigned); + +kbd_ctl_ops_t pc_ctl = { + .parse_scancode = pc_ctl_parse_scancode, + .init = pc_ctl_init, + .set_ind = pc_ctl_set_ind +}; + +enum dec_state { + ds_s, + ds_e +}; + +enum special_code { + SC_ACK = 0xfa, + SC_NAK = 0xfe +}; + +enum lock_ind_bits { + LI_SCROLL = 0x01, + LI_NUM = 0x02, + LI_CAPS = 0x04 +}; + +enum kbd_command { + KBD_CMD_SET_LEDS = 0xed +}; + +static enum dec_state ds; +static kbd_dev_t *kbd_dev; + +static int scanmap_simple[] = { + + [0x29] = KC_BACKTICK, + + [0x02] = KC_1, + [0x03] = KC_2, + [0x04] = KC_3, + [0x05] = KC_4, + [0x06] = KC_5, + [0x07] = KC_6, + [0x08] = KC_7, + [0x09] = KC_8, + [0x0a] = KC_9, + [0x0b] = KC_0, + + [0x0c] = KC_MINUS, + [0x0d] = KC_EQUALS, + [0x0e] = KC_BACKSPACE, + + [0x0f] = KC_TAB, + + [0x10] = KC_Q, + [0x11] = KC_W, + [0x12] = KC_E, + [0x13] = KC_R, + [0x14] = KC_T, + [0x15] = KC_Y, + [0x16] = KC_U, + [0x17] = KC_I, + [0x18] = KC_O, + [0x19] = KC_P, + + [0x1a] = KC_LBRACKET, + [0x1b] = KC_RBRACKET, + + [0x3a] = KC_CAPS_LOCK, + + [0x1e] = KC_A, + [0x1f] = KC_S, + [0x20] = KC_D, + [0x21] = KC_F, + [0x22] = KC_G, + [0x23] = KC_H, + [0x24] = KC_J, + [0x25] = KC_K, + [0x26] = KC_L, + + [0x27] = KC_SEMICOLON, + [0x28] = KC_QUOTE, + [0x2b] = KC_BACKSLASH, + + [0x2a] = KC_LSHIFT, + + [0x2c] = KC_Z, + [0x2d] = KC_X, + [0x2e] = KC_C, + [0x2f] = KC_V, + [0x30] = KC_B, + [0x31] = KC_N, + [0x32] = KC_M, + + [0x33] = KC_COMMA, + [0x34] = KC_PERIOD, + [0x35] = KC_SLASH, + + [0x36] = KC_RSHIFT, + + [0x1d] = KC_LCTRL, + [0x38] = KC_LALT, + [0x39] = KC_SPACE, + + [0x01] = KC_ESCAPE, + + [0x3b] = KC_F1, + [0x3c] = KC_F2, + [0x3d] = KC_F3, + [0x3e] = KC_F4, + [0x3f] = KC_F5, + [0x40] = KC_F6, + [0x41] = KC_F7, + + [0x42] = KC_F8, + [0x43] = KC_F9, + [0x44] = KC_F10, + + [0x57] = KC_F11, + [0x58] = KC_F12, + + [0x46] = KC_SCROLL_LOCK, + + [0x1c] = KC_ENTER, + + [0x45] = KC_NUM_LOCK, + [0x37] = KC_NTIMES, + [0x4a] = KC_NMINUS, + [0x4e] = KC_NPLUS, + [0x47] = KC_N7, + [0x48] = KC_N8, + [0x49] = KC_N9, + [0x4b] = KC_N4, + [0x4c] = KC_N5, + [0x4d] = KC_N6, + [0x4f] = KC_N1, + [0x50] = KC_N2, + [0x51] = KC_N3, + [0x52] = KC_N0, + [0x53] = KC_NPERIOD +}; + +static int scanmap_e0[] = { + [0x38] = KC_RALT, + [0x1d] = KC_RSHIFT, + + [0x37] = KC_PRTSCR, + + [0x52] = KC_INSERT, + [0x47] = KC_HOME, + [0x49] = KC_PAGE_UP, + + [0x53] = KC_DELETE, + [0x4f] = KC_END, + [0x51] = KC_PAGE_DOWN, + + [0x48] = KC_UP, + [0x4b] = KC_LEFT, + [0x50] = KC_DOWN, + [0x4d] = KC_RIGHT, + + [0x35] = KC_NSLASH, + [0x1c] = KC_NENTER +}; + +static int pc_ctl_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + ds = ds_s; + return 0; +} + +static void pc_ctl_parse_scancode(int scancode) +{ + kbd_event_type_t type; + unsigned int key; + int *map; + size_t map_length; + + /* + * ACK/NAK are returned as response to us sending a command. + * We are not interested in them. + */ + if (scancode == SC_ACK || scancode == SC_NAK) + return; + + if (scancode == 0xe0) { + ds = ds_e; + return; + } + + switch (ds) { + case ds_s: + map = scanmap_simple; + map_length = sizeof(scanmap_simple) / sizeof(int); + break; + case ds_e: + map = scanmap_e0; + map_length = sizeof(scanmap_e0) / sizeof(int); + break; + default: + map = NULL; + map_length = 0; + } + + ds = ds_s; + + if (scancode & 0x80) { + scancode &= ~0x80; + type = KEY_RELEASE; + } else { + type = KEY_PRESS; + } + + if ((scancode < 0) || ((size_t) scancode >= map_length)) + return; + + key = map[scancode]; + if (key != 0) + kbd_push_ev(kbd_dev, type, key); +} + +static void pc_ctl_set_ind(unsigned mods) +{ + uint8_t b; + + b = 0; + if ((mods & KM_CAPS_LOCK) != 0) + b = b | LI_CAPS; + if ((mods & KM_NUM_LOCK) != 0) + b = b | LI_NUM; + if ((mods & KM_SCROLL_LOCK) != 0) + b = b | LI_SCROLL; + + (*kbd_dev->port_ops->write)(KBD_CMD_SET_LEDS); + (*kbd_dev->port_ops->write)(b); +} + +/** + * @} + */ Index: uspace/srv/hid/input/ctl/stty.c =================================================================== --- uspace/srv/hid/input/ctl/stty.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/ctl/stty.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,247 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_ctl + * @ingroup input + * @{ + */ +/** + * @file + * @brief Serial TTY-like keyboard controller driver. + */ + +#include +#include +#include +#include +#include +#include + +static void stty_ctl_parse_scancode(int); +static int stty_ctl_init(kbd_dev_t *); +static void stty_ctl_set_ind(unsigned); + +kbd_ctl_ops_t stty_ctl = { + .parse_scancode = stty_ctl_parse_scancode, + .init = stty_ctl_init, + .set_ind = stty_ctl_set_ind +}; + +static kbd_dev_t *kbd_dev; + +/** Scancode parser */ +static gsp_t sp; + +/** Current parser state */ +static int ds; + +#include + +static int seq_defs[] = { + /* Not shifted */ + + 0, KC_BACKTICK, 0x60, GSP_END, + + 0, KC_1, 0x31, GSP_END, + 0, KC_2, 0x32, GSP_END, + 0, KC_3, 0x33, GSP_END, + 0, KC_4, 0x34, GSP_END, + 0, KC_5, 0x35, GSP_END, + 0, KC_6, 0x36, GSP_END, + 0, KC_7, 0x37, GSP_END, + 0, KC_8, 0x38, GSP_END, + 0, KC_9, 0x39, GSP_END, + 0, KC_0, 0x30, GSP_END, + + 0, KC_MINUS, 0x2d, GSP_END, + 0, KC_EQUALS, 0x3d, GSP_END, + 0, KC_BACKSPACE, 0x08, GSP_END, + + 0, KC_TAB, 0x09, GSP_END, + + 0, KC_Q, 0x71, GSP_END, + 0, KC_W, 0x77, GSP_END, + 0, KC_E, 0x65, GSP_END, + 0, KC_R, 0x72, GSP_END, + 0, KC_T, 0x74, GSP_END, + 0, KC_Y, 0x79, GSP_END, + 0, KC_U, 0x75, GSP_END, + 0, KC_I, 0x69, GSP_END, + 0, KC_O, 0x6f, GSP_END, + 0, KC_P, 0x70, GSP_END, + + 0, KC_LBRACKET, 0x5b, GSP_END, + 0, KC_RBRACKET, 0x5d, GSP_END, + + 0, KC_A, 0x61, GSP_END, + 0, KC_S, 0x73, GSP_END, + 0, KC_D, 0x64, GSP_END, + 0, KC_F, 0x66, GSP_END, + 0, KC_G, 0x67, GSP_END, + 0, KC_H, 0x68, GSP_END, + 0, KC_J, 0x6a, GSP_END, + 0, KC_K, 0x6b, GSP_END, + 0, KC_L, 0x6c, GSP_END, + + 0, KC_SEMICOLON, 0x3b, GSP_END, + 0, KC_QUOTE, 0x27, GSP_END, + 0, KC_BACKSLASH, 0x5c, GSP_END, + + 0, KC_Z, 0x7a, GSP_END, + 0, KC_X, 0x78, GSP_END, + 0, KC_C, 0x63, GSP_END, + 0, KC_V, 0x76, GSP_END, + 0, KC_B, 0x62, GSP_END, + 0, KC_N, 0x6e, GSP_END, + 0, KC_M, 0x6d, GSP_END, + + 0, KC_COMMA, 0x2c, GSP_END, + 0, KC_PERIOD, 0x2e, GSP_END, + 0, KC_SLASH, 0x2f, GSP_END, + + /* Shifted */ + + KM_SHIFT, KC_BACKTICK, 0x7e, GSP_END, + + KM_SHIFT, KC_1, 0x21, GSP_END, + KM_SHIFT, KC_2, 0x40, GSP_END, + KM_SHIFT, KC_3, 0x23, GSP_END, + KM_SHIFT, KC_4, 0x24, GSP_END, + KM_SHIFT, KC_5, 0x25, GSP_END, + KM_SHIFT, KC_6, 0x5e, GSP_END, + KM_SHIFT, KC_7, 0x26, GSP_END, + KM_SHIFT, KC_8, 0x2a, GSP_END, + KM_SHIFT, KC_9, 0x28, GSP_END, + KM_SHIFT, KC_0, 0x29, GSP_END, + + KM_SHIFT, KC_MINUS, 0x5f, GSP_END, + KM_SHIFT, KC_EQUALS, 0x2b, GSP_END, + + KM_SHIFT, KC_Q, 0x51, GSP_END, + KM_SHIFT, KC_W, 0x57, GSP_END, + KM_SHIFT, KC_E, 0x45, GSP_END, + KM_SHIFT, KC_R, 0x52, GSP_END, + KM_SHIFT, KC_T, 0x54, GSP_END, + KM_SHIFT, KC_Y, 0x59, GSP_END, + KM_SHIFT, KC_U, 0x55, GSP_END, + KM_SHIFT, KC_I, 0x49, GSP_END, + KM_SHIFT, KC_O, 0x4f, GSP_END, + KM_SHIFT, KC_P, 0x50, GSP_END, + + KM_SHIFT, KC_LBRACKET, 0x7b, GSP_END, + KM_SHIFT, KC_RBRACKET, 0x7d, GSP_END, + + KM_SHIFT, KC_A, 0x41, GSP_END, + KM_SHIFT, KC_S, 0x53, GSP_END, + KM_SHIFT, KC_D, 0x44, GSP_END, + KM_SHIFT, KC_F, 0x46, GSP_END, + KM_SHIFT, KC_G, 0x47, GSP_END, + KM_SHIFT, KC_H, 0x48, GSP_END, + KM_SHIFT, KC_J, 0x4a, GSP_END, + KM_SHIFT, KC_K, 0x4b, GSP_END, + KM_SHIFT, KC_L, 0x4c, GSP_END, + + KM_SHIFT, KC_SEMICOLON, 0x3a, GSP_END, + KM_SHIFT, KC_QUOTE, 0x22, GSP_END, + KM_SHIFT, KC_BACKSLASH, 0x7c, GSP_END, + + KM_SHIFT, KC_Z, 0x5a, GSP_END, + KM_SHIFT, KC_X, 0x58, GSP_END, + KM_SHIFT, KC_C, 0x43, GSP_END, + KM_SHIFT, KC_V, 0x56, GSP_END, + KM_SHIFT, KC_B, 0x42, GSP_END, + KM_SHIFT, KC_N, 0x4e, GSP_END, + KM_SHIFT, KC_M, 0x4d, GSP_END, + + KM_SHIFT, KC_COMMA, 0x3c, GSP_END, + KM_SHIFT, KC_PERIOD, 0x3e, GSP_END, + KM_SHIFT, KC_SLASH, 0x3f, GSP_END, + + /* ... */ + + 0, KC_SPACE, 0x20, GSP_END, + 0, KC_ENTER, 0x0a, GSP_END, + 0, KC_ENTER, 0x0d, GSP_END, + + 0, KC_ESCAPE, 0x1b, 0x1b, GSP_END, + + 0, KC_F1, 0x1b, 0x4f, 0x50, GSP_END, + 0, KC_F2, 0x1b, 0x4f, 0x51, GSP_END, + 0, KC_F3, 0x1b, 0x4f, 0x52, GSP_END, + 0, KC_F4, 0x1b, 0x4f, 0x53, GSP_END, + 0, KC_F5, 0x1b, 0x5b, 0x31, 0x35, 0x7e, GSP_END, + 0, KC_F6, 0x1b, 0x5b, 0x31, 0x37, 0x7e, GSP_END, + 0, KC_F7, 0x1b, 0x5b, 0x31, 0x38, 0x7e, GSP_END, + 0, KC_F8, 0x1b, 0x5b, 0x31, 0x39, 0x7e, GSP_END, + 0, KC_F9, 0x1b, 0x5b, 0x32, 0x30, 0x7e, GSP_END, + 0, KC_F10, 0x1b, 0x5b, 0x32, 0x31, 0x7e, GSP_END, + 0, KC_F11, 0x1b, 0x5b, 0x32, 0x33, 0x7e, GSP_END, + 0, KC_F12, 0x1b, 0x5b, 0x32, 0x34, 0x7e, GSP_END, + + 0, KC_INSERT, 0x1b, 0x5b, 0x32, 0x7e, GSP_END, + 0, KC_HOME, 0x1b, 0x5b, 0x48, GSP_END, + 0, KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END, + 0, KC_DELETE, 0x1b, 0x5b, 0x33, 0x7e, GSP_END, + 0, KC_END, 0x1b, 0x5b, 0x46, GSP_END, + 0, KC_PAGE_DOWN, 0x1b, 0x5b, 0x36, 0x7e, GSP_END, + + 0, KC_UP, 0x1b, 0x5b, 0x41, GSP_END, + 0, KC_LEFT, 0x1b, 0x5b, 0x44, GSP_END, + 0, KC_DOWN, 0x1b, 0x5b, 0x42, GSP_END, + 0, KC_RIGHT, 0x1b, 0x5b, 0x43, GSP_END, + + 0, 0 +}; + +static int stty_ctl_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + ds = 0; + + gsp_init(&sp); + return gsp_insert_defs(&sp, seq_defs); +} + +static void stty_ctl_parse_scancode(int scancode) +{ + unsigned mods, key; + + ds = gsp_step(&sp, ds, scancode, &mods, &key); + if (key != 0) { + stroke_sim(kbd_dev, mods, key); + } +} + +static void stty_ctl_set_ind(unsigned mods) +{ + (void) mods; +} + +/** + * @} + */ Index: uspace/srv/hid/input/ctl/sun.c =================================================================== --- uspace/srv/hid/input/ctl/sun.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/ctl/sun.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,229 @@ +/* + * Copyright (c) 2006 Jakub Jermar + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_ctl + * @ingroup input + * @{ + */ +/** + * @file + * @brief Sun keyboard controller driver. + */ + +#include +#include +#include +#include +#include + +static void sun_ctl_parse_scancode(int); +static int sun_ctl_init(kbd_dev_t *); +static void sun_ctl_set_ind(unsigned); + +kbd_ctl_ops_t sun_ctl = { + .parse_scancode = sun_ctl_parse_scancode, + .init = sun_ctl_init, + .set_ind = sun_ctl_set_ind +}; + +static kbd_dev_t *kbd_dev; + +#define KBD_KEY_RELEASE 0x80 +#define KBD_ALL_KEYS_UP 0x7f + +static int scanmap_simple[]; + +static int sun_ctl_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + return 0; +} + +static void sun_ctl_parse_scancode(int scancode) +{ + kbd_event_type_t type; + unsigned int key; + + if (scancode < 0 || scancode >= 0x100) + return; + + if (scancode == KBD_ALL_KEYS_UP) + return; + + if (scancode & KBD_KEY_RELEASE) { + scancode &= ~KBD_KEY_RELEASE; + type = KEY_RELEASE; + } else { + type = KEY_PRESS; + } + + key = scanmap_simple[scancode]; + if (key != 0) + kbd_push_ev(kbd_dev, type, key); +} + +static void sun_ctl_set_ind(unsigned mods) +{ + (void) mods; +} + +/** Primary meaning of scancodes. */ +static int scanmap_simple[] = { + [0x00] = 0, + [0x01] = 0, + [0x02] = 0, + [0x03] = 0, + [0x04] = 0, + [0x05] = KC_F1, + [0x06] = KC_F2, + [0x07] = KC_F10, + [0x08] = KC_F3, + [0x09] = KC_F11, + [0x0a] = KC_F4, + [0x0b] = KC_F12, + [0x0c] = KC_F5, + [0x0d] = KC_RALT, + [0x0e] = KC_F6, + [0x0f] = 0, + [0x10] = KC_F7, + [0x11] = KC_F8, + [0x12] = KC_F9, + [0x13] = KC_LALT, + [0x14] = KC_UP, + [0x15] = KC_PAUSE, + [0x16] = 0, + [0x17] = KC_SCROLL_LOCK, + [0x18] = KC_LEFT, + [0x19] = 0, + [0x1a] = 0, + [0x1b] = KC_DOWN, + [0x1c] = KC_RIGHT, + [0x1d] = KC_ESCAPE, + [0x1e] = KC_1, + [0x1f] = KC_2, + [0x20] = KC_3, + [0x21] = KC_4, + [0x22] = KC_5, + [0x23] = KC_6, + [0x24] = KC_7, + [0x25] = KC_8, + [0x26] = KC_9, + [0x27] = KC_0, + [0x28] = KC_MINUS, + [0x29] = KC_EQUALS, + [0x2a] = KC_BACKTICK, + [0x2b] = KC_BACKSPACE, + [0x2c] = KC_INSERT, + [0x2d] = 0, + [0x2e] = KC_NSLASH, + [0x2f] = KC_NTIMES, + [0x30] = 0, + [0x31] = 0, + [0x32] = KC_NPERIOD, + [0x33] = 0, + [0x34] = KC_HOME, + [0x35] = KC_TAB, + [0x36] = KC_Q, + [0x37] = KC_W, + [0x38] = KC_E, + [0x39] = KC_R, + [0x3a] = KC_T, + [0x3b] = KC_Y, + [0x3c] = KC_U, + [0x3d] = KC_I, + [0x3e] = KC_O, + [0x3f] = KC_P, + [0x40] = KC_LBRACKET, + [0x41] = KC_RBRACKET, + [0x42] = KC_DELETE, + [0x43] = 0, + [0x44] = KC_N7, + [0x45] = KC_N8, + [0x46] = KC_N9, + [0x47] = KC_NMINUS, + [0x48] = 0, + [0x49] = 0, + [0x4a] = KC_END, + [0x4b] = 0, + [0x4c] = KC_LCTRL, + [0x4d] = KC_A, + [0x4e] = KC_S, + [0x4f] = KC_D, + [0x50] = KC_F, + [0x51] = KC_G, + [0x52] = KC_H, + [0x53] = KC_J, + [0x54] = KC_K, + [0x55] = KC_L, + [0x56] = KC_SEMICOLON, + [0x57] = KC_QUOTE, + [0x58] = KC_BACKSLASH, + [0x59] = KC_ENTER, + [0x5a] = KC_NENTER, + [0x5b] = KC_N4, + [0x5c] = KC_N5, + [0x5d] = KC_N6, + [0x5e] = KC_N0, + [0x5f] = 0, + [0x60] = KC_PAGE_UP, + [0x61] = 0, + [0x62] = KC_NUM_LOCK, + [0x63] = KC_LSHIFT, + [0x64] = KC_Z, + [0x65] = KC_X, + [0x66] = KC_C, + [0x67] = KC_V, + [0x68] = KC_B, + [0x69] = KC_N, + [0x6a] = KC_M, + [0x6b] = KC_COMMA, + [0x6c] = KC_PERIOD, + [0x6d] = KC_SLASH, + [0x6e] = KC_RSHIFT, + [0x6f] = 0, + [0x70] = KC_N1, + [0x71] = KC_N2, + [0x72] = KC_N3, + [0x73] = 0, + [0x74] = 0, + [0x75] = 0, + [0x76] = 0, + [0x77] = KC_CAPS_LOCK, + [0x78] = 0, + [0x79] = KC_SPACE, + [0x7a] = 0, + [0x7b] = KC_PAGE_DOWN, + [0x7c] = 0, + [0x7d] = KC_NPLUS, + [0x7e] = 0, + [0x7f] = 0 +}; + +/** @} + */ Index: uspace/srv/hid/input/genarch/gsp.c =================================================================== --- uspace/srv/hid/input/genarch/gsp.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/genarch/gsp.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,289 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** + * @addtogroup kbdgen generic + * @ingroup input + * @{ + */ +/** @file + * @brief Generic scancode parser. + * + * The scancode parser is a simple finite state machine. It is described + * using sequences of input symbols (scancodes) and the corresponding output + * value (mods, key pair). When the parser recognizes a sequence, + * it outputs the value and restarts. If a transition is undefined, + * the parser restarts, too. + * + * Apart from precise values, GSP_DEFAULT allows to catch general cases. + * I.e. if we knew that after 0x1b 0x4f there always follow two more + * scancodes, we can define (0x1b, 0x4f, GSP_DEFAULT, GSP_DEFAULT, GSP_END) + * with null output. This will force the parser to read the entire sequence, + * not leaving garbage on the input if it does not recognize the specific + * sequence. + */ + +#include +#include +#include +#include + +#define TRANS_TABLE_CHAINS 256 + +/* + * Hash table operations for the transition function. + */ + +static hash_index_t trans_op_hash(unsigned long key[]); +static int trans_op_compare(unsigned long key[], hash_count_t keys, + link_t *item); +static void trans_op_remove_callback(link_t *item); + +static hash_table_operations_t trans_ops = { + .hash = trans_op_hash, + .compare = trans_op_compare, + .remove_callback = trans_op_remove_callback +}; + +static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input); +static void trans_insert(gsp_t *p, gsp_trans_t *t); +static gsp_trans_t *trans_new(void); + +/** Initialise scancode parser. */ +void gsp_init(gsp_t *p) +{ + p->states = 1; + hash_table_create(&p->trans, TRANS_TABLE_CHAINS, 2, &trans_ops); +} + +/** Insert a series of definitions into the parser. + * + * @param p The parser. + * @param defs Definition list. Each definition starts with two output values + * (mods, key) and continues with a sequence of input values + * terminated with GSP_END. The definition list is terminated + * with two zeroes (0, 0) for output values. + */ +int gsp_insert_defs(gsp_t *p, const int *defs) +{ + unsigned mods, key; + const int *dp; + int rc; + + dp = defs; + + while (1) { + /* Read the output values. */ + mods = *dp++; + key = *dp++; + if (key == 0) break; + + /* Insert one sequence. */ + rc = gsp_insert_seq(p, dp, mods, key); + if (rc != 0) + return rc; + + /* Skip to the next definition. */ + while (*dp != GSP_END) + ++dp; + ++dp; + } + + return 0; +} + +/** Insert one sequence into the parser. + * + * @param p The parser. + * @param seq Sequence of input values terminated with GSP_END. + * @param mods Corresponsing output value. + * @param key Corresponsing output value. + */ +int gsp_insert_seq(gsp_t *p, const int *seq, unsigned mods, unsigned key) +{ + int state; + gsp_trans_t *t; + + state = 0; + t = NULL; + + /* Input sequence must be non-empty. */ + if (*seq == GSP_END) + return -1; + + while (*(seq + 1) != GSP_END) { + t = trans_lookup(p, state, *seq); + if (t == NULL) { + /* Create new state. */ + t = trans_new(); + t->old_state = state; + t->input = *seq; + t->new_state = p->states++; + + t->out_mods = 0; + t->out_key = 0; + + trans_insert(p, t); + } + state = t->new_state; + ++seq; + } + + /* Process the last transition. */ + t = trans_lookup(p, state, *seq); + if (t != NULL) { + exit(1); + return -1; /* Conflicting definition. */ + } + + t = trans_new(); + t->old_state = state; + t->input = *seq; + t->new_state = 0; + + t->out_mods = mods; + t->out_key = key; + + trans_insert(p, t); + + return 0; +} + +/** Compute one parser step. + * + * Computes the next state and output values for a given state and input. + * This handles everything including restarts and default branches. + * + * @param p The parser. + * @param state Old state. + * @param input Input symbol (scancode). + * @param mods Output value (modifier). + * @param key Output value (key). + * @return New state. + */ +int gsp_step(gsp_t *p, int state, int input, unsigned *mods, unsigned *key) +{ + gsp_trans_t *t; + + t = trans_lookup(p, state, input); + if (t == NULL) { + t = trans_lookup(p, state, GSP_DEFAULT); + } + + if (t == NULL) { + printf("gsp_step: not found\n"); + *mods = 0; + *key = 0; + return 0; + } + + *mods = t->out_mods; + *key = t->out_key; + return t->new_state; +} + +/** Transition function lookup. + * + * Returns the value of the transition function for the given state + * and input. Note that the transition must be specified precisely, + * to obtain the default branch use input = GSP_DEFAULT. + * + * @param p Parser. + * @param state Current state. + * @param input Input value. + * @return The transition or @c NULL if not defined. + */ +static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input) +{ + link_t *item; + unsigned long key[2]; + + key[0] = state; + key[1] = input; + + item = hash_table_find(&p->trans, key); + if (item == NULL) return NULL; + + return hash_table_get_instance(item, gsp_trans_t, link); +} + +/** Define a new transition. + * + * @param p The parser. + * @param t Transition with all fields defined. + */ +static void trans_insert(gsp_t *p, gsp_trans_t *t) +{ + unsigned long key[2]; + + key[0] = t->old_state; + key[1] = t->input; + + hash_table_insert(&p->trans, key, &t->link); +} + +/** Allocate transition structure. */ +static gsp_trans_t *trans_new(void) +{ + gsp_trans_t *t; + + t = malloc(sizeof(gsp_trans_t)); + if (t == NULL) { + printf("Memory allocation failed.\n"); + exit(1); + } + + return t; +} + +/* + * Transition function hash table operations. + */ + +static hash_index_t trans_op_hash(unsigned long key[]) +{ + return (key[0] * 17 + key[1]) % TRANS_TABLE_CHAINS; +} + +static int trans_op_compare(unsigned long key[], hash_count_t keys, + link_t *item) +{ + gsp_trans_t *t; + + t = hash_table_get_instance(item, gsp_trans_t, link); + return ((key[0] == (unsigned long) t->old_state) + && (key[1] == (unsigned long) t->input)); +} + +static void trans_op_remove_callback(link_t *item) +{ +} + +/** + * @} + */ Index: uspace/srv/hid/input/genarch/stroke.c =================================================================== --- uspace/srv/hid/input/genarch/stroke.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/genarch/stroke.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup input + * @{ + */ +/** + * @file + * @brief Stroke simulator. + * + * When simulating a keyboard using a serial TTY we need to convert the + * recognized strokes (such as Shift-A) to sequences of key presses and + * releases (such as 'press Shift, press A, release A, release Shift'). + * + */ + +#include +#include +#include +#include + +/** Correspondence between modifers and the modifier keycodes. */ +static unsigned int mods_keys[][2] = { + { KM_LSHIFT, KC_LSHIFT }, + { 0, 0 } +}; + +/** Simulate keystroke using sequences of key presses and releases. */ +void stroke_sim(kbd_dev_t *kdev, unsigned mod, unsigned key) +{ + int i; + + /* Simulate modifier presses. */ + i = 0; + while (mods_keys[i][0] != 0) { + if (mod & mods_keys[i][0]) { + kbd_push_ev(kdev, KEY_PRESS, mods_keys[i][1]); + } + ++i; + } + + /* Simulate key press and release. */ + if (key != 0) { + kbd_push_ev(kdev, KEY_PRESS, key); + kbd_push_ev(kdev, KEY_RELEASE, key); + } + + /* Simulate modifier releases. */ + i = 0; + while (mods_keys[i][0] != 0) { + if (mod & mods_keys[i][0]) { + kbd_push_ev(kdev, KEY_RELEASE, mods_keys[i][1]); + } + ++i; + } +} + +/** + * @} + */ Index: uspace/srv/hid/input/generic/input.c =================================================================== --- uspace/srv/hid/input/generic/input.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/generic/input.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2006 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** + * @addtogroup inputgen generic + * @brief HelenOS input server. + * @ingroup input + * @{ + */ +/** @file + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// FIXME: remove this header +#include + +/* In microseconds */ +#define DISCOVERY_POLL_INTERVAL (10*1000*1000) + +static void kbd_devs_yield(void); +static void kbd_devs_reclaim(void); + +int client_phone = -1; + +/** Currently active modifiers. */ +static unsigned mods = KM_NUM_LOCK; + +/** Currently pressed lock keys. We track these to tackle autorepeat. */ +static unsigned lock_keys; + +/** List of keyboard devices */ +static link_t kbd_devs; + +bool irc_service = false; +int irc_phone = -1; + +#define NUM_LAYOUTS 3 + +static layout_op_t *layout[NUM_LAYOUTS] = { + &us_qwerty_op, + &us_dvorak_op, + &cz_op +}; + +static int active_layout = 0; + +void kbd_push_scancode(kbd_dev_t *kdev, int scancode) +{ +/* printf("scancode: 0x%x\n", scancode);*/ + (*kdev->ctl_ops->parse_scancode)(scancode); +} + +void kbd_push_ev(kbd_dev_t *kdev, int type, unsigned int key) +{ + kbd_event_t ev; + unsigned mod_mask; + + switch (key) { + case KC_LCTRL: mod_mask = KM_LCTRL; break; + case KC_RCTRL: mod_mask = KM_RCTRL; break; + case KC_LSHIFT: mod_mask = KM_LSHIFT; break; + case KC_RSHIFT: mod_mask = KM_RSHIFT; break; + case KC_LALT: mod_mask = KM_LALT; break; + case KC_RALT: mod_mask = KM_RALT; break; + default: mod_mask = 0; break; + } + + if (mod_mask != 0) { + if (type == KEY_PRESS) + mods = mods | mod_mask; + else + mods = mods & ~mod_mask; + } + + switch (key) { + case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break; + case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break; + case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break; + default: mod_mask = 0; break; + } + + if (mod_mask != 0) { + if (type == KEY_PRESS) { + /* + * Only change lock state on transition from released + * to pressed. This prevents autorepeat from messing + * up the lock state. + */ + mods = mods ^ (mod_mask & ~lock_keys); + lock_keys = lock_keys | mod_mask; + + /* Update keyboard lock indicator lights. */ + (*kdev->ctl_ops->set_ind)(mods); + } else { + lock_keys = lock_keys & ~mod_mask; + } + } +/* + printf("type: %d\n", type); + printf("mods: 0x%x\n", mods); + printf("keycode: %u\n", key); +*/ + if (type == KEY_PRESS && (mods & KM_LCTRL) && + key == KC_F1) { + active_layout = 0; + layout[active_layout]->reset(); + return; + } + + if (type == KEY_PRESS && (mods & KM_LCTRL) && + key == KC_F2) { + active_layout = 1; + layout[active_layout]->reset(); + return; + } + + if (type == KEY_PRESS && (mods & KM_LCTRL) && + key == KC_F3) { + active_layout = 2; + layout[active_layout]->reset(); + return; + } + + ev.type = type; + ev.key = key; + ev.mods = mods; + + ev.c = layout[active_layout]->parse_ev(&ev); + + async_obsolete_msg_4(client_phone, INPUT_EVENT, ev.type, ev.key, ev.mods, ev.c); +} + +static void client_connection(ipc_callid_t iid, ipc_call_t *icall) +{ + ipc_callid_t callid; + ipc_call_t call; + int retval; + + async_answer_0(iid, EOK); + + while (true) { + callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) { + if (client_phone != -1) { + async_obsolete_hangup(client_phone); + client_phone = -1; + } + + async_answer_0(callid, EOK); + return; + } + + switch (IPC_GET_IMETHOD(call)) { + case IPC_M_CONNECT_TO_ME: + if (client_phone != -1) { + retval = ELIMIT; + break; + } + client_phone = IPC_GET_ARG5(call); + retval = 0; + break; + case INPUT_YIELD: + kbd_devs_yield(); + retval = 0; + break; + case INPUT_RECLAIM: + kbd_devs_reclaim(); + retval = 0; + break; + default: + retval = EINVAL; + } + async_answer_0(callid, retval); + } +} + +/** Add new legacy keyboard device. */ +static void kbd_add_dev(kbd_port_ops_t *port, kbd_ctl_ops_t *ctl) +{ + kbd_dev_t *kdev; + + kdev = malloc(sizeof(kbd_dev_t)); + if (kdev == NULL) { + printf(NAME ": Failed adding keyboard device. Out of memory.\n"); + return; + } + + link_initialize(&kdev->kbd_devs); + kdev->dev_path = NULL; + kdev->port_ops = port; + kdev->ctl_ops = ctl; + + /* Initialize port driver. */ + if ((*kdev->port_ops->init)(kdev) != 0) + goto fail; + + /* Initialize controller driver. */ + if ((*kdev->ctl_ops->init)(kdev) != 0) { + /* XXX Uninit port */ + goto fail; + } + + list_append(&kdev->kbd_devs, &kbd_devs); + return; +fail: + free(kdev); +} + +/** Add new kbdev device. + * + * @param dev_path Filesystem path to the device (/dev/class/...) + */ +static int kbd_add_kbdev(const char *dev_path) +{ + kbd_dev_t *kdev; + + kdev = malloc(sizeof(kbd_dev_t)); + if (kdev == NULL) { + printf(NAME ": Failed adding keyboard device. Out of memory.\n"); + return -1; + } + + link_initialize(&kdev->kbd_devs); + kdev->dev_path = dev_path; + kdev->port_ops = NULL; + kdev->ctl_ops = &kbdev_ctl; + + /* Initialize controller driver. */ + if ((*kdev->ctl_ops->init)(kdev) != 0) { + goto fail; + } + + list_append(&kdev->kbd_devs, &kbd_devs); + return EOK; +fail: + free(kdev); + return -1; +} + +/** Add legacy drivers/devices. */ +static void kbd_add_legacy_devs(void) +{ + /* + * Need to add these drivers based on config unless we can probe + * them automatically. + */ +#if defined(UARCH_amd64) + kbd_add_dev(&chardev_port, &pc_ctl); +#endif +#if defined(UARCH_arm32) && defined(MACHINE_gta02) + kbd_add_dev(&chardev_port, &stty_ctl); +#endif +#if defined(UARCH_arm32) && defined(MACHINE_testarm) && defined(CONFIG_FB) + kbd_add_dev(&gxemul_port, &gxe_fb_ctl); +#endif +#if defined(UARCH_arm32) && defined(MACHINE_testarm) && !defined(CONFIG_FB) + kbd_add_dev(&gxemul_port, &stty_ctl); +#endif +#if defined(UARCH_arm32) && defined(MACHINE_integratorcp) + kbd_add_dev(&pl050_port, &pc_ctl); +#endif +#if defined(UARCH_ia32) + kbd_add_dev(&chardev_port, &pc_ctl); +#endif +#if defined(MACHINE_i460GX) + kbd_add_dev(&chardev_port, &pc_ctl); +#endif +#if defined(MACHINE_ski) + kbd_add_dev(&ski_port, &stty_ctl); +#endif +#if defined(MACHINE_msim) + kbd_add_dev(&msim_port, &pc_ctl); +#endif +#if (defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul)) && defined(CONFIG_FB) + kbd_add_dev(&gxemul_port, &gxe_fb_ctl); +#endif +#if defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul) && !defined(CONFIG_FB) + kbd_add_dev(&gxemul_port, &stty_ctl); +#endif +#if defined(UARCH_ppc32) + kbd_add_dev(&adb_port, &apple_ctl); +#endif +#if defined(UARCH_sparc64) && defined(PROCESSOR_sun4v) + kbd_add_dev(&niagara_port, &stty_ctl); +#endif +#if defined(UARCH_sparc64) && defined(MACHINE_serengeti) + kbd_add_dev(&sgcn_port, &stty_ctl); +#endif +#if defined(UARCH_sparc64) && defined(MACHINE_generic) + kbd_add_dev(&z8530_port, &sun_ctl); + kbd_add_dev(&ns16550_port, &sun_ctl); +#endif + /* Silence warning on abs32le about kbd_add_dev() being unused */ + (void) kbd_add_dev; +} + +static void kbd_devs_yield(void) +{ + /* For each keyboard device */ + list_foreach(kbd_devs, kdev_link) { + kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t, + kbd_devs); + + /* Yield port */ + if (kdev->port_ops != NULL) + (*kdev->port_ops->yield)(); + } +} + +static void kbd_devs_reclaim(void) +{ + /* For each keyboard device */ + list_foreach(kbd_devs, kdev_link) { + kbd_dev_t *kdev = list_get_instance(kdev_link, kbd_dev_t, + kbd_devs); + + /* Reclaim port */ + if (kdev->port_ops != NULL) + (*kdev->port_ops->reclaim)(); + } +} + +/** Periodically check for new kbdev devices in /dev/class/keyboard. + * + * @param arg Ignored + */ +static int dev_discovery_fibril(void *arg) +{ + char *dev_path; + size_t id = 1; + int rc; + + while (true) { + async_usleep(DISCOVERY_POLL_INTERVAL); + + rc = asprintf(&dev_path, "/dev/class/keyboard\\%zu", id); + if (rc < 0) + continue; + + if (kbd_add_kbdev(dev_path) == EOK) { + printf(NAME ": Connected kbdev device '%s'\n", + dev_path); + + /* XXX Handle device removal */ + ++id; + } + + free(dev_path); + } + + return EOK; +} + +/** Start a fibril for discovering new devices. */ +static void kbd_start_dev_discovery(void) +{ + fid_t fid; + + fid = fibril_create(dev_discovery_fibril, NULL); + if (!fid) { + printf(NAME ": Failed to create device discovery fibril.\n"); + return; + } + + fibril_add_ready(fid); +} + +int main(int argc, char **argv) +{ + printf("%s: HelenOS input service\n", NAME); + + sysarg_t fhc; + sysarg_t obio; + + list_initialize(&kbd_devs); + + if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc)) + || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))) + irc_service = true; + + if (irc_service) { + while (irc_phone < 0) + irc_phone = service_obsolete_connect_blocking(SERVICE_IRC, 0, 0); + } + + /* Add legacy devices. */ + kbd_add_legacy_devs(); + + /* Initialize (reset) layout. */ + layout[active_layout]->reset(); + + /* Register driver */ + int rc = devmap_driver_register(NAME, client_connection); + if (rc < 0) { + printf("%s: Unable to register driver (%d)\n", NAME, rc); + return -1; + } + + char kbd[DEVMAP_NAME_MAXLEN + 1]; + snprintf(kbd, DEVMAP_NAME_MAXLEN, "%s/%s", NAMESPACE, NAME); + + devmap_handle_t devmap_handle; + if (devmap_device_register(kbd, &devmap_handle) != EOK) { + printf("%s: Unable to register device %s\n", NAME, kbd); + return -1; + } + + /* Start looking for new kbdev devices */ + kbd_start_dev_discovery(); + + printf(NAME ": Accepting connections\n"); + async_manager(); + + /* Not reached. */ + return 0; +} + +/** + * @} + */ Index: uspace/srv/hid/input/include/gsp.h =================================================================== --- uspace/srv/hid/input/include/gsp.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/gsp.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief Generic scancode parser. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_GSP_H_ +#define KBD_GSP_H_ + +#include + +enum { + GSP_END = -1, /**< Terminates a sequence. */ + GSP_DEFAULT = -2 /**< Wildcard, catches unhandled cases. */ +}; + +/** Scancode parser description */ +typedef struct { + /** Transition table, (state, input) -> (state, output) */ + hash_table_t trans; + + /** Number of states */ + int states; +} gsp_t; + +/** Scancode parser transition. */ +typedef struct { + link_t link; /**< Link to hash table in @c gsp_t */ + + /* Preconditions */ + + int old_state; /**< State before transition */ + int input; /**< Input symbol (scancode) */ + + /* Effects */ + + int new_state; /**< State after transition */ + + /* Output emitted during transition */ + + unsigned out_mods; /**< Modifier to emit */ + unsigned out_key; /**< Keycode to emit */ +} gsp_trans_t; + +extern void gsp_init(gsp_t *); +extern int gsp_insert_defs(gsp_t *, const int *); +extern int gsp_insert_seq(gsp_t *, const int *, unsigned, unsigned); +extern int gsp_step(gsp_t *, int, int, unsigned *, unsigned *); + +#endif + +/** + * @} + */ Index: uspace/srv/hid/input/include/kbd.h =================================================================== --- uspace/srv/hid/input/include/kbd.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/kbd.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2006 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief HelenOS input server. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_KBD_H_ +#define KBD_KBD_H_ + +#include +#include + +#define NAME "input" +#define NAMESPACE "hid_in" + +struct kbd_port_ops; +struct kbd_ctl_ops; + +typedef struct kbd_dev { + /** Link to kbd_devs list */ + link_t kbd_devs; + + /** Path to the device (only for kbdev devices) */ + const char *dev_path; + + /** Port ops */ + struct kbd_port_ops *port_ops; + + /** Ctl ops */ + struct kbd_ctl_ops *ctl_ops; +} kbd_dev_t; + +extern bool irc_service; +extern int irc_phone; + +extern void kbd_push_scancode(kbd_dev_t *, int); +extern void kbd_push_ev(kbd_dev_t *, int, unsigned int); + +#endif + +/** + * @} + */ Index: uspace/srv/hid/input/include/kbd_ctl.h =================================================================== --- uspace/srv/hid/input/include/kbd_ctl.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/kbd_ctl.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief Keyboard controller driver interface. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_CTL_H_ +#define KBD_CTL_H_ + +#include + +struct kbd_dev; + +typedef struct kbd_ctl_ops { + void (*parse_scancode)(int); + int (*init)(struct kbd_dev *); + void (*set_ind)(unsigned); +} kbd_ctl_ops_t; + +extern kbd_ctl_ops_t apple_ctl; +extern kbd_ctl_ops_t gxe_fb_ctl; +extern kbd_ctl_ops_t kbdev_ctl; +extern kbd_ctl_ops_t pc_ctl; +extern kbd_ctl_ops_t stty_ctl; +extern kbd_ctl_ops_t sun_ctl; + +#endif + +/** + * @} + */ + Index: uspace/srv/hid/input/include/kbd_port.h =================================================================== --- uspace/srv/hid/input/include/kbd_port.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/kbd_port.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief Keyboard port driver interface. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_PORT_H_ +#define KBD_PORT_H_ + +#include + +struct kbd_dev; + +typedef struct kbd_port_ops { + int (*init)(struct kbd_dev *); + void (*yield)(void); + void (*reclaim)(void); + void (*write)(uint8_t); +} kbd_port_ops_t; + +extern kbd_port_ops_t adb_port; +extern kbd_port_ops_t chardev_port; +extern kbd_port_ops_t dummy_port; +extern kbd_port_ops_t gxemul_port; +extern kbd_port_ops_t msim_port; +extern kbd_port_ops_t niagara_port; +extern kbd_port_ops_t ns16550_port; +extern kbd_port_ops_t pl050_port; +extern kbd_port_ops_t sgcn_port; +extern kbd_port_ops_t ski_port; +extern kbd_port_ops_t z8530_port; + +#endif + +/** + * @} + */ + Index: uspace/srv/hid/input/include/layout.h =================================================================== --- uspace/srv/hid/input/include/layout.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/layout.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief Keyboard layout interface. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_LAYOUT_H_ +#define KBD_LAYOUT_H_ + +#include +#include + +typedef struct { + void (*reset)(void); + wchar_t (*parse_ev)(kbd_event_t *); +} layout_op_t; + +extern layout_op_t us_qwerty_op; +extern layout_op_t us_dvorak_op; +extern layout_op_t cz_op; + +#endif + +/** + * @} + */ Index: uspace/srv/hid/input/include/stroke.h =================================================================== --- uspace/srv/hid/input/include/stroke.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/include/stroke.h (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup inputgen generic + * @brief Generic scancode parser. + * @ingroup input + * @{ + */ +/** @file + */ + +#ifndef KBD_STROKE_H_ +#define KBD_STROKE_H_ + +#include + +extern void stroke_sim(kbd_dev_t *, unsigned, unsigned); + +#endif + +/** + * @} + */ + Index: uspace/srv/hid/input/layout/cz.c =================================================================== --- uspace/srv/hid/input/layout/cz.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/layout/cz.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,408 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup input + * @brief Czech QWERTZ layout. + * @{ + */ + +#include +#include +#include +#include +#include + +static void layout_reset(void); +static wchar_t layout_parse_ev(kbd_event_t *ev); + +enum m_state { + ms_start, + ms_hacek, + ms_carka +}; + +static enum m_state mstate; + +layout_op_t cz_op = { + layout_reset, + layout_parse_ev +}; + +static wchar_t map_lcase[] = { + [KC_Q] = 'q', + [KC_W] = 'w', + [KC_E] = 'e', + [KC_R] = 'r', + [KC_T] = 't', + [KC_Y] = 'z', + [KC_U] = 'u', + [KC_I] = 'i', + [KC_O] = 'o', + [KC_P] = 'p', + + [KC_A] = 'a', + [KC_S] = 's', + [KC_D] = 'd', + [KC_F] = 'f', + [KC_G] = 'g', + [KC_H] = 'h', + [KC_J] = 'j', + [KC_K] = 'k', + [KC_L] = 'l', + + [KC_Z] = 'y', + [KC_X] = 'x', + [KC_C] = 'c', + [KC_V] = 'v', + [KC_B] = 'b', + [KC_N] = 'n', + [KC_M] = 'm', +}; + +static wchar_t map_ucase[] = { + [KC_Q] = 'Q', + [KC_W] = 'W', + [KC_E] = 'E', + [KC_R] = 'R', + [KC_T] = 'T', + [KC_Y] = 'Z', + [KC_U] = 'U', + [KC_I] = 'I', + [KC_O] = 'O', + [KC_P] = 'P', + + [KC_A] = 'A', + [KC_S] = 'S', + [KC_D] = 'D', + [KC_F] = 'F', + [KC_G] = 'G', + [KC_H] = 'H', + [KC_J] = 'J', + [KC_K] = 'K', + [KC_L] = 'L', + + [KC_Z] = 'Y', + [KC_X] = 'X', + [KC_C] = 'C', + [KC_V] = 'V', + [KC_B] = 'B', + [KC_N] = 'N', + [KC_M] = 'M', +}; + +static wchar_t map_not_shifted[] = { + [KC_BACKTICK] = ';', + + [KC_1] = '+', + + [KC_MINUS] = '=', + + [KC_RBRACKET] = ')', + + [KC_QUOTE] = L'§', + + [KC_COMMA] = ',', + [KC_PERIOD] = '.', + [KC_SLASH] = '-', +}; + +static wchar_t map_shifted[] = { + [KC_1] = '1', + [KC_2] = '2', + [KC_3] = '3', + [KC_4] = '4', + [KC_5] = '5', + [KC_6] = '6', + [KC_7] = '7', + [KC_8] = '8', + [KC_9] = '9', + [KC_0] = '0', + + [KC_MINUS] = '%', + + [KC_LBRACKET] = '/', + [KC_RBRACKET] = '(', + + [KC_SEMICOLON] = '"', + [KC_QUOTE] = '!', + [KC_BACKSLASH] = '\'', + + [KC_COMMA] = '?', + [KC_PERIOD] = ':', + [KC_SLASH] = '_', +}; + +static wchar_t map_ns_nocaps[] = { + [KC_2] = L'ě', + [KC_3] = L'š', + [KC_4] = L'č', + [KC_5] = L'ř', + [KC_6] = L'ž', + [KC_7] = L'ý', + [KC_8] = L'á', + [KC_9] = L'í', + [KC_0] = L'é', + + [KC_LBRACKET] = L'ú', + [KC_SEMICOLON] = L'ů' +}; + +static wchar_t map_ns_caps[] = { + [KC_2] = L'Ě', + [KC_3] = L'Š', + [KC_4] = L'Č', + [KC_5] = L'Ř', + [KC_6] = L'Ž', + [KC_7] = L'Ý', + [KC_8] = L'Á', + [KC_9] = L'Í', + [KC_0] = L'É', + + [KC_LBRACKET] = L'Ú', + [KC_SEMICOLON] = L'Ů' +}; + +static wchar_t map_neutral[] = { + [KC_BACKSPACE] = '\b', + [KC_TAB] = '\t', + [KC_ENTER] = '\n', + [KC_SPACE] = ' ', + + [KC_NSLASH] = '/', + [KC_NTIMES] = '*', + [KC_NMINUS] = '-', + [KC_NPLUS] = '+', + [KC_NENTER] = '\n' +}; + +static wchar_t map_numeric[] = { + [KC_N7] = '7', + [KC_N8] = '8', + [KC_N9] = '9', + [KC_N4] = '4', + [KC_N5] = '5', + [KC_N6] = '6', + [KC_N1] = '1', + [KC_N2] = '2', + [KC_N3] = '3', + + [KC_N0] = '0', + [KC_NPERIOD] = '.' +}; + +static wchar_t map_hacek_lcase[] = { + [KC_E] = L'ě', + [KC_R] = L'ř', + [KC_T] = L'ť', + [KC_Y] = L'ž', + [KC_U] = L'ů', + + [KC_S] = L'š', + [KC_D] = L'ď', + + [KC_C] = L'č', + [KC_N] = L'ň' +}; + +static wchar_t map_hacek_ucase[] = { + [KC_E] = L'Ě', + [KC_R] = L'Ř', + [KC_T] = L'Ť', + [KC_Y] = L'Ž', + [KC_U] = L'Ů', + + [KC_S] = L'Š', + [KC_D] = L'Ď', + + [KC_C] = L'Č', + [KC_N] = L'Ň' +}; + +static wchar_t map_carka_lcase[] = { + [KC_E] = L'é', + [KC_U] = L'ú', + [KC_I] = L'í', + [KC_O] = L'ó', + + [KC_A] = L'á', + + [KC_Z] = L'ý', +}; + +static wchar_t map_carka_ucase[] = { + [KC_E] = L'É', + [KC_U] = L'Ú', + [KC_I] = L'Í', + [KC_O] = L'Ó', + + [KC_A] = L'Á', + + [KC_Z] = L'Ý', +}; + +static wchar_t translate(unsigned int key, wchar_t *map, size_t map_length) +{ + if (key >= map_length) + return 0; + return map[key]; +} + +static wchar_t parse_ms_hacek(kbd_event_t *ev) +{ + wchar_t c; + + mstate = ms_start; + + /* Produce no characters when Ctrl or Alt is pressed. */ + if ((ev->mods & (KM_CTRL | KM_ALT)) != 0) + return 0; + + if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0)) + c = translate(ev->key, map_hacek_ucase, sizeof(map_hacek_ucase) / sizeof(wchar_t)); + else + c = translate(ev->key, map_hacek_lcase, sizeof(map_hacek_lcase) / sizeof(wchar_t)); + + return c; +} + +static wchar_t parse_ms_carka(kbd_event_t *ev) +{ + wchar_t c; + + mstate = ms_start; + + /* Produce no characters when Ctrl or Alt is pressed. */ + if ((ev->mods & (KM_CTRL | KM_ALT)) != 0) + return 0; + + if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0)) + c = translate(ev->key, map_carka_ucase, sizeof(map_carka_ucase) / sizeof(wchar_t)); + else + c = translate(ev->key, map_carka_lcase, sizeof(map_carka_lcase) / sizeof(wchar_t)); + + return c; +} + +static wchar_t parse_ms_start(kbd_event_t *ev) +{ + wchar_t c; + + /* Produce no characters when Ctrl or Alt is pressed. */ + if ((ev->mods & (KM_CTRL | KM_ALT)) != 0) + return 0; + + if (ev->key == KC_EQUALS) { + if ((ev->mods & KM_SHIFT) != 0) + mstate = ms_hacek; + else + mstate = ms_carka; + + return 0; + } + + c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(wchar_t)); + if (c != 0) + return c; + + if ((ev->mods & KM_SHIFT) == 0) { + if ((ev->mods & KM_CAPS_LOCK) != 0) + c = translate(ev->key, map_ns_caps, sizeof(map_ns_caps) / sizeof(wchar_t)); + else + c = translate(ev->key, map_ns_nocaps, sizeof(map_ns_nocaps) / sizeof(wchar_t)); + + if (c != 0) + return c; + } + + if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0)) + c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(wchar_t)); + else + c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_SHIFT) != 0) + c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(wchar_t)); + else + c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_NUM_LOCK) != 0) + c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(wchar_t)); + else + c = 0; + + return c; +} + +static bool key_is_mod(unsigned key) +{ + switch (key) { + case KC_LSHIFT: + case KC_RSHIFT: + case KC_LALT: + case KC_RALT: + case KC_LCTRL: + case KC_RCTRL: + return true; + default: + return false; + } +} + +static void layout_reset(void) +{ + mstate = ms_start; +} + +static wchar_t layout_parse_ev(kbd_event_t *ev) +{ + if (ev->type != KEY_PRESS) + return 0; + + if (key_is_mod(ev->key)) + return 0; + + switch (mstate) { + case ms_start: + return parse_ms_start(ev); + case ms_hacek: + return parse_ms_hacek(ev); + case ms_carka: + return parse_ms_carka(ev); + } + + return 0; +} + +/** + * @} + */ Index: uspace/srv/hid/input/layout/us_dvorak.c =================================================================== --- uspace/srv/hid/input/layout/us_dvorak.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/layout/us_dvorak.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,250 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup input + * @brief US Dvorak Simplified Keyboard layout. + * @{ + */ + +#include +#include +#include +#include + +static void layout_reset(void); +static wchar_t layout_parse_ev(kbd_event_t *ev); + +layout_op_t us_dvorak_op = { + layout_reset, + layout_parse_ev +}; + +static wchar_t map_lcase[] = { + [KC_R] = 'p', + [KC_T] = 'y', + [KC_Y] = 'f', + [KC_U] = 'g', + [KC_I] = 'c', + [KC_O] = 'r', + [KC_P] = 'l', + + [KC_A] = 'a', + [KC_S] = 'o', + [KC_D] = 'e', + [KC_F] = 'u', + [KC_G] = 'i', + [KC_H] = 'd', + [KC_J] = 'h', + [KC_K] = 't', + [KC_L] = 'n', + + [KC_SEMICOLON] = 's', + + [KC_X] = 'q', + [KC_C] = 'j', + [KC_V] = 'k', + [KC_B] = 'x', + [KC_N] = 'b', + [KC_M] = 'm', + + [KC_COMMA] = 'w', + [KC_PERIOD] = 'v', + [KC_SLASH] = 'z', +}; + +static wchar_t map_ucase[] = { + [KC_R] = 'P', + [KC_T] = 'Y', + [KC_Y] = 'F', + [KC_U] = 'G', + [KC_I] = 'C', + [KC_O] = 'R', + [KC_P] = 'L', + + [KC_A] = 'A', + [KC_S] = 'O', + [KC_D] = 'E', + [KC_F] = 'U', + [KC_G] = 'I', + [KC_H] = 'D', + [KC_J] = 'H', + [KC_K] = 'T', + [KC_L] = 'N', + + [KC_SEMICOLON] = 'S', + + [KC_X] = 'Q', + [KC_C] = 'J', + [KC_V] = 'K', + [KC_B] = 'X', + [KC_N] = 'B', + [KC_M] = 'M', + + [KC_COMMA] = 'W', + [KC_PERIOD] = 'V', + [KC_SLASH] = 'Z', +}; + +static wchar_t map_not_shifted[] = { + [KC_BACKTICK] = '`', + + [KC_1] = '1', + [KC_2] = '2', + [KC_3] = '3', + [KC_4] = '4', + [KC_5] = '5', + [KC_6] = '6', + [KC_7] = '7', + [KC_8] = '8', + [KC_9] = '9', + [KC_0] = '0', + + [KC_MINUS] = '[', + [KC_EQUALS] = ']', + + [KC_Q] = '\'', + [KC_W] = ',', + [KC_E] = '.', + + [KC_LBRACKET] = '/', + [KC_RBRACKET] = '=', + + [KC_QUOTE] = '-', + [KC_BACKSLASH] = '\\', + + [KC_Z] = ';', +}; + +static wchar_t map_shifted[] = { + [KC_BACKTICK] = '~', + + [KC_1] = '!', + [KC_2] = '@', + [KC_3] = '#', + [KC_4] = '$', + [KC_5] = '%', + [KC_6] = '^', + [KC_7] = '&', + [KC_8] = '*', + [KC_9] = '(', + [KC_0] = ')', + + [KC_MINUS] = '{', + [KC_EQUALS] = '}', + + [KC_Q] = '"', + [KC_W] = '<', + [KC_E] = '>', + + [KC_LBRACKET] = '?', + [KC_RBRACKET] = '+', + + [KC_QUOTE] = '_', + [KC_BACKSLASH] = '|', + + [KC_Z] = ':', +}; + +static wchar_t map_neutral[] = { + [KC_BACKSPACE] = '\b', + [KC_TAB] = '\t', + [KC_ENTER] = '\n', + [KC_SPACE] = ' ', + + [KC_NSLASH] = '/', + [KC_NTIMES] = '*', + [KC_NMINUS] = '-', + [KC_NPLUS] = '+', + [KC_NENTER] = '\n' +}; + +static wchar_t map_numeric[] = { + [KC_N7] = '7', + [KC_N8] = '8', + [KC_N9] = '9', + [KC_N4] = '4', + [KC_N5] = '5', + [KC_N6] = '6', + [KC_N1] = '1', + [KC_N2] = '2', + [KC_N3] = '3', + + [KC_N0] = '0', + [KC_NPERIOD] = '.' +}; + +static wchar_t translate(unsigned int key, wchar_t *map, size_t map_length) +{ + if (key >= map_length) + return 0; + return map[key]; +} + +static void layout_reset(void) +{ +} + +static wchar_t layout_parse_ev(kbd_event_t *ev) +{ + wchar_t c; + + /* Produce no characters when Ctrl or Alt is pressed. */ + if ((ev->mods & (KM_CTRL | KM_ALT)) != 0) + return 0; + + c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(wchar_t)); + if (c != 0) + return c; + + if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0)) + c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(wchar_t)); + else + c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_SHIFT) != 0) + c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(wchar_t)); + else + c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_NUM_LOCK) != 0) + c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(wchar_t)); + else + c = 0; + + return c; +} + +/** + * @} + */ Index: uspace/srv/hid/input/layout/us_qwerty.c =================================================================== --- uspace/srv/hid/input/layout/us_qwerty.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/layout/us_qwerty.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup input + * @brief US QWERTY layout. + * @{ + */ + +#include +#include +#include +#include + +static void layout_reset(void); +static wchar_t layout_parse_ev(kbd_event_t *ev); + +layout_op_t us_qwerty_op = { + layout_reset, + layout_parse_ev +}; + +static wchar_t map_lcase[] = { + [KC_Q] = 'q', + [KC_W] = 'w', + [KC_E] = 'e', + [KC_R] = 'r', + [KC_T] = 't', + [KC_Y] = 'y', + [KC_U] = 'u', + [KC_I] = 'i', + [KC_O] = 'o', + [KC_P] = 'p', + + [KC_A] = 'a', + [KC_S] = 's', + [KC_D] = 'd', + [KC_F] = 'f', + [KC_G] = 'g', + [KC_H] = 'h', + [KC_J] = 'j', + [KC_K] = 'k', + [KC_L] = 'l', + + [KC_Z] = 'z', + [KC_X] = 'x', + [KC_C] = 'c', + [KC_V] = 'v', + [KC_B] = 'b', + [KC_N] = 'n', + [KC_M] = 'm', +}; + +static wchar_t map_ucase[] = { + [KC_Q] = 'Q', + [KC_W] = 'W', + [KC_E] = 'E', + [KC_R] = 'R', + [KC_T] = 'T', + [KC_Y] = 'Y', + [KC_U] = 'U', + [KC_I] = 'I', + [KC_O] = 'O', + [KC_P] = 'P', + + [KC_A] = 'A', + [KC_S] = 'S', + [KC_D] = 'D', + [KC_F] = 'F', + [KC_G] = 'G', + [KC_H] = 'H', + [KC_J] = 'J', + [KC_K] = 'K', + [KC_L] = 'L', + + [KC_Z] = 'Z', + [KC_X] = 'X', + [KC_C] = 'C', + [KC_V] = 'V', + [KC_B] = 'B', + [KC_N] = 'N', + [KC_M] = 'M', +}; + +static wchar_t map_not_shifted[] = { + [KC_BACKTICK] = '`', + + [KC_1] = '1', + [KC_2] = '2', + [KC_3] = '3', + [KC_4] = '4', + [KC_5] = '5', + [KC_6] = '6', + [KC_7] = '7', + [KC_8] = '8', + [KC_9] = '9', + [KC_0] = '0', + + [KC_MINUS] = '-', + [KC_EQUALS] = '=', + + [KC_LBRACKET] = '[', + [KC_RBRACKET] = ']', + + [KC_SEMICOLON] = ';', + [KC_QUOTE] = '\'', + [KC_BACKSLASH] = '\\', + + [KC_COMMA] = ',', + [KC_PERIOD] = '.', + [KC_SLASH] = '/', +}; + +static wchar_t map_shifted[] = { + [KC_BACKTICK] = '~', + + [KC_1] = '!', + [KC_2] = '@', + [KC_3] = '#', + [KC_4] = '$', + [KC_5] = '%', + [KC_6] = '^', + [KC_7] = '&', + [KC_8] = '*', + [KC_9] = '(', + [KC_0] = ')', + + [KC_MINUS] = '_', + [KC_EQUALS] = '+', + + [KC_LBRACKET] = '{', + [KC_RBRACKET] = '}', + + [KC_SEMICOLON] = ':', + [KC_QUOTE] = '"', + [KC_BACKSLASH] = '|', + + [KC_COMMA] = '<', + [KC_PERIOD] = '>', + [KC_SLASH] = '?', +}; + +static wchar_t map_neutral[] = { + [KC_BACKSPACE] = '\b', + [KC_TAB] = '\t', + [KC_ENTER] = '\n', + [KC_SPACE] = ' ', + + [KC_NSLASH] = '/', + [KC_NTIMES] = '*', + [KC_NMINUS] = '-', + [KC_NPLUS] = '+', + [KC_NENTER] = '\n' +}; + +static wchar_t map_numeric[] = { + [KC_N7] = '7', + [KC_N8] = '8', + [KC_N9] = '9', + [KC_N4] = '4', + [KC_N5] = '5', + [KC_N6] = '6', + [KC_N1] = '1', + [KC_N2] = '2', + [KC_N3] = '3', + + [KC_N0] = '0', + [KC_NPERIOD] = '.' +}; + +static wchar_t translate(unsigned int key, wchar_t *map, size_t map_length) +{ + if (key >= map_length) + return 0; + return map[key]; +} + +static void layout_reset(void) +{ +} + +static wchar_t layout_parse_ev(kbd_event_t *ev) +{ + wchar_t c; + + /* Produce no characters when Ctrl or Alt is pressed. */ + if ((ev->mods & (KM_CTRL | KM_ALT)) != 0) + return 0; + + c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(wchar_t)); + if (c != 0) + return c; + + if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0)) + c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(wchar_t)); + else + c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_SHIFT) != 0) + c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(wchar_t)); + else + c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(wchar_t)); + + if (c != 0) + return c; + + if ((ev->mods & KM_NUM_LOCK) != 0) + c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(wchar_t)); + else + c = 0; + + return c; +} + +/** + * @} + */ Index: uspace/srv/hid/input/port/adb.c =================================================================== --- uspace/srv/hid/input/port/adb.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/adb.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief ADB keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall); +static void adb_kbd_reg0_data(uint16_t data); + +static int adb_port_init(kbd_dev_t *); +static void adb_port_yield(void); +static void adb_port_reclaim(void); +static void adb_port_write(uint8_t data); + +kbd_port_ops_t adb_port = { + .init = adb_port_init, + .yield = adb_port_yield, + .reclaim = adb_port_reclaim, + .write = adb_port_write +}; + +static kbd_dev_t *kbd_dev; +static int dev_phone; + +static int adb_port_init(kbd_dev_t *kdev) +{ + const char *dev = "adb/kbd"; + devmap_handle_t handle; + + kbd_dev = kdev; + + int rc = devmap_device_get_handle(dev, &handle, 0); + if (rc == EOK) { + dev_phone = devmap_obsolete_device_connect(handle, 0); + if (dev_phone < 0) { + printf("%s: Failed to connect to device\n", NAME); + return dev_phone; + } + } else + return rc; + + /* NB: The callback connection is slotted for removal */ + rc = async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events); + if (rc != EOK) { + printf(NAME ": Failed to create callback from device\n"); + return rc; + } + + return EOK; +} + +static void adb_port_yield(void) +{ +} + +static void adb_port_reclaim(void) +{ +} + +static void adb_port_write(uint8_t data) +{ + /*async_msg_1(dev_phone, CHAR_WRITE_BYTE, data);*/ +} + +static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall) +{ + /* Ignore parameters, the connection is already opened */ + while (true) { + + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + int retval; + + if (!IPC_GET_IMETHOD(call)) { + /* TODO: Handle hangup */ + return; + } + + switch (IPC_GET_IMETHOD(call)) { + case ADB_REG_NOTIF: + adb_kbd_reg0_data(IPC_GET_ARG1(call)); + break; + default: + retval = ENOENT; + } + async_answer_0(callid, retval); + } +} + +static void adb_kbd_reg0_data(uint16_t data) +{ + uint8_t b0, b1; + + b0 = (data >> 8) & 0xff; + b1 = data & 0xff; + + if (b0 != 0xff) + kbd_push_scancode(kbd_dev, b0); + if (b1 != 0xff) + kbd_push_scancode(kbd_dev, b1); +} + +/** + * @} + */ Index: uspace/srv/hid/input/port/chardev.c =================================================================== --- uspace/srv/hid/input/port/chardev.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/chardev.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief Chardev keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall); + +static int chardev_port_init(kbd_dev_t *); +static void chardev_port_yield(void); +static void chardev_port_reclaim(void); +static void chardev_port_write(uint8_t data); + +kbd_port_ops_t chardev_port = { + .init = chardev_port_init, + .yield = chardev_port_yield, + .reclaim = chardev_port_reclaim, + .write = chardev_port_write +}; + +static kbd_dev_t *kbd_dev; +static int dev_phone; + +/** List of devices to try connecting to. */ +static const char *in_devs[] = { + "char/ps2a", + "char/s3c24ser" +}; + +static const unsigned int num_devs = sizeof(in_devs) / sizeof(in_devs[0]); + +static int chardev_port_init(kbd_dev_t *kdev) +{ + devmap_handle_t handle; + unsigned int i; + int rc; + + kbd_dev = kdev; + + for (i = 0; i < num_devs; i++) { + rc = devmap_device_get_handle(in_devs[i], &handle, 0); + if (rc == EOK) + break; + } + + if (i >= num_devs) { + printf("%s: Could not find any suitable input device\n", NAME); + return -1; + } + + dev_phone = devmap_obsolete_device_connect(handle, IPC_FLAG_BLOCKING); + if (dev_phone < 0) { + printf("%s: Failed connecting to device\n", NAME); + return ENOENT; + } + + /* NB: The callback connection is slotted for removal */ + if (async_obsolete_connect_to_me(dev_phone, 0, 0, 0, kbd_port_events) != 0) { + printf(NAME ": Failed to create callback from device\n"); + return -1; + } + + return 0; +} + +static void chardev_port_yield(void) +{ +} + +static void chardev_port_reclaim(void) +{ +} + +static void chardev_port_write(uint8_t data) +{ + async_obsolete_msg_1(dev_phone, CHAR_WRITE_BYTE, data); +} + +static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall) +{ + /* Ignore parameters, the connection is already opened */ + while (true) { + + ipc_call_t call; + ipc_callid_t callid = async_get_call(&call); + + if (!IPC_GET_IMETHOD(call)) { + /* TODO: Handle hangup */ + return; + } + + int retval; + + switch (IPC_GET_IMETHOD(call)) { + case CHAR_NOTIF_BYTE: + kbd_push_scancode(kbd_dev, IPC_GET_ARG1(call)); + break; + default: + retval = ENOENT; + } + async_answer_0(callid, retval); + } +} + + +/** + * @} + */ Index: uspace/srv/hid/input/port/gxemul.c =================================================================== --- uspace/srv/hid/input/port/gxemul.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/gxemul.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2007 Michal Kebrt + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @{ + * @ingroup kbd + */ +/** @file + * @brief GXEmul keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include + +static int gxemul_port_init(kbd_dev_t *); +static void gxemul_port_yield(void); +static void gxemul_port_reclaim(void); +static void gxemul_port_write(uint8_t data); + +kbd_port_ops_t gxemul_port = { + .init = gxemul_port_init, + .yield = gxemul_port_yield, + .reclaim = gxemul_port_reclaim, + .write = gxemul_port_write +}; + +static kbd_dev_t *kbd_dev; + +static irq_cmd_t gxemul_cmds[] = { + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* will be patched in run-time */ + .dstarg = 2, + }, + { + .cmd = CMD_ACCEPT + } +}; + +static irq_code_t gxemul_kbd = { + sizeof(gxemul_cmds) / sizeof(irq_cmd_t), + gxemul_cmds +}; + +static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call); + +/** Initializes keyboard handler. */ +static int gxemul_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t addr; + if (sysinfo_get_value("kbd.address.virtual", &addr) != EOK) + return -1; + + sysarg_t inr; + if (sysinfo_get_value("kbd.inr", &inr) != EOK) + return -1; + + async_set_interrupt_received(gxemul_irq_handler); + gxemul_cmds[0].addr = (void *) addr; + register_irq(inr, device_assign_devno(), 0, &gxemul_kbd); + return 0; +} + +static void gxemul_port_yield(void) +{ +} + +static void gxemul_port_reclaim(void) +{ +} + +static void gxemul_port_write(uint8_t data) +{ + (void) data; +} + +/** Process data sent when a key is pressed. + * + * @param keybuffer Buffer of pressed keys. + * @param call IPC call. + * + * @return Always 1. + */ +static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call) +{ + int scan_code = IPC_GET_ARG2(*call); + + kbd_push_scancode(kbd_dev, scan_code); +} + +/** @} + */ Index: uspace/srv/hid/input/port/msim.c =================================================================== --- uspace/srv/hid/input/port/msim.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/msim.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2006 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief Msim keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include + +static int msim_port_init(kbd_dev_t *); +static void msim_port_yield(void); +static void msim_port_reclaim(void); +static void msim_port_write(uint8_t data); + +kbd_port_ops_t msim_port = { + .init = msim_port_init, + .yield = msim_port_yield, + .reclaim = msim_port_reclaim, + .write = msim_port_write +}; + +static kbd_dev_t *kbd_dev; + +static irq_cmd_t msim_cmds[] = { + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* will be patched in run-time */ + .dstarg = 2 + }, + { + .cmd = CMD_ACCEPT + } +}; + +static irq_code_t msim_kbd = { + sizeof(msim_cmds) / sizeof(irq_cmd_t), + msim_cmds +}; + +static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call); + +static int msim_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t vaddr; + if (sysinfo_get_value("kbd.address.virtual", &vaddr) != EOK) + return -1; + + sysarg_t inr; + if (sysinfo_get_value("kbd.inr", &inr) != EOK) + return -1; + + msim_cmds[0].addr = (void *) vaddr; + async_set_interrupt_received(msim_irq_handler); + register_irq(inr, device_assign_devno(), 0, &msim_kbd); + + return 0; +} + +static void msim_port_yield(void) +{ +} + +static void msim_port_reclaim(void) +{ +} + +static void msim_port_write(uint8_t data) +{ + (void) data; +} + +static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call) +{ + int scan_code = IPC_GET_ARG2(*call); + kbd_push_scancode(kbd_dev, scan_code); +} + +/** @} +*/ Index: uspace/srv/hid/input/port/niagara.c =================================================================== --- uspace/srv/hid/input/port/niagara.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/niagara.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2008 Pavel Rimsky + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief Niagara console keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int niagara_port_init(kbd_dev_t *); +static void niagara_port_yield(void); +static void niagara_port_reclaim(void); +static void niagara_port_write(uint8_t data); + +kbd_port_ops_t niagara_port = { + .init = niagara_port_init, + .yield = niagara_port_yield, + .reclaim = niagara_port_reclaim, + .write = niagara_port_write +}; + +static kbd_dev_t *kbd_dev; + +#define POLL_INTERVAL 10000 + +/** + * Virtual address mapped to the buffer shared with the kernel counterpart. + */ +static uintptr_t input_buffer_addr; + +/* + * Kernel counterpart of the driver pushes characters (it has read) here. + * Keep in sync with the definition from + * kernel/arch/sparc64/src/drivers/niagara.c. + */ +#define INPUT_BUFFER_SIZE ((PAGE_SIZE) - 2 * 8) + +typedef volatile struct { + uint64_t write_ptr; + uint64_t read_ptr; + char data[INPUT_BUFFER_SIZE]; +} + __attribute__ ((packed)) + __attribute__ ((aligned(PAGE_SIZE))) + *input_buffer_t; + +/* virtual address of the shared buffer */ +static input_buffer_t input_buffer; + +static volatile bool polling_disabled = false; +static void niagara_thread_impl(void *arg); + +/** + * Initializes the Niagara driver. + * Maps the shared buffer and creates the polling thread. + */ +static int niagara_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t paddr; + if (sysinfo_get_value("niagara.inbuf.address", &paddr) != EOK) + return -1; + + input_buffer_addr = (uintptr_t) as_get_mappable_page(PAGE_SIZE); + int rc = physmem_map((void *) paddr, (void *) input_buffer_addr, + 1, AS_AREA_READ | AS_AREA_WRITE); + + if (rc != 0) { + printf("Niagara: uspace driver couldn't map physical memory: %d\n", + rc); + return rc; + } + + input_buffer = (input_buffer_t) input_buffer_addr; + + thread_id_t tid; + rc = thread_create(niagara_thread_impl, NULL, "kbd_poll", &tid); + if (rc != 0) + return rc; + + return 0; +} + +static void niagara_port_yield(void) +{ + polling_disabled = true; +} + +static void niagara_port_reclaim(void) +{ + polling_disabled = false; +} + +static void niagara_port_write(uint8_t data) +{ + (void) data; +} + +/** + * Called regularly by the polling thread. Reads codes of all the + * pressed keys from the buffer. + */ +static void niagara_key_pressed(void) +{ + char c; + + while (input_buffer->read_ptr != input_buffer->write_ptr) { + c = input_buffer->data[input_buffer->read_ptr]; + input_buffer->read_ptr = + ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE; + kbd_push_scancode(kbd_dev, c); + } +} + +/** + * Thread to poll SGCN for keypresses. + */ +static void niagara_thread_impl(void *arg) +{ + (void) arg; + + while (1) { + if (polling_disabled == false) + niagara_key_pressed(); + usleep(POLL_INTERVAL); + } +} +/** @} + */ Index: uspace/srv/hid/input/port/ns16550.c =================================================================== --- uspace/srv/hid/input/port/ns16550.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/ns16550.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2006 Josef Cejka + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief NS16550 port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int ns16550_port_init(kbd_dev_t *); +static void ns16550_port_yield(void); +static void ns16550_port_reclaim(void); +static void ns16550_port_write(uint8_t data); + +kbd_port_ops_t ns16550_port = { + .init = ns16550_port_init, + .yield = ns16550_port_yield, + .reclaim = ns16550_port_reclaim, + .write = ns16550_port_write +}; + +static kbd_dev_t *kbd_dev; + +/* NS16550 registers */ +#define RBR_REG 0 /** Receiver Buffer Register. */ +#define IER_REG 1 /** Interrupt Enable Register. */ +#define IIR_REG 2 /** Interrupt Ident Register (read). */ +#define FCR_REG 2 /** FIFO control register (write). */ +#define LCR_REG 3 /** Line Control register. */ +#define MCR_REG 4 /** Modem Control Register. */ +#define LSR_REG 5 /** Line Status Register. */ + +#define LSR_DATA_READY 0x01 + +static irq_cmd_t ns16550_cmds[] = { + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* Will be patched in run-time */ + .dstarg = 1 + }, + { + .cmd = CMD_BTEST, + .value = LSR_DATA_READY, + .srcarg = 1, + .dstarg = 3 + }, + { + .cmd = CMD_PREDICATE, + .value = 2, + .srcarg = 3 + }, + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* Will be patched in run-time */ + .dstarg = 2 + }, + { + .cmd = CMD_ACCEPT + } +}; + +irq_code_t ns16550_kbd = { + sizeof(ns16550_cmds) / sizeof(irq_cmd_t), + ns16550_cmds +}; + +static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call); + +static uintptr_t ns16550_physical; +static uintptr_t ns16550_kernel; + +static kbd_dev_t *kbd_dev; + +static int ns16550_port_init(kbd_dev_t *kdev) +{ + void *vaddr; + + kbd_dev = kdev; + + sysarg_t ns16550; + if (sysinfo_get_value("kbd.type.ns16550", &ns16550) != EOK) + return -1; + if (!ns16550) + return -1; + + if (sysinfo_get_value("kbd.address.physical", &ns16550_physical) != EOK) + return -1; + + if (sysinfo_get_value("kbd.address.kernel", &ns16550_kernel) != EOK) + return -1; + + sysarg_t inr; + if (sysinfo_get_value("kbd.inr", &inr) != EOK) + return -1; + + ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG); + ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG); + + async_set_interrupt_received(ns16550_irq_handler); + register_irq(inr, device_assign_devno(), inr, &ns16550_kbd); + + return pio_enable((void *) ns16550_physical, 8, &vaddr); +} + +static void ns16550_port_yield(void) +{ +} + +static void ns16550_port_reclaim(void) +{ +} + +static void ns16550_port_write(uint8_t data) +{ + (void) data; +} + +static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call) +{ + int scan_code = IPC_GET_ARG2(*call); + kbd_push_scancode(kbd_dev, scan_code); + + if (irc_service) + async_obsolete_msg_1(irc_phone, IRC_CLEAR_INTERRUPT, + IPC_GET_IMETHOD(*call)); +} + +/** + * @} + */ Index: uspace/srv/hid/input/port/pl050.c =================================================================== --- uspace/srv/hid/input/port/pl050.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/pl050.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2009 Vineeth Pillai + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief pl050 port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int pl050_port_init(kbd_dev_t *); +static void pl050_port_yield(void); +static void pl050_port_reclaim(void); +static void pl050_port_write(uint8_t data); + +kbd_port_ops_t pl050_port = { + .init = pl050_port_init, + .yield = pl050_port_yield, + .reclaim = pl050_port_reclaim, + .write = pl050_port_write +}; + +static kbd_dev_t *kbd_dev; + +#define PL050_STAT_RXFULL (1 << 4) + +static irq_cmd_t pl050_cmds[] = { + { + .cmd = CMD_PIO_READ_8, + .addr = NULL, + .dstarg = 1 + }, + { + .cmd = CMD_BTEST, + .value = PL050_STAT_RXFULL, + .srcarg = 1, + .dstarg = 3 + }, + { + .cmd = CMD_PREDICATE, + .value = 2, + .srcarg = 3 + }, + { + .cmd = CMD_PIO_READ_8, + .addr = NULL, /* Will be patched in run-time */ + .dstarg = 2 + }, + { + .cmd = CMD_ACCEPT + } +}; + +static irq_code_t pl050_kbd = { + sizeof(pl050_cmds) / sizeof(irq_cmd_t), + pl050_cmds +}; + +static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call); + +static int pl050_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t addr; + if (sysinfo_get_value("kbd.address.status", &addr) != EOK) + return -1; + + pl050_kbd.cmds[0].addr = (void *) addr; + + if (sysinfo_get_value("kbd.address.data", &addr) != EOK) + return -1; + + pl050_kbd.cmds[3].addr = (void *) addr; + + sysarg_t inr; + if (sysinfo_get_value("kbd.inr", &inr) != EOK) + return -1; + + async_set_interrupt_received(pl050_irq_handler); + register_irq(inr, device_assign_devno(), 0, &pl050_kbd); + + return 0; +} + +static void pl050_port_yield(void) +{ +} + +static void pl050_port_reclaim(void) +{ +} + +static void pl050_port_write(uint8_t data) +{ + (void) data; +} + +static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call) +{ + int scan_code = IPC_GET_ARG2(*call); + + kbd_push_scancode(kbd_dev, scan_code); + return; +} + +/** + * @} + */ Index: uspace/srv/hid/input/port/sgcn.c =================================================================== --- uspace/srv/hid/input/port/sgcn.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/sgcn.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2008 Pavel Rimsky + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief SGCN (Serengeti Console) keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int sgcn_port_init(kbd_dev_t *); +static void sgcn_port_yield(void); +static void sgcn_port_reclaim(void); +static void sgcn_port_write(uint8_t data); + +kbd_port_ops_t sgcn_port = { + .init = sgcn_port_init, + .yield = sgcn_port_yield, + .reclaim = sgcn_port_reclaim, + .write = sgcn_port_write +}; + +static kbd_dev_t *kbd_dev; + +#define POLL_INTERVAL 10000 + +/** + * SGCN buffer header. It is placed at the very beginning of the SGCN + * buffer. + */ +typedef struct { + /** hard-wired to "CON" */ + char magic[4]; + + /** we don't need this */ + char unused[8]; + + /** offset within the SGCN buffer of the input buffer start */ + uint32_t in_begin; + + /** offset within the SGCN buffer of the input buffer end */ + uint32_t in_end; + + /** offset within the SGCN buffer of the input buffer read pointer */ + uint32_t in_rdptr; + + /** offset within the SGCN buffer of the input buffer write pointer */ + uint32_t in_wrptr; +} __attribute__ ((packed)) sgcn_buffer_header_t; + +/* + * Returns a pointer to the object of a given type which is placed at the given + * offset from the console buffer beginning. + */ +#define SGCN_BUFFER(type, offset) \ + ((type *) (sram_virt_addr + sram_buffer_offset + (offset))) + +/** Returns a pointer to the console buffer header. */ +#define SGCN_BUFFER_HEADER (SGCN_BUFFER(sgcn_buffer_header_t, 0)) + +/** + * Virtual address mapped to SRAM. + */ +static uintptr_t sram_virt_addr; + +/** + * SGCN buffer offset within SGCN. + */ +static uintptr_t sram_buffer_offset; + +/* polling thread */ +static void sgcn_thread_impl(void *arg); + +static volatile bool polling_disabled = false; + +/** + * Initializes the SGCN driver. + * Maps the physical memory (SRAM) and creates the polling thread. + */ +static int sgcn_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t sram_paddr; + if (sysinfo_get_value("sram.address.physical", &sram_paddr) != EOK) + return -1; + + sysarg_t sram_size; + if (sysinfo_get_value("sram.area.size", &sram_size) != EOK) + return -1; + + if (sysinfo_get_value("sram.buffer.offset", &sram_buffer_offset) != EOK) + sram_buffer_offset = 0; + + sram_virt_addr = (uintptr_t) as_get_mappable_page(sram_size); + + if (physmem_map((void *) sram_paddr, (void *) sram_virt_addr, + sram_size / PAGE_SIZE, AS_AREA_READ | AS_AREA_WRITE) != 0) { + printf("SGCN: uspace driver could not map physical memory."); + return -1; + } + + thread_id_t tid; + int rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid); + if (rc != 0) + return rc; + + return 0; +} + +static void sgcn_port_yield(void) +{ + polling_disabled = true; +} + +static void sgcn_port_reclaim(void) +{ + polling_disabled = false; +} + +static void sgcn_port_write(uint8_t data) +{ + (void) data; +} + +/** + * Handler of the "key pressed" event. Reads codes of all the pressed keys from + * the buffer. + */ +static void sgcn_key_pressed(void) +{ + char c; + + uint32_t begin = SGCN_BUFFER_HEADER->in_begin; + uint32_t end = SGCN_BUFFER_HEADER->in_end; + uint32_t size = end - begin; + + volatile char *buf_ptr = (volatile char *) + SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); + volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr); + volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr); + + while (*in_rdptr_ptr != *in_wrptr_ptr) { + c = *buf_ptr; + *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin; + buf_ptr = (volatile char *) + SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr); + kbd_push_scancode(kbd_dev, c); + } +} + +/** + * Thread to poll SGCN for keypresses. + */ +static void sgcn_thread_impl(void *arg) +{ + (void) arg; + + while (1) { + if (polling_disabled == false) + sgcn_key_pressed(); + usleep(POLL_INTERVAL); + } +} + +/** @} + */ Index: uspace/srv/hid/input/port/ski.c =================================================================== --- uspace/srv/hid/input/port/ski.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/ski.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2005 Jakub Jermar + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief Ski console keyboard port driver. + */ + + +#include +#include +#include +#include +#include +#include +#include + +static int ski_port_init(kbd_dev_t *); +static void ski_port_yield(void); +static void ski_port_reclaim(void); +static void ski_port_write(uint8_t data); + +kbd_port_ops_t ski_port = { + .init = ski_port_init, + .yield = ski_port_yield, + .reclaim = ski_port_reclaim, + .write = ski_port_write +}; + +static kbd_dev_t *kbd_dev; + +#define SKI_GETCHAR 21 + +#define POLL_INTERVAL 10000 + +static void ski_thread_impl(void *arg); +static int32_t ski_getchar(void); + +static volatile bool polling_disabled = false; + +/** Initialize Ski port driver. */ +static int ski_port_init(kbd_dev_t *kdev) +{ + thread_id_t tid; + int rc; + + kbd_dev = kdev; + + rc = thread_create(ski_thread_impl, NULL, "kbd_poll", &tid); + if (rc != 0) { + return rc; + } + + return 0; +} + +static void ski_port_yield(void) +{ + polling_disabled = true; +} + +static void ski_port_reclaim(void) +{ + polling_disabled = false; +} + +static void ski_port_write(uint8_t data) +{ + (void) data; +} + +/** Thread to poll Ski for keypresses. */ +static void ski_thread_impl(void *arg) +{ + int32_t c; + (void) arg; + + while (1) { + while (polling_disabled == false) { + c = ski_getchar(); + if (c == 0) + break; + kbd_push_scancode(kbd_dev, c); + } + + usleep(POLL_INTERVAL); + } +} + +/** Ask Ski if a key was pressed. + * + * Use SSC (Simulator System Call) to get character from the debug console. + * This call is non-blocking. + * + * @return ASCII code of pressed key or 0 if no key pressed. + */ +static int32_t ski_getchar(void) +{ + uint64_t ch; + +#ifdef UARCH_ia64 + asm volatile ( + "mov r15 = %1\n" + "break 0x80000;;\n" /* modifies r8 */ + "mov %0 = r8;;\n" + + : "=r" (ch) + : "i" (SKI_GETCHAR) + : "r15", "r8" + ); +#else + ch = 0; +#endif + return (int32_t) ch; +} + +/** @} + */ Index: uspace/srv/hid/input/port/z8530.c =================================================================== --- uspace/srv/hid/input/port/z8530.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) +++ uspace/srv/hid/input/port/z8530.c (revision 5f8829315f6bebf5769560deb1bd34bc914628c4) @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2006 Martin Decky + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - 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. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/** @addtogroup kbd_port + * @ingroup kbd + * @{ + */ +/** @file + * @brief Z8530 keyboard port driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int z8530_port_init(kbd_dev_t *); +static void z8530_port_yield(void); +static void z8530_port_reclaim(void); +static void z8530_port_write(uint8_t data); + +kbd_port_ops_t z8530_port = { + .init = z8530_port_init, + .yield = z8530_port_yield, + .reclaim = z8530_port_reclaim, + .write = z8530_port_write +}; + +static kbd_dev_t *kbd_dev; + +#define CHAN_A_STATUS 4 +#define CHAN_A_DATA 6 + +#define RR0_RCA 1 + +static irq_cmd_t z8530_cmds[] = { + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* Will be patched in run-time */ + .dstarg = 1 + }, + { + .cmd = CMD_BTEST, + .value = RR0_RCA, + .srcarg = 1, + .dstarg = 3 + }, + { + .cmd = CMD_PREDICATE, + .value = 2, + .srcarg = 3 + }, + { + .cmd = CMD_PIO_READ_8, + .addr = (void *) 0, /* Will be patched in run-time */ + .dstarg = 2 + }, + { + .cmd = CMD_ACCEPT + } +}; + +static irq_code_t z8530_kbd = { + sizeof(z8530_cmds) / sizeof(irq_cmd_t), + z8530_cmds +}; + +static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call); + +static int z8530_port_init(kbd_dev_t *kdev) +{ + kbd_dev = kdev; + + sysarg_t z8530; + if (sysinfo_get_value("kbd.type.z8530", &z8530) != EOK) + return -1; + if (!z8530) + return -1; + + sysarg_t kaddr; + if (sysinfo_get_value("kbd.address.kernel", &kaddr) != EOK) + return -1; + + sysarg_t inr; + if (sysinfo_get_value("kbd.inr", &inr) != EOK) + return -1; + + z8530_cmds[0].addr = (void *) kaddr + CHAN_A_STATUS; + z8530_cmds[3].addr = (void *) kaddr + CHAN_A_DATA; + + async_set_interrupt_received(z8530_irq_handler); + register_irq(inr, device_assign_devno(), inr, &z8530_kbd); + + return 0; +} + +static void z8530_port_yield(void) +{ +} + +static void z8530_port_reclaim(void) +{ +} + +static void z8530_port_write(uint8_t data) +{ + (void) data; +} + +static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call) +{ + int scan_code = IPC_GET_ARG2(*call); + kbd_push_scancode(kbd_dev, scan_code); + + if (irc_service) + async_obsolete_msg_1(irc_phone, IRC_CLEAR_INTERRUPT, + IPC_GET_IMETHOD(*call)); +} + +/** @} + */