]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c
ab65e7e16f75543ea0437cc993cb6805cb501788
[mirror_edk2.git] / MdeModulePkg / Universal / Console / ConPlatformDxe / ConPlatform.c
1 /** @file
2 Console Platform DXE Driver, install Console Device Guids and update Console
3 Environment Variables.
4
5 Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "ConPlatform.h"
17
18
19 EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextInDriverBinding = {
20 ConPlatformTextInDriverBindingSupported,
21 ConPlatformTextInDriverBindingStart,
22 ConPlatformTextInDriverBindingStop,
23 0xa,
24 NULL,
25 NULL
26 };
27
28 EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextOutDriverBinding = {
29 ConPlatformTextOutDriverBindingSupported,
30 ConPlatformTextOutDriverBindingStart,
31 ConPlatformTextOutDriverBindingStop,
32 0xa,
33 NULL,
34 NULL
35 };
36
37 /**
38 Entrypoint of this module.
39
40 This function is the entrypoint of this module. It installs Driver Binding
41 Protocols together with Component Name Protocols.
42
43 @param ImageHandle The firmware allocated handle for the EFI image.
44 @param SystemTable A pointer to the EFI System Table.
45
46 @retval EFI_SUCCESS The entry point is executed successfully.
47
48 **/
49 EFI_STATUS
50 EFIAPI
51 InitializeConPlatform(
52 IN EFI_HANDLE ImageHandle,
53 IN EFI_SYSTEM_TABLE *SystemTable
54 )
55 {
56 EFI_STATUS Status;
57
58 Status = EfiLibInstallDriverBindingComponentName2 (
59 ImageHandle,
60 SystemTable,
61 &gConPlatformTextInDriverBinding,
62 ImageHandle,
63 &gConPlatformComponentName,
64 &gConPlatformComponentName2
65 );
66 ASSERT_EFI_ERROR (Status);
67
68 Status = EfiLibInstallDriverBindingComponentName2 (
69 ImageHandle,
70 SystemTable,
71 &gConPlatformTextOutDriverBinding,
72 NULL,
73 &gConPlatformComponentName,
74 &gConPlatformComponentName2
75 );
76 ASSERT_EFI_ERROR (Status);
77
78 return EFI_SUCCESS;
79 }
80
81
82 /**
83 Test to see if EFI_SIMPLE_TEXT_INPUT_PROTOCOL is supported on ControllerHandle.
84
85 @param This Protocol instance pointer.
86 @param ControllerHandle Handle of device to test.
87 @param RemainingDevicePath Optional parameter use to pick a specific child
88 device to start.
89
90 @retval EFI_SUCCESS This driver supports this device.
91 @retval other This driver does not support this device.
92
93 **/
94 EFI_STATUS
95 EFIAPI
96 ConPlatformTextInDriverBindingSupported (
97 IN EFI_DRIVER_BINDING_PROTOCOL *This,
98 IN EFI_HANDLE ControllerHandle,
99 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
100 )
101 {
102 return ConPlatformDriverBindingSupported (
103 This,
104 ControllerHandle,
105 &gEfiSimpleTextInProtocolGuid
106 );
107 }
108
109
110 /**
111 Test to see if EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL is supported on ControllerHandle.
112
113 @param This Protocol instance pointer.
114 @param ControllerHandle Handle of device to test.
115 @param RemainingDevicePath Optional parameter use to pick a specific child
116 device to start.
117
118 @retval EFI_SUCCESS This driver supports this device.
119 @retval other This driver does not support this device.
120
121 **/
122 EFI_STATUS
123 EFIAPI
124 ConPlatformTextOutDriverBindingSupported (
125 IN EFI_DRIVER_BINDING_PROTOCOL *This,
126 IN EFI_HANDLE ControllerHandle,
127 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
128 )
129 {
130 return ConPlatformDriverBindingSupported (
131 This,
132 ControllerHandle,
133 &gEfiSimpleTextOutProtocolGuid
134 );
135 }
136
137
138 /**
139 Test to see if the specified protocol is supported on ControllerHandle.
140
141 @param This Protocol instance pointer.
142 @param ControllerHandle Handle of device to test.
143 @param ProtocolGuid The specfic protocol.
144
145 @retval EFI_SUCCESS This driver supports this device.
146 @retval other This driver does not support this device.
147
148 **/
149 EFI_STATUS
150 ConPlatformDriverBindingSupported (
151 IN EFI_DRIVER_BINDING_PROTOCOL *This,
152 IN EFI_HANDLE ControllerHandle,
153 IN EFI_GUID *ProtocolGuid
154 )
155 {
156 EFI_STATUS Status;
157 VOID *Interface;
158
159 //
160 // Test to see if this is a physical device by checking if
161 // it has a Device Path Protocol.
162 //
163 Status = gBS->OpenProtocol (
164 ControllerHandle,
165 &gEfiDevicePathProtocolGuid,
166 NULL,
167 This->DriverBindingHandle,
168 ControllerHandle,
169 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
170 );
171 if (EFI_ERROR (Status)) {
172 return Status;
173 }
174 //
175 // Test to see if this device supports the specified Protocol.
176 //
177 Status = gBS->OpenProtocol (
178 ControllerHandle,
179 ProtocolGuid,
180 (VOID **) &Interface,
181 This->DriverBindingHandle,
182 ControllerHandle,
183 EFI_OPEN_PROTOCOL_BY_DRIVER
184 );
185 if (EFI_ERROR (Status)) {
186 return Status;
187 }
188
189 gBS->CloseProtocol (
190 ControllerHandle,
191 ProtocolGuid,
192 This->DriverBindingHandle,
193 ControllerHandle
194 );
195
196 return EFI_SUCCESS;
197 }
198
199 /**
200 Start this driver on the device for console input.
201
202 Start this driver on ControllerHandle by opening Simple Text Input Protocol,
203 reading Device Path, and installing Console In Devcice GUID on ControllerHandle.
204
205 If this devcie is not one hot-plug devce, append its device path into the
206 console environment variables ConInDev.
207
208 @param This Protocol instance pointer.
209 @param ControllerHandle Handle of device to bind driver to
210 @param RemainingDevicePath Optional parameter use to pick a specific child
211 device to start.
212
213 @retval EFI_SUCCESS This driver is added to ControllerHandle
214 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
215 @retval other This driver does not support this device.
216
217 **/
218 EFI_STATUS
219 EFIAPI
220 ConPlatformTextInDriverBindingStart (
221 IN EFI_DRIVER_BINDING_PROTOCOL *This,
222 IN EFI_HANDLE ControllerHandle,
223 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
224 )
225 {
226 EFI_STATUS Status;
227 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
228 EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn;
229 BOOLEAN IsInConInVariable;
230
231 //
232 // Get the Device Path Protocol so the environment variables can be updated
233 //
234 Status = gBS->OpenProtocol (
235 ControllerHandle,
236 &gEfiDevicePathProtocolGuid,
237 (VOID **) &DevicePath,
238 This->DriverBindingHandle,
239 ControllerHandle,
240 EFI_OPEN_PROTOCOL_GET_PROTOCOL
241 );
242 if (EFI_ERROR (Status)) {
243 return Status;
244 }
245 //
246 // Open the Simple Text Input Protocol BY_DRIVER
247 //
248 Status = gBS->OpenProtocol (
249 ControllerHandle,
250 &gEfiSimpleTextInProtocolGuid,
251 (VOID **) &TextIn,
252 This->DriverBindingHandle,
253 ControllerHandle,
254 EFI_OPEN_PROTOCOL_BY_DRIVER
255 );
256 if (EFI_ERROR (Status)) {
257 return Status;
258 }
259 //
260 // Check if the device path is in ConIn Variable
261 //
262 IsInConInVariable = FALSE;
263 Status = ConPlatformUpdateDeviceVariable (
264 L"ConIn",
265 DevicePath,
266 Check
267 );
268 if (!EFI_ERROR (Status)) {
269 IsInConInVariable = TRUE;
270 }
271
272 //
273 // Check the device path, if it is a hot plug device,
274 // do not put the device path into ConInDev, and install
275 // gEfiConsoleInDeviceGuid to the device handle directly.
276 // The policy is, make hot plug device plug in and play immediately.
277 //
278 if (IsHotPlugDevice (DevicePath)) {
279 gBS->InstallMultipleProtocolInterfaces (
280 &ControllerHandle,
281 &gEfiConsoleInDeviceGuid,
282 NULL,
283 NULL
284 );
285 //
286 // Append the device path to ConInDev only if it is in ConIn variable.
287 //
288 if (IsInConInVariable) {
289 ConPlatformUpdateDeviceVariable (
290 L"ConInDev",
291 DevicePath,
292 Append
293 );
294 }
295 } else {
296 //
297 // If it is not a hot-plug device, append the device path to the
298 // ConInDev environment variable
299 //
300 ConPlatformUpdateDeviceVariable (
301 L"ConInDev",
302 DevicePath,
303 Append
304 );
305
306 //
307 // If the device path is an instance in the ConIn environment variable,
308 // then install EfiConsoleInDeviceGuid onto ControllerHandle
309 //
310 if (IsInConInVariable) {
311 gBS->InstallMultipleProtocolInterfaces (
312 &ControllerHandle,
313 &gEfiConsoleInDeviceGuid,
314 NULL,
315 NULL
316 );
317 } else {
318 gBS->CloseProtocol (
319 ControllerHandle,
320 &gEfiSimpleTextInProtocolGuid,
321 This->DriverBindingHandle,
322 ControllerHandle
323 );
324 }
325 }
326
327 return EFI_SUCCESS;
328 }
329
330 /**
331 Start this driver on the device for console output and stardard error output.
332
333 Start this driver on ControllerHandle by opening Simple Text Output Protocol,
334 reading Device Path, and installing Console Out Devcic GUID, Standard Error
335 Device GUID on ControllerHandle.
336
337 If this devcie is not one hot-plug devce, append its device path into the
338 console environment variables ConOutDev, ErrOutDev.
339
340 @param This Protocol instance pointer.
341 @param ControllerHandle Handle of device to bind driver to
342 @param RemainingDevicePath Optional parameter use to pick a specific child
343 device to start.
344
345 @retval EFI_SUCCESS This driver is added to ControllerHandle
346 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
347 @retval other This driver does not support this device
348
349 **/
350 EFI_STATUS
351 EFIAPI
352 ConPlatformTextOutDriverBindingStart (
353 IN EFI_DRIVER_BINDING_PROTOCOL *This,
354 IN EFI_HANDLE ControllerHandle,
355 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
356 )
357 {
358 EFI_STATUS Status;
359 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
360 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *TextOut;
361 BOOLEAN NeedClose;
362 BOOLEAN IsInConOutVariable;
363 BOOLEAN IsInErrOutVariable;
364
365 NeedClose = TRUE;
366
367 //
368 // Get the Device Path Protocol so the environment variables can be updated
369 //
370 Status = gBS->OpenProtocol (
371 ControllerHandle,
372 &gEfiDevicePathProtocolGuid,
373 (VOID **) &DevicePath,
374 This->DriverBindingHandle,
375 ControllerHandle,
376 EFI_OPEN_PROTOCOL_GET_PROTOCOL
377 );
378 if (EFI_ERROR (Status)) {
379 return Status;
380 }
381 //
382 // Open the Simple Text Output Protocol BY_DRIVER
383 //
384 Status = gBS->OpenProtocol (
385 ControllerHandle,
386 &gEfiSimpleTextOutProtocolGuid,
387 (VOID **) &TextOut,
388 This->DriverBindingHandle,
389 ControllerHandle,
390 EFI_OPEN_PROTOCOL_BY_DRIVER
391 );
392 if (EFI_ERROR (Status)) {
393 return Status;
394 }
395 //
396 // Check if the device path is in ConOut & ErrOut Variable
397 //
398 IsInConOutVariable = FALSE;
399 Status = ConPlatformUpdateDeviceVariable (
400 L"ConOut",
401 DevicePath,
402 Check
403 );
404 if (!EFI_ERROR (Status)) {
405 IsInConOutVariable = TRUE;
406 }
407
408 IsInErrOutVariable = FALSE;
409 Status = ConPlatformUpdateDeviceVariable (
410 L"ErrOut",
411 DevicePath,
412 Check
413 );
414 if (!EFI_ERROR (Status)) {
415 IsInErrOutVariable = TRUE;
416 }
417
418 //
419 // Check the device path, if it is a hot plug device,
420 // do not put the device path into ConOutDev and ErrOutDev,
421 // and install gEfiConsoleOutDeviceGuid to the device handle directly.
422 // The policy is, make hot plug device plug in and play immediately.
423 //
424 if (IsHotPlugDevice (DevicePath)) {
425 gBS->InstallMultipleProtocolInterfaces (
426 &ControllerHandle,
427 &gEfiConsoleOutDeviceGuid,
428 NULL,
429 NULL
430 );
431 //
432 // Append the device path to ConOutDev only if it is in ConOut variable.
433 //
434 if (IsInConOutVariable) {
435 ConPlatformUpdateDeviceVariable (
436 L"ConOutDev",
437 DevicePath,
438 Append
439 );
440 }
441 //
442 // Append the device path to ErrOutDev only if it is in ErrOut variable.
443 //
444 if (IsInErrOutVariable) {
445 ConPlatformUpdateDeviceVariable (
446 L"ErrOutDev",
447 DevicePath,
448 Append
449 );
450 }
451 } else {
452 //
453 // If it is not a hot-plug device, append the device path to
454 // the ConOutDev and ErrOutDev environment variable.
455 // For GOP device path, append the sibling device path as well.
456 //
457 if (!ConPlatformUpdateGopCandidate (DevicePath)) {
458 ConPlatformUpdateDeviceVariable (
459 L"ConOutDev",
460 DevicePath,
461 Append
462 );
463 //
464 // Then append the device path to the ErrOutDev environment variable
465 //
466 ConPlatformUpdateDeviceVariable (
467 L"ErrOutDev",
468 DevicePath,
469 Append
470 );
471 }
472
473 //
474 // If the device path is an instance in the ConOut environment variable,
475 // then install EfiConsoleOutDeviceGuid onto ControllerHandle
476 //
477 if (IsInConOutVariable) {
478 NeedClose = FALSE;
479 Status = gBS->InstallMultipleProtocolInterfaces (
480 &ControllerHandle,
481 &gEfiConsoleOutDeviceGuid,
482 NULL,
483 NULL
484 );
485 }
486 //
487 // If the device path is an instance in the ErrOut environment variable,
488 // then install EfiStandardErrorDeviceGuid onto ControllerHandle
489 //
490 if (IsInErrOutVariable) {
491 NeedClose = FALSE;
492 gBS->InstallMultipleProtocolInterfaces (
493 &ControllerHandle,
494 &gEfiStandardErrorDeviceGuid,
495 NULL,
496 NULL
497 );
498 }
499
500 if (NeedClose) {
501 gBS->CloseProtocol (
502 ControllerHandle,
503 &gEfiSimpleTextOutProtocolGuid,
504 This->DriverBindingHandle,
505 ControllerHandle
506 );
507 }
508 }
509
510 return EFI_SUCCESS;
511 }
512
513 /**
514 Stop this driver on ControllerHandle by removing Console In Devcice GUID
515 and closing the Simple Text Input protocol on ControllerHandle.
516
517 @param This Protocol instance pointer.
518 @param ControllerHandle Handle of device to stop driver on
519 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
520 children is zero stop the entire bus driver.
521 @param ChildHandleBuffer List of Child Handles to Stop.
522
523 @retval EFI_SUCCESS This driver is removed ControllerHandle
524 @retval other This driver was not removed from this device
525
526 **/
527 EFI_STATUS
528 EFIAPI
529 ConPlatformTextInDriverBindingStop (
530 IN EFI_DRIVER_BINDING_PROTOCOL *This,
531 IN EFI_HANDLE ControllerHandle,
532 IN UINTN NumberOfChildren,
533 IN EFI_HANDLE *ChildHandleBuffer
534 )
535 {
536 EFI_STATUS Status;
537 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
538
539 //
540 // Get the Device Path Protocol firstly
541 //
542 Status = gBS->OpenProtocol (
543 ControllerHandle,
544 &gEfiDevicePathProtocolGuid,
545 (VOID **) &DevicePath,
546 This->DriverBindingHandle,
547 ControllerHandle,
548 EFI_OPEN_PROTOCOL_GET_PROTOCOL
549 );
550 //
551 // If there is device path on ControllerHandle
552 //
553 if (!EFI_ERROR (Status)) {
554 //
555 // Remove DevicePath from ConInDev if exists.
556 //
557 ConPlatformUpdateDeviceVariable (
558 L"ConInDev",
559 DevicePath,
560 Delete
561 );
562 }
563
564 //
565 // Uninstall the Console Device GUIDs from Controller Handle
566 //
567 ConPlatformUnInstallProtocol (
568 This,
569 ControllerHandle,
570 &gEfiConsoleInDeviceGuid
571 );
572
573 //
574 // Close the Simple Text Input Protocol
575 //
576 gBS->CloseProtocol (
577 ControllerHandle,
578 &gEfiSimpleTextInProtocolGuid,
579 This->DriverBindingHandle,
580 ControllerHandle
581 );
582
583 return EFI_SUCCESS;
584 }
585
586
587 /**
588 Stop this driver on ControllerHandle by removing Console Out Devcice GUID
589 and closing the Simple Text Output protocol on ControllerHandle.
590
591 @param This Protocol instance pointer.
592 @param ControllerHandle Handle of device to stop driver on
593 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
594 children is zero stop the entire bus driver.
595 @param ChildHandleBuffer List of Child Handles to Stop.
596
597 @retval EFI_SUCCESS This driver is removed ControllerHandle
598 @retval other This driver was not removed from this device
599
600 **/
601 EFI_STATUS
602 EFIAPI
603 ConPlatformTextOutDriverBindingStop (
604 IN EFI_DRIVER_BINDING_PROTOCOL *This,
605 IN EFI_HANDLE ControllerHandle,
606 IN UINTN NumberOfChildren,
607 IN EFI_HANDLE *ChildHandleBuffer
608 )
609 {
610 EFI_STATUS Status;
611 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
612
613 //
614 // Get the Device Path Protocol firstly
615 //
616 Status = gBS->OpenProtocol (
617 ControllerHandle,
618 &gEfiDevicePathProtocolGuid,
619 (VOID **) &DevicePath,
620 This->DriverBindingHandle,
621 ControllerHandle,
622 EFI_OPEN_PROTOCOL_GET_PROTOCOL
623 );
624 if (!EFI_ERROR (Status)) {
625 //
626 // Remove DevicePath from ConOutDev and ErrOutDev if exists.
627 //
628 ConPlatformUpdateDeviceVariable (
629 L"ConOutDev",
630 DevicePath,
631 Delete
632 );
633 ConPlatformUpdateDeviceVariable (
634 L"ErrOutDev",
635 DevicePath,
636 Delete
637 );
638 }
639
640 //
641 // Uninstall the Console Device GUIDs from Controller Handle
642 //
643 ConPlatformUnInstallProtocol (
644 This,
645 ControllerHandle,
646 &gEfiConsoleOutDeviceGuid
647 );
648
649 ConPlatformUnInstallProtocol (
650 This,
651 ControllerHandle,
652 &gEfiStandardErrorDeviceGuid
653 );
654
655 //
656 // Close the Simple Text Output Protocol
657 //
658 gBS->CloseProtocol (
659 ControllerHandle,
660 &gEfiSimpleTextOutProtocolGuid,
661 This->DriverBindingHandle,
662 ControllerHandle
663 );
664
665 return EFI_SUCCESS;
666 }
667
668
669 /**
670 Uninstall the specified protocol.
671
672 @param This Protocol instance pointer.
673 @param Handle Handle of device to uninstall protocol on.
674 @param ProtocolGuid The specified protocol need to be uninstalled.
675
676 **/
677 VOID
678 ConPlatformUnInstallProtocol (
679 IN EFI_DRIVER_BINDING_PROTOCOL *This,
680 IN EFI_HANDLE Handle,
681 IN EFI_GUID *ProtocolGuid
682 )
683 {
684 EFI_STATUS Status;
685
686 Status = gBS->OpenProtocol (
687 Handle,
688 ProtocolGuid,
689 NULL,
690 This->DriverBindingHandle,
691 Handle,
692 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
693 );
694
695 if (!EFI_ERROR (Status)) {
696 gBS->UninstallMultipleProtocolInterfaces (
697 Handle,
698 ProtocolGuid,
699 NULL,
700 NULL
701 );
702 }
703
704 return ;
705 }
706
707 /**
708 Get the necessary size of buffer and read the variable.
709
710 First get the necessary size of buffer. Then read the
711 EFI variable (Name) and return a dynamically allocated
712 buffer. On failure return NULL.
713
714 @param Name String part of EFI variable name
715
716 @return Dynamically allocated memory that contains a copy of the EFI variable.
717 Caller is repsoncible freeing the buffer. Return NULL means Variable
718 was not read.
719
720 **/
721 VOID *
722 ConPlatformGetVariable (
723 IN CHAR16 *Name
724 )
725 {
726 EFI_STATUS Status;
727 VOID *Buffer;
728 UINTN BufferSize;
729
730 BufferSize = 0;
731 Buffer = NULL;
732
733 //
734 // Test to see if the variable exists. If it doesn't, return NULL.
735 //
736 Status = gRT->GetVariable (
737 Name,
738 &gEfiGlobalVariableGuid,
739 NULL,
740 &BufferSize,
741 Buffer
742 );
743
744 if (Status == EFI_BUFFER_TOO_SMALL) {
745 //
746 // Allocate the buffer to return
747 //
748 Buffer = AllocatePool (BufferSize);
749 if (Buffer == NULL) {
750 return NULL;
751 }
752 //
753 // Read variable into the allocated buffer.
754 //
755 Status = gRT->GetVariable (
756 Name,
757 &gEfiGlobalVariableGuid,
758 NULL,
759 &BufferSize,
760 Buffer
761 );
762 if (EFI_ERROR (Status)) {
763 FreePool (Buffer);
764 //
765 // To make sure Buffer is NULL if any error occurs.
766 //
767 Buffer = NULL;
768 }
769 }
770
771 return Buffer;
772 }
773
774 /**
775 Function returns TRUE when the two input device paths point to the two
776 GOP child handles that have the same parent.
777
778 @param Left A pointer to a device path data structure.
779 @param Right A pointer to a device path data structure.
780
781 @retval TRUE Left and Right share the same parent.
782 @retval FALSE Left and Right don't share the same parent or either of them is not
783 a GOP device path.
784 **/
785 BOOLEAN
786 IsGopSibling (
787 IN EFI_DEVICE_PATH_PROTOCOL *Left,
788 IN EFI_DEVICE_PATH_PROTOCOL *Right
789 )
790 {
791 EFI_DEVICE_PATH_PROTOCOL *NodeLeft;
792 EFI_DEVICE_PATH_PROTOCOL *NodeRight;
793
794 for (NodeLeft = Left; !IsDevicePathEndType (NodeLeft); NodeLeft = NextDevicePathNode (NodeLeft)) {
795 if (DevicePathType (NodeLeft) == ACPI_DEVICE_PATH && DevicePathSubType (NodeLeft) == ACPI_ADR_DP) {
796 break;
797 }
798 }
799
800 if (IsDevicePathEndType (NodeLeft)) {
801 return FALSE;
802 }
803
804 for (NodeRight = Right; !IsDevicePathEndType (NodeRight); NodeRight = NextDevicePathNode (NodeRight)) {
805 if (DevicePathType (NodeRight) == ACPI_DEVICE_PATH && DevicePathSubType (NodeRight) == ACPI_ADR_DP) {
806 break;
807 }
808 }
809
810 if (IsDevicePathEndType (NodeRight)) {
811 return FALSE;
812 }
813
814 if (((UINTN) NodeLeft - (UINTN) Left) != ((UINTN) NodeRight - (UINTN) Right)) {
815 return FALSE;
816 }
817
818 return (BOOLEAN) (CompareMem (Left, Right, (UINTN) NodeLeft - (UINTN) Left) == 0);
819 }
820
821 /**
822 Function compares a device path data structure to that of all the nodes of a
823 second device path instance.
824
825 @param Multi A pointer to a multi-instance device path data structure.
826 @param Single A pointer to a single-instance device path data structure.
827 @param NewDevicePath If Delete is TRUE, this parameter must not be null, and it
828 points to the remaining device path data structure.
829 (remaining device path = Multi - Single.)
830 @param Delete If TRUE, means removing Single from Multi.
831 If FALSE, the routine just check whether Single matches
832 with any instance in Multi.
833
834 @retval EFI_SUCCESS If the Single is contained within Multi.
835 @retval EFI_NOT_FOUND If the Single is not contained within Multi.
836 @retval EFI_INVALID_PARAMETER Multi is NULL.
837 @retval EFI_INVALID_PARAMETER Single is NULL.
838 @retval EFI_INVALID_PARAMETER NewDevicePath is NULL when Delete is TRUE.
839
840 **/
841 EFI_STATUS
842 ConPlatformMatchDevicePaths (
843 IN EFI_DEVICE_PATH_PROTOCOL *Multi,
844 IN EFI_DEVICE_PATH_PROTOCOL *Single,
845 OUT EFI_DEVICE_PATH_PROTOCOL **NewDevicePath OPTIONAL,
846 IN BOOLEAN Delete
847 )
848 {
849 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
850 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath1;
851 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath2;
852 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
853 UINTN Size;
854
855 //
856 // The passed in DevicePath should not be NULL
857 //
858 if ((Multi == NULL) || (Single == NULL)) {
859 return EFI_INVALID_PARAMETER;
860 }
861
862 //
863 // If performing Delete operation, the NewDevicePath must not be NULL.
864 //
865 if (Delete) {
866 if (NewDevicePath == NULL) {
867 return EFI_INVALID_PARAMETER;
868 }
869 }
870
871 TempDevicePath1 = NULL;
872
873 DevicePath = Multi;
874 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
875
876 //
877 // Search for the match of 'Single' in 'Multi'
878 //
879 while (DevicePathInst != NULL) {
880 if ((CompareMem (Single, DevicePathInst, Size) == 0) || IsGopSibling (Single, DevicePathInst)) {
881 if (!Delete) {
882 //
883 // If Delete is FALSE, return EFI_SUCCESS if Single is found in Multi.
884 //
885 FreePool (DevicePathInst);
886 return EFI_SUCCESS;
887 }
888 } else {
889 if (Delete) {
890 //
891 // If the node of Multi does not match Single, then added it back to the result.
892 // That is, the node matching Single will be dropped and deleted from result.
893 //
894 TempDevicePath2 = AppendDevicePathInstance (
895 TempDevicePath1,
896 DevicePathInst
897 );
898 if (TempDevicePath1 != NULL) {
899 FreePool (TempDevicePath1);
900 }
901 TempDevicePath1 = TempDevicePath2;
902 }
903 }
904
905 FreePool (DevicePathInst);
906 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
907 }
908
909 if (Delete) {
910 //
911 // Return the new device path data structure with specified node deleted.
912 //
913 *NewDevicePath = TempDevicePath1;
914 return EFI_SUCCESS;
915 }
916
917 return EFI_NOT_FOUND;
918 }
919
920 /**
921 Update console environment variables.
922
923 @param VariableName Console environment variables, ConOutDev, ConInDev
924 ErrOutDev, ConIn ,ConOut or ErrOut.
925 @param DevicePath Console devcie's device path.
926 @param Operation Variable operations, including APPEND, CHECK and DELETE.
927
928 @retval EFI_SUCCESS Variable operates successfully.
929 @retval EFI_OUT_OF_RESOURCES If variable cannot be appended.
930 @retval other Variable updating failed.
931
932 **/
933 EFI_STATUS
934 ConPlatformUpdateDeviceVariable (
935 IN CHAR16 *VariableName,
936 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
937 IN CONPLATFORM_VAR_OPERATION Operation
938 )
939 {
940 EFI_STATUS Status;
941 EFI_DEVICE_PATH_PROTOCOL *VariableDevicePath;
942 EFI_DEVICE_PATH_PROTOCOL *NewVariableDevicePath;
943
944 VariableDevicePath = NULL;
945 NewVariableDevicePath = NULL;
946
947 //
948 // Get Variable according to variable name.
949 // The memory for Variable is allocated within ConPlatformGetVarible(),
950 // it is the caller's responsibility to free the memory before return.
951 //
952 VariableDevicePath = ConPlatformGetVariable (VariableName);
953
954 if (Operation != Delete) {
955 //
956 // Match specified DevicePath in Console Variable.
957 //
958 Status = ConPlatformMatchDevicePaths (
959 VariableDevicePath,
960 DevicePath,
961 NULL,
962 FALSE
963 );
964
965 if ((Operation == Check) || (!EFI_ERROR (Status))) {
966 //
967 // Branch here includes 2 cases:
968 // 1. Operation is CHECK, simply return Status.
969 // 2. Operation is APPEND, and device path already exists in variable, also return.
970 //
971 if (VariableDevicePath != NULL) {
972 FreePool (VariableDevicePath);
973 }
974
975 return Status;
976 }
977 //
978 // We reach here to append a device path that does not exist in variable.
979 //
980 Status = EFI_SUCCESS;
981 NewVariableDevicePath = AppendDevicePathInstance (
982 VariableDevicePath,
983 DevicePath
984 );
985 if (NewVariableDevicePath == NULL) {
986 Status = EFI_OUT_OF_RESOURCES;
987 }
988
989 } else {
990 //
991 // We reach here to remove DevicePath from the environment variable that
992 // is a multi-instance device path.
993 //
994 Status = ConPlatformMatchDevicePaths (
995 VariableDevicePath,
996 DevicePath,
997 &NewVariableDevicePath,
998 TRUE
999 );
1000 }
1001
1002 if (VariableDevicePath != NULL) {
1003 FreePool (VariableDevicePath);
1004 }
1005
1006 if (EFI_ERROR (Status)) {
1007 return Status;
1008 }
1009
1010 if (NewVariableDevicePath != NULL) {
1011 //
1012 // Update Console Environment Variable.
1013 //
1014 Status = gRT->SetVariable (
1015 VariableName,
1016 &gEfiGlobalVariableGuid,
1017 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1018 GetDevicePathSize (NewVariableDevicePath),
1019 NewVariableDevicePath
1020 );
1021
1022 FreePool (NewVariableDevicePath);
1023 }
1024
1025 return Status;
1026 }
1027
1028 /**
1029 Check if the device supports hot-plug through its device path.
1030
1031 This function could be updated to check more types of Hot Plug devices.
1032 Currently, it checks USB and PCCard device.
1033
1034 @param DevicePath Pointer to device's device path.
1035
1036 @retval TRUE The devcie is a hot-plug device
1037 @retval FALSE The devcie is not a hot-plug device.
1038
1039 **/
1040 BOOLEAN
1041 IsHotPlugDevice (
1042 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
1043 )
1044 {
1045 EFI_DEVICE_PATH_PROTOCOL *CheckDevicePath;
1046
1047 CheckDevicePath = DevicePath;
1048 while (!IsDevicePathEnd (CheckDevicePath)) {
1049 //
1050 // Check device whether is hot plug device or not throught Device Path
1051 //
1052 if ((DevicePathType (CheckDevicePath) == MESSAGING_DEVICE_PATH) &&
1053 (DevicePathSubType (CheckDevicePath) == MSG_USB_DP ||
1054 DevicePathSubType (CheckDevicePath) == MSG_USB_CLASS_DP ||
1055 DevicePathSubType (CheckDevicePath) == MSG_USB_WWID_DP)) {
1056 //
1057 // If Device is USB device
1058 //
1059 return TRUE;
1060 }
1061 if ((DevicePathType (CheckDevicePath) == HARDWARE_DEVICE_PATH) &&
1062 (DevicePathSubType (CheckDevicePath) == HW_PCCARD_DP)) {
1063 //
1064 // If Device is PCCard
1065 //
1066 return TRUE;
1067 }
1068
1069 CheckDevicePath = NextDevicePathNode (CheckDevicePath);
1070 }
1071
1072 return FALSE;
1073 }
1074
1075 /**
1076 Update ConOutDev and ErrOutDev variables to add the device path of
1077 GOP controller itself and the sibling controllers.
1078
1079 @param DevicePath Pointer to device's device path.
1080
1081 @retval TRUE The devcie is a GOP device.
1082 @retval FALSE The devcie is not a GOP device.
1083
1084 **/
1085 BOOLEAN
1086 ConPlatformUpdateGopCandidate (
1087 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
1088 )
1089 {
1090 EFI_STATUS Status;
1091 EFI_HANDLE PciHandle;
1092 EFI_HANDLE GopHandle;
1093 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
1094 UINTN EntryCount;
1095 UINTN Index;
1096 EFI_DEVICE_PATH_PROTOCOL *ChildDevicePath;
1097 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;
1098
1099 //
1100 // Check whether it's a GOP device.
1101 //
1102 TempDevicePath = DevicePath;
1103 Status = gBS->LocateDevicePath (&gEfiGraphicsOutputProtocolGuid, &TempDevicePath, &GopHandle);
1104 if (EFI_ERROR (Status)) {
1105 return FALSE;
1106 }
1107 //
1108 // Get the parent PciIo handle in order to find all the children
1109 //
1110 Status = gBS->LocateDevicePath (&gEfiPciIoProtocolGuid, &DevicePath, &PciHandle);
1111 if (EFI_ERROR (Status)) {
1112 return FALSE;
1113 }
1114
1115 Status = gBS->OpenProtocolInformation (
1116 PciHandle,
1117 &gEfiPciIoProtocolGuid,
1118 &OpenInfoBuffer,
1119 &EntryCount
1120 );
1121 if (EFI_ERROR (Status)) {
1122 return FALSE;
1123 }
1124
1125 for (Index = 0; Index < EntryCount; Index++) {
1126 //
1127 // Query all the children created by the GOP driver
1128 //
1129 if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
1130 Status = gBS->OpenProtocol (
1131 OpenInfoBuffer[Index].ControllerHandle,
1132 &gEfiDevicePathProtocolGuid,
1133 (VOID **) &ChildDevicePath,
1134 NULL,
1135 NULL,
1136 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1137 );
1138 if (!EFI_ERROR (Status)) {
1139 //
1140 // Append the device path to ConOutDev and ErrOutDev
1141 //
1142 ConPlatformUpdateDeviceVariable (L"ConOutDev", ChildDevicePath, Append);
1143 ConPlatformUpdateDeviceVariable (L"ErrOutDev", ChildDevicePath, Append);
1144 }
1145 }
1146 }
1147 FreePool (OpenInfoBuffer);
1148
1149 return TRUE;
1150 }