Remove the redundant include header: Common/StatusCode.h for Terminal modules.
[mirror_edk2.git] / EdkModulePkg / Universal / Console / Terminal / Dxe / TerminalConIn.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 TerminalConIn.c
15
16 Abstract:
17
18
19 Revision History
20 --*/
21
22 #include "Terminal.h"
23
24 EFI_STATUS
25 EFIAPI
26 TerminalConInReset (
27 IN EFI_SIMPLE_TEXT_IN_PROTOCOL *This,
28 IN BOOLEAN ExtendedVerification
29 )
30 /*++
31 Routine Description:
32
33 Implements EFI_SIMPLE_TEXT_IN_PROTOCOL.Reset().
34 This driver only perform dependent serial device reset regardless of
35 the value of ExtendeVerification
36
37 Arguments:
38
39 This - Indicates the calling context.
40
41 ExtendedVerification - Skip by this driver.
42
43 Returns:
44
45 EFI_SUCCESS
46 The reset operation succeeds.
47
48 EFI_DEVICE_ERROR
49 The dependent serial port reset fails.
50
51 --*/
52 {
53 EFI_STATUS Status;
54 TERMINAL_DEV *TerminalDevice;
55
56 TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (This);
57
58 //
59 // Report progress code here
60 //
61 Status = REPORT_STATUS_CODE_WITH_DEVICE_PATH (
62 EFI_PROGRESS_CODE,
63 EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_RESET,
64 TerminalDevice->DevicePath
65 );
66
67 Status = TerminalDevice->SerialIo->Reset (TerminalDevice->SerialIo);
68
69 //
70 // clear all the internal buffer for keys
71 //
72 InitializeRawFiFo (TerminalDevice);
73 InitializeUnicodeFiFo (TerminalDevice);
74 InitializeEfiKeyFiFo (TerminalDevice);
75
76 if (EFI_ERROR (Status)) {
77 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
78 EFI_ERROR_CODE | EFI_ERROR_MINOR,
79 EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_CONTROLLER_ERROR,
80 TerminalDevice->DevicePath
81 );
82 }
83
84 return Status;
85 }
86
87 EFI_STATUS
88 EFIAPI
89 TerminalConInReadKeyStroke (
90 IN EFI_SIMPLE_TEXT_IN_PROTOCOL *This,
91 OUT EFI_INPUT_KEY *Key
92 )
93 /*++
94 Routine Description:
95
96 Implements EFI_SIMPLE_TEXT_IN_PROTOCOL.ReadKeyStroke().
97
98 Arguments:
99
100 This - Indicates the calling context.
101
102 Key - A pointer to a buffer that is filled in with the keystroke
103 information for the key that was sent from terminal.
104
105 Returns:
106
107 EFI_SUCCESS
108 The keystroke information is returned successfully.
109
110 EFI_NOT_READY
111 There is no keystroke data available.
112
113 EFI_DEVICE_ERROR
114 The dependent serial device encounters error.
115
116 --*/
117 {
118 TERMINAL_DEV *TerminalDevice;
119 EFI_STATUS Status;
120
121 //
122 // Initialize *Key to nonsense value.
123 //
124 Key->ScanCode = SCAN_NULL;
125 Key->UnicodeChar = 0;
126 //
127 // get TERMINAL_DEV from "This" parameter.
128 //
129 TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (This);
130
131 Status = TerminalConInCheckForKey (This);
132 if (EFI_ERROR (Status)) {
133 return EFI_NOT_READY;
134 }
135
136 EfiKeyFiFoRemoveOneKey (TerminalDevice, Key);
137
138 return EFI_SUCCESS;
139
140 }
141
142 VOID
143 TranslateRawDataToEfiKey (
144 IN TERMINAL_DEV *TerminalDevice
145 )
146 /*++
147 Step1: Turn raw data into Unicode (according to different encode).
148 Step2: Translate Unicode into key information.
149 (according to different terminal standard).
150 --*/
151 {
152 switch (TerminalDevice->TerminalType) {
153
154 case PcAnsiType:
155 case VT100Type:
156 case VT100PlusType:
157 AnsiRawDataToUnicode (TerminalDevice);
158 UnicodeToEfiKey (TerminalDevice);
159 break;
160
161 case VTUTF8Type:
162 //
163 // Process all the raw data in the RawFIFO,
164 // put the processed key into UnicodeFIFO.
165 //
166 VTUTF8RawDataToUnicode (TerminalDevice);
167
168 //
169 // Translate all the Unicode data in the UnicodeFIFO to Efi key,
170 // then put into EfiKeyFIFO.
171 //
172 UnicodeToEfiKey (TerminalDevice);
173
174 break;
175 }
176 }
177
178 VOID
179 EFIAPI
180 TerminalConInWaitForKey (
181 IN EFI_EVENT Event,
182 IN VOID *Context
183 )
184 /*++
185 Routine Description:
186
187 Event notification function for EFI_SIMPLE_TEXT_IN_PROTOCOL.WaitForKey event
188 Signal the event if there is key available
189
190 Arguments:
191
192 Event - Indicates the event that invoke this function.
193
194 Context - Indicates the calling context.
195
196 Returns:
197
198 N/A
199
200 --*/
201 {
202 //
203 // Someone is waiting on the keystroke event, if there's
204 // a key pending, signal the event
205 //
206 // Context is the pointer to EFI_SIMPLE_TEXT_IN_PROTOCOL
207 //
208 if (!EFI_ERROR (TerminalConInCheckForKey (Context))) {
209
210 gBS->SignalEvent (Event);
211 }
212 }
213
214 EFI_STATUS
215 TerminalConInCheckForKey (
216 IN EFI_SIMPLE_TEXT_IN_PROTOCOL *This
217 )
218 /*++
219 Routine Description:
220
221 Check for a pending key in the Efi Key FIFO or Serial device buffer.
222
223 Arguments:
224
225 This - Indicates the calling context.
226
227 Returns:
228
229 EFI_SUCCESS
230 There is key pending.
231
232 EFI_NOT_READY
233 There is no key pending.
234
235 EFI_DEVICE_ERROR
236
237 --*/
238 {
239 EFI_STATUS Status;
240 TERMINAL_DEV *TerminalDevice;
241 UINT32 Control;
242 UINT8 Input;
243 EFI_SERIAL_IO_MODE *Mode;
244 EFI_SERIAL_IO_PROTOCOL *SerialIo;
245 UINTN SerialInTimeOut;
246
247 TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (This);
248
249 SerialIo = TerminalDevice->SerialIo;
250 if (SerialIo == NULL) {
251 return EFI_DEVICE_ERROR;
252 }
253 //
254 // if current timeout value for serial device is not identical with
255 // the value saved in TERMINAL_DEV structure, then recalculate the
256 // timeout value again and set serial attribute according to this value.
257 //
258 Mode = SerialIo->Mode;
259 if (Mode->Timeout != TerminalDevice->SerialInTimeOut) {
260
261 SerialInTimeOut = 0;
262 if (Mode->BaudRate != 0) {
263 SerialInTimeOut = (1 + Mode->DataBits + Mode->StopBits) * 2 * 1000000 / (UINTN) Mode->BaudRate;
264 }
265
266 Status = SerialIo->SetAttributes (
267 SerialIo,
268 Mode->BaudRate,
269 Mode->ReceiveFifoDepth,
270 (UINT32) SerialInTimeOut,
271 Mode->Parity,
272 (UINT8) Mode->DataBits,
273 Mode->StopBits
274 );
275
276 if (EFI_ERROR (Status)) {
277 TerminalDevice->SerialInTimeOut = 0;
278 } else {
279 TerminalDevice->SerialInTimeOut = SerialInTimeOut;
280 }
281 }
282 //
283 // check whether serial buffer is empty
284 //
285 Status = SerialIo->GetControl (SerialIo, &Control);
286
287 if (Control & EFI_SERIAL_INPUT_BUFFER_EMPTY) {
288 //
289 // Translate all the raw data in RawFIFO into EFI Key,
290 // according to different terminal type supported.
291 //
292 TranslateRawDataToEfiKey (TerminalDevice);
293
294 //
295 // if there is pre-fetched Efi Key in EfiKeyFIFO buffer,
296 // return directly.
297 //
298 if (!IsEfiKeyFiFoEmpty (TerminalDevice)) {
299 return EFI_SUCCESS;
300 } else {
301 return EFI_NOT_READY;
302 }
303 }
304 //
305 // Fetch all the keys in the serial buffer,
306 // and insert the byte stream into RawFIFO.
307 //
308 do {
309
310 Status = GetOneKeyFromSerial (TerminalDevice->SerialIo, &Input);
311
312 if (EFI_ERROR (Status)) {
313 if (Status == EFI_DEVICE_ERROR) {
314 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
315 EFI_ERROR_CODE | EFI_ERROR_MINOR,
316 EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_INPUT_ERROR,
317 TerminalDevice->DevicePath
318 );
319 }
320 break;
321 }
322
323 RawFiFoInsertOneKey (TerminalDevice, Input);
324 } while (TRUE);
325
326 //
327 // Translate all the raw data in RawFIFO into EFI Key,
328 // according to different terminal type supported.
329 //
330 TranslateRawDataToEfiKey (TerminalDevice);
331
332 if (IsEfiKeyFiFoEmpty (TerminalDevice)) {
333 return EFI_NOT_READY;
334 }
335
336 return EFI_SUCCESS;
337 }
338
339 EFI_STATUS
340 GetOneKeyFromSerial (
341 EFI_SERIAL_IO_PROTOCOL *SerialIo,
342 UINT8 *Input
343 )
344 /*++
345 Get one key out of serial buffer.
346 If serial buffer is empty, return EFI_NOT_READY;
347 if reading serial buffer encounter error, returns EFI_DEVICE_ERROR;
348 if reading serial buffer successfully, put the fetched key to
349 the parameter "Input", and return EFI_SUCCESS.
350 --*/
351 {
352 EFI_STATUS Status;
353 UINTN Size;
354
355 Size = 1;
356 *Input = 0;
357
358 Status = SerialIo->Read (SerialIo, &Size, Input);
359
360 if (EFI_ERROR (Status)) {
361
362 if (Status == EFI_TIMEOUT) {
363 return EFI_NOT_READY;
364 }
365
366 return EFI_DEVICE_ERROR;
367
368 }
369
370 if (*Input == 0) {
371 return EFI_NOT_READY;
372 }
373
374 return EFI_SUCCESS;
375 }
376
377 BOOLEAN
378 RawFiFoInsertOneKey (
379 TERMINAL_DEV *TerminalDevice,
380 UINT8 Input
381 )
382 /*++
383 Insert one byte raw data into the Raw Data FIFO.
384 If FIFO is FULL before data insertion,
385 return FALSE, and the key is lost.
386 --*/
387 {
388 UINT8 Tail;
389
390 Tail = TerminalDevice->RawFiFo.Tail;
391
392 if (IsRawFiFoFull (TerminalDevice)) {
393 //
394 // Raw FIFO is full
395 //
396 return FALSE;
397 }
398
399 TerminalDevice->RawFiFo.Data[Tail] = Input;
400
401 TerminalDevice->RawFiFo.Tail = (UINT8) ((Tail + 1) % (RAW_FIFO_MAX_NUMBER + 1));
402
403 return TRUE;
404 }
405
406 BOOLEAN
407 RawFiFoRemoveOneKey (
408 TERMINAL_DEV *TerminalDevice,
409 UINT8 *Output
410 )
411 /*++
412 Remove one byte raw data out of the Raw Data FIFO.
413 If FIFO buffer is empty before remove operation,
414 return FALSE.
415 --*/
416 {
417 UINT8 Head;
418
419 Head = TerminalDevice->RawFiFo.Head;
420
421 if (IsRawFiFoEmpty (TerminalDevice)) {
422 //
423 // FIFO is empty
424 //
425 *Output = 0;
426 return FALSE;
427 }
428
429 *Output = TerminalDevice->RawFiFo.Data[Head];
430
431 TerminalDevice->RawFiFo.Head = (UINT8) ((Head + 1) % (RAW_FIFO_MAX_NUMBER + 1));
432
433 return TRUE;
434 }
435
436 BOOLEAN
437 IsRawFiFoEmpty (
438 TERMINAL_DEV *TerminalDevice
439 )
440 /*++
441 Clarify whether FIFO buffer is empty.
442 --*/
443 {
444 if (TerminalDevice->RawFiFo.Head == TerminalDevice->RawFiFo.Tail) {
445 return TRUE;
446 } else {
447 return FALSE;
448 }
449 }
450
451 BOOLEAN
452 IsRawFiFoFull (
453 TERMINAL_DEV *TerminalDevice
454 )
455 /*++
456 Clarify whether FIFO buffer is full.
457 --*/
458 {
459 UINT8 Tail;
460 UINT8 Head;
461
462 Tail = TerminalDevice->RawFiFo.Tail;
463 Head = TerminalDevice->RawFiFo.Head;
464
465 if (((Tail + 1) % (RAW_FIFO_MAX_NUMBER + 1)) == Head) {
466
467 return TRUE;
468 }
469
470 return FALSE;
471 }
472
473 BOOLEAN
474 EfiKeyFiFoInsertOneKey (
475 TERMINAL_DEV *TerminalDevice,
476 EFI_INPUT_KEY Key
477 )
478 /*++
479 Insert one pre-fetched key into the FIFO buffer.
480 If FIFO buffer is FULL before key insertion,
481 return FALSE, and the key is lost.
482 --*/
483 {
484 UINT8 Tail;
485
486 Tail = TerminalDevice->EfiKeyFiFo.Tail;
487
488 if (IsEfiKeyFiFoFull (TerminalDevice)) {
489 //
490 // Efi Key FIFO is full
491 //
492 return FALSE;
493 }
494
495 TerminalDevice->EfiKeyFiFo.Data[Tail] = Key;
496
497 TerminalDevice->EfiKeyFiFo.Tail = (UINT8) ((Tail + 1) % (FIFO_MAX_NUMBER + 1));
498
499 return TRUE;
500 }
501
502 BOOLEAN
503 EfiKeyFiFoRemoveOneKey (
504 TERMINAL_DEV *TerminalDevice,
505 EFI_INPUT_KEY *Output
506 )
507 /*++
508 Remove one pre-fetched key out of the FIFO buffer.
509 If FIFO buffer is empty before remove operation,
510 return FALSE.
511 --*/
512 {
513 UINT8 Head;
514
515 Head = TerminalDevice->EfiKeyFiFo.Head;
516
517 if (IsEfiKeyFiFoEmpty (TerminalDevice)) {
518 //
519 // FIFO is empty
520 //
521 Output->ScanCode = SCAN_NULL;
522 Output->UnicodeChar = 0;
523 return FALSE;
524 }
525
526 *Output = TerminalDevice->EfiKeyFiFo.Data[Head];
527
528 TerminalDevice->EfiKeyFiFo.Head = (UINT8) ((Head + 1) % (FIFO_MAX_NUMBER + 1));
529
530 return TRUE;
531 }
532
533 BOOLEAN
534 IsEfiKeyFiFoEmpty (
535 TERMINAL_DEV *TerminalDevice
536 )
537 /*++
538 Clarify whether FIFO buffer is empty.
539 --*/
540 {
541 if (TerminalDevice->EfiKeyFiFo.Head == TerminalDevice->EfiKeyFiFo.Tail) {
542 return TRUE;
543 } else {
544 return FALSE;
545 }
546 }
547
548 BOOLEAN
549 IsEfiKeyFiFoFull (
550 TERMINAL_DEV *TerminalDevice
551 )
552 /*++
553 Clarify whether FIFO buffer is full.
554 --*/
555 {
556 UINT8 Tail;
557 UINT8 Head;
558
559 Tail = TerminalDevice->EfiKeyFiFo.Tail;
560 Head = TerminalDevice->EfiKeyFiFo.Head;
561
562 if (((Tail + 1) % (FIFO_MAX_NUMBER + 1)) == Head) {
563
564 return TRUE;
565 }
566
567 return FALSE;
568 }
569
570 BOOLEAN
571 UnicodeFiFoInsertOneKey (
572 TERMINAL_DEV *TerminalDevice,
573 UINT16 Input
574 )
575 /*++
576 Insert one pre-fetched key into the FIFO buffer.
577 If FIFO buffer is FULL before key insertion,
578 return FALSE, and the key is lost.
579 --*/
580 {
581 UINT8 Tail;
582
583 Tail = TerminalDevice->UnicodeFiFo.Tail;
584
585 if (IsUnicodeFiFoFull (TerminalDevice)) {
586 //
587 // Unicode FIFO is full
588 //
589 return FALSE;
590 }
591
592 TerminalDevice->UnicodeFiFo.Data[Tail] = Input;
593
594 TerminalDevice->UnicodeFiFo.Tail = (UINT8) ((Tail + 1) % (FIFO_MAX_NUMBER + 1));
595
596 return TRUE;
597 }
598
599 BOOLEAN
600 UnicodeFiFoRemoveOneKey (
601 TERMINAL_DEV *TerminalDevice,
602 UINT16 *Output
603 )
604 /*++
605 Remove one pre-fetched key out of the FIFO buffer.
606 If FIFO buffer is empty before remove operation,
607 return FALSE.
608 --*/
609 {
610 UINT8 Head;
611
612 Head = TerminalDevice->UnicodeFiFo.Head;
613
614 if (IsUnicodeFiFoEmpty (TerminalDevice)) {
615 //
616 // FIFO is empty
617 //
618 Output = NULL;
619 return FALSE;
620 }
621
622 *Output = TerminalDevice->UnicodeFiFo.Data[Head];
623
624 TerminalDevice->UnicodeFiFo.Head = (UINT8) ((Head + 1) % (FIFO_MAX_NUMBER + 1));
625
626 return TRUE;
627 }
628
629 BOOLEAN
630 IsUnicodeFiFoEmpty (
631 TERMINAL_DEV *TerminalDevice
632 )
633 /*++
634 Clarify whether FIFO buffer is empty.
635 --*/
636 {
637 if (TerminalDevice->UnicodeFiFo.Head == TerminalDevice->UnicodeFiFo.Tail) {
638 return TRUE;
639 } else {
640 return FALSE;
641 }
642 }
643
644 BOOLEAN
645 IsUnicodeFiFoFull (
646 TERMINAL_DEV *TerminalDevice
647 )
648 /*++
649 Clarify whether FIFO buffer is full.
650 --*/
651 {
652 UINT8 Tail;
653 UINT8 Head;
654
655 Tail = TerminalDevice->UnicodeFiFo.Tail;
656 Head = TerminalDevice->UnicodeFiFo.Head;
657
658 if (((Tail + 1) % (FIFO_MAX_NUMBER + 1)) == Head) {
659
660 return TRUE;
661 }
662
663 return FALSE;
664 }
665
666 UINT8
667 UnicodeFiFoGetKeyCount (
668 TERMINAL_DEV *TerminalDevice
669 )
670 {
671 UINT8 Tail;
672 UINT8 Head;
673
674 Tail = TerminalDevice->UnicodeFiFo.Tail;
675 Head = TerminalDevice->UnicodeFiFo.Head;
676
677 if (Tail >= Head) {
678 return (UINT8) (Tail - Head);
679 } else {
680 return (UINT8) (Tail + FIFO_MAX_NUMBER + 1 - Head);
681 }
682 }
683
684 VOID
685 UnicodeToEfiKeyFlushState (
686 IN TERMINAL_DEV *TerminalDevice
687 )
688 {
689 EFI_INPUT_KEY Key;
690
691 if (TerminalDevice->InputState & INPUT_STATE_ESC) {
692 Key.ScanCode = SCAN_ESC;
693 Key.UnicodeChar = 0;
694 EfiKeyFiFoInsertOneKey (TerminalDevice, Key);
695 }
696
697 if (TerminalDevice->InputState & INPUT_STATE_CSI) {
698 Key.ScanCode = SCAN_NULL;
699 Key.UnicodeChar = CSI;
700 EfiKeyFiFoInsertOneKey (TerminalDevice, Key);
701 }
702
703 if (TerminalDevice->InputState & INPUT_STATE_LEFTOPENBRACKET) {
704 Key.ScanCode = SCAN_NULL;
705 Key.UnicodeChar = LEFTOPENBRACKET;
706 EfiKeyFiFoInsertOneKey (TerminalDevice, Key);
707 }
708
709 if (TerminalDevice->InputState & INPUT_STATE_O) {
710 Key.ScanCode = SCAN_NULL;
711 Key.UnicodeChar = 'O';
712 EfiKeyFiFoInsertOneKey (TerminalDevice, Key);
713 }
714
715 if (TerminalDevice->InputState & INPUT_STATE_2) {
716 Key.ScanCode = SCAN_NULL;
717 Key.UnicodeChar = '2';
718 EfiKeyFiFoInsertOneKey (TerminalDevice, Key);
719 }
720
721 gBS->SetTimer (
722 TerminalDevice->TwoSecondTimeOut,
723 TimerCancel,
724 0
725 );
726
727 TerminalDevice->InputState = INPUT_STATE_DEFAULT;
728 }
729
730 VOID
731 UnicodeToEfiKey (
732 IN TERMINAL_DEV *TerminalDevice
733 )
734 /*++
735 Routine Description:
736
737 Converts a stream of Unicode characters from a terminal input device into EFI Keys that
738 can be read through the Simple Input Protocol. The table below shows the keyboard
739 input mappings that this function supports. If the ESC sequence listed in one of the
740 columns is presented, then it is translated into the coorespoding EFI Scan Code. If a
741 matching sequence is not found, then the raw key strokes are converted into EFI Keys.
742
743 2 seconds are allowed for an ESC sequence to be completed. If the ESC sequence is not
744 completed in 2 seconds, then the raw key strokes of the partial ESC sequence are
745 converted into EFI Keys.
746
747 There is one special input sequence that will force the system to reset.
748 This is ESC R ESC r ESC R.
749
750 Arguments:
751
752 TerminaDevice : The terminal device to use to translate raw input into EFI Keys
753
754 Returns:
755
756 None
757
758 Symbols used in table below
759 ===========================
760 ESC = 0x1B
761 CSI = 0x9B
762 DEL = 0x7f
763 ^ = CTRL
764
765 +=========+======+===========+==========+==========+
766 | | EFI | EFI 1.10 | | |
767 | | Scan | | VT100+ | |
768 | KEY | Code | PC ANSI | VTUTF8 | VT100 |
769 +=========+======+===========+==========+==========+
770 | NULL | 0x00 | | | |
771 | UP | 0x01 | ESC [ A | ESC [ A | ESC [ A |
772 | DOWN | 0x02 | ESC [ B | ESC [ B | ESC [ B |
773 | RIGHT | 0x03 | ESC [ C | ESC [ C | ESC [ C |
774 | LEFT | 0x04 | ESC [ D | ESC [ D | ESC [ D |
775 | HOME | 0x05 | ESC [ H | ESC h | ESC [ H |
776 | END | 0x06 | ESC [ F | ESC k | ESC [ K |
777 | INSERT | 0x07 | ESC [ @ | ESC + | ESC [ @ |
778 | | | ESC [ L | | ESC [ L |
779 | DELETE | 0x08 | ESC [ X | ESC - | ESC [ P |
780 | PG UP | 0x09 | ESC [ I | ESC ? | ESC [ V |
781 | | | | | ESC [ ? |
782 | PG DOWN | 0x0A | ESC [ G | ESC / | ESC [ U |
783 | | | | | ESC [ / |
784 | F1 | 0x0B | ESC [ M | ESC 1 | ESC O P |
785 | F2 | 0x0C | ESC [ N | ESC 2 | ESC O Q |
786 | F3 | 0x0D | ESC [ O | ESC 3 | ESC O w |
787 | F4 | 0x0E | ESC [ P | ESC 4 | ESC O x |
788 | F5 | 0x0F | ESC [ Q | ESC 5 | ESC O t |
789 | F6 | 0x10 | ESC [ R | ESC 6 | ESC O u |
790 | F7 | 0x11 | ESC [ S | ESC 7 | ESC O q |
791 | F8 | 0x12 | ESC [ T | ESC 8 | ESC O r |
792 | F9 | 0x13 | ESC [ U | ESC 9 | ESC O p |
793 | F10 | 0x14 | ESC [ V | ESC 0 | ESC O M |
794 | Escape | 0x17 | ESC | ESC | ESC |
795 +=========+======+===========+==========+=========+
796
797 Special Mappings
798 ================
799 ESC R ESC r ESC R = Reset System
800
801 --*/
802 {
803 EFI_STATUS Status;
804 EFI_STATUS TimerStatus;
805 UINT16 UnicodeChar;
806 EFI_INPUT_KEY Key;
807 BOOLEAN SetDefaultResetState;
808
809 TimerStatus = gBS->CheckEvent (TerminalDevice->TwoSecondTimeOut);
810
811 if (!EFI_ERROR (TimerStatus)) {
812 UnicodeToEfiKeyFlushState (TerminalDevice);
813 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
814 }
815
816 while (!IsUnicodeFiFoEmpty(TerminalDevice)) {
817
818 if (TerminalDevice->InputState != INPUT_STATE_DEFAULT) {
819 //
820 // Check to see if the 2 second timer has expired
821 //
822 TimerStatus = gBS->CheckEvent (TerminalDevice->TwoSecondTimeOut);
823 if (!EFI_ERROR (TimerStatus)) {
824 UnicodeToEfiKeyFlushState (TerminalDevice);
825 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
826 }
827 }
828
829 //
830 // Fetch one Unicode character from the Unicode FIFO
831 //
832 UnicodeFiFoRemoveOneKey (TerminalDevice,&UnicodeChar);
833
834 SetDefaultResetState = TRUE;
835
836 switch (TerminalDevice->InputState) {
837 case INPUT_STATE_DEFAULT:
838
839 break;
840
841 case INPUT_STATE_ESC:
842
843 if (UnicodeChar == LEFTOPENBRACKET) {
844 TerminalDevice->InputState |= INPUT_STATE_LEFTOPENBRACKET;
845 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
846 continue;
847 }
848
849 if (UnicodeChar == 'O' && TerminalDevice->TerminalType == VT100Type) {
850 TerminalDevice->InputState |= INPUT_STATE_O;
851 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
852 continue;
853 }
854
855 Key.ScanCode = SCAN_NULL;
856
857 if (TerminalDevice->TerminalType == VT100PlusType ||
858 TerminalDevice->TerminalType == VTUTF8Type) {
859 switch (UnicodeChar) {
860 case '1':
861 Key.ScanCode = SCAN_F1;
862 break;
863 case '2':
864 Key.ScanCode = SCAN_F2;
865 break;
866 case '3':
867 Key.ScanCode = SCAN_F3;
868 break;
869 case '4':
870 Key.ScanCode = SCAN_F4;
871 break;
872 case '5':
873 Key.ScanCode = SCAN_F5;
874 break;
875 case '6':
876 Key.ScanCode = SCAN_F6;
877 break;
878 case '7':
879 Key.ScanCode = SCAN_F7;
880 break;
881 case '8':
882 Key.ScanCode = SCAN_F8;
883 break;
884 case '9':
885 Key.ScanCode = SCAN_F9;
886 break;
887 case '0':
888 Key.ScanCode = SCAN_F10;
889 break;
890 case 'h':
891 Key.ScanCode = SCAN_HOME;
892 break;
893 case 'k':
894 Key.ScanCode = SCAN_END;
895 break;
896 case '+':
897 Key.ScanCode = SCAN_INSERT;
898 break;
899 case '-':
900 Key.ScanCode = SCAN_DELETE;
901 break;
902 case '/':
903 Key.ScanCode = SCAN_PAGE_DOWN;
904 break;
905 case '?':
906 Key.ScanCode = SCAN_PAGE_UP;
907 break;
908 default :
909 break;
910 }
911 }
912
913 switch (UnicodeChar) {
914 case 'R':
915 if (TerminalDevice->ResetState == RESET_STATE_DEFAULT) {
916 TerminalDevice->ResetState = RESET_STATE_ESC_R;
917 SetDefaultResetState = FALSE;
918 } else if (TerminalDevice->ResetState == RESET_STATE_ESC_R_ESC_r) {
919 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
920 }
921 Key.ScanCode = SCAN_NULL;
922 break;
923 case 'r':
924 if (TerminalDevice->ResetState == RESET_STATE_ESC_R) {
925 TerminalDevice->ResetState = RESET_STATE_ESC_R_ESC_r;
926 SetDefaultResetState = FALSE;
927 }
928 Key.ScanCode = SCAN_NULL;
929 break;
930 default :
931 break;
932 }
933
934 if (SetDefaultResetState) {
935 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
936 }
937
938 if (Key.ScanCode != SCAN_NULL) {
939 Key.UnicodeChar = 0;
940 EfiKeyFiFoInsertOneKey (TerminalDevice,Key);
941 TerminalDevice->InputState = INPUT_STATE_DEFAULT;
942 UnicodeToEfiKeyFlushState (TerminalDevice);
943 continue;
944 }
945
946 UnicodeToEfiKeyFlushState (TerminalDevice);
947
948 break;
949
950 case INPUT_STATE_ESC | INPUT_STATE_O:
951
952 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
953
954 Key.ScanCode = SCAN_NULL;
955
956 if (TerminalDevice->TerminalType == VT100Type) {
957 switch (UnicodeChar) {
958 case 'P':
959 Key.ScanCode = SCAN_F1;
960 break;
961 case 'Q':
962 Key.ScanCode = SCAN_F2;
963 break;
964 case 'w':
965 Key.ScanCode = SCAN_F3;
966 break;
967 case 'x':
968 Key.ScanCode = SCAN_F4;
969 break;
970 case 't':
971 Key.ScanCode = SCAN_F5;
972 break;
973 case 'u':
974 Key.ScanCode = SCAN_F6;
975 break;
976 case 'q':
977 Key.ScanCode = SCAN_F7;
978 break;
979 case 'r':
980 Key.ScanCode = SCAN_F8;
981 break;
982 case 'p':
983 Key.ScanCode = SCAN_F9;
984 break;
985 case 'M':
986 Key.ScanCode = SCAN_F10;
987 break;
988 default :
989 break;
990 }
991 }
992
993 if (Key.ScanCode != SCAN_NULL) {
994 Key.UnicodeChar = 0;
995 EfiKeyFiFoInsertOneKey (TerminalDevice,Key);
996 TerminalDevice->InputState = INPUT_STATE_DEFAULT;
997 UnicodeToEfiKeyFlushState (TerminalDevice);
998 continue;
999 }
1000
1001 UnicodeToEfiKeyFlushState (TerminalDevice);
1002
1003 break;
1004
1005 case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET:
1006
1007 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
1008
1009 Key.ScanCode = SCAN_NULL;
1010
1011 if (TerminalDevice->TerminalType == PcAnsiType ||
1012 TerminalDevice->TerminalType == VT100Type ||
1013 TerminalDevice->TerminalType == VT100PlusType ||
1014 TerminalDevice->TerminalType == VTUTF8Type) {
1015 switch (UnicodeChar) {
1016 case 'A':
1017 Key.ScanCode = SCAN_UP;
1018 break;
1019 case 'B':
1020 Key.ScanCode = SCAN_DOWN;
1021 break;
1022 case 'C':
1023 Key.ScanCode = SCAN_RIGHT;
1024 break;
1025 case 'D':
1026 Key.ScanCode = SCAN_LEFT;
1027 break;
1028 case 'H':
1029 if (TerminalDevice->TerminalType == PcAnsiType ||
1030 TerminalDevice->TerminalType == VT100Type) {
1031 Key.ScanCode = SCAN_HOME;
1032 }
1033 break;
1034 case 'F':
1035 if (TerminalDevice->TerminalType == PcAnsiType) {
1036 Key.ScanCode = SCAN_END;
1037 }
1038 break;
1039 case 'K':
1040 if (TerminalDevice->TerminalType == VT100Type) {
1041 Key.ScanCode = SCAN_END;
1042 }
1043 break;
1044 case 'L':
1045 case '@':
1046 if (TerminalDevice->TerminalType == PcAnsiType ||
1047 TerminalDevice->TerminalType == VT100Type) {
1048 Key.ScanCode = SCAN_INSERT;
1049 }
1050 break;
1051 case 'X':
1052 if (TerminalDevice->TerminalType == PcAnsiType) {
1053 Key.ScanCode = SCAN_DELETE;
1054 }
1055 break;
1056 case 'P':
1057 if (TerminalDevice->TerminalType == VT100Type) {
1058 Key.ScanCode = SCAN_DELETE;
1059 } else if (TerminalDevice->TerminalType == PcAnsiType) {
1060 Key.ScanCode = SCAN_F4;
1061 }
1062 break;
1063 case 'I':
1064 if (TerminalDevice->TerminalType == PcAnsiType) {
1065 Key.ScanCode = SCAN_PAGE_UP;
1066 }
1067 break;
1068 case 'V':
1069 if (TerminalDevice->TerminalType == PcAnsiType) {
1070 Key.ScanCode = SCAN_F10;
1071 }
1072 case '?':
1073 if (TerminalDevice->TerminalType == VT100Type) {
1074 Key.ScanCode = SCAN_PAGE_UP;
1075 }
1076 break;
1077 case 'G':
1078 if (TerminalDevice->TerminalType == PcAnsiType) {
1079 Key.ScanCode = SCAN_PAGE_DOWN;
1080 }
1081 break;
1082 case 'U':
1083 if (TerminalDevice->TerminalType == PcAnsiType) {
1084 Key.ScanCode = SCAN_F9;
1085 }
1086 case '/':
1087 if (TerminalDevice->TerminalType == VT100Type) {
1088 Key.ScanCode = SCAN_PAGE_DOWN;
1089 }
1090 break;
1091 case 'M':
1092 if (TerminalDevice->TerminalType == PcAnsiType) {
1093 Key.ScanCode = SCAN_F1;
1094 }
1095 break;
1096 case 'N':
1097 if (TerminalDevice->TerminalType == PcAnsiType) {
1098 Key.ScanCode = SCAN_F2;
1099 }
1100 break;
1101 case 'O':
1102 if (TerminalDevice->TerminalType == PcAnsiType) {
1103 Key.ScanCode = SCAN_F3;
1104 }
1105 break;
1106 case 'Q':
1107 if (TerminalDevice->TerminalType == PcAnsiType) {
1108 Key.ScanCode = SCAN_F5;
1109 }
1110 break;
1111 case 'R':
1112 if (TerminalDevice->TerminalType == PcAnsiType) {
1113 Key.ScanCode = SCAN_F6;
1114 }
1115 break;
1116 case 'S':
1117 if (TerminalDevice->TerminalType == PcAnsiType) {
1118 Key.ScanCode = SCAN_F7;
1119 }
1120 break;
1121 case 'T':
1122 if (TerminalDevice->TerminalType == PcAnsiType) {
1123 Key.ScanCode = SCAN_F8;
1124 }
1125 break;
1126 default :
1127 break;
1128 }
1129 }
1130
1131 if (Key.ScanCode != SCAN_NULL) {
1132 Key.UnicodeChar = 0;
1133 EfiKeyFiFoInsertOneKey (TerminalDevice,Key);
1134 TerminalDevice->InputState = INPUT_STATE_DEFAULT;
1135 UnicodeToEfiKeyFlushState (TerminalDevice);
1136 continue;
1137 }
1138
1139 UnicodeToEfiKeyFlushState (TerminalDevice);
1140
1141 break;
1142
1143
1144 default:
1145 //
1146 // Invalid state. This should never happen.
1147 //
1148 ASSERT (FALSE);
1149
1150 UnicodeToEfiKeyFlushState (TerminalDevice);
1151
1152 break;
1153 }
1154
1155 if (UnicodeChar == ESC) {
1156 TerminalDevice->InputState = INPUT_STATE_ESC;
1157 }
1158
1159 if (TerminalDevice->InputState != INPUT_STATE_DEFAULT) {
1160 Status = gBS->SetTimer(
1161 TerminalDevice->TwoSecondTimeOut,
1162 TimerRelative,
1163 (UINT64)20000000
1164 );
1165 continue;
1166 }
1167
1168 if (SetDefaultResetState) {
1169 TerminalDevice->ResetState = RESET_STATE_DEFAULT;
1170 }
1171
1172 if (UnicodeChar == DEL) {
1173 Key.ScanCode = SCAN_DELETE;
1174 Key.UnicodeChar = 0;
1175 } else {
1176 Key.ScanCode = SCAN_NULL;
1177 Key.UnicodeChar = UnicodeChar;
1178 }
1179
1180 EfiKeyFiFoInsertOneKey (TerminalDevice,Key);
1181 }
1182 }