payloads/libpayload/curses/keyboard.c

   1 /*
   2  * This file is part of the libpayload project.
   3  *
   4  * Copyright (C) 2007 Uwe Hermann <uwe@hermann-uwe.de>
   5  * Copyright (C) 2008 Advanced Micro Devices, Inc.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 /*
  32  * This file handles reading keystrokes from serial and the console
  33  * and "cooking" them so that they are correct for curses.
  34  * Also, implement key related functions (mainly wgetch)
  35  *
  36  * TODO:
  37  * Actually cook the serial (handle special keys)
  38  */
  39
  40 #include <libpayload-config.h>
  41 #include <usb/usb.h>
  42 #include "local.h"
  43
  44 static int _halfdelay = 0;
  45
  46 /* ============== Serial ==================== */
  47
  48 #if IS_ENABLED(CONFIG_LP_SERIAL_CONSOLE)
  49 /* We treat serial like a vt100 terminal.  For now we
  50    do the cooking in here, but we should probably eventually
  51    pass it to dedicated vt100 code */
  52
  53 static int getkeyseq(char *buffer, int len, int max)
  54 {
  55         int i;
  56
  57         while (1) {
  58                 for(i = 0; i < 75; i++) {
  59                         if (serial_havechar())
  60                                 break;
  61                         mdelay(1);
  62                 }
  63
  64                 if (i == 75)
  65                         return len;
  66
  67                 buffer[len++] = serial_getchar();
  68                 if (len == max)
  69                         return len;
  70         }
  71 }
  72
  73 static struct {
  74         const char *seq;
  75         int key;
  76 } escape_codes[] = {
  77         { "[A", KEY_UP },
  78         { "[B", KEY_DOWN },
  79         { "[C", KEY_RIGHT },
  80         { "[D", KEY_LEFT },
  81         { "[F", KEY_END },
  82         { "[H", KEY_HOME },
  83         { "[2~", KEY_IC },
  84         { "[3~", KEY_DC },
  85         { "[5~", KEY_PPAGE },
  86         { "[6~", KEY_NPAGE },
  87         { "OP", KEY_F(1) },
  88         { "OQ", KEY_F(2) },
  89         { "OR", KEY_F(3) },
  90         { "OS", KEY_F(4) },
  91         { "[15~", KEY_F(5) },
  92         { "[17~", KEY_F(6) },
  93         { "[18~", KEY_F(7) },
  94         { "[19~", KEY_F(8) },
  95         { "[20~", KEY_F(9) },
  96         { "[21~", KEY_F(10) },
  97         { "[23~", KEY_F(11) },
  98         { "[24~", KEY_F(12) },
  99         { NULL },
 100 };
 101
 102 static int handle_escape(void)
 103 {
 104         char buffer[5];
 105         int len = getkeyseq(buffer, 0, sizeof(buffer));
 106         int i, t;
 107
 108         if (len == 0)
 109                 return 27;
 110
 111         for(i = 0; escape_codes[i].seq != NULL; i++) {
 112                 const char *p = escape_codes[i].seq;
 113
 114                 for(t = 0; t < len; t++) {
 115                         if (!*p || *p != buffer[t])
 116                                 break;
 117                         p++;
 118                 }
 119
 120                 if (t == len)
 121                         return escape_codes[i].key;
 122         }
 123
 124         return 0;
 125 }
 126
 127 static int cook_serial(unsigned char ch)
 128 {
 129         switch(ch) {
 130         case 8:
 131                 return KEY_BACKSPACE;
 132
 133         case 13:
 134                 return KEY_ENTER;
 135
 136         case 27:
 137                 return handle_escape();
 138
 139         default:
 140                 return ch;
 141         }
 142 }
 143 #endif
 144
 145 /* ================ Keyboard ================ */
 146
 147 static int curses_getchar(int _delay)
 148 {
 149 #if IS_ENABLED(CONFIG_LP_USB_HID) || IS_ENABLED(CONFIG_LP_PC_KEYBOARD) || \
 150         IS_ENABLED(CONFIG_LP_SERIAL_CONSOLE)
 151         unsigned short c;
 152 #endif
 153
 154         do {
 155 #if IS_ENABLED(CONFIG_LP_USB_HID)
 156                 usb_poll();
 157                 if ((curses_flags & F_ENABLE_CONSOLE) &&
 158                     usbhid_havechar()) {
 159                         c = usbhid_getchar();
 160                         if (c != 0) return c;
 161                 }
 162 #endif
 163 #if IS_ENABLED(CONFIG_LP_PC_KEYBOARD)
 164                 if ((curses_flags & F_ENABLE_CONSOLE) &&
 165                     keyboard_havechar()) {
 166                         c = keyboard_getchar();
 167                         if (c != 0) return c;
 168                 }
 169 #endif
 170
 171 #if IS_ENABLED(CONFIG_LP_SERIAL_CONSOLE)
 172                 if ((curses_flags & F_ENABLE_SERIAL) &&
 173                     serial_havechar()) {
 174                         c = serial_getchar();
 175                         return cook_serial(c);
 176                 }
 177 #endif
 178
 179                 if (_delay == 0) {
 180                         break;
 181                 } else if (_delay >= 10) {
 182                         mdelay(10);
 183                         _delay -= 10;
 184                 } else if (_delay > 0) {
 185                         mdelay(_delay);
 186                         _delay = 0;
 187                 }
 188         } while (1);
 189
 190         return ERR;
 191 }
 192
 193 /* === Public functions === */
 194
 195 int wgetch(WINDOW *win)
 196 {
 197         int _delay = -1;
 198
 199         if (_halfdelay)
 200                 _delay = _halfdelay;
 201         else
 202                 _delay = win->_delay;
 203
 204         return curses_getchar(_delay);
 205 }
 206
 207 int nodelay(WINDOW *win, NCURSES_BOOL flag)
 208 {
 209         win->_delay = flag ? 0 : -1;
 210         return 0;
 211 }
 212
 213 int halfdelay(int tenths)
 214 {
 215         if (tenths > 255)
 216                 return ERR;
 217
 218         _halfdelay = tenths;
 219         return 0;
 220 }
 221
 222 int nocbreak(void)
 223 {
 224         /* Remove half delay timeout. */
 225         _halfdelay = 0;
 226         return 0;
 227 }
 228
 229 #if IS_ENABLED(CONFIG_LP_VGA_VIDEO_CONSOLE)
 230 void curses_enable_vga(int state)
 231 {
 232         if (state)
 233                 curses_flags |= F_ENABLE_CONSOLE;
 234         else
 235                 curses_flags &= ~F_ENABLE_CONSOLE;
 236 }
 237
 238 int curses_vga_enabled(void)
 239 {
 240         return (curses_flags & F_ENABLE_CONSOLE) != 0;
 241 }
 242 #else
 243 void curses_enable_vga(int state) { }
 244 int curses_vga_enabled(void) { return 0; }
 245 #endif
 246
 247 #if IS_ENABLED(CONFIG_LP_SERIAL_CONSOLE)
 248 void curses_enable_serial(int state)
 249 {
 250         if (state)
 251                 curses_flags |= F_ENABLE_SERIAL;
 252         else
 253                 curses_flags &= ~F_ENABLE_SERIAL;
 254 }
 255
 256 int curses_serial_enabled(void)
 257 {
 258         return (curses_flags & F_ENABLE_SERIAL) != 0;
 259 }
 260
 261 #else
 262 void curses_enable_serial(int state) { }
 263 int curses_serial_enabled(void) { return 0; }
 264 #endif