1 /** @file 2 Console Platform DXE Driver, install Console Device Guids and update Console 3 Environment Variables. 4 5 Copyright (c) 2006 - 2013, 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 standard 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 (DevicePathType (NodeLeft) == HARDWARE_DEVICE_PATH && DevicePathSubType (NodeLeft) == HW_CONTROLLER_DP && 797 DevicePathType (NextDevicePathNode (NodeLeft)) == ACPI_DEVICE_PATH && DevicePathSubType (NextDevicePathNode (NodeLeft)) == ACPI_ADR_DP)) { 798 break; 799 } 800 } 801 802 if (IsDevicePathEndType (NodeLeft)) { 803 return FALSE; 804 } 805 806 for (NodeRight = Right; !IsDevicePathEndType (NodeRight); NodeRight = NextDevicePathNode (NodeRight)) { 807 if ((DevicePathType (NodeRight) == ACPI_DEVICE_PATH && DevicePathSubType (NodeRight) == ACPI_ADR_DP) || 808 (DevicePathType (NodeRight) == HARDWARE_DEVICE_PATH && DevicePathSubType (NodeRight) == HW_CONTROLLER_DP && 809 DevicePathType (NextDevicePathNode (NodeRight)) == ACPI_DEVICE_PATH && DevicePathSubType (NextDevicePathNode (NodeRight)) == ACPI_ADR_DP)) { 810 break; 811 } 812 } 813 814 if (IsDevicePathEndType (NodeRight)) { 815 return FALSE; 816 } 817 818 if (((UINTN) NodeLeft - (UINTN) Left) != ((UINTN) NodeRight - (UINTN) Right)) { 819 return FALSE; 820 } 821 822 return (BOOLEAN) (CompareMem (Left, Right, (UINTN) NodeLeft - (UINTN) Left) == 0); 823 } 824 825 /** 826 Function compares a device path data structure to that of all the nodes of a 827 second device path instance. 828 829 @param Multi A pointer to a multi-instance device path data structure. 830 @param Single A pointer to a single-instance device path data structure. 831 @param NewDevicePath If Delete is TRUE, this parameter must not be null, and it 832 points to the remaining device path data structure. 833 (remaining device path = Multi - Single.) 834 @param Delete If TRUE, means removing Single from Multi. 835 If FALSE, the routine just check whether Single matches 836 with any instance in Multi. 837 838 @retval EFI_SUCCESS If the Single is contained within Multi. 839 @retval EFI_NOT_FOUND If the Single is not contained within Multi. 840 @retval EFI_INVALID_PARAMETER Multi is NULL. 841 @retval EFI_INVALID_PARAMETER Single is NULL. 842 @retval EFI_INVALID_PARAMETER NewDevicePath is NULL when Delete is TRUE. 843 844 **/ 845 EFI_STATUS 846 ConPlatformMatchDevicePaths ( 847 IN EFI_DEVICE_PATH_PROTOCOL *Multi, 848 IN EFI_DEVICE_PATH_PROTOCOL *Single, 849 OUT EFI_DEVICE_PATH_PROTOCOL **NewDevicePath OPTIONAL, 850 IN BOOLEAN Delete 851 ) 852 { 853 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 854 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath1; 855 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath2; 856 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst; 857 UINTN Size; 858 859 // 860 // The passed in DevicePath should not be NULL 861 // 862 if ((Multi == NULL) || (Single == NULL)) { 863 return EFI_INVALID_PARAMETER; 864 } 865 866 // 867 // If performing Delete operation, the NewDevicePath must not be NULL. 868 // 869 if (Delete) { 870 if (NewDevicePath == NULL) { 871 return EFI_INVALID_PARAMETER; 872 } 873 } 874 875 TempDevicePath1 = NULL; 876 877 DevicePath = Multi; 878 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size); 879 880 // 881 // Search for the match of 'Single' in 'Multi' 882 // 883 while (DevicePathInst != NULL) { 884 if ((CompareMem (Single, DevicePathInst, Size) == 0) || IsGopSibling (Single, DevicePathInst)) { 885 if (!Delete) { 886 // 887 // If Delete is FALSE, return EFI_SUCCESS if Single is found in Multi. 888 // 889 FreePool (DevicePathInst); 890 return EFI_SUCCESS; 891 } 892 } else { 893 if (Delete) { 894 // 895 // If the node of Multi does not match Single, then added it back to the result. 896 // That is, the node matching Single will be dropped and deleted from result. 897 // 898 TempDevicePath2 = AppendDevicePathInstance ( 899 TempDevicePath1, 900 DevicePathInst 901 ); 902 if (TempDevicePath1 != NULL) { 903 FreePool (TempDevicePath1); 904 } 905 TempDevicePath1 = TempDevicePath2; 906 } 907 } 908 909 FreePool (DevicePathInst); 910 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size); 911 } 912 913 if (Delete) { 914 // 915 // Return the new device path data structure with specified node deleted. 916 // 917 *NewDevicePath = TempDevicePath1; 918 return EFI_SUCCESS; 919 } 920 921 return EFI_NOT_FOUND; 922 } 923 924 /** 925 Update console environment variables. 926 927 @param VariableName Console environment variables, ConOutDev, ConInDev 928 ErrOutDev, ConIn ,ConOut or ErrOut. 929 @param DevicePath Console devcie's device path. 930 @param Operation Variable operations, including APPEND, CHECK and DELETE. 931 932 @retval EFI_SUCCESS Variable operates successfully. 933 @retval EFI_OUT_OF_RESOURCES If variable cannot be appended. 934 @retval other Variable updating failed. 935 936 **/ 937 EFI_STATUS 938 ConPlatformUpdateDeviceVariable ( 939 IN CHAR16 *VariableName, 940 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath, 941 IN CONPLATFORM_VAR_OPERATION Operation 942 ) 943 { 944 EFI_STATUS Status; 945 EFI_DEVICE_PATH_PROTOCOL *VariableDevicePath; 946 EFI_DEVICE_PATH_PROTOCOL *NewVariableDevicePath; 947 948 VariableDevicePath = NULL; 949 NewVariableDevicePath = NULL; 950 951 // 952 // Get Variable according to variable name. 953 // The memory for Variable is allocated within ConPlatformGetVarible(), 954 // it is the caller's responsibility to free the memory before return. 955 // 956 VariableDevicePath = ConPlatformGetVariable (VariableName); 957 958 if (Operation != Delete) { 959 // 960 // Match specified DevicePath in Console Variable. 961 // 962 Status = ConPlatformMatchDevicePaths ( 963 VariableDevicePath, 964 DevicePath, 965 NULL, 966 FALSE 967 ); 968 969 if ((Operation == Check) || (!EFI_ERROR (Status))) { 970 // 971 // Branch here includes 2 cases: 972 // 1. Operation is CHECK, simply return Status. 973 // 2. Operation is APPEND, and device path already exists in variable, also return. 974 // 975 if (VariableDevicePath != NULL) { 976 FreePool (VariableDevicePath); 977 } 978 979 return Status; 980 } 981 // 982 // We reach here to append a device path that does not exist in variable. 983 // 984 Status = EFI_SUCCESS; 985 NewVariableDevicePath = AppendDevicePathInstance ( 986 VariableDevicePath, 987 DevicePath 988 ); 989 if (NewVariableDevicePath == NULL) { 990 Status = EFI_OUT_OF_RESOURCES; 991 } 992 993 } else { 994 // 995 // We reach here to remove DevicePath from the environment variable that 996 // is a multi-instance device path. 997 // 998 Status = ConPlatformMatchDevicePaths ( 999 VariableDevicePath, 1000 DevicePath, 1001 &NewVariableDevicePath, 1002 TRUE 1003 ); 1004 } 1005 1006 if (VariableDevicePath != NULL) { 1007 FreePool (VariableDevicePath); 1008 } 1009 1010 if (EFI_ERROR (Status)) { 1011 return Status; 1012 } 1013 1014 if (NewVariableDevicePath != NULL) { 1015 // 1016 // Update Console Environment Variable. 1017 // 1018 Status = gRT->SetVariable ( 1019 VariableName, 1020 &gEfiGlobalVariableGuid, 1021 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS, 1022 GetDevicePathSize (NewVariableDevicePath), 1023 NewVariableDevicePath 1024 ); 1025 1026 FreePool (NewVariableDevicePath); 1027 } 1028 1029 return Status; 1030 } 1031 1032 /** 1033 Check if the device supports hot-plug through its device path. 1034 1035 This function could be updated to check more types of Hot Plug devices. 1036 Currently, it checks USB and PCCard device. 1037 1038 @param DevicePath Pointer to device's device path. 1039 1040 @retval TRUE The devcie is a hot-plug device 1041 @retval FALSE The devcie is not a hot-plug device. 1042 1043 **/ 1044 BOOLEAN 1045 IsHotPlugDevice ( 1046 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath 1047 ) 1048 { 1049 EFI_DEVICE_PATH_PROTOCOL *CheckDevicePath; 1050 1051 CheckDevicePath = DevicePath; 1052 while (!IsDevicePathEnd (CheckDevicePath)) { 1053 // 1054 // Check device whether is hot plug device or not throught Device Path 1055 // 1056 if ((DevicePathType (CheckDevicePath) == MESSAGING_DEVICE_PATH) && 1057 (DevicePathSubType (CheckDevicePath) == MSG_USB_DP || 1058 DevicePathSubType (CheckDevicePath) == MSG_USB_CLASS_DP || 1059 DevicePathSubType (CheckDevicePath) == MSG_USB_WWID_DP)) { 1060 // 1061 // If Device is USB device 1062 // 1063 return TRUE; 1064 } 1065 if ((DevicePathType (CheckDevicePath) == HARDWARE_DEVICE_PATH) && 1066 (DevicePathSubType (CheckDevicePath) == HW_PCCARD_DP)) { 1067 // 1068 // If Device is PCCard 1069 // 1070 return TRUE; 1071 } 1072 1073 CheckDevicePath = NextDevicePathNode (CheckDevicePath); 1074 } 1075 1076 return FALSE; 1077 } 1078 1079 /** 1080 Update ConOutDev and ErrOutDev variables to add the device path of 1081 GOP controller itself and the sibling controllers. 1082 1083 @param DevicePath Pointer to device's device path. 1084 1085 @retval TRUE The devcie is a GOP device. 1086 @retval FALSE The devcie is not a GOP device. 1087 1088 **/ 1089 BOOLEAN 1090 ConPlatformUpdateGopCandidate ( 1091 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath 1092 ) 1093 { 1094 EFI_STATUS Status; 1095 EFI_HANDLE PciHandle; 1096 EFI_HANDLE GopHandle; 1097 EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer; 1098 UINTN EntryCount; 1099 UINTN Index; 1100 EFI_DEVICE_PATH_PROTOCOL *ChildDevicePath; 1101 EFI_DEVICE_PATH_PROTOCOL *TempDevicePath; 1102 1103 // 1104 // Check whether it's a GOP device. 1105 // 1106 TempDevicePath = DevicePath; 1107 Status = gBS->LocateDevicePath (&gEfiGraphicsOutputProtocolGuid, &TempDevicePath, &GopHandle); 1108 if (EFI_ERROR (Status)) { 1109 return FALSE; 1110 } 1111 // 1112 // Get the parent PciIo handle in order to find all the children 1113 // 1114 Status = gBS->LocateDevicePath (&gEfiPciIoProtocolGuid, &DevicePath, &PciHandle); 1115 if (EFI_ERROR (Status)) { 1116 return FALSE; 1117 } 1118 1119 Status = gBS->OpenProtocolInformation ( 1120 PciHandle, 1121 &gEfiPciIoProtocolGuid, 1122 &OpenInfoBuffer, 1123 &EntryCount 1124 ); 1125 if (EFI_ERROR (Status)) { 1126 return FALSE; 1127 } 1128 1129 for (Index = 0; Index < EntryCount; Index++) { 1130 // 1131 // Query all the children created by the GOP driver 1132 // 1133 if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) { 1134 Status = gBS->OpenProtocol ( 1135 OpenInfoBuffer[Index].ControllerHandle, 1136 &gEfiDevicePathProtocolGuid, 1137 (VOID **) &ChildDevicePath, 1138 NULL, 1139 NULL, 1140 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1141 ); 1142 if (!EFI_ERROR (Status)) { 1143 // 1144 // Append the device path to ConOutDev and ErrOutDev 1145 // 1146 ConPlatformUpdateDeviceVariable (L"ConOutDev", ChildDevicePath, Append); 1147 ConPlatformUpdateDeviceVariable (L"ErrOutDev", ChildDevicePath, Append); 1148 } 1149 } 1150 } 1151 FreePool (OpenInfoBuffer); 1152 1153 return TRUE; 1154 } 1155