[mirror_edk2.git] / MdeModulePkg / Bus / Usb / UsbKbDxe / KeyBoard.c

/** @file\r
  Helper functions for USB Keyboard Driver.\r
\r
Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "KeyBoard.h"\r
\r
EFI_GUID  mUsbKeyboardLayoutPackageGuid = USB_KEYBOARD_LAYOUT_PACKAGE_GUID;\r
EFI_GUID  mUsbKeyboardLayoutKeyGuid = USB_KEYBOARD_LAYOUT_KEY_GUID;\r
\r
USB_KEYBOARD_LAYOUT_PACK_BIN  mUsbKeyboardLayoutBin = {\r
  sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN),   // Binary size\r
\r
  //\r
  // EFI_HII_PACKAGE_HEADER\r
  //\r
  {\r
    sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32),\r
    EFI_HII_PACKAGE_KEYBOARD_LAYOUT\r
  },\r
  1,  // LayoutCount\r
  sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32) - sizeof (EFI_HII_PACKAGE_HEADER) - sizeof (UINT16), // LayoutLength\r
  USB_KEYBOARD_LAYOUT_KEY_GUID,  // KeyGuid\r
  sizeof (UINT16) + sizeof (EFI_GUID) + sizeof (UINT32) + sizeof (UINT8) + (USB_KEYBOARD_KEY_COUNT * sizeof (EFI_KEY_DESCRIPTOR)), // LayoutDescriptorStringOffset\r
  USB_KEYBOARD_KEY_COUNT, // DescriptorCount\r
  {\r
    //\r
    // EFI_KEY_DESCRIPTOR (total number is USB_KEYBOARD_KEY_COUNT)\r
    //\r
    {EfiKeyC1,         'a',      'A',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB5,         'b',      'B',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB3,         'c',      'C',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC3,         'd',      'D',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD3,         'e',      'E',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC4,         'f',      'F',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC5,         'g',      'G',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC6,         'h',      'H',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD8,         'i',      'I',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC7,         'j',      'J',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC8,         'k',      'K',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC9,         'l',      'L',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB7,         'm',      'M',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB6,         'n',      'N',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD9,         'o',      'O',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD10,        'p',      'P',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD1,         'q',      'Q',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD4,         'r',      'R',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyC2,         's',      'S',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD5,         't',      'T',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD7,         'u',      'U',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB4,         'v',      'V',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD2,         'w',      'W',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB2,         'x',      'X',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyD6,         'y',      'Y',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyB1,         'z',      'Z',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK},\r
    {EfiKeyE1,         '1',      '!',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE2,         '2',      '@',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE3,         '3',      '#',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE4,         '4',      '$',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE5,         '5',      '%',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE6,         '6',      '^',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE7,         '7',      '&',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE8,         '8',      '*',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE9,         '9',      '(',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE10,        '0',      ')',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyEnter,      0x0d,     0x0d, 0, 0,  EFI_NULL_MODIFIER,   0},\r
    {EfiKeyEsc,        0x1b,     0x1b, 0, 0,  EFI_NULL_MODIFIER,   0},\r
    {EfiKeyBackSpace,  0x08,     0x08, 0, 0,  EFI_NULL_MODIFIER,   0},\r
    {EfiKeyTab,        0x09,     0x09, 0, 0,  EFI_NULL_MODIFIER,   0},\r
    {EfiKeySpaceBar,   ' ',      ' ',  0, 0,  EFI_NULL_MODIFIER,   0},\r
    {EfiKeyE11,        '-',      '_',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE12,        '=',      '+',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyD11,        '[',      '{',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyD12,        ']',      '}',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyD13,        '\\',     '|',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyC10,        ';',      ':',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyC11,        '\'',     '"',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyE0,         '`',      '~',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyB8,         ',',      '<',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyB9,         '.',      '>',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyB10,        '/',      '?',  0, 0,  EFI_NULL_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT},\r
    {EfiKeyCapsLock,   0x00,     0x00, 0, 0,  EFI_CAPS_LOCK_MODIFIER,            0},\r
    {EfiKeyF1,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_ONE_MODIFIER,     0},\r
    {EfiKeyF2,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_TWO_MODIFIER,     0},\r
    {EfiKeyF3,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_THREE_MODIFIER,   0},\r
    {EfiKeyF4,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_FOUR_MODIFIER,    0},\r
    {EfiKeyF5,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_FIVE_MODIFIER,    0},\r
    {EfiKeyF6,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_SIX_MODIFIER,     0},\r
    {EfiKeyF7,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_SEVEN_MODIFIER,   0},\r
    {EfiKeyF8,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_EIGHT_MODIFIER,   0},\r
    {EfiKeyF9,         0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_NINE_MODIFIER,    0},\r
    {EfiKeyF10,        0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_TEN_MODIFIER,     0},\r
    {EfiKeyF11,        0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_ELEVEN_MODIFIER,  0},\r
    {EfiKeyF12,        0x00,     0x00, 0, 0,  EFI_FUNCTION_KEY_TWELVE_MODIFIER,  0},\r
    {EfiKeyPrint,      0x00,     0x00, 0, 0,  EFI_PRINT_MODIFIER,                0},\r
    {EfiKeySLck,       0x00,     0x00, 0, 0,  EFI_SCROLL_LOCK_MODIFIER,          0},\r
    {EfiKeyPause,      0x00,     0x00, 0, 0,  EFI_PAUSE_MODIFIER,                0},\r
    {EfiKeyIns,        0x00,     0x00, 0, 0,  EFI_INSERT_MODIFIER,               0},\r
    {EfiKeyHome,       0x00,     0x00, 0, 0,  EFI_HOME_MODIFIER,                 0},\r
    {EfiKeyPgUp,       0x00,     0x00, 0, 0,  EFI_PAGE_UP_MODIFIER,              0},\r
    {EfiKeyDel,        0x00,     0x00, 0, 0,  EFI_DELETE_MODIFIER,               0},\r
    {EfiKeyEnd,        0x00,     0x00, 0, 0,  EFI_END_MODIFIER,                  0},\r
    {EfiKeyPgDn,       0x00,     0x00, 0, 0,  EFI_PAGE_DOWN_MODIFIER,            0},\r
    {EfiKeyRightArrow, 0x00,     0x00, 0, 0,  EFI_RIGHT_ARROW_MODIFIER,          0},\r
    {EfiKeyLeftArrow,  0x00,     0x00, 0, 0,  EFI_LEFT_ARROW_MODIFIER,           0},\r
    {EfiKeyDownArrow,  0x00,     0x00, 0, 0,  EFI_DOWN_ARROW_MODIFIER,           0},\r
    {EfiKeyUpArrow,    0x00,     0x00, 0, 0,  EFI_UP_ARROW_MODIFIER,             0},\r
    {EfiKeyNLck,       0x00,     0x00, 0, 0,  EFI_NUM_LOCK_MODIFIER,             0},\r
    {EfiKeySlash,      '/',      '/',  0, 0,  EFI_NULL_MODIFIER,                 0},\r
    {EfiKeyAsterisk,   '*',      '*',  0, 0,  EFI_NULL_MODIFIER,                 0},\r
    {EfiKeyMinus,      '-',      '-',  0, 0,  EFI_NULL_MODIFIER,                 0},\r
    {EfiKeyPlus,       '+',      '+',  0, 0,  EFI_NULL_MODIFIER,                 0},\r
    {EfiKeyEnter,      0x0d,     0x0d, 0, 0,  EFI_NULL_MODIFIER,                 0},\r
    {EfiKeyOne,        '1',      '1',  0, 0,  EFI_END_MODIFIER,         EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyTwo,        '2',      '2',  0, 0,  EFI_DOWN_ARROW_MODIFIER,  EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyThree,      '3',      '3',  0, 0,  EFI_PAGE_DOWN_MODIFIER,   EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyFour,       '4',      '4',  0, 0,  EFI_LEFT_ARROW_MODIFIER,  EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyFive,       '5',      '5',  0, 0,  EFI_NULL_MODIFIER,        EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeySix,        '6',      '6',  0, 0,  EFI_RIGHT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeySeven,      '7',      '7',  0, 0,  EFI_HOME_MODIFIER,        EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyEight,      '8',      '8',  0, 0,  EFI_UP_ARROW_MODIFIER,    EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyNine,       '9',      '9',  0, 0,  EFI_PAGE_UP_MODIFIER,     EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyZero,       '0',      '0',  0, 0,  EFI_INSERT_MODIFIER,      EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyPeriod,     '.',      '.',  0, 0,  EFI_DELETE_MODIFIER,      EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK},\r
    {EfiKeyA4,         0x00,     0x00, 0, 0,  EFI_MENU_MODIFIER,            0},\r
    {EfiKeyLCtrl,      0,        0,    0, 0,  EFI_LEFT_CONTROL_MODIFIER,    0},\r
    {EfiKeyLShift,     0,        0,    0, 0,  EFI_LEFT_SHIFT_MODIFIER,      0},\r
    {EfiKeyLAlt,       0,        0,    0, 0,  EFI_LEFT_ALT_MODIFIER,        0},\r
    {EfiKeyA0,         0,        0,    0, 0,  EFI_LEFT_LOGO_MODIFIER,       0},\r
    {EfiKeyRCtrl,      0,        0,    0, 0,  EFI_RIGHT_CONTROL_MODIFIER,   0},\r
    {EfiKeyRShift,     0,        0,    0, 0,  EFI_RIGHT_SHIFT_MODIFIER,     0},\r
    {EfiKeyA2,         0,        0,    0, 0,  EFI_RIGHT_ALT_MODIFIER,       0},\r
    {EfiKeyA3,         0,        0,    0, 0,  EFI_RIGHT_LOGO_MODIFIER,      0},\r
  },\r
  1,                          // DescriptionCount\r
  {'e', 'n', '-', 'U', 'S'},  // RFC4646 language code\r
  ' ',                        // Space\r
  {'E', 'n', 'g', 'l', 'i', 's', 'h', ' ', 'K', 'e', 'y', 'b', 'o', 'a', 'r', 'd', '\0'}, // DescriptionString[]\r
};\r
\r
//\r
// EFI_KEY to USB Keycode conversion table\r
// EFI_KEY is defined in UEFI spec.\r
// USB Keycode is defined in USB HID Firmware spec.\r
//\r
UINT8 EfiKeyToUsbKeyCodeConvertionTable[] = {\r
  0xe0,  //  EfiKeyLCtrl\r
  0xe3,  //  EfiKeyA0\r
  0xe2,  //  EfiKeyLAlt\r
  0x2c,  //  EfiKeySpaceBar\r
  0xe6,  //  EfiKeyA2\r
  0xe7,  //  EfiKeyA3\r
  0x65,  //  EfiKeyA4\r
  0xe4,  //  EfiKeyRCtrl\r
  0x50,  //  EfiKeyLeftArrow\r
  0x51,  //  EfiKeyDownArrow\r
  0x4F,  //  EfiKeyRightArrow\r
  0x62,  //  EfiKeyZero\r
  0x63,  //  EfiKeyPeriod\r
  0x28,  //  EfiKeyEnter\r
  0xe1,  //  EfiKeyLShift\r
  0x64,  //  EfiKeyB0\r
  0x1D,  //  EfiKeyB1\r
  0x1B,  //  EfiKeyB2\r
  0x06,  //  EfiKeyB3\r
  0x19,  //  EfiKeyB4\r
  0x05,  //  EfiKeyB5\r
  0x11,  //  EfiKeyB6\r
  0x10,  //  EfiKeyB7\r
  0x36,  //  EfiKeyB8\r
  0x37,  //  EfiKeyB9\r
  0x38,  //  EfiKeyB10\r
  0xe5,  //  EfiKeyRShift\r
  0x52,  //  EfiKeyUpArrow\r
  0x59,  //  EfiKeyOne\r
  0x5A,  //  EfiKeyTwo\r
  0x5B,  //  EfiKeyThree\r
  0x39,  //  EfiKeyCapsLock\r
  0x04,  //  EfiKeyC1\r
  0x16,  //  EfiKeyC2\r
  0x07,  //  EfiKeyC3\r
  0x09,  //  EfiKeyC4\r
  0x0A,  //  EfiKeyC5\r
  0x0B,  //  EfiKeyC6\r
  0x0D,  //  EfiKeyC7\r
  0x0E,  //  EfiKeyC8\r
  0x0F,  //  EfiKeyC9\r
  0x33,  //  EfiKeyC10\r
  0x34,  //  EfiKeyC11\r
  0x32,  //  EfiKeyC12\r
  0x5C,  //  EfiKeyFour\r
  0x5D,  //  EfiKeyFive\r
  0x5E,  //  EfiKeySix\r
  0x57,  //  EfiKeyPlus\r
  0x2B,  //  EfiKeyTab\r
  0x14,  //  EfiKeyD1\r
  0x1A,  //  EfiKeyD2\r
  0x08,  //  EfiKeyD3\r
  0x15,  //  EfiKeyD4\r
  0x17,  //  EfiKeyD5\r
  0x1C,  //  EfiKeyD6\r
  0x18,  //  EfiKeyD7\r
  0x0C,  //  EfiKeyD8\r
  0x12,  //  EfiKeyD9\r
  0x13,  //  EfiKeyD10\r
  0x2F,  //  EfiKeyD11\r
  0x30,  //  EfiKeyD12\r
  0x31,  //  EfiKeyD13\r
  0x4C,  //  EfiKeyDel\r
  0x4D,  //  EfiKeyEnd\r
  0x4E,  //  EfiKeyPgDn\r
  0x5F,  //  EfiKeySeven\r
  0x60,  //  EfiKeyEight\r
  0x61,  //  EfiKeyNine\r
  0x35,  //  EfiKeyE0\r
  0x1E,  //  EfiKeyE1\r
  0x1F,  //  EfiKeyE2\r
  0x20,  //  EfiKeyE3\r
  0x21,  //  EfiKeyE4\r
  0x22,  //  EfiKeyE5\r
  0x23,  //  EfiKeyE6\r
  0x24,  //  EfiKeyE7\r
  0x25,  //  EfiKeyE8\r
  0x26,  //  EfiKeyE9\r
  0x27,  //  EfiKeyE10\r
  0x2D,  //  EfiKeyE11\r
  0x2E,  //  EfiKeyE12\r
  0x2A,  //  EfiKeyBackSpace\r
  0x49,  //  EfiKeyIns\r
  0x4A,  //  EfiKeyHome\r
  0x4B,  //  EfiKeyPgUp\r
  0x53,  //  EfiKeyNLck\r
  0x54,  //  EfiKeySlash\r
  0x55,  //  EfiKeyAsterisk\r
  0x56,  //  EfiKeyMinus\r
  0x29,  //  EfiKeyEsc\r
  0x3A,  //  EfiKeyF1\r
  0x3B,  //  EfiKeyF2\r
  0x3C,  //  EfiKeyF3\r
  0x3D,  //  EfiKeyF4\r
  0x3E,  //  EfiKeyF5\r
  0x3F,  //  EfiKeyF6\r
  0x40,  //  EfiKeyF7\r
  0x41,  //  EfiKeyF8\r
  0x42,  //  EfiKeyF9\r
  0x43,  //  EfiKeyF10\r
  0x44,  //  EfiKeyF11\r
  0x45,  //  EfiKeyF12\r
  0x46,  //  EfiKeyPrint\r
  0x47,  //  EfiKeySLck\r
  0x48   //  EfiKeyPause\r
};\r
\r
//\r
// Keyboard modifier value to EFI Scan Code convertion table\r
// EFI Scan Code and the modifier values are defined in UEFI spec.\r
//\r
UINT8 ModifierValueToEfiScanCodeConvertionTable[] = {\r
  SCAN_NULL,       // EFI_NULL_MODIFIER\r
  SCAN_NULL,       // EFI_LEFT_CONTROL_MODIFIER\r
  SCAN_NULL,       // EFI_RIGHT_CONTROL_MODIFIER\r
  SCAN_NULL,       // EFI_LEFT_ALT_MODIFIER\r
  SCAN_NULL,       // EFI_RIGHT_ALT_MODIFIER\r
  SCAN_NULL,       // EFI_ALT_GR_MODIFIER\r
  SCAN_INSERT,     // EFI_INSERT_MODIFIER\r
  SCAN_DELETE,     // EFI_DELETE_MODIFIER\r
  SCAN_PAGE_DOWN,  // EFI_PAGE_DOWN_MODIFIER\r
  SCAN_PAGE_UP,    // EFI_PAGE_UP_MODIFIER\r
  SCAN_HOME,       // EFI_HOME_MODIFIER\r
  SCAN_END,        // EFI_END_MODIFIER\r
  SCAN_NULL,       // EFI_LEFT_SHIFT_MODIFIER\r
  SCAN_NULL,       // EFI_RIGHT_SHIFT_MODIFIER\r
  SCAN_NULL,       // EFI_CAPS_LOCK_MODIFIER\r
  SCAN_NULL,       // EFI_NUM_LOCK_MODIFIER\r
  SCAN_LEFT,       // EFI_LEFT_ARROW_MODIFIER\r
  SCAN_RIGHT,      // EFI_RIGHT_ARROW_MODIFIER\r
  SCAN_DOWN,       // EFI_DOWN_ARROW_MODIFIER\r
  SCAN_UP,         // EFI_UP_ARROW_MODIFIER\r
  SCAN_NULL,       // EFI_NS_KEY_MODIFIER\r
  SCAN_NULL,       // EFI_NS_KEY_DEPENDENCY_MODIFIER\r
  SCAN_F1,         // EFI_FUNCTION_KEY_ONE_MODIFIER\r
  SCAN_F2,         // EFI_FUNCTION_KEY_TWO_MODIFIER\r
  SCAN_F3,         // EFI_FUNCTION_KEY_THREE_MODIFIER\r
  SCAN_F4,         // EFI_FUNCTION_KEY_FOUR_MODIFIER\r
  SCAN_F5,         // EFI_FUNCTION_KEY_FIVE_MODIFIER\r
  SCAN_F6,         // EFI_FUNCTION_KEY_SIX_MODIFIER\r
  SCAN_F7,         // EFI_FUNCTION_KEY_SEVEN_MODIFIER\r
  SCAN_F8,         // EFI_FUNCTION_KEY_EIGHT_MODIFIER\r
  SCAN_F9,         // EFI_FUNCTION_KEY_NINE_MODIFIER\r
  SCAN_F10,        // EFI_FUNCTION_KEY_TEN_MODIFIER\r
  SCAN_F11,        // EFI_FUNCTION_KEY_ELEVEN_MODIFIER\r
  SCAN_F12,        // EFI_FUNCTION_KEY_TWELVE_MODIFIER\r
  SCAN_NULL,       // EFI_PRINT_MODIFIER\r
  SCAN_NULL,       // EFI_SYS_REQUEST_MODIFIER\r
  SCAN_NULL,       // EFI_SCROLL_LOCK_MODIFIER\r
  SCAN_PAUSE       // EFI_PAUSE_MODIFIER\r
};\r
\r
/**\r
  Initialize Key Convention Table by using default keyboard layout.\r
\r
  @param  UsbKeyboardDevice    The USB_KB_DEV instance.\r
\r
  @retval EFI_SUCCESS          The default keyboard layout was installed successfully\r
  @retval Others               Failure to install default keyboard layout.\r
**/\r
EFI_STATUS\r
InstallDefaultKeyboardLayout (\r
   IN OUT USB_KB_DEV           *UsbKeyboardDevice\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  EFI_HII_DATABASE_PROTOCOL    *HiiDatabase;\r
  EFI_HII_HANDLE               HiiHandle;\r
\r
  //\r
  // Locate Hii database protocol\r
  //\r
  Status = gBS->LocateProtocol (\r
                  &gEfiHiiDatabaseProtocolGuid,\r
                  NULL,\r
                  (VOID **) &HiiDatabase\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Install Keyboard Layout package to HII database\r
  //\r
  HiiHandle = HiiAddPackages (\r
                &mUsbKeyboardLayoutPackageGuid,\r
                UsbKeyboardDevice->ControllerHandle,\r
                &mUsbKeyboardLayoutBin,\r
                NULL\r
                );\r
  if (HiiHandle == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Set current keyboard layout\r
  //\r
  Status = HiiDatabase->SetKeyboardLayout (HiiDatabase, &mUsbKeyboardLayoutKeyGuid);\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Uses USB I/O to check whether the device is a USB keyboard device.\r
\r
  @param  UsbIo    Pointer to a USB I/O protocol instance.\r
\r
  @retval TRUE     Device is a USB keyboard device.\r
  @retval FALSE    Device is a not USB keyboard device.\r
\r
**/\r
BOOLEAN\r
IsUSBKeyboard (\r
  IN  EFI_USB_IO_PROTOCOL       *UsbIo\r
  )\r
{\r
  EFI_STATUS                    Status;\r
  EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDescriptor;\r
\r
  //\r
  // Get the default interface descriptor\r
  //\r
  Status = UsbIo->UsbGetInterfaceDescriptor (\r
                    UsbIo,\r
                    &InterfaceDescriptor\r
                    );\r
\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  }\r
\r
  if (InterfaceDescriptor.InterfaceClass == CLASS_HID &&\r
      InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT &&\r
      InterfaceDescriptor.InterfaceProtocol == PROTOCOL_KEYBOARD\r
      ) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Get current keyboard layout from HII database.\r
\r
  @return Pointer to HII Keyboard Layout.\r
          NULL means failure occurred while trying to get keyboard layout.\r
\r
**/\r
EFI_HII_KEYBOARD_LAYOUT *\r
GetCurrentKeyboardLayout (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_HII_DATABASE_PROTOCOL *HiiDatabase;\r
  EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;\r
  UINT16                    Length;\r
\r
  //\r
  // Locate HII Database Protocol\r
  //\r
  Status = gBS->LocateProtocol (\r
                  &gEfiHiiDatabaseProtocolGuid,\r
                  NULL,\r
                  (VOID **) &HiiDatabase\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Get current keyboard layout from HII database\r
  //\r
  Length = 0;\r
  KeyboardLayout = NULL;\r
  Status = HiiDatabase->GetKeyboardLayout (\r
                          HiiDatabase,\r
                          NULL,\r
                          &Length,\r
                          KeyboardLayout\r
                          );\r
  if (Status == EFI_BUFFER_TOO_SMALL) {\r
    KeyboardLayout = AllocatePool (Length);\r
    ASSERT (KeyboardLayout != NULL);\r
\r
    Status = HiiDatabase->GetKeyboardLayout (\r
                            HiiDatabase,\r
                            NULL,\r
                            &Length,\r
                            KeyboardLayout\r
                            );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (KeyboardLayout);\r
      KeyboardLayout = NULL;\r
    }\r
  }\r
\r
  return KeyboardLayout;\r
}\r
\r
/**\r
  Find Key Descriptor in Key Convertion Table given its USB keycode.\r
\r
  @param  UsbKeyboardDevice   The USB_KB_DEV instance.\r
  @param  KeyCode             USB Keycode.\r
\r
  @return The Key Descriptor in Key Convertion Table.\r
          NULL means not found.\r
\r
**/\r
EFI_KEY_DESCRIPTOR *\r
GetKeyDescriptor (\r
  IN USB_KB_DEV        *UsbKeyboardDevice,\r
  IN UINT8             KeyCode\r
  )\r
{\r
  UINT8  Index;\r
\r
  //\r
  // Make sure KeyCode is in the range of [0x4, 0x65] or [0xe0, 0xe7]\r
  //\r
  if ((!USBKBD_VALID_KEYCODE (KeyCode)) || ((KeyCode > 0x65) && (KeyCode < 0xe0)) || (KeyCode > 0xe7)) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Calculate the index of Key Descriptor in Key Convertion Table\r
  //\r
  if (KeyCode <= 0x65) {\r
    Index = (UINT8) (KeyCode - 4);\r
  } else {\r
    Index = (UINT8) (KeyCode - 0xe0 + NUMBER_OF_VALID_NON_MODIFIER_USB_KEYCODE);\r
  }\r
\r
  return &UsbKeyboardDevice->KeyConvertionTable[Index];\r
}\r
\r
/**\r
  Find Non-Spacing key for given Key descriptor.\r
\r
  @param  UsbKeyboardDevice    The USB_KB_DEV instance.\r
  @param  KeyDescriptor        Key descriptor.\r
\r
  @return The Non-Spacing key corresponding to KeyDescriptor\r
          NULL means not found.\r
\r
**/\r
USB_NS_KEY *\r
FindUsbNsKey (\r
  IN USB_KB_DEV          *UsbKeyboardDevice,\r
  IN EFI_KEY_DESCRIPTOR  *KeyDescriptor\r
  )\r
{\r
  LIST_ENTRY      *Link;\r
  LIST_ENTRY      *NsKeyList;\r
  USB_NS_KEY      *UsbNsKey;\r
  \r
  NsKeyList = &UsbKeyboardDevice->NsKeyList;\r
  Link = GetFirstNode (NsKeyList);\r
  while (!IsNull (NsKeyList, Link)) {\r
    UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);\r
\r
    if (UsbNsKey->NsKey[0].Key == KeyDescriptor->Key) {\r
      return UsbNsKey;\r
    }\r
\r
    Link = GetNextNode (NsKeyList, Link);\r
  }\r
\r
  return NULL;\r
}\r
\r
/**\r
  Find physical key definition for a given key descriptor.\r
\r
  For a specified non-spacing key, there are a list of physical\r
  keys following it. This function traverses the list of\r
  physical keys and tries to find the physical key matching\r
  the KeyDescriptor.\r
\r
  @param  UsbNsKey          The non-spacing key information.\r
  @param  KeyDescriptor     The key descriptor.\r
\r
  @return The physical key definition.\r
          If no physical key is found, parameter KeyDescriptor is returned.\r
\r
**/\r
EFI_KEY_DESCRIPTOR *\r
FindPhysicalKey (\r
  IN USB_NS_KEY          *UsbNsKey,\r
  IN EFI_KEY_DESCRIPTOR  *KeyDescriptor\r
  )\r
{\r
  UINTN               Index;\r
  EFI_KEY_DESCRIPTOR  *PhysicalKey;\r
\r
  PhysicalKey = &UsbNsKey->NsKey[1];\r
  for (Index = 0; Index < UsbNsKey->KeyCount; Index++) {\r
    if (KeyDescriptor->Key == PhysicalKey->Key) {\r
      return PhysicalKey;\r
    }\r
\r
    PhysicalKey++;\r
  }\r
\r
  //\r
  // No children definition matched, return original key\r
  //\r
  return KeyDescriptor;\r
}\r
\r
/**\r
  The notification function for EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID.\r
\r
  This function is registered to event of EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID\r
  group type, which will be triggered by EFI_HII_DATABASE_PROTOCOL.SetKeyboardLayout().\r
  It tries to get curent keyboard layout from HII database.\r
\r
  @param  Event        Event being signaled.\r
  @param  Context      Points to USB_KB_DEV instance.\r
\r
**/\r
VOID\r
EFIAPI\r
SetKeyboardLayoutEvent (\r
  IN EFI_EVENT              Event,\r
  IN VOID                   *Context\r
  )\r
{\r
  USB_KB_DEV                *UsbKeyboardDevice;\r
  EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;\r
  EFI_KEY_DESCRIPTOR        TempKey;\r
  EFI_KEY_DESCRIPTOR        *KeyDescriptor;\r
  EFI_KEY_DESCRIPTOR        *TableEntry;\r
  EFI_KEY_DESCRIPTOR        *NsKey;\r
  USB_NS_KEY                *UsbNsKey;\r
  UINTN                     Index;\r
  UINTN                     Index2;\r
  UINTN                     KeyCount;\r
  UINT8                     KeyCode;\r
\r
  UsbKeyboardDevice = (USB_KB_DEV *) Context;\r
  if (UsbKeyboardDevice->Signature != USB_KB_DEV_SIGNATURE) {\r
    return;\r
  }\r
\r
  //\r
  // Try to get current keyboard layout from HII database\r
  //\r
  KeyboardLayout = GetCurrentKeyboardLayout ();\r
  if (KeyboardLayout == NULL) {\r
    return;\r
  }\r
\r
  //\r
  // Re-allocate resource for KeyConvertionTable\r
  //\r
  ReleaseKeyboardLayoutResources (UsbKeyboardDevice);\r
  UsbKeyboardDevice->KeyConvertionTable = AllocateZeroPool ((NUMBER_OF_VALID_USB_KEYCODE) * sizeof (EFI_KEY_DESCRIPTOR));\r
  ASSERT (UsbKeyboardDevice->KeyConvertionTable != NULL);\r
\r
  //\r
  // Traverse the list of key descriptors following the header of EFI_HII_KEYBOARD_LAYOUT\r
  //\r
  KeyDescriptor = (EFI_KEY_DESCRIPTOR *) (((UINT8 *) KeyboardLayout) + sizeof (EFI_HII_KEYBOARD_LAYOUT));\r
  for (Index = 0; Index < KeyboardLayout->DescriptorCount; Index++) {\r
    //\r
    // Copy from HII keyboard layout package binary for alignment\r
    //\r
    CopyMem (&TempKey, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));\r
\r
    //\r
    // Fill the key into KeyConvertionTable, whose index is calculated from USB keycode.\r
    //\r
    KeyCode = EfiKeyToUsbKeyCodeConvertionTable [(UINT8) (TempKey.Key)];\r
    TableEntry = GetKeyDescriptor (UsbKeyboardDevice, KeyCode);\r
    CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));\r
\r
    //\r
    // For non-spacing key, create the list with a non-spacing key followed by physical keys.\r
    //\r
    if (TempKey.Modifier == EFI_NS_KEY_MODIFIER) {\r
      UsbNsKey = AllocatePool (sizeof (USB_NS_KEY));\r
      ASSERT (UsbNsKey != NULL);\r
\r
      //\r
      // Search for sequential children physical key definitions\r
      //\r
      KeyCount = 0;\r
      NsKey = KeyDescriptor + 1;\r
      for (Index2 = (UINT8) Index + 1; Index2 < KeyboardLayout->DescriptorCount; Index2++) {\r
        CopyMem (&TempKey, NsKey, sizeof (EFI_KEY_DESCRIPTOR));\r
        if (TempKey.Modifier == EFI_NS_KEY_DEPENDENCY_MODIFIER) {\r
          KeyCount++;\r
        } else {\r
          break;\r
        }\r
        NsKey++;\r
      }\r
\r
      UsbNsKey->Signature = USB_NS_KEY_SIGNATURE;\r
      UsbNsKey->KeyCount = KeyCount;\r
      UsbNsKey->NsKey = AllocateCopyPool (\r
                          (KeyCount + 1) * sizeof (EFI_KEY_DESCRIPTOR),\r
                          KeyDescriptor\r
                          );\r
      InsertTailList (&UsbKeyboardDevice->NsKeyList, &UsbNsKey->Link);\r
\r
      //\r
      // Skip over the child physical keys\r
      //\r
      Index += KeyCount;\r
      KeyDescriptor += KeyCount;\r
    }\r
\r
    KeyDescriptor++;\r
  }\r
