MdeModulePkg/Bus/Usb/UsbKbDxe/KeyBoard.c

   1 /** @file
   2
   3   Helper functions for USB Keyboard Driver.
   4
   5 Copyright (c) 2004 - 2008, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "KeyBoard.h"
  17 #include <Library/UsbLib.h>
  18
  19 //
  20 // Static English keyboard layout
  21 // Format:<efi key>, <unicode without shift>, <unicode with shift>, <Modifier>, <AffectedAttribute>
  22 //
  23 UINT8 KeyboardLayoutTable[USB_KEYCODE_MAX_MAKE + 8][5] = {
  24   {EfiKeyC1,         'a',      'A',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x04
  25   {EfiKeyB5,         'b',      'B',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x05
  26   {EfiKeyB3,         'c',      'C',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x06
  27   {EfiKeyC3,         'd',      'D',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x07
  28   {EfiKeyD3,         'e',      'E',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x08
  29   {EfiKeyC4,         'f',      'F',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x09
  30   {EfiKeyC5,         'g',      'G',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0A
  31   {EfiKeyC6,         'h',      'H',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0B
  32   {EfiKeyD8,         'i',      'I',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0C
  33   {EfiKeyC7,         'j',      'J',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0D
  34   {EfiKeyC8,         'k',      'K',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0E
  35   {EfiKeyC9,         'l',      'L',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x0F
  36   {EfiKeyB7,         'm',      'M',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x10
  37   {EfiKeyB6,         'n',      'N',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x11
  38   {EfiKeyD9,         'o',      'O',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x12
  39   {EfiKeyD10,        'p',      'P',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x13
  40   {EfiKeyD1,         'q',      'Q',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x14
  41   {EfiKeyD4,         'r',      'R',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x15
  42   {EfiKeyC2,         's',      'S',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x16
  43   {EfiKeyD5,         't',      'T',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x17
  44   {EfiKeyD7,         'u',      'U',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x18
  45   {EfiKeyB4,         'v',      'V',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x19
  46   {EfiKeyD2,         'w',      'W',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x1A
  47   {EfiKeyB2,         'x',      'X',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x1B
  48   {EfiKeyD6,         'y',      'Y',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x1C
  49   {EfiKeyB1,         'z',      'Z',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},   // 0x1D
  50   {EfiKeyE1,         '1',      '!',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x1E
  51   {EfiKeyE2,         '2',      '@',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x1F
  52   {EfiKeyE3,         '3',      '#',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x20
  53   {EfiKeyE4,         '4',      '$',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x21
  54   {EfiKeyE5,         '5',      '%',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x22
  55   {EfiKeyE6,         '6',      '^',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x23
  56   {EfiKeyE7,         '7',      '&',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x24
  57   {EfiKeyE8,         '8',      '*',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x25
  58   {EfiKeyE9,         '9',      '(',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x26
  59   {EfiKeyE10,        '0',      ')',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x27
  60   {EfiKeyEnter,      0x0d,     0x0d,  EFI_NULL_MODIFIER,   0},                                // 0x28   Enter
  61   {EfiKeyEsc,        0x1b,     0x1b,  EFI_NULL_MODIFIER,   0},                                // 0x29   Esc
  62   {EfiKeyBackSpace,  0x08,     0x08,  EFI_NULL_MODIFIER,   0},                                // 0x2A   Backspace
  63   {EfiKeyTab,        0x09,     0x09,  EFI_NULL_MODIFIER,   0},                                // 0x2B   Tab
  64   {EfiKeySpaceBar,   ' ',      ' ',   EFI_NULL_MODIFIER,   0},                                // 0x2C   Spacebar
  65   {EfiKeyE11,        '-',      '_',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x2D
  66   {EfiKeyE12,        '=',      '+',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x2E
  67   {EfiKeyD11,        '[',      '{',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x2F
  68   {EfiKeyD12,        ']',      '}',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x30
  69   {EfiKeyD13,        '\\',     '|',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x31
  70   {EfiKeyC12,        '\\',     '|',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x32  Keyboard Non-US # and ~
  71   {EfiKeyC10,        ';',      ':',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x33
  72   {EfiKeyC11,        '\'',     '"',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x34
  73   {EfiKeyE0,         '`',      '~',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x35  Keyboard Grave Accent and Tlide
  74   {EfiKeyB8,         ',',      '<',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x36
  75   {EfiKeyB9,         '.',      '>',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x37
  76   {EfiKeyB10,        '/',      '?',   EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},   // 0x38
  77   {EfiKeyCapsLock,   0x00,     0x00,  EFI_CAPS_LOCK_MODIFIER,            0},                  // 0x39   CapsLock
  78   {EfiKeyF1,         0x00,     0x00,  EFI_FUNCTION_KEY_ONE_MODIFIER,     0},                  // 0x3A
  79   {EfiKeyF2,         0x00,     0x00,  EFI_FUNCTION_KEY_TWO_MODIFIER,     0},                  // 0x3B
  80   {EfiKeyF3,         0x00,     0x00,  EFI_FUNCTION_KEY_THREE_MODIFIER,   0},                  // 0x3C
  81   {EfiKeyF4,         0x00,     0x00,  EFI_FUNCTION_KEY_FOUR_MODIFIER,    0},                  // 0x3D
  82   {EfiKeyF5,         0x00,     0x00,  EFI_FUNCTION_KEY_FIVE_MODIFIER,    0},                  // 0x3E
  83   {EfiKeyF6,         0x00,     0x00,  EFI_FUNCTION_KEY_SIX_MODIFIER,     0},                  // 0x3F
  84   {EfiKeyF7,         0x00,     0x00,  EFI_FUNCTION_KEY_SEVEN_MODIFIER,   0},                  // 0x40
  85   {EfiKeyF8,         0x00,     0x00,  EFI_FUNCTION_KEY_EIGHT_MODIFIER,   0},                  // 0x41
  86   {EfiKeyF9,         0x00,     0x00,  EFI_FUNCTION_KEY_NINE_MODIFIER,    0},                  // 0x42
  87   {EfiKeyF10,        0x00,     0x00,  EFI_FUNCTION_KEY_TEN_MODIFIER,     0},                  // 0x43
  88   {EfiKeyF11,        0x00,     0x00,  EFI_FUNCTION_KEY_ELEVEN_MODIFIER,  0},                  // 0x44   F11
  89   {EfiKeyF12,        0x00,     0x00,  EFI_FUNCTION_KEY_TWELVE_MODIFIER,  0},                  // 0x45   F12
  90   {EfiKeyPrint,      0x00,     0x00,  EFI_PRINT_MODIFIER,                0},                  // 0x46   PrintScreen
  91   {EfiKeySLck,       0x00,     0x00,  EFI_SCROLL_LOCK_MODIFIER,          0},                  // 0x47   Scroll Lock
  92   {EfiKeyPause,      0x00,     0x00,  EFI_PAUSE_MODIFIER,                0},                  // 0x48   Pause
  93   {EfiKeyIns,        0x00,     0x00,  EFI_INSERT_MODIFIER,               0},                  // 0x49
  94   {EfiKeyHome,       0x00,     0x00,  EFI_HOME_MODIFIER,                 0},                  // 0x4A
  95   {EfiKeyPgUp,       0x00,     0x00,  EFI_PAGE_UP_MODIFIER,              0},                  // 0x4B
  96   {EfiKeyDel,        0x00,     0x00,  EFI_DELETE_MODIFIER,               0},                  // 0x4C
  97   {EfiKeyEnd,        0x00,     0x00,  EFI_END_MODIFIER,                  0},                  // 0x4D
  98   {EfiKeyPgDn,       0x00,     0x00,  EFI_PAGE_DOWN_MODIFIER,            0},                  // 0x4E
  99   {EfiKeyRightArrow, 0x00,     0x00,  EFI_RIGHT_ARROW_MODIFIER,          0},                  // 0x4F
 100   {EfiKeyLeftArrow,  0x00,     0x00,  EFI_LEFT_ARROW_MODIFIER,           0},                  // 0x50
 101   {EfiKeyDownArrow,  0x00,     0x00,  EFI_DOWN_ARROW_MODIFIER,           0},                  // 0x51
 102   {EfiKeyUpArrow,    0x00,     0x00,  EFI_UP_ARROW_MODIFIER,             0},                  // 0x52
 103   {EfiKeyNLck,       0x00,     0x00,  EFI_NUM_LOCK_MODIFIER,             0},                  // 0x53   NumLock
 104   {EfiKeySlash,      '/',      '/',   EFI_NULL_MODIFIER,                 0},                  // 0x54
 105   {EfiKeyAsterisk,   '*',      '*',   EFI_NULL_MODIFIER,                 0},                  // 0x55
 106   {EfiKeyMinus,      '-',      '-',   EFI_NULL_MODIFIER,                 0},                  // 0x56
 107   {EfiKeyPlus,       '+',      '+',   EFI_NULL_MODIFIER,                 0},                  // 0x57
 108   {EfiKeyEnter,      0x0d,     0x0d,  EFI_NULL_MODIFIER,                 0},                  // 0x58
 109   {EfiKeyOne,        '1',      '1',   EFI_END_MODIFIER,         EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x59
 110   {EfiKeyTwo,        '2',      '2',   EFI_DOWN_ARROW_MODIFIER,  EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5A
 111   {EfiKeyThree,      '3',      '3',   EFI_PAGE_DOWN_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5B
 112   {EfiKeyFour,       '4',      '4',   EFI_LEFT_ARROW_MODIFIER,  EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5C
 113   {EfiKeyFive,       '5',      '5',   EFI_NULL_MODIFIER,        EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5D
 114   {EfiKeySix,        '6',      '6',   EFI_RIGHT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5E
 115   {EfiKeySeven,      '7',      '7',   EFI_HOME_MODIFIER,        EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x5F
 116   {EfiKeyEight,      '8',      '8',   EFI_UP_ARROW_MODIFIER,    EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x60
 117   {EfiKeyNine,       '9',      '9',   EFI_PAGE_UP_MODIFIER,     EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x61
 118   {EfiKeyZero,       '0',      '0',   EFI_INSERT_MODIFIER,      EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x62
 119   {EfiKeyPeriod,     '.',      '.',   EFI_DELETE_MODIFIER,      EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},   // 0x63
 120   {EfiKeyB0,         '\\',     '|',   EFI_NULL_MODIFIER,        EFI_AFFECTED_BY_STANDARD_SHIFT}, // 0x64 Keyboard Non-US \ and |
 121   {EfiKeyA4,         0x00,     0x00,  EFI_MENU_MODIFIER,        0},                              // 0x65 Keyboard Application
 122
 123   {EfiKeyLCtrl,      0,        0,     EFI_LEFT_CONTROL_MODIFIER,    0},  // 0xe0
 124   {EfiKeyLShift,     0,        0,     EFI_LEFT_SHIFT_MODIFIER,      0},  // 0xe1
 125   {EfiKeyLAlt,       0,        0,     EFI_LEFT_ALT_MODIFIER,        0},  // 0xe2
 126   {EfiKeyA0,         0,        0,     EFI_LEFT_LOGO_MODIFIER,       0},  // 0xe3
 127   {EfiKeyRCtrl,      0,        0,     EFI_RIGHT_CONTROL_MODIFIER,   0},  // 0xe4
 128   {EfiKeyRShift,     0,        0,     EFI_RIGHT_SHIFT_MODIFIER,     0},  // 0xe5
 129   {EfiKeyA2,         0,        0,     EFI_RIGHT_ALT_MODIFIER,       0},  // 0xe6
 130   {EfiKeyA3,         0,        0,     EFI_RIGHT_LOGO_MODIFIER,      0},  // 0xe7
 131 };
 132
 133 /**
 134   Initialize KeyConvertionTable by using default keyboard layout.
 135
 136   @param  UsbKeyboardDevice    The USB_KB_DEV instance.
 137   @retval None.
 138
 139 **/
 140 VOID
 141 EFIAPI
 142 LoadDefaultKeyboardLayout (
 143   IN USB_KB_DEV                 *UsbKeyboardDevice
 144   )
 145 {
 146   UINTN               Index;
 147   EFI_KEY_DESCRIPTOR  *KeyDescriptor;
 148
 149   //
 150   // Construct KeyConvertionTable by default keyboard layout
 151   //
 152   KeyDescriptor = &UsbKeyboardDevice->KeyConvertionTable[0];
 153
 154   for (Index = 0; Index < (USB_KEYCODE_MAX_MAKE + 8); Index++) {
 155     KeyDescriptor->Key                 = (EFI_KEY) KeyboardLayoutTable[Index][0];
 156     KeyDescriptor->Unicode             = KeyboardLayoutTable[Index][1];
 157     KeyDescriptor->ShiftedUnicode      = KeyboardLayoutTable[Index][2];
 158     KeyDescriptor->AltGrUnicode        = 0;
 159     KeyDescriptor->ShiftedAltGrUnicode = 0;
 160     KeyDescriptor->Modifier            = KeyboardLayoutTable[Index][3];
 161     KeyDescriptor->AffectedAttribute   = KeyboardLayoutTable[Index][4];
 162
 163     KeyDescriptor++;
 164   }
 165 }
 166
 167 //
 168 // EFI_KEY to USB Scan Code convertion table
 169 //
 170 UINT8 UsbScanCodeConvertionTable[] = {
 171   0xe0,  //  EfiKeyLCtrl
 172   0xe3,  //  EfiKeyA0
 173   0xe2,  //  EfiKeyLAlt
 174   0x2c,  //  EfiKeySpaceBar
 175   0xe6,  //  EfiKeyA2
 176   0xe7,  //  EfiKeyA3
 177   0x65,  //  EfiKeyA4
 178   0xe4,  //  EfiKeyRCtrl
 179   0x50,  //  EfiKeyLeftArrow
 180   0x51,  //  EfiKeyDownArrow
 181   0x4F,  //  EfiKeyRightArrow
 182   0x62,  //  EfiKeyZero
 183   0x63,  //  EfiKeyPeriod
 184   0x28,  //  EfiKeyEnter
 185   0xe1,  //  EfiKeyLShift
 186   0x64,  //  EfiKeyB0
 187   0x1D,  //  EfiKeyB1
 188   0x1B,  //  EfiKeyB2
 189   0x06,  //  EfiKeyB3
 190   0x19,  //  EfiKeyB4
 191   0x05,  //  EfiKeyB5
 192   0x11,  //  EfiKeyB6
 193   0x10,  //  EfiKeyB7
 194   0x36,  //  EfiKeyB8
 195   0x37,  //  EfiKeyB9
 196   0x38,  //  EfiKeyB10
 197   0xe5,  //  EfiKeyRShift
 198   0x52,  //  EfiKeyUpArrow
 199   0x59,  //  EfiKeyOne
 200   0x5A,  //  EfiKeyTwo
 201   0x5B,  //  EfiKeyThree
 202   0x39,  //  EfiKeyCapsLock
 203   0x04,  //  EfiKeyC1
 204   0x16,  //  EfiKeyC2
 205   0x07,  //  EfiKeyC3
 206   0x09,  //  EfiKeyC4
 207   0x0A,  //  EfiKeyC5
 208   0x0B,  //  EfiKeyC6
 209   0x0D,  //  EfiKeyC7
 210   0x0E,  //  EfiKeyC8
 211   0x0F,  //  EfiKeyC9
 212   0x33,  //  EfiKeyC10
 213   0x34,  //  EfiKeyC11
 214   0x32,  //  EfiKeyC12
 215   0x5C,  //  EfiKeyFour
 216   0x5D,  //  EfiKeyFive
 217   0x5E,  //  EfiKeySix
 218   0x57,  //  EfiKeyPlus
 219   0x2B,  //  EfiKeyTab
 220   0x14,  //  EfiKeyD1
 221   0x1A,  //  EfiKeyD2
 222   0x08,  //  EfiKeyD3
 223   0x15,  //  EfiKeyD4
 224   0x17,  //  EfiKeyD5
 225   0x1C,  //  EfiKeyD6
 226   0x18,  //  EfiKeyD7
 227   0x0C,  //  EfiKeyD8
 228   0x12,  //  EfiKeyD9
 229   0x13,  //  EfiKeyD10
 230   0x2F,  //  EfiKeyD11
 231   0x30,  //  EfiKeyD12
 232   0x31,  //  EfiKeyD13
 233   0x4C,  //  EfiKeyDel
 234   0x4D,  //  EfiKeyEnd
 235   0x4E,  //  EfiKeyPgDn
 236   0x5F,  //  EfiKeySeven
 237   0x60,  //  EfiKeyEight
 238   0x61,  //  EfiKeyNine
 239   0x35,  //  EfiKeyE0
 240   0x1E,  //  EfiKeyE1
 241   0x1F,  //  EfiKeyE2
 242   0x20,  //  EfiKeyE3
 243   0x21,  //  EfiKeyE4
 244   0x22,  //  EfiKeyE5
 245   0x23,  //  EfiKeyE6
 246   0x24,  //  EfiKeyE7
 247   0x25,  //  EfiKeyE8
 248   0x26,  //  EfiKeyE9
 249   0x27,  //  EfiKeyE10
 250   0x2D,  //  EfiKeyE11
 251   0x2E,  //  EfiKeyE12
 252   0x2A,  //  EfiKeyBackSpace
 253   0x49,  //  EfiKeyIns
 254   0x4A,  //  EfiKeyHome
 255   0x4B,  //  EfiKeyPgUp
 256   0x53,  //  EfiKeyNLck
 257   0x54,  //  EfiKeySlash
 258   0x55,  //  EfiKeyAsterisk
 259   0x56,  //  EfiKeyMinus
 260   0x29,  //  EfiKeyEsc
 261   0x3A,  //  EfiKeyF1
 262   0x3B,  //  EfiKeyF2
 263   0x3C,  //  EfiKeyF3
 264   0x3D,  //  EfiKeyF4
 265   0x3E,  //  EfiKeyF5
 266   0x3F,  //  EfiKeyF6
 267   0x40,  //  EfiKeyF7
 268   0x41,  //  EfiKeyF8
 269   0x42,  //  EfiKeyF9
 270   0x43,  //  EfiKeyF10
 271   0x44,  //  EfiKeyF11
 272   0x45,  //  EfiKeyF12
 273   0x46,  //  EfiKeyPrint
 274   0x47,  //  EfiKeySLck
 275   0x48   //  EfiKeyPause
 276 };
 277
 278 //
 279 // Keyboard Layout Modifier to EFI Scan Code convertion table
 280 //
 281 UINT8 EfiScanCodeConvertionTable[] = {
 282   SCAN_NULL,       // EFI_NULL_MODIFIER
 283   SCAN_NULL,       // EFI_LEFT_CONTROL_MODIFIER
 284   SCAN_NULL,       // EFI_RIGHT_CONTROL_MODIFIER
 285   SCAN_NULL,       // EFI_LEFT_ALT_MODIFIER
 286   SCAN_NULL,       // EFI_RIGHT_ALT_MODIFIER
 287   SCAN_NULL,       // EFI_ALT_GR_MODIFIER
 288   SCAN_INSERT,     // EFI_INSERT_MODIFIER
 289   SCAN_DELETE,     // EFI_DELETE_MODIFIER
 290   SCAN_PAGE_DOWN,  // EFI_PAGE_DOWN_MODIFIER
 291   SCAN_PAGE_UP,    // EFI_PAGE_UP_MODIFIER
 292   SCAN_HOME,       // EFI_HOME_MODIFIER
 293   SCAN_END,        // EFI_END_MODIFIER
 294   SCAN_NULL,       // EFI_LEFT_SHIFT_MODIFIER
 295   SCAN_NULL,       // EFI_RIGHT_SHIFT_MODIFIER
 296   SCAN_NULL,       // EFI_CAPS_LOCK_MODIFIER
 297   SCAN_NULL,       // EFI_NUM_LOCK_MODIFIER
 298   SCAN_LEFT,       // EFI_LEFT_ARROW_MODIFIER
 299   SCAN_RIGHT,      // EFI_RIGHT_ARROW_MODIFIER
 300   SCAN_DOWN,       // EFI_DOWN_ARROW_MODIFIER
 301   SCAN_UP,         // EFI_UP_ARROW_MODIFIER
 302   SCAN_NULL,       // EFI_NS_KEY_MODIFIER
 303   SCAN_NULL,       // EFI_NS_KEY_DEPENDENCY_MODIFIER
 304   SCAN_F1,         // EFI_FUNCTION_KEY_ONE_MODIFIER
 305   SCAN_F2,         // EFI_FUNCTION_KEY_TWO_MODIFIER
 306   SCAN_F3,         // EFI_FUNCTION_KEY_THREE_MODIFIER
 307   SCAN_F4,         // EFI_FUNCTION_KEY_FOUR_MODIFIER
 308   SCAN_F5,         // EFI_FUNCTION_KEY_FIVE_MODIFIER
 309   SCAN_F6,         // EFI_FUNCTION_KEY_SIX_MODIFIER
 310   SCAN_F7,         // EFI_FUNCTION_KEY_SEVEN_MODIFIER
 311   SCAN_F8,         // EFI_FUNCTION_KEY_EIGHT_MODIFIER
 312   SCAN_F9,         // EFI_FUNCTION_KEY_NINE_MODIFIER
 313   SCAN_F10,        // EFI_FUNCTION_KEY_TEN_MODIFIER
 314   SCAN_F11,        // EFI_FUNCTION_KEY_ELEVEN_MODIFIER
 315   SCAN_F12,        // EFI_FUNCTION_KEY_TWELVE_MODIFIER
 316 };
 317
 318 EFI_GUID  mKeyboardLayoutEventGuid = EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID;
 319
 320
 321 KB_MODIFIER  KB_Mod[8] = {
 322   { MOD_CONTROL_L,  0xe0 }, // 11100000
 323   { MOD_CONTROL_R,  0xe4 }, // 11100100
 324   { MOD_SHIFT_L,    0xe1 }, // 11100001
 325   { MOD_SHIFT_R,    0xe5 }, // 11100101
 326   { MOD_ALT_L,      0xe2 }, // 11100010
 327   { MOD_ALT_R,      0xe6 }, // 11100110
 328   { MOD_WIN_L,      0xe3 }, // 11100011
 329   { MOD_WIN_R,      0xe7 }, // 11100111
 330 };
 331
 332
 333
 334 /**
 335   Uses USB I/O to check whether the device is a USB Keyboard device.
 336
 337   @param  UsbIo    Points to a USB I/O protocol instance.
 338   @retval None
 339
 340 **/
 341 BOOLEAN
 342 EFIAPI
 343 IsUSBKeyboard (
 344   IN  EFI_USB_IO_PROTOCOL       *UsbIo
 345   )
 346 {
 347   EFI_STATUS                    Status;
 348   EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDescriptor;
 349
 350   //
 351   // Get the Default interface descriptor, currently we
 352   // assume it is interface 1
 353   //
 354   Status = UsbIo->UsbGetInterfaceDescriptor (
 355                     UsbIo,
 356                     &InterfaceDescriptor
 357                     );
 358
 359   if (EFI_ERROR (Status)) {
 360     return FALSE;
 361   }
 362
 363   if (InterfaceDescriptor.InterfaceClass == CLASS_HID &&
 364       InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT &&
 365       InterfaceDescriptor.InterfaceProtocol == PROTOCOL_KEYBOARD
 366       ) {
 367
 368     return TRUE;
 369   }
 370
 371   return FALSE;
 372 }
 373
 374 /**
 375   Get current keyboard layout from HII database.
 376
 377   @retval Pointer to EFI_HII_KEYBOARD_LAYOUT.
 378
 379 **/
 380 EFI_HII_KEYBOARD_LAYOUT *
 381 EFIAPI
 382 GetCurrentKeyboardLayout (
 383   VOID
 384   )
 385 {
 386   EFI_STATUS                Status;
 387   EFI_HII_DATABASE_PROTOCOL *HiiDatabase;
 388   EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;
 389   UINT16                    Length;
 390
 391   //
 392   // Locate Hii database protocol
 393   //
 394   Status = gBS->LocateProtocol (
 395                   &gEfiHiiDatabaseProtocolGuid,
 396                   NULL,
 397                   (VOID **) &HiiDatabase
 398                   );
 399   if (EFI_ERROR (Status)) {
 400     return NULL;
 401   }
 402
 403   //
 404   // Get current keyboard layout from HII database
 405   //
 406   Length = 0;
 407   KeyboardLayout = NULL;
 408   Status = HiiDatabase->GetKeyboardLayout (
 409                           HiiDatabase,
 410                           NULL,
 411                           &Length,
 412                           KeyboardLayout
 413                           );
 414   if (Status == EFI_BUFFER_TOO_SMALL) {
 415     KeyboardLayout = AllocatePool (Length);
 416     ASSERT (KeyboardLayout != NULL);
 417
 418     Status = HiiDatabase->GetKeyboardLayout (
 419                             HiiDatabase,
 420                             NULL,
 421                             &Length,
 422                             KeyboardLayout
 423                             );
 424     if (EFI_ERROR (Status)) {
 425       gBS->FreePool (KeyboardLayout);
 426       KeyboardLayout = NULL;
 427     }
 428   }
 429
 430   return KeyboardLayout;
 431 }
 432
 433 /**
 434   Find Key Descriptor in KeyConvertionTable given its scan code.
 435
 436   @param  UsbKeyboardDevice   The USB_KB_DEV instance.
 437   @param  ScanCode            USB scan code.
 438
 439   @return The Key descriptor in KeyConvertionTable.
 440
 441 **/
 442 EFI_KEY_DESCRIPTOR *
 443 EFIAPI
 444 GetKeyDescriptor (
 445   IN USB_KB_DEV        *UsbKeyboardDevice,
 446   IN UINT8             ScanCode
 447   )
 448 {
 449   UINT8  Index;
 450
 451   if (((ScanCode > 0x65) && (ScanCode < 0xe0)) || (ScanCode > 0xe7)) {
 452     return NULL;
 453   }
 454
 455   if (ScanCode <= 0x65) {
 456     Index = (UINT8) (ScanCode - 4);
 457   } else {
 458     Index = (UINT8) (ScanCode - 0xe0 + USB_KEYCODE_MAX_MAKE);
 459   }
 460
 461   return &UsbKeyboardDevice->KeyConvertionTable[Index];
 462 }
 463
 464 /**
 465   Find Non-Spacing key for given KeyDescriptor.
 466
 467   @param  UsbKeyboardDevice    The USB_KB_DEV instance.
 468   @param  KeyDescriptor        Key descriptor.
 469
 470   @retval NULL                 Key list is empty.
 471   @return Other                The Non-Spacing key.
 472
 473 **/
 474 USB_NS_KEY *
 475 EFIAPI
 476 FindUsbNsKey (
 477   IN USB_KB_DEV          *UsbKeyboardDevice,
 478   IN EFI_KEY_DESCRIPTOR  *KeyDescriptor
 479   )
 480 {
 481   LIST_ENTRY      *Link;
 482   USB_NS_KEY      *UsbNsKey;
 483
 484   Link = GetFirstNode (&UsbKeyboardDevice->NsKeyList);
 485   while (!IsNull (&UsbKeyboardDevice->NsKeyList, Link)) {
 486     UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);
 487
 488     if (UsbNsKey->NsKey[0].Key == KeyDescriptor->Key) {
 489       return UsbNsKey;
 490     }
 491
 492     Link = GetNextNode (&UsbKeyboardDevice->NsKeyList, Link);
 493   }
 494
 495   return NULL;
 496 }
 497
 498 /**
 499   Find physical key definition for a given Key stroke.
 500
 501   @param  UsbNsKey          The Non-Spacing key information.
 502   @param  KeyDescriptor     The key stroke.
 503
 504   @return The physical key definition.
 505
 506 **/
 507 EFI_KEY_DESCRIPTOR *
 508 EFIAPI
 509 FindPhysicalKey (
 510   IN USB_NS_KEY          *UsbNsKey,
 511   IN EFI_KEY_DESCRIPTOR  *KeyDescriptor
 512   )
 513 {
 514   UINTN               Index;
 515   EFI_KEY_DESCRIPTOR  *PhysicalKey;
 516
 517   PhysicalKey = &UsbNsKey->NsKey[1];
 518   for (Index = 0; Index < UsbNsKey->KeyCount; Index++) {
 519     if (KeyDescriptor->Key == PhysicalKey->Key) {
 520       return PhysicalKey;
 521     }
 522
 523     PhysicalKey++;
 524   }
 525
 526   //
 527   // No children definition matched, return original key
 528   //
 529   return KeyDescriptor;
 530 }
 531
 532 /**
 533   The notification function for SET_KEYBOARD_LAYOUT_EVENT.
 534
 535   @param  Event           The instance of EFI_EVENT.
 536   @param  Context         passing parameter.
 537
 538 **/
 539 VOID
 540 EFIAPI
 541 SetKeyboardLayoutEvent (
 542   EFI_EVENT                  Event,
 543   VOID                       *Context
 544   )
 545 {
 546   USB_KB_DEV                *UsbKeyboardDevice;
 547   EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;
 548   EFI_KEY_DESCRIPTOR        TempKey;
 549   EFI_KEY_DESCRIPTOR        *KeyDescriptor;
 550   EFI_KEY_DESCRIPTOR        *TableEntry;
 551   EFI_KEY_DESCRIPTOR        *NsKey;
 552   USB_NS_KEY                *UsbNsKey;
 553   UINTN                     Index;
 554   UINTN                     Index2;
 555   UINTN                     KeyCount;
 556   UINT8                     ScanCode;
 557
 558   UsbKeyboardDevice = (USB_KB_DEV *) Context;
 559
 560   //
 561   // Try to get current Keyboard Layout from HII database
 562   //
 563   KeyboardLayout = GetCurrentKeyboardLayout ();
 564   if (KeyboardLayout == NULL) {
 565     return;
 566   }
 567
 568   //
 569   // Allocate resource for KeyConvertionTable
 570   //
 571   ReleaseKeyboardLayoutResources (UsbKeyboardDevice);
 572   UsbKeyboardDevice->KeyConvertionTable = AllocateZeroPool ((USB_KEYCODE_MAX_MAKE + 8) * sizeof (EFI_KEY_DESCRIPTOR));
 573   ASSERT (UsbKeyboardDevice->KeyConvertionTable != NULL);
 574
 575   KeyDescriptor = (EFI_KEY_DESCRIPTOR *) (((UINT8 *) KeyboardLayout) + sizeof (EFI_HII_KEYBOARD_LAYOUT));
 576   for (Index = 0; Index < KeyboardLayout->DescriptorCount; Index++) {
 577     //
 578     // Copy from HII keyboard layout package binary for alignment
 579     //
 580     CopyMem (&TempKey, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
 581
 582     //
 583     // Fill the key into KeyConvertionTable (which use USB Scan Code as index)
 584     //
 585     ScanCode = UsbScanCodeConvertionTable [(UINT8) (TempKey.Key)];
 586     TableEntry = GetKeyDescriptor (UsbKeyboardDevice, ScanCode);
 587     CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
 588
 589     if (TempKey.Modifier == EFI_NS_KEY_MODIFIER) {
 590       //
 591       // Non-spacing key
 592       //
 593       UsbNsKey = AllocatePool (sizeof (USB_NS_KEY));
 594       ASSERT (UsbNsKey != NULL);
 595
 596       //
 597       // Search for sequential children physical key definitions
 598       //
 599       KeyCount = 0;
 600       NsKey = KeyDescriptor + 1;
 601       for (Index2 = Index + 1; Index2 < KeyboardLayout->DescriptorCount; Index2++) {
 602         CopyMem (&TempKey, NsKey, sizeof (EFI_KEY_DESCRIPTOR));
 603         if (TempKey.Modifier & EFI_NS_KEY_DEPENDENCY_MODIFIER) {
 604           KeyCount++;
 605         } else {
 606           break;
 607         }
 608         NsKey++;
 609       }
 610
 611       UsbNsKey->Signature = USB_NS_KEY_SIGNATURE;
 612       UsbNsKey->KeyCount = KeyCount;
 613       UsbNsKey->NsKey = AllocateCopyPool (
 614                           (KeyCount + 1) * sizeof (EFI_KEY_DESCRIPTOR),
 615                           KeyDescriptor
 616                           );
 617       InsertTailList (&UsbKeyboardDevice->NsKeyList, &UsbNsKey->Link);
 618
 619       //
 620       // Skip over the child physical keys
 621       //
 622       Index += KeyCount;
 623       KeyDescriptor += KeyCount;
 624     }
 625
 626     KeyDescriptor++;
 627   }
 628
 629   //
 630   // There are two EfiKeyEnter, duplicate its Key Descriptor
 631   //
 632   TableEntry = GetKeyDescriptor (UsbKeyboardDevice, 0x58);
 633   KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, 0x28);
 634   CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
 635
 636   gBS->FreePool (KeyboardLayout);
 637 }
 638
 639 /**
 640   Destroy resources for Keyboard layout.
 641
 642   @param  UsbKeyboardDevice    The USB_KB_DEV instance.
 643
 644 **/
 645 VOID
 646 EFIAPI
 647 ReleaseKeyboardLayoutResources (
 648   IN USB_KB_DEV              *UsbKeyboardDevice
 649   )
 650 {
 651   USB_NS_KEY      *UsbNsKey;
 652   LIST_ENTRY      *Link;
 653
 654   SafeFreePool (UsbKeyboardDevice->KeyConvertionTable);
 655   UsbKeyboardDevice->KeyConvertionTable = NULL;
 656
 657   while (!IsListEmpty (&UsbKeyboardDevice->NsKeyList)) {
 658     Link = GetFirstNode (&UsbKeyboardDevice->NsKeyList);
 659     UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);
 660     RemoveEntryList (&UsbNsKey->Link);
 661
 662     gBS->FreePool (UsbNsKey->NsKey);
 663     gBS->FreePool (UsbNsKey);
 664   }
 665 }
 666
 667 /**
 668   Initialize USB Keyboard layout.
 669
 670   @param  UsbKeyboardDevice      The USB_KB_DEV instance.
 671
 672   @retval EFI_SUCCESS            Initialization Success.
 673   @retval Other                  Keyboard layout initial failed.
 674
 675 **/
 676 EFI_STATUS
 677 EFIAPI
 678 InitKeyboardLayout (
 679   IN USB_KB_DEV   *UsbKeyboardDevice
 680   )
 681 {
 682   EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;
 683   EFI_STATUS                Status;
 684
 685   UsbKeyboardDevice->KeyConvertionTable = AllocateZeroPool ((USB_KEYCODE_MAX_MAKE + 8) * sizeof (EFI_KEY_DESCRIPTOR));
 686   ASSERT (UsbKeyboardDevice->KeyConvertionTable != NULL);
 687
 688   InitializeListHead (&UsbKeyboardDevice->NsKeyList);
 689   UsbKeyboardDevice->CurrentNsKey = NULL;
 690   UsbKeyboardDevice->KeyboardLayoutEvent = NULL;
 691
 692   //
 693   // Register SET_KEYBOARD_LAYOUT_EVENT notification
 694   //
 695   Status = gBS->CreateEventEx (
 696                   EVT_NOTIFY_SIGNAL,
 697                   TPL_NOTIFY,
 698                   SetKeyboardLayoutEvent,
 699                   UsbKeyboardDevice,
 700                   &mKeyboardLayoutEventGuid,
 701                   &UsbKeyboardDevice->KeyboardLayoutEvent
 702                   );
 703   if (EFI_ERROR (Status)) {
 704     return Status;
 705   }
 706
 707   //
 708   // Try to get current keyboard layout from HII database
 709   //
 710   KeyboardLayout = GetCurrentKeyboardLayout ();
 711   if (KeyboardLayout != NULL) {
 712     //
 713     // Force to initialize the keyboard layout
 714     //
 715     gBS->SignalEvent (UsbKeyboardDevice->KeyboardLayoutEvent);
 716   } else {
 717     if (FeaturePcdGet (PcdDisableDefaultKeyboardLayoutInUsbKbDriver)) {
 718       return EFI_NOT_READY;
 719     } else {
 720
 721       //
 722       // Fail to get keyboard layout from HII database,
 723       // use default keyboard layout
 724       //
 725       LoadDefaultKeyboardLayout (UsbKeyboardDevice);
 726     }
 727   }
 728
 729   return EFI_SUCCESS;
 730 }
 731
 732
 733 /**
 734   Initialize USB Keyboard device and all private data structures.
 735
 736   @param  UsbKeyboardDevice  The USB_KB_DEV instance.
 737
 738   @retval EFI_SUCCESS        Initialization is successful.
 739   @retval EFI_DEVICE_ERROR   Configure hardware failed.
 740
 741 **/
 742 EFI_STATUS
 743 EFIAPI
 744 InitUSBKeyboard (
 745   IN USB_KB_DEV   *UsbKeyboardDevice
 746   )
 747 {
 748   UINT8               ConfigValue;
 749   UINT8               Protocol;
 750   UINT8               ReportId;
 751   UINT8               Duration;
 752   EFI_STATUS          Status;
 753   UINT32              TransferResult;
 754
 755   KbdReportStatusCode (
 756     UsbKeyboardDevice->DevicePath,
 757     EFI_PROGRESS_CODE,
 758     PcdGet32 (PcdStatusCodeValueKeyboardSelfTest)
 759     );
 760
 761   InitUSBKeyBuffer (&(UsbKeyboardDevice->KeyboardBuffer));
 762
 763   //
 764   // default configurations
 765   //
 766   ConfigValue = 0x01;
 767
 768   //
 769   // Uses default configuration to configure the USB Keyboard device.
 770   //
 771   Status = UsbSetConfiguration (
 772             UsbKeyboardDevice->UsbIo,
 773             (UINT16) ConfigValue,
 774             &TransferResult
 775             );
 776   if (EFI_ERROR (Status)) {
 777     //
 778     // If configuration could not be set here, it means
 779     // the keyboard interface has some errors and could
 780     // not be initialized
 781     //
 782     KbdReportStatusCode (
 783       UsbKeyboardDevice->DevicePath,
 784       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 785       PcdGet32 (PcdStatusCodeValueKeyboardInterfaceError)
 786       );
 787
 788     return EFI_DEVICE_ERROR;
 789   }
 790
 791   UsbGetProtocolRequest (
 792     UsbKeyboardDevice->UsbIo,
 793     UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
 794     &Protocol
 795     );
 796   //
 797   // Sets boot protocol for the USB Keyboard.
 798   // This driver only supports boot protocol.
 799   // !!BugBug: How about the device that does not support boot protocol?
 800   //
 801   if (Protocol != BOOT_PROTOCOL) {
 802     UsbSetProtocolRequest (
 803       UsbKeyboardDevice->UsbIo,
 804       UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
 805       BOOT_PROTOCOL
 806       );
 807   }
 808   //
 809   // the duration is indefinite, so the endpoint will inhibit reporting forever,
 810   // and only reporting when a change is detected in the report data.
 811   //
 812
 813   //
 814   // idle value for all report ID
 815   //
 816   ReportId = 0;
 817   //
 818   // idle forever until there is a key pressed and released.
 819   //
 820   Duration = 0;
 821   UsbSetIdleRequest (
 822     UsbKeyboardDevice->UsbIo,
 823     UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
 824     ReportId,
 825     Duration
 826     );
 827
 828   UsbKeyboardDevice->CtrlOn     = 0;
 829   UsbKeyboardDevice->AltOn      = 0;
 830   UsbKeyboardDevice->ShiftOn    = 0;
 831   UsbKeyboardDevice->NumLockOn  = 0;
 832   UsbKeyboardDevice->CapsOn     = 0;
 833   UsbKeyboardDevice->ScrollOn   = 0;
 834
 835   UsbKeyboardDevice->LeftCtrlOn   = 0;
 836   UsbKeyboardDevice->LeftAltOn    = 0;
 837   UsbKeyboardDevice->LeftShiftOn  = 0;
 838   UsbKeyboardDevice->LeftLogoOn   = 0;
 839   UsbKeyboardDevice->RightCtrlOn  = 0;
 840   UsbKeyboardDevice->RightAltOn   = 0;
 841   UsbKeyboardDevice->RightShiftOn = 0;
 842   UsbKeyboardDevice->RightLogoOn  = 0;
 843   UsbKeyboardDevice->MenuKeyOn    = 0;
 844   UsbKeyboardDevice->SysReqOn     = 0;
 845
 846   UsbKeyboardDevice->AltGrOn      = 0;
 847
 848   UsbKeyboardDevice->CurrentNsKey = NULL;
 849
 850   //
 851   // Sync the initial state of lights
 852   //
 853   SetKeyLED (UsbKeyboardDevice);
 854
 855   ZeroMem (UsbKeyboardDevice->LastKeyCodeArray, sizeof (UINT8) * 8);
 856
 857   //
 858   // Set a timer for repeat keys' generation.
 859   //
 860   if (UsbKeyboardDevice->RepeatTimer != NULL) {
 861     gBS->CloseEvent (UsbKeyboardDevice->RepeatTimer);
 862     UsbKeyboardDevice->RepeatTimer = 0;
 863   }
 864
 865   Status = gBS->CreateEvent (
 866                   EVT_TIMER | EVT_NOTIFY_SIGNAL,
 867                   TPL_NOTIFY,
 868                   USBKeyboardRepeatHandler,
 869                   UsbKeyboardDevice,
 870                   &UsbKeyboardDevice->RepeatTimer
 871                   );
 872
 873   if (UsbKeyboardDevice->DelayedRecoveryEvent != NULL) {
 874     gBS->CloseEvent (UsbKeyboardDevice->DelayedRecoveryEvent);
 875     UsbKeyboardDevice->DelayedRecoveryEvent = 0;
 876   }
 877
 878   Status = gBS->CreateEvent (
 879                   EVT_TIMER | EVT_NOTIFY_SIGNAL,
 880                   TPL_NOTIFY,
 881                   USBKeyboardRecoveryHandler,
 882                   UsbKeyboardDevice,
 883                   &UsbKeyboardDevice->DelayedRecoveryEvent
 884                   );
 885
 886   return EFI_SUCCESS;
 887 }
 888
 889
 890 /**
 891   Handler function for USB Keyboard's asynchronous interrupt transfer.
 892
 893   @param  Data             A pointer to a buffer that is filled with key data which is
 894                            retrieved via asynchronous interrupt transfer.
 895   @param  DataLength       Indicates the size of the data buffer.
 896   @param  Context          Pointing to USB_KB_DEV instance.
 897   @param  Result           Indicates the result of the asynchronous interrupt transfer.
 898
 899   @retval EFI_SUCCESS      Handler is successful.
 900   @retval EFI_DEVICE_ERROR Hardware Error
 901
 902 **/
 903 EFI_STATUS
 904 EFIAPI
 905 KeyboardHandler (
 906   IN  VOID          *Data,
 907   IN  UINTN         DataLength,
 908   IN  VOID          *Context,
 909   IN  UINT32        Result
 910   )
 911 {
 912   USB_KB_DEV          *UsbKeyboardDevice;
 913   EFI_USB_IO_PROTOCOL *UsbIo;
 914   UINT8               *CurKeyCodeBuffer;
 915   UINT8               *OldKeyCodeBuffer;
 916   UINT8               CurModifierMap;
 917   UINT8               OldModifierMap;
 918   UINT8               Index;
 919   UINT8               Index2;
 920   BOOLEAN             Down;
 921   BOOLEAN             KeyRelease;
 922   BOOLEAN             KeyPress;
 923   UINT8               SavedTail;
 924   USB_KEY             UsbKey;
 925   UINT8               NewRepeatKey;
 926   UINT32              UsbStatus;
 927   EFI_KEY_DESCRIPTOR  *KeyDescriptor;
 928
 929   ASSERT (Context);
 930
 931   NewRepeatKey      = 0;
 932   UsbKeyboardDevice = (USB_KB_DEV *) Context;
 933   UsbIo             = UsbKeyboardDevice->UsbIo;
 934
 935   //
 936   // Analyzes the Result and performs corresponding action.
 937   //
 938   if (Result != EFI_USB_NOERROR) {
 939     //
 940     // Some errors happen during the process
 941     //
 942     KbdReportStatusCode (
 943       UsbKeyboardDevice->DevicePath,
 944       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 945       PcdGet32 (PcdStatusCodeValueKeyboardInputError)
 946       );
 947
 948     //
 949     // stop the repeat key generation if any
 950     //
 951     UsbKeyboardDevice->RepeatKey = 0;
 952
 953     gBS->SetTimer (
 954           UsbKeyboardDevice->RepeatTimer,
 955           TimerCancel,
 956           USBKBD_REPEAT_RATE
 957           );
 958
 959     if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
 960       UsbClearEndpointHalt (
 961         UsbIo,
 962         UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
 963         &UsbStatus
 964         );
 965     }
 966
 967     //
 968     // Delete & Submit this interrupt again
 969     //
 970
 971     UsbIo->UsbAsyncInterruptTransfer (
 972                       UsbIo,
 973                       UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
 974                       FALSE,
 975                       0,
 976                       0,
 977                       NULL,
 978                       NULL
 979                       );
 980
 981     gBS->SetTimer (
 982           UsbKeyboardDevice->DelayedRecoveryEvent,
 983           TimerRelative,
 984           EFI_USB_INTERRUPT_DELAY
 985           );
 986
 987     return EFI_DEVICE_ERROR;
 988   }
 989
 990   if (DataLength == 0 || Data == NULL) {
 991     return EFI_SUCCESS;
 992   }
 993
 994   CurKeyCodeBuffer  = (UINT8 *) Data;
 995   OldKeyCodeBuffer  = UsbKeyboardDevice->LastKeyCodeArray;
 996
 997   //
 998   // checks for new key stroke.
 999   // if no new key got, return immediately.
