--- /dev/null
+/**
+ * The 15-410 reference kernel keyboard handling code.
+ *
+ * @author Steve Muckle <smuckle@andrew.cmu.edu>
+ *
+ * @author Edited by zra for the 2003-2004 season.
+ *
+ * @author Edited by mpa for spring 2004
+ *
+ * @author Rewritten by nwf for spring 2007.
+ *
+ * Functions for turning keyboard scancodes
+ * into chars.
+ *
+ * Notice that we use Scancode Set 1
+ */
+/*@{*/
+
+#include "keyhelp.h"
+
+/**
+ * This is returned as the upper bits of the result of
+ * process_scancode and may be interrogated more readily by
+ * the KH_ macros in keyhelp.h
+ *
+ * WARNING:
+ * The bottom bits overlap with the KH_RESULT_ codes in the
+ * return value.
+ */
+static short key_state = 0;
+
+ /** Currently processing a PRINT SCREEN BREAK sequence */
+#define KH_PRSCR_UP_SCAN 0x0008
+ /** Currently processing a PRINT SCREEN MAKE sequence */
+#define KH_PRSCR_DOWN_SCAN 0x0004
+ /** Currently processing a PAUSE/BREAK (MAKE) sequence */
+#define KH_PAUSE_SCAN 0x0002
+ /** Currently processing an extended sequence (E0 prefix) */
+#define KH_EXTENDED_SCAN 0x0001
+static short key_internal_state = 0;
+
+static int key_sequence = 0;
+
+#define KHS_SHIFT_CORE (key_state & (KH_LSHIFT_KEY | KH_RSHIFT_KEY))
+#define KHS_CTL_CORE (key_state & (KH_LCONTROL_KEY | KH_RCONTROL_KEY))
+
+#define KHS_SHIFT(c,r,s,u) \
+ { c = KHS_SHIFT_CORE ? s : u; r = u; }
+#define KHS_SHIFTCTL(c,r,cc,s,u) \
+ { c = KHS_CTL_CORE ? cc : (KHS_SHIFT_CORE ? s : u); r = u; }
+#define KHS_SHIFTCAPSCTL(c,r,cc,s,u) \
+ { c = KHS_CTL_CORE ? cc : (((KHS_SHIFT_CORE || (key_state & KH_CAPS_LOCK)) && \
+ !(KHS_SHIFT_CORE && (key_state & KH_CAPS_LOCK))) ? s : u) ; r = u; }
+
+/**
+ * This function performs the mapping
+ * from simple scancodes to chars.
+ *
+ * @param scancode a simple scancode.
+ * @param pressed 0 if released, nonzero if pressed.
+ *
+ * @return A partially constructed kh_type.
+ */
+static kh_type
+process_simple_scan(int scancode, int pressed)
+{
+ unsigned char code = 0x80;
+ unsigned char rcode = 0x80;
+ kh_type res = 0;
+
+ switch(scancode & 0x7F)
+ {
+ case 0x1:
+ /* Escape key. */
+ rcode = code = 0x1B;
+ break;
+ case 0x2:
+ /* 1 or ! */
+ KHS_SHIFT(code, rcode, '!', '1');
+ break;
+ case 0x3:
+ /* 2 or @ */
+ KHS_SHIFTCTL(code, rcode, 0x00, '@', '2');
+ break;
+ case 0x4:
+ /* 3 or # */
+ KHS_SHIFT(code, rcode, '#', '3');
+ break;
+ case 0x5:
+ /* 4 or $ */
+ KHS_SHIFT(code, rcode, '$', '4');
+ break;
+ case 0x6:
+ /* 5 or % */
+ KHS_SHIFT(code, rcode, '%', '5');
+ break;
+ case 0x7:
+ /* 6 or ^ */
+ KHS_SHIFTCTL(code, rcode, 0x1E, '^', '6');
+ break;
+ case 0x8:
+ /* 7 or & */
+ KHS_SHIFT(code, rcode, '&', '7');
+ break;
+ case 0x9:
+ /* 8 or * */
+ KHS_SHIFT(code, rcode, '*', '8');
+ break;
+ case 0xA:
+ /* 9 or ( */
+ KHS_SHIFT(code, rcode, '(', '9');
+ break;
+ case 0xB:
+ /* 0 or ) */
+ KHS_SHIFT(code, rcode, ')', '0');
+ break;
+ case 0xC:
+ /* - or _ */
+ KHS_SHIFTCTL(code, rcode, 0x1F, '_', '-');
+ break;
+ case 0xD:
+ /* = or + */
+ KHS_SHIFT(code, rcode, '+', '=');
+ break;
+ case 0xE:
+ /* Backspace key. */
+ rcode = code = '\b';
+ break;
+ case 0xF:
+ /* Tab key. */
+ rcode = code = '\t';
+ break;
+ case 0x10:
+ /* q or Q. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x11, 'Q', 'q');
+ break;
+ case 0x11:
+ /* w or W. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x17, 'W', 'w');
+ break;
+ case 0x12:
+ /* e or E. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x05, 'E', 'e');
+ break;
+ case 0x13:
+ /* r or R. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x12, 'R', 'r');
+ break;
+ case 0x14:
+ /* t or T. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x14, 'T', 't');
+ break;
+ case 0x15:
+ /* y or Y. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x19, 'Y', 'y');
+ break;
+ case 0x16:
+ /* u or U. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x15, 'U', 'u');
+ break;
+ case 0x17:
+ /* i or I. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x09, 'I', 'i');
+ break;
+ case 0x18:
+ /* o or O. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0F, 'O', 'o');
+ break;
+ case 0x19:
+ /* p or P. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x10, 'P', 'p');
+ break;
+ case 0x1A:
+ /* [ or {. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x1B, '{', '[');
+ break;
+ case 0x1B:
+ /* ] or }. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x1D, '}', ']');
+ break;
+ case 0x1C:
+ /* Enter key. */
+ rcode=code='\n';
+ break;
+ case 0x1D:
+ if((key_internal_state & KH_PAUSE_SCAN) && (key_sequence == 0))
+ {
+ /* Stage 1 of a pause sequence */
+ key_sequence++;
+ return 0;
+ } else {
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ key_sequence = 0;
+ }
+ rcode=KHE_LCTL;
+ if(pressed)
+ key_state |= KH_LCONTROL_KEY;
+ else
+ key_state &= ~KH_LCONTROL_KEY;
+ break;
+ case 0x1E:
+ /* a or A. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x01, 'A', 'a');
+ break;
+ case 0x1F:
+ /* s or S. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x13, 'S', 's');
+ break;
+ case 0x20:
+ /* d or D. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x04, 'D', 'd');
+ break;
+ case 0x21:
+ /* f or F. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x06, 'F', 'f');
+ break;
+ case 0x22:
+ /* g or G. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x07, 'G', 'g');
+ break;
+ case 0x23:
+ /* h or H. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x08, 'H', 'h');
+ break;
+ case 0x24:
+ /* j or J. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0A, 'J', 'j');
+ break;
+ case 0x25:
+ /* k or K. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0B, 'K', 'k');
+ break;
+ case 0x26:
+ /* l or L. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0C, 'L', 'l');
+ break;
+ case 0x27:
+ /* ; or :. */
+ KHS_SHIFT(code, rcode, ':', ';');
+ break;
+ case 0x28:
+ /* ' or " */
+ KHS_SHIFT(code, rcode, '\"', '\'');
+ break;
+ case 0x29:
+ KHS_SHIFT(code, rcode, '~', '`');
+ break;
+ case 0x2A:
+ rcode = KHE_LSHIFT;
+ if(pressed)
+ key_state |= KH_LSHIFT_KEY;
+ else
+ key_state &= ~KH_LSHIFT_KEY;
+ break;
+ case 0x2B:
+ /* \ or |. */
+ KHS_SHIFTCTL(code, rcode, 0x1C, '|', '\\');
+ break;
+ case 0x2C:
+ /* z or Z. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x1A, 'Z', 'z');
+ break;
+ case 0x2D:
+ /* x or X. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x18, 'X', 'x');
+ break;
+ case 0x2E:
+ /* c or C. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x03, 'C', 'c');
+ break;
+ case 0x2F:
+ /* v or V. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x16, 'V', 'v');
+ break;
+ case 0x30:
+ /* b or B. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x02, 'B', 'b');
+ break;
+ case 0x31:
+ /* n or N. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0E, 'N', 'n');
+ break;
+ case 0x32:
+ /* m or M. */
+ KHS_SHIFTCAPSCTL(code, rcode, 0x0D, 'M', 'm');
+ break;
+ case 0x33:
+ /* , or <. */
+ KHS_SHIFT(code, rcode, '<', ',');
+ break;
+ case 0x34:
+ /* . or >. */
+ KHS_SHIFT(code, rcode, '>', '.');
+ break;
+ case 0x35:
+ /* / or ? */
+ KHS_SHIFT(code, rcode, '?', '/');
+ break;
+ case 0x36:
+ rcode = KHE_RSHIFT;
+ if(pressed)
+ key_state |= KH_RSHIFT_KEY;
+ else
+ key_state &= ~KH_RSHIFT_KEY;
+ break;
+ case 0x37:
+ /* NP * */
+ rcode = code = '*';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x38:
+ rcode = KHE_LALT;
+ if(pressed)
+ key_state |= KH_LALT_KEY;
+ else
+ key_state &= ~KH_LALT_KEY;
+ break;
+ case 0x39:
+ /* Space bar. */
+ rcode = code =' ';
+ break;
+ case 0x3A:
+ rcode = KHE_CAPSLOCK;
+ if(pressed)
+ {
+ if(key_state & KH_CAPS_LOCK)
+ key_state &= ~KH_CAPS_LOCK;
+ else
+ key_state |= KH_CAPS_LOCK;
+ }
+ break;
+ case 0x3B:
+ /* F1 key. */
+ rcode = code = KHE_F1;
+ break;
+ case 0x3C:
+ /* F2 key. */
+ rcode = code = KHE_F2;
+ break;
+ case 0x3D:
+ /* F3 key. */
+ rcode = code = KHE_F3;
+ break;
+ case 0x3E:
+ /* F4 key. */
+ rcode = code = KHE_F4;
+ break;
+ case 0x3F:
+ /* F5 key. */
+ rcode = code = KHE_F5;
+ break;
+ case 0x40:
+ /* F6 key. */
+ rcode = code = KHE_F6;
+ break;
+ case 0x41:
+ /* F7 key. */
+ rcode = code = KHE_F7;
+ break;
+ case 0x42:
+ /* F8 key. */
+ rcode = code = KHE_F8;
+ break;
+ case 0x43:
+ /* F9 key. */
+ rcode = code = KHE_F9;
+ break;
+ case 0x44:
+ /* F10 key. */
+ rcode = code = KHE_F10;
+ break;
+ case 0x45:
+ if((key_internal_state & KH_PAUSE_SCAN) && (key_sequence == 1))
+ {
+ /* Stage 2 of a pause sequence */
+ key_sequence++;
+ return 0;
+ } else {
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ key_sequence = 0;
+ }
+ rcode = KHE_NUMLOCK;
+ if(pressed)
+ {
+ if(key_state & KH_NUM_LOCK)
+ key_state &= ~KH_NUM_LOCK;
+ else
+ key_state |= KH_NUM_LOCK;
+ }
+ break;
+ case 0x47:
+ rcode = code = '7';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x48:
+ rcode = code = '8';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x49:
+ rcode = code = '9';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4A:
+ rcode = code = '-';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4B:
+ rcode = code = '4';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4C:
+ rcode = code = '5';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4D:
+ rcode = code = '6';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4E:
+ rcode = code = '+';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x4F:
+ rcode = code = '1';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x50:
+ rcode = code = '2';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x51:
+ rcode = code = '3';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x52:
+ rcode = code = '0';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x53:
+ rcode = code = '.';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x57:
+ /* F11 key. */
+ rcode = code = KHE_F11;
+ break;
+ case 0x58:
+ /* F12 key. */
+ rcode = code = KHE_F12;
+ break;
+ case 0xE1 & 0x7F:
+ if(!(key_internal_state & KH_PAUSE_SCAN))
+ {
+ /* Stage 0 of a pause sequence */
+ key_internal_state |= KH_PAUSE_SCAN;
+ key_sequence = 0;
+ return 0;
+ } else if ((key_internal_state & KH_PAUSE_SCAN) && (key_sequence == 2)) {
+ key_sequence++;
+ return 0;
+ } else {
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ key_sequence = 0;
+ }
+ /* FALLTHROUGH */
+ default:
+ rcode = code = KHE_UNDEFINED;
+ break;
+ }
+
+ if ( rcode != KHE_UNDEFINED && code != KHE_UNDEFINED )
+ res |= (KH_RESULT_HASDATA << KH_RMODS_SHIFT);
+ else
+ code = 0x00;
+
+ return res | (code << KH_CHAR_SHIFT)
+ | (rcode << KH_RAWCHAR_SHIFT)
+ | (KH_RESULT_HASRAW << KH_RMODS_SHIFT);
+}
+
+/**
+ * Processes extended scan codes. Notably, this includes
+ * the arrow keys as well as some of the more unusual keys
+ * on the keyboard.
+ *
+ * @param keypress the extended scancode.
+ * @param 0 if released. non-zero if pressed.
+ *
+ * @return A partially constructed kh_type.
+ */
+kh_type
+process_extended_scan(int keypress, int pressed)
+{
+ unsigned char code = 0x80;
+ unsigned char rcode = 0x80;
+ kh_type res = 0;
+
+ /* Intermediate states in multiple byte scancodes should return
+ * zero from this function, rather than returning a RESULT code.
+ */
+
+ switch(keypress & 0x7F)
+ {
+ case 0x1C:
+ /* NP '\n' */
+ rcode = code = '\n';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x1D:
+ /* Right control key */
+ rcode = KHE_RCTL;
+ if(pressed)
+ key_state |= KH_RCONTROL_KEY;
+ else
+ key_state &= ~KH_RCONTROL_KEY;
+ break;
+ case 0x2A:
+ /* Stage 0 of PRINT SCREEN MAKE and Stage 1 of PRINT SCREEN BREAK */
+ if(key_internal_state & KH_PRSCR_UP_SCAN)
+ {
+ rcode = code = KHE_PRINT_SCREEN;
+ key_internal_state &= ~KH_PRSCR_UP_SCAN;
+ } else if (!(key_internal_state & KH_PRSCR_UP_SCAN)) {
+ key_internal_state |= KH_PRSCR_DOWN_SCAN;
+ key_internal_state &= ~KH_EXTENDED_SCAN;
+ return 0;
+ } else {
+ rcode = code = KHE_UNDEFINED;
+ }
+ break;
+ case 0x35:
+ /* NP / */
+ rcode = code = '/';
+ res |= KH_RESULT_NUMPAD << KH_RMODS_SHIFT;
+ break;
+ case 0x37:
+ /* Stage 1 of PRINT SCREEN MAKE and Stage 0 of PRINT SCREEN BREAK */
+ if(key_internal_state & KH_PRSCR_DOWN_SCAN)
+ {
+ rcode = code = KHE_PRINT_SCREEN;
+ key_internal_state &= ~KH_PRSCR_DOWN_SCAN;
+ } else if (!(key_internal_state & KH_PRSCR_DOWN_SCAN)) {
+ key_internal_state |= KH_PRSCR_UP_SCAN;
+ key_internal_state &= ~KH_EXTENDED_SCAN;
+ return 0;
+ } else {
+ rcode = code = KHE_UNDEFINED;
+ }
+ break;
+ case 0x38:
+ /* Right alt key */
+ rcode = KHE_RALT;
+ if(pressed)
+ key_state |= KH_RALT_KEY;
+ else
+ key_state &= ~KH_RALT_KEY;
+ break;
+ case 0x48:
+ /* UP */
+ rcode = code=KHE_ARROW_UP;
+ break;
+ case 0x4b:
+ /* LEFT */
+ rcode = code=KHE_ARROW_LEFT;
+ break;
+ case 0x4d:
+ /* RIGHT */
+ rcode = code=KHE_ARROW_RIGHT;
+ break;
+ case 0x50:
+ /* DOWN */
+ rcode = code = KHE_ARROW_DOWN;
+ break;
+ case 0x53:
+ /* DEL */
+ rcode = code = 0x7F;
+ break;
+ default:
+ rcode = code = KHE_UNDEFINED;
+ break;
+ }
+
+ key_internal_state &= ~KH_EXTENDED_SCAN;
+
+ if ( rcode != KHE_UNDEFINED && code != KHE_UNDEFINED )
+ res |= (KH_RESULT_HASDATA << KH_RMODS_SHIFT);
+ else
+ code = 0x00;
+
+ return res | (code << KH_CHAR_SHIFT)
+ | (rcode << KH_RAWCHAR_SHIFT)
+ | (KH_RESULT_HASRAW << KH_RMODS_SHIFT);
+}
+
+ /** The entrypoint to the keyboard processing library.
+ *
+ * @param keypress A raw scancode as returned by the keyboard hardware.
+ * @return A kh_type indicating the keyboard modifier key states, result
+ * modifier bits, and potentially ASCII/410 Upper Code Plane
+ * translations.
+ */
+kh_type process_scancode(int keypress) {
+ kh_type res;
+ int pressed = !(keypress & 0x80);
+ int keycode = keypress & 0x7F;
+
+ if (key_internal_state & KH_EXTENDED_SCAN)
+ res = process_extended_scan(keycode, pressed);
+ else
+ {
+ switch(keypress & 0xFF)
+ {
+ case 0x9D:
+ if ((key_internal_state & KH_PAUSE_SCAN) && (key_sequence == 3))
+ {
+ key_sequence++;
+ return 0;
+ } else {
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ key_sequence = 0;
+ }
+ goto deflt;
+ case 0xC5:
+ if ((key_internal_state & KH_PAUSE_SCAN) && (key_sequence == 4))
+ {
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ /* Pause sequence completed */
+ res = (KHE_PAUSE << KH_CHAR_SHIFT)
+ | (KHE_PAUSE << KH_RAWCHAR_SHIFT)
+ | (KH_RESULT_HASDATA << KH_RMODS_SHIFT);
+ break;
+ }
+ key_internal_state &= ~KH_PAUSE_SCAN;
+ key_sequence = 0;
+ goto deflt;
+ case 0xE0:
+ key_internal_state |= KH_EXTENDED_SCAN;
+ /* Return no result for this intermediate state */
+ return key_state << KH_STATE_SHIFT;
+ default:
+deflt:
+ key_internal_state &= ~(KH_PRSCR_UP_SCAN | KH_PRSCR_DOWN_SCAN);
+ res = process_simple_scan(keycode, pressed);
+ }
+ }
+
+ if(pressed)
+ res |= KH_RESULT_MAKE << KH_RMODS_SHIFT;
+
+ res |= (key_state & KH_STATE_SMASK) << KH_STATE_SHIFT;
+
+ return res;
+}
+
+/*@}*/
git.joshuawise.com / netwatch.git / blobdiff