\r
  //\r
  // There are two EfiKeyEnter, duplicate its key descriptor\r
  //\r
  TableEntry = GetKeyDescriptor (UsbKeyboardDevice, 0x58);\r
  KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, 0x28);\r
  CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));\r
\r
  FreePool (KeyboardLayout);\r
}\r
\r
/**\r
  Destroy resources for keyboard layout.\r
\r
  @param  UsbKeyboardDevice    The USB_KB_DEV instance.\r
\r
**/\r
VOID\r
ReleaseKeyboardLayoutResources (\r
  IN OUT USB_KB_DEV              *UsbKeyboardDevice\r
  )\r
{\r
  USB_NS_KEY      *UsbNsKey;\r
  LIST_ENTRY      *Link;\r
\r
  if (UsbKeyboardDevice->KeyConvertionTable != NULL) {\r
    FreePool (UsbKeyboardDevice->KeyConvertionTable);\r
  }\r
  UsbKeyboardDevice->KeyConvertionTable = NULL;\r
\r
  while (!IsListEmpty (&UsbKeyboardDevice->NsKeyList)) {\r
    Link = GetFirstNode (&UsbKeyboardDevice->NsKeyList);\r
    UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);\r
    RemoveEntryList (&UsbNsKey->Link);\r
\r
    FreePool (UsbNsKey->NsKey);\r
    FreePool (UsbNsKey);\r
  }\r
}\r
\r
/**\r
  Initialize USB keyboard layout.\r
\r
  This function initializes Key Convertion Table for the USB keyboard device.\r
  It first tries to retrieve layout from HII database. If failed and default\r
  layout is enabled, then it just uses the default layout.\r
\r
  @param  UsbKeyboardDevice      The USB_KB_DEV instance.\r
\r
  @retval EFI_SUCCESS            Initialization succeeded.\r
  @retval EFI_NOT_READY          Keyboard layout cannot be retrieve from HII\r
                                 database, and default layout is disabled.\r
  @retval Other                  Fail to register event to EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group.\r
\r
**/\r
EFI_STATUS\r
InitKeyboardLayout (\r
  OUT USB_KB_DEV   *UsbKeyboardDevice\r
  )\r
{\r
  EFI_HII_KEYBOARD_LAYOUT   *KeyboardLayout;\r
  EFI_STATUS                Status;\r
\r
  UsbKeyboardDevice->KeyConvertionTable = AllocateZeroPool ((NUMBER_OF_VALID_USB_KEYCODE) * sizeof (EFI_KEY_DESCRIPTOR));\r
  ASSERT (UsbKeyboardDevice->KeyConvertionTable != NULL);\r
\r
  InitializeListHead (&UsbKeyboardDevice->NsKeyList);\r
  UsbKeyboardDevice->CurrentNsKey = NULL;\r
  UsbKeyboardDevice->KeyboardLayoutEvent = NULL;\r
\r
  //\r
  // Register event to EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group,\r
  // which will be triggered by EFI_HII_DATABASE_PROTOCOL.SetKeyboardLayout().\r
  //\r
  Status = gBS->CreateEventEx (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  SetKeyboardLayoutEvent,\r
                  UsbKeyboardDevice,\r
                  &gEfiHiiKeyBoardLayoutGuid,\r
                  &UsbKeyboardDevice->KeyboardLayoutEvent\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  KeyboardLayout = GetCurrentKeyboardLayout ();\r
  if (KeyboardLayout != NULL) {\r
    //\r
    // If current keyboard layout is successfully retrieved from HII database,\r
    // force to initialize the keyboard layout.\r
    //\r
    gBS->SignalEvent (UsbKeyboardDevice->KeyboardLayoutEvent);\r
  } else {\r
    if (FeaturePcdGet (PcdDisableDefaultKeyboardLayoutInUsbKbDriver)) {\r
      //\r
      // If no keyboard layout can be retrieved from HII database, and default layout\r
      // is disabled, then return EFI_NOT_READY.\r
      //\r
      return EFI_NOT_READY;\r
    }\r
    //\r
    // If no keyboard layout can be retrieved from HII database, and default layout\r
    // is enabled, then load the default keyboard layout.\r
    //\r
    InstallDefaultKeyboardLayout (UsbKeyboardDevice);\r
  }\r
  \r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Initialize USB keyboard device and all private data structures.\r
\r
  @param  UsbKeyboardDevice  The USB_KB_DEV instance.\r
\r
  @retval EFI_SUCCESS        Initialization is successful.\r
  @retval EFI_DEVICE_ERROR   Keyboard initialization failed.\r
\r
**/\r
EFI_STATUS\r
InitUSBKeyboard (\r
  IN OUT USB_KB_DEV   *UsbKeyboardDevice\r
  )\r
{\r
  UINT16              ConfigValue;\r
  UINT8               Protocol;\r
  UINT8               ReportId;\r
  UINT8               Duration;\r
  EFI_STATUS          Status;\r
  UINT32              TransferResult;\r
\r
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
    EFI_PROGRESS_CODE,\r
    (EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST),\r
    UsbKeyboardDevice->DevicePath\r
    );\r
\r
  InitQueue (&UsbKeyboardDevice->UsbKeyQueue, sizeof (USB_KEY));\r
  InitQueue (&UsbKeyboardDevice->EfiKeyQueue, sizeof (EFI_KEY_DATA));\r
\r
  //\r
  // Use the config out of the descriptor\r
  // Assumed the first config is the correct one and this is not always the case\r
  //\r
  Status = UsbGetConfiguration (\r
             UsbKeyboardDevice->UsbIo, \r
             &ConfigValue, \r
             &TransferResult\r
             );\r
  if (EFI_ERROR (Status)) {\r
    ConfigValue = 0x01;\r
  }\r
  \r
  //\r
  // Uses default configuration to configure the USB Keyboard device.\r
  //\r
  Status = UsbSetConfiguration (\r
             UsbKeyboardDevice->UsbIo,\r
             ConfigValue,\r
             &TransferResult\r
             );\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // If configuration could not be set here, it means\r
    // the keyboard interface has some errors and could\r
    // not be initialized\r
    //\r
    REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
      EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
      (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INTERFACE_ERROR),\r
      UsbKeyboardDevice->DevicePath\r
      );\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  UsbGetProtocolRequest (\r
    UsbKeyboardDevice->UsbIo,\r
    UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,\r
    &Protocol\r
    );\r
  //\r
  // Set boot protocol for the USB Keyboard.\r
  // This driver only supports boot protocol.\r
  //\r
  if (Protocol != BOOT_PROTOCOL) {\r
    UsbSetProtocolRequest (\r
      UsbKeyboardDevice->UsbIo,\r
      UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,\r
      BOOT_PROTOCOL\r
      );\r
  }\r
\r
  //\r
  // ReportId is zero, which means the idle rate applies to all input reports.\r
  //\r
  ReportId = 0;\r
  //\r
  // Duration is zero, which means the duration is infinite.\r
  // so the endpoint will inhibit reporting forever,\r
  // and only reporting when a change is detected in the report data.\r
  //\r
  Duration = 0;\r
  UsbSetIdleRequest (\r
    UsbKeyboardDevice->UsbIo,\r
    UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,\r
    ReportId,\r
    Duration\r
    );\r
\r
  UsbKeyboardDevice->CtrlOn     = FALSE;\r
  UsbKeyboardDevice->AltOn      = FALSE;\r
  UsbKeyboardDevice->ShiftOn    = FALSE;\r
  UsbKeyboardDevice->NumLockOn  = FALSE;\r
  UsbKeyboardDevice->CapsOn     = FALSE;\r
  UsbKeyboardDevice->ScrollOn   = FALSE;\r
  \r
  UsbKeyboardDevice->LeftCtrlOn   = FALSE;\r
  UsbKeyboardDevice->LeftAltOn    = FALSE;\r
  UsbKeyboardDevice->LeftShiftOn  = FALSE;\r
  UsbKeyboardDevice->LeftLogoOn   = FALSE;\r
  UsbKeyboardDevice->RightCtrlOn  = FALSE;\r
  UsbKeyboardDevice->RightAltOn   = FALSE;\r
  UsbKeyboardDevice->RightShiftOn = FALSE;\r
  UsbKeyboardDevice->RightLogoOn  = FALSE;\r
  UsbKeyboardDevice->MenuKeyOn    = FALSE;\r
  UsbKeyboardDevice->SysReqOn     = FALSE;\r
\r
  UsbKeyboardDevice->AltGrOn      = FALSE;\r
\r
  UsbKeyboardDevice->CurrentNsKey = NULL;\r
\r
  //\r
  // Sync the initial state of lights on keyboard.\r
  //\r
  SetKeyLED (UsbKeyboardDevice);\r
\r
  ZeroMem (UsbKeyboardDevice->LastKeyCodeArray, sizeof (UINT8) * 8);\r
\r
  //\r
  // Create event for repeat keys' generation.\r
  //\r
  if (UsbKeyboardDevice->RepeatTimer != NULL) {\r
    gBS->CloseEvent (UsbKeyboardDevice->RepeatTimer);\r
    UsbKeyboardDevice->RepeatTimer = NULL;\r
  }\r
\r
  gBS->CreateEvent (\r
         EVT_TIMER | EVT_NOTIFY_SIGNAL,\r
         TPL_CALLBACK,\r
         USBKeyboardRepeatHandler,\r
         UsbKeyboardDevice,\r
         &UsbKeyboardDevice->RepeatTimer\r
         );\r
\r
  //\r
  // Create event for delayed recovery, which deals with device error.\r
  //\r
  if (UsbKeyboardDevice->DelayedRecoveryEvent != NULL) {\r
    gBS->CloseEvent (UsbKeyboardDevice->DelayedRecoveryEvent);\r
    UsbKeyboardDevice->DelayedRecoveryEvent = NULL;\r
  }\r
\r
  gBS->CreateEvent (\r
         EVT_TIMER | EVT_NOTIFY_SIGNAL,\r
         TPL_NOTIFY,\r
         USBKeyboardRecoveryHandler,\r
         UsbKeyboardDevice,\r
         &UsbKeyboardDevice->DelayedRecoveryEvent\r
         );\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Handler function for USB keyboard's asynchronous interrupt transfer.\r
\r
  This function is the handler function for USB keyboard's asynchronous interrupt transfer\r
  to manage the keyboard. It parses the USB keyboard input report, and inserts data to\r
  keyboard buffer according to state of modifer keys and normal keys. Timer for repeat key\r
  is also set accordingly.\r
\r
  @param  Data             A pointer to a buffer that is filled with key data which is\r
                           retrieved via asynchronous interrupt transfer.\r
  @param  DataLength       Indicates the size of the data buffer.\r
  @param  Context          Pointing to USB_KB_DEV instance.\r
  @param  Result           Indicates the result of the asynchronous interrupt transfer.\r
\r
  @retval EFI_SUCCESS      Asynchronous interrupt transfer is handled successfully.\r
  @retval EFI_DEVICE_ERROR Hardware error occurs.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
KeyboardHandler (\r
  IN  VOID          *Data,\r
  IN  UINTN         DataLength,\r
  IN  VOID          *Context,\r
  IN  UINT32        Result\r
  )\r
{\r
  USB_KB_DEV          *UsbKeyboardDevice;\r
  EFI_USB_IO_PROTOCOL *UsbIo;\r
  UINT8               *CurKeyCodeBuffer;\r
  UINT8               *OldKeyCodeBuffer;\r
  UINT8               CurModifierMap;\r
  UINT8               OldModifierMap;\r
  UINT8               Mask;\r
  UINTN               Index;\r
  UINT8               Index2;\r
  BOOLEAN             KeyRelease;\r
  BOOLEAN             KeyPress;\r
  USB_KEY             UsbKey;\r
  UINT8               NewRepeatKey;\r
  UINT32              UsbStatus;\r
  EFI_KEY_DESCRIPTOR  *KeyDescriptor;\r
\r
  ASSERT (Context != NULL);\r
\r
  NewRepeatKey      = 0;\r
  UsbKeyboardDevice = (USB_KB_DEV *) Context;\r
  UsbIo             = UsbKeyboardDevice->UsbIo;\r
\r
  //\r
  // Analyzes Result and performs corresponding action.\r
  //\r
  if (Result != EFI_USB_NOERROR) {\r
    //\r
    // Some errors happen during the process\r
    //\r
    REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
      EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
      (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INPUT_ERROR),\r
      UsbKeyboardDevice->DevicePath\r
      );\r
\r
    //\r
    // Stop the repeat key generation if any\r
    //\r
    UsbKeyboardDevice->RepeatKey = 0;\r
\r
    gBS->SetTimer (\r
          UsbKeyboardDevice->RepeatTimer,\r
          TimerCancel,\r
          USBKBD_REPEAT_RATE\r
          );\r
\r
    if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {\r
      UsbClearEndpointHalt (\r
        UsbIo,\r
        UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,\r
        &UsbStatus\r
        );\r
    }\r
\r
    //\r
    // Delete & Submit this interrupt again\r
    // Handler of DelayedRecoveryEvent triggered by timer will re-submit the interrupt. \r
    //\r
    UsbIo->UsbAsyncInterruptTransfer (\r
             UsbIo,\r
             UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,\r
             FALSE,\r
             0,\r
             0,\r
             NULL,\r
             NULL\r
             );\r
    //\r
    // EFI_USB_INTERRUPT_DELAY is defined in USB standard for error handling.\r
    //\r
    gBS->SetTimer (\r
           UsbKeyboardDevice->DelayedRecoveryEvent,\r
           TimerRelative,\r
           EFI_USB_INTERRUPT_DELAY\r
           );\r
\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  //\r
  // If no error and no data, just return EFI_SUCCESS.\r
  //\r
  if (DataLength == 0 || Data == NULL) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Following code checks current keyboard input report against old key code buffer.\r
  // According to USB HID Firmware Specification, the report consists of 8 bytes.\r
  // Byte 0 is map of Modifier keys.\r
  // Byte 1 is reserved.\r
  // Bytes 2 to 7 are keycodes.\r
  //\r
  CurKeyCodeBuffer  = (UINT8 *) Data;\r
  OldKeyCodeBuffer  = UsbKeyboardDevice->LastKeyCodeArray;\r
\r
  //\r
  // Checks for new key stroke.\r
  //\r
  for (Index = 0; Index < 8; Index++) {\r
    if (OldKeyCodeBuffer[Index] != CurKeyCodeBuffer[Index]) {\r
      break;\r
    }\r
  }\r
\r
  //\r
  // If no new key, return EFI_SUCCESS immediately.\r
  //\r
  if (Index == 8) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Parse the modifier key, which is the first byte of keyboard input report.\r
  //\r
  CurModifierMap  = CurKeyCodeBuffer[0];\r
  OldModifierMap  = OldKeyCodeBuffer[0];\r
\r
  //\r
  // Handle modifier key's pressing or releasing situation.\r
  // According to USB HID Firmware spec, Byte 0 uses folloing map of Modifier keys:\r
  // Bit0: Left Control,  Keycode: 0xe0\r
  // Bit1: Left Shift,    Keycode: 0xe1\r
  // Bit2: Left Alt,      Keycode: 0xe2\r
  // Bit3: Left GUI,      Keycode: 0xe3\r
  // Bit4: Right Control, Keycode: 0xe4\r
  // Bit5: Right Shift,   Keycode: 0xe5\r
  // Bit6: Right Alt,     Keycode: 0xe6\r
  // Bit7: Right GUI,     Keycode: 0xe7\r
  //\r
  for (Index = 0; Index < 8; Index++) {\r
    Mask = (UINT8) (1 << Index);\r
    if ((CurModifierMap & Mask) != (OldModifierMap & Mask)) {\r
      //\r
      // If current modifier key is up, then CurModifierMap & Mask = 0;\r
      // otherwise it is a non-zero value.\r
      // Insert the changed modifier key into key buffer.\r
      //\r
      UsbKey.KeyCode = (UINT8) (0xe0 + Index);\r
      UsbKey.Down    = (BOOLEAN) ((CurModifierMap & Mask) != 0);\r
      Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));\r
    }\r
  }\r
