MdeModulePkg/Universal/Console/ConPlatformDxe/ConPlatform.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14     ConPlatform.c
  15
  16 Abstract:
  17
  18 --*/
  19
  20 #include <Uefi.h>
  21
  22 #include "ConPlatform.h"
  23
  24
  25 //
  26 // The protocols, PPI and GUID defintions for this module
  27 //
  28 #include <Protocol/SimpleTextOut.h>
  29 #include <Guid/GlobalVariable.h>
  30 #include <Guid/ConsoleInDevice.h>
  31 #include <Protocol/DevicePath.h>
  32 #include <Protocol/SimpleTextIn.h>
  33 #include <Guid/HotPlugDevice.h>
  34 #include <Guid/StandardErrorDevice.h>
  35 #include <Guid/ConsoleOutDevice.h>
  36 //
  37 // The Library classes this module consumes
  38 //
  39 #include <Library/DebugLib.h>
  40 #include <Library/UefiDriverEntryPoint.h>
  41 #include <Library/UefiLib.h>
  42 #include <Library/BaseMemoryLib.h>
  43 #include <Library/UefiBootServicesTableLib.h>
  44 #include <Library/UefiRuntimeServicesTableLib.h>
  45 #include <Library/DevicePathLib.h>
  46 #include <Library/MemoryAllocationLib.h>
  47 //
  48 // Driver Binding Externs
  49 //
  50 extern EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextInDriverBinding;
  51 extern EFI_COMPONENT_NAME_PROTOCOL gConPlatformComponentName;
  52 extern EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextOutDriverBinding;
  53 extern EFI_COMPONENT_NAME_PROTOCOL gConPlatformComponentName;
  54
  55 EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextInDriverBinding = {
  56   ConPlatformTextInDriverBindingSupported,
  57   ConPlatformTextInDriverBindingStart,
  58   ConPlatformTextInDriverBindingStop,
  59   0xa,
  60   NULL,
  61   NULL
  62 };
  63
  64 EFI_DRIVER_BINDING_PROTOCOL gConPlatformTextOutDriverBinding = {
  65   ConPlatformTextOutDriverBindingSupported,
  66   ConPlatformTextOutDriverBindingStart,
  67   ConPlatformTextOutDriverBindingStop,
  68   0xa,
  69   NULL,
  70   NULL
  71 };
  72
  73 /**
  74   The user Entry Point for module ConPlatform. The user code starts with this function.
  75
  76   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
  77   @param[in] SystemTable    A pointer to the EFI System Table.
  78
  79   @retval EFI_SUCCESS       The entry point is executed successfully.
  80   @retval other             Some error occurs when executing this entry point.
  81
  82 **/
  83 EFI_STATUS
  84 EFIAPI
  85 InitializeConPlatform(
  86   IN EFI_HANDLE           ImageHandle,
  87   IN EFI_SYSTEM_TABLE     *SystemTable
  88   )
  89 {
  90   EFI_STATUS              Status;
  91
  92   //
  93   // Install driver model protocol(s).
  94   //
  95   Status = EfiLibInstallAllDriverProtocols (
  96              ImageHandle,
  97              SystemTable,
  98              &gConPlatformTextInDriverBinding,
  99              ImageHandle,
 100              &gConPlatformComponentName,
 101              NULL,
 102              NULL
 103              );
 104   ASSERT_EFI_ERROR (Status);
 105
 106   Status = EfiLibInstallAllDriverProtocols (
 107              ImageHandle,
 108              SystemTable,
 109              &gConPlatformTextOutDriverBinding,
 110              NULL,
 111              &gConPlatformComponentName,
 112              NULL,
 113              NULL
 114              );
 115   ASSERT_EFI_ERROR (Status);
 116
 117
 118   return Status;
 119 }
 120
 121
 122 EFI_STATUS
 123 EFIAPI
 124 ConPlatformTextInDriverBindingSupported (
 125   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 126   IN  EFI_HANDLE                   ControllerHandle,
 127   IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 128   )
 129 /*++
 130
 131 Routine Description:
 132   Supported
 133
 134 Arguments:
 135   (Standard DriverBinding Protocol Supported() function)
 136
 137 Returns:
 138
 139   None
 140
 141 --*/
 142 {
 143   return ConPlatformDriverBindingSupported (
 144           This,
 145           ControllerHandle,
 146           RemainingDevicePath,
 147           &gEfiSimpleTextInProtocolGuid
 148           );
 149 }
 150
 151 EFI_STATUS
 152 EFIAPI
 153 ConPlatformTextOutDriverBindingSupported (
 154   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 155   IN  EFI_HANDLE                   ControllerHandle,
 156   IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 157   )
 158 /*++
 159
 160 Routine Description:
 161   Supported
 162
 163 Arguments:
 164   (Standard DriverBinding Protocol Supported() function)
 165
 166 Returns:
 167
 168   None
 169
 170 --*/
 171 {
 172   return ConPlatformDriverBindingSupported (
 173           This,
 174           ControllerHandle,
 175           RemainingDevicePath,
 176           &gEfiSimpleTextOutProtocolGuid
 177           );
 178 }
 179
 180 EFI_STATUS
 181 ConPlatformDriverBindingSupported (
 182   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 183   IN  EFI_HANDLE                   ControllerHandle,
 184   IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath,
 185   IN  EFI_GUID                     *ProtocolGuid
 186   )
 187 /*++
 188
 189 Routine Description:
 190   Supported
 191
 192 Arguments:
 193   (Standard DriverBinding Protocol Supported() function)
 194
 195 Returns:
 196
 197   None
 198
 199 --*/
 200 {
 201   EFI_STATUS  Status;
 202   VOID        *Interface;
 203
 204   //
 205   // Test to see if this is a physical device by checking to see if
 206   // it has a Device Path Protocol
 207   //
 208   Status = gBS->OpenProtocol (
 209                   ControllerHandle,
 210                   &gEfiDevicePathProtocolGuid,
 211                   NULL,
 212                   This->DriverBindingHandle,
 213                   ControllerHandle,
 214                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 215                   );
 216   if (EFI_ERROR (Status)) {
 217     return Status;
 218   }
 219   //
 220   // Test to see if this device supports the Simple Text Output Protocol
 221   //
 222   Status = gBS->OpenProtocol (
 223                   ControllerHandle,
 224                   ProtocolGuid,
 225                   (VOID **) &Interface,
 226                   This->DriverBindingHandle,
 227                   ControllerHandle,
 228                   EFI_OPEN_PROTOCOL_BY_DRIVER
 229                   );
 230   if (EFI_ERROR (Status)) {
 231     return Status;
 232   }
 233
 234   gBS->CloseProtocol (
 235         ControllerHandle,
 236         ProtocolGuid,
 237         This->DriverBindingHandle,
 238         ControllerHandle
 239         );
 240
 241   return EFI_SUCCESS;
 242 }
 243
 244 EFI_STATUS
 245 EFIAPI
 246 ConPlatformTextInDriverBindingStart (
 247   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 248   IN  EFI_HANDLE                    ControllerHandle,
 249   IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath
 250   )
 251 /*++
 252
 253 Routine Description:
 254
 255
 256 Arguments:
 257   (Standard DriverBinding Protocol Start() function)
 258
 259 Returns:
 260
 261
 262 --*/
 263 {
 264   EFI_STATUS                  Status;
 265   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
 266   EFI_SIMPLE_TEXT_INPUT_PROTOCOL *TextIn;
 267
 268   //
 269   // Get the Device Path Protocol so the environment variables can be updated
 270   //
 271   Status = gBS->OpenProtocol (
 272                   ControllerHandle,
 273                   &gEfiDevicePathProtocolGuid,
 274                   (VOID **) &DevicePath,
 275                   This->DriverBindingHandle,
 276                   ControllerHandle,
 277                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 278                   );
 279   if (EFI_ERROR (Status)) {
 280     return Status;
 281   }
 282   //
 283   // Open the Simple Input Protocol BY_DRIVER
 284   //
 285   Status = gBS->OpenProtocol (
 286                   ControllerHandle,
 287                   &gEfiSimpleTextInProtocolGuid,
 288                   (VOID **) &TextIn,
 289                   This->DriverBindingHandle,
 290                   ControllerHandle,
 291                   EFI_OPEN_PROTOCOL_BY_DRIVER
 292                   );
 293   if (EFI_ERROR (Status)) {
 294     return Status;
 295   }
 296   //
 297   // Check the device handle, if it is a hot plug device,
 298   // do not put the device path into ConInDev, and install
 299   // gEfiConsoleInDeviceGuid to the device handle directly.
 300   // The policy is, make hot plug device plug in and play immediately.
 301   //
 302   if (IsHotPlugDevice (This->DriverBindingHandle, ControllerHandle)) {
 303     gBS->InstallMultipleProtocolInterfaces (
 304           &ControllerHandle,
 305           &gEfiConsoleInDeviceGuid,
 306           NULL,
 307           NULL
 308           );
 309   } else {
 310     //
 311     // Append the device path to the ConInDev environment variable
 312     //
 313     ConPlatformUpdateDeviceVariable (
 314       VarConsoleInpDev,
 315       DevicePath,
 316       APPEND
 317       );
 318
 319     //
 320     // If the device path is an instance in the ConIn environment variable,
 321     // then install EfiConsoleInDeviceGuid onto ControllerHandle
 322     //
 323     Status = ConPlatformUpdateDeviceVariable (
 324               VarConsoleInp,
 325               DevicePath,
 326               CHECK
 327               );
 328
 329     if (!EFI_ERROR (Status)) {
 330       gBS->InstallMultipleProtocolInterfaces (
 331             &ControllerHandle,
 332             &gEfiConsoleInDeviceGuid,
 333             NULL,
 334             NULL
 335             );
 336     } else {
 337       gBS->CloseProtocol (
 338             ControllerHandle,
 339             &gEfiSimpleTextInProtocolGuid,
 340             This->DriverBindingHandle,
 341             ControllerHandle
 342             );
 343     }
 344   }
 345
 346   return EFI_SUCCESS;
 347 }
 348
 349 EFI_STATUS
 350 EFIAPI
 351 ConPlatformTextOutDriverBindingStart (
 352   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 353   IN  EFI_HANDLE                    ControllerHandle,
 354   IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath
 355   )
 356 /*++
 357
 358 Routine Description:
 359
 360
 361 Arguments:
 362   (Standard DriverBinding Protocol Start() function)
 363
 364 Returns:
 365
 366
 367 --*/
 368 {
 369   EFI_STATUS                    Status;
 370   EFI_DEVICE_PATH_PROTOCOL      *DevicePath;
 371   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *TextOut;
 372   BOOLEAN                       NeedClose;
 373
 374   NeedClose = TRUE;
 375
 376   //
 377   // Get the Device Path Protocol so the environment variables can be updated
 378   //
 379   Status = gBS->OpenProtocol (
 380                   ControllerHandle,
 381                   &gEfiDevicePathProtocolGuid,
 382                   (VOID **) &DevicePath,
 383                   This->DriverBindingHandle,
 384                   ControllerHandle,
 385                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 386                   );
 387   if (EFI_ERROR (Status)) {
 388     return Status;
 389   }
 390   //
 391   // Open the Simple Text Output Protocol BY_DRIVER
 392   //
 393   Status = gBS->OpenProtocol (
 394                   ControllerHandle,
 395                   &gEfiSimpleTextOutProtocolGuid,
 396                   (VOID **) &TextOut,
 397                   This->DriverBindingHandle,
 398                   ControllerHandle,
 399                   EFI_OPEN_PROTOCOL_BY_DRIVER
 400                   );
 401   if (EFI_ERROR (Status)) {
 402     return Status;
 403   }
 404   //
 405   // Check the device handle, if it is a hot plug device,
 406   // do not put the device path into ConOutDev and StdErrDev,
 407   // and install gEfiConsoleOutDeviceGuid to the device handle directly.
 408   // The policy is, make hot plug device plug in and play immediately.
 409   //
 410   if (IsHotPlugDevice (This->DriverBindingHandle, ControllerHandle)) {
 411     gBS->InstallMultipleProtocolInterfaces (
 412           &ControllerHandle,
 413           &gEfiConsoleOutDeviceGuid,
 414           NULL,
 415           NULL
 416           );
 417   } else {
 418     //
 419     // Append the device path to the ConOutDev environment variable
 420     //
 421     ConPlatformUpdateDeviceVariable (
 422       VarConsoleOutDev,
 423       DevicePath,
 424       APPEND
 425       );
 426     //
 427     // Append the device path to the StdErrDev environment variable
 428     //
 429     ConPlatformUpdateDeviceVariable (
 430       VarErrorOutDev,
 431       DevicePath,
 432       APPEND
 433       );
 434
 435     //
 436     // If the device path is an instance in the ConOut environment variable,
 437     // then install EfiConsoleOutDeviceGuid onto ControllerHandle
 438     //
 439     Status = ConPlatformUpdateDeviceVariable (
 440               VarConsoleOut,
 441               DevicePath,
 442               CHECK
 443               );
 444
 445     if (!EFI_ERROR (Status)) {
 446       NeedClose = FALSE;
 447       Status = gBS->InstallMultipleProtocolInterfaces (
 448                       &ControllerHandle,
 449                       &gEfiConsoleOutDeviceGuid,
 450                       NULL,
 451                       NULL
 452                       );
 453     }
 454     //
 455     // If the device path is an instance in the StdErr environment variable,
 456     // then install EfiStandardErrorDeviceGuid onto ControllerHandle
 457     //
 458     Status = ConPlatformUpdateDeviceVariable (
 459               VarErrorOut,
 460               DevicePath,
 461               CHECK
 462               );
 463     if (!EFI_ERROR (Status)) {
 464       NeedClose = FALSE;
 465       gBS->InstallMultipleProtocolInterfaces (
 466             &ControllerHandle,
 467             &gEfiStandardErrorDeviceGuid,
 468             NULL,
 469             NULL
 470             );
 471     }
 472
 473     if (NeedClose) {
 474       gBS->CloseProtocol (
 475             ControllerHandle,
 476             &gEfiSimpleTextOutProtocolGuid,
 477             This->DriverBindingHandle,
 478             ControllerHandle
 479             );
 480     }
 481   }
 482
 483   return EFI_SUCCESS;
 484 }
 485
 486 EFI_STATUS
 487 EFIAPI
 488 ConPlatformTextInDriverBindingStop (
 489   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 490   IN  EFI_HANDLE                   ControllerHandle,
 491   IN  UINTN                        NumberOfChildren,
 492   IN  EFI_HANDLE                   *ChildHandleBuffer
 493   )
 494 /*++
 495
 496 Routine Description:
 497
 498 Arguments:
 499   (Standard DriverBinding Protocol Stop() function)
 500
 501 Returns:
 502
 503   None
 504
 505 --*/
 506 {
 507   EFI_STATUS                Status;
 508   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 509
 510   //
 511   // hot plug device is not included into the console associated variables,
 512   // so no need to check variable for those hot plug devices.
 513   //
 514   if (!IsHotPlugDevice (This->DriverBindingHandle, ControllerHandle)) {
 515     //
 516     // Get the Device Path Protocol so the environment variables can be updated
 517     //
 518     Status = gBS->OpenProtocol (
 519                     ControllerHandle,
 520                     &gEfiDevicePathProtocolGuid,
 521                     (VOID **) &DevicePath,
 522                     This->DriverBindingHandle,
 523                     ControllerHandle,
 524                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 525                     );
 526     if (!EFI_ERROR (Status)) {
 527       //
 528       // Remove DevicePath from ConInDev
 529       //
 530       ConPlatformUpdateDeviceVariable (
 531         VarConsoleInpDev,
 532         DevicePath,
 533         DELETE
 534         );
 535     }
 536   }
 537   //
 538   // Uninstall the Console Device GUIDs from Controller Handle
 539   //
 540   ConPlatformUnInstallProtocol (
 541     This,
 542     ControllerHandle,
 543     &gEfiConsoleInDeviceGuid
 544     );
 545
 546   //
 547   // Close the Simple Input Protocol
 548   //
 549   gBS->CloseProtocol (
 550         ControllerHandle,
 551         &gEfiSimpleTextInProtocolGuid,
 552         This->DriverBindingHandle,
 553         ControllerHandle
 554         );
 555
 556   return EFI_SUCCESS;
 557 }
 558
 559 EFI_STATUS
 560 EFIAPI
 561 ConPlatformTextOutDriverBindingStop (
 562   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 563   IN  EFI_HANDLE                   ControllerHandle,
 564   IN  UINTN                        NumberOfChildren,
 565   IN  EFI_HANDLE                   *ChildHandleBuffer
 566   )
 567 /*++
 568
 569 Routine Description:
 570
 571 Arguments:
 572   (Standard DriverBinding Protocol Stop() function)
 573
 574 Returns:
 575
 576   None
 577
 578 --*/
 579 {
 580   EFI_STATUS                Status;
 581   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 582
 583   //
 584   // hot plug device is not included into the console associated variables,
 585   // so no need to check variable for those hot plug devices.
 586   //
 587   if (!IsHotPlugDevice (This->DriverBindingHandle, ControllerHandle)) {
 588     //
 589     // Get the Device Path Protocol so the environment variables can be updated
 590     //
 591     Status = gBS->OpenProtocol (
 592                     ControllerHandle,
 593                     &gEfiDevicePathProtocolGuid,
 594                     (VOID **) &DevicePath,
 595                     This->DriverBindingHandle,
 596                     ControllerHandle,
 597                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 598                     );
 599     if (!EFI_ERROR (Status)) {
 600       //
 601       // Remove DevicePath from ConOutDev, and StdErrDev
 602       //
 603       ConPlatformUpdateDeviceVariable (
 604         VarConsoleOutDev,
 605         DevicePath,
 606         DELETE
 607         );
 608       ConPlatformUpdateDeviceVariable (
 609         VarErrorOutDev,
 610         DevicePath,
 611         DELETE
 612         );
 613     }
 614   }
 615   //
 616   // Uninstall the Console Device GUIDs from Controller Handle
 617   //
 618   ConPlatformUnInstallProtocol (
 619     This,
 620     ControllerHandle,
 621     &gEfiConsoleOutDeviceGuid
 622     );
 623
 624   ConPlatformUnInstallProtocol (
 625     This,
 626     ControllerHandle,
 627     &gEfiStandardErrorDeviceGuid
 628     );
 629
 630   //
 631   // Close the Simple Text Output Protocol
 632   //
 633   gBS->CloseProtocol (
 634         ControllerHandle,
 635         &gEfiSimpleTextOutProtocolGuid,
 636         This->DriverBindingHandle,
 637         ControllerHandle
 638         );
 639
 640   return EFI_SUCCESS;
 641 }
 642
 643
 644 VOID
 645 ConPlatformUnInstallProtocol (
 646   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 647   IN  EFI_HANDLE                   Handle,
 648   IN  EFI_GUID                     *ProtocolGuid
 649   )
 650 {
 651   EFI_STATUS  Status;
 652
 653   Status = gBS->OpenProtocol (
 654                   Handle,
 655                   ProtocolGuid,
 656                   NULL,
 657                   This->DriverBindingHandle,
 658                   Handle,
 659                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 660                   );
 661
 662   if (!EFI_ERROR (Status)) {
 663     gBS->UninstallMultipleProtocolInterfaces (
 664           Handle,
 665           ProtocolGuid,
 666           NULL,
 667           NULL
 668           );
 669   }
 670
 671   return ;
 672 }
 673
 674 VOID *
 675 ConPlatformGetVariable (
 676   IN  CHAR16    *Name
 677   )
 678 /*++
 679
 680 Routine Description:
 681   Read the EFI variable (Name) and return a dynamically allocated
 682   buffer, and the size of the buffer. On failure return NULL.
 683
 684 Arguments:
 685   Name       - String part of EFI variable name
 686
 687 Returns:
 688   Dynamically allocated memory that contains a copy of the EFI variable.
 689   Caller is repsoncible freeing the buffer.
 690
 691   NULL - Variable was not read
 692
 693 --*/
 694 {
 695   EFI_STATUS  Status;
 696   VOID        *Buffer;
 697   UINTN       BufferSize;
 698
 699   BufferSize  = 0;
 700   Buffer      = NULL;
 701
 702   //
 703   // Test to see if the variable exists.  If it doesn't reuturn NULL
 704   //
 705   Status = gRT->GetVariable (
 706                   Name,
 707                   &gEfiGlobalVariableGuid,
 708                   NULL,
 709                   &BufferSize,
 710                   Buffer
 711                   );
 712
 713   if (Status == EFI_BUFFER_TOO_SMALL) {
 714     //
 715     // Allocate the buffer to return
 716     //
 717     Buffer = AllocatePool (BufferSize);
 718     if (Buffer == NULL) {
 719       return NULL;
 720     }
 721     //
 722     // Read variable into the allocated buffer.
 723     //
 724     Status = gRT->GetVariable (
 725                     Name,
 726                     &gEfiGlobalVariableGuid,
 727                     NULL,
 728                     &BufferSize,
 729                     Buffer
 730                     );
 731     if (EFI_ERROR (Status)) {
 732       FreePool (Buffer);
 733       Buffer = NULL;
 734     }
 735   }
 736
 737   return Buffer;
 738 }
 739
 740 EFI_STATUS
 741 ConPlatformMatchDevicePaths (
 742   IN  EFI_DEVICE_PATH_PROTOCOL  * Multi,
 743   IN  EFI_DEVICE_PATH_PROTOCOL  * Single,
 744   IN  EFI_DEVICE_PATH_PROTOCOL  **NewDevicePath OPTIONAL,
 745   IN  BOOLEAN                   Delete
 746   )
 747 /*++
 748
 749 Routine Description:
 750   Function compares a device path data structure to that of all the nodes of a
 751   second device path instance.
 752
 753 Arguments:
 754   Multi        - A pointer to a multi-instance device path data structure.
 755
 756   Single       - A pointer to a single-instance device path data structure.
 757
 758   NewDevicePath - If Delete is TRUE, this parameter must not be null, and it
 759                   points to the remaining device path data structure.
 760                   (remaining device path = Multi - Single.)
 761
 762   Delete        - If TRUE, means removing Single from Multi.
 763                   If FALSE, the routine just check whether Single matches
 764                   with any instance in Multi.
 765
 766 Returns:
 767
 768   The function returns EFI_SUCCESS if the Single is contained within Multi.
 769   Otherwise, EFI_NOT_FOUND is returned.
 770
 771 --*/
 772 {
 773   EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 774   EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath1;
 775   EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath2;
 776   EFI_DEVICE_PATH_PROTOCOL  *DevicePathInst;
 777   UINTN                     Size;
 778
 779   //
 780   // The passed in DevicePath should not be NULL
 781   //
 782   if ((!Multi) || (!Single)) {
 783     return EFI_NOT_FOUND;
 784   }
 785   //
 786   // if performing Delete operation, the NewDevicePath must not be NULL.
 787   //
 788   TempDevicePath1 = NULL;
 789
 790   DevicePath      = Multi;
 791   DevicePathInst  = GetNextDevicePathInstance (&DevicePath, &Size);
 792
 793   //
 794   // search for the match of 'Single' in 'Multi'
 795   //
 796   while (DevicePathInst) {
 797     if (CompareMem (Single, DevicePathInst, Size) == 0) {
 798       if (!Delete) {
 799         FreePool (DevicePathInst);
 800         return EFI_SUCCESS;
 801       }
 802     } else {
 803       if (Delete) {
 804         TempDevicePath2 = AppendDevicePathInstance (
 805                             TempDevicePath1,
 806                             DevicePathInst
 807                             );
 808         if (TempDevicePath1 != NULL) {
 809           FreePool (TempDevicePath1);
 810         }
 811         TempDevicePath1 = TempDevicePath2;
 812       }
 813     }
 814
 815     FreePool (DevicePathInst);
 816     DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
 817   }
 818
 819   if (Delete) {
 820     *NewDevicePath = TempDevicePath1;
 821     return EFI_SUCCESS;
 822   }
 823
 824   return EFI_NOT_FOUND;
 825 }
 826
 827 EFI_STATUS
 828 ConPlatformUpdateDeviceVariable (
 829   IN  CHAR16                    *VariableName,
 830   IN  EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
 831   IN  CONPLATFORM_VAR_OPERATION Operation
 832   )
 833 /*++
 834
 835 Routine Description:
 836
 837
 838 Arguments:
 839
 840 Returns:
 841
 842   None
 843
 844 --*/
 845 {
 846   EFI_STATUS                Status;
 847   EFI_DEVICE_PATH_PROTOCOL  *VariableDevicePath;
 848   EFI_DEVICE_PATH_PROTOCOL  *NewVariableDevicePath;
 849
 850   VariableDevicePath    = NULL;
 851   NewVariableDevicePath = NULL;
 852
 853   //
 854   // Get Variable according to variable name.
 855   // The memory for Variable is allocated within ConPlatformGetVarible(),
 856   // it is the caller's responsibility to free the memory before return.
 857   //
 858   VariableDevicePath = ConPlatformGetVariable (VariableName);
 859
 860   if (Operation != DELETE) {
 861
 862     Status = ConPlatformMatchDevicePaths (
 863               VariableDevicePath,
 864               DevicePath,
 865               NULL,
 866               FALSE
 867               );
 868
 869     if ((Operation == CHECK) || (!EFI_ERROR (Status))) {
 870       //
 871       // The device path is already in the variable
 872       //
 873       if (VariableDevicePath != NULL) {
 874         FreePool (VariableDevicePath);
 875       }
 876
 877       return Status;
 878     }
 879     //
 880     // The device path is not in variable. Append DevicePath to the
 881     // environment variable that is a multi-instance device path.
 882     //
 883     Status = EFI_SUCCESS;
 884     NewVariableDevicePath = AppendDevicePathInstance (
 885                               VariableDevicePath,
 886                               DevicePath
 887                               );
 888     if (NewVariableDevicePath == NULL) {
 889       Status = EFI_OUT_OF_RESOURCES;
 890     }
 891
 892   } else {
 893     //
 894     // Remove DevicePath from the environment variable that
 895     // is a multi-instance device path.
 896     //
 897     Status = ConPlatformMatchDevicePaths (
 898               VariableDevicePath,
 899               DevicePath,
 900               &NewVariableDevicePath,
 901               TRUE
 902               );
 903   }
 904
 905   if (VariableDevicePath != NULL) {
 906     FreePool (VariableDevicePath);
 907   }
 908
 909   if (EFI_ERROR (Status)) {
 910     return Status;
 911   }
 912
 913   Status = gRT->SetVariable (
 914                   VariableName,
 915                   &gEfiGlobalVariableGuid,
 916                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 917                   GetDevicePathSize (NewVariableDevicePath),
 918                   NewVariableDevicePath
 919                   );
 920
 921   FreePool (NewVariableDevicePath);
 922
 923   return Status;
 924 }
 925
 926 BOOLEAN
 927 IsHotPlugDevice (
 928   EFI_HANDLE    DriverBindingHandle,
 929   EFI_HANDLE    ControllerHandle
 930   )
 931 {
 932   EFI_STATUS  Status;
 933
 934   //
 935   // HotPlugDeviceGuid indicates ControllerHandle stands for a hot plug device.
 936   //
 937   Status = gBS->OpenProtocol (
 938                   ControllerHandle,
 939                   &gEfiHotPlugDeviceGuid,
 940                   NULL,
 941                   DriverBindingHandle,
 942                   ControllerHandle,
 943                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 944                   );
 945   if (EFI_ERROR (Status)) {
 946     return FALSE;
 947   }
 948
 949   return TRUE;
 950 }