Remove the redundant include header: Common/StatusCode.h for Terminal modules.
[mirror_edk2.git] / EdkModulePkg / Universal / Console / Terminal / Dxe / TerminalConOut.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 TerminalConOut.c
15
16 Abstract:
17
18
19 Revision History
20 --*/
21
22 #include "Terminal.h"
23
24 //
25 // This list is used to define the valid extend chars.
26 // It also provides a mapping from Unicode to PCANSI or
27 // ASCII. The ASCII mapping we just made up.
28 //
29 //
30 STATIC UNICODE_TO_CHAR UnicodeToPcAnsiOrAscii[] = {
31 { BOXDRAW_HORIZONTAL, 0xc4, L'-' },
32 { BOXDRAW_VERTICAL, 0xb3, L'|' },
33 { BOXDRAW_DOWN_RIGHT, 0xda, L'/' },
34 { BOXDRAW_DOWN_LEFT, 0xbf, L'\\' },
35 { BOXDRAW_UP_RIGHT, 0xc0, L'\\' },
36 { BOXDRAW_UP_LEFT, 0xd9, L'/' },
37 { BOXDRAW_VERTICAL_RIGHT, 0xc3, L'|' },
38 { BOXDRAW_VERTICAL_LEFT, 0xb4, L'|' },
39 { BOXDRAW_DOWN_HORIZONTAL, 0xc2, L'+' },
40 { BOXDRAW_UP_HORIZONTAL, 0xc1, L'+' },
41 { BOXDRAW_VERTICAL_HORIZONTAL, 0xc5, L'+' },
42 { BOXDRAW_DOUBLE_HORIZONTAL, 0xcd, L'-' },
43 { BOXDRAW_DOUBLE_VERTICAL, 0xba, L'|' },
44 { BOXDRAW_DOWN_RIGHT_DOUBLE, 0xd5, L'/' },
45 { BOXDRAW_DOWN_DOUBLE_RIGHT, 0xd6, L'/' },
46 { BOXDRAW_DOUBLE_DOWN_RIGHT, 0xc9, L'/' },
47 { BOXDRAW_DOWN_LEFT_DOUBLE, 0xb8, L'\\' },
48 { BOXDRAW_DOWN_DOUBLE_LEFT, 0xb7, L'\\' },
49 { BOXDRAW_DOUBLE_DOWN_LEFT, 0xbb, L'\\' },
50 { BOXDRAW_UP_RIGHT_DOUBLE, 0xd4, L'\\' },
51 { BOXDRAW_UP_DOUBLE_RIGHT, 0xd3, L'\\' },
52 { BOXDRAW_DOUBLE_UP_RIGHT, 0xc8, L'\\' },
53 { BOXDRAW_UP_LEFT_DOUBLE, 0xbe, L'/' },
54 { BOXDRAW_UP_DOUBLE_LEFT, 0xbd, L'/' },
55 { BOXDRAW_DOUBLE_UP_LEFT, 0xbc, L'/' },
56 { BOXDRAW_VERTICAL_RIGHT_DOUBLE, 0xc6, L'|' },
57 { BOXDRAW_VERTICAL_DOUBLE_RIGHT, 0xc7, L'|' },
58 { BOXDRAW_DOUBLE_VERTICAL_RIGHT, 0xcc, L'|' },
59 { BOXDRAW_VERTICAL_LEFT_DOUBLE, 0xb5, L'|' },
60 { BOXDRAW_VERTICAL_DOUBLE_LEFT, 0xb6, L'|' },
61 { BOXDRAW_DOUBLE_VERTICAL_LEFT, 0xb9, L'|' },
62 { BOXDRAW_DOWN_HORIZONTAL_DOUBLE, 0xd1, L'+' },
63 { BOXDRAW_DOWN_DOUBLE_HORIZONTAL, 0xd2, L'+' },
64 { BOXDRAW_DOUBLE_DOWN_HORIZONTAL, 0xcb, L'+' },
65 { BOXDRAW_UP_HORIZONTAL_DOUBLE, 0xcf, L'+' },
66 { BOXDRAW_UP_DOUBLE_HORIZONTAL, 0xd0, L'+' },
67 { BOXDRAW_DOUBLE_UP_HORIZONTAL, 0xca, L'+' },
68 { BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE, 0xd8, L'+' },
69 { BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL, 0xd7, L'+' },
70 { BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL, 0xce, L'+' },
71
72 { BLOCKELEMENT_FULL_BLOCK, 0xdb, L'*' },
73 { BLOCKELEMENT_LIGHT_SHADE, 0xb0, L'+' },
74
75 { GEOMETRICSHAPE_UP_TRIANGLE, 0x1e, L'^' },
76 { GEOMETRICSHAPE_RIGHT_TRIANGLE, 0x10, L'>' },
77 { GEOMETRICSHAPE_DOWN_TRIANGLE, 0x1f, L'v' },
78 { GEOMETRICSHAPE_LEFT_TRIANGLE, 0x11, L'<' },
79
80 { ARROW_LEFT, 0x3c, L'<' },
81 { ARROW_UP, 0x18, L'^' },
82 { ARROW_RIGHT, 0x3e, L'>' },
83 { ARROW_DOWN, 0x19, L'v' },
84
85 { 0x0000, 0x00, L'\0' }
86 };
87
88 CHAR16 mSetModeString[] = { ESC, '[', '=', '3', 'h', 0 };
89 CHAR16 mSetAttributeString[] = { ESC, '[', '0', 'm', ESC, '[', '4', '0', 'm', ESC, '[', '4', '0', 'm', 0 };
90 CHAR16 mClearScreenString[] = { ESC, '[', '2', 'J', 0 };
91 CHAR16 mSetCursorPositionString[] = { ESC, '[', '0', '0', ';', '0', '0', 'H', 0 };
92
93 //
94 // Body of the ConOut functions
95 //
96 EFI_STATUS
97 EFIAPI
98 TerminalConOutReset (
99 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
100 IN BOOLEAN ExtendedVerification
101 )
102 /*++
103 Routine Description:
104
105 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.Reset().
106 If ExtendeVerification is TRUE, then perform dependent serial device reset,
107 and set display mode to mode 0.
108 If ExtendedVerification is FALSE, only set display mode to mode 0.
109
110 Arguments:
111
112 This - Indicates the calling context.
113
114 ExtendedVerification - Indicates that the driver may perform a more exhaustive
115 verification operation of the device during reset.
116
117 Returns:
118
119 EFI_SUCCESS
120 The reset operation succeeds.
121
122 EFI_DEVICE_ERROR
123 The terminal is not functioning correctly or the serial port reset fails.
124
125 --*/
126 {
127 EFI_STATUS Status;
128 TERMINAL_DEV *TerminalDevice;
129
130 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
131
132 //
133 // Perform a more exhaustive reset by resetting the serial port.
134 //
135 if (ExtendedVerification) {
136 //
137 // Report progress code here
138 //
139 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
140 EFI_PROGRESS_CODE,
141 EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_RESET,
142 TerminalDevice->DevicePath
143 );
144
145 Status = TerminalDevice->SerialIo->Reset (TerminalDevice->SerialIo);
146 if (EFI_ERROR (Status)) {
147 //
148 // Report error code here
149 //
150 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
151 EFI_ERROR_CODE | EFI_ERROR_MINOR,
152 EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR,
153 TerminalDevice->DevicePath
154 );
155
156 return Status;
157 }
158 }
159
160 This->SetAttribute (This, EFI_TEXT_ATTR (This->Mode->Attribute & 0x0F, EFI_BACKGROUND_BLACK));
161
162 Status = This->SetMode (This, 0);
163
164 return Status;
165 }
166
167 EFI_STATUS
168 EFIAPI
169 TerminalConOutOutputString (
170 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
171 IN CHAR16 *WString
172 )
173 /*++
174 Routine Description:
175
176 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.OutputString().
177 The Unicode string will be converted to terminal expressible data stream
178 and send to terminal via serial port.
179
180
181 Arguments:
182
183 This - Indicates the calling context.
184
185 WString - The Null-terminated Unicode string to be displayed on
186 the terminal screen.
187
188 Returns:
189
190 EFI_SUCCESS
191 The string is output successfully.
192
193 EFI_DEVICE_ERROR
194 The serial port fails to send the string out.
195
196 EFI_WARN_UNKNOWN_GLYPH
197 Indicates that some of the characters in the Unicode string could not
198 be rendered and are skipped.
199
200 EFI_UNSUPPORTED
201
202 --*/
203 {
204 TERMINAL_DEV *TerminalDevice;
205 EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
206 UINTN MaxColumn;
207 UINTN MaxRow;
208 UINTN Length;
209 UTF8_CHAR Utf8Char;
210 CHAR8 GraphicChar;
211 CHAR8 AsciiChar;
212 EFI_STATUS Status;
213 UINT8 ValidBytes;
214 //
215 // flag used to indicate whether condition happens which will cause
216 // return EFI_WARN_UNKNOWN_GLYPH
217 //
218 BOOLEAN Warning;
219
220 ValidBytes = 0;
221 Warning = FALSE;
222
223 //
224 // get Terminal device data structure pointer.
225 //
226 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
227
228 //
229 // get current display mode
230 // Terminal driver only support mode 0
231 //
232 Mode = This->Mode;
233 if (Mode->Mode != 0) {
234 return EFI_UNSUPPORTED;
235 }
236
237 This->QueryMode (
238 This,
239 Mode->Mode,
240 &MaxColumn,
241 &MaxRow
242 );
243
244 for (; *WString != CHAR_NULL; WString++) {
245
246 switch (TerminalDevice->TerminalType) {
247
248 case PcAnsiType:
249 case VT100Type:
250 case VT100PlusType:
251
252 if (!TerminalIsValidTextGraphics (*WString, &GraphicChar, &AsciiChar)) {
253 //
254 // If it's not a graphic character convert Unicode to ASCII.
255 //
256 GraphicChar = (CHAR8) *WString;
257
258 if (!(TerminalIsValidAscii (GraphicChar) || TerminalIsValidEfiCntlChar (GraphicChar))) {
259 //
260 // when this driver use the OutputString to output control string,
261 // TerminalDevice->OutputEscChar is set to let the Esc char
262 // to be output to the terminal emulation software.
263 //
264 if ((GraphicChar == 27) && TerminalDevice->OutputEscChar) {
265 GraphicChar = 27;
266 } else {
267 GraphicChar = '?';
268 Warning = TRUE;
269 }
270 }
271
272 AsciiChar = GraphicChar;
273
274 }
275
276 if (TerminalDevice->TerminalType != PcAnsiType) {
277 GraphicChar = AsciiChar;
278 }
279
280 Length = 1;
281
282 Status = TerminalDevice->SerialIo->Write (
283 TerminalDevice->SerialIo,
284 &Length,
285 &GraphicChar
286 );
287
288 if (EFI_ERROR (Status)) {
289 goto OutputError;
290 }
291
292 break;
293
294 case VTUTF8Type:
295 UnicodeToUtf8 (*WString, &Utf8Char, &ValidBytes);
296 Length = ValidBytes;
297 Status = TerminalDevice->SerialIo->Write (
298 TerminalDevice->SerialIo,
299 &Length,
300 (UINT8 *) &Utf8Char
301 );
302 if (EFI_ERROR (Status)) {
303 goto OutputError;
304 }
305 break;
306 }
307 //
308 // Update cursor position.
309 //
310 switch (*WString) {
311
312 case CHAR_BACKSPACE:
313 if (Mode->CursorColumn > 0) {
314 Mode->CursorColumn--;
315 }
316 break;
317
318 case CHAR_LINEFEED:
319 if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
320 Mode->CursorRow++;
321 }
322 break;
323
324 case CHAR_CARRIAGE_RETURN:
325 Mode->CursorColumn = 0;
326 break;
327
328 default:
329 if (Mode->CursorColumn < (INT32) (MaxColumn - 1)) {
330
331 Mode->CursorColumn++;
332
333 } else {
334
335 Mode->CursorColumn = 0;
336 if (Mode->CursorRow < (INT32) (MaxRow - 1)) {
337 Mode->CursorRow++;
338 }
339
340 }
341 break;
342
343 };
344
345 }
346
347 if (Warning) {
348 return EFI_WARN_UNKNOWN_GLYPH;
349 }
350
351 return EFI_SUCCESS;
352
353 OutputError:
354 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
355 EFI_ERROR_CODE | EFI_ERROR_MINOR,
356 EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_OUTPUT_ERROR,
357 TerminalDevice->DevicePath
358 );
359
360 return EFI_DEVICE_ERROR;
361 }
362
363 EFI_STATUS
364 EFIAPI
365 TerminalConOutTestString (
366 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
367 IN CHAR16 *WString
368 )
369 /*++
370 Routine Description:
371
372 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.TestString().
373 If one of the characters in the *Wstring is
374 neither valid Unicode drawing characters,
375 not ASCII code, then this function will return
376 EFI_UNSUPPORTED.
377
378
379 Arguments:
380
381 This - Indicates the calling context.
382
383 WString - The Null-terminated Unicode string to be tested.
384
385 Returns:
386
387 EFI_SUCCESS
388 The terminal is capable of rendering the output string.
389
390 EFI_UNSUPPORTED
391 Some of the characters in the Unicode string cannot be rendered.
392
393 --*/
394 {
395 TERMINAL_DEV *TerminalDevice;
396 EFI_STATUS Status;
397
398 //
399 // get Terminal device data structure pointer.
400 //
401 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
402
403 switch (TerminalDevice->TerminalType) {
404
405 case PcAnsiType:
406 case VT100Type:
407 case VT100PlusType:
408 Status = AnsiTestString (TerminalDevice, WString);
409 break;
410
411 case VTUTF8Type:
412 Status = VTUTF8TestString (TerminalDevice, WString);
413 break;
414
415 default:
416 Status = EFI_UNSUPPORTED;
417 break;
418 }
419
420 return Status;
421 }
422
423 EFI_STATUS
424 EFIAPI
425 TerminalConOutQueryMode (
426 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
427 IN UINTN ModeNumber,
428 OUT UINTN *Columns,
429 OUT UINTN *Rows
430 )
431 /*++
432 Routine Description:
433
434 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.QueryMode().
435 It returns information for an available text mode
436 that the terminal supports.
437 In this driver, we only support text mode 80x25, which is
438 defined as mode 0.
439
440
441 Arguments:
442
443 *This
444 Indicates the calling context.
445
446 ModeNumber
447 The mode number to return information on.
448
449 Columns
450 The returned columns of the requested mode.
451
452 Rows
453 The returned rows of the requested mode.
454
455 Returns:
456
457 EFI_SUCCESS
458 The requested mode information is returned.
459
460 EFI_UNSUPPORTED
461 The mode number is not valid.
462
463 EFI_DEVICE_ERROR
464
465 --*/
466 {
467 if (This->Mode->MaxMode > 1) {
468 return EFI_DEVICE_ERROR;
469 }
470
471 if (ModeNumber == 0) {
472
473 *Columns = MODE0_COLUMN_COUNT;
474 *Rows = MODE0_ROW_COUNT;
475
476 return EFI_SUCCESS;
477 }
478
479 return EFI_UNSUPPORTED;
480 }
481
482 EFI_STATUS
483 EFIAPI
484 TerminalConOutSetMode (
485 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
486 IN UINTN ModeNumber
487 )
488 /*++
489 Routine Description:
490
491 Implements EFI_SIMPLE_TEXT_OUT.SetMode().
492 Set the terminal to a specified display mode.
493 In this driver, we only support mode 0.
494
495 Arguments:
496
497 This
498 Indicates the calling context.
499
500 ModeNumber
501 The text mode to set.
502
503 Returns:
504
505 EFI_SUCCESS
506 The requested text mode is set.
507
508 EFI_DEVICE_ERROR
509 The requested text mode cannot be set because of serial device error.
510
511 EFI_UNSUPPORTED
512 The text mode number is not valid.
513
514 --*/
515 {
516 EFI_STATUS Status;
517 TERMINAL_DEV *TerminalDevice;
518
519 //
520 // get Terminal device data structure pointer.
521 //
522 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
523
524 if (ModeNumber != 0) {
525 return EFI_UNSUPPORTED;
526 }
527
528 This->Mode->Mode = 0;
529
530 This->ClearScreen (This);
531
532 TerminalDevice->OutputEscChar = TRUE;
533 Status = This->OutputString (This, mSetModeString);
534 TerminalDevice->OutputEscChar = FALSE;
535
536 if (EFI_ERROR (Status)) {
537 return EFI_DEVICE_ERROR;
538 }
539
540 This->Mode->Mode = 0;
541
542 Status = This->ClearScreen (This);
543 if (EFI_ERROR (Status)) {
544 return EFI_DEVICE_ERROR;
545 }
546
547 return EFI_SUCCESS;
548
549 }
550
551 EFI_STATUS
552 EFIAPI
553 TerminalConOutSetAttribute (
554 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
555 IN UINTN Attribute
556 )
557 /*++
558 Routine Description:
559
560 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetAttribute().
561
562 Arguments:
563
564 This
565 Indicates the calling context.
566
567 Attribute
568 The attribute to set. Only bit0..6 are valid, all other bits
569 are undefined and must be zero.
570
571 Returns:
572
573 EFI_SUCCESS
574 The requested attribute is set.
575
576 EFI_DEVICE_ERROR
577 The requested attribute cannot be set due to serial port error.
578
579 EFI_UNSUPPORTED
580 The attribute requested is not defined by EFI spec.
581
582 --*/
583 {
584 UINT8 ForegroundControl;
585 UINT8 BackgroundControl;
586 UINT8 BrightControl;
587 INT32 SavedColumn;
588 INT32 SavedRow;
589 EFI_STATUS Status;
590 TERMINAL_DEV *TerminalDevice;
591
592 SavedColumn = 0;
593 SavedRow = 0;
594
595 //
596 // get Terminal device data structure pointer.
597 //
598 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
599
600 //
601 // only the bit0..6 of the Attribute is valid
602 //
603 if ((Attribute | 0x7f) != 0x7f) {
604 return EFI_UNSUPPORTED;
605 }
606 //
607 // convert Attribute value to terminal emulator
608 // understandable foreground color
609 //
610 switch (Attribute & 0x07) {
611
612 case EFI_BLACK:
613 ForegroundControl = 30;
614 break;
615
616 case EFI_BLUE:
617 ForegroundControl = 34;
618 break;
619
620 case EFI_GREEN:
621 ForegroundControl = 32;
622 break;
623
624 case EFI_CYAN:
625 ForegroundControl = 36;
626 break;
627
628 case EFI_RED:
629 ForegroundControl = 31;
630 break;
631
632 case EFI_MAGENTA:
633 ForegroundControl = 35;
634 break;
635
636 case EFI_BROWN:
637 ForegroundControl = 33;
638 break;
639
640 default:
641
642 case EFI_LIGHTGRAY:
643 ForegroundControl = 37;
644 break;
645
646 }
647 //
648 // bit4 of the Attribute indicates bright control
649 // of terminal emulator.
650 //
651 BrightControl = (UINT8) ((Attribute >> 3) & 1);
652
653 //
654 // convert Attribute value to terminal emulator
655 // understandable background color.
656 //
657 switch ((Attribute >> 4) & 0x07) {
658
659 case EFI_BLACK:
660 BackgroundControl = 40;
661 break;
662
663 case EFI_BLUE:
664 BackgroundControl = 44;
665 break;
666
667 case EFI_GREEN:
668 BackgroundControl = 42;
669 break;
670
671 case EFI_CYAN:
672 BackgroundControl = 46;
673 break;
674
675 case EFI_RED:
676 BackgroundControl = 41;
677 break;
678
679 case EFI_MAGENTA:
680 BackgroundControl = 45;
681 break;
682
683 case EFI_BROWN:
684 BackgroundControl = 43;
685 break;
686
687 default:
688
689 case EFI_LIGHTGRAY:
690 BackgroundControl = 47;
691 break;
692 }
693 //
694 // terminal emulator's control sequence to set attributes
695 //
696 mSetAttributeString[BRIGHT_CONTROL_OFFSET] = (CHAR16) ('0' + BrightControl);
697 mSetAttributeString[FOREGROUND_CONTROL_OFFSET + 0] = (CHAR16) ('0' + (ForegroundControl / 10));
698 mSetAttributeString[FOREGROUND_CONTROL_OFFSET + 1] = (CHAR16) ('0' + (ForegroundControl % 10));
699 mSetAttributeString[BACKGROUND_CONTROL_OFFSET + 0] = (CHAR16) ('0' + (BackgroundControl / 10));
700 mSetAttributeString[BACKGROUND_CONTROL_OFFSET + 1] = (CHAR16) ('0' + (BackgroundControl % 10));
701
702 //
703 // save current column and row
704 // for future scrolling back use.
705 //
706 SavedColumn = This->Mode->CursorColumn;
707 SavedRow = This->Mode->CursorRow;
708
709 TerminalDevice->OutputEscChar = TRUE;
710 Status = This->OutputString (This, mSetAttributeString);
711 TerminalDevice->OutputEscChar = FALSE;
712
713 if (EFI_ERROR (Status)) {
714 return EFI_DEVICE_ERROR;
715 }
716 //
717 // scroll back to saved cursor position.
718 //
719 This->Mode->CursorColumn = SavedColumn;
720 This->Mode->CursorRow = SavedRow;
721
722 This->Mode->Attribute = (INT32) Attribute;
723
724 return EFI_SUCCESS;
725
726 }
727
728 EFI_STATUS
729 EFIAPI
730 TerminalConOutClearScreen (
731 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This
732 )
733 /*++
734 Routine Description:
735
736 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.ClearScreen().
737 It clears the ANSI terminal's display to the
738 currently selected background color.
739
740
741 Arguments:
742
743 This
744 Indicates the calling context.
745
746 Returns:
747
748 EFI_SUCCESS
749 The operation completed successfully.
750
751 EFI_DEVICE_ERROR
752 The terminal screen cannot be cleared due to serial port error.
753
754 EFI_UNSUPPORTED
755 The terminal is not in a valid display mode.
756
757 --*/
758 {
759 EFI_STATUS Status;
760 TERMINAL_DEV *TerminalDevice;
761
762 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
763
764 //
765 // control sequence for clear screen request
766 //
767 TerminalDevice->OutputEscChar = TRUE;
768 Status = This->OutputString (This, mClearScreenString);
769 TerminalDevice->OutputEscChar = FALSE;
770
771 if (EFI_ERROR (Status)) {
772 return EFI_DEVICE_ERROR;
773 }
774
775 Status = This->SetCursorPosition (This, 0, 0);
776
777 return Status;
778 }
779
780 EFI_STATUS
781 EFIAPI
782 TerminalConOutSetCursorPosition (
783 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
784 IN UINTN Column,
785 IN UINTN Row
786 )
787 /*++
788 Routine Description:
789
790 Implements EFI_SIMPLE_TEXT_OUT_PROTOCOL.SetCursorPosition().
791
792 Arguments:
793
794 This
795 Indicates the calling context.
796
797 Column
798 The row to set cursor to.
799
800 Row
801 The column to set cursor to.
802
803 Returns:
804
805 EFI_SUCCESS
806 The operation completed successfully.
807
808 EFI_DEVICE_ERROR
809 The request fails due to serial port error.
810
811 EFI_UNSUPPORTED
812 The terminal is not in a valid text mode, or the cursor position
813 is invalid for current mode.
814
815 --*/
816 {
817 EFI_SIMPLE_TEXT_OUTPUT_MODE *Mode;
818 UINTN MaxColumn;
819 UINTN MaxRow;
820 EFI_STATUS Status;
821 TERMINAL_DEV *TerminalDevice;
822
823 TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (This);
824
825 //
826 // get current mode
827 //
828 Mode = This->Mode;
829
830 //
831 // get geometry of current mode
832 //
833 Status = This->QueryMode (
834 This,
835 Mode->Mode,
836 &MaxColumn,
837 &MaxRow
838 );
839 if (EFI_ERROR (Status)) {
840 return EFI_UNSUPPORTED;
841 }
842
843 if (Column >= MaxColumn || Row >= MaxRow) {
844 return EFI_UNSUPPORTED;
845 }
846 //
847 // control sequence to move the cursor
848 //
849 mSetCursorPositionString[ROW_OFFSET + 0] = (CHAR16) ('0' + ((Row + 1) / 10));
850 mSetCursorPositionString[ROW_OFFSET + 1] = (CHAR16) ('0' + ((Row + 1) % 10));
851 mSetCursorPositionString[COLUMN_OFFSET + 0] = (CHAR16) ('0' + ((Column + 1) / 10));
852 mSetCursorPositionString[COLUMN_OFFSET + 1] = (CHAR16) ('0' + ((Column + 1) % 10));
853
854 TerminalDevice->OutputEscChar = TRUE;
855 Status = This->OutputString (This, mSetCursorPositionString);
856 TerminalDevice->OutputEscChar = FALSE;
857
858 if (EFI_ERROR (Status)) {
859 return EFI_DEVICE_ERROR;
860 }
861 //
862 // update current cursor position
863 // in the Mode data structure.
864 //
865 Mode->CursorColumn = (INT32) Column;
866 Mode->CursorRow = (INT32) Row;
867
868 return EFI_SUCCESS;
869 }
870
871 EFI_STATUS
872 EFIAPI
873 TerminalConOutEnableCursor (
874 IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *This,
875 IN BOOLEAN Visible
876 )
877 /*++
878 Routine Description:
879
880 Implements SIMPLE_TEXT_OUTPUT.EnableCursor().
881 In this driver, the cursor cannot be hidden.
882
883 Arguments:
884
885 This
886 Indicates the calling context.
887
888 Visible
889 If TRUE, the cursor is set to be visible,
890 If FALSE, the cursor is set to be invisible.
891
892 Returns:
893
894 EFI_SUCCESS
895 The request is valid.
896
897 EFI_UNSUPPORTED
898 The terminal does not support cursor hidden.
899
900 --*/
901 {
902 if (!Visible) {
903 return EFI_UNSUPPORTED;
904 }
905
906 return EFI_SUCCESS;
907 }
908
909 BOOLEAN
910 TerminalIsValidTextGraphics (
911 IN CHAR16 Graphic,
912 OUT CHAR8 *PcAnsi, OPTIONAL
913 OUT CHAR8 *Ascii OPTIONAL
914 )
915 /*++
916
917 Routine Description:
918
919 Detects if a Unicode char is for Box Drawing text graphics.
920
921 Arguments:
922
923 Graphic - Unicode char to test.
924
925 PcAnsi - Optional pointer to return PCANSI equivalent of Graphic.
926
927 Ascii - Optional pointer to return ASCII equivalent of Graphic.
928
929 Returns:
930
931 TRUE if Graphic is a supported Unicode Box Drawing character.
932
933 --*/
934 {
935 UNICODE_TO_CHAR *Table;
936
937 if ((((Graphic & 0xff00) != 0x2500) && ((Graphic & 0xff00) != 0x2100))) {
938 //
939 // Unicode drawing code charts are all in the 0x25xx range,
940 // arrows are 0x21xx
941 //
942 return FALSE;
943 }
944
945 for (Table = UnicodeToPcAnsiOrAscii; Table->Unicode != 0x0000; Table++) {
946 if (Graphic == Table->Unicode) {
947 if (PcAnsi != NULL) {
948 *PcAnsi = Table->PcAnsi;
949 }
950
951 if (Ascii != NULL) {
952 *Ascii = Table->Ascii;
953 }
954
955 return TRUE;
956 }
957 }
958
959 return FALSE;
960 }
961
962 BOOLEAN
963 TerminalIsValidAscii (
964 IN CHAR16 Ascii
965 )
966 {
967 //
968 // valid ascii code lies in the extent of 0x20 ~ 0x7f
969 //
970 if ((Ascii >= 0x20) && (Ascii <= 0x7f)) {
971 return TRUE;
972 }
973
974 return FALSE;
975 }
976
977 BOOLEAN
978 TerminalIsValidEfiCntlChar (
979 IN CHAR16 CharC
980 )
981 {
982 //
983 // only support four control characters.
984 //
985 if (CharC == CHAR_NULL ||
986 CharC == CHAR_BACKSPACE ||
987 CharC == CHAR_LINEFEED ||
988 CharC == CHAR_CARRIAGE_RETURN ||
989 CharC == CHAR_TAB
990 ) {
991 return TRUE;
992 }
993
994 return FALSE;
995 }