VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/BootMaintenanceManagerUiLib/ConsoleOption.c@ 80922

Last change on this file since 80922 was 80721, checked in by vboxsync, 5 years ago

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • Property svn:eol-style set to native
File size: 33.9 KB
Line 
1/** @file
2handles console redirection from boot manager
3
4Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "BootMaintenanceManager.h"
10
11/**
12 Function compares a device path data structure to that of all the nodes of a
13 second device path instance.
14
15 @param Multi A pointer to a multi-instance device path data
16 structure.
17 @param Single A pointer to a single-instance device path data
18 structure.
19
20 @retval TRUE If the Single device path is contained within Multi device path.
21 @retval FALSE The Single device path is not match within Multi device path.
22
23**/
24BOOLEAN
25MatchDevicePaths (
26 IN EFI_DEVICE_PATH_PROTOCOL *Multi,
27 IN EFI_DEVICE_PATH_PROTOCOL *Single
28 )
29{
30 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
31 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
32 UINTN Size;
33
34 if (Multi == NULL || Single == NULL) {
35 return FALSE;
36 }
37
38 DevicePath = Multi;
39 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
40
41 //
42 // Search for the match of 'Single' in 'Multi'
43 //
44 while (DevicePathInst != NULL) {
45 //
46 // If the single device path is found in multiple device paths,
47 // return success
48 //
49 if (CompareMem (Single, DevicePathInst, Size) == 0) {
50 FreePool (DevicePathInst);
51 return TRUE;
52 }
53
54 FreePool (DevicePathInst);
55 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
56 }
57
58 return FALSE;
59}
60
61/**
62 Check whether the device path node is ISA Serial Node.
63
64 @param Acpi Device path node to be checked
65
66 @retval TRUE It's ISA Serial Node.
67 @retval FALSE It's NOT ISA Serial Node.
68
69**/
70BOOLEAN
71IsIsaSerialNode (
72 IN ACPI_HID_DEVICE_PATH *Acpi
73 )
74{
75 return (BOOLEAN) (
76 (DevicePathType (Acpi) == ACPI_DEVICE_PATH) &&
77 (DevicePathSubType (Acpi) == ACPI_DP) &&
78 (ReadUnaligned32 (&Acpi->HID) == EISA_PNP_ID (0x0501))
79 );
80}
81
82/**
83 Update Com Ports attributes from DevicePath
84
85 @param DevicePath DevicePath that contains Com ports
86
87 @retval EFI_SUCCESS The update is successful.
88
89**/
90EFI_STATUS
91UpdateComAttributeFromVariable (
92 EFI_DEVICE_PATH_PROTOCOL *DevicePath
93 );
94
95/**
96 Update the multi-instance device path of Terminal Device based on
97 the global TerminalMenu. If ChangeTernimal is TRUE, the terminal
98 device path in the Terminal Device in TerminalMenu is also updated.
99
100 @param DevicePath The multi-instance device path.
101 @param ChangeTerminal TRUE, then device path in the Terminal Device
102 in TerminalMenu is also updated; FALSE, no update.
103
104 @return EFI_SUCCESS The function completes successfully.
105
106**/
107EFI_STATUS
108ChangeTerminalDevicePath (
109 IN OUT EFI_DEVICE_PATH_PROTOCOL *DevicePath,
110 IN BOOLEAN ChangeTerminal
111 )
112{
113 EFI_DEVICE_PATH_PROTOCOL *Node;
114 EFI_DEVICE_PATH_PROTOCOL *Node1;
115 ACPI_HID_DEVICE_PATH *Acpi;
116 UART_DEVICE_PATH *Uart;
117 UART_DEVICE_PATH *Uart1;
118 UINTN Com;
119 BM_TERMINAL_CONTEXT *NewTerminalContext;
120 BM_MENU_ENTRY *NewMenuEntry;
121
122 Node = DevicePath;
123 Node = NextDevicePathNode (Node);
124 Com = 0;
125 while (!IsDevicePathEnd (Node)) {
126 Acpi = (ACPI_HID_DEVICE_PATH *) Node;
127 if (IsIsaSerialNode (Acpi)) {
128 CopyMem (&Com, &Acpi->UID, sizeof (UINT32));
129 }
130
131 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Com);
132
133 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
134 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
135 Uart = (UART_DEVICE_PATH *) Node;
136 CopyMem (
137 &Uart->BaudRate,
138 &NewTerminalContext->BaudRate,
139 sizeof (UINT64)
140 );
141
142 CopyMem (
143 &Uart->DataBits,
144 &NewTerminalContext->DataBits,
145 sizeof (UINT8)
146 );
147
148 CopyMem (
149 &Uart->Parity,
150 &NewTerminalContext->Parity,
151 sizeof (UINT8)
152 );
153
154 CopyMem (
155 &Uart->StopBits,
156 &NewTerminalContext->StopBits,
157 sizeof (UINT8)
158 );
159 //
160 // Change the device path in the ComPort
161 //
162 if (ChangeTerminal) {
163 Node1 = NewTerminalContext->DevicePath;
164 Node1 = NextDevicePathNode (Node1);
165 while (!IsDevicePathEnd (Node1)) {
166 if ((DevicePathType (Node1) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node1) == MSG_UART_DP)) {
167 Uart1 = (UART_DEVICE_PATH *) Node1;
168 CopyMem (
169 &Uart1->BaudRate,
170 &NewTerminalContext->BaudRate,
171 sizeof (UINT64)
172 );
173
174 CopyMem (
175 &Uart1->DataBits,
176 &NewTerminalContext->DataBits,
177 sizeof (UINT8)
178 );
179
180 CopyMem (
181 &Uart1->Parity,
182 &NewTerminalContext->Parity,
183 sizeof (UINT8)
184 );
185
186 CopyMem (
187 &Uart1->StopBits,
188 &NewTerminalContext->StopBits,
189 sizeof (UINT8)
190 );
191 break;
192 }
193 //
194 // end if
195 //
196 Node1 = NextDevicePathNode (Node1);
197 }
198 //
199 // end while
200 //
201 break;
202 }
203 }
204
205 Node = NextDevicePathNode (Node);
206 }
207
208 return EFI_SUCCESS;
209
210}
211
212/**
213 Update the device path that describing a terminal device
214 based on the new BaudRate, Data Bits, parity and Stop Bits
215 set.
216
217 @param DevicePath terminal device's path
218
219**/
220VOID
221ChangeVariableDevicePath (
222 IN OUT EFI_DEVICE_PATH_PROTOCOL *DevicePath
223 )
224{
225 EFI_DEVICE_PATH_PROTOCOL *Node;
226 ACPI_HID_DEVICE_PATH *Acpi;
227 UART_DEVICE_PATH *Uart;
228 UINTN Com;
229 BM_TERMINAL_CONTEXT *NewTerminalContext;
230 BM_MENU_ENTRY *NewMenuEntry;
231
232 Node = DevicePath;
233 Node = NextDevicePathNode (Node);
234 Com = 0;
235 while (!IsDevicePathEnd (Node)) {
236 Acpi = (ACPI_HID_DEVICE_PATH *) Node;
237 if (IsIsaSerialNode (Acpi)) {
238 CopyMem (&Com, &Acpi->UID, sizeof (UINT32));
239 }
240
241 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
242 NewMenuEntry = BOpt_GetMenuEntry (
243 &TerminalMenu,
244 Com
245 );
246 ASSERT (NewMenuEntry != NULL);
247 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
248 Uart = (UART_DEVICE_PATH *) Node;
249 CopyMem (
250 &Uart->BaudRate,
251 &NewTerminalContext->BaudRate,
252 sizeof (UINT64)
253 );
254
255 CopyMem (
256 &Uart->DataBits,
257 &NewTerminalContext->DataBits,
258 sizeof (UINT8)
259 );
260
261 CopyMem (
262 &Uart->Parity,
263 &NewTerminalContext->Parity,
264 sizeof (UINT8)
265 );
266
267 CopyMem (
268 &Uart->StopBits,
269 &NewTerminalContext->StopBits,
270 sizeof (UINT8)
271 );
272 }
273
274 Node = NextDevicePathNode (Node);
275 }
276}
277
278/**
279 Retrieve ACPI UID of UART from device path
280
281 @param Handle The handle for the UART device.
282 @param AcpiUid The ACPI UID on output.
283
284 @retval TRUE Find valid UID from device path
285 @retval FALSE Can't find
286
287**/
288BOOLEAN
289RetrieveUartUid (
290 IN EFI_HANDLE Handle,
291 IN OUT UINT32 *AcpiUid
292 )
293{
294 EFI_STATUS Status;
295 ACPI_HID_DEVICE_PATH *Acpi;
296 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
297
298 Status = gBS->HandleProtocol (
299 Handle,
300 &gEfiDevicePathProtocolGuid,
301 (VOID **) &DevicePath
302 );
303 if (EFI_ERROR (Status)) {
304 return FALSE;
305 }
306
307 Acpi = NULL;
308 for (; !IsDevicePathEnd (DevicePath); DevicePath = NextDevicePathNode (DevicePath)) {
309 if ((DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (DevicePath) == MSG_UART_DP)) {
310 break;
311 }
312 //
313 // Acpi points to the node before the Uart node
314 //
315 Acpi = (ACPI_HID_DEVICE_PATH *) DevicePath;
316 }
317
318 if ((Acpi != NULL) && IsIsaSerialNode (Acpi)) {
319 if (AcpiUid != NULL) {
320 CopyMem (AcpiUid, &Acpi->UID, sizeof (UINT32));
321 }
322 return TRUE;
323 } else {
324 return FALSE;
325 }
326}
327
328/**
329 Sort Uart handles array with Acpi->UID from low to high.
330
331 @param Handles EFI_SERIAL_IO_PROTOCOL handle buffer
332 @param NoHandles EFI_SERIAL_IO_PROTOCOL handle count
333**/
334VOID
335SortedUartHandle (
336 IN EFI_HANDLE *Handles,
337 IN UINTN NoHandles
338 )
339{
340 UINTN Index1;
341 UINTN Index2;
342 UINTN Position;
343 UINT32 AcpiUid1;
344 UINT32 AcpiUid2;
345 UINT32 TempAcpiUid;
346 EFI_HANDLE TempHandle;
347
348 for (Index1 = 0; Index1 < NoHandles-1; Index1++) {
349 if (!RetrieveUartUid (Handles[Index1], &AcpiUid1)) {
350 continue;
351 }
352 TempHandle = Handles[Index1];
353 Position = Index1;
354 TempAcpiUid = AcpiUid1;
355
356 for (Index2 = Index1+1; Index2 < NoHandles; Index2++) {
357 if (!RetrieveUartUid (Handles[Index2], &AcpiUid2)) {
358 continue;
359 }
360 if (AcpiUid2 < TempAcpiUid) {
361 TempAcpiUid = AcpiUid2;
362 TempHandle = Handles[Index2];
363 Position = Index2;
364 }
365 }
366 Handles[Position] = Handles[Index1];
367 Handles[Index1] = TempHandle;
368 }
369}
370
371/**
372 Test whether DevicePath is a valid Terminal
373
374
375 @param DevicePath DevicePath to be checked
376 @param Termi If DevicePath is valid Terminal, terminal type is returned.
377 @param Com If DevicePath is valid Terminal, Com Port type is returned.
378
379 @retval TRUE If DevicePath point to a Terminal.
380 @retval FALSE If DevicePath does not point to a Terminal.
381
382**/
383BOOLEAN
384IsTerminalDevicePath (
385 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
386 OUT TYPE_OF_TERMINAL *Termi,
387 OUT UINTN *Com
388 );
389
390/**
391 Build a list containing all serial devices.
392
393
394 @retval EFI_SUCCESS The function complete successfully.
395 @retval EFI_UNSUPPORTED No serial ports present.
396
397**/
398EFI_STATUS
399LocateSerialIo (
400 VOID
401 )
402{
403 UINTN Index;
404 UINTN Index2;
405 UINTN NoHandles;
406 EFI_HANDLE *Handles;
407 EFI_STATUS Status;
408 ACPI_HID_DEVICE_PATH *Acpi;
409 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
410 EFI_SERIAL_IO_PROTOCOL *SerialIo;
411 EFI_DEVICE_PATH_PROTOCOL *Node;
412 EFI_DEVICE_PATH_PROTOCOL *OutDevicePath;
413 EFI_DEVICE_PATH_PROTOCOL *InpDevicePath;
414 EFI_DEVICE_PATH_PROTOCOL *ErrDevicePath;
415 BM_MENU_ENTRY *NewMenuEntry;
416 BM_TERMINAL_CONTEXT *NewTerminalContext;
417 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
418 VENDOR_DEVICE_PATH Vendor;
419
420 //
421 // Get all handles that have SerialIo protocol installed
422 //
423 InitializeListHead (&TerminalMenu.Head);
424 TerminalMenu.MenuNumber = 0;
425 Status = gBS->LocateHandleBuffer (
426 ByProtocol,
427 &gEfiSerialIoProtocolGuid,
428 NULL,
429 &NoHandles,
430 &Handles
431 );
432 if (EFI_ERROR (Status)) {
433 //
434 // No serial ports present
435 //
436 return EFI_UNSUPPORTED;
437 }
438
439 //
440 // Sort Uart handles array with Acpi->UID from low to high
441 // then Terminal menu can be built from low Acpi->UID to high Acpi->UID
442 //
443 SortedUartHandle (Handles, NoHandles);
444
445 for (Index = 0; Index < NoHandles; Index++) {
446 //
447 // Check to see whether the handle has DevicePath Protocol installed
448 //
449 gBS->HandleProtocol (
450 Handles[Index],
451 &gEfiDevicePathProtocolGuid,
452 (VOID **) &DevicePath
453 );
454
455 Acpi = NULL;
456 for (Node = DevicePath; !IsDevicePathEnd (Node); Node = NextDevicePathNode (Node)) {
457 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
458 break;
459 }
460 //
461 // Acpi points to the node before Uart node
462 //
463 Acpi = (ACPI_HID_DEVICE_PATH *) Node;
464 }
465
466 if ((Acpi != NULL) && IsIsaSerialNode (Acpi)) {
467 NewMenuEntry = BOpt_CreateMenuEntry (BM_TERMINAL_CONTEXT_SELECT);
468 if (NewMenuEntry == NULL) {
469 FreePool (Handles);
470 return EFI_OUT_OF_RESOURCES;
471 }
472
473 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
474 CopyMem (&NewMenuEntry->OptionNumber, &Acpi->UID, sizeof (UINT32));
475 NewTerminalContext->DevicePath = DuplicateDevicePath (DevicePath);
476 //
477 // BugBug: I have no choice, calling EfiLibStrFromDatahub will hang the system!
478 // coz' the misc data for each platform is not correct, actually it's the device path stored in
479 // datahub which is not completed, so a searching for end of device path will enter a
480 // dead-loop.
481 //
482 NewMenuEntry->DisplayString = EfiLibStrFromDatahub (DevicePath);
483 if (NULL == NewMenuEntry->DisplayString) {
484 NewMenuEntry->DisplayString = UiDevicePathToStr (DevicePath);
485 }
486
487 NewMenuEntry->HelpString = NULL;
488
489 NewMenuEntry->DisplayStringToken = HiiSetString (mBmmCallbackInfo->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
490
491 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
492
493 gBS->HandleProtocol (
494 Handles[Index],
495 &gEfiSerialIoProtocolGuid,
496 (VOID **) &SerialIo
497 );
498
499 CopyMem (
500 &NewTerminalContext->BaudRate,
501 &SerialIo->Mode->BaudRate,
502 sizeof (UINT64)
503 );
504
505 CopyMem (
506 &NewTerminalContext->DataBits,
507 &SerialIo->Mode->DataBits,
508 sizeof (UINT8)
509 );
510
511 CopyMem (
512 &NewTerminalContext->Parity,
513 &SerialIo->Mode->Parity,
514 sizeof (UINT8)
515 );
516
517 CopyMem (
518 &NewTerminalContext->StopBits,
519 &SerialIo->Mode->StopBits,
520 sizeof (UINT8)
521 );
522 InsertTailList (&TerminalMenu.Head, &NewMenuEntry->Link);
523 TerminalMenu.MenuNumber++;
524 }
525 }
526 if (Handles != NULL) {
527 FreePool (Handles);
528 }
529
530 //
531 // Get L"ConOut", L"ConIn" and L"ErrOut" from the Var
532 //
533 GetEfiGlobalVariable2 (L"ConOut", (VOID**)&OutDevicePath, NULL);
534 GetEfiGlobalVariable2 (L"ConIn", (VOID**)&InpDevicePath, NULL);
535 GetEfiGlobalVariable2 (L"ErrOut", (VOID**)&ErrDevicePath, NULL);
536 if (OutDevicePath != NULL) {
537 UpdateComAttributeFromVariable (OutDevicePath);
538 }
539
540 if (InpDevicePath != NULL) {
541 UpdateComAttributeFromVariable (InpDevicePath);
542 }
543
544 if (ErrDevicePath != NULL) {
545 UpdateComAttributeFromVariable (ErrDevicePath);
546 }
547
548 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
549 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
550 if (NULL == NewMenuEntry) {
551 return EFI_NOT_FOUND;
552 }
553
554 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
555
556 NewTerminalContext->TerminalType = 0;
557 NewTerminalContext->IsConIn = FALSE;
558 NewTerminalContext->IsConOut = FALSE;
559 NewTerminalContext->IsStdErr = FALSE;
560
561 Vendor.Header.Type = MESSAGING_DEVICE_PATH;
562 Vendor.Header.SubType = MSG_VENDOR_DP;
563
564 for (Index2 = 0; Index2 < (ARRAY_SIZE (TerminalTypeGuid)); Index2++) {
565 CopyMem (&Vendor.Guid, &TerminalTypeGuid[Index2], sizeof (EFI_GUID));
566 SetDevicePathNodeLength (&Vendor.Header, sizeof (VENDOR_DEVICE_PATH));
567 NewDevicePath = AppendDevicePathNode (
568 NewTerminalContext->DevicePath,
569 (EFI_DEVICE_PATH_PROTOCOL *) &Vendor
570 );
571 if (NewMenuEntry->HelpString != NULL) {
572 FreePool (NewMenuEntry->HelpString);
573 }
574 //
575 // NewMenuEntry->HelpString = UiDevicePathToStr (NewDevicePath);
576 // NewMenuEntry->DisplayString = NewMenuEntry->HelpString;
577 //
578 NewMenuEntry->HelpString = NULL;
579
580 NewMenuEntry->DisplayStringToken = HiiSetString (mBmmCallbackInfo->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
581
582 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
583
584 if (MatchDevicePaths (OutDevicePath, NewDevicePath)) {
585 NewTerminalContext->IsConOut = TRUE;
586 NewTerminalContext->TerminalType = (UINT8) Index2;
587 }
588
589 if (MatchDevicePaths (InpDevicePath, NewDevicePath)) {
590 NewTerminalContext->IsConIn = TRUE;
591 NewTerminalContext->TerminalType = (UINT8) Index2;
592 }
593
594 if (MatchDevicePaths (ErrDevicePath, NewDevicePath)) {
595 NewTerminalContext->IsStdErr = TRUE;
596 NewTerminalContext->TerminalType = (UINT8) Index2;
597 }
598 }
599 }
600
601 return EFI_SUCCESS;
602}
603
604/**
605 Update Com Ports attributes from DevicePath
606
607 @param DevicePath DevicePath that contains Com ports
608
609 @retval EFI_SUCCESS The update is successful.
610 @retval EFI_NOT_FOUND Can not find specific menu entry
611**/
612EFI_STATUS
613UpdateComAttributeFromVariable (
614 EFI_DEVICE_PATH_PROTOCOL *DevicePath
615 )
616{
617 EFI_DEVICE_PATH_PROTOCOL *Node;
618 EFI_DEVICE_PATH_PROTOCOL *SerialNode;
619 ACPI_HID_DEVICE_PATH *Acpi;
620 UART_DEVICE_PATH *Uart;
621 UART_DEVICE_PATH *Uart1;
622 UINTN TerminalNumber;
623 BM_MENU_ENTRY *NewMenuEntry;
624 BM_TERMINAL_CONTEXT *NewTerminalContext;
625 UINTN Index;
626
627 Node = DevicePath;
628 Node = NextDevicePathNode (Node);
629 TerminalNumber = 0;
630 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
631 while (!IsDevicePathEnd (Node)) {
632 Acpi = (ACPI_HID_DEVICE_PATH *) Node;
633 if (IsIsaSerialNode (Acpi)) {
634 CopyMem (&TerminalNumber, &Acpi->UID, sizeof (UINT32));
635 }
636
637 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
638 Uart = (UART_DEVICE_PATH *) Node;
639 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, TerminalNumber);
640 if (NULL == NewMenuEntry) {
641 return EFI_NOT_FOUND;
642 }
643
644 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
645 CopyMem (
646 &NewTerminalContext->BaudRate,
647 &Uart->BaudRate,
648 sizeof (UINT64)
649 );
650
651 CopyMem (
652 &NewTerminalContext->DataBits,
653 &Uart->DataBits,
654 sizeof (UINT8)
655 );
656
657 CopyMem (
658 &NewTerminalContext->Parity,
659 &Uart->Parity,
660 sizeof (UINT8)
661 );
662
663 CopyMem (
664 &NewTerminalContext->StopBits,
665 &Uart->StopBits,
666 sizeof (UINT8)
667 );
668
669 SerialNode = NewTerminalContext->DevicePath;
670 SerialNode = NextDevicePathNode (SerialNode);
671 while (!IsDevicePathEnd (SerialNode)) {
672 if ((DevicePathType (SerialNode) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (SerialNode) == MSG_UART_DP)) {
673 //
674 // Update following device paths according to
675 // previous acquired uart attributes
676 //
677 Uart1 = (UART_DEVICE_PATH *) SerialNode;
678 CopyMem (
679 &Uart1->BaudRate,
680 &NewTerminalContext->BaudRate,
681 sizeof (UINT64)
682 );
683
684 CopyMem (
685 &Uart1->DataBits,
686 &NewTerminalContext->DataBits,
687 sizeof (UINT8)
688 );
689 CopyMem (
690 &Uart1->Parity,
691 &NewTerminalContext->Parity,
692 sizeof (UINT8)
693 );
694 CopyMem (
695 &Uart1->StopBits,
696 &NewTerminalContext->StopBits,
697 sizeof (UINT8)
698 );
699
700 break;
701 }
702
703 SerialNode = NextDevicePathNode (SerialNode);
704 }
705 //
706 // end while
707 //
708 }
709
710 Node = NextDevicePathNode (Node);
711 }
712 //
713 // end while
714 //
715 }
716
717 return EFI_SUCCESS;
718}
719
720/**
721 Build up Console Menu based on types passed in. The type can
722 be BM_CONSOLE_IN_CONTEXT_SELECT, BM_CONSOLE_OUT_CONTEXT_SELECT
723 and BM_CONSOLE_ERR_CONTEXT_SELECT.
724
725 @param ConsoleMenuType Can be BM_CONSOLE_IN_CONTEXT_SELECT, BM_CONSOLE_OUT_CONTEXT_SELECT
726 and BM_CONSOLE_ERR_CONTEXT_SELECT.
727
728 @retval EFI_UNSUPPORTED The type passed in is not in the 3 types defined.
729 @retval EFI_NOT_FOUND If the EFI Variable defined in UEFI spec with name "ConOutDev",
730 "ConInDev" or "ConErrDev" doesn't exists.
731 @retval EFI_OUT_OF_RESOURCES Not enough resource to complete the operations.
732 @retval EFI_SUCCESS Function completes successfully.
733
734**/
735EFI_STATUS
736GetConsoleMenu (
737 IN UINTN ConsoleMenuType
738 )
739{
740 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
741 EFI_DEVICE_PATH_PROTOCOL *AllDevicePath;
742 EFI_DEVICE_PATH_PROTOCOL *MultiDevicePath;
743 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
744 UINTN Size;
745 UINTN AllCount;
746 UINTN Index;
747 UINTN Index2;
748 BM_MENU_ENTRY *NewMenuEntry;
749 BM_CONSOLE_CONTEXT *NewConsoleContext;
750 TYPE_OF_TERMINAL Terminal;
751 UINTN Com;
752 BM_MENU_OPTION *ConsoleMenu;
753
754 DevicePath = NULL;
755 AllDevicePath = NULL;
756 AllCount = 0;
757 switch (ConsoleMenuType) {
758 case BM_CONSOLE_IN_CONTEXT_SELECT:
759 ConsoleMenu = &ConsoleInpMenu;
760 GetEfiGlobalVariable2 (L"ConIn", (VOID**)&DevicePath, NULL);
761 GetEfiGlobalVariable2 (L"ConInDev", (VOID**)&AllDevicePath, NULL);
762 break;
763
764 case BM_CONSOLE_OUT_CONTEXT_SELECT:
765 ConsoleMenu = &ConsoleOutMenu;
766 GetEfiGlobalVariable2 (L"ConOut", (VOID**)&DevicePath, NULL);
767 GetEfiGlobalVariable2 (L"ConOutDev", (VOID**)&AllDevicePath, NULL);
768 break;
769
770 case BM_CONSOLE_ERR_CONTEXT_SELECT:
771 ConsoleMenu = &ConsoleErrMenu;
772 GetEfiGlobalVariable2 (L"ErrOut", (VOID**)&DevicePath, NULL);
773 GetEfiGlobalVariable2 (L"ErrOutDev", (VOID**)&AllDevicePath, NULL);
774 break;
775
776 default:
777 return EFI_UNSUPPORTED;
778 }
779
780 if (NULL == AllDevicePath) {
781 return EFI_NOT_FOUND;
782 }
783
784 InitializeListHead (&ConsoleMenu->Head);
785
786 AllCount = EfiDevicePathInstanceCount (AllDevicePath);
787 ConsoleMenu->MenuNumber = 0;
788 //
789 // Following is menu building up for Console Devices selected.
790 //
791 MultiDevicePath = AllDevicePath;
792 Index2 = 0;
793 for (Index = 0; Index < AllCount; Index++) {
794 DevicePathInst = GetNextDevicePathInstance (&MultiDevicePath, &Size);
795
796 NewMenuEntry = BOpt_CreateMenuEntry (BM_CONSOLE_CONTEXT_SELECT);
797 if (NULL == NewMenuEntry) {
798 return EFI_OUT_OF_RESOURCES;
799 }
800
801 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
802 NewMenuEntry->OptionNumber = Index2;
803
804 NewConsoleContext->DevicePath = DuplicateDevicePath (DevicePathInst);
805 ASSERT (NewConsoleContext->DevicePath != NULL);
806 NewMenuEntry->DisplayString = EfiLibStrFromDatahub (NewConsoleContext->DevicePath);
807 if (NULL == NewMenuEntry->DisplayString) {
808 NewMenuEntry->DisplayString = UiDevicePathToStr (NewConsoleContext->DevicePath);
809 }
810
811 NewMenuEntry->DisplayStringToken = HiiSetString (mBmmCallbackInfo->BmmHiiHandle, 0, NewMenuEntry->DisplayString, NULL);
812
813 if (NULL == NewMenuEntry->HelpString) {
814 NewMenuEntry->HelpStringToken = NewMenuEntry->DisplayStringToken;
815 } else {
816 NewMenuEntry->HelpStringToken = HiiSetString (mBmmCallbackInfo->BmmHiiHandle, 0, NewMenuEntry->HelpString, NULL);
817 }
818
819 NewConsoleContext->IsTerminal = IsTerminalDevicePath (
820 NewConsoleContext->DevicePath,
821 &Terminal,
822 &Com
823 );
824
825 NewConsoleContext->IsActive = MatchDevicePaths (
826 DevicePath,
827 NewConsoleContext->DevicePath
828 );
829
830 if (NewConsoleContext->IsTerminal) {
831 BOpt_DestroyMenuEntry (NewMenuEntry);
832 } else {
833 Index2++;
834 ConsoleMenu->MenuNumber++;
835 InsertTailList (&ConsoleMenu->Head, &NewMenuEntry->Link);
836 }
837 }
838
839 return EFI_SUCCESS;
840}
841
842/**
843 Build up ConsoleOutMenu, ConsoleInpMenu and ConsoleErrMenu
844
845 @retval EFI_SUCCESS The function always complete successfully.
846
847**/
848EFI_STATUS
849GetAllConsoles (
850 VOID
851 )
852{
853 GetConsoleMenu (BM_CONSOLE_IN_CONTEXT_SELECT);
854 GetConsoleMenu (BM_CONSOLE_OUT_CONTEXT_SELECT);
855 GetConsoleMenu (BM_CONSOLE_ERR_CONTEXT_SELECT);
856 return EFI_SUCCESS;
857}
858
859/**
860 Free ConsoleOutMenu, ConsoleInpMenu and ConsoleErrMenu
861
862 @retval EFI_SUCCESS The function always complete successfully.
863**/
864EFI_STATUS
865FreeAllConsoles (
866 VOID
867 )
868{
869 BOpt_FreeMenu (&ConsoleOutMenu);
870 BOpt_FreeMenu (&ConsoleInpMenu);
871 BOpt_FreeMenu (&ConsoleErrMenu);
872 BOpt_FreeMenu (&TerminalMenu);
873 return EFI_SUCCESS;
874}
875
876/**
877 Test whether DevicePath is a valid Terminal
878
879
880 @param DevicePath DevicePath to be checked
881 @param Termi If DevicePath is valid Terminal, terminal type is returned.
882 @param Com If DevicePath is valid Terminal, Com Port type is returned.
883
884 @retval TRUE If DevicePath point to a Terminal.
885 @retval FALSE If DevicePath does not point to a Terminal.
886
887**/
888BOOLEAN
889IsTerminalDevicePath (
890 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
891 OUT TYPE_OF_TERMINAL *Termi,
892 OUT UINTN *Com
893 )
894{
895 BOOLEAN IsTerminal;
896 EFI_DEVICE_PATH_PROTOCOL *Node;
897 VENDOR_DEVICE_PATH *Vendor;
898 UART_DEVICE_PATH *Uart;
899 ACPI_HID_DEVICE_PATH *Acpi;
900
901 IsTerminal = FALSE;
902
903 Uart = NULL;
904 Vendor = NULL;
905 Acpi = NULL;
906 for (Node = DevicePath; !IsDevicePathEnd (Node); Node = NextDevicePathNode (Node)) {
907 //
908 // Vendor points to the node before the End node
909 //
910 Vendor = (VENDOR_DEVICE_PATH *) Node;
911
912 if ((DevicePathType (Node) == MESSAGING_DEVICE_PATH) && (DevicePathSubType (Node) == MSG_UART_DP)) {
913 Uart = (UART_DEVICE_PATH *) Node;
914 }
915
916 if (Uart == NULL) {
917 //
918 // Acpi points to the node before the UART node
919 //
920 Acpi = (ACPI_HID_DEVICE_PATH *) Node;
921 }
922 }
923
924 if (Vendor == NULL ||
925 DevicePathType (Vendor) != MESSAGING_DEVICE_PATH ||
926 DevicePathSubType (Vendor) != MSG_VENDOR_DP ||
927 Uart == NULL) {
928 return FALSE;
929 }
930
931 //
932 // There are four kinds of Terminal types
933 // check to see whether this devicepath
934 // is one of that type
935 //
936 if (CompareGuid (&Vendor->Guid, &TerminalTypeGuid[0])) {
937 *Termi = TerminalTypePcAnsi;
938 IsTerminal = TRUE;
939 } else {
940 if (CompareGuid (&Vendor->Guid, &TerminalTypeGuid[1])) {
941 *Termi = TerminalTypeVt100;
942 IsTerminal = TRUE;
943 } else {
944 if (CompareGuid (&Vendor->Guid, &TerminalTypeGuid[2])) {
945 *Termi = TerminalTypeVt100Plus;
946 IsTerminal = TRUE;
947 } else {
948 if (CompareGuid (&Vendor->Guid, &TerminalTypeGuid[3])) {
949 *Termi = TerminalTypeVtUtf8;
950 IsTerminal = TRUE;
951 } else {
952 if (CompareGuid (&Vendor->Guid, &TerminalTypeGuid[4])) {
953 *Termi = TerminalTypeTtyTerm;
954 IsTerminal = TRUE;
955 } else {
956 IsTerminal = FALSE;
957 }
958 }
959 }
960 }
961 }
962
963 if (!IsTerminal) {
964 return FALSE;
965 }
966
967 if ((Acpi != NULL) && IsIsaSerialNode (Acpi)) {
968 CopyMem (Com, &Acpi->UID, sizeof (UINT32));
969 } else {
970 return FALSE;
971 }
972
973 return TRUE;
974}
975
976/**
977 Get mode number according to column and row
978
979 @param CallbackData The BMM context data.
980**/
981VOID
982GetConsoleOutMode (
983 IN BMM_CALLBACK_DATA *CallbackData
984 )
985{
986 UINTN Col;
987 UINTN Row;
988 UINTN CurrentCol;
989 UINTN CurrentRow;
990 UINTN Mode;
991 UINTN MaxMode;
992 EFI_STATUS Status;
993 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
994
995 ConOut = gST->ConOut;
996 MaxMode = (UINTN) (ConOut->Mode->MaxMode);
997
998 CurrentCol = PcdGet32 (PcdSetupConOutColumn);
999 CurrentRow = PcdGet32 (PcdSetupConOutRow);
1000 for (Mode = 0; Mode < MaxMode; Mode++) {
1001 Status = ConOut->QueryMode (ConOut, Mode, &Col, &Row);
1002 if (!EFI_ERROR(Status)) {
1003 if (CurrentCol == Col && CurrentRow == Row) {
1004 CallbackData->BmmFakeNvData.ConsoleOutMode = (UINT16) Mode;
1005 break;
1006 }
1007 }
1008 }
1009}
1010
1011/**
1012
1013 Initialize console input device check box to ConsoleInCheck[MAX_MENU_NUMBER]
1014 in BMM_FAKE_NV_DATA structure.
1015
1016 @param CallbackData The BMM context data.
1017
1018**/
1019VOID
1020GetConsoleInCheck (
1021 IN BMM_CALLBACK_DATA *CallbackData
1022 )
1023{
1024 UINT16 Index;
1025 BM_MENU_ENTRY *NewMenuEntry;
1026 UINT8 *ConInCheck;
1027 BM_CONSOLE_CONTEXT *NewConsoleContext;
1028 BM_TERMINAL_CONTEXT *NewTerminalContext;
1029
1030 ASSERT (CallbackData != NULL);
1031
1032 ConInCheck = &CallbackData->BmmFakeNvData.ConsoleInCheck[0];
1033 for (Index = 0; ((Index < ConsoleInpMenu.MenuNumber) && \
1034 (Index < MAX_MENU_NUMBER)) ; Index++) {
1035 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleInpMenu, Index);
1036 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
1037 ConInCheck[Index] = NewConsoleContext->IsActive;
1038 }
1039
1040 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
1041 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
1042 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
1043 ASSERT (Index + ConsoleInpMenu.MenuNumber < MAX_MENU_NUMBER);
1044 ConInCheck[Index + ConsoleInpMenu.MenuNumber] = NewTerminalContext->IsConIn;
1045 }
1046}
1047
1048/**
1049
1050 Initialize console output device check box to ConsoleOutCheck[MAX_MENU_NUMBER]
1051 in BMM_FAKE_NV_DATA structure.
1052
1053 @param CallbackData The BMM context data.
1054
1055**/
1056VOID
1057GetConsoleOutCheck (
1058 IN BMM_CALLBACK_DATA *CallbackData
1059 )
1060{
1061 UINT16 Index;
1062 BM_MENU_ENTRY *NewMenuEntry;
1063 UINT8 *ConOutCheck;
1064 BM_CONSOLE_CONTEXT *NewConsoleContext;
1065 BM_TERMINAL_CONTEXT *NewTerminalContext;
1066
1067 ASSERT (CallbackData != NULL);
1068 ConOutCheck = &CallbackData->BmmFakeNvData.ConsoleOutCheck[0];
1069 for (Index = 0; ((Index < ConsoleOutMenu.MenuNumber) && \
1070 (Index < MAX_MENU_NUMBER)) ; Index++) {
1071 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleOutMenu, Index);
1072 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
1073 ConOutCheck[Index] = NewConsoleContext->IsActive;
1074 }
1075
1076 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
1077 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
1078 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
1079 ASSERT (Index + ConsoleOutMenu.MenuNumber < MAX_MENU_NUMBER);
1080 ConOutCheck[Index + ConsoleOutMenu.MenuNumber] = NewTerminalContext->IsConOut;
1081 }
1082}
1083
1084/**
1085
1086 Initialize standard error output device check box to ConsoleErrCheck[MAX_MENU_NUMBER]
1087 in BMM_FAKE_NV_DATA structure.
1088
1089 @param CallbackData The BMM context data.
1090
1091**/
1092VOID
1093GetConsoleErrCheck (
1094 IN BMM_CALLBACK_DATA *CallbackData
1095 )
1096{
1097 UINT16 Index;
1098 BM_MENU_ENTRY *NewMenuEntry;
1099 UINT8 *ConErrCheck;
1100 BM_CONSOLE_CONTEXT *NewConsoleContext;
1101 BM_TERMINAL_CONTEXT *NewTerminalContext;
1102
1103 ASSERT (CallbackData != NULL);
1104 ConErrCheck = &CallbackData->BmmFakeNvData.ConsoleErrCheck[0];
1105 for (Index = 0; ((Index < ConsoleErrMenu.MenuNumber) && \
1106 (Index < MAX_MENU_NUMBER)) ; Index++) {
1107 NewMenuEntry = BOpt_GetMenuEntry (&ConsoleErrMenu, Index);
1108 NewConsoleContext = (BM_CONSOLE_CONTEXT *) NewMenuEntry->VariableContext;
1109 ConErrCheck[Index] = NewConsoleContext->IsActive;
1110 }
1111
1112 for (Index = 0; Index < TerminalMenu.MenuNumber; Index++) {
1113 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, Index);
1114 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
1115 ASSERT (Index + ConsoleErrMenu.MenuNumber < MAX_MENU_NUMBER);
1116 ConErrCheck[Index + ConsoleErrMenu.MenuNumber] = NewTerminalContext->IsStdErr;
1117 }
1118}
1119
1120/**
1121
1122 Initialize terminal attributes (baudrate, data rate, stop bits, parity and terminal type)
1123 to BMM_FAKE_NV_DATA structure.
1124
1125 @param CallbackData The BMM context data.
1126
1127**/
1128VOID
1129GetTerminalAttribute (
1130 IN BMM_CALLBACK_DATA *CallbackData
1131 )
1132{
1133 BMM_FAKE_NV_DATA *CurrentFakeNVMap;
1134 BM_MENU_ENTRY *NewMenuEntry;
1135 BM_TERMINAL_CONTEXT *NewTerminalContext;
1136 UINT16 TerminalIndex;
1137 UINT8 AttributeIndex;
1138
1139 ASSERT (CallbackData != NULL);
1140
1141 CurrentFakeNVMap = &CallbackData->BmmFakeNvData;
1142 for (TerminalIndex = 0; ((TerminalIndex < TerminalMenu.MenuNumber) && \
1143 (TerminalIndex < MAX_MENU_NUMBER)); TerminalIndex++) {
1144 NewMenuEntry = BOpt_GetMenuEntry (&TerminalMenu, TerminalIndex);
1145 NewTerminalContext = (BM_TERMINAL_CONTEXT *) NewMenuEntry->VariableContext;
1146 for (AttributeIndex = 0; AttributeIndex < sizeof (BaudRateList) / sizeof (BaudRateList [0]); AttributeIndex++) {
1147 if (NewTerminalContext->BaudRate == (UINT64) (BaudRateList[AttributeIndex].Value)) {
1148 NewTerminalContext->BaudRateIndex = AttributeIndex;
1149 break;
1150 }
1151 }
1152 for (AttributeIndex = 0; AttributeIndex < ARRAY_SIZE (DataBitsList); AttributeIndex++) {
1153 if (NewTerminalContext->DataBits == (UINT64) (DataBitsList[AttributeIndex].Value)) {
1154 NewTerminalContext->DataBitsIndex = AttributeIndex;
1155 break;
1156 }
1157 }
1158
1159 for (AttributeIndex = 0; AttributeIndex < ARRAY_SIZE (ParityList); AttributeIndex++) {
1160 if (NewTerminalContext->Parity == (UINT64) (ParityList[AttributeIndex].Value)) {
1161 NewTerminalContext->ParityIndex = AttributeIndex;
1162 break;
1163 }
1164 }
1165
1166 for (AttributeIndex = 0; AttributeIndex < ARRAY_SIZE (StopBitsList); AttributeIndex++) {
1167 if (NewTerminalContext->StopBits == (UINT64) (StopBitsList[AttributeIndex].Value)) {
1168 NewTerminalContext->StopBitsIndex = AttributeIndex;
1169 break;
1170 }
1171 }
1172 CurrentFakeNVMap->COMBaudRate[TerminalIndex] = NewTerminalContext->BaudRateIndex;
1173 CurrentFakeNVMap->COMDataRate[TerminalIndex] = NewTerminalContext->DataBitsIndex;
1174 CurrentFakeNVMap->COMStopBits[TerminalIndex] = NewTerminalContext->StopBitsIndex;
1175 CurrentFakeNVMap->COMParity[TerminalIndex] = NewTerminalContext->ParityIndex;
1176 CurrentFakeNVMap->COMTerminalType[TerminalIndex] = NewTerminalContext->TerminalType;
1177 CurrentFakeNVMap->COMFlowControl[TerminalIndex] = NewTerminalContext->FlowControl;
1178 }
1179}
1180
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette