MdeModulePkg/Library/UefiBootManagerLib/BmConsole.c

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