[mirror_edk2.git] / MdeModulePkg / Universal / Console / TerminalDxe / Terminal.c

/** @file\r
  Produces Simple Text Input Protocol, Simple Text Input Extended Protocol and\r
  Simple Text Output Protocol upon Serial IO Protocol.\r
\r
Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
\r
#include "Terminal.h"\r
\r
//\r
// Globals\r
//\r
EFI_DRIVER_BINDING_PROTOCOL gTerminalDriverBinding = {\r
  TerminalDriverBindingSupported,\r
  TerminalDriverBindingStart,\r
  TerminalDriverBindingStop,\r
  0xa,\r
  NULL,\r
  NULL\r
};\r
\r
\r
EFI_GUID  *mTerminalType[] = {\r
  &gEfiPcAnsiGuid,\r
  &gEfiVT100Guid,\r
  &gEfiVT100PlusGuid,\r
  &gEfiVTUTF8Guid,\r
  &gEfiTtyTermGuid,\r
  &gEdkiiLinuxTermGuid,\r
  &gEdkiiXtermR6Guid,\r
  &gEdkiiVT400Guid,\r
  &gEdkiiSCOTermGuid\r
};\r
\r
\r
CHAR16 *mSerialConsoleNames[] = {\r
  L"PC-ANSI Serial Console",\r
  L"VT-100 Serial Console",\r
  L"VT-100+ Serial Console",\r
  L"VT-UTF8 Serial Console",\r
  L"Tty Terminal Serial Console",\r
  L"Linux Terminal Serial Console",\r
  L"Xterm R6 Serial Console",\r
  L"VT-400 Serial Console",\r
  L"SCO Terminal Serial Console"\r
};\r
\r
TERMINAL_DEV  mTerminalDevTemplate = {\r
  TERMINAL_DEV_SIGNATURE,\r
  NULL,\r
  0,\r
  NULL,\r
  NULL,\r
  {   // SimpleTextInput\r
    TerminalConInReset,\r
    TerminalConInReadKeyStroke,\r
    NULL\r
  },\r
  {   // SimpleTextOutput\r
    TerminalConOutReset,\r
    TerminalConOutOutputString,\r
    TerminalConOutTestString,\r
    TerminalConOutQueryMode,\r
    TerminalConOutSetMode,\r
    TerminalConOutSetAttribute,\r
    TerminalConOutClearScreen,\r
    TerminalConOutSetCursorPosition,\r
    TerminalConOutEnableCursor,\r
    NULL\r
  },\r
  {   // SimpleTextOutputMode\r
    1,                                           // MaxMode\r
    0,                                           // Mode\r
    EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK),    // Attribute\r
    0,                                           // CursorColumn\r
    0,                                           // CursorRow\r
    TRUE                                         // CursorVisible\r
  },\r
  NULL, // TerminalConsoleModeData\r
  0,  // SerialInTimeOut\r
\r
  NULL, // RawFifo\r
  NULL, // UnicodeFiFo\r
  NULL, // EfiKeyFiFo\r
  NULL, // EfiKeyFiFoForNotify\r
\r
  NULL, // ControllerNameTable\r
  NULL, // TimerEvent\r
  NULL, // TwoSecondTimeOut\r
  INPUT_STATE_DEFAULT,\r
  RESET_STATE_DEFAULT,\r
  {\r
      0,\r
      0,\r
      0\r
  },\r
  0,\r
  FALSE,\r
  {   // SimpleTextInputEx\r
    TerminalConInResetEx,\r
    TerminalConInReadKeyStrokeEx,\r
    NULL,\r
    TerminalConInSetState,\r
    TerminalConInRegisterKeyNotify,\r
    TerminalConInUnregisterKeyNotify,\r
  },\r
  {   // NotifyList\r
    NULL,\r
    NULL,\r
  },\r
  NULL // KeyNotifyProcessEvent\r
};\r
\r
TERMINAL_CONSOLE_MODE_DATA mTerminalConsoleModeData[] = {\r
  {80,  25},\r
  {80,  50},\r
  {100, 31},\r
  //\r
  // New modes can be added here.\r
  //\r
};\r
\r
/**\r
  Convert the GUID representation of terminal type to enum type.\r
\r
  @param Guid  The GUID representation of terminal type.\r
\r
  @return  The terminal type in enum type.\r
**/\r
TERMINAL_TYPE\r
TerminalTypeFromGuid (\r
  IN EFI_GUID                     *Guid\r
)\r
{\r
  TERMINAL_TYPE                   Type;\r
\r
  for (Type = 0; Type < ARRAY_SIZE (mTerminalType); Type++) {\r
    if (CompareGuid (Guid, mTerminalType[Type])) {\r
      break;\r
    }\r
  }\r
  return Type;\r
}\r
\r
/**\r
  Test to see if this driver supports Controller.\r
\r
  @param  This                Protocol instance pointer.\r
  @param  Controller          Handle of device to test\r
  @param  RemainingDevicePath Optional parameter use to pick a specific child\r
                              device to start.\r
\r
  @retval EFI_SUCCESS         This driver supports this device.\r
  @retval EFI_ALREADY_STARTED This driver is already running on this device.\r
  @retval other               This driver does not support this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
TerminalDriverBindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN EFI_HANDLE                     Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;\r
  EFI_SERIAL_IO_PROTOCOL    *SerialIo;\r
  VENDOR_DEVICE_PATH        *Node;\r
\r
  //\r
  // If remaining device path is not NULL, then make sure it is a\r
  // device path that describes a terminal communications protocol.\r
  //\r
  if (RemainingDevicePath != NULL) {\r
    //\r
    // Check if RemainingDevicePath is the End of Device Path Node,\r
    // if yes, go on checking other conditions\r
    //\r
    if (!IsDevicePathEnd (RemainingDevicePath)) {\r
      //\r
      // If RemainingDevicePath isn't the End of Device Path Node,\r
      // check its validation\r
      //\r
      Node = (VENDOR_DEVICE_PATH *) RemainingDevicePath;\r
\r
      if (Node->Header.Type != MESSAGING_DEVICE_PATH ||\r
          Node->Header.SubType != MSG_VENDOR_DP ||\r
          DevicePathNodeLength(&Node->Header) != sizeof(VENDOR_DEVICE_PATH)) {\r
\r
        return EFI_UNSUPPORTED;\r
\r
      }\r
      //\r
      // only supports PC ANSI, VT100, VT100+, VT-UTF8, TtyTerm\r
      // Linux, XtermR6, VT400 and SCO terminal types\r
      //\r
      if (TerminalTypeFromGuid (&Node->Guid) == ARRAY_SIZE (mTerminalType)) {\r
        return EFI_UNSUPPORTED;\r
      }\r
    }\r
  }\r
  //\r
  // Open the IO Abstraction(s) needed to perform the supported test\r
  // The Controller must support the Serial I/O Protocol.\r
  // This driver is a bus driver with at most 1 child device, so it is\r
  // ok for it to be already started.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiSerialIoProtocolGuid,\r
                  (VOID **) &SerialIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (Status == EFI_ALREADY_STARTED) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Close the I/O Abstraction(s) used to perform the supported test\r
  //\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiSerialIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  //\r
  // Open the EFI Device Path protocol needed to perform the supported test\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiDevicePathProtocolGuid,\r
                  (VOID **) &ParentDevicePath,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (Status == EFI_ALREADY_STARTED) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocol, don't use device path protocol in the Support() function\r
  //\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiDevicePathProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  return Status;\r
}\r
\r
\r
/**\r
  Free notify functions list.\r
\r
  @param  ListHead               The list head\r
\r
  @retval EFI_SUCCESS            Free the notify list successfully.\r
  @retval EFI_INVALID_PARAMETER  ListHead is NULL.\r
\r
**/\r
EFI_STATUS\r
TerminalFreeNotifyList (\r
  IN OUT LIST_ENTRY           *ListHead\r
  )\r
{\r
  TERMINAL_CONSOLE_IN_EX_NOTIFY *NotifyNode;\r
\r
  if (ListHead == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  while (!IsListEmpty (ListHead)) {\r
    NotifyNode = CR (\r
                   ListHead->ForwardLink,\r
                   TERMINAL_CONSOLE_IN_EX_NOTIFY,\r
                   NotifyEntry,\r
                   TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE\r
                   );\r
    RemoveEntryList (ListHead->ForwardLink);\r
    FreePool (NotifyNode);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Initialize all the text modes which the terminal console supports.\r
\r
  It returns information for available text modes that the terminal can support.\r
\r
  @param[out] TextModeCount      The total number of text modes that terminal console supports.\r
\r
  @return   The buffer to the text modes column and row information.\r
            Caller is responsible to free it when it's non-NULL.\r
\r
**/\r
TERMINAL_CONSOLE_MODE_DATA *\r
InitializeTerminalConsoleTextMode (\r
  OUT INT32                         *TextModeCount\r
)\r
{\r
  TERMINAL_CONSOLE_MODE_DATA  *TextModeData;\r
\r
  ASSERT (TextModeCount != NULL);\r
\r
  TextModeData = AllocateCopyPool (sizeof (mTerminalConsoleModeData), mTerminalConsoleModeData);\r
  if (TextModeData == NULL) {\r
    return NULL;\r
  }\r
  *TextModeCount = ARRAY_SIZE (mTerminalConsoleModeData);\r
\r
  DEBUG_CODE_BEGIN ();\r
    INT32 Index;\r
    for (Index = 0; Index < *TextModeCount; Index++) {\r
      DEBUG ((DEBUG_INFO, "Terminal - Mode %d, Column = %d, Row = %d\n",\r
              Index, TextModeData[Index].Columns, TextModeData[Index].Rows));\r
    }\r
  DEBUG_CODE_END ();\r
  return TextModeData;\r
}\r
\r
/**\r
  Stop the terminal state machine.\r
\r
  @param TerminalDevice    The terminal device.\r
**/\r
VOID\r
StopTerminalStateMachine (\r
  TERMINAL_DEV             *TerminalDevice\r
  )\r
{\r
  EFI_TPL                  OriginalTpl;\r
\r
  OriginalTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
\r
  gBS->CloseEvent (TerminalDevice->TimerEvent);\r
  gBS->CloseEvent (TerminalDevice->TwoSecondTimeOut);\r
\r
  gBS->RestoreTPL (OriginalTpl);\r
}\r
\r
/**\r
  Start the terminal state machine.\r
\r
  @param TerminalDevice    The terminal device.\r
**/\r
VOID\r
StartTerminalStateMachine (\r
  TERMINAL_DEV             *TerminalDevice\r
  )\r
{\r
  EFI_STATUS               Status;\r
  Status = gBS->CreateEvent (\r
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,\r
                  TPL_NOTIFY,\r
                  TerminalConInTimerHandler,\r
                  TerminalDevice,\r
                  &TerminalDevice->TimerEvent\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->SetTimer (\r
                  TerminalDevice->TimerEvent,\r
                  TimerPeriodic,\r
                  KEYBOARD_TIMER_INTERVAL\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_TIMER,\r
                  TPL_CALLBACK,\r
                  NULL,\r
                  NULL,\r
                  &TerminalDevice->TwoSecondTimeOut\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
}\r
\r
/**\r
  Initialize the controller name table.\r
\r
  @param TerminalType        The terminal type.\r
  @param ControllerNameTable The controller name table.\r
\r
  @retval EFI_SUCCESS  The controller name table is initialized successfully.\r
  @retval others       Return status of AddUnicodeString2 ().\r
**/\r
EFI_STATUS\r
InitializeControllerNameTable (\r
  TERMINAL_TYPE             TerminalType,\r
  EFI_UNICODE_STRING_TABLE  **ControllerNameTable\r
)\r
{\r
  EFI_STATUS                Status;\r
  EFI_UNICODE_STRING_TABLE  *Table;\r
\r
  ASSERT (TerminalType < ARRAY_SIZE (mTerminalType));\r
  Table = NULL;\r
  Status = AddUnicodeString2 (\r
             "eng",\r
             gTerminalComponentName.SupportedLanguages,\r
             &Table,\r
             mSerialConsoleNames[TerminalType],\r
             TRUE\r
             );\r
  if (!EFI_ERROR (Status)) {\r
    Status = AddUnicodeString2 (\r
               "en",\r
               gTerminalComponentName2.SupportedLanguages,\r
               &Table,\r
               mSerialConsoleNames[TerminalType],\r
               FALSE\r
               );\r
    if (EFI_ERROR (Status)) {\r
      FreeUnicodeStringTable (Table);\r
    }\r
  }\r
  if (!EFI_ERROR (Status)) {\r
    *ControllerNameTable = Table;\r
  }\r
  return Status;\r
}\r
\r
/**\r
  Start this driver on Controller by opening a Serial IO protocol,\r
  reading Device Path, and creating a child handle with a Simple Text In,\r
  Simple Text In Ex and Simple Text Out protocol, and device path protocol.\r
  And store Console Device Environment Variables.\r
\r
  @param  This                 Protocol instance pointer.\r
  @param  Controller           Handle of device to bind driver to\r
  @param  RemainingDevicePath  Optional parameter use to pick a specific child\r
                               device to start.\r
\r
  @retval EFI_SUCCESS          This driver is added to Controller.\r
  @retval EFI_ALREADY_STARTED  This driver is already running on Controller.\r
  @retval other                This driver does not support this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
TerminalDriverBindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN EFI_HANDLE                     Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  EFI_SERIAL_IO_PROTOCOL              *SerialIo;\r
  EFI_DEVICE_PATH_PROTOCOL            *ParentDevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL            *Vendor;\r
  EFI_HANDLE                          SerialIoHandle;\r
  EFI_SERIAL_IO_MODE                  *Mode;\r
  UINTN                               SerialInTimeOut;\r
  TERMINAL_DEV                        *TerminalDevice;\r
  UINT8                               TerminalType;\r
  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;\r
  UINTN                               EntryCount;\r
  UINTN                               Index;\r
  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL     *SimpleTextOutput;\r
  EFI_SIMPLE_TEXT_INPUT_PROTOCOL      *SimpleTextInput;\r
  EFI_UNICODE_STRING_TABLE            *ControllerNameTable;\r
\r
  //\r
  // Get the Device Path Protocol to build the device path of the child device\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiDevicePathProtocolGuid,\r
                  (VOID **) &ParentDevicePath,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  ASSERT ((Status == EFI_SUCCESS) || (Status == EFI_ALREADY_STARTED));\r
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Open the Serial I/O Protocol BY_DRIVER.  It might already be started.\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiSerialIoProtocolGuid,\r
                  (VOID **) &SerialIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  ASSERT ((Status == EFI_SUCCESS) || (Status == EFI_ALREADY_STARTED));\r
  if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) {\r
    return Status;\r
  }\r
\r
  if (!IsHotPlugDevice (ParentDevicePath)) {\r
    //\r
    // if the serial device is a hot plug device, do not update the\r
    // ConInDev, ConOutDev, and StdErrDev variables.\r
    //\r
    TerminalUpdateConsoleDevVariable (EFI_CON_IN_DEV_VARIABLE_NAME, ParentDevicePath);\r
    TerminalUpdateConsoleDevVariable (EFI_CON_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
    TerminalUpdateConsoleDevVariable (EFI_ERR_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
  }\r
\r
  //\r
  // Do not create any child for END remaining device path.\r
  //\r
  if ((RemainingDevicePath != NULL) && IsDevicePathEnd (RemainingDevicePath)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  if (Status == EFI_ALREADY_STARTED) {\r
\r
    if (RemainingDevicePath == NULL) {\r
      //\r
      // If RemainingDevicePath is NULL or is the End of Device Path Node\r
      //\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // This driver can only produce one child per serial port.\r
    // Change its terminal type as remaining device path requests.\r
    //\r
    Status = gBS->OpenProtocolInformation (\r
                    Controller,\r
                    &gEfiSerialIoProtocolGuid,\r
                    &OpenInfoBuffer,\r
                    &EntryCount\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
      Status = EFI_NOT_FOUND;\r
      for (Index = 0; Index < EntryCount; Index++) {\r
        if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {\r
          Status = gBS->OpenProtocol (\r
                          OpenInfoBuffer[Index].ControllerHandle,\r
                          &gEfiSimpleTextInProtocolGuid,\r
                          (VOID **) &SimpleTextInput,\r
                          This->DriverBindingHandle,\r
                          Controller,\r
                          EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                          );\r
          if (!EFI_ERROR (Status)) {\r
            TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (SimpleTextInput);\r
            TerminalType = TerminalTypeFromGuid (&((VENDOR_DEVICE_PATH *) RemainingDevicePath)->Guid);\r
            ASSERT (TerminalType < ARRAY_SIZE (mTerminalType));\r
            if (TerminalDevice->TerminalType != TerminalType) {\r
              Status = InitializeControllerNameTable (TerminalType, &ControllerNameTable);\r
              if (!EFI_ERROR (Status)) {\r
                StopTerminalStateMachine (TerminalDevice);\r
                //\r
                // Update the device path\r
                //\r
                Vendor = TerminalDevice->DevicePath;\r
                Status = gBS->LocateDevicePath (&gEfiSerialIoProtocolGuid, &Vendor, &SerialIoHandle);\r
                ASSERT_EFI_ERROR (Status);\r
                CopyGuid (&((VENDOR_DEVICE_PATH *) Vendor)->Guid, mTerminalType[TerminalType]);\r
                Status = gBS->ReinstallProtocolInterface (\r
                                TerminalDevice->Handle,\r
                                &gEfiDevicePathProtocolGuid,\r
                                TerminalDevice->DevicePath,\r
                                TerminalDevice->DevicePath\r
                                );\r
                if (!EFI_ERROR (Status)) {\r
                  TerminalDevice->TerminalType = TerminalType;\r
                  StartTerminalStateMachine (TerminalDevice);\r
                  FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);\r
                  TerminalDevice->ControllerNameTable = ControllerNameTable;\r
                } else {\r
                  //\r
                  // Restore the device path on failure\r
                  //\r
                  CopyGuid (&((VENDOR_DEVICE_PATH *) Vendor)->Guid, mTerminalType[TerminalDevice->TerminalType]);\r
                  FreeUnicodeStringTable (ControllerNameTable);\r
                }\r
              }\r
            }\r
          }\r
          break;\r
        }\r
      }\r
      FreePool (OpenInfoBuffer);\r
    }\r
    return Status;\r
  }\r
\r
  //\r
  // Initialize the Terminal Dev\r
  //\r
  TerminalDevice = AllocateCopyPool (sizeof (TERMINAL_DEV), &mTerminalDevTemplate);\r
  if (TerminalDevice == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto CloseProtocols;\r
  }\r
\r
  if (RemainingDevicePath == NULL) {\r
    //\r
    // If RemainingDevicePath is NULL, use default terminal type\r
    //\r
    TerminalDevice->TerminalType = PcdGet8 (PcdDefaultTerminalType);\r
  } else {\r
    //\r
    // End of Device Path Node is handled in above.\r
    //\r
    ASSERT (!IsDevicePathEnd (RemainingDevicePath));\r
    //\r
    // If RemainingDevicePath isn't the End of Device Path Node,\r
    // Use the RemainingDevicePath to determine the terminal type\r
    //\r
    TerminalDevice->TerminalType = TerminalTypeFromGuid (&((VENDOR_DEVICE_PATH *) RemainingDevicePath)->Guid);\r
  }\r
  ASSERT (TerminalDevice->TerminalType < ARRAY_SIZE (mTerminalType));\r
  TerminalDevice->SerialIo = SerialIo;\r
\r
  //\r
  // Build the component name for the child device\r
  //\r
  Status = InitializeControllerNameTable (TerminalDevice->TerminalType, &TerminalDevice->ControllerNameTable);\r
  if (EFI_ERROR (Status)) {\r
    goto FreeResources;\r
  }\r
\r
  //\r
  // Build the device path for the child device\r
  //\r
  Status = SetTerminalDevicePath (TerminalDevice->TerminalType, ParentDevicePath, &TerminalDevice->DevicePath);\r
  if (EFI_ERROR (Status)) {\r
    goto FreeResources;\r
  }\r
\r
  InitializeListHead (&TerminalDevice->NotifyList);\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_WAIT,\r
                  TPL_NOTIFY,\r
                  TerminalConInWaitForKeyEx,\r
                  TerminalDevice,\r
                  &TerminalDevice->SimpleInputEx.WaitForKeyEx\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_WAIT,\r
                  TPL_NOTIFY,\r
                  TerminalConInWaitForKey,\r
                  TerminalDevice,\r
                  &TerminalDevice->SimpleInput.WaitForKey\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
  Status = gBS->CreateEvent (\r
                  EVT_NOTIFY_SIGNAL,\r
                  TPL_CALLBACK,\r
                  KeyNotifyProcessHandler,\r
                  TerminalDevice,\r
                  &TerminalDevice->KeyNotifyProcessEvent\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //\r
  // Allocates and initializes the FIFO buffer to be zero, used for accommodating\r
  // the pre-read pending characters.\r
  //\r
  TerminalDevice->RawFiFo = AllocateZeroPool (sizeof (RAW_DATA_FIFO));\r
  if (TerminalDevice->RawFiFo == NULL) {\r
    goto FreeResources;\r
  }\r
  TerminalDevice->UnicodeFiFo = AllocateZeroPool (sizeof (UNICODE_FIFO));\r
  if (TerminalDevice->UnicodeFiFo == NULL) {\r
    goto FreeResources;\r
  }\r
  TerminalDevice->EfiKeyFiFo = AllocateZeroPool (sizeof (EFI_KEY_FIFO));\r
  if (TerminalDevice->EfiKeyFiFo == NULL) {\r
    goto FreeResources;\r
  }\r
  TerminalDevice->EfiKeyFiFoForNotify = AllocateZeroPool (sizeof (EFI_KEY_FIFO));\r
  if (TerminalDevice->EfiKeyFiFoForNotify == NULL) {\r
    goto FreeResources;\r
  }\r
\r
  //\r
  // Set the timeout value of serial buffer for keystroke response performance issue\r
  //\r
  Mode = TerminalDevice->SerialIo->Mode;\r
\r
  SerialInTimeOut = 0;\r
  if (Mode->BaudRate != 0) {\r
    SerialInTimeOut = (1 + Mode->DataBits + Mode->StopBits) * 2 * 1000000 / (UINTN) Mode->BaudRate;\r
  }\r
\r
  Status = TerminalDevice->SerialIo->SetAttributes (\r
                                       TerminalDevice->SerialIo,\r
                                       Mode->BaudRate,\r
                                       Mode->ReceiveFifoDepth,\r
                                       (UINT32) SerialInTimeOut,\r
                                       (EFI_PARITY_TYPE) (Mode->Parity),\r
                                       (UINT8) Mode->DataBits,\r
                                       (EFI_STOP_BITS_TYPE) (Mode->StopBits)\r
                                       );\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // if set attributes operation fails, invalidate\r
    // the value of SerialInTimeOut,thus make it\r
    // inconsistent with the default timeout value\r
    // of serial buffer. This will invoke the recalculation\r
    // in the readkeystroke routine.\r
    //\r
    TerminalDevice->SerialInTimeOut = 0;\r
  } else {\r
    TerminalDevice->SerialInTimeOut = SerialInTimeOut;\r
  }\r
\r
  SimpleTextOutput = &TerminalDevice->SimpleTextOutput;\r
  SimpleTextInput = &TerminalDevice->SimpleInput;\r
\r
  //\r
  // Initialize SimpleTextOut instance\r
  //\r
  SimpleTextOutput->Mode = &TerminalDevice->SimpleTextOutputMode;\r
  TerminalDevice->TerminalConsoleModeData = InitializeTerminalConsoleTextMode (\r
    &SimpleTextOutput->Mode->MaxMode\r
  );\r
  if (TerminalDevice->TerminalConsoleModeData == NULL) {\r
    goto FreeResources;\r
  }\r
  //\r
  // For terminal devices, cursor is always visible\r
  //\r
  SimpleTextOutput->Mode->CursorVisible = TRUE;\r
  Status = SimpleTextOutput->SetAttribute (SimpleTextOutput, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));\r
  if (!EFI_ERROR (Status)) {\r
    Status = SimpleTextOutput->Reset (SimpleTextOutput, FALSE);\r
  }\r
  if (EFI_ERROR (Status)) {\r
    goto ReportError;\r
  }\r
\r
  //\r
  // Initialize SimpleTextInput instance\r
  //\r
  Status = SimpleTextInput->Reset (SimpleTextInput, FALSE);\r
  if (EFI_ERROR (Status)) {\r
    goto ReportError;\r
  }\r
\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &TerminalDevice->Handle,\r
                  &gEfiSimpleTextInProtocolGuid,      &TerminalDevice->SimpleInput,\r
                  &gEfiSimpleTextInputExProtocolGuid, &TerminalDevice->SimpleInputEx,\r
                  &gEfiSimpleTextOutProtocolGuid,     &TerminalDevice->SimpleTextOutput,\r
                  &gEfiDevicePathProtocolGuid,        TerminalDevice->DevicePath,\r
                  NULL\r
                  );\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->OpenProtocol (\r
                    Controller,\r
                    &gEfiSerialIoProtocolGuid,\r
                    (VOID **) &TerminalDevice->SerialIo,\r
                    This->DriverBindingHandle,\r
                    TerminalDevice->Handle,\r
                    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
    StartTerminalStateMachine (TerminalDevice);\r
    return Status;\r
  }\r
\r
ReportError:\r
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
    EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
    (EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR),\r
    ParentDevicePath\r
    );\r
\r
FreeResources:\r
  ASSERT (TerminalDevice != NULL);\r
\r
  if (TerminalDevice->SimpleInput.WaitForKey != NULL) {\r
    gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);\r
  }\r
  if (TerminalDevice->SimpleInputEx.WaitForKeyEx != NULL) {\r
    gBS->CloseEvent (TerminalDevice->SimpleInputEx.WaitForKeyEx);\r
  }\r
  if (TerminalDevice->KeyNotifyProcessEvent != NULL) {\r
    gBS->CloseEvent (TerminalDevice->KeyNotifyProcessEvent);\r
  }\r
\r
  if (TerminalDevice->RawFiFo != NULL) {\r
    FreePool (TerminalDevice->RawFiFo);\r
  }\r
  if (TerminalDevice->UnicodeFiFo != NULL) {\r
    FreePool (TerminalDevice->UnicodeFiFo);\r
  }\r
  if (TerminalDevice->EfiKeyFiFo != NULL) {\r
    FreePool (TerminalDevice->EfiKeyFiFo);\r
  }\r
  if (TerminalDevice->EfiKeyFiFoForNotify != NULL) {\r
    FreePool (TerminalDevice->EfiKeyFiFoForNotify);\r
  }\r
\r
  if (TerminalDevice->ControllerNameTable != NULL) {\r
    FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);\r
  }\r
\r
  if (TerminalDevice->DevicePath != NULL) {\r
    FreePool (TerminalDevice->DevicePath);\r
  }\r
\r
  if (TerminalDevice->TerminalConsoleModeData != NULL) {\r
    FreePool (TerminalDevice->TerminalConsoleModeData);\r
  }\r
\r
  FreePool (TerminalDevice);\r
\r
CloseProtocols:\r
\r
  //\r
  // Remove Parent Device Path from\r
  // the Console Device Environment Variables\r
  //\r
  TerminalRemoveConsoleDevVariable (EFI_CON_IN_DEV_VARIABLE_NAME, ParentDevicePath);\r
  TerminalRemoveConsoleDevVariable (EFI_CON_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
  TerminalRemoveConsoleDevVariable (EFI_ERR_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
\r
  Status = gBS->CloseProtocol (\r
                  Controller,\r
                  &gEfiSerialIoProtocolGuid,\r
                  This->DriverBindingHandle,\r
                  Controller\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->CloseProtocol (\r
                  Controller,\r
                  &gEfiDevicePathProtocolGuid,\r
                  This->DriverBindingHandle,\r
                  Controller\r
                  );\r
  ASSERT_EFI_ERROR (Status);\r
  return Status;\r
}\r
\r
/**\r
  Stop this driver on Controller by closing Simple Text In, Simple Text\r
  In Ex, Simple Text Out protocol, and removing parent device path from\r
  Console Device Environment Variables.\r
\r
  @param  This              Protocol instance pointer.\r
  @param  Controller        Handle of device to stop driver on\r
  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of\r
                            children is zero stop the entire bus driver.\r
  @param  ChildHandleBuffer List of Child Handles to Stop.\r
\r
  @retval EFI_SUCCESS       This driver is removed Controller.\r
  @retval other             This driver could not be removed from this device.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
TerminalDriverBindingStop (\r
  IN  EFI_DRIVER_BINDING_PROTOCOL   *This,\r
  IN  EFI_HANDLE                    Controller,\r
  IN  UINTN                         NumberOfChildren,\r
  IN  EFI_HANDLE                    *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  UINTN                            Index;\r
  BOOLEAN                          AllChildrenStopped;\r
  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *SimpleTextOutput;\r
  TERMINAL_DEV                     *TerminalDevice;\r
  EFI_DEVICE_PATH_PROTOCOL         *ParentDevicePath;\r
  EFI_SERIAL_IO_PROTOCOL           *SerialIo;\r
\r
  //\r
  // Complete all outstanding transactions to Controller.\r
  // Don't allow any new transaction to Controller to be started.\r
  //\r
  if (NumberOfChildren == 0) {\r
    //\r
    // Close the bus driver\r
    //\r
    Status = gBS->OpenProtocol (\r
                    Controller,\r
                    &gEfiDevicePathProtocolGuid,\r
                    (VOID **) &ParentDevicePath,\r
                    This->DriverBindingHandle,\r
                    Controller,\r
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    //\r
    // Remove Parent Device Path from\r
    // the Console Device Environment Variables\r
    //\r
    TerminalRemoveConsoleDevVariable (EFI_CON_IN_DEV_VARIABLE_NAME, ParentDevicePath);\r
    TerminalRemoveConsoleDevVariable (EFI_CON_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
    TerminalRemoveConsoleDevVariable (EFI_ERR_OUT_DEV_VARIABLE_NAME, ParentDevicePath);\r
\r
    gBS->CloseProtocol (\r
          Controller,\r
          &gEfiSerialIoProtocolGuid,\r
          This->DriverBindingHandle,\r
          Controller\r
          );\r
\r
    gBS->CloseProtocol (\r
          Controller,\r
          &gEfiDevicePathProtocolGuid,\r
          This->DriverBindingHandle,\r
          Controller\r
          );\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  AllChildrenStopped = TRUE;\r
\r
  for (Index = 0; Index < NumberOfChildren; Index++) {\r
\r
    Status = gBS->OpenProtocol (\r
                    ChildHandleBuffer[Index],\r
                    &gEfiSimpleTextOutProtocolGuid,\r
                    (VOID **) &SimpleTextOutput,\r
                    This->DriverBindingHandle,\r
                    ChildHandleBuffer[Index],\r
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
\r
      TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (SimpleTextOutput);\r
\r
      gBS->CloseProtocol (\r
            Controller,\r
            &gEfiSerialIoProtocolGuid,\r
            This->DriverBindingHandle,\r
            ChildHandleBuffer[Index]\r
            );\r
\r
      Status = gBS->UninstallMultipleProtocolInterfaces (\r
                      ChildHandleBuffer[Index],\r
                      &gEfiSimpleTextInProtocolGuid,\r
                      &TerminalDevice->SimpleInput,\r
                      &gEfiSimpleTextInputExProtocolGuid,\r
                      &TerminalDevice->SimpleInputEx,\r
                      &gEfiSimpleTextOutProtocolGuid,\r
                      &TerminalDevice->SimpleTextOutput,\r
                      &gEfiDevicePathProtocolGuid,\r
                      TerminalDevice->DevicePath,\r
                      NULL\r
                      );\r
      if (EFI_ERROR (Status)) {\r
        gBS->OpenProtocol (\r
              Controller,\r
              &gEfiSerialIoProtocolGuid,\r
              (VOID **) &SerialIo,\r
              This->DriverBindingHandle,\r
              ChildHandleBuffer[Index],\r
              EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
              );\r
      } else {\r
\r
        FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);\r
        StopTerminalStateMachine (TerminalDevice);\r
        gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);\r
        gBS->CloseEvent (TerminalDevice->SimpleInputEx.WaitForKeyEx);\r
        gBS->CloseEvent (TerminalDevice->KeyNotifyProcessEvent);\r
        TerminalFreeNotifyList (&TerminalDevice->NotifyList);\r
        FreePool (TerminalDevice->DevicePath);\r
        FreePool (TerminalDevice->TerminalConsoleModeData);\r
        FreePool (TerminalDevice);\r
      }\r
    }\r
\r
    if (EFI_ERROR (Status)) {\r
      AllChildrenStopped = FALSE;\r
    }\r
  }\r
\r
  if (!AllChildrenStopped) {\r
    return EFI_DEVICE_ERROR;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Compare a device path data structure to that of all the nodes of a\r
  second device path instance.\r
\r
  @param  Multi          A pointer to a multi-instance device path data structure.\r
  @param  Single         A pointer to a single-instance device path data structure.\r
\r
  @retval TRUE           If the Single is contained within Multi.\r
  @retval FALSE          The Single is not match within Multi.\r
\r
**/\r
BOOLEAN\r
MatchDevicePaths (\r
  IN  EFI_DEVICE_PATH_PROTOCOL  *Multi,\r
  IN  EFI_DEVICE_PATH_PROTOCOL  *Single\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;\r
  EFI_DEVICE_PATH_PROTOCOL  *DevicePathInst;\r
  UINTN                     Size;\r
\r
  DevicePath      = Multi;\r
  DevicePathInst  = GetNextDevicePathInstance (&DevicePath, &Size);\r
  //\r
  // Search for the match of 'Single' in 'Multi'\r
  //\r
  while (DevicePathInst != NULL) {\r
    //\r
    // If the single device path is found in multiple device paths,\r
    // return success\r
    //\r
    if (CompareMem (Single, DevicePathInst, Size) == 0) {\r
      FreePool (DevicePathInst);\r
      return TRUE;\r
    }\r
\r
    FreePool (DevicePathInst);\r
    DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);\r
  }\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Update terminal device path in Console Device Environment Variables.\r
\r
  @param  VariableName           The Console Device Environment Variable.\r
  @param  ParentDevicePath       The terminal device path to be updated.\r
\r
**/\r
VOID\r
TerminalUpdateConsoleDevVariable (\r
  IN CHAR16                    *VariableName,\r
  IN EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINTN                     NameSize;\r
  UINTN                     VariableSize;\r
  TERMINAL_TYPE             TerminalType;\r
  EFI_DEVICE_PATH_PROTOCOL  *Variable;\r
  EFI_DEVICE_PATH_PROTOCOL  *NewVariable;\r
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;\r
  EDKII_SET_VARIABLE_STATUS *SetVariableStatus;\r
\r
  //\r
  // Get global variable and its size according to the name given.\r
  //\r
  Status = GetEfiGlobalVariable2 (VariableName, (VOID**)&Variable, NULL);\r
  if (Status == EFI_NOT_FOUND) {\r
    Status   = EFI_SUCCESS;\r
    Variable = NULL;\r
  }\r
  if (EFI_ERROR (Status)) {\r
    return;\r
  }\r
\r
  //\r
  // Append terminal device path onto the variable.\r
  //\r
  for (TerminalType = 0; TerminalType < ARRAY_SIZE (mTerminalType); TerminalType++) {\r
    SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);\r
\r
    if (TempDevicePath != NULL) {\r
      if (!MatchDevicePaths (Variable, TempDevicePath)) {\r
        NewVariable = AppendDevicePathInstance (Variable, TempDevicePath);\r
        if (NewVariable != NULL) {\r
          if (Variable != NULL) {\r
            FreePool (Variable);\r
          }\r
          Variable = NewVariable;\r
        }\r
      }\r
\r
      FreePool (TempDevicePath);\r
    }\r
\r
  }\r
\r
  VariableSize = GetDevicePathSize (Variable);\r
\r
  Status = gRT->SetVariable (\r
                  VariableName,\r
                  &gEfiGlobalVariableGuid,\r
                  EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                  VariableSize,\r
                  Variable\r
                  );\r
\r
  if (EFI_ERROR (Status)) {\r
    NameSize = StrSize (VariableName);\r
    SetVariableStatus = AllocatePool (sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + VariableSize);\r
    if (SetVariableStatus != NULL) {\r
      CopyGuid (&SetVariableStatus->Guid, &gEfiGlobalVariableGuid);\r
      SetVariableStatus->NameSize   = NameSize;\r
      SetVariableStatus->DataSize   = VariableSize;\r
      SetVariableStatus->SetStatus  = Status;\r
      SetVariableStatus->Attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS;\r
      CopyMem (SetVariableStatus + 1,                          VariableName, NameSize);\r
      CopyMem (((UINT8 *) (SetVariableStatus + 1)) + NameSize, Variable,     VariableSize);\r
\r
      REPORT_STATUS_CODE_EX (\r
        EFI_ERROR_CODE,\r
        PcdGet32 (PcdErrorCodeSetVariable),\r
        0,\r
        NULL,\r
        &gEdkiiStatusCodeDataTypeVariableGuid,\r
        SetVariableStatus,\r
        sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + VariableSize\r
        );\r
\r
      FreePool (SetVariableStatus);\r
    }\r
  }\r
\r
  FreePool (Variable);\r
\r
  return ;\r
}\r
\r
\r
/**\r
  Remove terminal device path from Console Device Environment Variables.\r
\r
  @param  VariableName           Console Device Environment Variables.\r
  @param  ParentDevicePath       The terminal device path to be updated.\r
\r
**/\r
VOID\r
TerminalRemoveConsoleDevVariable (\r
  IN CHAR16                    *VariableName,\r
  IN EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath\r
  )\r
{\r
  EFI_STATUS                Status;\r
  BOOLEAN                   FoundOne;\r
  BOOLEAN                   Match;\r
  UINTN                     VariableSize;\r
  UINTN                     InstanceSize;\r
  TERMINAL_TYPE             TerminalType;\r
  EFI_DEVICE_PATH_PROTOCOL  *Instance;\r
  EFI_DEVICE_PATH_PROTOCOL  *Variable;\r
  EFI_DEVICE_PATH_PROTOCOL  *OriginalVariable;\r
  EFI_DEVICE_PATH_PROTOCOL  *NewVariable;\r
  EFI_DEVICE_PATH_PROTOCOL  *SavedNewVariable;\r
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;\r
\r
  Instance  = NULL;\r
\r
  //\r
  // Get global variable and its size according to the name given.\r
  //\r
  GetEfiGlobalVariable2 (VariableName, (VOID**)&Variable, NULL);\r
  if (Variable == NULL) {\r
    return ;\r
  }\r
\r
  FoundOne          = FALSE;\r
  OriginalVariable  = Variable;\r
  NewVariable       = NULL;\r
\r
  //\r
  // Get first device path instance from Variable\r
  //\r
  Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);\r
  if (Instance == NULL) {\r
    FreePool (OriginalVariable);\r
    return ;\r
  }\r
  //\r
  // Loop through all the device path instances of Variable\r
  //\r
  do {\r
    //\r
    // Loop through all the terminal types that this driver supports\r
    //\r
    Match = FALSE;\r
    for (TerminalType = 0; TerminalType < ARRAY_SIZE (mTerminalType); TerminalType++) {\r
\r
      SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);\r
\r
      //\r
      // Compare the generated device path to the current device path instance\r
      //\r
      if (TempDevicePath != NULL) {\r
        if (CompareMem (Instance, TempDevicePath, InstanceSize) == 0) {\r
          Match     = TRUE;\r
          FoundOne  = TRUE;\r
        }\r
\r
        FreePool (TempDevicePath);\r
      }\r
    }\r
    //\r
    // If a match was not found, then keep the current device path instance\r
    //\r
    if (!Match) {\r
      SavedNewVariable  = NewVariable;\r
      NewVariable       = AppendDevicePathInstance (NewVariable, Instance);\r
      if (SavedNewVariable != NULL) {\r
        FreePool (SavedNewVariable);\r
      }\r
    }\r
    //\r
    // Get next device path instance from Variable\r
    //\r
    FreePool (Instance);\r
    Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);\r
  } while (Instance != NULL);\r
\r
  FreePool (OriginalVariable);\r
\r
  if (FoundOne) {\r
    VariableSize = GetDevicePathSize (NewVariable);\r
\r
    Status = gRT->SetVariable (\r
                    VariableName,\r
                    &gEfiGlobalVariableGuid,\r
                    EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,\r
                    VariableSize,\r
                    NewVariable\r
                    );\r
    //\r
    // Shrinking variable with existing variable driver implementation shouldn't fail.\r
    //\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  if (NewVariable != NULL) {\r
    FreePool (NewVariable);\r
  }\r
\r
  return ;\r
}\r
\r
/**\r
  Build terminal device path according to terminal type.\r
\r
  @param  TerminalType           The terminal type is PC ANSI, VT100, VT100+ or VT-UTF8.\r
  @param  ParentDevicePath       Parent device path.\r
  @param  TerminalDevicePath     Returned terminal device path, if building successfully.\r
\r
  @retval EFI_UNSUPPORTED        Terminal does not belong to the supported type.\r
  @retval EFI_OUT_OF_RESOURCES   Generate terminal device path failed.\r
  @retval EFI_SUCCESS            Build terminal device path successfully.\r
\r
**/\r
EFI_STATUS\r
SetTerminalDevicePath (\r
  IN  TERMINAL_TYPE               TerminalType,\r
  IN  EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath,\r
  OUT EFI_DEVICE_PATH_PROTOCOL    **TerminalDevicePath\r
  )\r
{\r
  VENDOR_DEVICE_PATH  Node;\r
\r
  ASSERT (TerminalType < ARRAY_SIZE (mTerminalType));\r
  Node.Header.Type    = MESSAGING_DEVICE_PATH;\r
  Node.Header.SubType = MSG_VENDOR_DP;\r
  SetDevicePathNodeLength (&Node.Header, sizeof (VENDOR_DEVICE_PATH));\r
  CopyGuid (&Node.Guid, mTerminalType[TerminalType]);\r
\r
  //\r
  // Append the terminal node onto parent device path\r
  // to generate a complete terminal device path.\r
  //\r
  *TerminalDevicePath = AppendDevicePathNode (\r
                          ParentDevicePath,\r
                          (EFI_DEVICE_PATH_PROTOCOL *) &Node\r
                          );\r
  if (*TerminalDevicePath == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  The user Entry Point for module Terminal. The user code starts with this function.\r
\r
  @param  ImageHandle    The firmware allocated handle for the EFI image.\r
  @param  SystemTable    A pointer to the EFI System Table.\r
\r
  @retval EFI_SUCCESS       The entry point is executed successfully.\r
  @retval other             Some error occurs when executing this entry point.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InitializeTerminal(\r
  IN EFI_HANDLE           ImageHandle,\r
  IN EFI_SYSTEM_TABLE     *SystemTable\r
  )\r
{\r
  EFI_STATUS              Status;\r
\r
  //\r
  // Install driver model protocol(s).\r
  //\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gTerminalDriverBinding,\r
             ImageHandle,\r
             &gTerminalComponentName,\r
             &gTerminalComponentName2\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Status;\r
}\r
\r
/**\r
  Check if the device supports hot-plug through its device path.\r
\r
  This function could be updated to check more types of Hot Plug devices.\r
  Currently, it checks USB and PCCard device.\r
\r
  @param  DevicePath            Pointer to device's device path.\r
\r
  @retval TRUE                  The devcie is a hot-plug device\r
  @retval FALSE                 The devcie is not a hot-plug device.\r
\r
**/\r
BOOLEAN\r
IsHotPlugDevice (\r
  IN  EFI_DEVICE_PATH_PROTOCOL    *DevicePath\r
  )\r
{\r
  EFI_DEVICE_PATH_PROTOCOL     *CheckDevicePath;\r
\r
  CheckDevicePath = DevicePath;\r
  while (!IsDevicePathEnd (CheckDevicePath)) {\r
    //\r
    // Check device whether is hot plug device or not throught Device Path\r
    //\r
    if ((DevicePathType (CheckDevicePath) == MESSAGING_DEVICE_PATH) &&\r
        (DevicePathSubType (CheckDevicePath) == MSG_USB_DP ||\r
         DevicePathSubType (CheckDevicePath) == MSG_USB_CLASS_DP ||\r
         DevicePathSubType (CheckDevicePath) == MSG_USB_WWID_DP)) {\r
      //\r
      // If Device is USB device\r
      //\r
      return TRUE;\r
    }\r
    if ((DevicePathType (CheckDevicePath) == HARDWARE_DEVICE_PATH) &&\r
        (DevicePathSubType (CheckDevicePath) == HW_PCCARD_DP)) {\r
      //\r
      // If Device is PCCard\r
      //\r
      return TRUE;\r
    }\r
\r
    CheckDevicePath = NextDevicePathNode (CheckDevicePath);\r
  }\r
\r
  return FALSE;\r
}\r