\r
  //\r
  // Handle normal key's releasing situation\r
  // Bytes 2 to 7 are for normal keycodes\r
  //\r
  KeyRelease = FALSE;\r
  for (Index = 2; Index < 8; Index++) {\r
\r
    if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index])) {\r
      continue;\r
    }\r
    //\r
    // For any key in old keycode buffer, if it is not in current keycode buffer,\r
    // then it is released. Otherwise, it is not released.\r
    //\r
    KeyRelease = TRUE;\r
    for (Index2 = 2; Index2 < 8; Index2++) {\r
\r
      if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index2])) {\r
        continue;\r
      }\r
\r
      if (OldKeyCodeBuffer[Index] == CurKeyCodeBuffer[Index2]) {\r
        KeyRelease = FALSE;\r
        break;\r
      }\r
    }\r
\r
    if (KeyRelease) {\r
      UsbKey.KeyCode = OldKeyCodeBuffer[Index];\r
      UsbKey.Down    = FALSE;\r
      Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));\r
      //\r
      // The original repeat key is released.\r
      //\r
      if (OldKeyCodeBuffer[Index] == UsbKeyboardDevice->RepeatKey) {\r
        UsbKeyboardDevice->RepeatKey = 0;\r
      }\r
    }\r
  }\r
\r
  //\r
  // If original repeat key is released, cancel the repeat timer\r
  //\r
  if (UsbKeyboardDevice->RepeatKey == 0) {\r
    gBS->SetTimer (\r
           UsbKeyboardDevice->RepeatTimer,\r
           TimerCancel,\r
           USBKBD_REPEAT_RATE\r
           );\r
  }\r
