BmConsole.c@ 80721

Last change on this file since 80721 was 80721, checked in by vboxsync, 6 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: 22.5 KB

Line
1	/** @file
2	Library functions which contain all the code to connect console device.
3
4	Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
5	(C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
6	SPDX-License-Identifier: BSD-2-Clause-Patent
7
8	**/
9
10	#include "InternalBm.h"
11
12	CHAR16 *mConVarName[] = {
13	L"ConIn",
14	L"ConOut",
15	L"ErrOut",
16	L"ConInDev",
17	L"ConOutDev",
18	L"ErrOutDev"
19	};
20
21	/**
22	Search out the video controller.
23
24	@return PCI device path of the video controller.
25	**/
26	EFI_HANDLE
27	BmGetVideoController (
28	VOID
29	)
30	{
31	EFI_STATUS Status;
32	UINTN RootBridgeHandleCount;
33	EFI_HANDLE *RootBridgeHandleBuffer;
34	UINTN HandleCount;
35	EFI_HANDLE *HandleBuffer;
36	UINTN RootBridgeIndex;
37	UINTN Index;
38	EFI_HANDLE VideoController;
39	EFI_PCI_IO_PROTOCOL *PciIo;
40	PCI_TYPE00 Pci;
41
42	//
43	// Make all the PCI_IO protocols show up
44	//
45	Status = gBS->LocateHandleBuffer (
46	ByProtocol,
47	&gEfiPciRootBridgeIoProtocolGuid,
48	NULL,
49	&RootBridgeHandleCount,
50	&RootBridgeHandleBuffer
51	);
52	if (EFI_ERROR (Status) \|\| (RootBridgeHandleCount == 0)) {
53	return NULL;
54	}
55
56	VideoController = NULL;
57	for (RootBridgeIndex = 0; RootBridgeIndex < RootBridgeHandleCount; RootBridgeIndex++) {
58	gBS->ConnectController (RootBridgeHandleBuffer[RootBridgeIndex], NULL, NULL, FALSE);
59
60	//
61	// Start to check all the pci io to find the first video controller
62	//
63	Status = gBS->LocateHandleBuffer (
64	ByProtocol,
65	&gEfiPciIoProtocolGuid,
66	NULL,
67	&HandleCount,
68	&HandleBuffer
69	);
70	if (EFI_ERROR (Status)) {
71	continue;
72	}
73
74	for (Index = 0; Index < HandleCount; Index++) {
75	Status = gBS->HandleProtocol (HandleBuffer[Index], &gEfiPciIoProtocolGuid, (VOID **) &PciIo);
76	if (!EFI_ERROR (Status)) {
77	//
78	// Check for all video controller
79	//
80	Status = PciIo->Pci.Read (
81	PciIo,
82	EfiPciIoWidthUint32,
83	0,
84	sizeof (Pci) / sizeof (UINT32),
85	&Pci
86	);
87	if (!EFI_ERROR (Status) && IS_PCI_VGA (&Pci)) {
88	// TODO: use IS_PCI_DISPLAY??
89	VideoController = HandleBuffer[Index];
90	break;
91	}
92	}
93	}
94	FreePool (HandleBuffer);
95
96	if (VideoController != NULL) {
97	break;
98	}
99	}
100	FreePool (RootBridgeHandleBuffer);
101
102	return VideoController;
103	}
104
105	/**
106	Query all the children of VideoController and return the device paths of all the
107	children that support GraphicsOutput protocol.
108
109	@param VideoController PCI handle of video controller.
110
111	@return Device paths of all the children that support GraphicsOutput protocol.
112	**/
113	EFI_DEVICE_PATH_PROTOCOL *
114	EFIAPI
115	EfiBootManagerGetGopDevicePath (
116	IN EFI_HANDLE VideoController
117	)
118	{
119	UINTN Index;
120	EFI_STATUS Status;
121	EFI_GUID **ProtocolBuffer;
122	UINTN ProtocolBufferCount;
123	UINTN ProtocolIndex;
124	EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
125	UINTN EntryCount;
126	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
127	EFI_DEVICE_PATH_PROTOCOL *Next;
128	EFI_DEVICE_PATH_PROTOCOL *Previous;
129	EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
130	EFI_DEVICE_PATH_PROTOCOL *GopPool;
131	EFI_DEVICE_PATH_PROTOCOL *ReturnDevicePath;
132
133
134	Status = gBS->ProtocolsPerHandle (
135	VideoController,
136	&ProtocolBuffer,
137	&ProtocolBufferCount
138	);
139	if (EFI_ERROR (Status)) {
140	return NULL;
141	}
142
143	GopPool = NULL;
144
145	for (ProtocolIndex = 0; ProtocolIndex < ProtocolBufferCount; ProtocolIndex++) {
146	Status = gBS->OpenProtocolInformation (
147	VideoController,
148	ProtocolBuffer[ProtocolIndex],
149	&OpenInfoBuffer,
150	&EntryCount
151	);
152	if (EFI_ERROR (Status)) {
153	continue;
154	}
155
156	for (Index = 0; Index < EntryCount; Index++) {
157	//
158	// Query all the children
159	//
160	if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
161	Status = gBS->OpenProtocol (
162	OpenInfoBuffer[Index].ControllerHandle,
163	&gEfiDevicePathProtocolGuid,
164	(VOID **) &DevicePath,
165	NULL,
166	NULL,
167	EFI_OPEN_PROTOCOL_GET_PROTOCOL
168	);
169	if (EFI_ERROR (Status)) {
170	continue;
171	}
172
173	Previous = NULL;
174	for (Next = DevicePath; !IsDevicePathEnd (Next); Next = NextDevicePathNode (Next)) {
175	Previous = Next;
176	}
177	ASSERT (Previous != NULL);
178
179	if (DevicePathType (Previous) == ACPI_DEVICE_PATH && DevicePathSubType (Previous) == ACPI_ADR_DP) {
180	Status = gBS->OpenProtocol (
181	OpenInfoBuffer[Index].ControllerHandle,
182	&gEfiGraphicsOutputProtocolGuid,
183	NULL,
184	NULL,
185	NULL,
186	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
187	);
188	if (!EFI_ERROR (Status)) {
189	//
190	// Append the device path to GOP pool when there is GOP protocol installed.
191	//
192	TempDevicePath = GopPool;
193	GopPool = AppendDevicePathInstance (GopPool, DevicePath);
194	gBS->FreePool (TempDevicePath);
195	}
196	}
197
198	if (DevicePathType (Previous) == HARDWARE_DEVICE_PATH && DevicePathSubType (Previous) == HW_CONTROLLER_DP) {
199	//
200	// Recursively look for GOP child in this frame buffer handle
201	//
202	DEBUG ((EFI_D_INFO, "[Bds] Looking for GOP child deeper ... \n"));
203	TempDevicePath = GopPool;
204	ReturnDevicePath = EfiBootManagerGetGopDevicePath (OpenInfoBuffer[Index].ControllerHandle);
205	GopPool = AppendDevicePathInstance (GopPool, ReturnDevicePath);
206	gBS->FreePool (ReturnDevicePath);
207	gBS->FreePool (TempDevicePath);
208	}
209	}
210	}
211
212	FreePool (OpenInfoBuffer);
213	}
214
215	FreePool (ProtocolBuffer);
216
217	return GopPool;
218	}
219
220	/**
221	Connect the platform active active video controller.
222
223	@param VideoController PCI handle of video controller.
224
225	@retval EFI_NOT_FOUND There is no active video controller.
226	@retval EFI_SUCCESS The video controller is connected.
227	**/
228	EFI_STATUS
229	EFIAPI
230	EfiBootManagerConnectVideoController (
231	EFI_HANDLE VideoController OPTIONAL
232	)
233	{
234	EFI_DEVICE_PATH_PROTOCOL *Gop;
235
236	if (VideoController == NULL) {
237	//
238	// Get the platform vga device
239	//
240	VideoController = BmGetVideoController ();
241	}
242
243	if (VideoController == NULL) {
244	return EFI_NOT_FOUND;
245	}
246
247	//
248	// Try to connect the PCI device path, so that GOP driver could start on this
249	// device and create child handles with GraphicsOutput Protocol installed
250	// on them, then we get device paths of these child handles and select
251	// them as possible console device.
252	//
253	gBS->ConnectController (VideoController, NULL, NULL, FALSE);
254
255	Gop = EfiBootManagerGetGopDevicePath (VideoController);
256	if (Gop == NULL) {
257	return EFI_NOT_FOUND;
258	}
259
260	EfiBootManagerUpdateConsoleVariable (ConOut, Gop, NULL);
261	FreePool (Gop);
262
263	//
264	// Necessary for ConPlatform and ConSplitter driver to start up again after ConOut is updated.
265	//
266	return gBS->ConnectController (VideoController, NULL, NULL, TRUE);
267	}
268
269	/**
270	Fill console handle in System Table if there are no valid console handle in.
271
272	Firstly, check the validation of console handle in System Table. If it is invalid,
273	update it by the first console device handle from EFI console variable.
274
275	@param VarName The name of the EFI console variable.
276	@param ConsoleGuid Specified Console protocol GUID.
277	@param ConsoleHandle On IN, console handle in System Table to be checked.
278	On OUT, new console handle in system table.
279	@param ProtocolInterface On IN, console protocol on console handle in System Table to be checked.
280	On OUT, new console protocol on new console handle in system table.
281
282	@retval TRUE System Table has been updated.
283	@retval FALSE System Table hasn't been updated.
284
285	**/
286	BOOLEAN
287	BmUpdateSystemTableConsole (
288	IN CHAR16 *VarName,
289	IN EFI_GUID *ConsoleGuid,
290	IN OUT EFI_HANDLE *ConsoleHandle,
291	IN OUT VOID **ProtocolInterface
292	)
293	{
294	EFI_STATUS Status;
295	UINTN DevicePathSize;
296	EFI_DEVICE_PATH_PROTOCOL *FullDevicePath;
297	EFI_DEVICE_PATH_PROTOCOL *VarConsole;
298	EFI_DEVICE_PATH_PROTOCOL *Instance;
299	EFI_DEVICE_PATH_PROTOCOL *FullInstance;
300	VOID *Interface;
301	EFI_HANDLE NewHandle;
302	EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;
303
304	ASSERT (VarName != NULL);
305	ASSERT (ConsoleHandle != NULL);
306	ASSERT (ConsoleGuid != NULL);
307	ASSERT (ProtocolInterface != NULL);
308
309	if (*ConsoleHandle != NULL) {
310	Status = gBS->HandleProtocol (
311	*ConsoleHandle,
312	ConsoleGuid,
313	&Interface
314	);
315	if (Status == EFI_SUCCESS && Interface == *ProtocolInterface) {
316	//
317	// If ConsoleHandle is valid and console protocol on this handle also
318	// also matched, just return.
319	//
320	return FALSE;
321	}
322	}
323
324	//
325	// Get all possible consoles device path from EFI variable
326	//
327	GetEfiGlobalVariable2 (VarName, (VOID **) &VarConsole, NULL);
328	if (VarConsole == NULL) {
329	//
330	// If there is no any console device, just return.
331	//
332	return FALSE;
333	}
334
335	FullDevicePath = VarConsole;
336
337	do {
338	//
339	// Check every instance of the console variable
340	//
341	Instance = GetNextDevicePathInstance (&VarConsole, &DevicePathSize);
342	if (Instance == NULL) {
343	DEBUG ((EFI_D_ERROR, "[Bds] No valid console instance is found for %s!\n", VarName));
344	// We should not ASSERT when all the console devices are removed.
345	// ASSERT_EFI_ERROR (EFI_NOT_FOUND);
346	FreePool (FullDevicePath);
347	return FALSE;
348	}
349
350	//
351	// Find console device handle by device path instance
352	//
353	FullInstance = Instance;
354	Status = gBS->LocateDevicePath (
355	ConsoleGuid,
356	&Instance,
357	&NewHandle
358	);
359	FreePool (FullInstance);
360	if (!EFI_ERROR (Status)) {
361	//
362	// Get the console protocol on this console device handle
363	//
364	Status = gBS->HandleProtocol (
365	NewHandle,
366	ConsoleGuid,
367	&Interface
368	);
369	if (!EFI_ERROR (Status)) {
370	//
371	// Update new console handle in System Table.
372	//
373	*ConsoleHandle = NewHandle;
374	*ProtocolInterface = Interface;
375	if (CompareGuid (ConsoleGuid, &gEfiSimpleTextOutProtocolGuid)) {
376	//
377	// If it is console out device, set console mode 80x25 if current mode is invalid.
378	//
379	TextOut = (EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *) Interface;
380	if (TextOut->Mode->Mode == -1) {
381	TextOut->SetMode (TextOut, 0);
382	}
383	}
384	FreePool (FullDevicePath);
385	return TRUE;
386	}
387	}
388
389	} while (Instance != NULL);
390
391	//
392	// No any available console devcie found.
393	//
394	FreePool (FullDevicePath);
395	return FALSE;
396	}
397
398	/**
399	This function updates the console variable based on ConVarName. It can
400	add or remove one specific console device path from the variable
401
402	@param ConsoleType ConIn, ConOut, ErrOut, ConInDev, ConOutDev or ErrOutDev.
403	@param CustomizedConDevicePath The console device path to be added to
404	the console variable. Cannot be multi-instance.
405	@param ExclusiveDevicePath The console device path to be removed
406	from the console variable. Cannot be multi-instance.
407
408	@retval EFI_UNSUPPORTED The added device path is the same as a removed one.
409	@retval EFI_SUCCESS Successfully added or removed the device path from the
410	console variable.
411	@retval others Return status of RT->SetVariable().
412
413	**/
414	EFI_STATUS
415	EFIAPI
416	EfiBootManagerUpdateConsoleVariable (
417	IN CONSOLE_TYPE ConsoleType,
418	IN EFI_DEVICE_PATH_PROTOCOL *CustomizedConDevicePath,
419	IN EFI_DEVICE_PATH_PROTOCOL *ExclusiveDevicePath
420	)
421	{
422	EFI_STATUS Status;
423	EFI_DEVICE_PATH_PROTOCOL *VarConsole;
424	EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
425	EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
426
427	if (ConsoleType >= ARRAY_SIZE (mConVarName)) {
428	return EFI_INVALID_PARAMETER;
429	}
430
431	//
432	// Notes: check the device path point, here should check
433	// with compare memory
434	//
435	if (CustomizedConDevicePath == ExclusiveDevicePath) {
436	return EFI_UNSUPPORTED;
437	}
438	//
439	// Delete the ExclusiveDevicePath from current default console
440	//
441	GetEfiGlobalVariable2 (mConVarName[ConsoleType], (VOID **) &VarConsole, NULL);
442	//
443	// Initialize NewDevicePath
444	//
445	NewDevicePath = VarConsole;
446
447	//
448	// If ExclusiveDevicePath is even the part of the instance in VarConsole, delete it.
449	// In the end, NewDevicePath is the final device path.
450	//
451	if (ExclusiveDevicePath != NULL && VarConsole != NULL) {
452	NewDevicePath = BmDelPartMatchInstance (VarConsole, ExclusiveDevicePath);
453	}
454	//
455	// Try to append customized device path to NewDevicePath.
456	//
457	if (CustomizedConDevicePath != NULL) {
458	if (!BmMatchDevicePaths (NewDevicePath, CustomizedConDevicePath)) {
459	//
460	// Check if there is part of CustomizedConDevicePath in NewDevicePath, delete it.
461	//
462	NewDevicePath = BmDelPartMatchInstance (NewDevicePath, CustomizedConDevicePath);
463	//
464	// In the first check, the default console variable will be _ModuleEntryPoint,
465	// just append current customized device path
466	//
467	TempNewDevicePath = NewDevicePath;
468	NewDevicePath = AppendDevicePathInstance (NewDevicePath, CustomizedConDevicePath);
469	if (TempNewDevicePath != NULL) {
470	FreePool(TempNewDevicePath);
471	}
472	}
473	}
474
475	//
476	// Finally, Update the variable of the default console by NewDevicePath
477	//
478	Status = gRT->SetVariable (
479	mConVarName[ConsoleType],
480	&gEfiGlobalVariableGuid,
481	EFI_VARIABLE_BOOTSERVICE_ACCESS \| EFI_VARIABLE_RUNTIME_ACCESS
482	\| ((ConsoleType < ConInDev) ? EFI_VARIABLE_NON_VOLATILE : 0),
483	GetDevicePathSize (NewDevicePath),
484	NewDevicePath
485	);
486
487	if (VarConsole == NewDevicePath) {
488	if (VarConsole != NULL) {
489	FreePool(VarConsole);
490	}
491	} else {
492	if (VarConsole != NULL) {
493	FreePool(VarConsole);
494	}
495	if (NewDevicePath != NULL) {
496	FreePool(NewDevicePath);
497	}
498	}
499
500	return Status;
501	}
502
503
504	/**
505	Connect the console device base on the variable ConsoleType.
506
507	@param ConsoleType ConIn, ConOut or ErrOut.
508
509	@retval EFI_NOT_FOUND There is not any console devices connected
510	success
511	@retval EFI_SUCCESS Success connect any one instance of the console
512	device path base on the variable ConVarName.
513
514	**/
515	EFI_STATUS
516	EFIAPI
517	EfiBootManagerConnectConsoleVariable (
518	IN CONSOLE_TYPE ConsoleType
519	)
520	{
521	EFI_STATUS Status;
522	EFI_DEVICE_PATH_PROTOCOL *StartDevicePath;
523	EFI_DEVICE_PATH_PROTOCOL *Instance;
524	EFI_DEVICE_PATH_PROTOCOL *Next;
525	EFI_DEVICE_PATH_PROTOCOL *CopyOfDevicePath;
526	UINTN Size;
527	BOOLEAN DeviceExist;
528	EFI_HANDLE Handle;
529
530	if ((ConsoleType != ConIn) && (ConsoleType != ConOut) && (ConsoleType != ErrOut)) {
531	return EFI_INVALID_PARAMETER;
532	}
533
534	Status = EFI_SUCCESS;
535	DeviceExist = FALSE;
536	Handle = NULL;
537
538	//
539	// Check if the console variable exist
540	//
541	GetEfiGlobalVariable2 (mConVarName[ConsoleType], (VOID **) &StartDevicePath, NULL);
542	if (StartDevicePath == NULL) {
543	return EFI_UNSUPPORTED;
544	}
545
546	CopyOfDevicePath = StartDevicePath;
547	do {
548	//
549	// Check every instance of the console variable
550	//
551	Instance = GetNextDevicePathInstance (&CopyOfDevicePath, &Size);
552	if (Instance == NULL) {
553	FreePool (StartDevicePath);
554	return EFI_UNSUPPORTED;
555	}
556
557	Next = Instance;
558	while (!IsDevicePathEndType (Next)) {
559	Next = NextDevicePathNode (Next);
560	}
561
562	SetDevicePathEndNode (Next);
563	//
564	// Connect the USB console
565	// USB console device path is a short-form device path that
566	// starts with the first element being a USB WWID
567	// or a USB Class device path
568	//
569	if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
570	((DevicePathSubType (Instance) == MSG_USB_CLASS_DP) \|\| (DevicePathSubType (Instance) == MSG_USB_WWID_DP))
571	) {
572	Status = BmConnectUsbShortFormDevicePath (Instance);
573	if (!EFI_ERROR (Status)) {
574	DeviceExist = TRUE;
575	}
576	} else {
577	for (Next = Instance; !IsDevicePathEnd (Next); Next = NextDevicePathNode (Next)) {
578	if (DevicePathType (Next) == ACPI_DEVICE_PATH && DevicePathSubType (Next) == ACPI_ADR_DP) {
579	break;
580	} else if (DevicePathType (Next) == HARDWARE_DEVICE_PATH &&
581	DevicePathSubType (Next) == HW_CONTROLLER_DP &&
582	DevicePathType (NextDevicePathNode (Next)) == ACPI_DEVICE_PATH &&
583	DevicePathSubType (NextDevicePathNode (Next)) == ACPI_ADR_DP
584	) {
585	break;
586	}
587	}
588	if (!IsDevicePathEnd (Next)) {
589	//
590	// For GOP device path, start the video driver with NULL remaining device path
591	//
592	SetDevicePathEndNode (Next);
593	Status = EfiBootManagerConnectDevicePath (Instance, &Handle);
594	if (!EFI_ERROR (Status)) {
595	gBS->ConnectController (Handle, NULL, NULL, TRUE);
596	}
597	} else {
598	Status = EfiBootManagerConnectDevicePath (Instance, NULL);
599	}
600	if (EFI_ERROR (Status)) {
601	//
602	// Delete the instance from the console varialbe
603	//
604	EfiBootManagerUpdateConsoleVariable (ConsoleType, NULL, Instance);
605	} else {
606	DeviceExist = TRUE;
607	}
608	}
609	FreePool(Instance);
610	} while (CopyOfDevicePath != NULL);
611
612	FreePool (StartDevicePath);
613
614	if (!DeviceExist) {
615	return EFI_NOT_FOUND;
616	}
617
618	return EFI_SUCCESS;
619	}
620
621
622	/**
623	This function will search every input/output device in current system,
624	and make every input/output device as potential console device.
625	**/
626	VOID
627	EFIAPI
628	EfiBootManagerConnectAllConsoles (
629	VOID
630	)
631	{
632	UINTN Index;
633	EFI_DEVICE_PATH_PROTOCOL *ConDevicePath;
634	UINTN HandleCount;
635	EFI_HANDLE *HandleBuffer;
636
637	Index = 0;
638	HandleCount = 0;
639	HandleBuffer = NULL;
640	ConDevicePath = NULL;
641
642	//
643	// Update all the console variables
644	//
645	gBS->LocateHandleBuffer (
646	ByProtocol,
647	&gEfiSimpleTextInProtocolGuid,
648	NULL,
649	&HandleCount,
650	&HandleBuffer
651	);
652
653	for (Index = 0; Index < HandleCount; Index++) {
654	gBS->HandleProtocol (
655	HandleBuffer[Index],
656	&gEfiDevicePathProtocolGuid,
657	(VOID **) &ConDevicePath
658	);
659	EfiBootManagerUpdateConsoleVariable (ConIn, ConDevicePath, NULL);
660	}
661
662	if (HandleBuffer != NULL) {
663	FreePool(HandleBuffer);
664	HandleBuffer = NULL;
665	}
666
667	gBS->LocateHandleBuffer (
668	ByProtocol,
669	&gEfiSimpleTextOutProtocolGuid,
670	NULL,
671	&HandleCount,
672	&HandleBuffer
673	);
674	for (Index = 0; Index < HandleCount; Index++) {
675	gBS->HandleProtocol (
676	HandleBuffer[Index],
677	&gEfiDevicePathProtocolGuid,
678	(VOID **) &ConDevicePath
679	);
680	EfiBootManagerUpdateConsoleVariable (ConOut, ConDevicePath, NULL);
681	EfiBootManagerUpdateConsoleVariable (ErrOut, ConDevicePath, NULL);
682	}
683
684	if (HandleBuffer != NULL) {
685	FreePool(HandleBuffer);
686	}
687
688	//
689	// Connect all console variables
690	//
691	EfiBootManagerConnectAllDefaultConsoles ();
692	}
693
694
695	/**
696	This function will connect all the console devices base on the console
697	device variable ConIn, ConOut and ErrOut.
698
699	@retval EFI_DEVICE_ERROR All the consoles were not connected due to an error.
700	@retval EFI_SUCCESS Success connect any one instance of the console
701	device path base on the variable ConVarName.
702	**/
703	EFI_STATUS
704	EFIAPI
705	EfiBootManagerConnectAllDefaultConsoles (
706	VOID
707	)
708	{
709	EFI_STATUS Status;
710	BOOLEAN OneConnected;
711	BOOLEAN SystemTableUpdated;
712
713	OneConnected = FALSE;
714
715	Status = EfiBootManagerConnectConsoleVariable (ConOut);
716	if (!EFI_ERROR (Status)) {
717	OneConnected = TRUE;
718	}
719	PERF_EVENT ("ConOutReady");
720
721
722	Status = EfiBootManagerConnectConsoleVariable (ConIn);
723	if (!EFI_ERROR (Status)) {
724	OneConnected = TRUE;
725	}
726	PERF_EVENT ("ConInReady");
727
728	Status = EfiBootManagerConnectConsoleVariable (ErrOut);
729	if (!EFI_ERROR (Status)) {
730	OneConnected = TRUE;
731	}
732	PERF_EVENT ("ErrOutReady");
733
734	SystemTableUpdated = FALSE;
735	//
736	// Fill console handles in System Table if no console device assignd.
737	//
738	if (BmUpdateSystemTableConsole (L"ConIn", &gEfiSimpleTextInProtocolGuid, &gST->ConsoleInHandle, (VOID **) &gST->ConIn)) {
739	SystemTableUpdated = TRUE;
740	}
741	if (BmUpdateSystemTableConsole (L"ConOut", &gEfiSimpleTextOutProtocolGuid, &gST->ConsoleOutHandle, (VOID **) &gST->ConOut)) {
742	SystemTableUpdated = TRUE;
743	}
744	if (BmUpdateSystemTableConsole (L"ErrOut", &gEfiSimpleTextOutProtocolGuid, &gST->StandardErrorHandle, (VOID **) &gST->StdErr)) {
745	SystemTableUpdated = TRUE;
746	}
747
748	if (SystemTableUpdated) {
749	//
750	// Update the CRC32 in the EFI System Table header
751	//
752	gST->Hdr.CRC32 = 0;
753	gBS->CalculateCrc32 (
754	(UINT8 *) &gST->Hdr,
755	gST->Hdr.HeaderSize,
756	&gST->Hdr.CRC32
757	);
758	}
759
760	return OneConnected ? EFI_SUCCESS : EFI_DEVICE_ERROR;
761	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/UefiBootManagerLib/BmConsole.c@ 80721

Download in other formats: