OpenCore  1.0.4
OpenCore Bootloader
Loading...
Searching...
No Matches
KeyBoard.c
Go to the documentation of this file.
1
10#include "KeyBoard.h"
11
12#include <IndustryStandard/AppleHid.h>
13
14#include <Guid/UsbKeyBoardLayout.h>
15
16#include <Library/ResetSystemLib.h>
17
18USB_KEYBOARD_LAYOUT_PACK_BIN mUsbKeyboardLayoutBin = {
19 sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN), // Binary size
20
21 //
22 // EFI_HII_PACKAGE_HEADER
23 //
24 {
25 sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32),
26 EFI_HII_PACKAGE_KEYBOARD_LAYOUT
27 },
28 1, // LayoutCount
29 sizeof (USB_KEYBOARD_LAYOUT_PACK_BIN) - sizeof (UINT32) - sizeof (EFI_HII_PACKAGE_HEADER) - sizeof (UINT16), // LayoutLength
30 USB_KEYBOARD_LAYOUT_KEY_GUID, // KeyGuid
31 sizeof (UINT16) + sizeof (EFI_GUID) + sizeof (UINT32) + sizeof (UINT8) + (USB_KEYBOARD_KEY_COUNT * sizeof (EFI_KEY_DESCRIPTOR)), // LayoutDescriptorStringOffset
32 USB_KEYBOARD_KEY_COUNT, // DescriptorCount
33 {
34 //
35 // EFI_KEY_DESCRIPTOR (total number is USB_KEYBOARD_KEY_COUNT)
36 //
37 { EfiKeyC1, 'a', 'A', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
38 { EfiKeyB5, 'b', 'B', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
39 { EfiKeyB3, 'c', 'C', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
40 { EfiKeyC3, 'd', 'D', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
41 { EfiKeyD3, 'e', 'E', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
42 { EfiKeyC4, 'f', 'F', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
43 { EfiKeyC5, 'g', 'G', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
44 { EfiKeyC6, 'h', 'H', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
45 { EfiKeyD8, 'i', 'I', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
46 { EfiKeyC7, 'j', 'J', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
47 { EfiKeyC8, 'k', 'K', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
48 { EfiKeyC9, 'l', 'L', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
49 { EfiKeyB7, 'm', 'M', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
50 { EfiKeyB6, 'n', 'N', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
51 { EfiKeyD9, 'o', 'O', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
52 { EfiKeyD10, 'p', 'P', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
53 { EfiKeyD1, 'q', 'Q', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
54 { EfiKeyD4, 'r', 'R', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
55 { EfiKeyC2, 's', 'S', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
56 { EfiKeyD5, 't', 'T', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
57 { EfiKeyD7, 'u', 'U', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
58 { EfiKeyB4, 'v', 'V', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
59 { EfiKeyD2, 'w', 'W', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
60 { EfiKeyB2, 'x', 'X', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
61 { EfiKeyD6, 'y', 'Y', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
62 { EfiKeyB1, 'z', 'Z', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_CAPS_LOCK },
63 { EfiKeyE1, '1', '!', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
64 { EfiKeyE2, '2', '@', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
65 { EfiKeyE3, '3', '#', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
66 { EfiKeyE4, '4', '$', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
67 { EfiKeyE5, '5', '%', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
68 { EfiKeyE6, '6', '^', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
69 { EfiKeyE7, '7', '&', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
70 { EfiKeyE8, '8', '*', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
71 { EfiKeyE9, '9', '(', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
72 { EfiKeyE10, '0', ')', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
73 { EfiKeyEnter, 0x0d, 0x0d, 0, 0, EFI_NULL_MODIFIER, 0 },
74 { EfiKeyEsc, 0x1b, 0x1b, 0, 0, EFI_NULL_MODIFIER, 0 },
75 { EfiKeyBackSpace, 0x08, 0x08, 0, 0, EFI_NULL_MODIFIER, 0 },
76 { EfiKeyTab, 0x09, 0x09, 0, 0, EFI_NULL_MODIFIER, 0 },
77 { EfiKeySpaceBar, ' ', ' ', 0, 0, EFI_NULL_MODIFIER, 0 },
78 { EfiKeyE11, '-', '_', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
79 { EfiKeyE12, '=', '+', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
80 { EfiKeyD11, '[', '{', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
81 { EfiKeyD12, ']', '}', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
82 { EfiKeyD13, '\\', '|', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
83 { EfiKeyC12, '\\', '|', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
84 { EfiKeyC10, ';', ':', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
85 { EfiKeyC11, '\'', '"', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
86 { EfiKeyE0, '`', '~', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
87 { EfiKeyB8, ',', '<', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
88 { EfiKeyB9, '.', '>', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
89 { EfiKeyB10, '/', '?', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT },
90 { EfiKeyCapsLock, 0x00, 0x00, 0, 0, EFI_CAPS_LOCK_MODIFIER, 0 },
91 { EfiKeyF1, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_ONE_MODIFIER, 0 },
92 { EfiKeyF2, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TWO_MODIFIER, 0 },
93 { EfiKeyF3, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_THREE_MODIFIER, 0 },
94 { EfiKeyF4, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_FOUR_MODIFIER, 0 },
95 { EfiKeyF5, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_FIVE_MODIFIER, 0 },
96 { EfiKeyF6, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_SIX_MODIFIER, 0 },
97 { EfiKeyF7, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_SEVEN_MODIFIER, 0 },
98 { EfiKeyF8, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_EIGHT_MODIFIER, 0 },
99 { EfiKeyF9, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_NINE_MODIFIER, 0 },
100 { EfiKeyF10, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TEN_MODIFIER, 0 },
101 { EfiKeyF11, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_ELEVEN_MODIFIER, 0 },
102 { EfiKeyF12, 0x00, 0x00, 0, 0, EFI_FUNCTION_KEY_TWELVE_MODIFIER, 0 },
103 { EfiKeyPrint, 0x00, 0x00, 0, 0, EFI_PRINT_MODIFIER, 0 },
104 { EfiKeySLck, 0x00, 0x00, 0, 0, EFI_SCROLL_LOCK_MODIFIER, 0 },
105 { EfiKeyPause, 0x00, 0x00, 0, 0, EFI_PAUSE_MODIFIER, 0 },
106 { EfiKeyIns, 0x00, 0x00, 0, 0, EFI_INSERT_MODIFIER, 0 },
107 { EfiKeyHome, 0x00, 0x00, 0, 0, EFI_HOME_MODIFIER, 0 },
108 { EfiKeyPgUp, 0x00, 0x00, 0, 0, EFI_PAGE_UP_MODIFIER, 0 },
109 { EfiKeyDel, 0x00, 0x00, 0, 0, EFI_DELETE_MODIFIER, 0 },
110 { EfiKeyEnd, 0x00, 0x00, 0, 0, EFI_END_MODIFIER, 0 },
111 { EfiKeyPgDn, 0x00, 0x00, 0, 0, EFI_PAGE_DOWN_MODIFIER, 0 },
112 { EfiKeyRightArrow, 0x00, 0x00, 0, 0, EFI_RIGHT_ARROW_MODIFIER, 0 },
113 { EfiKeyLeftArrow, 0x00, 0x00, 0, 0, EFI_LEFT_ARROW_MODIFIER, 0 },
114 { EfiKeyDownArrow, 0x00, 0x00, 0, 0, EFI_DOWN_ARROW_MODIFIER, 0 },
115 { EfiKeyUpArrow, 0x00, 0x00, 0, 0, EFI_UP_ARROW_MODIFIER, 0 },
116 { EfiKeyNLck, 0x00, 0x00, 0, 0, EFI_NUM_LOCK_MODIFIER, 0 },
117 { EfiKeySlash, '/', '/', 0, 0, EFI_NULL_MODIFIER, 0 },
118 { EfiKeyAsterisk, '*', '*', 0, 0, EFI_NULL_MODIFIER, 0 },
119 { EfiKeyMinus, '-', '-', 0, 0, EFI_NULL_MODIFIER, 0 },
120 { EfiKeyPlus, '+', '+', 0, 0, EFI_NULL_MODIFIER, 0 },
121 { EfiKeyEnter, 0x0d, 0x0d, 0, 0, EFI_NULL_MODIFIER, 0 },
122 { EfiKeyOne, '1', '1', 0, 0, EFI_END_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
123 { EfiKeyTwo, '2', '2', 0, 0, EFI_DOWN_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
124 { EfiKeyThree, '3', '3', 0, 0, EFI_PAGE_DOWN_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
125 { EfiKeyFour, '4', '4', 0, 0, EFI_LEFT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
126 { EfiKeyFive, '5', '5', 0, 0, EFI_NULL_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
127 { EfiKeySix, '6', '6', 0, 0, EFI_RIGHT_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
128 { EfiKeySeven, '7', '7', 0, 0, EFI_HOME_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
129 { EfiKeyEight, '8', '8', 0, 0, EFI_UP_ARROW_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
130 { EfiKeyNine, '9', '9', 0, 0, EFI_PAGE_UP_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
131 { EfiKeyZero, '0', '0', 0, 0, EFI_INSERT_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
132 { EfiKeyPeriod, '.', '.', 0, 0, EFI_DELETE_MODIFIER, EFI_AFFECTED_BY_STANDARD_SHIFT | EFI_AFFECTED_BY_NUM_LOCK },
133 { EfiKeyA4, 0x00, 0x00, 0, 0, EFI_MENU_MODIFIER, 0 },
134 { EfiKeyLCtrl, 0, 0, 0, 0, EFI_LEFT_CONTROL_MODIFIER, 0 },
135 { EfiKeyLShift, 0, 0, 0, 0, EFI_LEFT_SHIFT_MODIFIER, 0 },
136 { EfiKeyLAlt, 0, 0, 0, 0, EFI_LEFT_ALT_MODIFIER, 0 },
137 { EfiKeyA0, 0, 0, 0, 0, EFI_LEFT_LOGO_MODIFIER, 0 },
138 { EfiKeyRCtrl, 0, 0, 0, 0, EFI_RIGHT_CONTROL_MODIFIER, 0 },
139 { EfiKeyRShift, 0, 0, 0, 0, EFI_RIGHT_SHIFT_MODIFIER, 0 },
140 { EfiKeyA2, 0, 0, 0, 0, EFI_RIGHT_ALT_MODIFIER, 0 },
141 { EfiKeyA3, 0, 0, 0, 0, EFI_RIGHT_LOGO_MODIFIER, 0 },
142 },
143 1, // DescriptionCount
144 { 'e', 'n', '-', 'U', 'S' }, // RFC4646 language code
145 ' ', // Space
146 { 'E', 'n', 'g', 'l', 'i', 's', 'h', ' ', 'K', 'e', 'y', 'b', 'o', 'a', 'r', 'd', '\0' }, // DescriptionString[]
147};
148
149//
150// EFI_KEY to USB Keycode conversion table
151// EFI_KEY is defined in UEFI spec.
152// USB Keycode is defined in USB HID Firmware spec.
153//
154UINT8 EfiKeyToUsbKeyCodeConvertionTable[] = {
155 0xe0, // EfiKeyLCtrl
156 0xe3, // EfiKeyA0
157 0xe2, // EfiKeyLAlt
158 0x2c, // EfiKeySpaceBar
159 0xe6, // EfiKeyA2
160 0xe7, // EfiKeyA3
161 0x65, // EfiKeyA4
162 0xe4, // EfiKeyRCtrl
163 0x50, // EfiKeyLeftArrow
164 0x51, // EfiKeyDownArrow
165 0x4F, // EfiKeyRightArrow
166 0x62, // EfiKeyZero
167 0x63, // EfiKeyPeriod
168 0x28, // EfiKeyEnter
169 0xe1, // EfiKeyLShift
170 0x64, // EfiKeyB0
171 0x1D, // EfiKeyB1
172 0x1B, // EfiKeyB2
173 0x06, // EfiKeyB3
174 0x19, // EfiKeyB4
175 0x05, // EfiKeyB5
176 0x11, // EfiKeyB6
177 0x10, // EfiKeyB7
178 0x36, // EfiKeyB8
179 0x37, // EfiKeyB9
180 0x38, // EfiKeyB10
181 0xe5, // EfiKeyRShift
182 0x52, // EfiKeyUpArrow
183 0x59, // EfiKeyOne
184 0x5A, // EfiKeyTwo
185 0x5B, // EfiKeyThree
186 0x39, // EfiKeyCapsLock
187 0x04, // EfiKeyC1
188 0x16, // EfiKeyC2
189 0x07, // EfiKeyC3
190 0x09, // EfiKeyC4
191 0x0A, // EfiKeyC5
192 0x0B, // EfiKeyC6
193 0x0D, // EfiKeyC7
194 0x0E, // EfiKeyC8
195 0x0F, // EfiKeyC9
196 0x33, // EfiKeyC10
197 0x34, // EfiKeyC11
198 0x32, // EfiKeyC12
199 0x5C, // EfiKeyFour
200 0x5D, // EfiKeyFive
201 0x5E, // EfiKeySix
202 0x57, // EfiKeyPlus
203 0x2B, // EfiKeyTab
204 0x14, // EfiKeyD1
205 0x1A, // EfiKeyD2
206 0x08, // EfiKeyD3
207 0x15, // EfiKeyD4
208 0x17, // EfiKeyD5
209 0x1C, // EfiKeyD6
210 0x18, // EfiKeyD7
211 0x0C, // EfiKeyD8
212 0x12, // EfiKeyD9
213 0x13, // EfiKeyD10
214 0x2F, // EfiKeyD11
215 0x30, // EfiKeyD12
216 0x31, // EfiKeyD13
217 0x4C, // EfiKeyDel
218 0x4D, // EfiKeyEnd
219 0x4E, // EfiKeyPgDn
220 0x5F, // EfiKeySeven
221 0x60, // EfiKeyEight
222 0x61, // EfiKeyNine
223 0x35, // EfiKeyE0
224 0x1E, // EfiKeyE1
225 0x1F, // EfiKeyE2
226 0x20, // EfiKeyE3
227 0x21, // EfiKeyE4
228 0x22, // EfiKeyE5
229 0x23, // EfiKeyE6
230 0x24, // EfiKeyE7
231 0x25, // EfiKeyE8
232 0x26, // EfiKeyE9
233 0x27, // EfiKeyE10
234 0x2D, // EfiKeyE11
235 0x2E, // EfiKeyE12
236 0x2A, // EfiKeyBackSpace
237 0x49, // EfiKeyIns
238 0x4A, // EfiKeyHome
239 0x4B, // EfiKeyPgUp
240 0x53, // EfiKeyNLck
241 0x54, // EfiKeySlash
242 0x55, // EfiKeyAsterisk
243 0x56, // EfiKeyMinus
244 0x29, // EfiKeyEsc
245 0x3A, // EfiKeyF1
246 0x3B, // EfiKeyF2
247 0x3C, // EfiKeyF3
248 0x3D, // EfiKeyF4
249 0x3E, // EfiKeyF5
250 0x3F, // EfiKeyF6
251 0x40, // EfiKeyF7
252 0x41, // EfiKeyF8
253 0x42, // EfiKeyF9
254 0x43, // EfiKeyF10
255 0x44, // EfiKeyF11
256 0x45, // EfiKeyF12
257 0x46, // EfiKeyPrint
258 0x47, // EfiKeySLck
259 0x48 // EfiKeyPause
260};
261
262//
263// Keyboard modifier value to EFI Scan Code conversion table
264// EFI Scan Code and the modifier values are defined in UEFI spec.
265//
266UINT8 ModifierValueToEfiScanCodeConvertionTable[] = {
267 SCAN_NULL, // EFI_NULL_MODIFIER
268 SCAN_NULL, // EFI_LEFT_CONTROL_MODIFIER
269 SCAN_NULL, // EFI_RIGHT_CONTROL_MODIFIER
270 SCAN_NULL, // EFI_LEFT_ALT_MODIFIER
271 SCAN_NULL, // EFI_RIGHT_ALT_MODIFIER
272 SCAN_NULL, // EFI_ALT_GR_MODIFIER
273 SCAN_INSERT, // EFI_INSERT_MODIFIER
274 SCAN_DELETE, // EFI_DELETE_MODIFIER
275 SCAN_PAGE_DOWN, // EFI_PAGE_DOWN_MODIFIER
276 SCAN_PAGE_UP, // EFI_PAGE_UP_MODIFIER
277 SCAN_HOME, // EFI_HOME_MODIFIER
278 SCAN_END, // EFI_END_MODIFIER
279 SCAN_NULL, // EFI_LEFT_SHIFT_MODIFIER
280 SCAN_NULL, // EFI_RIGHT_SHIFT_MODIFIER
281 SCAN_NULL, // EFI_CAPS_LOCK_MODIFIER
282 SCAN_NULL, // EFI_NUM_LOCK_MODIFIER
283 SCAN_LEFT, // EFI_LEFT_ARROW_MODIFIER
284 SCAN_RIGHT, // EFI_RIGHT_ARROW_MODIFIER
285 SCAN_DOWN, // EFI_DOWN_ARROW_MODIFIER
286 SCAN_UP, // EFI_UP_ARROW_MODIFIER
287 SCAN_NULL, // EFI_NS_KEY_MODIFIER
288 SCAN_NULL, // EFI_NS_KEY_DEPENDENCY_MODIFIER
289 SCAN_F1, // EFI_FUNCTION_KEY_ONE_MODIFIER
290 SCAN_F2, // EFI_FUNCTION_KEY_TWO_MODIFIER
291 SCAN_F3, // EFI_FUNCTION_KEY_THREE_MODIFIER
292 SCAN_F4, // EFI_FUNCTION_KEY_FOUR_MODIFIER
293 SCAN_F5, // EFI_FUNCTION_KEY_FIVE_MODIFIER
294 SCAN_F6, // EFI_FUNCTION_KEY_SIX_MODIFIER
295 SCAN_F7, // EFI_FUNCTION_KEY_SEVEN_MODIFIER
296 SCAN_F8, // EFI_FUNCTION_KEY_EIGHT_MODIFIER
297 SCAN_F9, // EFI_FUNCTION_KEY_NINE_MODIFIER
298 SCAN_F10, // EFI_FUNCTION_KEY_TEN_MODIFIER
299 SCAN_F11, // EFI_FUNCTION_KEY_ELEVEN_MODIFIER
300 SCAN_F12, // EFI_FUNCTION_KEY_TWELVE_MODIFIER
301 //
302 // For Partial Keystroke support
303 //
304 SCAN_NULL, // EFI_PRINT_MODIFIER
305 SCAN_NULL, // EFI_SYS_REQUEST_MODIFIER
306 SCAN_NULL, // EFI_SCROLL_LOCK_MODIFIER
307 SCAN_PAUSE, // EFI_PAUSE_MODIFIER
308 SCAN_NULL, // EFI_BREAK_MODIFIER
309 SCAN_NULL, // EFI_LEFT_LOGO_MODIFIER
310 SCAN_NULL, // EFI_RIGHT_LOGO_MODIFER
311 SCAN_NULL, // EFI_MENU_MODIFER
312};
313
323BOOLEAN
324IsUSBKeyboard (
325 IN EFI_USB_IO_PROTOCOL *UsbIo
326 )
327{
328 EFI_STATUS Status;
329 EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
330
331 //
332 // Get the default interface descriptor
333 //
334 Status = UsbIo->UsbGetInterfaceDescriptor (
335 UsbIo,
336 &InterfaceDescriptor
337 );
338
339 if (EFI_ERROR (Status)) {
340 return FALSE;
341 }
342
343 if ((InterfaceDescriptor.InterfaceClass == CLASS_HID) &&
344 (InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT) &&
345 (InterfaceDescriptor.InterfaceProtocol == PROTOCOL_KEYBOARD)
346 )
347 {
348 return TRUE;
349 }
350
351 return FALSE;
352}
353
364EFI_KEY_DESCRIPTOR *
365GetKeyDescriptor (
366 IN USB_KB_DEV *UsbKeyboardDevice,
367 IN UINT8 KeyCode
368 )
369{
370 UINT8 Index;
371
372 //
373 // Make sure KeyCode is in the range of [0x4, 0x65] or [0xe0, 0xe7]
374 //
375 if ((!USBKBD_VALID_KEYCODE (KeyCode)) || ((KeyCode > 0x65) && (KeyCode < 0xe0)) || (KeyCode > 0xe7)) {
376 return NULL;
377 }
378
379 //
380 // Calculate the index of Key Descriptor in Key Convertion Table
381 //
382 if (KeyCode <= 0x65) {
383 Index = (UINT8)(KeyCode - 4);
384 } else {
385 Index = (UINT8)(KeyCode - 0xe0 + NUMBER_OF_VALID_NON_MODIFIER_USB_KEYCODE);
386 }
387
388 return &UsbKeyboardDevice->KeyConvertionTable[Index];
389}
390
401USB_NS_KEY *
402FindUsbNsKey (
403 IN USB_KB_DEV *UsbKeyboardDevice,
404 IN EFI_KEY_DESCRIPTOR *KeyDescriptor
405 )
406{
407 LIST_ENTRY *Link;
408 LIST_ENTRY *NsKeyList;
409 USB_NS_KEY *UsbNsKey;
410
411 NsKeyList = &UsbKeyboardDevice->NsKeyList;
412 Link = GetFirstNode (NsKeyList);
413 while (!IsNull (NsKeyList, Link)) {
414 UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);
415
416 if (UsbNsKey->NsKey[0].Key == KeyDescriptor->Key) {
417 return UsbNsKey;
418 }
419
420 Link = GetNextNode (NsKeyList, Link);
421 }
422
423 return NULL;
424}
425
441EFI_KEY_DESCRIPTOR *
442FindPhysicalKey (
443 IN USB_NS_KEY *UsbNsKey,
444 IN EFI_KEY_DESCRIPTOR *KeyDescriptor
445 )
446{
447 UINTN Index;
448 EFI_KEY_DESCRIPTOR *PhysicalKey;
449
450 PhysicalKey = &UsbNsKey->NsKey[1];
451 for (Index = 0; Index < UsbNsKey->KeyCount; Index++) {
452 if (KeyDescriptor->Key == PhysicalKey->Key) {
453 return PhysicalKey;
454 }
455
456 PhysicalKey++;
457 }
458
459 //
460 // No children definition matched, return original key
461 //
462 return KeyDescriptor;
463}
464
471VOID
472ReleaseKeyboardLayoutResources (
473 IN OUT USB_KB_DEV *UsbKeyboardDevice
474 )
475{
476 USB_NS_KEY *UsbNsKey;
477 LIST_ENTRY *Link;
478
479 if (UsbKeyboardDevice->KeyConvertionTable != NULL) {
480 FreePool (UsbKeyboardDevice->KeyConvertionTable);
481 }
482
483 UsbKeyboardDevice->KeyConvertionTable = NULL;
484
485 if (UsbKeyboardDevice->NsKeyList.ForwardLink == NULL) {
486 return;
487 }
488
489 while (!IsListEmpty (&UsbKeyboardDevice->NsKeyList)) {
490 Link = GetFirstNode (&UsbKeyboardDevice->NsKeyList);
491 UsbNsKey = USB_NS_KEY_FORM_FROM_LINK (Link);
492 RemoveEntryList (&UsbNsKey->Link);
493
494 FreePool (UsbNsKey->NsKey);
495 FreePool (UsbNsKey);
496 }
497}
498
514EFI_STATUS
515InitKeyboardLayout (
516 OUT USB_KB_DEV *UsbKeyboardDevice
517 )
518{
519 EFI_KEY_DESCRIPTOR TempKey;
520 EFI_KEY_DESCRIPTOR *KeyDescriptor;
521 EFI_KEY_DESCRIPTOR *TableEntry;
522 EFI_KEY_DESCRIPTOR *NsKey;
523 USB_NS_KEY *UsbNsKey;
524 UINT8 DescIndex;
525 UINT8 DescIndex2;
526 UINT8 KeyCount;
527 UINT8 KeyCode;
528
529 UsbKeyboardDevice->KeyConvertionTable = AllocateZeroPool ((NUMBER_OF_VALID_USB_KEYCODE)*sizeof (EFI_KEY_DESCRIPTOR));
530 ASSERT (UsbKeyboardDevice->KeyConvertionTable != NULL);
531
532 InitializeListHead (&UsbKeyboardDevice->NsKeyList);
533 UsbKeyboardDevice->CurrentNsKey = NULL;
534
535 //
536 // Traverse the list of key descriptors following the header of EFI_HII_KEYBOARD_LAYOUT
537 //
538 KeyDescriptor = (EFI_KEY_DESCRIPTOR *)(&mUsbKeyboardLayoutBin.KeyDescriptor[0]);
539 for (DescIndex = 0; DescIndex < mUsbKeyboardLayoutBin.DescriptorCount; DescIndex++) {
540 //
541 // Copy from HII keyboard layout package binary for alignment
542 //
543 CopyMem (&TempKey, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
544
545 //
546 // Fill the key into KeyConvertionTable, whose index is calculated from USB keycode.
547 //
548 KeyCode = EfiKeyToUsbKeyCodeConvertionTable[(UINT8)(TempKey.Key)];
549 TableEntry = GetKeyDescriptor (UsbKeyboardDevice, KeyCode);
550 if (TableEntry == NULL) {
551 ReleaseKeyboardLayoutResources (UsbKeyboardDevice);
552 return EFI_OUT_OF_RESOURCES;
553 }
554
555 CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
556
557 //
558 // For non-spacing key, create the list with a non-spacing key followed by physical keys.
559 //
560 if (TempKey.Modifier == EFI_NS_KEY_MODIFIER) {
561 UsbNsKey = AllocateZeroPool (sizeof (USB_NS_KEY));
562 ASSERT (UsbNsKey != NULL);
563
564 //
565 // Search for sequential children physical key definitions
566 //
567 KeyCount = 0;
568 NsKey = KeyDescriptor + 1;
569 for (DescIndex2 = DescIndex + 1; DescIndex2 < mUsbKeyboardLayoutBin.DescriptorCount; DescIndex2++) {
570 CopyMem (&TempKey, NsKey, sizeof (EFI_KEY_DESCRIPTOR));
571 if (TempKey.Modifier == EFI_NS_KEY_DEPENDENCY_MODIFIER) {
572 KeyCount++;
573 } else {
574 break;
575 }
576
577 NsKey++;
578 }
579
580 UsbNsKey->Signature = USB_NS_KEY_SIGNATURE;
581 UsbNsKey->KeyCount = KeyCount;
582 UsbNsKey->NsKey = AllocateCopyPool (
583 (KeyCount + 1) * sizeof (EFI_KEY_DESCRIPTOR),
584 KeyDescriptor
585 );
586 InsertTailList (&UsbKeyboardDevice->NsKeyList, &UsbNsKey->Link);
587
588 //
589 // Skip over the child physical keys
590 //
591 DescIndex += KeyCount;
592 KeyDescriptor += KeyCount;
593 }
594
595 KeyDescriptor++;
596 }
597
598 //
599 // There are two EfiKeyEnter, duplicate its key descriptor
600 //
601 TableEntry = GetKeyDescriptor (UsbKeyboardDevice, 0x58);
602 KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, 0x28);
603 CopyMem (TableEntry, KeyDescriptor, sizeof (EFI_KEY_DESCRIPTOR));
604
605 return EFI_SUCCESS;
606}
607
617EFI_STATUS
618InitUSBKeyboard (
619 IN OUT USB_KB_DEV *UsbKeyboardDevice
620 )
621{
622 UINT16 ConfigValue;
623 UINT8 Protocol;
624 EFI_STATUS Status;
625 UINT32 TransferResult;
626
627 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
628 EFI_PROGRESS_CODE,
629 (EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST),
630 UsbKeyboardDevice->DevicePath
631 );
632
633 InitQueue (&UsbKeyboardDevice->UsbKeyQueue, sizeof (USB_KEY));
634 InitQueue (&UsbKeyboardDevice->EfiKeyQueue, sizeof (EFI_KEY_DATA));
635 InitQueue (&UsbKeyboardDevice->EfiKeyQueueForNotify, sizeof (EFI_KEY_DATA));
636
637 //
638 // Use the config out of the descriptor
639 // Assumed the first config is the correct one and this is not always the case
640 //
641 Status = UsbGetConfiguration (
642 UsbKeyboardDevice->UsbIo,
643 &ConfigValue,
644 &TransferResult
645 );
646 if (EFI_ERROR (Status)) {
647 ConfigValue = 0x01;
648 //
649 // Uses default configuration to configure the USB Keyboard device.
650 //
651 Status = UsbSetConfiguration (
652 UsbKeyboardDevice->UsbIo,
653 ConfigValue,
654 &TransferResult
655 );
656 if (EFI_ERROR (Status)) {
657 //
658 // If configuration could not be set here, it means
659 // the keyboard interface has some errors and could
660 // not be initialized
661 //
662 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
663 EFI_ERROR_CODE | EFI_ERROR_MINOR,
664 (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INTERFACE_ERROR),
665 UsbKeyboardDevice->DevicePath
666 );
667
668 return EFI_DEVICE_ERROR;
669 }
670 }
671
672 UsbGetProtocolRequest (
673 UsbKeyboardDevice->UsbIo,
674 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
675 &Protocol
676 );
677 //
678 // Set boot protocol for the USB Keyboard.
679 // This driver only supports boot protocol.
680 //
681 if (Protocol != BOOT_PROTOCOL) {
682 UsbSetProtocolRequest (
683 UsbKeyboardDevice->UsbIo,
684 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
685 BOOT_PROTOCOL
686 );
687 }
688
689 UsbKeyboardDevice->CtrlOn = FALSE;
690 UsbKeyboardDevice->AltOn = FALSE;
691 UsbKeyboardDevice->ShiftOn = FALSE;
692 UsbKeyboardDevice->NumLockOn = FALSE;
693 UsbKeyboardDevice->CapsOn = FALSE;
694 UsbKeyboardDevice->ScrollOn = FALSE;
695
696 UsbKeyboardDevice->LeftCtrlOn = FALSE;
697 UsbKeyboardDevice->LeftAltOn = FALSE;
698 UsbKeyboardDevice->LeftShiftOn = FALSE;
699 UsbKeyboardDevice->LeftLogoOn = FALSE;
700 UsbKeyboardDevice->RightCtrlOn = FALSE;
701 UsbKeyboardDevice->RightAltOn = FALSE;
702 UsbKeyboardDevice->RightShiftOn = FALSE;
703 UsbKeyboardDevice->RightLogoOn = FALSE;
704 UsbKeyboardDevice->MenuKeyOn = FALSE;
705 UsbKeyboardDevice->SysReqOn = FALSE;
706
707 UsbKeyboardDevice->AltGrOn = FALSE;
708
709 UsbKeyboardDevice->CurrentNsKey = NULL;
710
711 //
712 // Sync the initial state of lights on keyboard.
713 //
714 SetKeyLED (UsbKeyboardDevice);
715
716 ZeroMem (UsbKeyboardDevice->LastKeyCodeArray, sizeof (UINT8) * 8);
717
718 //
719 // Create event for repeat keys' generation.
720 //
721 if (UsbKeyboardDevice->RepeatTimer != NULL) {
722 gBS->CloseEvent (UsbKeyboardDevice->RepeatTimer);
723 UsbKeyboardDevice->RepeatTimer = NULL;
724 }
725
726 gBS->CreateEvent (
727 EVT_TIMER | EVT_NOTIFY_SIGNAL,
728 TPL_CALLBACK,
729 USBKeyboardRepeatHandler,
730 UsbKeyboardDevice,
731 &UsbKeyboardDevice->RepeatTimer
732 );
733
734 //
735 // Create event for delayed recovery, which deals with device error.
736 //
737 if (UsbKeyboardDevice->DelayedRecoveryEvent != NULL) {
738 gBS->CloseEvent (UsbKeyboardDevice->DelayedRecoveryEvent);
739 UsbKeyboardDevice->DelayedRecoveryEvent = NULL;
740 }
741
742 gBS->CreateEvent (
743 EVT_TIMER | EVT_NOTIFY_SIGNAL,
744 TPL_NOTIFY,
745 USBKeyboardRecoveryHandler,
746 UsbKeyboardDevice,
747 &UsbKeyboardDevice->DelayedRecoveryEvent
748 );
749
750 return EFI_SUCCESS;
751}
752
771EFI_STATUS
772EFIAPI
773KeyboardHandler (
774 IN VOID *Data,
775 IN UINTN DataLength,
776 IN VOID *Context,
777 IN UINT32 Result
778 )
779{
780 USB_KB_DEV *UsbKeyboardDevice;
781 EFI_USB_IO_PROTOCOL *UsbIo;
782 UINT8 *CurKeyCodeBuffer;
783 UINT8 *OldKeyCodeBuffer;
784 UINT8 CurModifierMap;
785 UINT8 OldModifierMap;
786 UINT8 Mask;
787 UINTN Index;
788 UINT8 Index2;
789 BOOLEAN KeyRelease;
790 BOOLEAN KeyPress;
791 USB_KEY UsbKey;
792 UINT8 NewRepeatKey;
793 UINT32 UsbStatus;
794 EFI_KEY_DESCRIPTOR *KeyDescriptor;
795 UINTN NumberOfKeyCodes;
796 APPLE_KEY_CODE KeyCodes[6];
797
798 ASSERT (Context != NULL);
799
800 NewRepeatKey = 0;
801 UsbKeyboardDevice = (USB_KB_DEV *)Context;
802 UsbIo = UsbKeyboardDevice->UsbIo;
803
804 //
805 // Analyzes Result and performs corresponding action.
806 //
807 if (Result != EFI_USB_NOERROR) {
808 //
809 // Some errors happen during the process
810 //
811 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
812 EFI_ERROR_CODE | EFI_ERROR_MINOR,
813 (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INPUT_ERROR),
814 UsbKeyboardDevice->DevicePath
815 );
816
817 //
818 // Stop the repeat key generation if any
819 //
820 UsbKeyboardDevice->RepeatKey = 0;
821
822 gBS->SetTimer (
823 UsbKeyboardDevice->RepeatTimer,
824 TimerCancel,
825 USBKBD_REPEAT_RATE
826 );
827
828 if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
829 UsbClearEndpointHalt (
830 UsbIo,
831 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
832 &UsbStatus
833 );
834 }
835
836 //
837 // Delete & Submit this interrupt again
838 // Handler of DelayedRecoveryEvent triggered by timer will re-submit the interrupt.
839 //
840 UsbIo->UsbAsyncInterruptTransfer (
841 UsbIo,
842 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
843 FALSE,
844 0,
845 0,
846 NULL,
847 NULL
848 );
849 //
850 // EFI_USB_INTERRUPT_DELAY is defined in USB standard for error handling.
851 //
852 gBS->SetTimer (
853 UsbKeyboardDevice->DelayedRecoveryEvent,
854 TimerRelative,
855 EFI_USB_INTERRUPT_DELAY
856 );
857
858 return EFI_DEVICE_ERROR;
859 }
860
861 //
862 // If no error and no data, just return EFI_SUCCESS.
863 //
864 if ((DataLength == 0) || (Data == NULL)) {
865 return EFI_SUCCESS;
866 }
867
868 //
869 // Following code checks current keyboard input report against old key code buffer.
870 // According to USB HID Firmware Specification, the report consists of 8 bytes.
871 // Byte 0 is map of Modifier keys.
872 // Byte 1 is reserved.
873 // Bytes 2 to 7 are keycodes.
874 //
875 if (DataLength < 8) {
876 return EFI_DEVICE_ERROR;
877 }
878
879 CurKeyCodeBuffer = (UINT8 *)Data;
880 OldKeyCodeBuffer = UsbKeyboardDevice->LastKeyCodeArray;
881
882 //
883 // Checks for new key stroke.
884 //
885 for (Index = 0; Index < 8; Index++) {
886 if (OldKeyCodeBuffer[Index] != CurKeyCodeBuffer[Index]) {
887 break;
888 }
889 }
890
891 //
892 // If no new key, return EFI_SUCCESS immediately.
893 //
894 if (Index == 8) {
895 return EFI_SUCCESS;
896 }
897
898 //
899 // Parse the modifier key, which is the first byte of keyboard input report.
900 //
901 CurModifierMap = CurKeyCodeBuffer[0];
902 OldModifierMap = OldKeyCodeBuffer[0];
903
904 NumberOfKeyCodes = 0;
905
906 //
907 // Pass the data to the Apple protocol
908 //
909 for (Index = 2; Index < 8; Index++) {
910 if (USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index])) {
911 KeyCodes[NumberOfKeyCodes] = APPLE_HID_USB_KB_KP_USAGE (
912 CurKeyCodeBuffer[Index]
913 );
914
915 ++NumberOfKeyCodes;
916 }
917 }
918
919 if (UsbKeyboardDevice->KeyMapDb != NULL) {
920 UsbKeyboardDevice->KeyMapDb->SetKeyStrokeBufferKeys (
921 UsbKeyboardDevice->KeyMapDb,
922 UsbKeyboardDevice->KeyMapDbIndex,
923 (APPLE_MODIFIER_MAP)CurModifierMap,
924 NumberOfKeyCodes,
925 &KeyCodes[0]
926 );
927 }
928
929 //
930 // Handle modifier key's pressing or releasing situation.
931 // According to USB HID Firmware spec, Byte 0 uses following map of Modifier keys:
932 // Bit0: Left Control, Keycode: 0xe0
933 // Bit1: Left Shift, Keycode: 0xe1
934 // Bit2: Left Alt, Keycode: 0xe2
935 // Bit3: Left GUI, Keycode: 0xe3
936 // Bit4: Right Control, Keycode: 0xe4
937 // Bit5: Right Shift, Keycode: 0xe5
938 // Bit6: Right Alt, Keycode: 0xe6
939 // Bit7: Right GUI, Keycode: 0xe7
940 //
941 for (Index = 0; Index < 8; Index++) {
942 Mask = (UINT8)(1 << Index);
943 if ((CurModifierMap & Mask) != (OldModifierMap & Mask)) {
944 //
945 // If current modifier key is up, then CurModifierMap & Mask = 0;
946 // otherwise it is a non-zero value.
947 // Insert the changed modifier key into key buffer.
948 //
949 UsbKey.KeyCode = (UINT8)(0xe0 + Index);
950 UsbKey.Down = (BOOLEAN)((CurModifierMap & Mask) != 0);
951 Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));
952 }
953 }
954
955 //
956 // Handle normal key's releasing situation
957 // Bytes 2 to 7 are for normal keycodes
958 //
959 KeyRelease = FALSE;
960 for (Index = 2; Index < 8; Index++) {
961 if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index])) {
962 continue;
963 }
964
965 //
966 // For any key in old keycode buffer, if it is not in current keycode buffer,
967 // then it is released. Otherwise, it is not released.
968 //
969 KeyRelease = TRUE;
970 for (Index2 = 2; Index2 < 8; Index2++) {
971 if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index2])) {
972 continue;
973 }
974
975 if (OldKeyCodeBuffer[Index] == CurKeyCodeBuffer[Index2]) {
976 KeyRelease = FALSE;
977 break;
978 }
979 }
980
981 if (KeyRelease) {
982 UsbKey.KeyCode = OldKeyCodeBuffer[Index];
983 UsbKey.Down = FALSE;
984 Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));
985 //
986 // The original repeat key is released.
987 //
988 if (OldKeyCodeBuffer[Index] == UsbKeyboardDevice->RepeatKey) {
989 UsbKeyboardDevice->RepeatKey = 0;
990 }
991 }
992 }
993
994 //
995 // If original repeat key is released, cancel the repeat timer
996 //
997 if (UsbKeyboardDevice->RepeatKey == 0) {
998 gBS->SetTimer (
999 UsbKeyboardDevice->RepeatTimer,
1000 TimerCancel,
1001 USBKBD_REPEAT_RATE
1002 );
1003 }
1004
1005 //
1006 // Handle normal key's pressing situation
1007 //
1008 KeyPress = FALSE;
1009 for (Index = 2; Index < 8; Index++) {
1010 if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index])) {
1011 continue;
1012 }
1013
1014 //
1015 // For any key in current keycode buffer, if it is not in old keycode buffer,
1016 // then it is pressed. Otherwise, it is not pressed.
1017 //
1018 KeyPress = TRUE;
1019 for (Index2 = 2; Index2 < 8; Index2++) {
1020 if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index2])) {
1021 continue;
1022 }
1023
1024 if (CurKeyCodeBuffer[Index] == OldKeyCodeBuffer[Index2]) {
1025 KeyPress = FALSE;
1026 break;
1027 }
1028 }
1029
1030 if (KeyPress) {
1031 UsbKey.KeyCode = CurKeyCodeBuffer[Index];
1032 UsbKey.Down = TRUE;
1033 Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));
1034
1035 //
1036 // Handle repeat key
1037 //
1038 KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, CurKeyCodeBuffer[Index]);
1039 if (KeyDescriptor == NULL) {
1040 continue;
1041 }
1042
1043 if ((KeyDescriptor->Modifier == EFI_NUM_LOCK_MODIFIER) || (KeyDescriptor->Modifier == EFI_CAPS_LOCK_MODIFIER)) {
1044 //
1045 // For NumLock or CapsLock pressed, there is no need to handle repeat key for them.
1046 //
1047 UsbKeyboardDevice->RepeatKey = 0;
1048 } else {
1049 //
1050 // Prepare new repeat key, and clear the original one.
1051 //
1052 NewRepeatKey = CurKeyCodeBuffer[Index];
1053 UsbKeyboardDevice->RepeatKey = 0;
1054 }
1055 }
1056 }
1057
1058 //
1059 // Update LastKeycodeArray buffer in the UsbKeyboardDevice data structure.
1060 //
1061 for (Index = 0; Index < 8; Index++) {
1062 UsbKeyboardDevice->LastKeyCodeArray[Index] = CurKeyCodeBuffer[Index];
1063 }
1064
1065 //
1066 // If there is new key pressed, update the RepeatKey value, and set the
1067 // timer to repeat delay timer
1068 //
1069 if (NewRepeatKey != 0) {
1070 //
1071 // Sets trigger time to "Repeat Delay Time",
1072 // to trigger the repeat timer when the key is hold long
1073 // enough time.
1074 //
1075 gBS->SetTimer (
1076 UsbKeyboardDevice->RepeatTimer,
1077 TimerRelative,
1078 USBKBD_REPEAT_DELAY
1079 );
1080 UsbKeyboardDevice->RepeatKey = NewRepeatKey;
1081 }
1082
1083 return EFI_SUCCESS;
1084}
1085
1099EFI_STATUS
1100USBParseKey (
1101 IN OUT USB_KB_DEV *UsbKeyboardDevice,
1102 OUT UINT8 *KeyCode
1103 )
1104{
1105 USB_KEY UsbKey;
1106 EFI_KEY_DESCRIPTOR *KeyDescriptor;
1107
1108 *KeyCode = 0;
1109
1110 while (!IsQueueEmpty (&UsbKeyboardDevice->UsbKeyQueue)) {
1111 //
1112 // Pops one raw data off.
1113 //
1114 Dequeue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));
1115
1116 KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, UsbKey.KeyCode);
1117 if (KeyDescriptor == NULL) {
1118 continue;
1119 }
1120
1121 if (!UsbKey.Down) {
1122 //
1123 // Key is released.
1124 //
1125 switch (KeyDescriptor->Modifier) {
1126 //
1127 // Ctrl release
1128 //
1129 case EFI_LEFT_CONTROL_MODIFIER:
1130 UsbKeyboardDevice->LeftCtrlOn = FALSE;
1131 UsbKeyboardDevice->CtrlOn = FALSE;
1132 break;
1133 case EFI_RIGHT_CONTROL_MODIFIER:
1134 UsbKeyboardDevice->RightCtrlOn = FALSE;
1135 UsbKeyboardDevice->CtrlOn = FALSE;
1136 break;
1137
1138 //
1139 // Shift release
1140 //
1141 case EFI_LEFT_SHIFT_MODIFIER:
1142 UsbKeyboardDevice->LeftShiftOn = FALSE;
1143 UsbKeyboardDevice->ShiftOn = FALSE;
1144 break;
1145 case EFI_RIGHT_SHIFT_MODIFIER:
1146 UsbKeyboardDevice->RightShiftOn = FALSE;
1147 UsbKeyboardDevice->ShiftOn = FALSE;
1148 break;
1149
1150 //
1151 // Alt release
1152 //
1153 case EFI_LEFT_ALT_MODIFIER:
1154 UsbKeyboardDevice->LeftAltOn = FALSE;
1155 UsbKeyboardDevice->AltOn = FALSE;
1156 break;
1157 case EFI_RIGHT_ALT_MODIFIER:
1158 UsbKeyboardDevice->RightAltOn = FALSE;
1159 UsbKeyboardDevice->AltOn = FALSE;
1160 break;
1161
1162 //
1163 // Left Logo release
1164 //
1165 case EFI_LEFT_LOGO_MODIFIER:
1166 UsbKeyboardDevice->LeftLogoOn = FALSE;
1167 break;
1168
1169 //
1170 // Right Logo release
1171 //
1172 case EFI_RIGHT_LOGO_MODIFIER:
1173 UsbKeyboardDevice->RightLogoOn = FALSE;
1174 break;
1175
1176 //
1177 // Menu key release
1178 //
1179 case EFI_MENU_MODIFIER:
1180 UsbKeyboardDevice->MenuKeyOn = FALSE;
1181 break;
1182
1183 //
1184 // SysReq release
1185 //
1186 case EFI_PRINT_MODIFIER:
1187 case EFI_SYS_REQUEST_MODIFIER:
1188 UsbKeyboardDevice->SysReqOn = FALSE;
1189 break;
1190
1191 //
1192 // AltGr release
1193 //
1194 case EFI_ALT_GR_MODIFIER:
1195 UsbKeyboardDevice->AltGrOn = FALSE;
1196 break;
1197
1198 default:
1199 break;
1200 }
1201
1202 continue;
1203 }
1204
1205 //
1206 // Analyzes key pressing situation
1207 //
1208 switch (KeyDescriptor->Modifier) {
1209 //
1210 // Ctrl press
1211 //
1212 case EFI_LEFT_CONTROL_MODIFIER:
1213 UsbKeyboardDevice->LeftCtrlOn = TRUE;
1214 UsbKeyboardDevice->CtrlOn = TRUE;
1215 break;
1216 case EFI_RIGHT_CONTROL_MODIFIER:
1217 UsbKeyboardDevice->RightCtrlOn = TRUE;
1218 UsbKeyboardDevice->CtrlOn = TRUE;
1219 break;
1220
1221 //
1222 // Shift press
1223 //
1224 case EFI_LEFT_SHIFT_MODIFIER:
1225 UsbKeyboardDevice->LeftShiftOn = TRUE;
1226 UsbKeyboardDevice->ShiftOn = TRUE;
1227 break;
1228 case EFI_RIGHT_SHIFT_MODIFIER:
1229 UsbKeyboardDevice->RightShiftOn = TRUE;
1230 UsbKeyboardDevice->ShiftOn = TRUE;
1231 break;
1232
1233 //
1234 // Alt press
1235 //
1236 case EFI_LEFT_ALT_MODIFIER:
1237 UsbKeyboardDevice->LeftAltOn = TRUE;
1238 UsbKeyboardDevice->AltOn = TRUE;
1239 break;
1240 case EFI_RIGHT_ALT_MODIFIER:
1241 UsbKeyboardDevice->RightAltOn = TRUE;
1242 UsbKeyboardDevice->AltOn = TRUE;
1243 break;
1244
1245 //
1246 // Left Logo press
1247 //
1248 case EFI_LEFT_LOGO_MODIFIER:
1249 UsbKeyboardDevice->LeftLogoOn = TRUE;
1250 break;
1251
1252 //
1253 // Right Logo press
1254 //
1255 case EFI_RIGHT_LOGO_MODIFIER:
1256 UsbKeyboardDevice->RightLogoOn = TRUE;
1257 break;
1258
1259 //
1260 // Menu key press
1261 //
1262 case EFI_MENU_MODIFIER:
1263 UsbKeyboardDevice->MenuKeyOn = TRUE;
1264 break;
1265
1266 //
1267 // SysReq press
1268 //
1269 case EFI_PRINT_MODIFIER:
1270 case EFI_SYS_REQUEST_MODIFIER:
1271 UsbKeyboardDevice->SysReqOn = TRUE;
1272 break;
1273
1274 //
1275 // AltGr press
1276 //
1277 case EFI_ALT_GR_MODIFIER:
1278 UsbKeyboardDevice->AltGrOn = TRUE;
1279 break;
1280
1281 case EFI_NUM_LOCK_MODIFIER:
1282 //
1283 // Toggle NumLock
1284 //
1285 UsbKeyboardDevice->NumLockOn = (BOOLEAN)(!(UsbKeyboardDevice->NumLockOn));
1286 SetKeyLED (UsbKeyboardDevice);
1287 break;
1288
1289 case EFI_CAPS_LOCK_MODIFIER:
1290 //
1291 // Toggle CapsLock
1292 //
1293 UsbKeyboardDevice->CapsOn = (BOOLEAN)(!(UsbKeyboardDevice->CapsOn));
1294 SetKeyLED (UsbKeyboardDevice);
1295 break;
1296
1297 case EFI_SCROLL_LOCK_MODIFIER:
1298 //
1299 // Toggle ScrollLock
1300 //
1301 UsbKeyboardDevice->ScrollOn = (BOOLEAN)(!(UsbKeyboardDevice->ScrollOn));
1302 SetKeyLED (UsbKeyboardDevice);
1303 break;
1304
1305 default:
1306 break;
1307 }
1308
1309 //
1310 // When encountering Ctrl + Alt + Del, then warm reset.
1311 //
1312 if (KeyDescriptor->Modifier == EFI_DELETE_MODIFIER) {
1313 if ((UsbKeyboardDevice->CtrlOn) && (UsbKeyboardDevice->AltOn)) {
1314 //
1315 // CHANGE: Use library call to be able to centrally alter the behaviour.
1316 //
1317 ResetWarm ();
1318 }
1319 }
1320
1321 *KeyCode = UsbKey.KeyCode;
1322 return EFI_SUCCESS;
1323 }
1324
1325 return EFI_NOT_READY;
1326}
1327
1334VOID
1335InitializeKeyState (
1336 IN USB_KB_DEV *UsbKeyboardDevice,
1337 OUT EFI_KEY_STATE *KeyState
1338 )
1339{
1340 KeyState->KeyShiftState = EFI_SHIFT_STATE_VALID;
1341 KeyState->KeyToggleState = EFI_TOGGLE_STATE_VALID;
1342
1343 if (UsbKeyboardDevice->LeftCtrlOn) {
1344 KeyState->KeyShiftState |= EFI_LEFT_CONTROL_PRESSED;
1345 }
1346
1347 if (UsbKeyboardDevice->RightCtrlOn) {
1348 KeyState->KeyShiftState |= EFI_RIGHT_CONTROL_PRESSED;
1349 }
1350
1351 if (UsbKeyboardDevice->LeftAltOn) {
1352 KeyState->KeyShiftState |= EFI_LEFT_ALT_PRESSED;
1353 }
1354
1355 if (UsbKeyboardDevice->RightAltOn) {
1356 KeyState->KeyShiftState |= EFI_RIGHT_ALT_PRESSED;
1357 }
1358
1359 if (UsbKeyboardDevice->LeftShiftOn) {
1360 KeyState->KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
1361 }
1362
1363 if (UsbKeyboardDevice->RightShiftOn) {
1364 KeyState->KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
1365 }
1366
1367 if (UsbKeyboardDevice->LeftLogoOn) {
1368 KeyState->KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
1369 }
1370
1371 if (UsbKeyboardDevice->RightLogoOn) {
1372 KeyState->KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
1373 }
1374
1375 if (UsbKeyboardDevice->MenuKeyOn) {
1376 KeyState->KeyShiftState |= EFI_MENU_KEY_PRESSED;
1377 }
1378
1379 if (UsbKeyboardDevice->SysReqOn) {
1380 KeyState->KeyShiftState |= EFI_SYS_REQ_PRESSED;
1381 }
1382
1383 if (UsbKeyboardDevice->ScrollOn) {
1384 KeyState->KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
1385 }
1386
1387 if (UsbKeyboardDevice->NumLockOn) {
1388 KeyState->KeyToggleState |= EFI_NUM_LOCK_ACTIVE;
1389 }
1390
1391 if (UsbKeyboardDevice->CapsOn) {
1392 KeyState->KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
1393 }
1394
1395 if (UsbKeyboardDevice->IsSupportPartialKey) {
1396 KeyState->KeyToggleState |= EFI_KEY_STATE_EXPOSED;
1397 }
1398}
1399
1416EFI_STATUS
1417UsbKeyCodeToEfiInputKey (
1418 IN USB_KB_DEV *UsbKeyboardDevice,
1419 IN UINT8 KeyCode,
1420 OUT EFI_KEY_DATA *KeyData
1421 )
1422{
1423 EFI_KEY_DESCRIPTOR *KeyDescriptor;
1424 LIST_ENTRY *Link;
1425 LIST_ENTRY *NotifyList;
1426 KEYBOARD_CONSOLE_IN_EX_NOTIFY *CurrentNotify;
1427
1428 //
1429 // KeyCode must in the range of [0x4, 0x65] or [0xe0, 0xe7].
1430 //
1431 KeyDescriptor = GetKeyDescriptor (UsbKeyboardDevice, KeyCode);
1432 if (KeyDescriptor == NULL) {
1433 return EFI_DEVICE_ERROR;
1434 }
1435
1436 if (KeyDescriptor->Modifier == EFI_NS_KEY_MODIFIER) {
1437 //
1438 // If this is a dead key with EFI_NS_KEY_MODIFIER, then record it and return.
1439 //
1440 UsbKeyboardDevice->CurrentNsKey = FindUsbNsKey (UsbKeyboardDevice, KeyDescriptor);
1441 return EFI_NOT_READY;
1442 }
1443
1444 if (UsbKeyboardDevice->CurrentNsKey != NULL) {
1445 //
1446 // If this keystroke follows a non-spacing key, then find the descriptor for corresponding
1447 // physical key.
1448 //
1449 KeyDescriptor = FindPhysicalKey (UsbKeyboardDevice->CurrentNsKey, KeyDescriptor);
1450 UsbKeyboardDevice->CurrentNsKey = NULL;
1451 }
1452
1453 //
1454 // Make sure modifier of Key Descriptor is in the valid range according to UEFI spec.
1455 //
1456 if (KeyDescriptor->Modifier >= (sizeof (ModifierValueToEfiScanCodeConvertionTable) / sizeof (UINT8))) {
1457 return EFI_DEVICE_ERROR;
1458 }
1459
1460 KeyData->Key.ScanCode = ModifierValueToEfiScanCodeConvertionTable[KeyDescriptor->Modifier];
1461 KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;
1462
1463 if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_STANDARD_SHIFT) != 0) {
1464 if (UsbKeyboardDevice->ShiftOn) {
1465 KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode;
1466
1467 //
1468 // Need not return associated shift state if a class of printable characters that
1469 // are normally adjusted by shift modifiers. e.g. Shift Key + 'f' key = 'F'
1470 //
1471 if ((KeyDescriptor->Unicode != CHAR_NULL) && (KeyDescriptor->ShiftedUnicode != CHAR_NULL) &&
1472 (KeyDescriptor->Unicode != KeyDescriptor->ShiftedUnicode))
1473 {
1474 UsbKeyboardDevice->LeftShiftOn = FALSE;
1475 UsbKeyboardDevice->RightShiftOn = FALSE;
1476 }
1477
1478 if (UsbKeyboardDevice->AltGrOn) {
1479 KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedAltGrUnicode;
1480 }
1481 } else {
1482 //
1483 // Shift off
1484 //
1485 KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;
1486
1487 if (UsbKeyboardDevice->AltGrOn) {
1488 KeyData->Key.UnicodeChar = KeyDescriptor->AltGrUnicode;
1489 }
1490 }
1491 }
1492
1493 if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_CAPS_LOCK) != 0) {
1494 if (UsbKeyboardDevice->CapsOn) {
1495 if (KeyData->Key.UnicodeChar == KeyDescriptor->Unicode) {
1496 KeyData->Key.UnicodeChar = KeyDescriptor->ShiftedUnicode;
1497 } else if (KeyData->Key.UnicodeChar == KeyDescriptor->ShiftedUnicode) {
1498 KeyData->Key.UnicodeChar = KeyDescriptor->Unicode;
1499 }
1500 }
1501 }
1502
1503 if ((KeyDescriptor->AffectedAttribute & EFI_AFFECTED_BY_NUM_LOCK) != 0) {
1504 //
1505 // For key affected by NumLock, if NumLock is on and Shift is not pressed, then it means
1506 // normal key, instead of original control key. So the ScanCode should be cleaned.
1507 // Otherwise, it means control key, so preserve the EFI Scan Code and clear the unicode keycode.
1508 //
1509 if ((UsbKeyboardDevice->NumLockOn) && (!(UsbKeyboardDevice->ShiftOn))) {
1510 KeyData->Key.ScanCode = SCAN_NULL;
1511 } else {
1512 KeyData->Key.UnicodeChar = CHAR_NULL;
1513 }
1514 }
1515
1516 //
1517 // Translate Unicode 0x1B (ESC) to EFI Scan Code
1518 //
1519 if ((KeyData->Key.UnicodeChar == 0x1B) && (KeyData->Key.ScanCode == SCAN_NULL)) {
1520 KeyData->Key.ScanCode = SCAN_ESC;
1521 KeyData->Key.UnicodeChar = CHAR_NULL;
1522 }
1523
1524 //
1525 // Not valid for key without both unicode key code and EFI Scan Code.
1526 //
1527 if ((KeyData->Key.UnicodeChar == 0) && (KeyData->Key.ScanCode == SCAN_NULL)) {
1528 if (!UsbKeyboardDevice->IsSupportPartialKey) {
1529 return EFI_NOT_READY;
1530 }
1531 }
1532
1533 //
1534 // Save Shift/Toggle state
1535 //
1536 InitializeKeyState (UsbKeyboardDevice, &KeyData->KeyState);
1537
1538 //
1539 // Signal KeyNotify process event if this key pressed matches any key registered.
1540 //
1541 NotifyList = &UsbKeyboardDevice->NotifyList;
1542 for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {
1543 CurrentNotify = CR (Link, KEYBOARD_CONSOLE_IN_EX_NOTIFY, NotifyEntry, USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE);
1544 if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
1545 //
1546 // The key notification function needs to run at TPL_CALLBACK
1547 // while current TPL is TPL_NOTIFY. It will be invoked in
1548 // KeyNotifyProcessHandler() which runs at TPL_CALLBACK.
1549 //
1550 Enqueue (&UsbKeyboardDevice->EfiKeyQueueForNotify, KeyData, sizeof (*KeyData));
1551 gBS->SignalEvent (UsbKeyboardDevice->KeyNotifyProcessEvent);
1552 break;
1553 }
1554 }
1555
1556 return EFI_SUCCESS;
1557}
1558
1566VOID
1567InitQueue (
1568 IN OUT USB_SIMPLE_QUEUE *Queue,
1569 IN UINTN ItemSize
1570 )
1571{
1572 UINTN Index;
1573
1574 Queue->ItemSize = ItemSize;
1575 Queue->Head = 0;
1576 Queue->Tail = 0;
1577
1578 if (Queue->Buffer[0] != NULL) {
1579 FreePool (Queue->Buffer[0]);
1580 }
1581
1582 Queue->Buffer[0] = AllocatePool (sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]) * ItemSize);
1583 ASSERT (Queue->Buffer[0] != NULL);
1584
1585 for (Index = 1; Index < sizeof (Queue->Buffer) / sizeof (Queue->Buffer[0]); Index++) {
1586 Queue->Buffer[Index] = ((UINT8 *)Queue->Buffer[Index - 1]) + ItemSize;
1587 }
1588}
1589
1595VOID
1596DestroyQueue (
1597 IN OUT USB_SIMPLE_QUEUE *Queue
1598 )
1599{
1600 FreePool (Queue->Buffer[0]);
1601}
1602
1612BOOLEAN
1613IsQueueEmpty (
1614 IN USB_SIMPLE_QUEUE *Queue
1615 )
1616{
1617 //
1618 // Meet FIFO empty condition
1619 //
1620 return (BOOLEAN)(Queue->Head == Queue->Tail);
1621}
1622
1632BOOLEAN
1633IsQueueFull (
1634 IN USB_SIMPLE_QUEUE *Queue
1635 )
1636{
1637 return (BOOLEAN)(((Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1)) == Queue->Head);
1638}
1639
1647VOID
1648Enqueue (
1649 IN OUT USB_SIMPLE_QUEUE *Queue,
1650 IN VOID *Item,
1651 IN UINTN ItemSize
1652 )
1653{
1654 ASSERT (ItemSize == Queue->ItemSize);
1655 //
1656 // If keyboard buffer is full, throw the
1657 // first key out of the keyboard buffer.
1658 //
1659 if (IsQueueFull (Queue)) {
1660 Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1);
1661 }
1662
1663 CopyMem (Queue->Buffer[Queue->Tail], Item, ItemSize);
1664
1665 //
1666 // Adjust the tail pointer of the FIFO keyboard buffer.
1667 //
1668 Queue->Tail = (Queue->Tail + 1) % (MAX_KEY_ALLOWED + 1);
1669}
1670
1682EFI_STATUS
1683Dequeue (
1684 IN OUT USB_SIMPLE_QUEUE *Queue,
1685 OUT VOID *Item,
1686 IN UINTN ItemSize
1687 )
1688{
1689 ASSERT (Queue->ItemSize == ItemSize);
1690
1691 if (IsQueueEmpty (Queue)) {
1692 return EFI_DEVICE_ERROR;
1693 }
1694
1695 CopyMem (Item, Queue->Buffer[Queue->Head], ItemSize);
1696
1697 //
1698 // Adjust the head pointer of the FIFO keyboard buffer.
1699 //
1700 Queue->Head = (Queue->Head + 1) % (MAX_KEY_ALLOWED + 1);
1701
1702 return EFI_SUCCESS;
1703}
1704
1711VOID
1712SetKeyLED (
1713 IN USB_KB_DEV *UsbKeyboardDevice
1714 )
1715{
1716 LED_MAP Led;
1717 UINT8 ReportId;
1718
1719 //
1720 // Set each field in Led map.
1721 //
1722 Led.NumLock = (UINT8)((UsbKeyboardDevice->NumLockOn) ? 1 : 0);
1723 Led.CapsLock = (UINT8)((UsbKeyboardDevice->CapsOn) ? 1 : 0);
1724 Led.ScrollLock = (UINT8)((UsbKeyboardDevice->ScrollOn) ? 1 : 0);
1725 Led.Resrvd = 0;
1726
1727 ReportId = 0;
1728 //
1729 // Call Set_Report Request to lighten the LED.
1730 //
1731 UsbSetReportRequest (
1732 UsbKeyboardDevice->UsbIo,
1733 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
1734 ReportId,
1735 HID_OUTPUT_REPORT,
1736 1,
1737 (UINT8 *)&Led
1738 );
1739}
1740
1754VOID
1755EFIAPI
1756USBKeyboardRepeatHandler (
1757 IN EFI_EVENT Event,
1758 IN VOID *Context
1759 )
1760{
1761 USB_KB_DEV *UsbKeyboardDevice;
1762 USB_KEY UsbKey;
1763
1764 UsbKeyboardDevice = (USB_KB_DEV *)Context;
1765
1766 //
1767 // Do nothing when there is no repeat key.
1768 //
1769 if (UsbKeyboardDevice->RepeatKey != 0) {
1770 //
1771 // Inserts the repeat key into keyboard buffer,
1772 //
1773 UsbKey.KeyCode = UsbKeyboardDevice->RepeatKey;
1774 UsbKey.Down = TRUE;
1775 Enqueue (&UsbKeyboardDevice->UsbKeyQueue, &UsbKey, sizeof (UsbKey));
1776
1777 //
1778 // Set repeat rate for next repeat key generation.
1779 //
1780 gBS->SetTimer (
1781 UsbKeyboardDevice->RepeatTimer,
1782 TimerRelative,
1783 USBKBD_REPEAT_RATE
1784 );
1785 }
1786}
1787
1801VOID
1802EFIAPI
1803USBKeyboardRecoveryHandler (
1804 IN EFI_EVENT Event,
1805 IN VOID *Context
1806 )
1807{
1808 USB_KB_DEV *UsbKeyboardDevice;
1809 EFI_USB_IO_PROTOCOL *UsbIo;
1810 UINT8 PacketSize;
1811
1812 UsbKeyboardDevice = (USB_KB_DEV *)Context;
1813
1814 UsbIo = UsbKeyboardDevice->UsbIo;
1815
1816 PacketSize = (UINT8)(UsbKeyboardDevice->IntEndpointDescriptor.MaxPacketSize);
1817
1818 //
1819 // Re-submit Asynchronous Interrupt Transfer for recovery.
1820 //
1821 UsbIo->UsbAsyncInterruptTransfer (
1822 UsbIo,
1823 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
1824 TRUE,
1825 UsbKeyboardDevice->IntEndpointDescriptor.Interval,
1826 PacketSize,
1827 KeyboardHandler,
1828 UsbKeyboardDevice
1829 );
1830}
APPLE_HID_USB_KB_KP_USAGE
#define APPLE_HID_USB_KB_KP_USAGE(UsbHidUsageIdKbKp)
Definition AppleHid.h:21
APPLE_KEY_CODE
APPLE_HID_USAGE APPLE_KEY_CODE
Definition AppleHid.h:317
APPLE_MODIFIER_MAP
UINT16 APPLE_MODIFIER_MAP
Definition AppleHid.h:102
SUBCLASS_BOOT
#define SUBCLASS_BOOT
Definition BdsPlatform.h:124
PROTOCOL_KEYBOARD
#define PROTOCOL_KEYBOARD
Definition BdsPlatform.h:125
CLASS_HID
#define CLASS_HID
Definition BdsPlatform.h:123
IsKeyRegistered
BOOLEAN IsKeyRegistered(IN EFI_KEY_DATA *RegsiteredData, IN EFI_KEY_DATA *InputData)
Definition EfiKey.c:965
USBKBD_REPEAT_RATE
#define USBKBD_REPEAT_RATE
Definition EfiKey.h:42
MAX_KEY_ALLOWED
#define MAX_KEY_ALLOWED
Definition EfiKey.h:38
NUMBER_OF_VALID_NON_MODIFIER_USB_KEYCODE
#define NUMBER_OF_VALID_NON_MODIFIER_USB_KEYCODE
Definition EfiKey.h:184
NUMBER_OF_VALID_USB_KEYCODE
#define NUMBER_OF_VALID_USB_KEYCODE
Definition EfiKey.h:185
USBKBD_VALID_KEYCODE
#define USBKBD_VALID_KEYCODE(Key)
Definition EfiKey.h:189
USB_NS_KEY_SIGNATURE
#define USB_NS_KEY_SIGNATURE
Definition EfiKey.h:73
USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE
#define USB_KB_CONSOLE_IN_EX_NOTIFY_SIGNATURE
Definition EfiKey.h:64
BOOT_PROTOCOL
#define BOOT_PROTOCOL
Definition EfiKey.h:48
USBKBD_REPEAT_DELAY
#define USBKBD_REPEAT_DELAY
Definition EfiKey.h:41
USB_NS_KEY_FORM_FROM_LINK
#define USB_NS_KEY_FORM_FROM_LINK(a)
Definition EfiKey.h:91
USBKeyboardRepeatHandler
VOID EFIAPI USBKeyboardRepeatHandler(IN EFI_EVENT Event, IN VOID *Context)
Definition KeyBoard.c:1756
KeyboardHandler
EFI_STATUS EFIAPI KeyboardHandler(IN VOID *Data, IN UINTN DataLength, IN VOID *Context, IN UINT32 Result)
Definition KeyBoard.c:773
GetKeyDescriptor
EFI_KEY_DESCRIPTOR * GetKeyDescriptor(IN USB_KB_DEV *UsbKeyboardDevice, IN UINT8 KeyCode)
Definition KeyBoard.c:365
SetKeyLED
VOID SetKeyLED(IN USB_KB_DEV *UsbKeyboardDevice)
Definition KeyBoard.c:1712
FindPhysicalKey
EFI_KEY_DESCRIPTOR * FindPhysicalKey(IN USB_NS_KEY *UsbNsKey, IN EFI_KEY_DESCRIPTOR *KeyDescriptor)
Definition KeyBoard.c:442
USBKeyboardRecoveryHandler
VOID EFIAPI USBKeyboardRecoveryHandler(IN EFI_EVENT Event, IN VOID *Context)
Definition KeyBoard.c:1803
DestroyQueue
VOID DestroyQueue(IN OUT USB_SIMPLE_QUEUE *Queue)
Definition KeyBoard.c:1596
InitUSBKeyboard
EFI_STATUS InitUSBKeyboard(IN OUT USB_KB_DEV *UsbKeyboardDevice)
Definition KeyBoard.c:618
Dequeue
EFI_STATUS Dequeue(IN OUT USB_SIMPLE_QUEUE *Queue, OUT VOID *Item, IN UINTN ItemSize)
Definition KeyBoard.c:1683
ReleaseKeyboardLayoutResources
VOID ReleaseKeyboardLayoutResources(IN OUT USB_KB_DEV *UsbKeyboardDevice)
Definition KeyBoard.c:472
USBParseKey
EFI_STATUS USBParseKey(IN OUT USB_KB_DEV *UsbKeyboardDevice, OUT UINT8 *KeyCode)
Definition KeyBoard.c:1100
FindUsbNsKey
USB_NS_KEY * FindUsbNsKey(IN USB_KB_DEV *UsbKeyboardDevice, IN EFI_KEY_DESCRIPTOR *KeyDescriptor)
Definition KeyBoard.c:402
ModifierValueToEfiScanCodeConvertionTable
UINT8 ModifierValueToEfiScanCodeConvertionTable[]
Definition KeyBoard.c:266
mUsbKeyboardLayoutBin
USB_KEYBOARD_LAYOUT_PACK_BIN mUsbKeyboardLayoutBin
Definition KeyBoard.c:18
InitQueue
VOID InitQueue(IN OUT USB_SIMPLE_QUEUE *Queue, IN UINTN ItemSize)
Definition KeyBoard.c:1567
Enqueue
VOID Enqueue(IN OUT USB_SIMPLE_QUEUE *Queue, IN VOID *Item, IN UINTN ItemSize)
Definition KeyBoard.c:1648
InitializeKeyState
VOID InitializeKeyState(IN USB_KB_DEV *UsbKeyboardDevice, OUT EFI_KEY_STATE *KeyState)
Definition KeyBoard.c:1335
IsQueueFull
BOOLEAN IsQueueFull(IN USB_SIMPLE_QUEUE *Queue)
Definition KeyBoard.c:1633
IsUSBKeyboard
BOOLEAN IsUSBKeyboard(IN EFI_USB_IO_PROTOCOL *UsbIo)
Definition KeyBoard.c:324
EfiKeyToUsbKeyCodeConvertionTable
UINT8 EfiKeyToUsbKeyCodeConvertionTable[]
Definition KeyBoard.c:154
UsbKeyCodeToEfiInputKey
EFI_STATUS UsbKeyCodeToEfiInputKey(IN USB_KB_DEV *UsbKeyboardDevice, IN UINT8 KeyCode, OUT EFI_KEY_DATA *KeyData)
Definition KeyBoard.c:1417
InitKeyboardLayout
EFI_STATUS InitKeyboardLayout(OUT USB_KB_DEV *UsbKeyboardDevice)
Definition KeyBoard.c:515
IsQueueEmpty
BOOLEAN IsQueueEmpty(IN USB_SIMPLE_QUEUE *Queue)
Definition KeyBoard.c:1613
USB_KEYBOARD_KEY_COUNT
#define USB_KEYBOARD_KEY_COUNT
Definition KeyBoard.h:14
gBS
EFI_BOOT_SERVICES * gBS
Definition OcBootServicesTableLib.c:29
ResetWarm
VOID EFIAPI ResetWarm(VOID)
Definition OcResetSystemLib.c:38
CopyMem
VOID *EFIAPI CopyMem(OUT VOID *DestinationBuffer, IN CONST VOID *SourceBuffer, IN UINTN Length)
Definition UserBaseMemoryLib.c:75
ZeroMem
VOID *EFIAPI ZeroMem(OUT VOID *Buffer, IN UINTN Length)
Definition UserBaseMemoryLib.c:102
ASSERT
#define ASSERT(x)
Definition coder.h:55
_KEYBOARD_CONSOLE_IN_EX_NOTIFY
Definition EfiKey.h:66
_KEYBOARD_CONSOLE_IN_EX_NOTIFY::KeyData
EFI_KEY_DATA KeyData
Definition EfiKey.h:68
APPLE_KEY_MAP_DATABASE_PROTOCOL::SetKeyStrokeBufferKeys
KEY_MAP_SET_KEY_STROKES_KEYS SetKeyStrokeBufferKeys
Definition AppleKeyMapDatabase.h:103
LED_MAP
Definition EfiKey.h:191
LED_MAP::NumLock
UINT8 NumLock
Definition EfiKey.h:192
LED_MAP::ScrollLock
UINT8 ScrollLock
Definition EfiKey.h:194
LED_MAP::Resrvd
UINT8 Resrvd
Definition EfiKey.h:195
LED_MAP::CapsLock
UINT8 CapsLock
Definition EfiKey.h:193
USB_KB_DEV
Definition EfiKey.h:96
USB_KB_DEV::LastKeyCodeArray
UINT8 LastKeyCodeArray[8]
Definition EfiKey.h:117
USB_KB_DEV::IntEndpointDescriptor
EFI_USB_ENDPOINT_DESCRIPTOR IntEndpointDescriptor
Definition EfiKey.h:106
USB_KB_DEV::RepeatKey
UINT8 RepeatKey
Definition EfiKey.h:122
USB_KB_DEV::UsbKeyQueue
USB_SIMPLE_QUEUE UsbKeyQueue
Definition EfiKey.h:108
USB_KB_DEV::UsbIo
EFI_USB_IO_PROTOCOL * UsbIo
Definition EfiKey.h:103
USB_KB_DEV::KeyMapDbIndex
UINTN KeyMapDbIndex
Definition EfiKey.h:156
USB_KB_DEV::RepeatTimer
EFI_EVENT RepeatTimer
Definition EfiKey.h:123
USB_KB_DEV::KeyMapDb
APPLE_KEY_MAP_DATABASE_PROTOCOL * KeyMapDb
Definition EfiKey.h:155
USB_KB_DEV::DevicePath
EFI_DEVICE_PATH_PROTOCOL * DevicePath
Definition EfiKey.h:99
USB_KB_DEV::DelayedRecoveryEvent
EFI_EVENT DelayedRecoveryEvent
Definition EfiKey.h:100
USB_KEYBOARD_LAYOUT_PACK_BIN
Definition KeyBoard.h:20
USB_KEYBOARD_LAYOUT_PACK_BIN::KeyDescriptor
EFI_KEY_DESCRIPTOR KeyDescriptor[USB_KEYBOARD_KEY_COUNT]
Definition KeyBoard.h:39
USB_KEYBOARD_LAYOUT_PACK_BIN::DescriptorCount
UINT8 DescriptorCount
Definition KeyBoard.h:38
USB_KEY
Definition EfiKey.h:51
USB_KEY::Down
BOOLEAN Down
Definition EfiKey.h:52
USB_KEY::KeyCode
UINT8 KeyCode
Definition EfiKey.h:53
USB_NS_KEY
Definition EfiKey.h:75
USB_NS_KEY::KeyCount
UINTN KeyCount
Definition EfiKey.h:82
USB_NS_KEY::Link
LIST_ENTRY Link
Definition EfiKey.h:77
USB_NS_KEY::Signature
UINTN Signature
Definition EfiKey.h:76
USB_NS_KEY::NsKey
EFI_KEY_DESCRIPTOR * NsKey
Definition EfiKey.h:88
USB_SIMPLE_QUEUE
Definition EfiKey.h:56