TerminalConIn.c

Go to the documentation of this file.

 
#include "Terminal.h"
 
EFI_STATUS
ReadKeyStrokeWorker (
  IN  TERMINAL_DEV  *TerminalDevice,
  OUT EFI_KEY_DATA  *KeyData
  )
{
  if (KeyData == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  KeyData->KeyState.KeyShiftState  = 0;
  KeyData->KeyState.KeyToggleState = 0;
 
  if (!EfiKeyFiFoRemoveOneKey (TerminalDevice, &KeyData->Key)) {
    return EFI_NOT_READY;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TerminalConInReset (
  IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *This,
  IN  BOOLEAN                         ExtendedVerification
  )
{
  EFI_STATUS    Status;
  TERMINAL_DEV  *TerminalDevice;
 
  TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (This);
 
  //
  // Report progress code here
  //
  REPORT_STATUS_CODE_WITH_DEVICE_PATH (
    EFI_PROGRESS_CODE,
    (EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_RESET),
    TerminalDevice->DevicePath
    );
 
  Status = TerminalDevice->SerialIo->Reset (TerminalDevice->SerialIo);
 
  //
  // Make all the internal buffer empty for keys
  //
  TerminalDevice->RawFiFo->Head             = TerminalDevice->RawFiFo->Tail;
  TerminalDevice->UnicodeFiFo->Head         = TerminalDevice->UnicodeFiFo->Tail;
  TerminalDevice->EfiKeyFiFo->Head          = TerminalDevice->EfiKeyFiFo->Tail;
  TerminalDevice->EfiKeyFiFoForNotify->Head = TerminalDevice->EfiKeyFiFoForNotify->Tail;
 
  if (EFI_ERROR (Status)) {
    REPORT_STATUS_CODE_WITH_DEVICE_PATH (
      EFI_ERROR_CODE | EFI_ERROR_MINOR,
      (EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_CONTROLLER_ERROR),
      TerminalDevice->DevicePath
      );
  }
 
  if (!EFI_ERROR (Status)) {
    Status = TerminalDevice->SerialIo->SetControl (TerminalDevice->SerialIo, EFI_SERIAL_DATA_TERMINAL_READY|EFI_SERIAL_REQUEST_TO_SEND);
    if (Status == EFI_UNSUPPORTED) {
      Status = EFI_SUCCESS;
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
TerminalConInReadKeyStroke (
  IN  EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *This,
  OUT EFI_INPUT_KEY                   *Key
  )
{
  TERMINAL_DEV  *TerminalDevice;
  EFI_STATUS    Status;
  EFI_KEY_DATA  KeyData;
 
  //
  //  get TERMINAL_DEV from "This" parameter.
  //
  TerminalDevice = TERMINAL_CON_IN_DEV_FROM_THIS (This);
 
  Status = ReadKeyStrokeWorker (TerminalDevice, &KeyData);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));
 
  return EFI_SUCCESS;
}
 
BOOLEAN
IsKeyRegistered (
  IN EFI_KEY_DATA  *RegsiteredData,
  IN EFI_KEY_DATA  *InputData
  )
{
  ASSERT (RegsiteredData != NULL && InputData != NULL);
 
  if ((RegsiteredData->Key.ScanCode    != InputData->Key.ScanCode) ||
      (RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar))
  {
    return FALSE;
  }
 
  return TRUE;
}
 
VOID
EFIAPI
TerminalConInWaitForKeyEx (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  TerminalConInWaitForKey (Event, Context);
}
 
//
// Simple Text Input Ex protocol functions
//
 
EFI_STATUS
EFIAPI
TerminalConInResetEx (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN BOOLEAN                            ExtendedVerification
  )
{
  EFI_STATUS    Status;
  TERMINAL_DEV  *TerminalDevice;
 
  TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
 
  Status = TerminalDevice->SimpleInput.Reset (&TerminalDevice->SimpleInput, ExtendedVerification);
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TerminalConInReadKeyStrokeEx (
  IN  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  OUT EFI_KEY_DATA                       *KeyData
  )
{
  TERMINAL_DEV  *TerminalDevice;
 
  if (KeyData == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
 
  return ReadKeyStrokeWorker (TerminalDevice, KeyData);
}
 
EFI_STATUS
EFIAPI
TerminalConInSetState (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN EFI_KEY_TOGGLE_STATE               *KeyToggleState
  )
{
  if (KeyToggleState == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID) {
    return EFI_UNSUPPORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TerminalConInRegisterKeyNotify (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN EFI_KEY_DATA                       *KeyData,
  IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,
  OUT VOID                              **NotifyHandle
  )
{
  TERMINAL_DEV                   *TerminalDevice;
  TERMINAL_CONSOLE_IN_EX_NOTIFY  *NewNotify;
  LIST_ENTRY                     *Link;
  LIST_ENTRY                     *NotifyList;
  TERMINAL_CONSOLE_IN_EX_NOTIFY  *CurrentNotify;
 
  if ((KeyData == NULL) || (NotifyHandle == NULL) || (KeyNotificationFunction == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
 
  //
  // Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
  //
  NotifyList = &TerminalDevice->NotifyList;
  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {
    CurrentNotify = CR (
                      Link,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY,
                      NotifyEntry,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
                      );
    if (IsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
      if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {
        *NotifyHandle = CurrentNotify;
        return EFI_SUCCESS;
      }
    }
  }
 
  //
  // Allocate resource to save the notification function
  //
  NewNotify = (TERMINAL_CONSOLE_IN_EX_NOTIFY *)AllocateZeroPool (sizeof (TERMINAL_CONSOLE_IN_EX_NOTIFY));
  if (NewNotify == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  NewNotify->Signature         = TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE;
  NewNotify->KeyNotificationFn = KeyNotificationFunction;
  CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA));
  InsertTailList (&TerminalDevice->NotifyList, &NewNotify->NotifyEntry);
 
  *NotifyHandle = NewNotify;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
TerminalConInUnregisterKeyNotify (
  IN EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
  IN VOID                               *NotificationHandle
  )
{
  TERMINAL_DEV                   *TerminalDevice;
  LIST_ENTRY                     *Link;
  TERMINAL_CONSOLE_IN_EX_NOTIFY  *CurrentNotify;
  LIST_ENTRY                     *NotifyList;
 
  if (NotificationHandle == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  TerminalDevice = TERMINAL_CON_IN_EX_DEV_FROM_THIS (This);
 
  NotifyList = &TerminalDevice->NotifyList;
  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {
    CurrentNotify = CR (
                      Link,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY,
                      NotifyEntry,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
                      );
    if (CurrentNotify == NotificationHandle) {
      //
      // Remove the notification function from NotifyList and free resources
      //
      RemoveEntryList (&CurrentNotify->NotifyEntry);
 
      gBS->FreePool (CurrentNotify);
      return EFI_SUCCESS;
    }
  }
 
  //
  // Can not find the matching entry in database.
  //
  return EFI_INVALID_PARAMETER;
}
 
VOID
TranslateRawDataToEfiKey (
  IN  TERMINAL_DEV  *TerminalDevice
  )
{
  switch (TerminalDevice->TerminalType) {
    case TerminalTypePcAnsi:
    case TerminalTypeVt100:
    case TerminalTypeVt100Plus:
    case TerminalTypeTtyTerm:
    case TerminalTypeLinux:
    case TerminalTypeXtermR6:
    case TerminalTypeVt400:
    case TerminalTypeSCO:
      AnsiRawDataToUnicode (TerminalDevice);
      UnicodeToEfiKey (TerminalDevice);
      break;
 
    case TerminalTypeVtUtf8:
      //
      // Process all the raw data in the RawFIFO,
      // put the processed key into UnicodeFIFO.
      //
      VTUTF8RawDataToUnicode (TerminalDevice);
 
      //
      // Translate all the Unicode data in the UnicodeFIFO to Efi key,
      // then put into EfiKeyFIFO.
      //
      UnicodeToEfiKey (TerminalDevice);
 
      break;
  }
}
 
VOID
EFIAPI
TerminalConInWaitForKey (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  //
  // Someone is waiting on the keystroke event, if there's
  // a key pending, signal the event
  //
  if (!IsEfiKeyFiFoEmpty ((TERMINAL_DEV *)Context)) {
    gBS->SignalEvent (Event);
  }
}
 
VOID
EFIAPI
TerminalConInTimerHandler (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EFI_STATUS              Status;
  TERMINAL_DEV            *TerminalDevice;
  UINT32                  Control;
  UINT8                   Input;
  EFI_SERIAL_IO_MODE      *Mode;
  EFI_SERIAL_IO_PROTOCOL  *SerialIo;
  UINTN                   SerialInTimeOut;
 
  TerminalDevice = (TERMINAL_DEV *)Context;
 
  SerialIo = TerminalDevice->SerialIo;
  if (SerialIo == NULL) {
    return;
  }
 
  //
  //  if current timeout value for serial device is not identical with
  //  the value saved in TERMINAL_DEV structure, then recalculate the
  //  timeout value again and set serial attribute according to this value.
  //
  Mode = SerialIo->Mode;
  if (Mode->Timeout != TerminalDevice->SerialInTimeOut) {
    SerialInTimeOut = 0;
    if (Mode->BaudRate != 0) {
      //
      // According to BAUD rate to calculate the timeout value.
      //
      SerialInTimeOut = (1 + Mode->DataBits + Mode->StopBits) * 2 * 1000000 / (UINTN)Mode->BaudRate;
    }
 
    Status = SerialIo->SetAttributes (
                         SerialIo,
                         Mode->BaudRate,
                         Mode->ReceiveFifoDepth,
                         (UINT32)SerialInTimeOut,
                         (EFI_PARITY_TYPE)(Mode->Parity),
                         (UINT8)Mode->DataBits,
                         (EFI_STOP_BITS_TYPE)(Mode->StopBits)
                         );
 
    if (EFI_ERROR (Status)) {
      TerminalDevice->SerialInTimeOut = 0;
    } else {
      TerminalDevice->SerialInTimeOut = SerialInTimeOut;
    }
  }
 
  //
  // Check whether serial buffer is empty.
  // Skip the key transfer loop only if the SerialIo protocol instance
  // successfully reports EFI_SERIAL_INPUT_BUFFER_EMPTY.
  //
  Status = SerialIo->GetControl (SerialIo, &Control);
  if (EFI_ERROR (Status) || ((Control & EFI_SERIAL_INPUT_BUFFER_EMPTY) == 0)) {
    //
    // Fetch all the keys in the serial buffer,
    // and insert the byte stream into RawFIFO.
    //
    while (!IsRawFiFoFull (TerminalDevice)) {
      Status = GetOneKeyFromSerial (TerminalDevice->SerialIo, &Input);
 
      if (EFI_ERROR (Status)) {
        if (Status == EFI_DEVICE_ERROR) {
          REPORT_STATUS_CODE_WITH_DEVICE_PATH (
            EFI_ERROR_CODE | EFI_ERROR_MINOR,
            (EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_EC_INPUT_ERROR),
            TerminalDevice->DevicePath
            );
        }
 
        break;
      }
 
      RawFiFoInsertOneKey (TerminalDevice, Input);
    }
  }
 
  //
  // Translate all the raw data in RawFIFO into EFI Key,
  // according to different terminal type supported.
  //
  TranslateRawDataToEfiKey (TerminalDevice);
}
 
VOID
EFIAPI
KeyNotifyProcessHandler (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  BOOLEAN                        HasKey;
  TERMINAL_DEV                   *TerminalDevice;
  EFI_INPUT_KEY                  Key;
  EFI_KEY_DATA                   KeyData;
  LIST_ENTRY                     *Link;
  LIST_ENTRY                     *NotifyList;
  TERMINAL_CONSOLE_IN_EX_NOTIFY  *CurrentNotify;
  EFI_TPL                        OldTpl;
 
  TerminalDevice = (TERMINAL_DEV *)Context;
 
  //
  // Invoke notification functions.
  //
  NotifyList = &TerminalDevice->NotifyList;
  while (TRUE) {
    //
    // Enter critical section
    //
    OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
    HasKey = EfiKeyFiFoForNotifyRemoveOneKey (TerminalDevice->EfiKeyFiFoForNotify, &Key);
    CopyMem (&KeyData.Key, &Key, sizeof (EFI_INPUT_KEY));
    KeyData.KeyState.KeyShiftState  = 0;
    KeyData.KeyState.KeyToggleState = 0;
    //
    // Leave critical section
    //
    gBS->RestoreTPL (OldTpl);
    if (!HasKey) {
      break;
    }
 
    for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {
      CurrentNotify = CR (Link, TERMINAL_CONSOLE_IN_EX_NOTIFY, NotifyEntry, TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE);
      if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {
        CurrentNotify->KeyNotificationFn (&KeyData);
      }
    }
  }
}
 
EFI_STATUS
GetOneKeyFromSerial (
  EFI_SERIAL_IO_PROTOCOL  *SerialIo,
  UINT8                   *Output
  )
{
  EFI_STATUS  Status;
  UINTN       Size;
 
  Size    = 1;
  *Output = 0;
 
  //
  // Read one key from serial I/O device.
  //
  Status = SerialIo->Read (SerialIo, &Size, Output);
 
  if (EFI_ERROR (Status)) {
    if (Status == EFI_TIMEOUT) {
      return EFI_NOT_READY;
    }
 
    return EFI_DEVICE_ERROR;
  }
 
  if (*Output == 0) {
    return EFI_NOT_READY;
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
RawFiFoInsertOneKey (
  TERMINAL_DEV  *TerminalDevice,
  UINT8         Input
  )
{
  UINT8  Tail;
 
  Tail = TerminalDevice->RawFiFo->Tail;
 
  if (IsRawFiFoFull (TerminalDevice)) {
    //
    // Raw FIFO is full
    //
    return FALSE;
  }
 
  TerminalDevice->RawFiFo->Data[Tail] = Input;
 
  TerminalDevice->RawFiFo->Tail = (UINT8)((Tail + 1) % (RAW_FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
RawFiFoRemoveOneKey (
  TERMINAL_DEV  *TerminalDevice,
  UINT8         *Output
  )
{
  UINT8  Head;
 
  Head = TerminalDevice->RawFiFo->Head;
 
  if (IsRawFiFoEmpty (TerminalDevice)) {
    //
    //  FIFO is empty
    //
    *Output = 0;
    return FALSE;
  }
 
  *Output = TerminalDevice->RawFiFo->Data[Head];
 
  TerminalDevice->RawFiFo->Head = (UINT8)((Head + 1) % (RAW_FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
IsRawFiFoEmpty (
  TERMINAL_DEV  *TerminalDevice
  )
{
  if (TerminalDevice->RawFiFo->Head == TerminalDevice->RawFiFo->Tail) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
IsRawFiFoFull (
  TERMINAL_DEV  *TerminalDevice
  )
{
  UINT8  Tail;
  UINT8  Head;
 
  Tail = TerminalDevice->RawFiFo->Tail;
  Head = TerminalDevice->RawFiFo->Head;
 
  if (((Tail + 1) % (RAW_FIFO_MAX_NUMBER + 1)) == Head) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
EfiKeyFiFoForNotifyInsertOneKey (
  EFI_KEY_FIFO   *EfiKeyFiFo,
  EFI_INPUT_KEY  *Input
  )
{
  UINT8  Tail;
 
  Tail = EfiKeyFiFo->Tail;
 
  if (IsEfiKeyFiFoForNotifyFull (EfiKeyFiFo)) {
    //
    // FIFO is full
    //
    return FALSE;
  }
 
  CopyMem (&EfiKeyFiFo->Data[Tail], Input, sizeof (EFI_INPUT_KEY));
 
  EfiKeyFiFo->Tail = (UINT8)((Tail + 1) % (FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
EfiKeyFiFoForNotifyRemoveOneKey (
  EFI_KEY_FIFO   *EfiKeyFiFo,
  EFI_INPUT_KEY  *Output
  )
{
  UINT8  Head;
 
  Head = EfiKeyFiFo->Head;
  ASSERT (Head < FIFO_MAX_NUMBER + 1);
 
  if (IsEfiKeyFiFoForNotifyEmpty (EfiKeyFiFo)) {
    //
    // FIFO is empty
    //
    Output->ScanCode    = SCAN_NULL;
    Output->UnicodeChar = 0;
    return FALSE;
  }
 
  CopyMem (Output, &EfiKeyFiFo->Data[Head], sizeof (EFI_INPUT_KEY));
 
  EfiKeyFiFo->Head = (UINT8)((Head + 1) % (FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
IsEfiKeyFiFoForNotifyEmpty (
  EFI_KEY_FIFO  *EfiKeyFiFo
  )
{
  if (EfiKeyFiFo->Head == EfiKeyFiFo->Tail) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
IsEfiKeyFiFoForNotifyFull (
  EFI_KEY_FIFO  *EfiKeyFiFo
  )
{
  UINT8  Tail;
  UINT8  Head;
 
  Tail = EfiKeyFiFo->Tail;
  Head = EfiKeyFiFo->Head;
 
  if (((Tail + 1) % (FIFO_MAX_NUMBER + 1)) == Head) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
EfiKeyFiFoInsertOneKey (
  TERMINAL_DEV   *TerminalDevice,
  EFI_INPUT_KEY  *Key
  )
{
  UINT8                          Tail;
  LIST_ENTRY                     *Link;
  LIST_ENTRY                     *NotifyList;
  TERMINAL_CONSOLE_IN_EX_NOTIFY  *CurrentNotify;
  EFI_KEY_DATA                   KeyData;
 
  Tail = TerminalDevice->EfiKeyFiFo->Tail;
 
  CopyMem (&KeyData.Key, Key, sizeof (EFI_INPUT_KEY));
  KeyData.KeyState.KeyShiftState  = 0;
  KeyData.KeyState.KeyToggleState = 0;
 
  //
  // Signal KeyNotify process event if this key pressed matches any key registered.
  //
  NotifyList = &TerminalDevice->NotifyList;
  for (Link = GetFirstNode (NotifyList); !IsNull (NotifyList, Link); Link = GetNextNode (NotifyList, Link)) {
    CurrentNotify = CR (
                      Link,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY,
                      NotifyEntry,
                      TERMINAL_CONSOLE_IN_EX_NOTIFY_SIGNATURE
                      );
    if (IsKeyRegistered (&CurrentNotify->KeyData, &KeyData)) {
      //
      // The key notification function needs to run at TPL_CALLBACK
      // while current TPL is TPL_NOTIFY. It will be invoked in
      // KeyNotifyProcessHandler() which runs at TPL_CALLBACK.
      //
      EfiKeyFiFoForNotifyInsertOneKey (TerminalDevice->EfiKeyFiFoForNotify, Key);
      gBS->SignalEvent (TerminalDevice->KeyNotifyProcessEvent);
      break;
    }
  }
 
  if (IsEfiKeyFiFoFull (TerminalDevice)) {
    //
    // Efi Key FIFO is full
    //
    return FALSE;
  }
 
  CopyMem (&TerminalDevice->EfiKeyFiFo->Data[Tail], Key, sizeof (EFI_INPUT_KEY));
 
  TerminalDevice->EfiKeyFiFo->Tail = (UINT8)((Tail + 1) % (FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
EfiKeyFiFoRemoveOneKey (
  TERMINAL_DEV   *TerminalDevice,
  EFI_INPUT_KEY  *Output
  )
{
  UINT8  Head;
 
  Head = TerminalDevice->EfiKeyFiFo->Head;
  ASSERT (Head < FIFO_MAX_NUMBER + 1);
 
  if (IsEfiKeyFiFoEmpty (TerminalDevice)) {
    //
    //  FIFO is empty
    //
    Output->ScanCode    = SCAN_NULL;
    Output->UnicodeChar = 0;
    return FALSE;
  }
 
  CopyMem (Output, &TerminalDevice->EfiKeyFiFo->Data[Head], sizeof (EFI_INPUT_KEY));
 
  TerminalDevice->EfiKeyFiFo->Head = (UINT8)((Head + 1) % (FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
BOOLEAN
IsEfiKeyFiFoEmpty (
  TERMINAL_DEV  *TerminalDevice
  )
{
  if (TerminalDevice->EfiKeyFiFo->Head == TerminalDevice->EfiKeyFiFo->Tail) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
IsEfiKeyFiFoFull (
  TERMINAL_DEV  *TerminalDevice
  )
{
  UINT8  Tail;
  UINT8  Head;
 
  Tail = TerminalDevice->EfiKeyFiFo->Tail;
  Head = TerminalDevice->EfiKeyFiFo->Head;
 
  if (((Tail + 1) % (FIFO_MAX_NUMBER + 1)) == Head) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
UnicodeFiFoInsertOneKey (
  TERMINAL_DEV  *TerminalDevice,
  UINT16        Input
  )
{
  UINT8  Tail;
 
  Tail = TerminalDevice->UnicodeFiFo->Tail;
  ASSERT (Tail < FIFO_MAX_NUMBER + 1);
 
  if (IsUnicodeFiFoFull (TerminalDevice)) {
    //
    // Unicode FIFO is full
    //
    return FALSE;
  }
 
  TerminalDevice->UnicodeFiFo->Data[Tail] = Input;
 
  TerminalDevice->UnicodeFiFo->Tail = (UINT8)((Tail + 1) % (FIFO_MAX_NUMBER + 1));
 
  return TRUE;
}
 
VOID
UnicodeFiFoRemoveOneKey (
  TERMINAL_DEV  *TerminalDevice,
  UINT16        *Output
  )
{
  UINT8  Head;
 
  Head = TerminalDevice->UnicodeFiFo->Head;
  ASSERT (Head < FIFO_MAX_NUMBER + 1);
 
  *Output = TerminalDevice->UnicodeFiFo->Data[Head];
 
  TerminalDevice->UnicodeFiFo->Head = (UINT8)((Head + 1) % (FIFO_MAX_NUMBER + 1));
}
 
BOOLEAN
IsUnicodeFiFoEmpty (
  TERMINAL_DEV  *TerminalDevice
  )
{
  if (TerminalDevice->UnicodeFiFo->Head == TerminalDevice->UnicodeFiFo->Tail) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
IsUnicodeFiFoFull (
  TERMINAL_DEV  *TerminalDevice
  )
{
  UINT8  Tail;
  UINT8  Head;
 
  Tail = TerminalDevice->UnicodeFiFo->Tail;
  Head = TerminalDevice->UnicodeFiFo->Head;
 
  if (((Tail + 1) % (FIFO_MAX_NUMBER + 1)) == Head) {
    return TRUE;
  }
 
  return FALSE;
}
 
VOID
UnicodeToEfiKeyFlushState (
  IN  TERMINAL_DEV  *TerminalDevice
  )
{
  EFI_INPUT_KEY  Key;
  UINT32         InputState;
 
  InputState = TerminalDevice->InputState;
 
  if (IsEfiKeyFiFoFull (TerminalDevice)) {
    return;
  }
 
  if ((InputState & INPUT_STATE_ESC) != 0) {
    Key.ScanCode    = SCAN_ESC;
    Key.UnicodeChar = 0;
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
 
  if ((InputState & INPUT_STATE_CSI) != 0) {
    Key.ScanCode    = SCAN_NULL;
    Key.UnicodeChar = CSI;
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
 
  if ((InputState & INPUT_STATE_LEFTOPENBRACKET) != 0) {
    Key.ScanCode    = SCAN_NULL;
    Key.UnicodeChar = LEFTOPENBRACKET;
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
 
  if ((InputState & INPUT_STATE_O) != 0) {
    Key.ScanCode    = SCAN_NULL;
    Key.UnicodeChar = 'O';
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
 
  if ((InputState & INPUT_STATE_2) != 0) {
    Key.ScanCode    = SCAN_NULL;
    Key.UnicodeChar = '2';
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
 
  //
  // Cancel the timer.
  //
  gBS->SetTimer (
         TerminalDevice->TwoSecondTimeOut,
         TimerCancel,
         0
         );
 
  TerminalDevice->InputState = INPUT_STATE_DEFAULT;
}
 
VOID
UnicodeToEfiKey (
  IN  TERMINAL_DEV  *TerminalDevice
  )
{
  EFI_STATUS     Status;
  EFI_STATUS     TimerStatus;
  UINT16         UnicodeChar;
  EFI_INPUT_KEY  Key;
  BOOLEAN        SetDefaultResetState;
 
  TimerStatus = gBS->CheckEvent (TerminalDevice->TwoSecondTimeOut);
 
  if (!EFI_ERROR (TimerStatus)) {
    UnicodeToEfiKeyFlushState (TerminalDevice);
    TerminalDevice->ResetState = RESET_STATE_DEFAULT;
  }
 
  while (!IsUnicodeFiFoEmpty (TerminalDevice) && !IsEfiKeyFiFoFull (TerminalDevice)) {
    if (TerminalDevice->InputState != INPUT_STATE_DEFAULT) {
      //
      // Check to see if the 2 seconds timer has expired
      //
      TimerStatus = gBS->CheckEvent (TerminalDevice->TwoSecondTimeOut);
      if (!EFI_ERROR (TimerStatus)) {
        UnicodeToEfiKeyFlushState (TerminalDevice);
        TerminalDevice->ResetState = RESET_STATE_DEFAULT;
      }
    }
 
    //
    // Fetch one Unicode character from the Unicode FIFO
    //
    UnicodeFiFoRemoveOneKey (TerminalDevice, &UnicodeChar);
 
    SetDefaultResetState = TRUE;
 
    switch (TerminalDevice->InputState) {
      case INPUT_STATE_DEFAULT:
 
        break;
 
      case INPUT_STATE_ESC:
 
        if (UnicodeChar == LEFTOPENBRACKET) {
          TerminalDevice->InputState |= INPUT_STATE_LEFTOPENBRACKET;
          TerminalDevice->ResetState  = RESET_STATE_DEFAULT;
          continue;
        }
 
        if ((UnicodeChar == 'O') && ((TerminalDevice->TerminalType == TerminalTypeVt100) ||
                                     (TerminalDevice->TerminalType == TerminalTypeTtyTerm) ||
                                     (TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
                                     (TerminalDevice->TerminalType == TerminalTypeVt100Plus) ||
                                     (TerminalDevice->TerminalType == TerminalTypeVtUtf8)))
        {
          TerminalDevice->InputState |= INPUT_STATE_O;
          TerminalDevice->ResetState  = RESET_STATE_DEFAULT;
          continue;
        }
 
        Key.ScanCode = SCAN_NULL;
 
        if ((TerminalDevice->TerminalType == TerminalTypeVt100Plus) ||
            (TerminalDevice->TerminalType == TerminalTypeVtUtf8))
        {
          switch (UnicodeChar) {
            case '1':
              Key.ScanCode = SCAN_F1;
              break;
            case '2':
              Key.ScanCode = SCAN_F2;
              break;
            case '3':
              Key.ScanCode = SCAN_F3;
              break;
            case '4':
              Key.ScanCode = SCAN_F4;
              break;
            case '5':
              Key.ScanCode = SCAN_F5;
              break;
            case '6':
              Key.ScanCode = SCAN_F6;
              break;
            case '7':
              Key.ScanCode = SCAN_F7;
              break;
            case '8':
              Key.ScanCode = SCAN_F8;
              break;
            case '9':
              Key.ScanCode = SCAN_F9;
              break;
            case '0':
              Key.ScanCode = SCAN_F10;
              break;
            case '!':
              Key.ScanCode = SCAN_F11;
              break;
            case '@':
              Key.ScanCode = SCAN_F12;
              break;
            case 'h':
              Key.ScanCode = SCAN_HOME;
              break;
            case 'k':
              Key.ScanCode = SCAN_END;
              break;
            case '+':
              Key.ScanCode = SCAN_INSERT;
              break;
            case '-':
              Key.ScanCode = SCAN_DELETE;
              break;
            case '/':
              Key.ScanCode = SCAN_PAGE_DOWN;
              break;
            case '?':
              Key.ScanCode = SCAN_PAGE_UP;
              break;
            default:
              break;
          }
        }
 
        switch (UnicodeChar) {
          case 'R':
            if (TerminalDevice->ResetState == RESET_STATE_DEFAULT) {
              TerminalDevice->ResetState = RESET_STATE_ESC_R;
              SetDefaultResetState       = FALSE;
            } else if (TerminalDevice->ResetState == RESET_STATE_ESC_R_ESC_R) {
              gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
            }
 
            Key.ScanCode = SCAN_NULL;
            break;
          case 'r':
            if (TerminalDevice->ResetState == RESET_STATE_ESC_R) {
              TerminalDevice->ResetState = RESET_STATE_ESC_R_ESC_R;
              SetDefaultResetState       = FALSE;
            }
 
            Key.ScanCode = SCAN_NULL;
            break;
          default:
            break;
        }
 
        if (SetDefaultResetState) {
          TerminalDevice->ResetState = RESET_STATE_DEFAULT;
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_O:
 
        TerminalDevice->ResetState = RESET_STATE_DEFAULT;
 
        Key.ScanCode = SCAN_NULL;
 
        if (TerminalDevice->TerminalType == TerminalTypeVt100) {
          switch (UnicodeChar) {
            case 'P':
              Key.ScanCode = SCAN_F1;
              break;
            case 'Q':
              Key.ScanCode = SCAN_F2;
              break;
            case 'w':
              Key.ScanCode = SCAN_F3;
              break;
            case 'x':
              Key.ScanCode = SCAN_F4;
              break;
            case 't':
              Key.ScanCode = SCAN_F5;
              break;
            case 'u':
              Key.ScanCode = SCAN_F6;
              break;
            case 'q':
              Key.ScanCode = SCAN_F7;
              break;
            case 'r':
              Key.ScanCode = SCAN_F8;
              break;
            case 'p':
              Key.ScanCode = SCAN_F9;
              break;
            case 'M':
              Key.ScanCode = SCAN_F10;
              break;
            default:
              break;
          }
        } else if (TerminalDevice->TerminalType == TerminalTypeTtyTerm) {
          /* Also accept VT100 escape codes for F1-F4, HOME and END for TTY term */
          switch (UnicodeChar) {
            case 'P':
              Key.ScanCode = SCAN_F1;
              break;
            case 'Q':
              Key.ScanCode = SCAN_F2;
              break;
            case 'R':
              Key.ScanCode = SCAN_F3;
              break;
            case 'S':
              Key.ScanCode = SCAN_F4;
              break;
            case 'H':
              Key.ScanCode = SCAN_HOME;
              break;
            case 'F':
              Key.ScanCode = SCAN_END;
              break;
          }
        } else if ((TerminalDevice->TerminalType == TerminalTypeVt100Plus) ||
                   (TerminalDevice->TerminalType == TerminalTypeVtUtf8))
        {
          switch (UnicodeChar) {
            case 'P':
              Key.ScanCode = SCAN_F1;
              break;
            case 'Q':
              Key.ScanCode = SCAN_F2;
              break;
            case 'R':
              Key.ScanCode = SCAN_F3;
              break;
            case 'S':
              Key.ScanCode = SCAN_F4;
              break;
            case 'T':
              Key.ScanCode = SCAN_F5;
              break;
            case 'U':
              Key.ScanCode = SCAN_F6;
              break;
            case 'V':
              Key.ScanCode = SCAN_F7;
              break;
            case 'W':
              Key.ScanCode = SCAN_F8;
              break;
            case 'X':
              Key.ScanCode = SCAN_F9;
              break;
            case 'Y':
              Key.ScanCode = SCAN_F10;
              break;
            case 'Z':
              Key.ScanCode = SCAN_F11;
              break;
            case '[':
              Key.ScanCode = SCAN_F12;
              break;
          }
        } else if (TerminalDevice->TerminalType == TerminalTypeXtermR6) {
          switch (UnicodeChar) {
            case 'P':
              Key.ScanCode = SCAN_F1;
              break;
            case 'Q':
              Key.ScanCode = SCAN_F2;
              break;
            case 'R':
              Key.ScanCode = SCAN_F3;
              break;
            case 'S':
              Key.ScanCode = SCAN_F4;
              break;
          }
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET:
 
        if ((UnicodeChar == '1') && ((TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
                                     (TerminalDevice->TerminalType == TerminalTypeVt400) ||
                                     (TerminalDevice->TerminalType == TerminalTypeLinux)))
        {
          TerminalDevice->InputState |= INPUT_STATE_1;
          continue;
        }
 
        if ((UnicodeChar == '2') && ((TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
                                     (TerminalDevice->TerminalType == TerminalTypeVt400) ||
                                     (TerminalDevice->TerminalType == TerminalTypeLinux)))
        {
          TerminalDevice->InputState |= INPUT_STATE_2;
          continue;
        }
 
        if ((UnicodeChar == LEFTOPENBRACKET) && (TerminalDevice->TerminalType == TerminalTypeLinux)) {
          TerminalDevice->InputState |= INPUT_STATE_LEFTOPENBRACKET_2ND;
          continue;
        }
 
        TerminalDevice->ResetState = RESET_STATE_DEFAULT;
 
        Key.ScanCode = SCAN_NULL;
 
        if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
            (TerminalDevice->TerminalType == TerminalTypeVt100) ||
            (TerminalDevice->TerminalType == TerminalTypeVt100Plus) ||
            (TerminalDevice->TerminalType == TerminalTypeVtUtf8) ||
            (TerminalDevice->TerminalType == TerminalTypeTtyTerm) ||
            (TerminalDevice->TerminalType == TerminalTypeLinux) ||
            (TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
            (TerminalDevice->TerminalType == TerminalTypeVt400) ||
            (TerminalDevice->TerminalType == TerminalTypeSCO))
        {
          switch (UnicodeChar) {
            case 'A':
              Key.ScanCode = SCAN_UP;
              break;
            case 'B':
              Key.ScanCode = SCAN_DOWN;
              break;
            case 'C':
              Key.ScanCode = SCAN_RIGHT;
              break;
            case 'D':
              Key.ScanCode = SCAN_LEFT;
              break;
            case 'H':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeVt100) ||
                  (TerminalDevice->TerminalType == TerminalTypeTtyTerm))
              {
                Key.ScanCode = SCAN_HOME;
              }
 
              break;
            case 'F':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeTtyTerm))
              {
                Key.ScanCode = SCAN_END;
              }
 
              break;
            case 'K':
              if (TerminalDevice->TerminalType == TerminalTypeVt100) {
                Key.ScanCode = SCAN_END;
              }
 
              break;
            case 'L':
            case '@':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeVt100))
              {
                Key.ScanCode = SCAN_INSERT;
              }
 
              break;
            case 'X':
              if (TerminalDevice->TerminalType == TerminalTypePcAnsi) {
                Key.ScanCode = SCAN_DELETE;
              } else if (TerminalDevice->TerminalType == TerminalTypeSCO) {
                Key.ScanCode = SCAN_F12;
              }
 
              break;
            case 'P':
              if (TerminalDevice->TerminalType == TerminalTypeVt100) {
                Key.ScanCode = SCAN_DELETE;
              } else if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                         (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F4;
              }
 
              break;
            case 'I':
              if (TerminalDevice->TerminalType == TerminalTypePcAnsi) {
                Key.ScanCode = SCAN_PAGE_UP;
              }
 
              break;
            case 'V':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F10;
              }
 
              break;
            case '?':
              if (TerminalDevice->TerminalType == TerminalTypeVt100) {
                Key.ScanCode = SCAN_PAGE_UP;
              }
 
              break;
            case 'G':
              if (TerminalDevice->TerminalType == TerminalTypePcAnsi) {
                Key.ScanCode = SCAN_PAGE_DOWN;
              }
 
              break;
            case 'U':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F9;
              }
 
              break;
            case '/':
              if (TerminalDevice->TerminalType == TerminalTypeVt100) {
                Key.ScanCode = SCAN_PAGE_DOWN;
              }
 
              break;
            case 'M':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F1;
              }
 
              break;
            case 'N':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F2;
              }
 
              break;
            case 'O':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F3;
              }
 
              break;
            case 'Q':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F5;
              }
 
              break;
            case 'R':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F6;
              }
 
              break;
            case 'S':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F7;
              }
 
              break;
            case 'T':
              if ((TerminalDevice->TerminalType == TerminalTypePcAnsi) ||
                  (TerminalDevice->TerminalType == TerminalTypeSCO))
              {
                Key.ScanCode = SCAN_F8;
              }
 
              break;
            case 'W':
              if (TerminalDevice->TerminalType == TerminalTypeSCO) {
                Key.ScanCode = SCAN_F11;
              }
 
              break;
            default:
              break;
          }
        }
 
        /*
         * The VT220 escape codes that the TTY terminal accepts all have
         * numeric codes, and there are no ambiguous prefixes shared with
         * other terminal types.
         */
        if ((TerminalDevice->TerminalType == TerminalTypeTtyTerm) &&
            (Key.ScanCode == SCAN_NULL) &&
            (UnicodeChar >= '0') &&
            (UnicodeChar <= '9'))
        {
          TerminalDevice->TtyEscapeStr[0] = UnicodeChar;
          TerminalDevice->TtyEscapeIndex  = 1;
          TerminalDevice->InputState     |= INPUT_STATE_LEFTOPENBRACKET_TTY;
          continue;
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET | INPUT_STATE_1:
 
        TerminalDevice->ResetState = RESET_STATE_DEFAULT;
 
        Key.ScanCode = SCAN_NULL;
 
        if ((TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
            (TerminalDevice->TerminalType == TerminalTypeVt400) ||
            (TerminalDevice->TerminalType == TerminalTypeLinux))
        {
          switch (UnicodeChar) {
            case '1':
              if (TerminalDevice->TerminalType == TerminalTypeVt400) {
                Key.ScanCode = SCAN_F1;
              }
 
              break;
            case '2':
              if (TerminalDevice->TerminalType == TerminalTypeVt400) {
                Key.ScanCode = SCAN_F2;
              }
 
              break;
            case '3':
              if (TerminalDevice->TerminalType == TerminalTypeVt400) {
                Key.ScanCode = SCAN_F3;
              }
 
              break;
            case '4':
              if (TerminalDevice->TerminalType == TerminalTypeVt400) {
                Key.ScanCode = SCAN_F4;
              }
 
              break;
            case '5':
              if ((TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
                  (TerminalDevice->TerminalType == TerminalTypeVt400))
              {
                Key.ScanCode = SCAN_F5;
              }
 
              break;
            case '7':
              Key.ScanCode = SCAN_F6;
              break;
            case '8':
              Key.ScanCode = SCAN_F7;
              break;
            case '9':
              Key.ScanCode = SCAN_F8;
              break;
          }
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET | INPUT_STATE_2:
 
        TerminalDevice->InputState = INPUT_STATE_DEFAULT;
        Key.ScanCode               = SCAN_NULL;
        if ((TerminalDevice->TerminalType == TerminalTypeXtermR6) ||
            (TerminalDevice->TerminalType == TerminalTypeVt400) ||
            (TerminalDevice->TerminalType == TerminalTypeLinux))
        {
          switch (UnicodeChar) {
            case '0':
              Key.ScanCode = SCAN_F9;
              break;
            case '1':
              Key.ScanCode = SCAN_F10;
              break;
            case '3':
              Key.ScanCode = SCAN_F11;
              break;
            case '4':
              Key.ScanCode = SCAN_F12;
              break;
          }
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET | INPUT_STATE_LEFTOPENBRACKET_2ND:
 
        TerminalDevice->InputState = INPUT_STATE_DEFAULT;
        Key.ScanCode               = SCAN_NULL;
 
        if (TerminalDevice->TerminalType == TerminalTypeLinux) {
          switch (UnicodeChar) {
            case 'A':
              Key.ScanCode = SCAN_F1;
              break;
            case 'B':
              Key.ScanCode = SCAN_F2;
              break;
            case 'C':
              Key.ScanCode = SCAN_F3;
              break;
            case 'D':
              Key.ScanCode = SCAN_F4;
              break;
            case 'E':
              Key.ScanCode = SCAN_F5;
              break;
          }
        }
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
 
      case INPUT_STATE_ESC | INPUT_STATE_LEFTOPENBRACKET | INPUT_STATE_LEFTOPENBRACKET_TTY:
        /*
         * Here we handle the VT220 escape codes that we accept.  This
         * state is only used by the TTY terminal type.
         */
        Key.ScanCode = SCAN_NULL;
        if (TerminalDevice->TerminalType == TerminalTypeTtyTerm) {
          if ((UnicodeChar == '~') && (TerminalDevice->TtyEscapeIndex <= 2)) {
            UINT16  EscCode;
            TerminalDevice->TtyEscapeStr[TerminalDevice->TtyEscapeIndex] = 0; /* Terminate string */
            EscCode                                                      = (UINT16)StrDecimalToUintn (TerminalDevice->TtyEscapeStr);
            switch (EscCode) {
              case 2:
                Key.ScanCode = SCAN_INSERT;
                break;
              case 3:
                Key.ScanCode = SCAN_DELETE;
                break;
              case 5:
                Key.ScanCode = SCAN_PAGE_UP;
                break;
              case 6:
                Key.ScanCode = SCAN_PAGE_DOWN;
                break;
              case 11:
              case 12:
              case 13:
              case 14:
              case 15:
                Key.ScanCode = SCAN_F1 + EscCode - 11;
                break;
              case 17:
              case 18:
              case 19:
              case 20:
              case 21:
                Key.ScanCode = SCAN_F6 + EscCode - 17;
                break;
              case 23:
              case 24:
                Key.ScanCode = SCAN_F11 + EscCode - 23;
                break;
              default:
                break;
            }
          } else if (TerminalDevice->TtyEscapeIndex == 1) {
            /* 2 character escape code   */
            TerminalDevice->TtyEscapeStr[TerminalDevice->TtyEscapeIndex++] = UnicodeChar;
            continue;
          } else {
            DEBUG ((DEBUG_ERROR, "Unexpected state in escape2\n"));
          }
        }
 
        TerminalDevice->ResetState = RESET_STATE_DEFAULT;
 
        if (Key.ScanCode != SCAN_NULL) {
          Key.UnicodeChar = 0;
          EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
          TerminalDevice->InputState = INPUT_STATE_DEFAULT;
          UnicodeToEfiKeyFlushState (TerminalDevice);
          continue;
        }
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
        break;
 
      default:
        //
        // Invalid state. This should never happen.
        //
        ASSERT (FALSE);
 
        UnicodeToEfiKeyFlushState (TerminalDevice);
 
        break;
    }
 
    if (UnicodeChar == ESC) {
      TerminalDevice->InputState = INPUT_STATE_ESC;
    }
 
    if (UnicodeChar == CSI) {
      TerminalDevice->InputState = INPUT_STATE_CSI;
    }
 
    if (TerminalDevice->InputState != INPUT_STATE_DEFAULT) {
      Status = gBS->SetTimer (
                      TerminalDevice->TwoSecondTimeOut,
                      TimerRelative,
                      (UINT64)20000000
                      );
      ASSERT_EFI_ERROR (Status);
      continue;
    }
 
    if (SetDefaultResetState) {
      TerminalDevice->ResetState = RESET_STATE_DEFAULT;
    }
 
    if (UnicodeChar == DEL) {
      if (TerminalDevice->TerminalType == TerminalTypeTtyTerm) {
        Key.ScanCode    = SCAN_NULL;
        Key.UnicodeChar = CHAR_BACKSPACE;
      } else {
        Key.ScanCode    = SCAN_DELETE;
        Key.UnicodeChar = 0;
      }
    } else {
      Key.ScanCode    = SCAN_NULL;
      Key.UnicodeChar = UnicodeChar;
    }
 
    EfiKeyFiFoInsertOneKey (TerminalDevice, &Key);
  }
}