1000   //
1001   for (Index = 0; Index < 8; Index++) {
1002     if (OldKeyCodeBuffer[Index] != CurKeyCodeBuffer[Index]) {
1003       break;
1004     }
1005   }
1006
1007   if (Index == 8) {
1008     return EFI_SUCCESS;
1009   }
1010
1011   //
1012   // Parse the modifier key
1013   //
1014   CurModifierMap  = CurKeyCodeBuffer[0];
1015   OldModifierMap  = OldKeyCodeBuffer[0];
1016
1017   //
1018   // handle modifier key's pressing or releasing situation.
1019   //
1020   for (Index = 0; Index < 8; Index++) {
1021
1022     if ((CurModifierMap & KB_Mod[Index].Mask) != (OldModifierMap & KB_Mod[Index].Mask)) {
1023       //
1024       // if current modifier key is up, then
1025       // CurModifierMap & KB_Mod[Index].Mask = 0;
1026       // otherwize it is a non-zero value.
1027       // Inserts the pressed modifier key into key buffer.
1028       //
1029       Down = (UINT8) (CurModifierMap & KB_Mod[Index].Mask);
1030       InsertKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), KB_Mod[Index].Key, Down);
1031     }
1032   }
1033
1034   //
1035   // handle normal key's releasing situation
1036   //
1037   KeyRelease = FALSE;
1038   for (Index = 2; Index < 8; Index++) {
1039
1040     if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index])) {
1041       continue;
1042     }
1043
1044     KeyRelease = TRUE;
1045     for (Index2 = 2; Index2 < 8; Index2++) {
1046
1047       if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index2])) {
1048         continue;
1049       }
1050
1051       if (OldKeyCodeBuffer[Index] == CurKeyCodeBuffer[Index2]) {
1052         KeyRelease = FALSE;
1053         break;
1054       }
1055     }
1056
1057     if (KeyRelease) {
1058       InsertKeyCode (
1059         &(UsbKeyboardDevice->KeyboardBuffer),
1060         OldKeyCodeBuffer[Index],
1061         0
1062         );
1063       //
1064       // the original reapeat key is released.
1065       //
1066       if (OldKeyCodeBuffer[Index] == UsbKeyboardDevice->RepeatKey) {
1067         UsbKeyboardDevice->RepeatKey = 0;
1068       }
1069     }
1070   }
1071
1072   //
1073   // original repeat key is released, cancel the repeat timer
1074   //
1075   if (UsbKeyboardDevice->RepeatKey == 0) {
1076     gBS->SetTimer (
1077           UsbKeyboardDevice->RepeatTimer,
1078           TimerCancel,
1079           USBKBD_REPEAT_RATE
1080           );
1081   }
1082
1083   //
1084   // handle normal key's pressing situation
1085   //
1086   KeyPress = FALSE;
1087   for (Index = 2; Index < 8; Index++) {
1088
1089     if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index])) {
1090       continue;
1091     }
1092
1093     KeyPress = TRUE;
1094     for (Index2 = 2; Index2 < 8; Index2++) {
1095
1096       if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index2])) {
1097         continue;
1098       }
1099
1100       if (CurKeyCodeBuffer[Index] == OldKeyCodeBuffer[Index2]) {
1101         KeyPress = FALSE;
1102         break;
1103       }
1104     }
1105
1106     if (KeyPress) {
1107       InsertKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), CurKeyCodeBuffer[Index], 1);
1108       //
1109       // NumLock pressed or CapsLock pressed
1110       //
1111       KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, CurKeyCodeBuffer[Index]);
1112       if (KeyDescriptor->Modifier == EFI_NUM_LOCK_MODIFIER || KeyDescriptor->Modifier == EFI_CAPS_LOCK_MODIFIER) {
1113         UsbKeyboardDevice->RepeatKey = 0;
1114       } else {
1115         NewRepeatKey = CurKeyCodeBuffer[Index];
1116         //
1117         // do not repeat the original repeated key
1118         //
1119         UsbKeyboardDevice->RepeatKey = 0;
1120       }
1121     }
1122   }
1123
1124   //
1125   // Update LastKeycodeArray[] buffer in the
1126   // Usb Keyboard Device data structure.
1127   //
1128   for (Index = 0; Index < 8; Index++) {
1129     UsbKeyboardDevice->LastKeyCodeArray[Index] = CurKeyCodeBuffer[Index];
1130   }
1131
1132   //
1133   // pre-process KeyboardBuffer, pop out the ctrl,alt,del key in sequence
1134   // and judge whether it will invoke reset event.
1135   //
1136   SavedTail = UsbKeyboardDevice->KeyboardBuffer.bTail;
1137   Index     = UsbKeyboardDevice->KeyboardBuffer.bHead;
1138   while (Index != SavedTail) {
1139     RemoveKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), &UsbKey);
1140
1141     KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, UsbKey.KeyCode);
1142
1143     switch (KeyDescriptor->Modifier) {
1144
1145     case EFI_LEFT_CONTROL_MODIFIER:
1146     case EFI_RIGHT_CONTROL_MODIFIER:
1147       if (UsbKey.Down != 0) {
1148         UsbKeyboardDevice->CtrlOn = 1;
1149       } else {
1150         UsbKeyboardDevice->CtrlOn = 0;
1151       }
1152       break;
1153
1154     case EFI_LEFT_ALT_MODIFIER:
1155     case EFI_RIGHT_ALT_MODIFIER:
1156       if (UsbKey.Down != 0) {
1157         UsbKeyboardDevice->AltOn = 1;
1158       } else {
1159         UsbKeyboardDevice->AltOn = 0;
1160       }
1161       break;
1162
1163     case EFI_ALT_GR_MODIFIER:
1164       if (UsbKey.Down != 0) {
1165         UsbKeyboardDevice->AltGrOn = 1;
1166       } else {
1167         UsbKeyboardDevice->AltGrOn = 0;
1168       }
1169       break;
1170
1171     //
1172     // Del Key Code
1173     //
1174     case EFI_DELETE_MODIFIER:
1175       if (UsbKey.Down != 0) {
1176         if ((UsbKeyboardDevice->CtrlOn != 0) && (UsbKeyboardDevice->AltOn != 0)) {
1177           gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
1178         }
1179       }
1180       break;
1181
1182     default:
1183       break;
1184     }
1185
1186     //
1187     // insert the key back to the buffer.
1188     // so the key sequence will not be destroyed.
1189     //
1190     InsertKeyCode (
1191       &(UsbKeyboardDevice->KeyboardBuffer),
1192       UsbKey.KeyCode,
1193       UsbKey.Down
1194       );
1195     Index = UsbKeyboardDevice->KeyboardBuffer.bHead;
1196
1197   }
1198   //
1199   // If have new key pressed, update the RepeatKey value, and set the
1200   // timer to repeate delay timer
1201   //
1202   if (NewRepeatKey != 0) {
1203     //
1204     // sets trigger time to "Repeat Delay Time",
1205     // to trigger the repeat timer when the key is hold long
1206     // enough time.
1207     //
1208     gBS->SetTimer (
1209           UsbKeyboardDevice->RepeatTimer,
1210           TimerRelative,
1211           USBKBD_REPEAT_DELAY
1212           );
1213     UsbKeyboardDevice->RepeatKey = NewRepeatKey;
1214   }
1215
1216   return EFI_SUCCESS;
1217 }
1218
1219
1220 /**
1221   Retrieves a key character after parsing the raw data in keyboard buffer.
1222
1223   @param  UsbKeyboardDevice    The USB_KB_DEV instance.
1224   @param  KeyChar              Points to the Key character after key parsing.
1225
1226   @retval EFI_SUCCESS          Parse key is successful.
1227   @retval EFI_NOT_READY        Device is not ready.
1228
1229 **/
1230 EFI_STATUS
1231 EFIAPI
1232 USBParseKey (
1233   IN OUT  USB_KB_DEV  *UsbKeyboardDevice,
1234   OUT     UINT8       *KeyChar
1235   )
1236 {
1237   USB_KEY             UsbKey;
1238   EFI_KEY_DESCRIPTOR  *KeyDescriptor;
1239
1240   *KeyChar = 0;
1241
1242   while (!IsUSBKeyboardBufferEmpty (&UsbKeyboardDevice->KeyboardBuffer)) {
1243     //
1244     // pops one raw data off.
1245     //
1246     RemoveKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), &UsbKey);
1247
1248     KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, UsbKey.KeyCode);
1249     if (UsbKey.Down == 0) {
1250       switch (KeyDescriptor->Modifier) {
1251
1252       //
1253       // CTRL release
1254       //
1255       case EFI_LEFT_CONTROL_MODIFIER:
1256         UsbKeyboardDevice->LeftCtrlOn = 0;
1257         UsbKeyboardDevice->CtrlOn = 0;
1258         break;
1259       case EFI_RIGHT_CONTROL_MODIFIER:
1260         UsbKeyboardDevice->RightCtrlOn = 0;
1261         UsbKeyboardDevice->CtrlOn = 0;
1262         break;
1263
1264       //
1265       // Shift release
1266       //
1267       case EFI_LEFT_SHIFT_MODIFIER:
1268         UsbKeyboardDevice->LeftShiftOn = 0;
1269         UsbKeyboardDevice->ShiftOn = 0;
1270         break;
1271       case EFI_RIGHT_SHIFT_MODIFIER:
1272         UsbKeyboardDevice->RightShiftOn = 0;
1273         UsbKeyboardDevice->ShiftOn = 0;
1274         break;
1275
1276       //
1277       // Alt release
1278       //
1279       case EFI_LEFT_ALT_MODIFIER:
1280         UsbKeyboardDevice->LeftAltOn = 0;
1281         UsbKeyboardDevice->AltOn = 0;
1282         break;
1283       case EFI_RIGHT_ALT_MODIFIER:
1284         UsbKeyboardDevice->RightAltOn = 0;
1285         UsbKeyboardDevice->AltOn = 0;
1286         break;
1287
1288       //
1289       // Left Logo release
1290       //
1291       case EFI_LEFT_LOGO_MODIFIER:
1292         UsbKeyboardDevice->LeftLogoOn = 0;
1293         break;
1294
1295       //
1296       // Right Logo release
1297       //
1298       case EFI_RIGHT_LOGO_MODIFIER:
1299         UsbKeyboardDevice->RightLogoOn = 0;
1300         break;
1301
1302       //
1303       // Menu key release
1304       //
1305       case EFI_MENU_MODIFIER:
1306         UsbKeyboardDevice->MenuKeyOn = 0;
1307         break;
1308
1309       //
1310       // SysReq release
1311       //
1312       case EFI_PRINT_MODIFIER:
1313       case EFI_SYS_REQUEST_MODIFIER:
1314         UsbKeyboardDevice->SysReqOn = 0;
1315         break;
1316
1317       //
1318       // AltGr release
1319       //
1320       case EFI_ALT_GR_MODIFIER:
1321         UsbKeyboardDevice->AltGrOn = 0;
1322         break;
1323
1324       default:
1325         break;
1326       }
1327
1328       continue;
1329     }
1330
1331     //
1332     // Analyzes key pressing situation
1333     //
1334     switch (KeyDescriptor->Modifier) {
1335
1336     //
1337     // CTRL press
1338     //
1339     case EFI_LEFT_CONTROL_MODIFIER:
1340       UsbKeyboardDevice->LeftCtrlOn = 1;
1341       UsbKeyboardDevice->CtrlOn = 1;
1342       continue;
1343       break;
1344     case EFI_RIGHT_CONTROL_MODIFIER:
1345       UsbKeyboardDevice->RightCtrlOn = 1;
1346       UsbKeyboardDevice->CtrlOn = 1;
1347       continue;
1348       break;
1349
1350     //
1351     // Shift press
1352     //
1353     case EFI_LEFT_SHIFT_MODIFIER:
1354       UsbKeyboardDevice->LeftShiftOn = 1;
1355       UsbKeyboardDevice->ShiftOn = 1;
1356       continue;
1357       break;
1358     case EFI_RIGHT_SHIFT_MODIFIER:
1359       UsbKeyboardDevice->RightShiftOn = 1;
1360       UsbKeyboardDevice->ShiftOn = 1;
1361       continue;
1362       break;
1363
1364     //
1365     // Alt press
1366     //
1367     case EFI_LEFT_ALT_MODIFIER:
1368       UsbKeyboardDevice->LeftAltOn = 1;
1369       UsbKeyboardDevice->AltOn = 1;
1370       continue;
1371       break;
1372     case EFI_RIGHT_ALT_MODIFIER:
1373       UsbKeyboardDevice->RightAltOn = 1;
1374       UsbKeyboardDevice->AltOn = 1;
1375       continue;
1376       break;
1377
1378     //
1379     // Left Logo press
1380     //
1381     case EFI_LEFT_LOGO_MODIFIER:
1382       UsbKeyboardDevice->LeftLogoOn = 1;
1383       break;
1384
1385     //
1386     // Right Logo press
1387     //
1388     case EFI_RIGHT_LOGO_MODIFIER:
1389       UsbKeyboardDevice->RightLogoOn = 1;
1390       break;
1391
1392     //
1393     // Menu key press
1394     //
1395     case EFI_MENU_MODIFIER:
1396       UsbKeyboardDevice->MenuKeyOn = 1;
1397       break;
1398
1399     //
1400     // SysReq press
1401     //
1402     case EFI_PRINT_MODIFIER:
1403     case EFI_SYS_REQUEST_MODIFIER:
1404       UsbKeyboardDevice->SysReqOn = 1;
1405       continue;
1406       break;
1407
1408     //
1409     // AltGr press
1410     //
1411     case EFI_ALT_GR_MODIFIER:
1412       UsbKeyboardDevice->AltGrOn = 1;
1413       break;
1414
1415     case EFI_NUM_LOCK_MODIFIER:
1416       UsbKeyboardDevice->NumLockOn ^= 1;
1417       //
1418       // Turn on the NumLock light on KB
1419       //
1420       SetKeyLED (UsbKeyboardDevice);
1421       continue;
1422       break;
1423
1424     case EFI_CAPS_LOCK_MODIFIER:
1425       UsbKeyboardDevice->CapsOn ^= 1;
1426       //
1427       // Turn on the CapsLock light on KB
1428       //
1429       SetKeyLED (UsbKeyboardDevice);
1430       continue;
1431       break;
1432
1433     case EFI_SCROLL_LOCK_MODIFIER:
1434       UsbKeyboardDevice->ScrollOn ^= 1;
1435       //
1436       // Turn on the ScrollLock light on KB
1437       //
1438       SetKeyLED (UsbKeyboardDevice);
1439       continue;
1440       break;
1441
1442     //
1443     // F11,F12,PrintScreen,Pause/Break
1444     // could not be retrieved via SimpleTxtInEx protocol
1445     //
1446     case EFI_FUNCTION_KEY_ELEVEN_MODIFIER:
1447     case EFI_FUNCTION_KEY_TWELVE_MODIFIER:
1448     case EFI_PAUSE_MODIFIER:
1449     case EFI_BREAK_MODIFIER:
1450       //
1451       // fall through
1452       //
1453       continue;
1454       break;
1455
1456     default:
1457       break;
1458     }
1459
1460     //
1461     // When encountered Del Key...
1462     //
1463     if (KeyDescriptor->Modifier == EFI_DELETE_MODIFIER) {
1464       if ((UsbKeyboardDevice->CtrlOn != 0) && (UsbKeyboardDevice->AltOn != 0)) {
1465         gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
1466       }
1467     }
1468
1469     *KeyChar = UsbKey.KeyCode;
1470     return EFI_SUCCESS;
1471   }
1472
1473   return EFI_NOT_READY;
1474 }
1475
1476
1477 /**
1478   Converts USB Keyboard code to EFI Scan Code.
1479
1480   @param  UsbKeyboardDevice    The USB_KB_DEV instance.
1481   @param  KeyChar              Indicates the key code that will be interpreted.
1482   @param  Key                  A pointer to a buffer that is filled in with
1483                                the keystroke information for the key that
1484                                was pressed.
1485
1486   @retval EFI_NOT_READY        Device is not ready
1487   @retval EFI_SUCCESS          Success.
1488
1489 **/
1490 EFI_STATUS
1491 EFIAPI
1492 USBKeyCodeToEFIScanCode (
1493   IN  USB_KB_DEV      *UsbKeyboardDevice,
1494   IN  UINT8           KeyChar,
1495   OUT EFI_INPUT_KEY   *Key
1496   )
1497 {
1498   UINT8               Index;
1499   EFI_KEY_DESCRIPTOR  *KeyDescriptor;
1500
1501   if (!USBKBD_VALID_KEYCODE (KeyChar)) {
1502     return EFI_NOT_READY;
1503   }
1504
1505   //
1506   // valid USB Key Code starts from 4
1507   //
1508   Index = (UINT8) (KeyChar - 4);
1509
1510   if (Index >= USB_KEYCODE_MAX_MAKE) {
1511     return EFI_NOT_READY;
1512   }
1513
1514   KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, KeyChar);
1515
1516   //
1517   // Check for Non-spacing key
1518   //
1519   if (KeyDescriptor->Modifier == EFI_NS_KEY_MODIFIER) {
1520     UsbKeyboardDevice->CurrentNsKey = FindUsbNsKey (UsbKeyboardDevice, KeyDescriptor);
1521     return EFI_NOT_READY;
1522   }
1523
1524   //
1525   // Check whether this keystroke follows a Non-spacing key
1526   //
1527   if (UsbKeyboardDevice->CurrentNsKey != NULL) {
1528     KeyDescriptor = FindPhysicalKey (UsbKeyboardDevice->CurrentNsKey, KeyDescriptor);
1529     UsbKeyboardDevice->CurrentNsKey = NULL;
1530   }
1531
1532   Key->ScanCode = EfiScanCodeConvertionTable[KeyDescriptor->Modifier];
1533   Key->UnicodeChar = KeyDescriptor->Unicode;
1534
1535   if (KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_STANDARD_SHIFT) {
1536     if (UsbKeyboardDevice->ShiftOn != 0) {
1537       Key->UnicodeChar = KeyDescriptor->ShiftedUnicode;
1538
1539       //
1540       // Need not return associated shift state if a class of printable characters that
1541       // are normally adjusted by shift modifiers. e.g. Shift Key + 'f' key = 'F'
1542       //
1543       if (KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) {
1544         UsbKeyboardDevice->LeftShiftOn = 0;
1545         UsbKeyboardDevice->RightShiftOn = 0;
1546       }
1547
1548       if (UsbKeyboardDevice->AltGrOn != 0) {
1549         Key->UnicodeChar = KeyDescriptor->ShiftedAltGrUnicode;
1550       }
1551     } else {
1552       //
1553       // Shift off
1554       //
1555       Key->UnicodeChar = KeyDescriptor->Unicode;
1556
1557       if (UsbKeyboardDevice->AltGrOn != 0) {
1558         Key->UnicodeChar = KeyDescriptor->AltGrUnicode;
1559       }
1560     }
1561   }
1562
1563   if (KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) {
1564     if (UsbKeyboardDevice->CapsOn != 0) {
1565
1566       if (Key->UnicodeChar == KeyDescriptor->Unicode) {
1567
1568         Key->UnicodeChar = KeyDescriptor->ShiftedUnicode;
1569
1570       } else if (Key->UnicodeChar == KeyDescriptor->ShiftedUnicode) {
1571
1572         Key->UnicodeChar = KeyDescriptor->Unicode;
1573
1574       }
1575     }
1576   }
1577
1578   //
1579   // Translate the CTRL-Alpha characters to their corresponding control value  (ctrl-a = 0x0001 through ctrl-Z = 0x001A)
1580   //
1581   if (UsbKeyboardDevice->CtrlOn != 0) {
1582     if (Key->UnicodeChar >= 'a' && Key->UnicodeChar <= 'z') {
1583       Key->UnicodeChar = (UINT8) (Key->UnicodeChar - 'a' + 1);
1584     } else if (Key->UnicodeChar >= 'A' && Key->UnicodeChar <= 'Z') {
1585       Key->UnicodeChar = (UINT8) (Key->UnicodeChar - 'A' + 1);
1586     }
1587   }
1588
1589   if (KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_NUM_LOCK) {
1590
1591     if ((UsbKeyboardDevice->NumLockOn != 0) && (UsbKeyboardDevice->ShiftOn == 0)) {
1592
1593       Key->ScanCode = SCAN_NULL;
1594
1595     } else {
1596       Key->UnicodeChar = 0x00;
1597     }
1598   }
1599
1600   //
1601   // Translate Unicode 0x1B (ESC) to EFI Scan Code
1602   //
1603   if (Key->UnicodeChar == 0x1B && Key->ScanCode == SCAN_NULL) {
1604     Key->ScanCode = SCAN_ESC;
1605     Key->UnicodeChar = 0x00;
1606   }
1607
1608   if (Key->UnicodeChar == 0 && Key->ScanCode == SCAN_NULL) {
1609     return EFI_NOT_READY;
1610   }
1611
1612
1613   //
1614   // Save Shift/Toggle state
1615   //
1616   if (UsbKeyboardDevice->LeftCtrlOn == 1) {
1617     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
1618   }
1619   if (UsbKeyboardDevice->RightCtrlOn == 1) {
1620     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
1621   }
1622   if (UsbKeyboardDevice->LeftAltOn == 1) {
1623     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;
1624   }
1625   if (UsbKeyboardDevice->RightAltOn == 1) {
1626     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_RIGHT_ALT_PRESSED;
1627   }
1628   if (UsbKeyboardDevice->LeftShiftOn == 1) {
1629     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
1630   }
1631   if (UsbKeyboardDevice->RightShiftOn == 1) {
1632     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
1633   }
1634   if (UsbKeyboardDevice->LeftLogoOn == 1) {
1635     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
1636   }
1637   if (UsbKeyboardDevice->RightLogoOn == 1) {
1638     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
1639   }
1640   if (UsbKeyboardDevice->MenuKeyOn == 1) {
1641     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_MENU_KEY_PRESSED;
1642   }
1643   if (UsbKeyboardDevice->SysReqOn == 1) {
1644     UsbKeyboardDevice->KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED;
1645   }
1646
1647   if (UsbKeyboardDevice->ScrollOn == 1) {
1648     UsbKeyboardDevice->KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
1649   }
1650   if (UsbKeyboardDevice->NumLockOn == 1) {
1651     UsbKeyboardDevice->KeyState.KeyToggleState |= EFI_NUM_LOCK_ACTIVE;
1652   }
1653   if (UsbKeyboardDevice->CapsOn == 1) {
1654     UsbKeyboardDevice->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
1655   }
1656
1657   return EFI_SUCCESS;
1658
1659 }
1660
1661
1662 /**
1663   Resets USB Keyboard Buffer.
1664
1665   @param  KeyboardBuffer     Points to the USB Keyboard Buffer.
1666
1667   @retval EFI_SUCCESS        Init key buffer successfully.
1668
1669 **/
1670 EFI_STATUS
1671 EFIAPI
1672 InitUSBKeyBuffer (
1673   IN OUT  USB_KB_BUFFER   *KeyboardBuffer
1674   )
1675 {
1676   ZeroMem (KeyboardBuffer, sizeof (USB_KB_BUFFER));
1677
1678   KeyboardBuffer->bHead = KeyboardBuffer->bTail;
1679
1680   return EFI_SUCCESS;
1681 }
1682
1683
1684 /**
1685   Check whether USB Keyboard buffer is empty.
1686
1687   @param  KeyboardBuffer     USB Keyboard Buffer.
1688
1689   @retval TRUE               Key buffer is empty.
1690   @retval FALSE              Key buffer is not empty.
1691
1692 **/
1693 BOOLEAN
1694 EFIAPI
1695 IsUSBKeyboardBufferEmpty (
1696   IN  USB_KB_BUFFER   *KeyboardBuffer
1697   )
1698 {
1699   //
1700   // meet FIFO empty condition
1701   //
1702   return (BOOLEAN) (KeyboardBuffer->bHead == KeyboardBuffer->bTail);
1703 }
1704
1705
1706 /**
1707   Check whether USB Keyboard buffer is full.
1708
1709   @param  KeyboardBuffer     USB Keyboard Buffer.
1710
1711   @retval TRUE               Key buffer is full.
1712   @retval FALSE              Key buffer is not full.
1713
1714 **/
1715 BOOLEAN
1716 EFIAPI
1717 IsUSBKeyboardBufferFull (
1718   IN  USB_KB_BUFFER   *KeyboardBuffer
1719   )
1720 {
1721   return (BOOLEAN)(((KeyboardBuffer->bTail + 1) % (MAX_KEY_ALLOWED + 1)) ==
1722                                                         KeyboardBuffer->bHead);
1723 }
1724
1725
1726 /**
1727   Inserts a key code into keyboard buffer.
1728
1729   @param  KeyboardBuffer     Points to the USB Keyboard Buffer.
1730   @param  Key                Key code
1731   @param  Down               Special key
1732
1733   @retval EFI_SUCCESS        Success
1734
1735 **/
1736 EFI_STATUS
1737 EFIAPI
1738 InsertKeyCode (
1739   IN OUT  USB_KB_BUFFER *KeyboardBuffer,
1740   IN      UINT8         Key,
1741   IN      UINT8         Down
1742   )
1743 {
1744   USB_KEY UsbKey;
1745
1746   //
1747   // if keyboard buffer is full, throw the
1748   // first key out of the keyboard buffer.
1749   //
1750   if (IsUSBKeyboardBufferFull (KeyboardBuffer)) {
1751     RemoveKeyCode (KeyboardBuffer, &UsbKey);
1752   }
1753
1754   KeyboardBuffer->buffer[KeyboardBuffer->bTail].KeyCode = Key;
1755   KeyboardBuffer->buffer[KeyboardBuffer->bTail].Down    = Down;
1756
1757   //
1758   // adjust the tail pointer of the FIFO keyboard buffer.
1759   //
1760   KeyboardBuffer->bTail = (UINT8) ((KeyboardBuffer->bTail + 1) % (MAX_KEY_ALLOWED + 1));
1761
1762   return EFI_SUCCESS;
1763 }
1764
1765
1766 /**
1767   Pops a key code off from keyboard buffer.
1768
1769   @param  KeyboardBuffer     Points to the USB Keyboard Buffer.
1770   @param  UsbKey             Points to the buffer that contains a usb key code.
1771
1772   @retval EFI_SUCCESS        Success
1773   @retval EFI_DEVICE_ERROR   Hardware Error
1774
1775 **/
1776 EFI_STATUS
1777 EFIAPI
1778 RemoveKeyCode (
1779   IN OUT  USB_KB_BUFFER *KeyboardBuffer,
1780   OUT     USB_KEY       *UsbKey
1781   )
1782 {
1783   if (IsUSBKeyboardBufferEmpty (KeyboardBuffer)) {
1784     return EFI_DEVICE_ERROR;
1785   }
1786
1787   UsbKey->KeyCode = KeyboardBuffer->buffer[KeyboardBuffer->bHead].KeyCode;
1788   UsbKey->Down    = KeyboardBuffer->buffer[KeyboardBuffer->bHead].Down;
1789
1790   //
1791   // adjust the head pointer of the FIFO keyboard buffer.
1792   //
1793   KeyboardBuffer->bHead = (UINT8) ((KeyboardBuffer->bHead + 1) % (MAX_KEY_ALLOWED + 1));
1794
1795   return EFI_SUCCESS;
1796 }
1797
1798
1799 /**
1800   Sets USB Keyboard LED state.
1801
1802   @param  UsbKeyboardDevice  The USB_KB_DEV instance.
1803
1804   @retval EFI_SUCCESS        Success
1805
1806 **/
1807 EFI_STATUS
1808 EFIAPI
1809 SetKeyLED (
1810   IN  USB_KB_DEV    *UsbKeyboardDevice
1811   )
1812 {
1813   LED_MAP Led;
1814   UINT8   ReportId;
1815
1816   //
1817   // Set each field in Led map.
1818   //
1819   Led.NumLock    = (UINT8) UsbKeyboardDevice->NumLockOn;
1820   Led.CapsLock   = (UINT8) UsbKeyboardDevice->CapsOn;
1821   Led.ScrollLock = (UINT8) UsbKeyboardDevice->ScrollOn;
1822   Led.Resrvd     = 0;
1823
1824   ReportId       = 0;
1825   //
1826   // call Set Report Request to lighten the LED.
1827   //
1828   UsbSetReportRequest (
1829     UsbKeyboardDevice->UsbIo,
1830     UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
1831     ReportId,
1832     HID_OUTPUT_REPORT,
1833     1,
1834     (UINT8 *) &Led
1835     );
1836
1837   return EFI_SUCCESS;
1838 }
1839
1840
1841 /**
1842   Timer handler for Repeat Key timer.
1843
1844   @param  Event              The Repeat Key event.
1845   @param  Context            Points to the USB_KB_DEV instance.
1846
1847
1848 **/
1849 VOID
1850 EFIAPI
1851 USBKeyboardRepeatHandler (
1852   IN    EFI_EVENT    Event,
1853   IN    VOID         *Context
1854   )
1855 {
1856   USB_KB_DEV  *UsbKeyboardDevice;
1857
1858   UsbKeyboardDevice = (USB_KB_DEV *) Context;
1859
1860   //
1861   // Do nothing when there is no repeat key.
1862   //
1863   if (UsbKeyboardDevice->RepeatKey != 0) {
1864     //
1865     // Inserts one Repeat key into keyboard buffer,
1866     //
1867     InsertKeyCode (
1868       &(UsbKeyboardDevice->KeyboardBuffer),
1869       UsbKeyboardDevice->RepeatKey,
1870       1
1871       );
1872
1873     //
1874     // set repeate rate for repeat key generation.
1875     //
1876     gBS->SetTimer (
1877           UsbKeyboardDevice->RepeatTimer,
1878           TimerRelative,
1879           USBKBD_REPEAT_RATE
1880           );
1881
1882   }
1883 }
1884
1885
1886 /**
1887   Timer handler for Delayed Recovery timer.
1888
1889   @param  Event              The Delayed Recovery event.
1890   @param  Context            Points to the USB_KB_DEV instance.
1891
1892
1893 **/
1894 VOID
1895 EFIAPI
1896 USBKeyboardRecoveryHandler (
1897   IN    EFI_EVENT    Event,
1898   IN    VOID         *Context
1899   )
1900 {
1901
1902   USB_KB_DEV          *UsbKeyboardDevice;
1903   EFI_USB_IO_PROTOCOL *UsbIo;
1904   UINT8               PacketSize;
1905
1906   UsbKeyboardDevice = (USB_KB_DEV *) Context;
1907
1908   UsbIo             = UsbKeyboardDevice->UsbIo;
1909
1910   PacketSize        = (UINT8) (UsbKeyboardDevice->IntEndpointDescriptor.MaxPacketSize);
1911
1912   UsbIo->UsbAsyncInterruptTransfer (
1913           UsbIo,
1914           UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
1915           TRUE,
1916           UsbKeyboardDevice->IntEndpointDescriptor.Interval,
1917           PacketSize,
1918           KeyboardHandler,
1919           UsbKeyboardDevice
1920           );
1921 }