| /** @file | |
| Implementation for EFI_SIMPLE_TEXT_INPUT_PROTOCOL protocol. | |
| (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR> | |
| Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR> | |
| Copyright (C) 2016 Silicon Graphics, Inc. All rights reserved.<BR> | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| **/ | |
| #include "Terminal.h" | |
| /** | |
| Reads the next keystroke from the input device. The WaitForKey Event can | |
| be used to test for existence of a keystroke via WaitForEvent () call. | |
| @param TerminalDevice Terminal driver private structure | |
| @param KeyData A pointer to a buffer that is filled in with the | |
| keystroke state data for the key that was | |
| pressed. | |
| @retval EFI_SUCCESS The keystroke information was returned. | |
| @retval EFI_NOT_READY There was no keystroke data available. | |
| @retval EFI_INVALID_PARAMETER KeyData is NULL. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Implements EFI_SIMPLE_TEXT_INPUT_PROTOCOL.Reset(). | |
| This driver only perform dependent serial device reset regardless of | |
| the value of ExtendeVerification | |
| @param This Indicates the calling context. | |
| @param ExtendedVerification Skip by this driver. | |
| @retval EFI_SUCCESS The reset operation succeeds. | |
| @retval EFI_DEVICE_ERROR The dependent serial port reset fails. | |
| **/ | |
| 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 | |
| ); | |
| } | |
| return Status; | |
| } | |
| /** | |
| Implements EFI_SIMPLE_TEXT_INPUT_PROTOCOL.ReadKeyStroke(). | |
| @param This Indicates the calling context. | |
| @param Key A pointer to a buffer that is filled in with the | |
| keystroke information for the key that was sent | |
| from terminal. | |
| @retval EFI_SUCCESS The keystroke information is returned successfully. | |
| @retval EFI_NOT_READY There is no keystroke data available. | |
| @retval EFI_DEVICE_ERROR The dependent serial device encounters error. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Check if the key already has been registered. | |
| If both RegsiteredData and InputData is NULL, then ASSERT(). | |
| @param RegsiteredData A pointer to a buffer that is filled in with the | |
| keystroke state data for the key that was | |
| registered. | |
| @param InputData A pointer to a buffer that is filled in with the | |
| keystroke state data for the key that was | |
| pressed. | |
| @retval TRUE Key be pressed matches a registered key. | |
| @retval FALSE Match failed. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Event notification function for EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL.WaitForKeyEx event | |
| Signal the event if there is key available | |
| @param Event Indicates the event that invoke this function. | |
| @param Context Indicates the calling context. | |
| **/ | |
| VOID | |
| EFIAPI | |
| TerminalConInWaitForKeyEx ( | |
| IN EFI_EVENT Event, | |
| IN VOID *Context | |
| ) | |
| { | |
| TerminalConInWaitForKey (Event, Context); | |
| } | |
| // | |
| // Simple Text Input Ex protocol functions | |
| // | |
| /** | |
| Reset the input device and optionally run diagnostics | |
| @param This Protocol instance pointer. | |
| @param ExtendedVerification Driver may perform diagnostics on reset. | |
| @retval EFI_SUCCESS The device was reset. | |
| @retval EFI_DEVICE_ERROR The device is not functioning properly and could | |
| not be reset. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Reads the next keystroke from the input device. The WaitForKey Event can | |
| be used to test for existence of a keystroke via WaitForEvent () call. | |
| @param This Protocol instance pointer. | |
| @param KeyData A pointer to a buffer that is filled in with the | |
| keystroke state data for the key that was | |
| pressed. | |
| @retval EFI_SUCCESS The keystroke information was returned. | |
| @retval EFI_NOT_READY There was no keystroke data available. | |
| @retval EFI_DEVICE_ERROR The keystroke information was not returned due | |
| to hardware errors. | |
| @retval EFI_INVALID_PARAMETER KeyData is NULL. | |
| **/ | |
| 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); | |
| } | |
| /** | |
| Set certain state for the input device. | |
| @param This Protocol instance pointer. | |
| @param KeyToggleState A pointer to the EFI_KEY_TOGGLE_STATE to set the | |
| state for the input device. | |
| @retval EFI_SUCCESS The device state was set successfully. | |
| @retval EFI_DEVICE_ERROR The device is not functioning correctly and | |
| could not have the setting adjusted. | |
| @retval EFI_UNSUPPORTED The device does not have the ability to set its | |
| state. | |
| @retval EFI_INVALID_PARAMETER KeyToggleState is NULL. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Register a notification function for a particular keystroke for the input device. | |
| @param This Protocol instance pointer. | |
| @param KeyData A pointer to a buffer that is filled in with | |
| the keystroke information for the key that was | |
| pressed. If KeyData.Key, KeyData.KeyState.KeyToggleState | |
| and KeyData.KeyState.KeyShiftState are 0, then any incomplete | |
| keystroke will trigger a notification of the KeyNotificationFunction. | |
| @param KeyNotificationFunction Points to the function to be called when the key | |
| sequence is typed specified by KeyData. This notification function | |
| should be called at <=TPL_CALLBACK. | |
| @param NotifyHandle Points to the unique handle assigned to the | |
| registered notification. | |
| @retval EFI_SUCCESS The notification function was registered | |
| successfully. | |
| @retval EFI_OUT_OF_RESOURCES Unable to allocate resources for necessary data | |
| structures. | |
| @retval EFI_INVALID_PARAMETER KeyData or NotifyHandle is NULL. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Remove a registered notification function from a particular keystroke. | |
| @param This Protocol instance pointer. | |
| @param NotificationHandle The handle of the notification function being | |
| unregistered. | |
| @retval EFI_SUCCESS The notification function was unregistered | |
| successfully. | |
| @retval EFI_INVALID_PARAMETER The NotificationHandle is invalid. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Translate raw data into Unicode (according to different encode), and | |
| translate Unicode into key information. (according to different standard). | |
| @param TerminalDevice Terminal driver private structure. | |
| **/ | |
| 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; | |
| } | |
| } | |
| /** | |
| Event notification function for EFI_SIMPLE_TEXT_INPUT_PROTOCOL.WaitForKey event | |
| Signal the event if there is key available | |
| @param Event Indicates the event that invoke this function. | |
| @param Context Indicates the calling context. | |
| **/ | |
| 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); | |
| } | |
| } | |
| /** | |
| Timer handler to poll the key from serial. | |
| @param Event Indicates the event that invoke this function. | |
| @param Context Indicates the calling context. | |
| **/ | |
| 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); | |
| } | |
| /** | |
| Process key notify. | |
| @param Event Indicates the event that invoke this function. | |
| @param Context Indicates the calling context. | |
| **/ | |
| 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); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| Get one key out of serial buffer. | |
| @param SerialIo Serial I/O protocol attached to the serial device. | |
| @param Output The fetched key. | |
| @retval EFI_NOT_READY If serial buffer is empty. | |
| @retval EFI_DEVICE_ERROR If reading serial buffer encounter error. | |
| @retval EFI_SUCCESS If reading serial buffer successfully, put | |
| the fetched key to the parameter output. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Insert one byte raw data into the Raw Data FIFO. | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Input The key will be input. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If Raw Data buffer is full before key insertion, | |
| and the key is lost. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Remove one pre-fetched key out of the Raw Data FIFO. | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Output The key will be removed. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If Raw Data FIFO buffer is empty before remove operation. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Clarify whether Raw Data FIFO buffer is empty. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If Raw Data FIFO buffer is empty. | |
| @retval FALSE If Raw Data FIFO buffer is not empty. | |
| **/ | |
| BOOLEAN | |
| IsRawFiFoEmpty ( | |
| TERMINAL_DEV *TerminalDevice | |
| ) | |
| { | |
| if (TerminalDevice->RawFiFo->Head == TerminalDevice->RawFiFo->Tail) { | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| Clarify whether Raw Data FIFO buffer is full. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If Raw Data FIFO buffer is full. | |
| @retval FALSE If Raw Data FIFO buffer is not full. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Insert one pre-fetched key into the FIFO buffer. | |
| @param EfiKeyFiFo Pointer to instance of EFI_KEY_FIFO. | |
| @param Input The key will be input. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If FIFO buffer is full before key insertion, | |
| and the key is lost. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Remove one pre-fetched key out of the FIFO buffer. | |
| @param EfiKeyFiFo Pointer to instance of EFI_KEY_FIFO. | |
| @param Output The key will be removed. | |
| @retval TRUE If remove successfully. | |
| @retval FALSE If FIFO buffer is empty before remove operation. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Clarify whether FIFO buffer is empty. | |
| @param EfiKeyFiFo Pointer to instance of EFI_KEY_FIFO. | |
| @retval TRUE If FIFO buffer is empty. | |
| @retval FALSE If FIFO buffer is not empty. | |
| **/ | |
| BOOLEAN | |
| IsEfiKeyFiFoForNotifyEmpty ( | |
| EFI_KEY_FIFO *EfiKeyFiFo | |
| ) | |
| { | |
| if (EfiKeyFiFo->Head == EfiKeyFiFo->Tail) { | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| Clarify whether FIFO buffer is full. | |
| @param EfiKeyFiFo Pointer to instance of EFI_KEY_FIFO. | |
| @retval TRUE If FIFO buffer is full. | |
| @retval FALSE If FIFO buffer is not full. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Insert one pre-fetched key into the FIFO buffer. | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Key The key will be input. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If FIFO buffer is full before key insertion, | |
| and the key is lost. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Remove one pre-fetched key out of the FIFO buffer. | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Output The key will be removed. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If FIFO buffer is empty before remove operation. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Clarify whether FIFO buffer is empty. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If FIFO buffer is empty. | |
| @retval FALSE If FIFO buffer is not empty. | |
| **/ | |
| BOOLEAN | |
| IsEfiKeyFiFoEmpty ( | |
| TERMINAL_DEV *TerminalDevice | |
| ) | |
| { | |
| if (TerminalDevice->EfiKeyFiFo->Head == TerminalDevice->EfiKeyFiFo->Tail) { | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| Clarify whether FIFO buffer is full. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If FIFO buffer is full. | |
| @retval FALSE If FIFO buffer is not full. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Insert one pre-fetched key into the Unicode FIFO buffer. | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Input The key will be input. | |
| @retval TRUE If insert successfully. | |
| @retval FALSE If Unicode FIFO buffer is full before key insertion, | |
| and the key is lost. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Remove one pre-fetched key out of the Unicode FIFO buffer. | |
| The caller should guarantee that Unicode FIFO buffer is not empty | |
| by IsUnicodeFiFoEmpty (). | |
| @param TerminalDevice Terminal driver private structure. | |
| @param Output The key will be removed. | |
| **/ | |
| 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)); | |
| } | |
| /** | |
| Clarify whether Unicode FIFO buffer is empty. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If Unicode FIFO buffer is empty. | |
| @retval FALSE If Unicode FIFO buffer is not empty. | |
| **/ | |
| BOOLEAN | |
| IsUnicodeFiFoEmpty ( | |
| TERMINAL_DEV *TerminalDevice | |
| ) | |
| { | |
| if (TerminalDevice->UnicodeFiFo->Head == TerminalDevice->UnicodeFiFo->Tail) { | |
| return TRUE; | |
| } else { | |
| return FALSE; | |
| } | |
| } | |
| /** | |
| Clarify whether Unicode FIFO buffer is full. | |
| @param TerminalDevice Terminal driver private structure | |
| @retval TRUE If Unicode FIFO buffer is full. | |
| @retval FALSE If Unicode FIFO buffer is not full. | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Update the Unicode characters from a terminal input device into EFI Keys FIFO. | |
| @param TerminalDevice The terminal device to use to translate raw input into EFI Keys | |
| **/ | |
| 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; | |
| } | |
| /** | |
| Converts a stream of Unicode characters from a terminal input device into EFI Keys that | |
| can be read through the Simple Input Protocol. | |
| The table below shows the keyboard input mappings that this function supports. | |
| If the ESC sequence listed in one of the columns is presented, then it is translated | |
| into the corresponding EFI Scan Code. If a matching sequence is not found, then the raw | |
| key strokes are converted into EFI Keys. | |
| 2 seconds are allowed for an ESC sequence to be completed. If the ESC sequence is not | |
| completed in 2 seconds, then the raw key strokes of the partial ESC sequence are | |
| converted into EFI Keys. | |
| There is one special input sequence that will force the system to reset. | |
| This is ESC R ESC r ESC R. | |
| Note: current implementation support terminal types include: PC ANSI, VT100+/VTUTF8, VT100. | |
| The table below is not same with UEFI Spec 2.3 Appendix B Table 201(not support ANSI X3.64 / | |
| DEC VT200-500 and extra support PC ANSI, VT100)since UEFI Table 201 is just an example. | |
| Symbols used in table below | |
| =========================== | |
| ESC = 0x1B | |
| CSI = 0x9B | |
| DEL = 0x7f | |
| ^ = CTRL | |
| +=========+======+===========+==========+==========+ | |
| | | EFI | UEFI 2.0 | | | | |
| | | Scan | | VT100+ | | | |
| | KEY | Code | PC ANSI | VTUTF8 | VT100 | | |
| +=========+======+===========+==========+==========+ | |
| | NULL | 0x00 | | | | | |
| | UP | 0x01 | ESC [ A | ESC [ A | ESC [ A | | |
| | DOWN | 0x02 | ESC [ B | ESC [ B | ESC [ B | | |
| | RIGHT | 0x03 | ESC [ C | ESC [ C | ESC [ C | | |
| | LEFT | 0x04 | ESC [ D | ESC [ D | ESC [ D | | |
| | HOME | 0x05 | ESC [ H | ESC h | ESC [ H | | |
| | END | 0x06 | ESC [ F | ESC k | ESC [ K | | |
| | INSERT | 0x07 | ESC [ @ | ESC + | ESC [ @ | | |
| | | | ESC [ L | | ESC [ L | | |
| | DELETE | 0x08 | ESC [ X | ESC - | ESC [ P | | |
| | PG UP | 0x09 | ESC [ I | ESC ? | ESC [ V | | |
| | | | | | ESC [ ? | | |
| | PG DOWN | 0x0A | ESC [ G | ESC / | ESC [ U | | |
| | | | | | ESC [ / | | |
| | F1 | 0x0B | ESC [ M | ESC 1 | ESC O P | | |
| | F2 | 0x0C | ESC [ N | ESC 2 | ESC O Q | | |
| | F3 | 0x0D | ESC [ O | ESC 3 | ESC O w | | |
| | F4 | 0x0E | ESC [ P | ESC 4 | ESC O x | | |
| | F5 | 0x0F | ESC [ Q | ESC 5 | ESC O t | | |
| | F6 | 0x10 | ESC [ R | ESC 6 | ESC O u | | |
| | F7 | 0x11 | ESC [ S | ESC 7 | ESC O q | | |
| | F8 | 0x12 | ESC [ T | ESC 8 | ESC O r | | |
| | F9 | 0x13 | ESC [ U | ESC 9 | ESC O p | | |
| | F10 | 0x14 | ESC [ V | ESC 0 | ESC O M | | |
| | Escape | 0x17 | ESC | ESC | ESC | | |
| | F11 | 0x15 | | ESC ! | | | |
| | F12 | 0x16 | | ESC @ | | | |
| +=========+======+===========+==========+==========+ | |
| Putty function key map: | |
| +=========+======+===========+=============+=============+=============+=========+ | |
| | | EFI | | | | | | | |
| | | Scan | | | Normal | | | | |
| | KEY | Code | VT100+ | Xterm R6 | VT400 | Linux | SCO | | |
| +=========+======+===========+=============+=============+=============+=========+ | |
| | F1 | 0x0B | ESC O P | ESC O P | ESC [ 1 1 ~ | ESC [ [ A | ESC [ M | | |
| | F2 | 0x0C | ESC O Q | ESC O Q | ESC [ 1 2 ~ | ESC [ [ B | ESC [ N | | |
| | F3 | 0x0D | ESC O R | ESC O R | ESC [ 1 3 ~ | ESC [ [ C | ESC [ O | | |
| | F4 | 0x0E | ESC O S | ESC O S | ESC [ 1 4 ~ | ESC [ [ D | ESC [ P | | |
| | F5 | 0x0F | ESC O T | ESC [ 1 5 ~ | ESC [ 1 5 ~ | ESC [ [ E | ESC [ Q | | |
| | F6 | 0x10 | ESC O U | ESC [ 1 7 ~ | ESC [ 1 7 ~ | ESC [ 1 7 ~ | ESC [ R | | |
| | F7 | 0x11 | ESC O V | ESC [ 1 8 ~ | ESC [ 1 8 ~ | ESC [ 1 8 ~ | ESC [ S | | |
| | F8 | 0x12 | ESC O W | ESC [ 1 9 ~ | ESC [ 1 9 ~ | ESC [ 1 9 ~ | ESC [ T | | |
| | F9 | 0x13 | ESC O X | ESC [ 2 0 ~ | ESC [ 2 0 ~ | ESC [ 2 0 ~ | ESC [ U | | |
| | F10 | 0x14 | ESC O Y | ESC [ 2 1 ~ | ESC [ 2 1 ~ | ESC [ 2 1 ~ | ESC [ V | | |
| | Escape | 0x17 | ESC | ESC | ESC | ESC | ESC | | |
| | F11 | 0x15 | ESC O Z | ESC [ 2 3 ~ | ESC [ 2 3 ~ | ESC [ 2 3 ~ | ESC [ W | | |
| | F12 | 0x16 | ESC O [ | ESC [ 2 4 ~ | ESC [ 2 4 ~ | ESC [ 2 4 ~ | ESC [ X | | |
| +=========+======+===========+=============+=============+=============+=========+ | |
| Special Mappings | |
| ================ | |
| ESC R ESC r ESC R = Reset System | |
| @param TerminalDevice The terminal device to use to translate raw input into EFI Keys | |
| **/ | |
| 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->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) { | |
| 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 ((EFI_D_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); | |
| } | |
| } |