aadc1bf2aeadf4da709ac35769c490aa66e464c6
[mirror_edk2.git] / IntelFrameworkModulePkg / Bus / Isa / Ps2KeyboardDxe / Ps2KbdCtrller.c
1 /** @file
2 Routines that access 8042 keyboard controller
3
4 Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "Ps2Keyboard.h"
16
17 struct {
18 UINT8 ScanCode; ///< follows value defined in Scan Code Set1
19 UINT16 EfiScanCode;
20 CHAR16 UnicodeChar;
21 CHAR16 ShiftUnicodeChar;
22 }
23 ConvertKeyboardScanCodeToEfiKey[] = {
24
25 {
26 0x01, // Escape
27 SCAN_ESC,
28 0x0000,
29 0x0000
30 },
31 {
32 0x02,
33 SCAN_NULL,
34 L'1',
35 L'!'
36 },
37 {
38 0x03,
39 SCAN_NULL,
40 L'2',
41 L'@'
42 },
43 {
44 0x04,
45 SCAN_NULL,
46 L'3',
47 L'#'
48 },
49 {
50 0x05,
51 SCAN_NULL,
52 L'4',
53 L'$'
54 },
55 {
56 0x06,
57 SCAN_NULL,
58 L'5',
59 L'%'
60 },
61 {
62 0x07,
63 SCAN_NULL,
64 L'6',
65 L'^'
66 },
67 {
68 0x08,
69 SCAN_NULL,
70 L'7',
71 L'&'
72 },
73 {
74 0x09,
75 SCAN_NULL,
76 L'8',
77 L'*'
78 },
79 {
80 0x0A,
81 SCAN_NULL,
82 L'9',
83 L'('
84 },
85 {
86 0x0B,
87 SCAN_NULL,
88 L'0',
89 L')'
90 },
91 {
92 0x0C,
93 SCAN_NULL,
94 L'-',
95 L'_'
96 },
97 {
98 0x0D,
99 SCAN_NULL,
100 L'=',
101 L'+'
102 },
103 {
104 0x0E, // BackSpace
105 SCAN_NULL,
106 0x0008,
107 0x0008
108 },
109 {
110 0x0F, // Tab
111 SCAN_NULL,
112 0x0009,
113 0x0009
114 },
115 {
116 0x10,
117 SCAN_NULL,
118 L'q',
119 L'Q'
120 },
121 {
122 0x11,
123 SCAN_NULL,
124 L'w',
125 L'W'
126 },
127 {
128 0x12,
129 SCAN_NULL,
130 L'e',
131 L'E'
132 },
133 {
134 0x13,
135 SCAN_NULL,
136 L'r',
137 L'R'
138 },
139 {
140 0x14,
141 SCAN_NULL,
142 L't',
143 L'T'
144 },
145 {
146 0x15,
147 SCAN_NULL,
148 L'y',
149 L'Y'
150 },
151 {
152 0x16,
153 SCAN_NULL,
154 L'u',
155 L'U'
156 },
157 {
158 0x17,
159 SCAN_NULL,
160 L'i',
161 L'I'
162 },
163 {
164 0x18,
165 SCAN_NULL,
166 L'o',
167 L'O'
168 },
169 {
170 0x19,
171 SCAN_NULL,
172 L'p',
173 L'P'
174 },
175 {
176 0x1a,
177 SCAN_NULL,
178 L'[',
179 L'{'
180 },
181 {
182 0x1b,
183 SCAN_NULL,
184 L']',
185 L'}'
186 },
187 {
188 0x1c, // Enter
189 SCAN_NULL,
190 0x000d,
191 0x000d
192 },
193 {
194 0x1d,
195 SCAN_NULL,
196 0x0000,
197 0x0000
198 },
199 {
200 0x1e,
201 SCAN_NULL,
202 L'a',
203 L'A'
204 },
205 {
206 0x1f,
207 SCAN_NULL,
208 L's',
209 L'S'
210 },
211 {
212 0x20,
213 SCAN_NULL,
214 L'd',
215 L'D'
216 },
217 {
218 0x21,
219 SCAN_NULL,
220 L'f',
221 L'F'
222 },
223 {
224 0x22,
225 SCAN_NULL,
226 L'g',
227 L'G'
228 },
229 {
230 0x23,
231 SCAN_NULL,
232 L'h',
233 L'H'
234 },
235 {
236 0x24,
237 SCAN_NULL,
238 L'j',
239 L'J'
240 },
241 {
242 0x25,
243 SCAN_NULL,
244 L'k',
245 L'K'
246 },
247 {
248 0x26,
249 SCAN_NULL,
250 L'l',
251 L'L'
252 },
253 {
254 0x27,
255 SCAN_NULL,
256 L';',
257 L':'
258 },
259 {
260 0x28,
261 SCAN_NULL,
262 L'\'',
263 L'"'
264 },
265 {
266 0x29,
267 SCAN_NULL,
268 L'`',
269 L'~'
270 },
271 {
272 0x2a, // Left Shift
273 SCAN_NULL,
274 0x0000,
275 0x0000
276 },
277 {
278 0x2b,
279 SCAN_NULL,
280 L'\\',
281 L'|'
282 },
283 {
284 0x2c,
285 SCAN_NULL,
286 L'z',
287 L'Z'
288 },
289 {
290 0x2d,
291 SCAN_NULL,
292 L'x',
293 L'X'
294 },
295 {
296 0x2e,
297 SCAN_NULL,
298 L'c',
299 L'C'
300 },
301 {
302 0x2f,
303 SCAN_NULL,
304 L'v',
305 L'V'
306 },
307 {
308 0x30,
309 SCAN_NULL,
310 L'b',
311 L'B'
312 },
313 {
314 0x31,
315 SCAN_NULL,
316 L'n',
317 L'N'
318 },
319 {
320 0x32,
321 SCAN_NULL,
322 L'm',
323 L'M'
324 },
325 {
326 0x33,
327 SCAN_NULL,
328 L',',
329 L'<'
330 },
331 {
332 0x34,
333 SCAN_NULL,
334 L'.',
335 L'>'
336 },
337 {
338 0x35,
339 SCAN_NULL,
340 L'/',
341 L'?'
342 },
343 {
344 0x36, //Right Shift
345 SCAN_NULL,
346 0x0000,
347 0x0000
348 },
349 {
350 0x37, // Numeric Keypad *
351 SCAN_NULL,
352 L'*',
353 L'*'
354 },
355 {
356 0x38, //Left Alt/Extended Right Alt
357 SCAN_NULL,
358 0x0000,
359 0x0000
360 },
361 {
362 0x39,
363 SCAN_NULL,
364 L' ',
365 L' '
366 },
367 {
368 0x3A, //CapsLock
369 SCAN_NULL,
370 0x0000,
371 0x0000
372 },
373 {
374 0x3B,
375 SCAN_F1,
376 0x0000,
377 0x0000
378 },
379 {
380 0x3C,
381 SCAN_F2,
382 0x0000,
383 0x0000
384 },
385 {
386 0x3D,
387 SCAN_F3,
388 0x0000,
389 0x0000
390 },
391 {
392 0x3E,
393 SCAN_F4,
394 0x0000,
395 0x0000
396 },
397 {
398 0x3F,
399 SCAN_F5,
400 0x0000,
401 0x0000
402 },
403 {
404 0x40,
405 SCAN_F6,
406 0x0000,
407 0x0000
408 },
409 {
410 0x41,
411 SCAN_F7,
412 0x0000,
413 0x0000
414 },
415 {
416 0x42,
417 SCAN_F8,
418 0x0000,
419 0x0000
420 },
421 {
422 0x43,
423 SCAN_F9,
424 0x0000,
425 0x0000
426 },
427 {
428 0x44,
429 SCAN_F10,
430 0x0000,
431 0x0000
432 },
433 {
434 0x45, // NumLock
435 SCAN_NULL,
436 0x0000,
437 0x0000
438 },
439 {
440 0x46, // ScrollLock
441 SCAN_NULL,
442 0x0000,
443 0x0000
444 },
445 {
446 0x47,
447 SCAN_HOME,
448 L'7',
449 L'7'
450 },
451 {
452 0x48,
453 SCAN_UP,
454 L'8',
455 L'8'
456 },
457 {
458 0x49,
459 SCAN_PAGE_UP,
460 L'9',
461 L'9'
462 },
463 {
464 0x4a,
465 SCAN_NULL,
466 L'-',
467 L'-'
468 },
469 {
470 0x4b,
471 SCAN_LEFT,
472 L'4',
473 L'4'
474 },
475 {
476 0x4c, // Numeric Keypad 5
477 SCAN_NULL,
478 L'5',
479 L'5'
480 },
481 {
482 0x4d,
483 SCAN_RIGHT,
484 L'6',
485 L'6'
486 },
487 {
488 0x4e,
489 SCAN_NULL,
490 L'+',
491 L'+'
492 },
493 {
494 0x4f,
495 SCAN_END,
496 L'1',
497 L'1'
498 },
499 {
500 0x50,
501 SCAN_DOWN,
502 L'2',
503 L'2'
504 },
505 {
506 0x51,
507 SCAN_PAGE_DOWN,
508 L'3',
509 L'3'
510 },
511 {
512 0x52,
513 SCAN_INSERT,
514 L'0',
515 L'0'
516 },
517 {
518 0x53,
519 SCAN_DELETE,
520 L'.',
521 L'.'
522 },
523 {
524 0x57,
525 SCAN_F11,
526 0x0000,
527 0x0000
528 },
529 {
530 0x58,
531 SCAN_F12,
532 0x0000,
533 0x0000
534 },
535 {
536 0x5B, //Left LOGO
537 SCAN_NULL,
538 0x0000,
539 0x0000
540 },
541 {
542 0x5C, //Right LOGO
543 SCAN_NULL,
544 0x0000,
545 0x0000
546 },
547 {
548 0x5D, //Menu key
549 SCAN_NULL,
550 0x0000,
551 0x0000
552 },
553 {
554 TABLE_END,
555 TABLE_END,
556 SCAN_NULL,
557 SCAN_NULL
558 },
559 };
560
561
562 //
563 // The WaitForValue time out
564 //
565 UINTN mWaitForValueTimeOut = KEYBOARD_WAITFORVALUE_TIMEOUT;
566
567 BOOLEAN mEnableMouseInterface;
568
569 /**
570 Read data register .
571
572 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
573
574 @return return the value
575
576 **/
577 UINT8
578 KeyReadDataRegister (
579 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
580 )
581
582 {
583 EFI_ISA_IO_PROTOCOL *IsaIo;
584 UINT8 Data;
585
586 //
587 // Use IsaIo protocol to perform IO operations
588 //
589 IsaIo = ConsoleIn->IsaIo;
590
591 IsaIo->Io.Read (
592 IsaIo,
593 EfiIsaIoWidthUint8,
594 ConsoleIn->DataRegisterAddress,
595 1,
596 &Data
597 );
598
599 return Data;
600 }
601
602 /**
603 Write data register.
604
605 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
606 @param Data value wanted to be written
607
608 **/
609 VOID
610 KeyWriteDataRegister (
611 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
612 IN UINT8 Data
613 )
614
615 {
616 EFI_ISA_IO_PROTOCOL *IsaIo;
617
618 //
619 // Use IsaIo protocol to perform IO operations
620 //
621 IsaIo = ConsoleIn->IsaIo;
622
623 IsaIo->Io.Write (
624 IsaIo,
625 EfiIsaIoWidthUint8,
626 ConsoleIn->DataRegisterAddress,
627 1,
628 &Data
629 );
630
631 }
632
633 /**
634 Read status register.
635
636 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
637
638 @return value in status register
639
640 **/
641 UINT8
642 KeyReadStatusRegister (
643 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
644 )
645 {
646 EFI_ISA_IO_PROTOCOL *IsaIo;
647 UINT8 Data;
648
649 //
650 // Use IsaIo protocol to perform IO operations
651 //
652 IsaIo = ConsoleIn->IsaIo;
653
654 IsaIo->Io.Read (
655 IsaIo,
656 EfiIsaIoWidthUint8,
657 ConsoleIn->StatusRegisterAddress,
658 1,
659 &Data
660 );
661
662 return Data;
663
664 }
665
666 /**
667 Write command register .
668
669 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
670 @param Data The value wanted to be written
671
672 **/
673 VOID
674 KeyWriteCommandRegister (
675 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
676 IN UINT8 Data
677 )
678 {
679 EFI_ISA_IO_PROTOCOL *IsaIo;
680
681 //
682 // Use IsaIo protocol to perform IO operations
683 //
684 IsaIo = ConsoleIn->IsaIo;
685
686 IsaIo->Io.Write (
687 IsaIo,
688 EfiIsaIoWidthUint8,
689 ConsoleIn->CommandRegisterAddress,
690 1,
691 &Data
692 );
693
694 }
695
696 /**
697 Display error message.
698
699 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
700 @param ErrMsg Unicode string of error message
701
702 **/
703 VOID
704 KeyboardError (
705 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
706 IN CHAR16 *ErrMsg
707 )
708 {
709 ConsoleIn->KeyboardErr = TRUE;
710 }
711
712 /**
713 Timer event handler: read a series of scancodes from 8042
714 and put them into memory scancode buffer.
715 it read as much scancodes to either fill
716 the memory buffer or empty the keyboard buffer.
717 It is registered as running under TPL_NOTIFY
718
719 @param Event The timer event
720 @param Context A KEYBOARD_CONSOLE_IN_DEV pointer
721
722 **/
723 VOID
724 EFIAPI
725 KeyboardTimerHandler (
726 IN EFI_EVENT Event,
727 IN VOID *Context
728 )
729
730 {
731 UINT8 Data;
732 EFI_TPL OldTpl;
733 KEYBOARD_CONSOLE_IN_DEV *ConsoleIn;
734
735 ConsoleIn = Context;
736
737 //
738 // Enter critical section
739 //
740 OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
741
742 if (((KEYBOARD_CONSOLE_IN_DEV *) Context)->KeyboardErr) {
743 //
744 // Leave critical section and return
745 //
746 gBS->RestoreTPL (OldTpl);
747 return ;
748 }
749
750 //
751 // To let KB driver support Hot plug, here should skip the 'resend' command for the case that
752 // KB is not connected to system. If KB is not connected to system, driver will find there's something
753 // error in the following code and wait for the input buffer empty, this waiting time shoulb be short enough since
754 // this is a NOTIFY TPL period function, or the system performance will degrade hardly when KB is not connected.
755 // Just skip the 'resend' process simply.
756 //
757
758 Data = 0;
759
760 //
761 // if there is no key present, just return
762 //
763 if ((KeyReadStatusRegister (Context) & (KEYBOARD_STATUS_REGISTER_TRANSMIT_TIMEOUT|KEYBOARD_STATUS_REGISTER_HAS_OUTPUT_DATA)) != KEYBOARD_STATUS_REGISTER_HAS_OUTPUT_DATA) {
764 //
765 // Leave critical section and return
766 //
767 gBS->RestoreTPL (OldTpl);
768
769 return ;
770 }
771 //
772 // Read one byte of the scan code and store it into the memory buffer
773 //
774 if (ConsoleIn->ScancodeBufCount < KEYBOARD_BUFFER_MAX_COUNT) {
775
776 Data = KeyReadDataRegister (Context);
777 //
778 // put the scancode into the memory scancode buffer
779 //
780 ConsoleIn->ScancodeBufCount++;
781 ConsoleIn->ScancodeBufEndPos++;
782 if (ConsoleIn->ScancodeBufEndPos >= KEYBOARD_BUFFER_MAX_COUNT) {
783 ConsoleIn->ScancodeBufEndPos = 0;
784 }
785
786 ConsoleIn->ScancodeBuf[ConsoleIn->ScancodeBufEndPos] = Data;
787
788 //
789 // Handle Alt+Ctrl+Del Key combination
790 //
791 switch (Data) {
792 case SCANCODE_CTRL_MAKE:
793 ConsoleIn->Ctrled = TRUE;
794 break;
795
796 case SCANCODE_CTRL_BREAK:
797 ConsoleIn->Ctrled = FALSE;
798 break;
799
800 case SCANCODE_ALT_MAKE:
801 ConsoleIn->Alted = TRUE;
802 break;
803
804 case SCANCODE_ALT_BREAK:
805 ConsoleIn->Alted = FALSE;
806 break;
807 }
808 //
809 // if Alt+Ctrl+Del, Reboot the System
810 //
811 if (ConsoleIn->Ctrled && ConsoleIn->Alted && Data == 0x53) {
812 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
813 }
814 }
815 //
816 // Leave critical section and return
817 //
818 gBS->RestoreTPL (OldTpl);
819
820 return ;
821 }
822
823 /**
824 Read several bytes from the scancode buffer without removing them.
825 This function is called to see if there are enough bytes of scancode
826 representing a single key.
827
828 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
829 @param Count Number of bytes to be read
830 @param Buf Store the results
831
832 @retval EFI_SUCCESS success to scan the keyboard code
833 @retval EFI_NOT_READY invalid parameter
834 **/
835 EFI_STATUS
836 GetScancodeBufHead (
837 KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
838 IN UINT32 Count,
839 OUT UINT8 *Buf
840 )
841 {
842 UINT32 Index;
843 UINT32 Pos;
844
845 Index = 0;
846 Pos = 0;
847
848 //
849 // check the valid range of parameter 'Count'
850 //
851 if (Count <= 0 || ConsoleIn->ScancodeBufCount < Count) {
852 return EFI_NOT_READY;
853 }
854 //
855 // retrieve the values
856 //
857 for (Index = 0; Index < Count; Index++) {
858
859 if (Index == 0) {
860
861 Pos = ConsoleIn->ScancodeBufStartPos;
862 } else {
863
864 Pos = Pos + 1;
865 if (Pos >= KEYBOARD_BUFFER_MAX_COUNT) {
866 Pos = 0;
867 }
868 }
869
870 Buf[Index] = ConsoleIn->ScancodeBuf[Pos];
871 }
872
873 return EFI_SUCCESS;
874 }
875
876 /**
877
878 Read & remove several bytes from the scancode buffer.
879 This function is usually called after GetScancodeBufHead()
880
881 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
882 @param Count Number of bytes to be read
883 @param Buf Store the results
884
885 @retval EFI_SUCCESS success to scan the keyboard code
886 @retval EFI_NOT_READY invalid parameter
887 **/
888 EFI_STATUS
889 PopScancodeBufHead (
890 KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
891 IN UINT32 Count,
892 OUT UINT8 *Buf
893 )
894 {
895 UINT32 Index;
896
897 Index = 0;
898
899 //
900 // Check the valid range of parameter 'Count'
901 //
902 if (Count <= 0 || ConsoleIn->ScancodeBufCount < Count) {
903 return EFI_NOT_READY;
904 }
905 //
906 // Retrieve and remove the values
907 //
908 for (Index = 0; Index < Count; Index++) {
909
910 if (Index != 0) {
911
912 ConsoleIn->ScancodeBufStartPos++;
913 if (ConsoleIn->ScancodeBufStartPos >= KEYBOARD_BUFFER_MAX_COUNT) {
914 ConsoleIn->ScancodeBufStartPos = 0;
915 }
916 }
917
918 Buf[Index] = ConsoleIn->ScancodeBuf[ConsoleIn->ScancodeBufStartPos];
919 ConsoleIn->ScancodeBufCount--;
920 }
921
922 ConsoleIn->ScancodeBufStartPos++;
923 if (ConsoleIn->ScancodeBufStartPos >= KEYBOARD_BUFFER_MAX_COUNT) {
924 ConsoleIn->ScancodeBufStartPos = 0;
925 }
926
927 return EFI_SUCCESS;
928 }
929
930 /**
931 Read key value .
932
933 @param ConsoleIn - Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
934 @param Data - Pointer to outof buffer for keeping key value
935
936 @retval EFI_TIMEOUT Status resigter time out
937 @retval EFI_SUCCESS Success to read keyboard
938
939 **/
940 EFI_STATUS
941 KeyboardRead (
942 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
943 OUT UINT8 *Data
944 )
945
946 {
947 UINT32 TimeOut;
948 UINT32 RegFilled;
949
950 TimeOut = 0;
951 RegFilled = 0;
952
953 //
954 // wait till output buffer full then perform the read
955 //
956 for (TimeOut = 0; TimeOut < KEYBOARD_TIMEOUT; TimeOut += 30) {
957 if (KeyReadStatusRegister (ConsoleIn) & KEYBOARD_STATUS_REGISTER_HAS_OUTPUT_DATA) {
958 RegFilled = 1;
959 *Data = KeyReadDataRegister (ConsoleIn);
960 break;
961 }
962
963 MicroSecondDelay (30);
964 }
965
966 if (RegFilled == 0) {
967 return EFI_TIMEOUT;
968 }
969
970 return EFI_SUCCESS;
971 }
972
973 /**
974 write key to keyboard
975
976 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
977 @param Data value wanted to be written
978
979 @retval EFI_TIMEOUT The input buffer register is full for putting new value util timeout
980 @retval EFI_SUCCESS The new value is sucess put into input buffer register.
981
982 **/
983 EFI_STATUS
984 KeyboardWrite (
985 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
986 IN UINT8 Data
987 )
988 {
989 UINT32 TimeOut;
990 UINT32 RegEmptied;
991
992 TimeOut = 0;
993 RegEmptied = 0;
994
995 //
996 // wait for input buffer empty
997 //
998 for (TimeOut = 0; TimeOut < KEYBOARD_TIMEOUT; TimeOut += 30) {
999 if ((KeyReadStatusRegister (ConsoleIn) & 0x02) == 0) {
1000 RegEmptied = 1;
1001 break;
1002 }
1003
1004 MicroSecondDelay (30);
1005 }
1006
1007 if (RegEmptied == 0) {
1008 return EFI_TIMEOUT;
1009 }
1010 //
1011 // Write it
1012 //
1013 KeyWriteDataRegister (ConsoleIn, Data);
1014
1015 return EFI_SUCCESS;
1016 }
1017
1018 /**
1019 Issue keyboard command.
1020
1021 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
1022 @param Data The buff holding the command
1023
1024 @retval EFI_TIMEOUT Keyboard is not ready to issuing
1025 @retval EFI_SUCCESS Success to issue keyboard command
1026
1027 **/
1028 EFI_STATUS
1029 KeyboardCommand (
1030 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
1031 IN UINT8 Data
1032 )
1033 {
1034 UINT32 TimeOut;
1035 UINT32 RegEmptied;
1036
1037 TimeOut = 0;
1038 RegEmptied = 0;
1039
1040 //
1041 // Wait For Input Buffer Empty
1042 //
1043 for (TimeOut = 0; TimeOut < KEYBOARD_TIMEOUT; TimeOut += 30) {
1044 if ((KeyReadStatusRegister (ConsoleIn) & 0x02) == 0) {
1045 RegEmptied = 1;
1046 break;
1047 }
1048
1049 MicroSecondDelay (30);
1050 }
1051
1052 if (RegEmptied == 0) {
1053 return EFI_TIMEOUT;
1054 }
1055 //
1056 // issue the command
1057 //
1058 KeyWriteCommandRegister (ConsoleIn, Data);
1059
1060 //
1061 // Wait For Input Buffer Empty again
1062 //
1063 RegEmptied = 0;
1064 for (TimeOut = 0; TimeOut < KEYBOARD_TIMEOUT; TimeOut += 30) {
1065 if ((KeyReadStatusRegister (ConsoleIn) & 0x02) == 0) {
1066 RegEmptied = 1;
1067 break;
1068 }
1069
1070 MicroSecondDelay (30);
1071 }
1072
1073 if (RegEmptied == 0) {
1074 return EFI_TIMEOUT;
1075 }
1076
1077 return EFI_SUCCESS;
1078 }
1079
1080 /**
1081 wait for a specific value to be presented on
1082 8042 Data register by keyboard and then read it,
1083 used in keyboard commands ack
1084
1085 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
1086 @param Value the value wanted to be waited.
1087
1088 @retval EFI_TIMEOUT Fail to get specific value in given time
1089 @retval EFI_SUCCESS Success to get specific value in given time.
1090
1091 **/
1092 EFI_STATUS
1093 KeyboardWaitForValue (
1094 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
1095 IN UINT8 Value
1096 )
1097 {
1098 UINT8 Data;
1099 UINT32 TimeOut;
1100 UINT32 SumTimeOut;
1101 UINT32 GotIt;
1102
1103 GotIt = 0;
1104 TimeOut = 0;
1105 SumTimeOut = 0;
1106
1107 //
1108 // Make sure the initial value of 'Data' is different from 'Value'
1109 //
1110 Data = 0;
1111 if (Data == Value) {
1112 Data = 1;
1113 }
1114 //
1115 // Read from 8042 (multiple times if needed)
1116 // until the expected value appears
1117 // use SumTimeOut to control the iteration
1118 //
1119 while (1) {
1120 //
1121 // Perform a read
1122 //
1123 for (TimeOut = 0; TimeOut < KEYBOARD_TIMEOUT; TimeOut += 30) {
1124 if (KeyReadStatusRegister (ConsoleIn) & 0x01) {
1125 Data = KeyReadDataRegister (ConsoleIn);
1126 break;
1127 }
1128
1129 MicroSecondDelay (30);
1130 }
1131
1132 SumTimeOut += TimeOut;
1133
1134 if (Data == Value) {
1135 GotIt = 1;
1136 break;
1137 }
1138
1139 if (SumTimeOut >= mWaitForValueTimeOut) {
1140 break;
1141 }
1142 }
1143 //
1144 // Check results
1145 //
1146 if (GotIt == 1) {
1147 return EFI_SUCCESS;
1148 } else {
1149 return EFI_TIMEOUT;
1150 }
1151
1152 }
1153
1154 /**
1155 Show keyboard status lights according to
1156 indicators in ConsoleIn.
1157
1158 @param ConsoleIn Pointer to instance of KEYBOARD_CONSOLE_IN_DEV
1159
1160 @return status of updating keyboard register
1161
1162 **/
1163 EFI_STATUS
1164 UpdateStatusLights (
1165 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
1166 )
1167 {
1168 EFI_STATUS Status;
1169 UINT8 Command;
1170
1171 //
1172 // Send keyboard command
1173 //
1174 Status = KeyboardWrite (ConsoleIn, 0xed);
1175 if (EFI_ERROR (Status)) {
1176 return Status;
1177 }
1178
1179 KeyboardWaitForValue (ConsoleIn, 0xfa);
1180
1181 //
1182 // Light configuration
1183 //
1184 Command = 0;
1185 if (ConsoleIn->CapsLock) {
1186 Command |= 4;
1187 }
1188
1189 if (ConsoleIn->NumLock) {
1190 Command |= 2;
1191 }
1192
1193 if (ConsoleIn->ScrollLock) {
1194 Command |= 1;
1195 }
1196
1197 Status = KeyboardWrite (ConsoleIn, Command);
1198
1199 if (EFI_ERROR (Status)) {
1200 return Status;
1201 }
1202
1203 KeyboardWaitForValue (ConsoleIn, 0xfa);
1204 return Status;
1205 }
1206
1207 /**
1208 Get scancode from scancode buffer
1209 and translate into EFI-scancode and unicode defined by EFI spec
1210 The function is always called in TPL_NOTIFY
1211
1212 @param ConsoleIn KEYBOARD_CONSOLE_IN_DEV instance pointer
1213
1214 @retval EFI_NOT_READY Input from console not ready yet.
1215 @retval EFI_SUCCESS Function executed successfully.
1216
1217 **/
1218 EFI_STATUS
1219 KeyGetchar (
1220 IN OUT KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
1221 )
1222 {
1223 EFI_STATUS Status;
1224 UINT8 ScanCode;
1225 UINT8 Readed;
1226 BOOLEAN Extended;
1227 UINT8 ScancodeArr[4];
1228 UINTN Index;
1229 //
1230 // 4 bytes most
1231 //
1232 UINT32 ScancodeArrPos;
1233 //
1234 // point to the current position in ScancodeArr
1235 //
1236
1237 Readed = 0;
1238 Extended = FALSE;
1239 ScancodeArrPos = 0;
1240
1241 //
1242 // Read one byte of the scan code and store it into the memory buffer
1243 // This block of code is added to insert an action that is equivalent to
1244 // the timer event handling function, so as to increase the frequency of
1245 // detecting the availability of keys. Timer event has a max frequency of
1246 // 18Hz which is insufficient
1247 //
1248 //
1249 // To let KB driver support Hot plug, here should skip the 'resend' command for the case that
1250 // KB is not connected to system. If KB is not connected to system, driver will find there's something
1251 // error in the following code and wait for the input buffer empty, this waiting time shoulb be short enough since
1252 // this is a NOTIFY TPL period function, or the system performance will degrade hardly when KB is not connected.
1253 // Just skip the 'resend' process simply.
1254 //
1255
1256
1257 if (((KeyReadStatusRegister (ConsoleIn) & 0x21) == 0x1) && (ConsoleIn->ScancodeBufCount < KEYBOARD_BUFFER_MAX_COUNT)) {
1258
1259 Readed = KeyReadDataRegister (ConsoleIn);
1260 //
1261 // put the scancode into the memory scancode buffer
1262 //
1263 ConsoleIn->ScancodeBufCount++;
1264 ConsoleIn->ScancodeBufEndPos++;
1265 if (ConsoleIn->ScancodeBufEndPos >= KEYBOARD_BUFFER_MAX_COUNT) {
1266 ConsoleIn->ScancodeBufEndPos = 0;
1267 }
1268
1269 ConsoleIn->ScancodeBuf[ConsoleIn->ScancodeBufEndPos] = Readed;
1270
1271 //
1272 // Handle Alt+Ctrl+Del Key combination
1273 //
1274 switch (Readed) {
1275
1276 case SCANCODE_CTRL_MAKE:
1277 ConsoleIn->Ctrled = TRUE;
1278 break;
1279
1280 case SCANCODE_CTRL_BREAK:
1281 ConsoleIn->Ctrled = FALSE;
1282 break;
1283
1284 case SCANCODE_ALT_MAKE:
1285 ConsoleIn->Alted = TRUE;
1286 break;
1287
1288 case SCANCODE_ALT_BREAK:
1289 ConsoleIn->Alted = FALSE;
1290 break;
1291 }
1292 //
1293 // if Alt+Ctrl+Del, Reboot the System
1294 //
1295 if (ConsoleIn->Ctrled && ConsoleIn->Alted && Readed == 0x53) {
1296 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
1297 }
1298 }
1299 //
1300 // Check if there are enough bytes of scancode representing a single key
1301 // available in the buffer
1302 //
1303 while (TRUE) {
1304
1305 Status = GetScancodeBufHead (ConsoleIn, 1, ScancodeArr);
1306 ScancodeArrPos = 0;
1307 if (EFI_ERROR (Status)) {
1308 return EFI_NOT_READY;
1309 }
1310
1311 if (ScancodeArr[ScancodeArrPos] == SCANCODE_EXTENDED) {
1312 Extended = TRUE;
1313 Status = GetScancodeBufHead (ConsoleIn, 2, ScancodeArr);
1314 ScancodeArrPos = 1;
1315 if (EFI_ERROR (Status)) {
1316 return EFI_NOT_READY;
1317 }
1318 }
1319 //
1320 // Checks for key scancode for PAUSE:E1-1D/45-E1/9D-C5
1321 // if present, ignore them
1322 //
1323 if (ScancodeArr[ScancodeArrPos] == SCANCODE_EXTENDED1) {
1324
1325 Status = GetScancodeBufHead (ConsoleIn, 2, ScancodeArr);
1326 ScancodeArrPos = 1;
1327
1328 if (EFI_ERROR (Status)) {
1329 return EFI_NOT_READY;
1330 }
1331
1332 Status = GetScancodeBufHead (ConsoleIn, 3, ScancodeArr);
1333 ScancodeArrPos = 2;
1334
1335 if (EFI_ERROR (Status)) {
1336 return EFI_NOT_READY;
1337 }
1338
1339 PopScancodeBufHead (ConsoleIn, 3, ScancodeArr);
1340 return EFI_NOT_READY;
1341 }
1342 //
1343 // if we reach this position, scancodes for a key is in buffer now,pop them
1344 //
1345 Status = PopScancodeBufHead (ConsoleIn, ScancodeArrPos + 1, ScancodeArr);
1346 if (EFI_ERROR (Status)) {
1347 return EFI_NOT_READY;
1348 }
1349 //
1350 // store the last available byte, this byte of scancode will be checked
1351 //
1352 ScanCode = ScancodeArr[ScancodeArrPos];
1353
1354 //
1355 // Check for special keys and update the driver state.
1356 //
1357 switch (ScanCode) {
1358
1359 case SCANCODE_CTRL_MAKE:
1360 ConsoleIn->Ctrl = TRUE;
1361 break;
1362
1363 case SCANCODE_CTRL_BREAK:
1364 ConsoleIn->Ctrl = FALSE;
1365 break;
1366
1367 case SCANCODE_ALT_MAKE:
1368 ConsoleIn->Alt = TRUE;
1369 break;
1370
1371 case SCANCODE_ALT_BREAK:
1372 ConsoleIn->Alt = FALSE;
1373 break;
1374
1375 case SCANCODE_LEFT_SHIFT_MAKE:
1376 if (!Extended) {
1377 ConsoleIn->Shift = TRUE;
1378 ConsoleIn->LeftShift = TRUE;
1379 }
1380 break;
1381 case SCANCODE_RIGHT_SHIFT_MAKE:
1382 if (!Extended) {
1383 ConsoleIn->Shift = TRUE;
1384 ConsoleIn->RightShift = TRUE;
1385 }
1386 break;
1387
1388 case SCANCODE_LEFT_SHIFT_BREAK:
1389 if (!Extended) {
1390 ConsoleIn->Shift = FALSE;
1391 ConsoleIn->LeftShift = FALSE;
1392 } else {
1393 ConsoleIn->SysReq = FALSE;
1394 }
1395 break;
1396 case SCANCODE_RIGHT_SHIFT_BREAK:
1397 if (!Extended) {
1398 ConsoleIn->Shift = FALSE;
1399 ConsoleIn->RightShift = FALSE;
1400 }
1401 break;
1402
1403 case SCANCODE_LEFT_LOGO_MAKE:
1404 ConsoleIn->LeftLogo = TRUE;
1405 break;
1406 case SCANCODE_LEFT_LOGO_BREAK:
1407 ConsoleIn->LeftLogo = FALSE;
1408 break;
1409 case SCANCODE_RIGHT_LOGO_MAKE:
1410 ConsoleIn->RightLogo = TRUE;
1411 break;
1412 case SCANCODE_RIGHT_LOGO_BREAK:
1413 ConsoleIn->RightLogo = FALSE;
1414 break;
1415 case SCANCODE_MENU_MAKE:
1416 ConsoleIn->Menu = TRUE;
1417 break;
1418 case SCANCODE_MENU_BREAK:
1419 ConsoleIn->Menu = FALSE;
1420 break;
1421 case SCANCODE_SYS_REQ_MAKE:
1422 if (Extended) {
1423 ConsoleIn->SysReq = TRUE;
1424 }
1425 case SCANCODE_CAPS_LOCK_MAKE:
1426 ConsoleIn->CapsLock = (BOOLEAN)!ConsoleIn->CapsLock;
1427 UpdateStatusLights (ConsoleIn);
1428 break;
1429
1430 case SCANCODE_NUM_LOCK_MAKE:
1431 ConsoleIn->NumLock = (BOOLEAN)!ConsoleIn->NumLock;
1432 UpdateStatusLights (ConsoleIn);
1433 break;
1434
1435 case SCANCODE_SCROLL_LOCK_MAKE:
1436 ConsoleIn->ScrollLock = (BOOLEAN)!ConsoleIn->ScrollLock;
1437 UpdateStatusLights (ConsoleIn);
1438 break;
1439 }
1440 //
1441 // If this is a BREAK Key or above the valid range, ignore it
1442 //
1443 if (ScanCode >= SCANCODE_MAX_MAKE) {
1444 continue;
1445 } else {
1446 break;
1447 }
1448 }
1449 //
1450 // Treat Numeric Key Pad "/" specially
1451 //
1452 if (Extended && ScanCode == 0x35) {
1453 ConsoleIn->Key.ScanCode = SCAN_NULL;
1454 ConsoleIn->Key.UnicodeChar = L'/';
1455 return EFI_SUCCESS;
1456 }
1457 //
1458 // Convert Keyboard ScanCode into an EFI Key
1459 //
1460 for (Index = 0; ConvertKeyboardScanCodeToEfiKey[Index].ScanCode != TABLE_END; Index += 1) {
1461 if (ScanCode == ConvertKeyboardScanCodeToEfiKey[Index].ScanCode) {
1462 ConsoleIn->Key.ScanCode = ConvertKeyboardScanCodeToEfiKey[Index].EfiScanCode;
1463 if (ConsoleIn->Shift) {
1464 ConsoleIn->Key.UnicodeChar = ConvertKeyboardScanCodeToEfiKey[Index].ShiftUnicodeChar;
1465 //
1466 // Need not return associated shift state if a class of printable characters that
1467 // are normally adjusted by shift modifiers. e.g. Shift Key + 'f' key = 'F'
1468 //
1469 if (ConsoleIn->Key.UnicodeChar >= L'A' && ConsoleIn->Key.UnicodeChar <= L'Z') {
1470 ConsoleIn->LeftShift = FALSE;
1471 ConsoleIn->RightShift = FALSE;
1472 }
1473 } else {
1474 ConsoleIn->Key.UnicodeChar = ConvertKeyboardScanCodeToEfiKey[Index].UnicodeChar;
1475 }
1476 //
1477 // alphabetic key is affected by CapsLock State
1478 //
1479 if (ConsoleIn->CapsLock) {
1480 if (ConsoleIn->Key.UnicodeChar >= L'a' && ConsoleIn->Key.UnicodeChar <= L'z') {
1481 ConsoleIn->Key.UnicodeChar = ConvertKeyboardScanCodeToEfiKey[Index].ShiftUnicodeChar;
1482 } else if (ConsoleIn->Key.UnicodeChar >= L'A' && ConsoleIn->Key.UnicodeChar <= L'Z') {
1483 ConsoleIn->Key.UnicodeChar = ConvertKeyboardScanCodeToEfiKey[Index].UnicodeChar;
1484 }
1485 }
1486 //
1487 // Translate the CTRL-Alpha characters to their corresponding control value (ctrl-a = 0x0001 through ctrl-Z = 0x001A)
1488 //
1489 if (ConsoleIn->Ctrled) {
1490 if (ConsoleIn->Key.UnicodeChar >= L'a' && ConsoleIn->Key.UnicodeChar <= L'z') {
1491 ConsoleIn->Key.UnicodeChar = (UINT16) (ConsoleIn->Key.UnicodeChar - L'a' + 1);
1492 } else if (ConsoleIn->Key.UnicodeChar >= L'A' && ConsoleIn->Key.UnicodeChar <= L'Z') {
1493 ConsoleIn->Key.UnicodeChar = (UINT16) (ConsoleIn->Key.UnicodeChar - L'A' + 1);
1494 }
1495 }
1496
1497 break;
1498 }
1499 }
1500
1501 //
1502 // distinguish numeric key pad keys' 'up symbol' and 'down symbol'
1503 //
1504 if (ScanCode >= 0x47 && ScanCode <= 0x53) {
1505
1506 if (ConsoleIn->NumLock && !ConsoleIn->Shift && !Extended) {
1507 ConsoleIn->Key.ScanCode = SCAN_NULL;
1508 } else if (ScanCode != 0x4a && ScanCode != 0x4e) {
1509 ConsoleIn->Key.UnicodeChar = 0x0000;
1510 }
1511 }
1512 //
1513 // If the key can not be converted then just return.
1514 //
1515 if (ConsoleIn->Key.ScanCode == SCAN_NULL && ConsoleIn->Key.UnicodeChar == 0x0000) {
1516 return EFI_NOT_READY;
1517 }
1518
1519 //
1520 // Save the Shift/Toggle state
1521 //
1522 if (ConsoleIn->Ctrl) {
1523 ConsoleIn->KeyState.KeyShiftState |= (Extended) ? EFI_RIGHT_CONTROL_PRESSED : EFI_LEFT_CONTROL_PRESSED;
1524 }
1525 if (ConsoleIn->Alt) {
1526 ConsoleIn->KeyState.KeyShiftState |= (Extended) ? EFI_RIGHT_ALT_PRESSED : EFI_LEFT_ALT_PRESSED;
1527 }
1528 if (ConsoleIn->LeftShift) {
1529 ConsoleIn->KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
1530 }
1531 if (ConsoleIn->RightShift) {
1532 ConsoleIn->KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
1533 }
1534 if (ConsoleIn->LeftLogo) {
1535 ConsoleIn->KeyState.KeyShiftState |= EFI_LEFT_LOGO_PRESSED;
1536 }
1537 if (ConsoleIn->RightLogo) {
1538 ConsoleIn->KeyState.KeyShiftState |= EFI_RIGHT_LOGO_PRESSED;
1539 }
1540 if (ConsoleIn->Menu) {
1541 ConsoleIn->KeyState.KeyShiftState |= EFI_MENU_KEY_PRESSED;
1542 }
1543 if (ConsoleIn->SysReq) {
1544 ConsoleIn->KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED;
1545 }
1546 if (ConsoleIn->CapsLock) {
1547 ConsoleIn->KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
1548 }
1549 if (ConsoleIn->NumLock) {
1550 ConsoleIn->KeyState.KeyToggleState |= EFI_NUM_LOCK_ACTIVE;
1551 }
1552 if (ConsoleIn->ScrollLock) {
1553 ConsoleIn->KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
1554 }
1555
1556 return EFI_SUCCESS;
1557 }
1558
1559 /**
1560 Perform 8042 controller and keyboard Initialization.
1561 If ExtendedVerification is TRUE, do additional test for
1562 the keyboard interface
1563
1564 @param ConsoleIn - KEYBOARD_CONSOLE_IN_DEV instance pointer
1565 @param ExtendedVerification - indicates a thorough initialization
1566
1567 @retval EFI_DEVICE_ERROR Fail to init keyboard
1568 @retval EFI_SUCCESS Success to init keyboard
1569 **/
1570 EFI_STATUS
1571 InitKeyboard (
1572 IN OUT KEYBOARD_CONSOLE_IN_DEV *ConsoleIn,
1573 IN BOOLEAN ExtendedVerification
1574 )
1575 {
1576 EFI_STATUS Status;
1577 EFI_STATUS Status1;
1578 UINT8 CommandByte;
1579 EFI_PS2_POLICY_PROTOCOL *Ps2Policy;
1580 UINT32 TryTime;
1581
1582 Status = EFI_SUCCESS;
1583 mEnableMouseInterface = TRUE;
1584 TryTime = 0;
1585
1586 //
1587 // Get Ps2 policy to set this
1588 //
1589 gBS->LocateProtocol (
1590 &gEfiPs2PolicyProtocolGuid,
1591 NULL,
1592 (VOID **) &Ps2Policy
1593 );
1594
1595 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
1596 EFI_PROGRESS_CODE,
1597 EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_CLEAR_BUFFER,
1598 ConsoleIn->DevicePath
1599 );
1600
1601 //
1602 // Perform a read to cleanup the Status Register's
1603 // output buffer full bits within MAX TRY times
1604 //
1605 while (!EFI_ERROR (Status) && TryTime < KEYBOARD_MAX_TRY) {
1606 Status = KeyboardRead (ConsoleIn, &CommandByte);
1607 TryTime ++;
1608 }
1609 //
1610 // Exceed the max try times. The device may be error.
1611 //
1612 if (TryTime == KEYBOARD_MAX_TRY) {
1613 Status = EFI_DEVICE_ERROR;
1614 goto Done;
1615 }
1616 //
1617 // We should disable mouse interface during the initialization process
1618 // since mouse device output could block keyboard device output in the
1619 // 60H port of 8042 controller.
1620 //
1621 // So if we are not initializing 8042 controller for the
1622 // first time, we have to remember the previous mouse interface
1623 // enabling state
1624 //
1625 // Test the system flag in to determine whether this is the first
1626 // time initialization
1627 //
1628 if ((KeyReadStatusRegister (ConsoleIn) & KEYBOARD_STATUS_REGISTER_SYSTEM_FLAG) != 0) {
1629 //
1630 // 8042 controller is already setup (by myself or by mouse driver):
1631 // See whether mouse interface is already enabled
1632 // which determines whether we should enable it later
1633 //
1634 //
1635 // Read the command byte of 8042 controller
1636 //
1637 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_READ);
1638 if (EFI_ERROR (Status)) {
1639 KeyboardError (ConsoleIn, L"\n\r");
1640 goto Done;
1641 }
1642
1643 Status = KeyboardRead (ConsoleIn, &CommandByte);
1644 if (EFI_ERROR (Status)) {
1645 KeyboardError (ConsoleIn, L"\n\r");
1646 goto Done;
1647 }
1648 //
1649 // Test the mouse enabling bit
1650 //
1651 if ((CommandByte & 0x20) != 0) {
1652 mEnableMouseInterface = FALSE;
1653 } else {
1654 mEnableMouseInterface = TRUE;
1655 }
1656
1657 } else {
1658 //
1659 // 8042 controller is not setup yet:
1660 // 8042 controller selftest;
1661 // Don't enable mouse interface later.
1662 //
1663 //
1664 // Disable keyboard and mouse interfaces
1665 //
1666 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_DISABLE_KEYBOARD_INTERFACE);
1667 if (EFI_ERROR (Status)) {
1668 KeyboardError (ConsoleIn, L"\n\r");
1669 goto Done;
1670 }
1671
1672 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_DISABLE_MOUSE_INTERFACE);
1673 if (EFI_ERROR (Status)) {
1674 KeyboardError (ConsoleIn, L"\n\r");
1675 goto Done;
1676 }
1677
1678 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
1679 EFI_PROGRESS_CODE,
1680 EFI_PERIPHERAL_KEYBOARD | EFI_P_KEYBOARD_PC_SELF_TEST,
1681 ConsoleIn->DevicePath
1682 );
1683 //
1684 // 8042 Controller Self Test
1685 //
1686 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_CONTROLLER_SELF_TEST);
1687 if (EFI_ERROR (Status)) {
1688 KeyboardError (ConsoleIn, L"8042 controller command write error!\n\r");
1689 goto Done;
1690 }
1691
1692 Status = KeyboardWaitForValue (ConsoleIn, 0x55);
1693 if (EFI_ERROR (Status)) {
1694 KeyboardError (ConsoleIn, L"8042 controller self test failed!\n\r");
1695 goto Done;
1696 }
1697 //
1698 // Don't enable mouse interface later
1699 //
1700 mEnableMouseInterface = FALSE;
1701
1702 }
1703
1704 if (Ps2Policy != NULL) {
1705 Ps2Policy->Ps2InitHardware (ConsoleIn->Handle);
1706 }
1707 //
1708 // Write 8042 Command Byte, set System Flag
1709 // While at the same time:
1710 // 1. disable mouse interface,
1711 // 2. enable kbd interface,
1712 // 3. enable PC/XT kbd translation mode
1713 // 4. enable mouse and kbd interrupts
1714 //
1715 // ( Command Byte bits:
1716 // 7: Reserved
1717 // 6: PC/XT translation mode
1718 // 5: Disable Auxiliary device interface
1719 // 4: Disable keyboard interface
1720 // 3: Reserved
1721 // 2: System Flag
1722 // 1: Enable Auxiliary device interrupt
1723 // 0: Enable Keyboard interrupt )
1724 //
1725 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_WRITE);
1726 if (EFI_ERROR (Status)) {
1727 KeyboardError (ConsoleIn, L"8042 controller command write error!\n\r");
1728 goto Done;
1729 }
1730
1731 Status = KeyboardWrite (ConsoleIn, 0x67);
1732 if (EFI_ERROR (Status)) {
1733 KeyboardError (ConsoleIn, L"8042 controller data write error!\n\r");
1734 goto Done;
1735 }
1736
1737 //
1738 // Clear Memory Scancode Buffer
1739 //
1740 ConsoleIn->ScancodeBufStartPos = 0;
1741 ConsoleIn->ScancodeBufEndPos = KEYBOARD_BUFFER_MAX_COUNT - 1;
1742 ConsoleIn->ScancodeBufCount = 0;
1743 ConsoleIn->Ctrled = FALSE;
1744 ConsoleIn->Alted = FALSE;
1745
1746 //
1747 // Reset the status indicators
1748 //
1749 ConsoleIn->Ctrl = FALSE;
1750 ConsoleIn->Alt = FALSE;
1751 ConsoleIn->Shift = FALSE;
1752 ConsoleIn->CapsLock = FALSE;
1753 ConsoleIn->NumLock = FALSE;
1754 ConsoleIn->ScrollLock = FALSE;
1755 ConsoleIn->LeftShift = FALSE;
1756 ConsoleIn->RightShift = FALSE;
1757 ConsoleIn->LeftLogo = FALSE;
1758 ConsoleIn->RightLogo = FALSE;
1759 ConsoleIn->Menu = FALSE;
1760 ConsoleIn->SysReq = FALSE;
1761
1762 //
1763 // For reseting keyboard is not mandatory before booting OS and sometimes keyboard responses very slow,
1764 // and to support KB hot plug, we need to let the InitKB succeed no matter whether there is a KB device connected
1765 // to system. So we only do the real reseting for keyboard when user asks and there is a real KB connected t system,
1766 // and normally during booting an OS, it's skipped.
1767 //
1768 if (ExtendedVerification && CheckKeyboardConnect (ConsoleIn)) {
1769 //
1770 // Additional verifications for keyboard interface
1771 //
1772 //
1773 // Keyboard Interface Test
1774 //
1775 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_KEYBOARD_INTERFACE_SELF_TEST);
1776 if (EFI_ERROR (Status)) {
1777 KeyboardError (ConsoleIn, L"8042 controller command write error!\n\r");
1778 goto Done;
1779 }
1780
1781 Status = KeyboardWaitForValue (ConsoleIn, 0x00);
1782 if (EFI_ERROR (Status)) {
1783 KeyboardError (
1784 ConsoleIn,
1785 L"Some specific value not aquired from 8042 controller!\n\r"
1786 );
1787 goto Done;
1788 }
1789 //
1790 // Keyboard reset with a BAT(Basic Assurance Test)
1791 //
1792 Status = KeyboardWrite (ConsoleIn, KEYBOARD_8048_COMMAND_RESET);
1793 if (EFI_ERROR (Status)) {
1794 KeyboardError (ConsoleIn, L"8042 controller data write error!\n\r");
1795 goto Done;
1796 }
1797
1798 Status = KeyboardWaitForValue (ConsoleIn, KEYBOARD_8048_RETURN_8042_ACK);
1799 if (EFI_ERROR (Status)) {
1800 KeyboardError (ConsoleIn, L"Some specific value not aquired from 8042 controller!\n\r");
1801 goto Done;
1802 }
1803 //
1804 // wait for BAT completion code
1805 //
1806 mWaitForValueTimeOut = KEYBOARD_BAT_TIMEOUT;
1807
1808 Status = KeyboardWaitForValue (ConsoleIn, KEYBOARD_8048_RETURN_8042_BAT_SUCCESS);
1809 if (EFI_ERROR (Status)) {
1810 KeyboardError (ConsoleIn, L"Keyboard self test failed!\n\r");
1811 goto Done;
1812 }
1813
1814 mWaitForValueTimeOut = KEYBOARD_WAITFORVALUE_TIMEOUT;
1815
1816 //
1817 // Set Keyboard to use Scan Code Set 2
1818 //
1819 Status = KeyboardWrite (ConsoleIn, KEYBOARD_8048_COMMAND_SELECT_SCAN_CODE_SET);
1820 if (EFI_ERROR (Status)) {
1821 KeyboardError (ConsoleIn, L"8042 controller data write error!\n\r");
1822 goto Done;
1823 }
1824
1825 Status = KeyboardWaitForValue (ConsoleIn, KEYBOARD_8048_RETURN_8042_ACK);
1826 if (EFI_ERROR (Status)) {
1827 KeyboardError (ConsoleIn, L"Some specific value not aquired from 8042 controller!\n\r");
1828 goto Done;
1829 }
1830
1831 Status = KeyboardWrite (ConsoleIn, 0x02);
1832 if (EFI_ERROR (Status)) {
1833 KeyboardError (ConsoleIn, L"8042 controller data write error!!\n\r");
1834 goto Done;
1835 }
1836
1837 Status = KeyboardWaitForValue (ConsoleIn, KEYBOARD_8048_RETURN_8042_ACK);
1838 if (EFI_ERROR (Status)) {
1839 KeyboardError (ConsoleIn, L"Some specific value not aquired from 8042 controller!\n\r");
1840 goto Done;
1841 }
1842
1843 //
1844 // Clear Keyboard Scancode Buffer
1845 //
1846 Status = KeyboardWrite (ConsoleIn, KEYBOARD_8048_COMMAND_CLEAR_OUTPUT_DATA);
1847 if (EFI_ERROR (Status)) {
1848 KeyboardError (ConsoleIn, L"8042 controller data write error!\n\r");
1849 goto Done;
1850 }
1851
1852 Status = KeyboardWaitForValue (ConsoleIn, KEYBOARD_8048_RETURN_8042_ACK);
1853 if (EFI_ERROR (Status)) {
1854 KeyboardError (ConsoleIn, L"Some specific value not aquired from 8042 controller!\n\r");
1855 goto Done;
1856 }
1857 //
1858 if (Ps2Policy != NULL) {
1859 if ((Ps2Policy->KeyboardLight & EFI_KEYBOARD_CAPSLOCK) == EFI_KEYBOARD_CAPSLOCK) {
1860 ConsoleIn->CapsLock = TRUE;
1861 }
1862
1863 if ((Ps2Policy->KeyboardLight & EFI_KEYBOARD_NUMLOCK) == EFI_KEYBOARD_NUMLOCK) {
1864 ConsoleIn->NumLock = TRUE;
1865 }
1866
1867 if ((Ps2Policy->KeyboardLight & EFI_KEYBOARD_SCROLLLOCK) == EFI_KEYBOARD_SCROLLLOCK) {
1868 ConsoleIn->ScrollLock = TRUE;
1869 }
1870 }
1871 //
1872 // Update Keyboard Lights
1873 //
1874 Status = UpdateStatusLights (ConsoleIn);
1875 if (EFI_ERROR (Status)) {
1876 KeyboardError (ConsoleIn, L"Update keyboard status lights error!\n\r");
1877 goto Done;
1878 }
1879 }
1880 //
1881 // At last, we can now enable the mouse interface if appropriate
1882 //
1883 Done:
1884
1885 if (mEnableMouseInterface) {
1886 //
1887 // Enable mouse interface
1888 //
1889 Status1 = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_ENABLE_MOUSE_INTERFACE);
1890 if (EFI_ERROR (Status1)) {
1891 KeyboardError (ConsoleIn, L"8042 controller command write error!\n\r");
1892 return EFI_DEVICE_ERROR;
1893 }
1894 }
1895
1896 if (!EFI_ERROR (Status)) {
1897 return EFI_SUCCESS;
1898 } else {
1899 return EFI_DEVICE_ERROR;
1900 }
1901
1902 }
1903
1904 /**
1905 Disable the keyboard interface of the 8042 controller.
1906
1907 @param ConsoleIn The device instance
1908
1909 @return status of issuing disable command
1910
1911 **/
1912 EFI_STATUS
1913 DisableKeyboard (
1914 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
1915 )
1916 {
1917 EFI_STATUS Status;
1918
1919 //
1920 // Disable keyboard interface
1921 //
1922 Status = KeyboardCommand (ConsoleIn, KEYBOARD_8042_COMMAND_DISABLE_KEYBOARD_INTERFACE);
1923 if (EFI_ERROR (Status)) {
1924 KeyboardError (ConsoleIn, L"\n\r");
1925 return EFI_DEVICE_ERROR;
1926 }
1927
1928 return Status;
1929 }
1930
1931 /**
1932 Check whether there is Ps/2 Keyboard device in system by 0xF4 Keyboard Command
1933 If Keyboard receives 0xF4, it will respond with 'ACK'. If it doesn't respond, the device
1934 should not be in system.
1935
1936 @param[in] ConsoleIn Keyboard Private Data Structure
1937
1938 @retval TRUE Keyboard in System.
1939 @retval FALSE Keyboard not in System.
1940 **/
1941 BOOLEAN
1942 EFIAPI
1943 CheckKeyboardConnect (
1944 IN KEYBOARD_CONSOLE_IN_DEV *ConsoleIn
1945 )
1946 {
1947 EFI_STATUS Status;
1948 UINTN WaitForValueTimeOutBcakup;
1949
1950 Status = EFI_SUCCESS;
1951 //
1952 // enable keyboard itself and wait for its ack
1953 // If can't receive ack, Keyboard should not be connected.
1954 //
1955 Status = KeyboardWrite (
1956 ConsoleIn,
1957 KEYBOARD_KBEN
1958 );
1959
1960 if (EFI_ERROR (Status)) {
1961 return FALSE;
1962 }
1963 //
1964 // wait for 1s
1965 //
1966 WaitForValueTimeOutBcakup = mWaitForValueTimeOut;
1967 mWaitForValueTimeOut = KEYBOARD_WAITFORVALUE_TIMEOUT;
1968 Status = KeyboardWaitForValue (
1969 ConsoleIn,
1970 KEYBOARD_CMDECHO_ACK
1971 );
1972 mWaitForValueTimeOut = WaitForValueTimeOutBcakup;
1973
1974 if (EFI_ERROR (Status)) {
1975 return FALSE;
1976 }
1977
1978 return TRUE;
1979 }
1980