\r
  //\r
  // Handle normal key's pressing situation\r
  //\r
  KeyPress = FALSE;\r
  for (Index = 2; Index < 8; Index++) {\r
\r
    if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index])) {\r
      continue;\r
    }\r
    //\r
    // For any key in current keycode buffer, if it is not in old keycode buffer,\r
    // then it is pressed. Otherwise, it is not pressed.\r
    //\r
    KeyPress = TRUE;\r
    for (Index2 = 2; Index2 < 8; Index2++) {\r
\r
      if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index2])) {\r
        continue;\r
      }\r
\r
      if (CurKeyCodeBuffer[Index] == OldKeyCodeBuffer[Index2]) {\r
        KeyPress = FALSE;\r
        break;\r
      }\r
    }\r
\r
    if (KeyPress) {\r
      UsbKey.KeyCode = CurKeyCodeBuffer[Index];\r
      UsbKey.Down    = TRUE;\r
      Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));\r
\r
      //\r
      // Handle repeat key\r
      //\r
      KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, CurKeyCodeBuffer[Index]);\r
      ASSERT (KeyDescriptor != NULL);\r
\r
      if (KeyDescriptor->Modifier == EFI_NUM_LOCK_MODIFIER || KeyDescriptor->Modifier == EFI_CAPS_LOCK_MODIFIER) {\r
        //\r
        // For NumLock or CapsLock pressed, there is no need to handle repeat key for them.\r
        //\r
        UsbKeyboardDevice->RepeatKey = 0;\r
      } else {\r
        //\r
        // Prepare new repeat key, and clear the original one.\r
        //\r
        NewRepeatKey = CurKeyCodeBuffer[Index];\r
        UsbKeyboardDevice->RepeatKey = 0;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Update LastKeycodeArray buffer in the UsbKeyboardDevice data structure.\r
  //\r
  for (Index = 0; Index < 8; Index++) {\r
    UsbKeyboardDevice->LastKeyCodeArray[Index] = CurKeyCodeBuffer[Index];\r
  }\r
\r
  //\r
  // If there is new key pressed, update the RepeatKey value, and set the\r
  // timer to repeate delay timer\r
  //\r
  if (NewRepeatKey != 0) {\r
    //\r
    // Sets trigger time to "Repeat Delay Time",\r
    // to trigger the repeat timer when the key is hold long\r
    // enough time.\r
    //\r
    gBS->SetTimer (\r
           UsbKeyboardDevice->RepeatTimer,\r
           TimerRelative,\r
           USBKBD_REPEAT_DELAY\r
           );\r
    UsbKeyboardDevice->RepeatKey = NewRepeatKey;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Retrieves a USB keycode after parsing the raw data in keyboard buffer.\r
\r
  This function parses keyboard buffer. It updates state of modifier key for\r
  USB_KB_DEV instancem, and returns keycode for output.\r
\r
  @param  UsbKeyboardDevice    The USB_KB_DEV instance.\r
  @param  KeyCode              Pointer to the USB keycode for output.\r
\r
  @retval EFI_SUCCESS          Keycode successfully parsed.\r
  @retval EFI_NOT_READY        Keyboard buffer is not ready for a valid keycode\r
\r
**/\r
EFI_STATUS\r
USBParseKey (\r
  IN OUT  USB_KB_DEV  *UsbKeyboardDevice,\r
     OUT  UINT8       *KeyCode\r
  )\r
{\r
  USB_KEY             UsbKey;\r
  EFI_KEY_DESCRIPTOR  *KeyDescriptor;\r
\r
  *KeyCode = 0;\r
\r
  while (!IsQueueEmpty (&UsbKeyboardDevice->UsbKeyQueue)) {\r
    //\r
    // Pops one raw data off.\r
    //\r
    Dequeue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));\r
\r
    KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, UsbKey.KeyCode);\r
    ASSERT (KeyDescriptor != NULL);\r
\r
    if (!UsbKey.Down) {\r
      //\r
      // Key is released.\r
      //\r
      switch (KeyDescriptor->Modifier) {\r
\r
      //\r
      // Ctrl release\r
      //\r
      case EFI_LEFT_CONTROL_MODIFIER:\r
        UsbKeyboardDevice->LeftCtrlOn = FALSE;\r
        UsbKeyboardDevice->CtrlOn = FALSE;\r
        break;\r
      case EFI_RIGHT_CONTROL_MODIFIER:\r
        UsbKeyboardDevice->RightCtrlOn = FALSE;\r
        UsbKeyboardDevice->CtrlOn = FALSE;\r
        break;\r
\r
      //\r
      // Shift release\r
      //\r
      case EFI_LEFT_SHIFT_MODIFIER:\r
        UsbKeyboardDevice->LeftShiftOn = FALSE;\r
        UsbKeyboardDevice->ShiftOn = FALSE;\r
        break;\r
      case EFI_RIGHT_SHIFT_MODIFIER:\r
        UsbKeyboardDevice->RightShiftOn = FALSE;\r
        UsbKeyboardDevice->ShiftOn = FALSE;\r
        break;\r
\r
      //\r
      // Alt release\r
      //\r
      case EFI_LEFT_ALT_MODIFIER:\r
        UsbKeyboardDevice->LeftAltOn = FALSE;\r
        UsbKeyboardDevice->AltOn = FALSE;\r
        break;\r
      case EFI_RIGHT_ALT_MODIFIER:\r
        UsbKeyboardDevice->RightAltOn = FALSE;\r
        UsbKeyboardDevice->AltOn = FALSE;\r
        break;\r
\r
      //\r
      // Left Logo release\r
      //\r
      case EFI_LEFT_LOGO_MODIFIER:\r
        UsbKeyboardDevice->LeftLogoOn = FALSE;\r
        break;\r
\r
      //\r
      // Right Logo release\r
      //\r
      case EFI_RIGHT_LOGO_MODIFIER:\r
        UsbKeyboardDevice->RightLogoOn = FALSE;\r
        break;\r
\r
      //\r
      // Menu key release\r
      //\r
      case EFI_MENU_MODIFIER:\r
        UsbKeyboardDevice->MenuKeyOn = FALSE;\r
        break;\r
\r
      //\r
      // SysReq release\r
      //\r
      case EFI_PRINT_MODIFIER:\r
      case EFI_SYS_REQUEST_MODIFIER:\r
        UsbKeyboardDevice->SysReqOn = FALSE;\r
        break;\r
\r
      //\r
      // AltGr release\r
      //\r
      case EFI_ALT_GR_MODIFIER:\r
        UsbKeyboardDevice->AltGrOn = FALSE;\r
        break;\r
\r
      default:\r
        break;\r
      }\r
\r
      continue;\r
    }\r
\r
    //\r
    // Analyzes key pressing situation\r
    //\r
    switch (KeyDescriptor->Modifier) {\r
\r
    //\r
    // Ctrl press\r
    //\r
    case EFI_LEFT_CONTROL_MODIFIER:\r
      UsbKeyboardDevice->LeftCtrlOn = TRUE;\r
      UsbKeyboardDevice->CtrlOn = TRUE;\r
      continue;\r
      break;\r
    case EFI_RIGHT_CONTROL_MODIFIER:\r
      UsbKeyboardDevice->RightCtrlOn = TRUE;\r
      UsbKeyboardDevice->CtrlOn = TRUE;\r
      continue;\r
      break;\r
\r
    //\r
    // Shift press\r
    //\r
    case EFI_LEFT_SHIFT_MODIFIER:\r
      UsbKeyboardDevice->LeftShiftOn = TRUE;\r
      UsbKeyboardDevice->ShiftOn = TRUE;\r
      continue;\r
      break;\r
    case EFI_RIGHT_SHIFT_MODIFIER:\r
      UsbKeyboardDevice->RightShiftOn = TRUE;\r
      UsbKeyboardDevice->ShiftOn = TRUE;\r
      continue;\r
      break;\r
\r
    //\r
    // Alt press\r
    //\r
    case EFI_LEFT_ALT_MODIFIER:\r
      UsbKeyboardDevice->LeftAltOn = TRUE;\r
      UsbKeyboardDevice->AltOn = TRUE;\r
      continue;\r
      break;\r
    case EFI_RIGHT_ALT_MODIFIER:\r
      UsbKeyboardDevice->RightAltOn = TRUE;\r
      UsbKeyboardDevice->AltOn = TRUE;\r
      continue;\r
      break;\r
\r
    //\r
    // Left Logo press\r
    //\r
    case EFI_LEFT_LOGO_MODIFIER:\r
      UsbKeyboardDevice->LeftLogoOn = TRUE;\r
      break;\r
\r
    //\r
    // Right Logo press\r
    //\r
    case EFI_RIGHT_LOGO_MODIFIER:\r
      UsbKeyboardDevice->RightLogoOn = TRUE;\r
      break;\r
\r
    //\r
    // Menu key press\r
    //\r
    case EFI_MENU_MODIFIER:\r
      UsbKeyboardDevice->MenuKeyOn = TRUE;\r
      break;\r
\r
    //\r
    // SysReq press\r
    //\r
    case EFI_PRINT_MODIFIER:\r
    case EFI_SYS_REQUEST_MODIFIER:\r
      UsbKeyboardDevice->SysReqOn = TRUE;\r
      continue;\r
      break;\r
\r
    //\r
    // AltGr press\r
    //\r
    case EFI_ALT_GR_MODIFIER:\r
      UsbKeyboardDevice->AltGrOn = TRUE;\r
      break;\r
\r
    case EFI_NUM_LOCK_MODIFIER:\r
      //\r
      // Toggle NumLock\r
      //\r
      UsbKeyboardDevice->NumLockOn = (BOOLEAN) (!(UsbKeyboardDevice->NumLockOn));\r
      SetKeyLED (UsbKeyboardDevice);\r
      continue;\r
      break;\r
\r
    case EFI_CAPS_LOCK_MODIFIER:\r
      //\r
      // Toggle CapsLock\r
      //\r
      UsbKeyboardDevice->CapsOn = (BOOLEAN) (!(UsbKeyboardDevice->CapsOn));\r
      SetKeyLED (UsbKeyboardDevice);\r
      continue;\r
      break;\r
\r
    case EFI_SCROLL_LOCK_MODIFIER:\r
      //\r
      // Toggle ScrollLock\r
      //\r
      UsbKeyboardDevice->ScrollOn = (BOOLEAN) (!(UsbKeyboardDevice->ScrollOn));\r
      SetKeyLED (UsbKeyboardDevice);\r
      continue;\r
      break;\r
\r
    default:\r
      break;\r
    }\r
\r
    //\r
    // When encountering Ctrl + Alt + Del, then warm reset.\r
    //\r
    if (KeyDescriptor->Modifier == EFI_DELETE_MODIFIER) {\r
      if ((UsbKeyboardDevice->CtrlOn) && (UsbKeyboardDevice->AltOn)) {\r
        gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);\r
      }\r
    }\r
