To fix
[mirror_edk2.git] / EdkModulePkg / Bus / Usb / UsbKb / Dxe / keyboard.c
1 /*++
2
3 Copyright (c) 2006, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 Keyboard.c
15
16 Abstract:
17
18 Helper functions for USB Keyboard Driver
19
20 Revision History
21
22 --*/
23
24 #include "keyboard.h"
25
26 //
27 // USB Key Code to Efi key mapping table
28 // Format:<efi scan code>, <unicode without shift>, <unicode with shift>
29 //
30 STATIC
31 UINT8 KeyConvertionTable[USB_KEYCODE_MAX_MAKE][3] = {
32 { SCAN_NULL, 'a', 'A' }, // 0x04
33 { SCAN_NULL, 'b', 'B' }, // 0x05
34 { SCAN_NULL, 'c', 'C' }, // 0x06
35 { SCAN_NULL, 'd', 'D' }, // 0x07
36 { SCAN_NULL, 'e', 'E' }, // 0x08
37 { SCAN_NULL, 'f', 'F' }, // 0x09
38 { SCAN_NULL, 'g', 'G' }, // 0x0A
39 { SCAN_NULL, 'h', 'H' }, // 0x0B
40 { SCAN_NULL, 'i', 'I' }, // 0x0C
41 { SCAN_NULL, 'j', 'J' }, // 0x0D
42 { SCAN_NULL, 'k', 'K' }, // 0x0E
43 { SCAN_NULL, 'l', 'L' }, // 0x0F
44 { SCAN_NULL, 'm', 'M' }, // 0x10
45 { SCAN_NULL, 'n', 'N' }, // 0x11
46 { SCAN_NULL, 'o', 'O' }, // 0x12
47 { SCAN_NULL, 'p', 'P' }, // 0x13
48 { SCAN_NULL, 'q', 'Q' }, // 0x14
49 { SCAN_NULL, 'r', 'R' }, // 0x15
50 { SCAN_NULL, 's', 'S' }, // 0x16
51 { SCAN_NULL, 't', 'T' }, // 0x17
52 { SCAN_NULL, 'u', 'U' }, // 0x18
53 { SCAN_NULL, 'v', 'V' }, // 0x19
54 { SCAN_NULL, 'w', 'W' }, // 0x1A
55 { SCAN_NULL, 'x', 'X' }, // 0x1B
56 { SCAN_NULL, 'y', 'Y' }, // 0x1C
57 { SCAN_NULL, 'z', 'Z' }, // 0x1D
58 { SCAN_NULL, '1', '!' }, // 0x1E
59 { SCAN_NULL, '2', '@' }, // 0x1F
60 { SCAN_NULL, '3', '#' }, // 0x20
61 { SCAN_NULL, '4', '$' }, // 0x21
62 { SCAN_NULL, '5', '%' }, // 0x22
63 { SCAN_NULL, '6', '^' }, // 0x23
64 { SCAN_NULL, '7', '&' }, // 0x24
65 { SCAN_NULL, '8', '*' }, // 0x25
66 { SCAN_NULL, '9', '(' }, // 0x26
67 { SCAN_NULL, '0', ')' }, // 0x27
68 { SCAN_NULL, 0x0d, 0x0d }, // 0x28 Enter
69 { SCAN_ESC, 0x00, 0x00 }, // 0x29 Esc
70 { SCAN_NULL, 0x08, 0x08 }, // 0x2A Backspace
71 { SCAN_NULL, 0x09, 0x09 }, // 0x2B Tab
72 { SCAN_NULL, ' ', ' ' }, // 0x2C Spacebar
73 { SCAN_NULL, '-', '_' }, // 0x2D
74 { SCAN_NULL, '=', '+' }, // 0x2E
75 { SCAN_NULL, '[', '{' }, // 0x2F
76 { SCAN_NULL, ']', '}' }, // 0x30
77 { SCAN_NULL, '\\', '|' }, // 0x31
78 { SCAN_NULL, '\\', '|' }, // 0x32 Keyboard US \ and |
79 { SCAN_NULL, ';', ':' }, // 0x33
80 { SCAN_NULL, '\'', '"' }, // 0x34
81 { SCAN_NULL, '`', '~' }, // 0x35 Keyboard Grave Accent and Tlide
82 { SCAN_NULL, ',', '<' }, // 0x36
83 { SCAN_NULL, '.', '>' }, // 0x37
84 { SCAN_NULL, '/', '?' }, // 0x38
85 { SCAN_NULL, 0x00, 0x00 }, // 0x39 CapsLock
86 { SCAN_F1, 0x00, 0x00 }, // 0x3A
87 { SCAN_F2, 0x00, 0x00 }, // 0x3B
88 { SCAN_F3, 0x00, 0x00 }, // 0x3C
89 { SCAN_F4, 0x00, 0x00 }, // 0x3D
90 { SCAN_F5, 0x00, 0x00 }, // 0x3E
91 { SCAN_F6, 0x00, 0x00 }, // 0x3F
92 { SCAN_F7, 0x00, 0x00 }, // 0x40
93 { SCAN_F8, 0x00, 0x00 }, // 0x41
94 { SCAN_F9, 0x00, 0x00 }, // 0x42
95 { SCAN_F10, 0x00, 0x00 }, // 0x43
96 { SCAN_F11, 0x00, 0x00 }, // 0x44 F11
97 { SCAN_F12, 0x00, 0x00 }, // 0x45 F12
98 { SCAN_NULL, 0x00, 0x00 }, // 0x46 PrintScreen
99 { SCAN_NULL, 0x00, 0x00 }, // 0x47 Scroll Lock
100 { SCAN_NULL, 0x00, 0x00 }, // 0x48 Pause
101 { SCAN_INSERT, 0x00, 0x00 }, // 0x49
102 { SCAN_HOME, 0x00, 0x00 }, // 0x4A
103 { SCAN_PAGE_UP, 0x00, 0x00 }, // 0x4B
104 { SCAN_DELETE, 0x00, 0x00 }, // 0x4C
105 { SCAN_END, 0x00, 0x00 }, // 0x4D
106 { SCAN_PAGE_DOWN, 0x00, 0x00 }, // 0x4E
107 { SCAN_RIGHT, 0x00, 0x00 }, // 0x4F
108 { SCAN_LEFT, 0x00, 0x00 }, // 0x50
109 { SCAN_DOWN, 0x00, 0x00 }, // 0x51
110 { SCAN_UP, 0x00, 0x00 }, // 0x52
111 { SCAN_NULL, 0x00, 0x00 }, // 0x53 NumLock
112 { SCAN_NULL, '/', '/' }, // 0x54
113 { SCAN_NULL, '*', '*' }, // 0x55
114 { SCAN_NULL, '-', '-' }, // 0x56
115 { SCAN_NULL, '+', '+' }, // 0x57
116 { SCAN_NULL, 0x0d, 0x0d }, // 0x58
117 { SCAN_END, '1', '1' }, // 0x59
118 { SCAN_DOWN, '2', '2' }, // 0x5A
119 { SCAN_PAGE_DOWN, '3', '3' }, // 0x5B
120 { SCAN_LEFT, '4', '4' }, // 0x5C
121 { SCAN_NULL, '5', '5' }, // 0x5D
122 { SCAN_RIGHT, '6', '6' }, // 0x5E
123 { SCAN_HOME, '7', '7' }, // 0x5F
124 { SCAN_UP, '8', '8' }, // 0x60
125 { SCAN_PAGE_UP, '9', '9' }, // 0x61
126 { SCAN_INSERT, '0', '0' }, // 0x62
127 { SCAN_DELETE, '.', '.' }, // 0x63
128 { SCAN_NULL, '\\', '|' }, // 0x64 Keyboard Non-US \ and |
129 { SCAN_NULL, 0x00, 0x00 }, // 0x65 Keyboard Application
130 { SCAN_NULL, 0x00, 0x00 }, // 0x66 Keyboard Power
131 { SCAN_NULL, '=' , '=' } // 0x67 Keypad =
132 };
133
134 STATIC KB_MODIFIER KB_Mod[8] = {
135 { MOD_CONTROL_L, 0xe0 }, // 11100000
136 { MOD_CONTROL_R, 0xe4 }, // 11100100
137 { MOD_SHIFT_L, 0xe1 }, // 11100001
138 { MOD_SHIFT_R, 0xe5 }, // 11100101
139 { MOD_ALT_L, 0xe2 }, // 11100010
140 { MOD_ALT_R, 0xe6 }, // 11100110
141 { MOD_WIN_L, 0xe3 }, // 11100011
142 { MOD_WIN_R, 0xe7 } // 11100111
143 };
144
145
146 BOOLEAN
147 IsUSBKeyboard (
148 IN EFI_USB_IO_PROTOCOL *UsbIo
149 )
150 /*++
151
152 Routine Description:
153 Uses USB I/O to check whether the device is a USB Keyboard device.
154
155 Arguments:
156 UsbIo: Points to a USB I/O protocol instance.
157
158 Returns:
159
160 --*/
161 {
162 EFI_STATUS Status;
163 EFI_USB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
164
165 //
166 // Get the Default interface descriptor, currently we
167 // assume it is interface 1
168 //
169 Status = UsbIo->UsbGetInterfaceDescriptor (
170 UsbIo,
171 &InterfaceDescriptor
172 );
173
174 if (EFI_ERROR (Status)) {
175 return FALSE;
176 }
177
178 if (InterfaceDescriptor.InterfaceClass == CLASS_HID &&
179 InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT &&
180 InterfaceDescriptor.InterfaceProtocol == PROTOCOL_KEYBOARD
181 ) {
182
183 return TRUE;
184 }
185
186 return FALSE;
187 }
188
189
190 EFI_STATUS
191 InitUSBKeyboard (
192 IN USB_KB_DEV *UsbKeyboardDevice
193 )
194 /*++
195
196 Routine Description:
197 Initialize USB Keyboard device and all private data structures.
198
199 Arguments:
200 UsbKeyboardDevice The USB_KB_DEV instance.
201
202 Returns:
203 EFI_SUCCESS - Success
204 EFI_DEVICE_ERROR - Hardware Error
205 --*/
206 {
207 UINT8 ConfigValue;
208 UINT8 Protocol;
209 UINT8 ReportId;
210 UINT8 Duration;
211 EFI_STATUS Status;
212 UINT32 TransferResult;
213
214 KbdReportStatusCode (
215 UsbKeyboardDevice->DevicePath,
216 EFI_PROGRESS_CODE,
217 (EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST)
218 );
219
220 InitUSBKeyBuffer (&(UsbKeyboardDevice->KeyboardBuffer));
221
222 //
223 // default configurations
224 //
225 ConfigValue = 0x01;
226
227 //
228 // Uses default configuration to configure the USB Keyboard device.
229 //
230 Status = UsbSetDeviceConfiguration (
231 UsbKeyboardDevice->UsbIo,
232 (UINT16) ConfigValue,
233 &TransferResult
234 );
235 if (EFI_ERROR (Status)) {
236 //
237 // If configuration could not be set here, it means
238 // the keyboard interface has some errors and could
239 // not be initialized
240 //
241 KbdReportStatusCode (
242 UsbKeyboardDevice->DevicePath,
243 EFI_ERROR_CODE | EFI_ERROR_MINOR,
244 (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INTERFACE_ERROR)
245 );
246
247 return EFI_DEVICE_ERROR;
248 }
249
250 UsbGetProtocolRequest (
251 UsbKeyboardDevice->UsbIo,
252 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
253 &Protocol
254 );
255 //
256 // Sets boot protocol for the USB Keyboard.
257 // This driver only supports boot protocol.
258 // !!BugBug: How about the device that does not support boot protocol?
259 //
260 if (Protocol != BOOT_PROTOCOL) {
261 UsbSetProtocolRequest (
262 UsbKeyboardDevice->UsbIo,
263 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
264 BOOT_PROTOCOL
265 );
266 }
267 //
268 // the duration is indefinite, so the endpoint will inhibit reporting forever,
269 // and only reporting when a change is detected in the report data.
270 //
271
272 //
273 // idle value for all report ID
274 //
275 ReportId = 0;
276 //
277 // idle forever until there is a key pressed and released.
278 //
279 Duration = 0;
280 UsbSetIdleRequest (
281 UsbKeyboardDevice->UsbIo,
282 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
283 ReportId,
284 Duration
285 );
286
287 UsbKeyboardDevice->CtrlOn = 0;
288 UsbKeyboardDevice->AltOn = 0;
289 UsbKeyboardDevice->ShiftOn = 0;
290 UsbKeyboardDevice->NumLockOn = 0;
291 UsbKeyboardDevice->CapsOn = 0;
292 UsbKeyboardDevice->ScrollOn = 0;
293 ZeroMem (UsbKeyboardDevice->LastKeyCodeArray, sizeof (UINT8) * 8);
294
295 //
296 // Set a timer for repeat keys' generation.
297 //
298 if (UsbKeyboardDevice->RepeatTimer) {
299 gBS->CloseEvent (UsbKeyboardDevice->RepeatTimer);
300 UsbKeyboardDevice->RepeatTimer = 0;
301 }
302
303 Status = gBS->CreateEvent (
304 EFI_EVENT_TIMER | EFI_EVENT_NOTIFY_SIGNAL,
305 EFI_TPL_NOTIFY,
306 USBKeyboardRepeatHandler,
307 UsbKeyboardDevice,
308 &UsbKeyboardDevice->RepeatTimer
309 );
310
311 if (UsbKeyboardDevice->DelayedRecoveryEvent) {
312 gBS->CloseEvent (UsbKeyboardDevice->DelayedRecoveryEvent);
313 UsbKeyboardDevice->DelayedRecoveryEvent = 0;
314 }
315
316 Status = gBS->CreateEvent (
317 EFI_EVENT_TIMER | EFI_EVENT_NOTIFY_SIGNAL,
318 EFI_TPL_NOTIFY,
319 USBKeyboardRecoveryHandler,
320 UsbKeyboardDevice,
321 &UsbKeyboardDevice->DelayedRecoveryEvent
322 );
323
324 return EFI_SUCCESS;
325 }
326
327 EFI_STATUS
328 EFIAPI
329 KeyboardHandler (
330 IN VOID *Data,
331 IN UINTN DataLength,
332 IN VOID *Context,
333 IN UINT32 Result
334 )
335 /*++
336
337 Routine Description:
338 Handler function for USB Keyboard's asynchronous interrupt transfer.
339
340 Arguments:
341 Data A pointer to a buffer that is filled with key data which is
342 retrieved via asynchronous interrupt transfer.
343 DataLength Indicates the size of the data buffer.
344 Context Pointing to USB_KB_DEV instance.
345 Result Indicates the result of the asynchronous interrupt transfer.
346
347 Returns:
348 EFI_SUCCESS - Success
349 EFI_DEVICE_ERROR - Hardware Error
350 --*/
351 {
352 USB_KB_DEV *UsbKeyboardDevice;
353 EFI_USB_IO_PROTOCOL *UsbIo;
354 UINT8 *CurKeyCodeBuffer;
355 UINT8 *OldKeyCodeBuffer;
356 UINT8 CurModifierMap;
357 UINT8 OldModifierMap;
358 UINT8 Index;
359 UINT8 Index2;
360 BOOLEAN Down;
361 BOOLEAN KeyRelease;
362 BOOLEAN KeyPress;
363 UINT8 SavedTail;
364 USB_KEY UsbKey;
365 UINT8 NewRepeatKey;
366 UINT32 UsbStatus;
367
368 ASSERT (Context);
369
370 NewRepeatKey = 0;
371 UsbKeyboardDevice = (USB_KB_DEV *) Context;
372 UsbIo = UsbKeyboardDevice->UsbIo;
373
374 //
375 // Analyzes the Result and performs corresponding action.
376 //
377 if (Result != EFI_USB_NOERROR) {
378 //
379 // Some errors happen during the process
380 //
381 KbdReportStatusCode (
382 UsbKeyboardDevice->DevicePath,
383 EFI_ERROR_CODE | EFI_ERROR_MINOR,
384 (EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_INPUT_ERROR)
385 );
386
387 //
388 // stop the repeat key generation if any
389 //
390 UsbKeyboardDevice->RepeatKey = 0;
391
392 gBS->SetTimer (
393 UsbKeyboardDevice->RepeatTimer,
394 TimerCancel,
395 USBKBD_REPEAT_RATE
396 );
397
398 if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
399 UsbClearEndpointHalt (
400 UsbIo,
401 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
402 &UsbStatus
403 );
404 }
405
406 //
407 // Delete & Submit this interrupt again
408 //
409
410 UsbIo->UsbAsyncInterruptTransfer (
411 UsbIo,
412 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
413 FALSE,
414 0,
415 0,
416 NULL,
417 NULL
418 );
419
420 gBS->SetTimer (
421 UsbKeyboardDevice->DelayedRecoveryEvent,
422 TimerRelative,
423 EFI_USB_INTERRUPT_DELAY
424 );
425
426 return EFI_DEVICE_ERROR;
427 }
428
429 if (DataLength == 0 || Data == NULL) {
430 return EFI_SUCCESS;
431 }
432
433 CurKeyCodeBuffer = (UINT8 *) Data;
434 OldKeyCodeBuffer = UsbKeyboardDevice->LastKeyCodeArray;
435
436 //
437 // checks for new key stroke.
438 // if no new key got, return immediately.
439 //
440 for (Index = 0; Index < 8; Index++) {
441 if (OldKeyCodeBuffer[Index] != CurKeyCodeBuffer[Index]) {
442 break;
443 }
444 }
445
446 if (Index == 8) {
447 return EFI_SUCCESS;
448 }
449
450 //
451 // Parse the modifier key
452 //
453 CurModifierMap = CurKeyCodeBuffer[0];
454 OldModifierMap = OldKeyCodeBuffer[0];
455
456 //
457 // handle modifier key's pressing or releasing situation.
458 //
459 for (Index = 0; Index < 8; Index++) {
460
461 if ((CurModifierMap & KB_Mod[Index].Mask) != (OldModifierMap & KB_Mod[Index].Mask)) {
462 //
463 // if current modifier key is up, then
464 // CurModifierMap & KB_Mod[Index].Mask = 0;
465 // otherwize it is a non-zero value.
466 // Inserts the pressed modifier key into key buffer.
467 //
468 Down = (UINT8) (CurModifierMap & KB_Mod[Index].Mask);
469 InsertKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), KB_Mod[Index].Key, Down);
470 }
471 }
472
473 //
474 // handle normal key's releasing situation
475 //
476 KeyRelease = FALSE;
477 for (Index = 2; Index < 8; Index++) {
478
479 if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index])) {
480 continue;
481 }
482
483 KeyRelease = TRUE;
484 for (Index2 = 2; Index2 < 8; Index2++) {
485
486 if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index2])) {
487 continue;
488 }
489
490 if (OldKeyCodeBuffer[Index] == CurKeyCodeBuffer[Index2]) {
491 KeyRelease = FALSE;
492 break;
493 }
494 }
495
496 if (KeyRelease) {
497 InsertKeyCode (
498 &(UsbKeyboardDevice->KeyboardBuffer),
499 OldKeyCodeBuffer[Index],
500 0
501 );
502 //
503 // the original reapeat key is released.
504 //
505 if (OldKeyCodeBuffer[Index] == UsbKeyboardDevice->RepeatKey) {
506 UsbKeyboardDevice->RepeatKey = 0;
507 }
508 }
509 }
510
511 //
512 // original repeat key is released, cancel the repeat timer
513 //
514 if (UsbKeyboardDevice->RepeatKey == 0) {
515 gBS->SetTimer (
516 UsbKeyboardDevice->RepeatTimer,
517 TimerCancel,
518 USBKBD_REPEAT_RATE
519 );
520 }
521
522 //
523 // handle normal key's pressing situation
524 //
525 KeyPress = FALSE;
526 for (Index = 2; Index < 8; Index++) {
527
528 if (!USBKBD_VALID_KEYCODE (CurKeyCodeBuffer[Index])) {
529 continue;
530 }
531
532 KeyPress = TRUE;
533 for (Index2 = 2; Index2 < 8; Index2++) {
534
535 if (!USBKBD_VALID_KEYCODE (OldKeyCodeBuffer[Index2])) {
536 continue;
537 }
538
539 if (CurKeyCodeBuffer[Index] == OldKeyCodeBuffer[Index2]) {
540 KeyPress = FALSE;
541 break;
542 }
543 }
544
545 if (KeyPress) {
546 InsertKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), CurKeyCodeBuffer[Index], 1);
547 //
548 // NumLock pressed or CapsLock pressed
549 //
550 if (CurKeyCodeBuffer[Index] == 0x53 || CurKeyCodeBuffer[Index] == 0x39) {
551 UsbKeyboardDevice->RepeatKey = 0;
552 } else {
553 NewRepeatKey = CurKeyCodeBuffer[Index];
554 //
555 // do not repeat the original repeated key
556 //
557 UsbKeyboardDevice->RepeatKey = 0;
558 }
559 }
560 }
561
562 //
563 // Update LastKeycodeArray[] buffer in the
564 // Usb Keyboard Device data structure.
565 //
566 for (Index = 0; Index < 8; Index++) {
567 UsbKeyboardDevice->LastKeyCodeArray[Index] = CurKeyCodeBuffer[Index];
568 }
569
570 //
571 // pre-process KeyboardBuffer, pop out the ctrl,alt,del key in sequence
572 // and judge whether it will invoke reset event.
573 //
574 SavedTail = UsbKeyboardDevice->KeyboardBuffer.bTail;
575 Index = UsbKeyboardDevice->KeyboardBuffer.bHead;
576 while (Index != SavedTail) {
577 RemoveKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), &UsbKey);
578
579 switch (UsbKey.KeyCode) {
580
581 case 0xe0:
582 case 0xe4:
583 if (UsbKey.Down) {
584 UsbKeyboardDevice->CtrlOn = 1;
585 } else {
586 UsbKeyboardDevice->CtrlOn = 0;
587 }
588 break;
589
590 case 0xe2:
591 case 0xe6:
592 if (UsbKey.Down) {
593 UsbKeyboardDevice->AltOn = 1;
594 } else {
595 UsbKeyboardDevice->AltOn = 0;
596 }
597 break;
598
599 //
600 // Del Key Code
601 //
602 case 0x4c:
603 case 0x63:
604 if (UsbKey.Down) {
605 if (UsbKeyboardDevice->CtrlOn && UsbKeyboardDevice->AltOn) {
606 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
607 }
608 }
609 break;
610
611 default:
612 break;
613 }
614
615 //
616 // insert the key back to the buffer.
617 // so the key sequence will not be destroyed.
618 //
619 InsertKeyCode (
620 &(UsbKeyboardDevice->KeyboardBuffer),
621 UsbKey.KeyCode,
622 UsbKey.Down
623 );
624 Index = UsbKeyboardDevice->KeyboardBuffer.bHead;
625
626 }
627 //
628 // If have new key pressed, update the RepeatKey value, and set the
629 // timer to repeate delay timer
630 //
631 if (NewRepeatKey != 0) {
632 //
633 // sets trigger time to "Repeat Delay Time",
634 // to trigger the repeat timer when the key is hold long
635 // enough time.
636 //
637 gBS->SetTimer (
638 UsbKeyboardDevice->RepeatTimer,
639 TimerRelative,
640 USBKBD_REPEAT_DELAY
641 );
642 UsbKeyboardDevice->RepeatKey = NewRepeatKey;
643 }
644
645 return EFI_SUCCESS;
646 }
647
648 EFI_STATUS
649 USBParseKey (
650 IN OUT USB_KB_DEV *UsbKeyboardDevice,
651 OUT UINT8 *KeyChar
652 )
653 /*++
654
655 Routine Description:
656 Retrieves a key character after parsing the raw data in keyboard buffer.
657
658 Arguments:
659 UsbKeyboardDevice The USB_KB_DEV instance.
660 KeyChar Points to the Key character after key parsing.
661
662 Returns:
663 EFI_SUCCESS - Success
664 EFI_NOT_READY - Device is not ready
665 --*/
666 {
667 USB_KEY UsbKey;
668
669 *KeyChar = 0;
670
671 while (!IsUSBKeyboardBufferEmpty (&UsbKeyboardDevice->KeyboardBuffer)) {
672 //
673 // pops one raw data off.
674 //
675 RemoveKeyCode (&(UsbKeyboardDevice->KeyboardBuffer), &UsbKey);
676
677 if (!UsbKey.Down) {
678 switch (UsbKey.KeyCode) {
679
680 case 0xe0:
681 case 0xe4:
682 UsbKeyboardDevice->CtrlOn = 0;
683 break;
684
685 case 0xe1:
686 case 0xe5:
687 UsbKeyboardDevice->ShiftOn = 0;
688 break;
689
690 case 0xe2:
691 case 0xe6:
692 UsbKeyboardDevice->AltOn = 0;
693 break;
694
695 default:
696 break;
697 }
698
699 continue;
700 }
701
702 //
703 // Analyzes key pressing situation
704 //
705 switch (UsbKey.KeyCode) {
706
707 case 0xe0:
708 case 0xe4:
709 UsbKeyboardDevice->CtrlOn = 1;
710 continue;
711 break;
712
713 case 0xe1:
714 case 0xe5:
715 UsbKeyboardDevice->ShiftOn = 1;
716 continue;
717 break;
718
719 case 0xe2:
720 case 0xe6:
721 UsbKeyboardDevice->AltOn = 1;
722 continue;
723 break;
724
725 case 0xe3:
726 case 0xe7:
727 continue;
728 break;
729
730 case 0x53:
731 UsbKeyboardDevice->NumLockOn ^= 1;
732 SetKeyLED (UsbKeyboardDevice);
733 continue;
734 break;
735
736 case 0x39:
737 UsbKeyboardDevice->CapsOn ^= 1;
738 SetKeyLED (UsbKeyboardDevice);
739 continue;
740 break;
741
742 //
743 // F11,F12,PrintScreen,ScrollLock,Pause,Application,Power
744 // keys are not valid EFI key
745 //
746 case 0x44:
747 //
748 // fall through
749 //
750 case 0x45:
751 //
752 // fall through
753 //
754 case 0x46:
755 //
756 // fall through
757 //
758 case 0x47:
759 //
760 // Turn on the ScrollLock light on KB
761 //
762 UsbKeyboardDevice->ScrollOn ^= 1;
763 SetKeyLED (UsbKeyboardDevice);
764 continue;
765 break;
766 case 0x48:
767 //
768 // fall through
769 //
770 case 0x65:
771 case 0x66:
772 continue;
773 break;
774
775 default:
776 break;
777 }
778
779 //
780 // When encountered Del Key...
781 //
782 if (UsbKey.KeyCode == 0x4c || UsbKey.KeyCode == 0x63) {
783 if (UsbKeyboardDevice->CtrlOn && UsbKeyboardDevice->AltOn) {
784 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
785 }
786 }
787
788 *KeyChar = UsbKey.KeyCode;
789 return EFI_SUCCESS;
790 }
791
792 return EFI_NOT_READY;
793
794 }
795
796
797 EFI_STATUS
798 USBKeyCodeToEFIScanCode (
799 IN USB_KB_DEV *UsbKeyboardDevice,
800 IN UINT8 KeyChar,
801 OUT EFI_INPUT_KEY *Key
802 )
803 /*++
804
805 Routine Description:
806 Converts USB Keyboard code to EFI Scan Code.
807
808 Arguments:
809 UsbKeyboardDevice The USB_KB_DEV instance.
810 KeyChar Indicates the key code that will be interpreted.
811 Key A pointer to a buffer that is filled in with
812 the keystroke information for the key that
813 was pressed.
814 Returns:
815 EFI_NOT_READY - Device is not ready
816 EFI_SUCCESS - Success
817 --*/
818 {
819 UINT8 Index;
820
821 if (!USBKBD_VALID_KEYCODE (KeyChar)) {
822 return EFI_NOT_READY;
823 }
824
825 //
826 // valid USB Key Code starts from 4
827 //
828 Index = (UINT8) (KeyChar - 4);
829
830 if (Index >= USB_KEYCODE_MAX_MAKE) {
831 return EFI_NOT_READY;
832 }
833
834 Key->ScanCode = KeyConvertionTable[Index][0];
835
836 if (UsbKeyboardDevice->ShiftOn) {
837
838 Key->UnicodeChar = KeyConvertionTable[Index][2];
839
840 } else {
841
842 Key->UnicodeChar = KeyConvertionTable[Index][1];
843 }
844
845 if (UsbKeyboardDevice->CapsOn) {
846
847 if (Key->UnicodeChar >= 'a' && Key->UnicodeChar <= 'z') {
848
849 Key->UnicodeChar = KeyConvertionTable[Index][2];
850
851 } else if (Key->UnicodeChar >= 'A' && Key->UnicodeChar <= 'Z') {
852
853 Key->UnicodeChar = KeyConvertionTable[Index][1];
854
855 }
856 }
857
858 if (KeyChar >= 0x59 && KeyChar <= 0x63) {
859
860 if (UsbKeyboardDevice->NumLockOn && !UsbKeyboardDevice->ShiftOn) {
861
862 Key->ScanCode = SCAN_NULL;
863
864 } else {
865
866 Key->UnicodeChar = 0x00;
867 }
868 }
869
870 if (Key->UnicodeChar == 0 && Key->ScanCode == SCAN_NULL) {
871 return EFI_NOT_READY;
872 }
873
874 return EFI_SUCCESS;
875
876 }
877
878
879 EFI_STATUS
880 InitUSBKeyBuffer (
881 IN OUT USB_KB_BUFFER *KeyboardBuffer
882 )
883 /*++
884
885 Routine Description:
886 Resets USB Keyboard Buffer.
887
888 Arguments:
889 KeyboardBuffer - Points to the USB Keyboard Buffer.
890
891 Returns:
892 EFI_SUCCESS - Success
893 --*/
894 {
895 ZeroMem (KeyboardBuffer, sizeof (USB_KB_BUFFER));
896
897 KeyboardBuffer->bHead = KeyboardBuffer->bTail;
898
899 return EFI_SUCCESS;
900 }
901
902 BOOLEAN
903 IsUSBKeyboardBufferEmpty (
904 IN USB_KB_BUFFER *KeyboardBuffer
905 )
906 /*++
907
908 Routine Description:
909 Check whether USB Keyboard buffer is empty.
910
911 Arguments:
912 KeyboardBuffer - USB Keyboard Buffer.
913
914 Returns:
915
916 --*/
917 {
918 //
919 // meet FIFO empty condition
920 //
921 return (BOOLEAN) (KeyboardBuffer->bHead == KeyboardBuffer->bTail);
922 }
923
924
925 BOOLEAN
926 IsUSBKeyboardBufferFull (
927 IN USB_KB_BUFFER *KeyboardBuffer
928 )
929 /*++
930
931 Routine Description:
932 Check whether USB Keyboard buffer is full.
933
934 Arguments:
935 KeyboardBuffer - USB Keyboard Buffer.
936
937 Returns:
938
939 --*/
940 {
941 return (BOOLEAN)(((KeyboardBuffer->bTail + 1) % (MAX_KEY_ALLOWED + 1)) ==
942 KeyboardBuffer->bHead);
943 }
944
945
946 EFI_STATUS
947 InsertKeyCode (
948 IN OUT USB_KB_BUFFER *KeyboardBuffer,
949 IN UINT8 Key,
950 IN UINT8 Down
951 )
952 /*++
953
954 Routine Description:
955 Inserts a key code into keyboard buffer.
956
957 Arguments:
958 KeyboardBuffer - Points to the USB Keyboard Buffer.
959 Key - Key code
960 Down - Special key
961 Returns:
962 EFI_SUCCESS - Success
963 --*/
964 {
965 USB_KEY UsbKey;
966
967 //
968 // if keyboard buffer is full, throw the
969 // first key out of the keyboard buffer.
970 //
971 if (IsUSBKeyboardBufferFull (KeyboardBuffer)) {
972 RemoveKeyCode (KeyboardBuffer, &UsbKey);
973 }
974
975 KeyboardBuffer->buffer[KeyboardBuffer->bTail].KeyCode = Key;
976 KeyboardBuffer->buffer[KeyboardBuffer->bTail].Down = Down;
977
978 //
979 // adjust the tail pointer of the FIFO keyboard buffer.
980 //
981 KeyboardBuffer->bTail = (UINT8) ((KeyboardBuffer->bTail + 1) % (MAX_KEY_ALLOWED + 1));
982
983 return EFI_SUCCESS;
984 }
985
986 EFI_STATUS
987 RemoveKeyCode (
988 IN OUT USB_KB_BUFFER *KeyboardBuffer,
989 OUT USB_KEY *UsbKey
990 )
991 /*++
992
993 Routine Description:
994 Pops a key code off from keyboard buffer.
995
996 Arguments:
997 KeyboardBuffer - Points to the USB Keyboard Buffer.
998 UsbKey - Points to the buffer that contains a usb key code.
999
1000 Returns:
1001 EFI_SUCCESS - Success
1002 EFI_DEVICE_ERROR - Hardware Error
1003 --*/
1004 {
1005 if (IsUSBKeyboardBufferEmpty (KeyboardBuffer)) {
1006 return EFI_DEVICE_ERROR;
1007 }
1008
1009 UsbKey->KeyCode = KeyboardBuffer->buffer[KeyboardBuffer->bHead].KeyCode;
1010 UsbKey->Down = KeyboardBuffer->buffer[KeyboardBuffer->bHead].Down;
1011
1012 //
1013 // adjust the head pointer of the FIFO keyboard buffer.
1014 //
1015 KeyboardBuffer->bHead = (UINT8) ((KeyboardBuffer->bHead + 1) % (MAX_KEY_ALLOWED + 1));
1016
1017 return EFI_SUCCESS;
1018 }
1019
1020 EFI_STATUS
1021 SetKeyLED (
1022 IN USB_KB_DEV *UsbKeyboardDevice
1023 )
1024 /*++
1025
1026 Routine Description:
1027 Sets USB Keyboard LED state.
1028
1029 Arguments:
1030 UsbKeyboardDevice - The USB_KB_DEV instance.
1031
1032 Returns:
1033 EFI_SUCCESS - Success
1034 --*/
1035 {
1036 LED_MAP Led;
1037 UINT8 ReportId;
1038
1039 //
1040 // Set each field in Led map.
1041 //
1042 Led.NumLock = (UINT8) UsbKeyboardDevice->NumLockOn;
1043 Led.CapsLock = (UINT8) UsbKeyboardDevice->CapsOn;
1044 Led.ScrollLock = (UINT8) UsbKeyboardDevice->ScrollOn;
1045 Led.Resrvd = 0;
1046
1047 ReportId = 0;
1048 //
1049 // call Set Report Request to lighten the LED.
1050 //
1051 UsbSetReportRequest (
1052 UsbKeyboardDevice->UsbIo,
1053 UsbKeyboardDevice->InterfaceDescriptor.InterfaceNumber,
1054 ReportId,
1055 HID_OUTPUT_REPORT,
1056 1,
1057 (UINT8 *) &Led
1058 );
1059
1060 return EFI_SUCCESS;
1061 }
1062
1063 VOID
1064 EFIAPI
1065 USBKeyboardRepeatHandler (
1066 IN EFI_EVENT Event,
1067 IN VOID *Context
1068 )
1069 /*++
1070
1071 Routine Description:
1072 Timer handler for Repeat Key timer.
1073
1074 Arguments:
1075 Event - The Repeat Key event.
1076 Context - Points to the USB_KB_DEV instance.
1077
1078 Returns:
1079
1080 --*/
1081 {
1082 USB_KB_DEV *UsbKeyboardDevice;
1083
1084 UsbKeyboardDevice = (USB_KB_DEV *) Context;
1085
1086 //
1087 // Do nothing when there is no repeat key.
1088 //
1089 if (UsbKeyboardDevice->RepeatKey != 0) {
1090 //
1091 // Inserts one Repeat key into keyboard buffer,
1092 //
1093 InsertKeyCode (
1094 &(UsbKeyboardDevice->KeyboardBuffer),
1095 UsbKeyboardDevice->RepeatKey,
1096 1
1097 );
1098
1099 //
1100 // set repeate rate for repeat key generation.
1101 //
1102 gBS->SetTimer (
1103 UsbKeyboardDevice->RepeatTimer,
1104 TimerRelative,
1105 USBKBD_REPEAT_RATE
1106 );
1107
1108 }
1109 }
1110
1111 VOID
1112 EFIAPI
1113 USBKeyboardRecoveryHandler (
1114 IN EFI_EVENT Event,
1115 IN VOID *Context
1116 )
1117 /*++
1118
1119 Routine Description:
1120 Timer handler for Delayed Recovery timer.
1121
1122 Arguments:
1123 Event - The Delayed Recovery event.
1124 Context - Points to the USB_KB_DEV instance.
1125
1126 Returns:
1127
1128 --*/
1129 {
1130
1131 USB_KB_DEV *UsbKeyboardDevice;
1132 EFI_USB_IO_PROTOCOL *UsbIo;
1133 UINT8 PacketSize;
1134
1135 UsbKeyboardDevice = (USB_KB_DEV *) Context;
1136
1137 UsbIo = UsbKeyboardDevice->UsbIo;
1138
1139 PacketSize = (UINT8) (UsbKeyboardDevice->IntEndpointDescriptor.MaxPacketSize);
1140
1141 UsbIo->UsbAsyncInterruptTransfer (
1142 UsbIo,
1143 UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
1144 TRUE,
1145 UsbKeyboardDevice->IntEndpointDescriptor.Interval,
1146 PacketSize,
1147 KeyboardHandler,
1148 UsbKeyboardDevice
1149 );
1150 }