// // This file contains a 'Sample Driver' and is licensed as such // under the terms of your license agreement with Intel or your // vendor. This file may be modified by the user, subject to // the additional terms of the license agreement // /** @file Helper functions for HID Keyboard Driver. Copyright (c) 2013 - 2019, Intel Corporation. All rights reserved.
This software and associated documentation (if any) is furnished under a license and may only be used or copied in accordance with the terms of the license. Except as permitted by such license, no part of this software or documentation may be reproduced, stored in a retrieval system, or transmitted in any form or by any means without the express written consent of Intel Corporation. **/ #include "HidKbDxe.h" #include "KeyBoard.h" #define HI_BYTE(x) (x & 0xff00) // Extracts the Most Significant byte of UINT16 #define LO_BYTE(x) (x & 0x00ff) // Extracts the Least Significant byte of UINT16 HID_KEYBOARD_LAYOUT_PACK_BIN mHidKeyboardLayoutBin = { sizeof (HID_KEYBOARD_LAYOUT_PACK_BIN), // Binary size // // EFI_HII_PACKAGE_HEADER // { sizeof (HID_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32), EFI_HII_PACKAGE_KEYBOARD_LAYOUT }, 1, // LayoutCount sizeof (HID_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32) - sizeof (EFI_HII_PACKAGE_HEADER) - sizeof (UINT16), // LayoutLength HID_KEYBOARD_LAYOUT_KEY_GUID, // KeyGuid sizeof (UINT16) + sizeof (EFI_GUID) + sizeof (UINT32) + sizeof (UINT8) + (HID_KEYBOARD_KEY_COUNT * sizeof (EFI_KEY_DESCRIPTOR)), // LayoutDescriptorStringOffset HID_KEYBOARD_KEY_COUNT, // DescriptorCount { // // EFI_KEY_DESCRIPTOR (total number is HID_KEYBOARD_KEY_COUNT) // {EfiKeyC1, 'a', 'A', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB5, 'b', 'B', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB3, 'c', 'C', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC3, 'd', 'D', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD3, 'e', 'E', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC4, 'f', 'F', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC5, 'g', 'G', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC6, 'h', 'H', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD8, 'i', 'I', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC7, 'j', 'J', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC8, 'k', 'K', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC9, 'l', 'L', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB7, 'm', 'M', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB6, 'n', 'N', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD9, 'o', 'O', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD10, 'p', 'P', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD1, 'q', 'Q', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD4, 'r', 'R', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyC2, 's', 'S', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD5, 't', 'T', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD7, 'u', 'U', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB4, 'v', 'V', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD2, 'w', 'W', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB2, 'x', 'X', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyD6, 'y', 'Y', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyB1, 'z', 'Z', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK}, {EfiKeyE1, '1', '!', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE2, '2', '@', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE3, '3', '#', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE4, '4', '$', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE5, '5', '%', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE6, '6', '^', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE7, '7', '&', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE8, '8', '*', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE9, '9', '(', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE10, '0', ')', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyEnter, 0x0d, 0x0d, 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyEsc, 0x1b, 0x1b, 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyBackSpace, 0x08, 0x08, 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyTab, 0x09, 0x09, 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeySpaceBar, ' ', ' ', 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyE11, '-', '_', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE12, '=', '+', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyD11, '[', '{', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyD12, ']', '}', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyD13, '\\', '|', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyC12, '\\', '|', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyC10, ';', ':', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyC11, '\'', '"', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyE0, '`', '~', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyB8, ',', '<', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyB9, '.', '>', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyB10, '/', '?', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT}, {EfiKeyCapsLock, 0x00, 0x00, 0, 0, EFI_CAPS_LOCK_MODIFIER, 0}, {EfiKeyF1, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_ONE_MODIFIER, 0}, {EfiKeyF2, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TWO_MODIFIER, 0}, {EfiKeyF3, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_THREE_MODIFIER, 0}, {EfiKeyF4, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_FOUR_MODIFIER, 0}, {EfiKeyF5, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_FIVE_MODIFIER, 0}, {EfiKeyF6, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_SIX_MODIFIER, 0}, {EfiKeyF7, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_SEVEN_MODIFIER, 0}, {EfiKeyF8, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_EIGHT_MODIFIER, 0}, {EfiKeyF9, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_NINE_MODIFIER, 0}, {EfiKeyF10, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TEN_MODIFIER, 0}, {EfiKeyF11, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_ELEVEN_MODIFIER, 0}, {EfiKeyF12, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TWELVE_MODIFIER, 0}, {EfiKeyPrint, 0x00, 0x00, 0, 0, EFI_PRINT_MODIFIER, 0}, {EfiKeySLck, 0x00, 0x00, 0, 0, EFI_SCROLL_LOCK_MODIFIER, 0}, {EfiKeyPause, 0x00, 0x00, 0, 0, EFI_PAUSE_MODIFIER, 0}, {EfiKeyIns, 0x00, 0x00, 0, 0, EFI_INSERT_MODIFIER, 0}, {EfiKeyHome, 0x00, 0x00, 0, 0, EFI_HOME_MODIFIER, 0}, {EfiKeyPgUp, 0x00, 0x00, 0, 0, EFI_PAGE_UP_MODIFIER, 0}, {EfiKeyDel, 0x00, 0x00, 0, 0, EFI_DELETE_MODIFIER, 0}, {EfiKeyEnd, 0x00, 0x00, 0, 0, EFI_END_MODIFIER, 0}, {EfiKeyPgDn, 0x00, 0x00, 0, 0, EFI_PAGE_DOWN_MODIFIER, 0}, {EfiKeyRightArrow, 0x00, 0x00, 0, 0, EFI_RIGHT_ARROW_MODIFIER, 0}, {EfiKeyLeftArrow, 0x00, 0x00, 0, 0, EFI_LEFT_ARROW_MODIFIER, 0}, {EfiKeyDownArrow, 0x00, 0x00, 0, 0, EFI_DOWN_ARROW_MODIFIER, 0}, {EfiKeyUpArrow, 0x00, 0x00, 0, 0, EFI_UP_ARROW_MODIFIER, 0}, {EfiKeyNLck, 0x00, 0x00, 0, 0, EFI_NUM_LOCK_MODIFIER, 0}, {EfiKeySlash, '/', '/', 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyAsterisk, '*', '*', 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyMinus, '-', '-', 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyPlus, '+', '+', 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyEnter, 0x0d, 0x0d, 0, 0, EFI_NULL_MODIFIER, 0}, {EfiKeyOne, '1', '1', 0, 0, EFI_END_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyTwo, '2', '2', 0, 0, EFI_DOWN_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyThree, '3', '3', 0, 0, EFI_PAGE_DOWN_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyFour, '4', '4', 0, 0, EFI_LEFT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyFive, '5', '5', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeySix, '6', '6', 0, 0, EFI_RIGHT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeySeven, '7', '7', 0, 0, EFI_HOME_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyEight, '8', '8', 0, 0, EFI_UP_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyNine, '9', '9', 0, 0, EFI_PAGE_UP_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyZero, '0', '0', 0, 0, EFI_INSERT_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyPeriod, '.', '.', 0, 0, EFI_DELETE_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK}, {EfiKeyA4, 0x00, 0x00, 0, 0, EFI_MENU_MODIFIER, 0}, {EfiKeyLCtrl, 0, 0, 0, 0, EFI_LEFT_CONTROL_MODIFIER, 0}, {EfiKeyLShift, 0, 0, 0, 0, EFI_LEFT_SHIFT_MODIFIER, 0}, {EfiKeyLAlt, 0, 0, 0, 0, EFI_LEFT_ALT_MODIFIER, 0}, {EfiKeyA0, 0, 0, 0, 0, EFI_LEFT_LOGO_MODIFIER, 0}, {EfiKeyRCtrl, 0, 0, 0, 0, EFI_RIGHT_CONTROL_MODIFIER, 0}, {EfiKeyRShift, 0, 0, 0, 0, EFI_RIGHT_SHIFT_MODIFIER, 0}, {EfiKeyA2, 0, 0, 0, 0, EFI_RIGHT_ALT_MODIFIER, 0}, {EfiKeyA3, 0, 0, 0, 0, EFI_RIGHT_LOGO_MODIFIER, 0}, }, 1, // DescriptionCount {'e', 'n', '-', 'U', 'S'}, // RFC4646 language code ' ', // Space {'E', 'n', 'g', 'l', 'i', 's', 'h', ' ', 'K', 'e', 'y', 'b', 'o', 'a', 'r', 'd', '\0'}, // DescriptionString[] }; // // Keyboard LED Indexes // enum { EFI_KEY_NUM_LOCK = 0x01, EFI_KEY_CAPS_LOCK, EFI_KEY_SCROLL_LOCK, }; // // EFI_KEY to HID Keycode conversion table // EFI_KEY is defined in UEFI spec. // HID Keycode is defined in HID HID Firmware spec. // UINT8 EfiKeyToHidKeyCodeConvertionTable[] = { 0xe0, // EfiKeyLCtrl 0xe3, // EfiKeyA0 0xe2, // EfiKeyLAlt 0x2c, // EfiKeySpaceBar 0xe6, // EfiKeyA2 0xe7, // EfiKeyA3 0x65, // EfiKeyA4 0xe4, // EfiKeyRCtrl 0x50, // EfiKeyLeftArrow 0x51, // EfiKeyDownArrow 0x4F, // EfiKeyRightArrow 0x62, // EfiKeyZero 0x63, // EfiKeyPeriod 0x28, // EfiKeyEnter 0xe1, // EfiKeyLShift 0x64, // EfiKeyB0 0x1D, // EfiKeyB1 0x1B, // EfiKeyB2 0x06, // EfiKeyB3 0x19, // EfiKeyB4 0x05, // EfiKeyB5 0x11, // EfiKeyB6 0x10, // EfiKeyB7 0x36, // EfiKeyB8 0x37, // EfiKeyB9 0x38, // EfiKeyB10 0xe5, // EfiKeyRShift 0x52, // EfiKeyUpArrow 0x59, // EfiKeyOne 0x5A, // EfiKeyTwo 0x5B, // EfiKeyThree 0x39, // EfiKeyCapsLock 0x04, // EfiKeyC1 0x16, // EfiKeyC2 0x07, // EfiKeyC3 0x09, // EfiKeyC4 0x0A, // EfiKeyC5 0x0B, // EfiKeyC6 0x0D, // EfiKeyC7 0x0E, // EfiKeyC8 0x0F, // EfiKeyC9 0x33, // EfiKeyC10 0x34, // EfiKeyC11 0x32, // EfiKeyC12 0x5C, // EfiKeyFour 0x5D, // EfiKeyFive 0x5E, // EfiKeySix 0x57, // EfiKeyPlus 0x2B, // EfiKeyTab 0x14, // EfiKeyD1 0x1A, // EfiKeyD2 0x08, // EfiKeyD3 0x15, // EfiKeyD4 0x17, // EfiKeyD5 0x1C, // EfiKeyD6 0x18, // EfiKeyD7 0x0C, // EfiKeyD8 0x12, // EfiKeyD9 0x13, // EfiKeyD10 0x2F, // EfiKeyD11 0x30, // EfiKeyD12 0x31, // EfiKeyD13 0x4C, // EfiKeyDel 0x4D, // EfiKeyEnd 0x4E, // EfiKeyPgDn 0x5F, // EfiKeySeven 0x60, // EfiKeyEight 0x61, // EfiKeyNine 0x35, // EfiKeyE0 0x1E, // EfiKeyE1 0x1F, // EfiKeyE2 0x20, // EfiKeyE3 0x21, // EfiKeyE4 0x22, // EfiKeyE5 0x23, // EfiKeyE6 0x24, // EfiKeyE7 0x25, // EfiKeyE8 0x26, // EfiKeyE9 0x27, // EfiKeyE10 0x2D, // EfiKeyE11 0x2E, // EfiKeyE12 0x2A, // EfiKeyBackSpace 0x49, // EfiKeyIns 0x4A, // EfiKeyHome 0x4B, // EfiKeyPgUp 0x53, // EfiKeyNLck 0x54, // EfiKeySlash 0x55, // EfiKeyAsterisk 0x56, // EfiKeyMinus 0x29, // EfiKeyEsc 0x3A, // EfiKeyF1 0x3B, // EfiKeyF2 0x3C, // EfiKeyF3 0x3D, // EfiKeyF4 0x3E, // EfiKeyF5 0x3F, // EfiKeyF6 0x40, // EfiKeyF7 0x41, // EfiKeyF8 0x42, // EfiKeyF9 0x43, // EfiKeyF10 0x44, // EfiKeyF11 0x45, // EfiKeyF12 0x46, // EfiKeyPrint 0x47, // EfiKeySLck 0x48 // EfiKeyPause }; // // Keyboard modifier value to EFI Scan Code convertion table // EFI Scan Code and the modifier values are defined in UEFI spec. // UINT8 ModifierValueToEfiScanCodeConvertionTable[] = { SCAN_NULL, // EFI_NULL_MODIFIER SCAN_NULL, // EFI_LEFT_CONTROL_MODIFIER SCAN_NULL, // EFI_RIGHT_CONTROL_MODIFIER SCAN_NULL, // EFI_LEFT_ALT_MODIFIER SCAN_NULL, // EFI_RIGHT_ALT_MODIFIER SCAN_NULL, // EFI_ALT_GR_MODIFIER SCAN_INSERT, // EFI_INSERT_MODIFIER SCAN_DELETE, // EFI_DELETE_MODIFIER SCAN_PAGE_DOWN, // EFI_PAGE_DOWN_MODIFIER SCAN_PAGE_UP, // EFI_PAGE_UP_MODIFIER SCAN_HOME, // EFI_HOME_MODIFIER SCAN_END, // EFI_END_MODIFIER SCAN_NULL, // EFI_LEFT_SHIFT_MODIFIER SCAN_NULL, // EFI_RIGHT_SHIFT_MODIFIER SCAN_NULL, // EFI_CAPS_LOCK_MODIFIER SCAN_NULL, // EFI_NUM_LOCK_MODIFIER SCAN_LEFT, // EFI_LEFT_ARROW_MODIFIER SCAN_RIGHT, // EFI_RIGHT_ARROW_MODIFIER SCAN_DOWN, // EFI_DOWN_ARROW_MODIFIER SCAN_UP, // EFI_UP_ARROW_MODIFIER SCAN_NULL, // EFI_NS_KEY_MODIFIER SCAN_NULL, // EFI_NS_KEY_DEPENDENCY_MODIFIER SCAN_F1, // EFI_FUNCTION_KEY_ONE_MODIFIER SCAN_F2, // EFI_FUNCTION_KEY_TWO_MODIFIER SCAN_F3, // EFI_FUNCTION_KEY_THREE_MODIFIER SCAN_F4, // EFI_FUNCTION_KEY_FOUR_MODIFIER SCAN_F5, // EFI_FUNCTION_KEY_FIVE_MODIFIER SCAN_F6, // EFI_FUNCTION_KEY_SIX_MODIFIER SCAN_F7, // EFI_FUNCTION_KEY_SEVEN_MODIFIER SCAN_F8, // EFI_FUNCTION_KEY_EIGHT_MODIFIER SCAN_F9, // EFI_FUNCTION_KEY_NINE_MODIFIER SCAN_F10, // EFI_FUNCTION_KEY_TEN_MODIFIER SCAN_F11, // EFI_FUNCTION_KEY_ELEVEN_MODIFIER SCAN_F12, // EFI_FUNCTION_KEY_TWELVE_MODIFIER // // For Partial Keystroke support // SCAN_NULL, // EFI_PRINT_MODIFIER SCAN_NULL, // EFI_SYS_REQUEST_MODIFIER SCAN_NULL, // EFI_SCROLL_LOCK_MODIFIER SCAN_PAUSE, // EFI_PAUSE_MODIFIER SCAN_NULL, // EFI_BREAK_MODIFIER SCAN_NULL, // EFI_LEFT_LOGO_MODIFIER SCAN_NULL, // EFI_RIGHT_LOGO_MODIFER SCAN_NULL, // EFI_MENU_MODIFER }; /** Initialize Key Convention Table by using default keyboard layout. @param HidKbDev The HID_KB_DEV instance. @retval EFI_SUCCESS The default keyboard layout was installed successfully @retval Others Failure to install default keyboard layout. **/ EFI_STATUS InstallDefaultKeyboardLayout ( IN OUT HID_KB_DEV *HidKbDev ) { EFI_STATUS Status; EFI_HII_DATABASE_PROTOCOL *HiiDatabase; EFI_HII_HANDLE HiiHandle; // // Locate Hii database protocol // Status = gBS->LocateProtocol ( &gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &HiiDatabase ); if (EFI_ERROR (Status)) { return Status; } // // Install Keyboard Layout package to HII database // HiiHandle = HiiAddPackages ( &gHidKeyboardLayoutPackageGuid, HidKbDev->ControllerHandle, &mHidKeyboardLayoutBin, NULL ); if (HiiHandle == NULL) { return EFI_OUT_OF_RESOURCES; } // // Set current keyboard layout // Status = HiiDatabase->SetKeyboardLayout (HiiDatabase, &gHidKeyboardLayoutKeyGuid); return Status; } /** Get current keyboard layout from HII database. @return Pointer to HII Keyboard Layout. NULL means failure occurred while trying to get keyboard layout. **/ EFI_HII_KEYBOARD_LAYOUT * GetCurrentKeyboardLayout ( VOID ) { EFI_STATUS Status; EFI_HII_DATABASE_PROTOCOL *HiiDatabase; EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout; UINT16 Length; // // Locate HII Database Protocol // Status = gBS->LocateProtocol ( &gEfiHiiDatabaseProtocolGuid, NULL, (VOID **) &HiiDatabase ); if (EFI_ERROR (Status)) { return NULL; } // // Get current keyboard layout from HII database // Length = 0; KeyboardLayout = NULL; Status = HiiDatabase->GetKeyboardLayout ( HiiDatabase, NULL, &Length, KeyboardLayout ); if (Status == EFI_BUFFER_TOO_SMALL) { KeyboardLayout = AllocatePool (Length); ASSERT (KeyboardLayout != NULL); Status = HiiDatabase->GetKeyboardLayout ( HiiDatabase, NULL, &Length, KeyboardLayout ); if (EFI_ERROR (Status)) { FreePool (KeyboardLayout); KeyboardLayout = NULL; } } return KeyboardLayout; } /** Find Key Descriptor in Key Convertion Table given its HID keycode. @param HidKbDev The HID_KB_DEV instance. @param KeyCode HID Keycode. @return The Key Descriptor in Key Convertion Table. NULL means not found. **/ EFI_KEY_DESCRIPTOR * GetKeyDescriptor ( IN HID_KB_DEV *HidKbDev, IN UINT8 KeyCode ) { UINT8 Index; // // Make sure KeyCode is in the range of [0x4, 0x65] or [0xe0, 0xe7] // if ((!HIDKBD_VALID_KEYCODE (KeyCode)) || ((KeyCode > 0x65) && (KeyCode < 0xe0)) || (KeyCode > 0xe7)) { return NULL; } // // Calculate the index of Key Descriptor in Key Convertion Table // if (KeyCode <= 0x65) { Index = (UINT8) (KeyCode - 4); } else { Index = (UINT8) (KeyCode - 0xe0 + NUMBER_OF_VALID_NON_MODIFIER_HID_KEYCODE); } return &HidKbDev->KeyConvertionTable[Index]; } /** Find Non-Spacing key for given Key descriptor. @param HidKbDev The HID_KB_DEV instance. @param KeyDescriptor Key descriptor. @return The Non-Spacing key corresponding to KeyDescriptor NULL means not found. **/ HID_NS_KEY * FindHidNsKey ( IN HID_KB_DEV *HidKbDev, IN EFI_KEY_DESCRIPTOR *KeyDescriptor ) { LIST_ENTRY *Link; LIST_ENTRY *NsKeyList; HID_NS_KEY *HidNsKey; NsKeyList = &HidKbDev->NsKeyList; Link = GetFirstNode (NsKeyList); while (!IsNull (NsKeyList, Link)) { HidNsKey = HID_NS_KEY_FORM_FROM_LINK (Link); if (HidNsKey->NsKey[0].Key == KeyDescriptor->Key) { return HidNsKey; } Link = GetNextNode (NsKeyList, Link); } return NULL; } /** Find physical key definition for a given key descriptor. For a specified non-spacing key, there are a list of physical keys following it. This function traverses the list of physical keys and tries to find the physical key matching the KeyDescriptor. @param HidNsKey The non-spacing key information. @param KeyDescriptor The key descriptor. @return The physical key definition. If no physical key is found, parameter KeyDescriptor is returned. **/ EFI_KEY_DESCRIPTOR * FindPhysicalKey ( IN HID_NS_KEY *HidNsKey, IN EFI_KEY_DESCRIPTOR *KeyDescriptor ) { UINTN Index; EFI_KEY_DESCRIPTOR *PhysicalKey; PhysicalKey = &HidNsKey->NsKey[1]; for (Index = 0; Index < HidNsKey->KeyCount; Index++) { if (KeyDescriptor->Key == PhysicalKey->Key) { return PhysicalKey; } PhysicalKey++; } // // No children definition matched, return original key // return KeyDescriptor; } /** The notification function for EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID. This function is registered to event of EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group type, which will be triggered by EFI_HII_DATABASE_PROTOCOL.SetKeyboardLayout(). It tries to get curent keyboard layout from HII database. @param Event Event being signaled. @param Context Points to HID_KB_DEV instance. **/ VOID EFIAPI SetKeyboardLayoutEvent ( IN EFI_EVENT Event, IN VOID *Context ) { HID_KB_DEV *HidKbDev; EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout; EFI_KEY_DESCRIPTOR TempKey; EFI_KEY_DESCRIPTOR *KeyDescriptor; EFI_KEY_DESCRIPTOR *TableEntry; EFI_KEY_DESCRIPTOR *NsKey; HID_NS_KEY *HidNsKey; UINTN Index; UINTN Index2; UINTN KeyCount; UINT8 KeyCode; HidKbDev = (HID_KB_DEV *) Context; if (HidKbDev->Signature != HID_KB_DEV_SIGNATURE) { return; } // // Try to get current keyboard layout from HII database // KeyboardLayout = GetCurrentKeyboardLayout (); if (KeyboardLayout == NULL) { return; } // // Re-allocate resource for KeyConvertionTable // ReleaseKeyboardLayoutResources (HidKbDev); HidKbDev->KeyConvertionTable = AllocateZeroPool ((NUMBER_OF_VALID_HID_KEYCODE) * sizeof (EFI_KEY_DESCRIPTOR)); ASSERT (HidKbDev->KeyConvertionTable != NULL); // // Traverse the list of key descriptors following the header of EFI_HII_KEYBOARD_LAYOUT // KeyDescriptor = (EFI_KEY_DESCRIPTOR *) (((UINT8 *) KeyboardLayout) + sizeof (EFI_HII_KEYBOARD_LAYOUT)); for (Index = 0; Index < KeyboardLayout->DescriptorCount; Index++) { // // Copy from HII keyboard layout package binary for alignment // CopyMem (&TempKey, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR)); // // Fill the key into KeyConvertionTable, whose index is calculated from HID keycode. // KeyCode = EfiKeyToHidKeyCodeConvertionTable [(UINT8) (TempKey.Key)]; TableEntry = GetKeyDescriptor (HidKbDev, KeyCode); if (TableEntry == NULL) { ReleaseKeyboardLayoutResources (HidKbDev); FreePool (KeyboardLayout); return; } CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR)); // // For non-spacing key, create the list with a non-spacing key followed by physical keys. // if (TempKey.Modifier == EFI_NS_KEY_MODIFIER) { HidNsKey = AllocateZeroPool (sizeof (HID_NS_KEY)); if (HidNsKey == NULL) { ASSERT (HidNsKey != NULL); return; } // // Search for sequential children physical key definitions // KeyCount = 0; NsKey = KeyDescriptor + 1; for (Index2 = (UINT8) Index + 1; Index2 < KeyboardLayout->DescriptorCount; Index2++) { CopyMem (&TempKey, NsKey, sizeof (EFI_KEY_DESCRIPTOR)); if (TempKey.Modifier == EFI_NS_KEY_DEPENDENCY_MODIFIER) { KeyCount++; } else { break; } NsKey++; } HidNsKey->Signature = HID_NS_KEY_SIGNATURE; HidNsKey->KeyCount = KeyCount; HidNsKey->NsKey = AllocateCopyPool ( (KeyCount + 1) * sizeof (EFI_KEY_DESCRIPTOR), KeyDescriptor ); InsertTailList (&HidKbDev->NsKeyList, &HidNsKey->Link); // // Skip over the child physical keys // Index += KeyCount; KeyDescriptor += KeyCount; } KeyDescriptor++; } // // There are two EfiKeyEnter, duplicate its key descriptor // TableEntry = GetKeyDescriptor (HidKbDev, 0x58); KeyDescriptor = GetKeyDescriptor (HidKbDev, 0x28); CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR)); FreePool (KeyboardLayout); } /** Destroy resources for keyboard layout. @param HidKbDev The HID_KB_DEV instance. **/ VOID ReleaseKeyboardLayoutResources ( IN OUT HID_KB_DEV *HidKbDev ) { HID_NS_KEY *HidNsKey; LIST_ENTRY *Link; if (HidKbDev->KeyConvertionTable != NULL) { FreePool (HidKbDev->KeyConvertionTable); } HidKbDev->KeyConvertionTable = NULL; while (!IsListEmpty (&HidKbDev->NsKeyList)) { Link = GetFirstNode (&HidKbDev->NsKeyList); HidNsKey = HID_NS_KEY_FORM_FROM_LINK (Link); RemoveEntryList (&HidNsKey->Link); FreePool (HidNsKey->NsKey); FreePool (HidNsKey); } } /** Initialize HID keyboard layout. This function initializes Key Convertion Table for the HID keyboard device. It first tries to retrieve layout from HII database. If failed and default layout is enabled, then it just uses the default layout. @param HidKbDev The HID_KB_DEV instance. @retval EFI_SUCCESS Initialization succeeded. @retval EFI_NOT_READY Keyboard layout cannot be retrieve from HII database, and default layout is disabled. @retval Other Fail to register event to EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group. **/ EFI_STATUS InitKeyboardLayout ( OUT HID_KB_DEV *HidKbDev ) { EFI_HII_KEYBOARD_LAYOUT *KeyboardLayout; EFI_STATUS Status; HidKbDev->KeyConvertionTable = AllocateZeroPool ((NUMBER_OF_VALID_HID_KEYCODE) * sizeof (EFI_KEY_DESCRIPTOR)); ASSERT (HidKbDev->KeyConvertionTable != NULL); InitializeListHead (&HidKbDev->NsKeyList); HidKbDev->CurrentNsKey = NULL; HidKbDev->KeyboardLayoutEvent = NULL; // // Register event to EFI_HII_SET_KEYBOARD_LAYOUT_EVENT_GUID group, // which will be triggered by EFI_HII_DATABASE_PROTOCOL.SetKeyboardLayout(). // Status = gBS->CreateEventEx ( EVT_NOTIFY_SIGNAL, TPL_NOTIFY, SetKeyboardLayoutEvent, HidKbDev, &gEfiHiiKeyBoardLayoutGuid, &HidKbDev->KeyboardLayoutEvent ); if (EFI_ERROR (Status)) { return Status; } KeyboardLayout = GetCurrentKeyboardLayout (); if (KeyboardLayout != NULL) { // // If current keyboard layout is successfully retrieved from HII database, // force to initialize the keyboard layout. // gBS->SignalEvent (HidKbDev->KeyboardLayoutEvent); } else { if (FeaturePcdGet (PcdDisableDefaultKeyboardLayoutInHidKbDriver)) { // // If no keyboard layout can be retrieved from HII database, and default layout // is disabled, then return EFI_NOT_READY. // return EFI_NOT_READY; } // // If no keyboard layout can be retrieved from HII database, and default layout // is enabled, then load the default keyboard layout. // InstallDefaultKeyboardLayout (HidKbDev); } return EFI_SUCCESS; } /** Initialize HID keyboard device and all private data structures. @param HidKbDev The HID_KB_DEV instance. @retval EFI_SUCCESS Initialization is successful. @retval EFI_DEVICE_ERROR Keyboard initialization failed. **/ EFI_STATUS InitHidKeyboard ( IN OUT HID_KB_DEV *HidKbDev ) { UINT8 ReportId; UINT8 Duration; InitQueue (&HidKbDev->HidKeyQueue, sizeof (HID_KEY)); InitQueue (&HidKbDev->EfiKeyQueue, sizeof (EFI_KEY_DATA)); // // ReportId is zero, which means the idle rate applies to all input reports. // ReportId = 0; // // Duration is zero, which means the duration is infinite. // so the endpoint will inhibit reporting forever, // and only reporting when a change is detected in the report data. // Duration = 0; HidSetIdleRequest ( HidKbDev->Hid, ReportId, Duration ); HidKbDev->CtrlOn = FALSE; HidKbDev->AltOn = FALSE; HidKbDev->LedKeyState[LED_KEY_SHIFT] = FALSE; HidKbDev->LedKeyState[LED_KEY_NUMLOCK] = FALSE; HidKbDev->LedKeyState[LED_KEY_CAPSLOCK] = FALSE; HidKbDev->LedKeyState[LED_KEY_SCROLL] = FALSE; HidKbDev->LeftCtrlOn = FALSE; HidKbDev->LeftAltOn = FALSE; HidKbDev->LeftShiftOn = FALSE; HidKbDev->LeftLogoOn = FALSE; HidKbDev->RightCtrlOn = FALSE; HidKbDev->RightAltOn = FALSE; HidKbDev->RightShiftOn = FALSE; HidKbDev->RightLogoOn = FALSE; HidKbDev->MenuKeyOn = FALSE; HidKbDev->SysReqOn = FALSE; HidKbDev->AltGrOn = FALSE; HidKbDev->CurrentNsKey = NULL; // // Sync the initial state of lights on keyboard. // SetKeyLED (HidKbDev); ZeroMem (HidKbDev->LastKeyCodeArray, sizeof (UINT8) * 8); // // Create event for repeat keys' generation. // if (HidKbDev->RepeatTimer != NULL) { gBS->CloseEvent (HidKbDev->RepeatTimer); HidKbDev->RepeatTimer = NULL; } gBS->CreateEvent ( EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, HidKbRepeatHandler, HidKbDev, &HidKbDev->RepeatTimer ); HidStartNotification (HidKbDev->Hid); return EFI_SUCCESS; } /** Checks whether a key is in Key buffer. @param[in] Key The Key code. @param[in] KeyBuffer Point to the key buffer. @param[in] Size The size of key buffer. @retval TRUE If Key is found in buffer. @retval FALSE If key is not found in the buffer. **/ BOOLEAN EFIAPI IsKeyInBuffer( IN UINT8 Key, IN UINT8 KeyBuffer[], IN UINT32 Size) { UINT8 Index; for (Index = 0; Index < Size; Index++){ // Ignore the 0x00 codes if (KeyBuffer[Index] == 0) { continue; } // If found in key buffer then return True if (Key == KeyBuffer[Index]) { return TRUE; } } return FALSE; } /** Handler function for HID keyboard's asynchronous interrupt transfer. This function is the handler function for HID keyboard's asynchronous interrupt transfer to manage the keyboard. It parses the HID keyboard input report, and inserts data to keyboard buffer according to state of modifer keys and normal keys. Timer for repeat key is also set accordingly. @param Data A pointer to a buffer that is filled with key data which is retrieved via asynchronous interrupt transfer. @param DataLength Indicates the size of the data buffer. @param Context Pointing to HID_KB_DEV instance. @retval EFI_SUCCESS Asynchronous interrupt transfer is handled successfully. @retval EFI_DEVICE_ERROR Hardware error occurs. **/ EFI_STATUS EFIAPI KeyboardHandler ( IN VOID *Data, IN UINTN DataLength, IN VOID *Context ) { HID_KB_DEV *HidKbDev; HID_KEY HidKey; UINT8 ReportId; UINT16 Buffer; UINT8 *DataPtr; UINT8 SaveData[MAX_KEYCODE_BUFF_SIZE]; UINT8 SaveDataIndex; LIST_ENTRY *Link; LIST_ENTRY *Cur; UINT32 BitsRemaning; UINT32 Limit; HID_REPORT_FMT *ReportItem; UINT16 Index; EFI_KEY_DESCRIPTOR *KeyDescriptor; ZeroMem (SaveData, sizeof (SaveData)); SaveDataIndex = 0; ASSERT (Context != NULL); BitsRemaning = 8; DataPtr = (UINT8*)Data; // Extract the ReportId ReportId = DataPtr[0]; DataPtr ++; DataLength --; HidKbDev = (HID_KB_DEV *) Context; // Workaround: Belkin Mobile Wireless Keyboard and Microsoft Universal Foldable Keyboard // Consumer Page(0x0C) USAGE instead of Keyboard/Keypad Page(0x07) to send ESCAPE key // So for above two keyboards converting USAGE ID from Consumer Page to Keyboard/Keypad Page // for ESCAPE key. if (DataLength == 2) { if (((DataPtr[0] == 0x40) && (DataPtr[1] == 0x00)) || ((DataPtr[0] == 0x23) && (DataPtr[1] == 0x02))) { HidKey.KeyCode = 0x29; HidKey.Down = TRUE; Enqueue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); return EFI_SUCCESS; } } HidKbDev->Hid->GetReportFormatList(HidKbDev->Hid, &Link); Cur = GetFirstNode (Link); HidKbDev->RepeatKey = 0x00; Buffer = (UINT16)DataPtr[0]; BitsRemaning = 8; while (!IsNull (Link, Cur)) { ReportItem = ITEM_FROM_LINK(Cur); // Check if the item is of the input type if ( ReportItem->ReportId != ReportId || ReportItem->Type != BT_HID_ITEM_TYPE_INPUT || ReportItem->UsagePage != BT_HID_KEYBOARD_USAGE_PAGE ) { Cur = GetNextNode (Link, Cur); continue; } switch (ReportItem->ArrVar) { case BT_HID_ITEM_TYPE_VARIABLE: // This section is for parsing the modifier keys for (Index = 0; Index < ReportItem->ReportCount; Index++) { if (BitsRemaning < ReportItem->ReportSize) { Buffer = Buffer << BitsRemaning; DataPtr ++; // Refill the lower byte of the Buffer // and retain the higer byte as is Buffer |= (UINT16)DataPtr[0]; Buffer = Buffer << (ReportItem->ReportSize - BitsRemaning); BitsRemaning = 8 - (ReportItem->ReportSize - BitsRemaning); } else { Buffer = Buffer << ReportItem->ReportSize; BitsRemaning -= ReportItem->ReportSize; } // Bit position is same as the indexing, so substract from 7 HidKey.KeyCode = (UINT8)(ReportItem->UsageMin + 7 - Index); if (HI_BYTE(Buffer) != 0) HidKey.Down = TRUE; else HidKey.Down = FALSE; // Skip if it's constant if (ReportItem->DatConst == 0) Enqueue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); Buffer &= 0x00ff; } break; case BT_HID_ITEM_TYPE_ARRAY: // This section is for handling the normal keycodes Limit = (ReportItem->ReportCount < MAX_KEYCODE_BUFF_SIZE) ? ReportItem->ReportCount : MAX_KEYCODE_BUFF_SIZE; for (Index=0; Index < ReportItem->ReportCount; Index++) { if (BitsRemaning < ReportItem->ReportSize) { Buffer = Buffer << BitsRemaning; DataPtr ++; // Refill the lower byte of the Buffer // and retain the higer byte as is Buffer |= (UINT16)DataPtr[0]; Buffer = Buffer << (ReportItem->ReportSize - BitsRemaning); BitsRemaning = 8 - (ReportItem->ReportSize - BitsRemaning); } else { Buffer = Buffer << ReportItem->ReportSize; BitsRemaning -= ReportItem->ReportSize; } // // Constant bits may exist for certain OEM specific usage. Don't care it here. // if (ReportItem->DatConst == 0) { HidKey.KeyCode = (UINT8)(ReportItem->UsageMin + (Buffer >> 8)); if (SaveDataIndex < MAX_KEYCODE_BUFF_SIZE) { SaveData[SaveDataIndex++] = (Buffer >> 8); } // The basic key detection algorithm is: // A key is pressed if it's not in old buffer but in new buffer. // A key is released if it's in old buffer but not in new buffer. if (HidKey.KeyCode != 0) { if (!IsKeyInBuffer (HidKey.KeyCode, HidKbDev->OldKeyBuffer, Limit)) { HidKbDev->RepeatKey = HidKey.KeyCode; HidKey.Down = TRUE; } } // Skip adding the key if it's a constant. Add only if it's a new key! if (HidKbDev->RepeatKey != HidKbDev->PreviousKey) { Enqueue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); } } Buffer &= 0x00ff; } // Check if the old key was released for ( Index = 0; Index < Limit; Index++ ){ // Ignore the 0x00 codes if (HidKbDev->OldKeyBuffer[Index] == 0) { continue; } // Check if Old key is present in incoming New key input buffer. // Release it if it's not present. if (!IsKeyInBuffer (HidKbDev->OldKeyBuffer[Index], SaveData, Limit)){ HidKey.KeyCode = HidKbDev->OldKeyBuffer[Index]; HidKey.Down = FALSE; Enqueue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); } } // Update the old KeyBuffer for ( Index = 0; Index < MAX_KEYCODE_BUFF_SIZE; Index ++ ) { HidKbDev->OldKeyBuffer[Index] = SaveData[Index]; } break; } Cur = GetNextNode (Link, Cur); } // Stop the timer in case there is no repeat key and the timer is running if ( HidKbDev->RepeatKey == 0x00 && HidKbDev->TimerSet == TRUE ) { gBS->SetTimer ( HidKbDev->RepeatTimer, TimerCancel, HIDKBD_REPEAT_RATE ); HidKbDev->PreviousKey = 0x00; HidKbDev->TimerSet = FALSE; } // Set or Clear the Repeat Key if ( HidKbDev->RepeatKey != HidKbDev->PreviousKey ) { // Check to see if CAPSLOCK or NUMLOCK is pressed. KeyDescriptor = GetKeyDescriptor (HidKbDev,HidKbDev->RepeatKey); if (KeyDescriptor != NULL) { if (KeyDescriptor->Modifier == EFI_NUM_LOCK_MODIFIER || KeyDescriptor->Modifier == EFI_CAPS_LOCK_MODIFIER) { return EFI_SUCCESS; } } // Start a timer gBS->SetTimer ( HidKbDev->RepeatTimer, TimerRelative, HIDKBD_REPEAT_DELAY ); HidKbDev->PreviousKey = HidKbDev->RepeatKey; HidKbDev->TimerSet = TRUE; } return EFI_SUCCESS; } /** Retrieves a HID keycode after parsing the raw data in keyboard buffer. This function parses keyboard buffer. It updates state of modifier key for HID_KB_DEV instancem, and returns keycode for output. @param HidKbDev The HID_KB_DEV instance. @param KeyCode Pointer to the HID keycode for output. @retval EFI_SUCCESS Keycode successfully parsed. @retval EFI_NOT_READY Keyboard buffer is not ready for a valid keycode **/ EFI_STATUS HidParseKey ( IN OUT HID_KB_DEV *HidKbDev, OUT UINT8 *KeyCode ) { HID_KEY HidKey; EFI_KEY_DESCRIPTOR *KeyDescriptor; *KeyCode = 0; while (!IsQueueEmpty (&HidKbDev->HidKeyQueue)) { // // Pops one raw data off. // Dequeue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); KeyDescriptor = GetKeyDescriptor (HidKbDev, HidKey.KeyCode); if (KeyDescriptor == NULL) continue; if (!HidKey.Down) { // // Key is released. // switch (KeyDescriptor->Modifier) { // // Ctrl release // case EFI_LEFT_CONTROL_MODIFIER: HidKbDev->LeftCtrlOn = FALSE; break; case EFI_RIGHT_CONTROL_MODIFIER: HidKbDev->RightCtrlOn = FALSE; break; // // Shift release // case EFI_LEFT_SHIFT_MODIFIER: HidKbDev->LeftShiftOn = FALSE; break; case EFI_RIGHT_SHIFT_MODIFIER: HidKbDev->RightShiftOn = FALSE; break; // // Alt release // case EFI_LEFT_ALT_MODIFIER: HidKbDev->LeftAltOn = FALSE; break; case EFI_RIGHT_ALT_MODIFIER: HidKbDev->RightAltOn = FALSE; break; // // Left Logo release // case EFI_LEFT_LOGO_MODIFIER: HidKbDev->LeftLogoOn = FALSE; break; // // Right Logo release // case EFI_RIGHT_LOGO_MODIFIER: HidKbDev->RightLogoOn = FALSE; break; // // Menu key release // case EFI_MENU_MODIFIER: HidKbDev->MenuKeyOn = FALSE; break; // // SysReq release // case EFI_PRINT_MODIFIER: case EFI_SYS_REQUEST_MODIFIER: HidKbDev->SysReqOn = FALSE; break; // // AltGr release // case EFI_ALT_GR_MODIFIER: HidKbDev->AltGrOn = FALSE; break; default: break; } if ((HidKbDev->LeftShiftOn == FALSE) && (HidKbDev->RightShiftOn == FALSE)) HidKbDev->LedKeyState[LED_KEY_SHIFT] = FALSE; if ((HidKbDev->LeftCtrlOn == FALSE) && (HidKbDev->RightCtrlOn == FALSE)) HidKbDev->CtrlOn = FALSE; if ((HidKbDev->LeftAltOn == FALSE) && (HidKbDev->RightAltOn == FALSE)) HidKbDev->AltOn = FALSE; continue; } // // Analyzes key pressing situation // switch (KeyDescriptor->Modifier) { // // Ctrl press // case EFI_LEFT_CONTROL_MODIFIER: HidKbDev->LeftCtrlOn = TRUE; HidKbDev->CtrlOn = TRUE; break; case EFI_RIGHT_CONTROL_MODIFIER: HidKbDev->RightCtrlOn = TRUE; HidKbDev->CtrlOn = TRUE; break; // // Shift press // case EFI_LEFT_SHIFT_MODIFIER: HidKbDev->LeftShiftOn = TRUE; HidKbDev->LedKeyState[LED_KEY_SHIFT] = TRUE; break; case EFI_RIGHT_SHIFT_MODIFIER: HidKbDev->RightShiftOn = TRUE; HidKbDev->LedKeyState[LED_KEY_SHIFT] = TRUE; break; // // Alt press // case EFI_LEFT_ALT_MODIFIER: HidKbDev->LeftAltOn = TRUE; HidKbDev->AltOn = TRUE; break; case EFI_RIGHT_ALT_MODIFIER: HidKbDev->RightAltOn = TRUE; HidKbDev->AltOn = TRUE; break; // // Left Logo press // case EFI_LEFT_LOGO_MODIFIER: HidKbDev->LeftLogoOn = TRUE; break; // // Right Logo press // case EFI_RIGHT_LOGO_MODIFIER: HidKbDev->RightLogoOn = TRUE; break; // // Menu key press // case EFI_MENU_MODIFIER: HidKbDev->MenuKeyOn = TRUE; break; // // SysReq press // case EFI_PRINT_MODIFIER: case EFI_SYS_REQUEST_MODIFIER: HidKbDev->SysReqOn = TRUE; break; // // AltGr press // case EFI_ALT_GR_MODIFIER: HidKbDev->AltGrOn = TRUE; break; case EFI_NUM_LOCK_MODIFIER: // // Toggle NumLock // HidKbDev->LedKeyState[LED_KEY_NUMLOCK] = (BOOLEAN) (!(HidKbDev->LedKeyState[LED_KEY_NUMLOCK])); HidKbDev->LedKeyState[EFI_KEY_NUM_LOCK] = (HidKbDev->LedKeyState[LED_KEY_NUMLOCK] == TRUE ) ? TRUE : FALSE; SetKeyLED (HidKbDev); break; case EFI_CAPS_LOCK_MODIFIER: // // Toggle CapsLock // HidKbDev->LedKeyState[LED_KEY_CAPSLOCK] = (BOOLEAN) (!(HidKbDev->LedKeyState[LED_KEY_CAPSLOCK])); HidKbDev->LedKeyState[EFI_KEY_CAPS_LOCK] = (HidKbDev->LedKeyState[LED_KEY_CAPSLOCK] == TRUE ) ? TRUE : FALSE; SetKeyLED (HidKbDev); break; case EFI_SCROLL_LOCK_MODIFIER: // // Toggle ScrollLock // HidKbDev->LedKeyState[LED_KEY_SCROLL] = (BOOLEAN) (!(HidKbDev->LedKeyState[LED_KEY_SCROLL])); HidKbDev->LedKeyState[EFI_KEY_SCROLL_LOCK] = (HidKbDev->LedKeyState[LED_KEY_SCROLL] == TRUE ) ? TRUE : FALSE; SetKeyLED (HidKbDev); break; default: break; } // // When encountering Ctrl + Alt + Del, then warm reset. // if (KeyDescriptor->Modifier == EFI_DELETE_MODIFIER) { if ((HidKbDev->CtrlOn) && (HidKbDev->AltOn)) { gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL); } } *KeyCode = HidKey.KeyCode; return EFI_SUCCESS; } return EFI_NOT_READY; } /** Converts HID Keycode ranging from 0x4 to 0x65 to EFI_INPUT_KEY. @param HidKbDev The HID_KB_DEV instance. @param KeyCode Indicates the key code that will be interpreted. @param KeyData A pointer to a buffer that is filled in with the keystroke information for the key that was pressed. @retval EFI_SUCCESS Success. @retval EFI_INVALID_PARAMETER KeyCode is not in the range of 0x4 to 0x65. @retval EFI_INVALID_PARAMETER Translated EFI_INPUT_KEY has zero for both ScanCode and UnicodeChar. @retval EFI_NOT_READY KeyCode represents a dead key with EFI_NS_KEY_MODIFIER @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources. @retval EFI_DEVICE_ERROR Keyboard layout is invalid. **/ EFI_STATUS HidKeyCodeToEfiInputKey ( IN HID_KB_DEV *HidKbDev, IN UINT8 KeyCode, OUT EFI_KEY_DATA *KeyData ) { EFI_KEY_DESCRIPTOR *KeyDescriptor; LIST_ENTRY *Link; LIST_ENTRY *NotifyList; KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify; // // KeyCode must in the range of [0x4, 0x65] or [0xe0, 0xe7]. // KeyDescriptor = GetKeyDescriptor (HidKbDev, KeyCode); if (KeyDescriptor == NULL) { ASSERT (KeyDescriptor != NULL); return EFI_OUT_OF_RESOURCES; } if (KeyDescriptor->Modifier == EFI_NS_KEY_MODIFIER) { // // If this is a dead key with EFI_NS_KEY_MODIFIER, then record it and return. // HidKbDev->CurrentNsKey = FindHidNsKey (HidKbDev, KeyDescriptor); return EFI_NOT_READY; } if (HidKbDev->CurrentNsKey != NULL) { // // If this keystroke follows a non-spacing key, then find the descriptor for corresponding // physical key. // KeyDescriptor = FindPhysicalKey (HidKbDev->CurrentNsKey, KeyDescriptor); HidKbDev->CurrentNsKey = NULL; } // // Make sure modifier of Key Descriptor is in the valid range according to UEFI spec. // if (KeyDescriptor->Modifier >= (sizeof (ModifierValueToEfiScanCodeConvertionTable) / sizeof (UINT8))) { return EFI_DEVICE_ERROR; } KeyData->Key.ScanCode = ModifierValueToEfiScanCodeConvertionTable[KeyDescriptor->Modifier]; KeyData->Key.UnicodeChar = KeyDescriptor->Unicode; if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_STANDARD_SHIFT)!= 0) { if (HidKbDev->LedKeyState[LED_KEY_SHIFT]) { KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode; // // Need not return associated shift state if a class of printable characters that // are normally adjusted by shift modifiers. e.g. Shift Key + 'f' key = 'F' // if ((KeyDescriptor->Unicode != CHAR_NULL) && (KeyDescriptor->ShiftedUnicode != CHAR_NULL) && (KeyDescriptor->Unicode != KeyDescriptor->ShiftedUnicode)) { HidKbDev->LeftShiftOn = FALSE; HidKbDev->RightShiftOn = FALSE; } if (HidKbDev->AltGrOn) { KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedAltGrUnicode; } } else { // // Shift off // KeyData->Key.UnicodeChar = KeyDescriptor->Unicode; if (HidKbDev->AltGrOn) { KeyData->Key.UnicodeChar = KeyDescriptor->AltGrUnicode; } } } if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) != 0) { if (HidKbDev->LedKeyState[LED_KEY_CAPSLOCK]) { if (KeyData->Key.UnicodeChar == KeyDescriptor->Unicode) { KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode; } else if (KeyData->Key.UnicodeChar == KeyDescriptor->ShiftedUnicode) { KeyData->Key.UnicodeChar = KeyDescriptor->Unicode; } } } if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_NUM_LOCK) != 0) { // // For key affected by NumLock, if NumLock is on and Shift is not pressed, then it means // normal key, instead of original control key. So the ScanCode should be cleaned. // Otherwise, it means control key, so preserve the EFI Scan Code and clear the unicode keycode. // if ((HidKbDev->LedKeyState[LED_KEY_NUMLOCK]) && (!(HidKbDev->LedKeyState[LED_KEY_SHIFT]))) { KeyData->Key.ScanCode = SCAN_NULL; } else { KeyData->Key.UnicodeChar = CHAR_NULL; } } // // Translate Unicode 0x1B (ESC) to EFI Scan Code // if (KeyData->Key.UnicodeChar == 0x1B && KeyData->Key.ScanCode == SCAN_NULL) { KeyData->Key.ScanCode = SCAN_ESC; KeyData->Key.UnicodeChar = CHAR_NULL; } // // Not valid for key without both unicode key code and EFI Scan Code. // if (KeyData->Key.UnicodeChar == 0 && KeyData->Key.ScanCode == SCAN_NULL) { if (!HidKbDev->IsSupportPartialKey) { return EFI_NOT_READY; } } // // Save Shift/Toggle state // KeyData->KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID; KeyData->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID; if (HidKbDev->LeftCtrlOn) { KeyData->KeyState.KeyShiftState |= EFI_LEFT_CONTROL_PRESSED; } if (HidKbDev->RightCtrlOn) { KeyData->KeyState.KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED; } if (HidKbDev->LeftAltOn) { KeyData->KeyState.KeyShiftState |= EFI_LEFT_ALT_PRESSED; } if (HidKbDev->RightAltOn) { KeyData->KeyState.KeyShiftState |= EFI_RIGHT_ALT_PRESSED; } if (HidKbDev->LeftShiftOn) { KeyData->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED; } if (HidKbDev->RightShiftOn) { KeyData->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED; } if (HidKbDev->LeftLogoOn) { KeyData->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED; } if (HidKbDev->RightLogoOn) { KeyData->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED; } if (HidKbDev->MenuKeyOn) { KeyData->KeyState.KeyShiftState |= EFI_MENU_KEY_PRESSED; } if (HidKbDev->SysReqOn) { KeyData->KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED; } if (HidKbDev->LedKeyState[LED_KEY_SCROLL]) { KeyData->KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE; } if (HidKbDev->LedKeyState[LED_KEY_NUMLOCK]) { KeyData->KeyState.KeyToggleState |= EFI_NUM_LOCK_ACTIVE; } if (HidKbDev->LedKeyState[LED_KEY_CAPSLOCK]) { KeyData->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE; } if (HidKbDev->IsSupportPartialKey) { KeyData->KeyState.KeyToggleState |= EFI_KEY_STATE_EXPOSED; } // // Invoke notification functions if the key is registered. // NotifyList = &HidKbDev->NotifyList; for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) { CurrentNotify = CR (Link, KEYBOARD_CONSOLE_IN_EX_NOTIFY, NotifyEntry, HID_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE); if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) { CurrentNotify->KeyNotificationFn (KeyData); } } return EFI_SUCCESS; } /** Create the queue. @param Queue Points to the queue. @param ItemSize Size of the single item. **/ VOID InitQueue ( IN OUT HID_SIMPLE_QUEUE *Queue, IN UINTN ItemSize ) { UINTN Index; Queue->ItemSize = ItemSize; Queue->Head = 0; Queue->Tail = 0; if (Queue->Buffer[0] != NULL) { FreePool (Queue->Buffer[0]); } Queue->Buffer[0] = AllocatePool (sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]) * ItemSize); ASSERT (Queue->Buffer[0] != NULL); for (Index = 1; Index < sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]); Index++) { Queue->Buffer[Index] = ((UINT8 *) Queue->Buffer[Index - 1]) + ItemSize; } } /** Destroy the queue @param Queue Points to the queue. **/ VOID DestroyQueue ( IN OUT HID_SIMPLE_QUEUE *Queue ) { FreePool (Queue->Buffer[0]); } /** Check whether the queue is empty. @param Queue Points to the queue. @retval TRUE Queue is empty. @retval FALSE Queue is not empty. **/ BOOLEAN IsQueueEmpty ( IN HID_SIMPLE_QUEUE *Queue ) { // // Meet FIFO empty condition // return (BOOLEAN) (Queue->Head == Queue->Tail); } /** Check whether the queue is full. @param Queue Points to the queue. @retval TRUE Queue is full. @retval FALSE Queue is not full. **/ BOOLEAN IsQueueFull ( IN HID_SIMPLE_QUEUE *Queue ) { return (BOOLEAN) (((Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1)) == Queue->Head); } /** Enqueue the item to the queue. @param Queue Points to the queue. @param Item Points to the item to be enqueued. @param ItemSize Size of the item. **/ VOID Enqueue ( IN OUT HID_SIMPLE_QUEUE *Queue, IN VOID *Item, IN UINTN ItemSize ) { ASSERT (ItemSize == Queue->ItemSize); // // If keyboard buffer is full, throw the // first key out of the keyboard buffer. // if (IsQueueFull (Queue)) { Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1); } CopyMem (Queue->Buffer[Queue->Tail], Item, ItemSize); // // Adjust the tail pointer of the FIFO keyboard buffer. // Queue->Tail = (Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1); } /** Dequeue a item from the queue. @param Queue Points to the queue. @param Item Receives the item. @param ItemSize Size of the item. @retval EFI_SUCCESS Item was successfully dequeued. @retval EFI_DEVICE_ERROR The queue is empty. **/ EFI_STATUS Dequeue ( IN OUT HID_SIMPLE_QUEUE *Queue, OUT VOID *Item, IN UINTN ItemSize ) { ASSERT (Queue->ItemSize == ItemSize); if (IsQueueEmpty (Queue)) { return EFI_DEVICE_ERROR; } CopyMem (Item, Queue->Buffer[Queue->Head], ItemSize); // // Adjust the head pointer of the FIFO keyboard buffer. // Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1); return EFI_SUCCESS; } /** Sets HID keyboard LED state. @param HidKbDev The HID_KB_DEV instance. @retval EFI_OUT_OF_RESOURCES Can't allocate memory resources. @retval EFI_SUCCESS The HID keyboard LED state is successfully set. **/ EFI_STATUS SetKeyLED ( IN HID_KB_DEV *HidKbDev ) { UINT32 ReportItemSize; UINT8 *Data; UINT32 Index; UINT8 BitMask; UINT32 ByteIndex; UINT32 BitIndex; LIST_ENTRY *Link; LIST_ENTRY *Cur; HID_REPORT_FMT *ReportItem; HidKbDev->Hid->GetReportFormatList(HidKbDev->Hid, &Link); Cur = GetFirstNode (Link); ByteIndex = 0; BitIndex = 0; // Find the total size of all output // reports corresponding to the LED if (HidKbDev->OutLedReportSize == 0){ while (!IsNull (Link, Cur)) { ReportItem = ITEM_FROM_LINK(Cur); if (ReportItem->UsagePage == BT_HID_LED_USAGE_PAGE) HidKbDev->OutLedReportSize = HidKbDev->OutLedReportSize + (ReportItem->ReportCount * ReportItem->ReportSize); Cur = GetNextNode (Link, Cur); } Cur = GetFirstNode (Link); } Data = (UINT8 *)AllocateZeroPool(HidKbDev->OutLedReportSize/8); if (Data == NULL) { return EFI_OUT_OF_RESOURCES; } while (!IsNull (Link, Cur)) { ReportItem = ITEM_FROM_LINK(Cur); if (ReportItem->UsagePage == BT_HID_LED_USAGE_PAGE) { // If it's of the constant type skip it! if (ReportItem->DatConst){ ReportItemSize = ReportItem->ReportCount * ReportItem->ReportSize; ByteIndex += ReportItemSize / 8; BitIndex = BitIndex + ReportItemSize; if (BitIndex >= 7) { ByteIndex += 1; BitIndex = BitIndex % 7; } } for (Index = ReportItem->UsageMin; Index <= ReportItem->UsageMax; Index++) { if (HidKbDev->LedKeyState[Index] == TRUE) { BitMask = Data[ByteIndex]; BitMask = BitMask | (1 << BitIndex); Data[ByteIndex] = BitMask; } BitIndex += ReportItem->ReportSize; if (BitIndex == 7){ ByteIndex ++; BitIndex = 0; } } } Cur = GetNextNode (Link, Cur); } // // Call Set_Report Request to lighten the LED. // HidSetReportRequest ( HidKbDev->Hid, 0, BluetoothHidOutputReport, (UINT16)(HidKbDev->OutLedReportSize/8), Data ); FreePool(Data); return EFI_SUCCESS; } /** Handler for Repeat Key event. This function is the handler for Repeat Key event triggered by timer. After a repeatable key is pressed, the event would be triggered with interval of HIDKBD_REPEAT_DELAY. Once the event is triggered, following trigger will come with interval of HIDKBD_REPEAT_RATE. @param Event The Repeat Key event. @param Context Points to the HID_KB_DEV instance. **/ VOID EFIAPI HidKbRepeatHandler ( IN EFI_EVENT Event, IN VOID *Context ) { HID_KB_DEV *HidKbDev; HID_KEY HidKey; HidKbDev = (HID_KB_DEV *) Context; // // Do nothing when there is no repeat key. // if (HidKbDev->RepeatKey != 0) { // // Inserts the repeat key into keyboard buffer, // HidKey.KeyCode = HidKbDev->RepeatKey; HidKey.Down = TRUE; Enqueue (&HidKbDev->HidKeyQueue, &HidKey, sizeof (HidKey)); // // Set repeat rate for next repeat key generation. // gBS->SetTimer ( HidKbDev->RepeatTimer, TimerRelative, HIDKBD_REPEAT_RATE ); } }