\r
    *KeyCode = UsbKey.KeyCode;\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_READY;\r
}\r
\r
\r
/**\r
  Converts USB Keycode ranging from 0x4 to 0x65 to EFI_INPUT_KEY.\r
\r
  @param  UsbKeyboardDevice     The USB_KB_DEV instance.\r
  @param  KeyCode               Indicates the key code that will be interpreted.\r
  @param  KeyData               A pointer to a buffer that is filled in with\r
                                the keystroke information for the key that\r
                                was pressed.\r
\r
  @retval EFI_SUCCESS           Success.\r
  @retval EFI_INVALID_PARAMETER KeyCode is not in the range of 0x4 to 0x65.\r
  @retval EFI_INVALID_PARAMETER Translated EFI_INPUT_KEY has zero for both ScanCode and UnicodeChar.\r
  @retval EFI_NOT_READY         KeyCode represents a dead key with EFI_NS_KEY_MODIFIER\r
  @retval EFI_DEVICE_ERROR      Keyboard layout is invalid.\r
\r
**/\r
EFI_STATUS\r
UsbKeyCodeToEfiInputKey (\r
  IN  USB_KB_DEV                *UsbKeyboardDevice,\r
  IN  UINT8                     KeyCode,\r
  OUT EFI_KEY_DATA              *KeyData\r
  )\r
{\r
  EFI_KEY_DESCRIPTOR            *KeyDescriptor;\r
  LIST_ENTRY                    *Link;\r
  LIST_ENTRY                    *NotifyList;\r
  KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify;  \r
\r
  //\r
  // KeyCode must in the range of 0x4 to 0x65\r
  //\r
  if (!USBKBD_VALID_KEYCODE (KeyCode)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if ((KeyCode - 4) >= NUMBER_OF_VALID_NON_MODIFIER_USB_KEYCODE) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, KeyCode);\r
  ASSERT (KeyDescriptor != NULL);\r
\r
  if (KeyDescriptor->Modifier == EFI_NS_KEY_MODIFIER) {\r
    //\r
    // If this is a dead key with EFI_NS_KEY_MODIFIER, then record it and return.\r
    //\r
    UsbKeyboardDevice->CurrentNsKey = FindUsbNsKey (UsbKeyboardDevice, KeyDescriptor);\r
    return EFI_NOT_READY;\r
  }\r
\r
  if (UsbKeyboardDevice->CurrentNsKey != NULL) {\r
    //\r
    // If this keystroke follows a non-spacing key, then find the descriptor for corresponding\r
    // physical key.\r
    //\r
    KeyDescriptor = FindPhysicalKey (UsbKeyboardDevice->CurrentNsKey, KeyDescriptor);\r
    UsbKeyboardDevice->CurrentNsKey = NULL;\r
  }\r
\r
  //\r
  // Make sure modifier of Key Descriptor is in the valid range according to UEFI spec.\r
  //\r
  if (KeyDescriptor->Modifier > (sizeof (ModifierValueToEfiScanCodeConvertionTable) / sizeof (UINT8))) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  KeyData->Key.ScanCode    = ModifierValueToEfiScanCodeConvertionTable[KeyDescriptor->Modifier];\r
  KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;\r
\r
  if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_STANDARD_SHIFT)!= 0) {\r
    if (UsbKeyboardDevice->ShiftOn) {\r
      KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode;\r
\r
      //\r
      // Need not return associated shift state if a class of printable characters that\r
      // are normally adjusted by shift modifiers. e.g. Shift Key + 'f' key = 'F'\r
      //\r
      if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) != 0) {\r
        UsbKeyboardDevice->LeftShiftOn = FALSE;\r
        UsbKeyboardDevice->RightShiftOn = FALSE;\r
      }\r
\r
      if (UsbKeyboardDevice->AltGrOn) {\r
        KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedAltGrUnicode;\r
      }\r
    } else {\r
      //\r
      // Shift off\r
      //\r
      KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;\r
\r
      if (UsbKeyboardDevice->AltGrOn) {\r
        KeyData->Key.UnicodeChar = KeyDescriptor->AltGrUnicode;\r
      }\r
    }\r
  }\r
\r
  if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) != 0) {\r
    if (UsbKeyboardDevice->CapsOn) {\r
      if (KeyData->Key.UnicodeChar == KeyDescriptor->Unicode) {\r
        KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode;\r
      } else if (KeyData->Key.UnicodeChar == KeyDescriptor->ShiftedUnicode) {\r
        KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;\r
      }\r
    }\r
  }\r
\r
  if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_NUM_LOCK) != 0) {\r
    //\r
    // For key affected by NumLock, if NumLock is on and Shift is not pressed, then it means\r
    // normal key, instead of original control key. So the ScanCode should be cleaned.\r
    // Otherwise, it means control key, so preserve the EFI Scan Code and clear the unicode keycode.\r
    //\r
    if ((UsbKeyboardDevice->NumLockOn) && (!(UsbKeyboardDevice->ShiftOn))) {\r
      KeyData->Key.ScanCode = SCAN_NULL;\r
    } else {\r
      KeyData->Key.UnicodeChar = 0x00;\r
    }\r
  }\r
\r
  //\r
  // Translate Unicode 0x1B (ESC) to EFI Scan Code\r
  //\r
  if (KeyData->Key.UnicodeChar == 0x1B && KeyData->Key.ScanCode == SCAN_NULL) {\r
    KeyData->Key.ScanCode = SCAN_ESC;\r
    KeyData->Key.UnicodeChar = 0x00;\r
  }\r
\r
  //\r
  // Not valid for key without both unicode key code and EFI Scan Code.\r
  //\r
  if (KeyData->Key.UnicodeChar == 0 && KeyData->Key.ScanCode == SCAN_NULL) {\r
    return EFI_NOT_READY;\r
  }\r
\r
  //\r
  // Save Shift/Toggle state\r
  //\r
  KeyData->KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID;\r
  KeyData->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;\r
\r
  if (UsbKeyboardDevice->LeftCtrlOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->RightCtrlOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->LeftAltOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->RightAltOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_RIGHT_ALT_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->LeftShiftOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->RightShiftOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->LeftLogoOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->RightLogoOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->MenuKeyOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_MENU_KEY_PRESSED;\r
  }\r
  if (UsbKeyboardDevice->SysReqOn) {\r
    KeyData->KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED;\r
  }\r
\r
  if (UsbKeyboardDevice->ScrollOn) {\r
    KeyData->KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;\r
  }\r
  if (UsbKeyboardDevice->NumLockOn) {\r
    KeyData->KeyState.KeyToggleState |= EFI_NUM_LOCK_ACTIVE;\r
  }\r
  if (UsbKeyboardDevice->CapsOn) {\r
    KeyData->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;\r
  }\r
\r
  //\r
  // Invoke notification functions if the key is registered.\r
  //\r
  NotifyList = &UsbKeyboardDevice->NotifyList;\r
  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {\r
    CurrentNotify = CR (Link, KEYBOARD_CONSOLE_IN_EX_NOTIFY, NotifyEntry, USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE);\r
    if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) { \r
      CurrentNotify->KeyNotificationFn (KeyData);\r
    }\r
  }\r
\r
  //\r
  // Translate the CTRL-Alpha characters to their corresponding control value\r
  // (ctrl-a = 0x0001 through ctrl-Z = 0x001A)\r
  //\r
  if (UsbKeyboardDevice->CtrlOn) {\r
    if (KeyData->Key.UnicodeChar >= 'a' && KeyData->Key.UnicodeChar <= 'z') {\r
      KeyData->Key.UnicodeChar = (UINT8) (KeyData->Key.UnicodeChar - 'a' + 1);\r
    } else if (KeyData->Key.UnicodeChar >= 'A' && KeyData->Key.UnicodeChar <= 'Z') {\r
      KeyData->Key.UnicodeChar = (UINT8) (KeyData->Key.UnicodeChar - 'A' + 1);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Create the queue.\r
\r
  @param  Queue     Points to the queue.\r
  @param  ItemSize  Size of the single item.\r
\r
**/\r
VOID\r
InitQueue (\r
  IN OUT  USB_SIMPLE_QUEUE   *Queue,\r
  IN      UINTN              ItemSize\r
  )\r
{\r
  UINTN                      Index;\r
\r
  Queue->ItemSize  = ItemSize;\r
  Queue->Head      = 0;\r
  Queue->Tail      = 0;\r
\r
  if (Queue->Buffer[0] != NULL) {\r
    FreePool (Queue->Buffer[0]);\r
  }\r
\r
  Queue->Buffer[0] = AllocatePool (sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]) * ItemSize);\r
  ASSERT (Queue->Buffer[0] != NULL);\r
\r
  for (Index = 1; Index < sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]); Index++) {\r
    Queue->Buffer[Index] = ((UINT8 *) Queue->Buffer[Index - 1]) + ItemSize;\r
  }\r
}\r
\r
/**\r
  Destroy the queue\r
\r
  @param Queue    Points to the queue.\r
**/\r
VOID\r
DestroyQueue (\r
  IN OUT USB_SIMPLE_QUEUE   *Queue\r
  )\r
{\r
  FreePool (Queue->Buffer[0]);\r
}\r
\r
\r
/**\r
  Check whether the queue is empty.\r
\r
  @param  Queue     Points to the queue.\r
\r
  @retval TRUE      Queue is empty.\r
  @retval FALSE     Queue is not empty.\r
\r
**/\r
BOOLEAN\r
IsQueueEmpty (\r
  IN  USB_SIMPLE_QUEUE   *Queue\r
  )\r
{\r
  //\r
  // Meet FIFO empty condition\r
  //\r
  return (BOOLEAN) (Queue->Head == Queue->Tail);\r
}\r
\r
\r
/**\r
  Check whether the queue is full.\r
\r
  @param  Queue     Points to the queue.\r
\r
  @retval TRUE      Queue is full.\r
  @retval FALSE     Queue is not full.\r
\r
**/\r
BOOLEAN\r
IsQueueFull (\r
  IN  USB_SIMPLE_QUEUE   *Queue\r
  )\r
{\r
  return (BOOLEAN) (((Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1)) == Queue->Head);\r
}\r
\r
\r
/**\r
  Enqueue the item to the queue.\r
\r
  @param  Queue     Points to the queue.\r
  @param  Item      Points to the item to be enqueued.\r
  @param  ItemSize  Size of the item.\r
**/\r
VOID\r
Enqueue (\r
  IN OUT  USB_SIMPLE_QUEUE *Queue,\r
  IN      VOID             *Item,\r
  IN      UINTN            ItemSize\r
  )\r
{\r
  ASSERT (ItemSize == Queue->ItemSize);\r
  //\r
  // If keyboard buffer is full, throw the\r
  // first key out of the keyboard buffer.\r
  //\r
  if (IsQueueFull (Queue)) {\r
    Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1);\r
  }\r
\r
  CopyMem (Queue->Buffer[Queue->Tail], Item, ItemSize);\r
\r
  //\r
  // Adjust the tail pointer of the FIFO keyboard buffer.\r
  //\r
  Queue->Tail = (Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1);\r
}\r
\r
\r
/**\r
  Dequeue a item from the queue.\r
\r
  @param  Queue     Points to the queue.\r
  @param  Item      Receives the item.\r
  @param  ItemSize  Size of the item.\r
\r
  @retval EFI_SUCCESS        Item was successfully dequeued.\r
  @retval EFI_DEVICE_ERROR   The queue is empty.\r
\r
**/\r
EFI_STATUS\r
Dequeue (\r
  IN OUT  USB_SIMPLE_QUEUE *Queue,\r
     OUT  VOID             *Item,\r
  IN      UINTN            ItemSize\r
  )\r
{\r
  ASSERT (Queue->ItemSize == ItemSize);\r
\r
  if (IsQueueEmpty (Queue)) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  CopyMem (Item, Queue->Buffer[Queue->Head], ItemSize);\r
\r
  //\r
  // Adjust the head pointer of the FIFO keyboard buffer.\r
  //\r
  Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Sets USB keyboard LED state.\r
\r
  @param  UsbKeyboardDevice  The USB_KB_DEV instance.\r
\r
**/\r
VOID\r
SetKeyLED (\r
  IN  USB_KB_DEV    *UsbKeyboardDevice\r
  )\r
{\r
  LED_MAP Led;\r
  UINT8   ReportId;\r
\r
  //\r
  // Set each field in Led map.\r
  //\r
  Led.NumLock    = (UINT8) ((UsbKeyboardDevice->NumLockOn) ? 1 : 0);\r
  Led.CapsLock   = (UINT8) ((UsbKeyboardDevice->CapsOn) ? 1 : 0);\r
  Led.ScrollLock = (UINT8) ((UsbKeyboardDevice->ScrollOn) ? 1 : 0);\r
  Led.Resrvd     = 0;\r
\r
  ReportId       = 0;\r
  //\r
  // Call Set_Report Request to lighten the LED.\r
  //\r
  UsbSetReportRequest (\r
    UsbKeyboardDevice->UsbIo,\r
    UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,\r
    ReportId,\r
    HID_OUTPUT_REPORT,\r
    1,\r
    (UINT8 *) &Led\r
    );\r
}\r
\r
\r
/**\r
  Handler for Repeat Key event.\r
\r
  This function is the handler for Repeat Key event triggered\r
  by timer.\r
  After a repeatable key is pressed, the event would be triggered\r
  with interval of USBKBD_REPEAT_DELAY. Once the event is triggered,\r
  following trigger will come with interval of USBKBD_REPEAT_RATE.\r
\r
  @param  Event              The Repeat Key event.\r
  @param  Context            Points to the USB_KB_DEV instance.\r
\r
**/\r
VOID\r
EFIAPI\r
USBKeyboardRepeatHandler (\r
  IN    EFI_EVENT    Event,\r
  IN    VOID         *Context\r
  )\r
{\r
  USB_KB_DEV  *UsbKeyboardDevice;\r
  USB_KEY     UsbKey;\r
\r
  UsbKeyboardDevice = (USB_KB_DEV *) Context;\r
\r
  //\r
  // Do nothing when there is no repeat key.\r
  //\r
  if (UsbKeyboardDevice->RepeatKey != 0) {\r
    //\r
    // Inserts the repeat key into keyboard buffer,\r
    //\r
    UsbKey.KeyCode = UsbKeyboardDevice->RepeatKey;\r
    UsbKey.Down    = TRUE;\r
    Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));\r
\r
    //\r
    // Set repeat rate for next repeat key generation.\r
    //\r
    gBS->SetTimer (\r
           UsbKeyboardDevice->RepeatTimer,\r
           TimerRelative,\r
           USBKBD_REPEAT_RATE\r
           );\r
  }\r
}\r
\r
\r
/**\r
  Handler for Delayed Recovery event.\r
\r
  This function is the handler for Delayed Recovery event triggered\r
  by timer.\r
  After a device error occurs, the event would be triggered\r
  with interval of EFI_USB_INTERRUPT_DELAY. EFI_USB_INTERRUPT_DELAY\r
  is defined in USB standard for error handling.\r
\r
  @param  Event              The Delayed Recovery event.\r
  @param  Context            Points to the USB_KB_DEV instance.\r
\r
**/\r
VOID\r
EFIAPI\r
USBKeyboardRecoveryHandler (\r
  IN    EFI_EVENT    Event,\r
  IN    VOID         *Context\r
  )\r
{\r
\r
  USB_KB_DEV          *UsbKeyboardDevice;\r
  EFI_USB_IO_PROTOCOL *UsbIo;\r
  UINT8               PacketSize;\r
\r
  UsbKeyboardDevice = (USB_KB_DEV *) Context;\r
\r
  UsbIo             = UsbKeyboardDevice->UsbIo;\r
\r
  PacketSize        = (UINT8) (UsbKeyboardDevice->IntEndpointDescriptor.MaxPacketSize);\r
\r
  //\r
  // Re-submit Asynchronous Interrupt Transfer for recovery.\r
  //\r
  UsbIo->UsbAsyncInterruptTransfer (\r
           UsbIo,\r
           UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,\r
           TRUE,\r
           UsbKeyboardDevice->IntEndpointDescriptor.Interval,\r
           PacketSize,\r
           KeyboardHandler,\r
           UsbKeyboardDevice\r
           );\r
}\r