mirror of https://github.com/acidanthera/audk.git
787 lines
19 KiB
C
787 lines
19 KiB
C
/** @file
|
|
|
|
Copyright (c) 2004 - 2007, Intel Corporation
|
|
All rights reserved. This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
Module Name:
|
|
|
|
EfiKey.c
|
|
|
|
Abstract:
|
|
|
|
USB Keyboard Driver
|
|
|
|
Revision History
|
|
|
|
|
|
**/
|
|
|
|
#include "efikey.h"
|
|
#include "keyboard.h"
|
|
|
|
//
|
|
// Prototypes
|
|
// Driver model protocol interface
|
|
//
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingEntryPoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingSupported (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingStart (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
);
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingStop (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN UINTN NumberOfChildren,
|
|
IN EFI_HANDLE *ChildHandleBuffer
|
|
);
|
|
|
|
//
|
|
// Simple Text In Protocol Interface
|
|
//
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardReset (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
);
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardReadKeyStroke (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
OUT EFI_INPUT_KEY *Key
|
|
);
|
|
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
USBKeyboardWaitForKey (
|
|
IN EFI_EVENT Event,
|
|
IN VOID *Context
|
|
);
|
|
|
|
//
|
|
// Helper functions
|
|
//
|
|
STATIC
|
|
EFI_STATUS
|
|
USBKeyboardCheckForKey (
|
|
IN USB_KB_DEV *UsbKeyboardDevice
|
|
);
|
|
|
|
EFI_GUID gEfiUsbKeyboardDriverGuid = {
|
|
0xa05f5f78, 0xfb3, 0x4d10, {0x90, 0x90, 0xac, 0x4, 0x6e, 0xeb, 0x7c, 0x3c}
|
|
};
|
|
|
|
//
|
|
// USB Keyboard Driver Global Variables
|
|
//
|
|
EFI_DRIVER_BINDING_PROTOCOL gUsbKeyboardDriverBinding = {
|
|
USBKeyboardDriverBindingSupported,
|
|
USBKeyboardDriverBindingStart,
|
|
USBKeyboardDriverBindingStop,
|
|
0xa,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingEntryPoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Driver Entry Point.
|
|
|
|
Arguments:
|
|
ImageHandle - EFI_HANDLE
|
|
SystemTable - EFI_SYSTEM_TABLE
|
|
Returns:
|
|
EFI_STATUS
|
|
|
|
--*/
|
|
{
|
|
return EfiLibInstallAllDriverProtocols (
|
|
ImageHandle,
|
|
SystemTable,
|
|
&gUsbKeyboardDriverBinding,
|
|
ImageHandle,
|
|
&gUsbKeyboardComponentName,
|
|
NULL,
|
|
NULL
|
|
);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Supported.
|
|
|
|
@param This EFI_DRIVER_BINDING_PROTOCOL
|
|
@param Controller Controller handle
|
|
@param RemainingDevicePath EFI_DEVICE_PATH_PROTOCOL
|
|
EFI_STATUS
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingSupported (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS OpenStatus;
|
|
EFI_USB_IO_PROTOCOL *UsbIo;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Check if USB_IO protocol is attached on the controller handle.
|
|
//
|
|
OpenStatus = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
(VOID **) &UsbIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (OpenStatus)) {
|
|
return OpenStatus;
|
|
}
|
|
|
|
//
|
|
// Use the USB I/O protocol interface to check whether the Controller is
|
|
// the Keyboard controller that can be managed by this driver.
|
|
//
|
|
Status = EFI_SUCCESS;
|
|
|
|
if (!IsUSBKeyboard (UsbIo)) {
|
|
Status = EFI_UNSUPPORTED;
|
|
}
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Start.
|
|
|
|
@param This EFI_DRIVER_BINDING_PROTOCOL
|
|
@param Controller Controller handle
|
|
@param RemainingDevicePath EFI_DEVICE_PATH_PROTOCOL
|
|
|
|
@retval EFI_SUCCESS Success
|
|
@retval EFI_OUT_OF_RESOURCES Can't allocate memory
|
|
@retval EFI_UNSUPPORTED The Start routine fail
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingStart (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_USB_IO_PROTOCOL *UsbIo;
|
|
USB_KB_DEV *UsbKeyboardDevice;
|
|
UINT8 EndpointNumber;
|
|
EFI_USB_ENDPOINT_DESCRIPTOR EndpointDescriptor;
|
|
UINT8 Index;
|
|
UINT8 EndpointAddr;
|
|
UINT8 PollingInterval;
|
|
UINT8 PacketSize;
|
|
BOOLEAN Found;
|
|
|
|
UsbKeyboardDevice = NULL;
|
|
Found = FALSE;
|
|
|
|
//
|
|
// Open USB_IO Protocol
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
(VOID **) &UsbIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
UsbKeyboardDevice = AllocateZeroPool (sizeof (USB_KB_DEV));
|
|
if (UsbKeyboardDevice == NULL) {
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
//
|
|
// Get the Device Path Protocol on Controller's handle
|
|
//
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID **) &UsbKeyboardDevice->DevicePath,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return Status;
|
|
}
|
|
//
|
|
// Report that the usb keyboard is being enabled
|
|
//
|
|
KbdReportStatusCode (
|
|
UsbKeyboardDevice->DevicePath,
|
|
EFI_PROGRESS_CODE,
|
|
PcdGet32 (PcdStatusCodeValueKeyboardEnable)
|
|
);
|
|
|
|
//
|
|
// This is pretty close to keyboard detection, so log progress
|
|
//
|
|
KbdReportStatusCode (
|
|
UsbKeyboardDevice->DevicePath,
|
|
EFI_PROGRESS_CODE,
|
|
PcdGet32 (PcdStatusCodeValueKeyboardPresenceDetect)
|
|
);
|
|
|
|
//
|
|
// Initialize UsbKeyboardDevice
|
|
//
|
|
UsbKeyboardDevice->UsbIo = UsbIo;
|
|
|
|
//
|
|
// Get interface & endpoint descriptor
|
|
//
|
|
UsbIo->UsbGetInterfaceDescriptor (
|
|
UsbIo,
|
|
&UsbKeyboardDevice->InterfaceDescriptor
|
|
);
|
|
|
|
EndpointNumber = UsbKeyboardDevice->InterfaceDescriptor.NumEndpoints;
|
|
|
|
for (Index = 0; Index < EndpointNumber; Index++) {
|
|
|
|
UsbIo->UsbGetEndpointDescriptor (
|
|
UsbIo,
|
|
Index,
|
|
&EndpointDescriptor
|
|
);
|
|
|
|
if ((EndpointDescriptor.Attributes & 0x03) == 0x03) {
|
|
//
|
|
// We only care interrupt endpoint here
|
|
//
|
|
CopyMem(&UsbKeyboardDevice->IntEndpointDescriptor, &EndpointDescriptor, sizeof(EndpointDescriptor));
|
|
Found = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!Found) {
|
|
//
|
|
// No interrupt endpoint found, then return unsupported.
|
|
//
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
UsbKeyboardDevice->Signature = USB_KB_DEV_SIGNATURE;
|
|
UsbKeyboardDevice->SimpleInput.Reset = USBKeyboardReset;
|
|
UsbKeyboardDevice->SimpleInput.ReadKeyStroke = USBKeyboardReadKeyStroke;
|
|
Status = gBS->CreateEvent (
|
|
EVT_NOTIFY_WAIT,
|
|
TPL_NOTIFY,
|
|
USBKeyboardWaitForKey,
|
|
UsbKeyboardDevice,
|
|
&(UsbKeyboardDevice->SimpleInput.WaitForKey)
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Install simple txt in protocol interface
|
|
// for the usb keyboard device.
|
|
// Usb keyboard is a hot plug device, and expected to work immediately
|
|
// when plugging into system, so a HotPlugDeviceGuid is installed onto
|
|
// the usb keyboard device handle, to distinguish it from other conventional
|
|
// console devices.
|
|
//
|
|
Status = gBS->InstallMultipleProtocolInterfaces (
|
|
&Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&UsbKeyboardDevice->SimpleInput,
|
|
&gEfiHotPlugDeviceGuid,
|
|
NULL,
|
|
NULL
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
gBS->CloseEvent (UsbKeyboardDevice->SimpleInput.WaitForKey);
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Reset USB Keyboard Device
|
|
//
|
|
Status = UsbKeyboardDevice->SimpleInput.Reset (
|
|
&UsbKeyboardDevice->SimpleInput,
|
|
TRUE
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
gBS->UninstallMultipleProtocolInterfaces (
|
|
Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&UsbKeyboardDevice->SimpleInput,
|
|
&gEfiHotPlugDeviceGuid,
|
|
NULL,
|
|
NULL
|
|
);
|
|
gBS->CloseEvent (UsbKeyboardDevice->SimpleInput.WaitForKey);
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return Status;
|
|
}
|
|
//
|
|
// submit async interrupt transfer
|
|
//
|
|
EndpointAddr = UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress;
|
|
PollingInterval = UsbKeyboardDevice->IntEndpointDescriptor.Interval;
|
|
PacketSize = (UINT8) (UsbKeyboardDevice->IntEndpointDescriptor.MaxPacketSize);
|
|
|
|
Status = UsbIo->UsbAsyncInterruptTransfer (
|
|
UsbIo,
|
|
EndpointAddr,
|
|
TRUE,
|
|
PollingInterval,
|
|
PacketSize,
|
|
KeyboardHandler,
|
|
UsbKeyboardDevice
|
|
);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
|
|
gBS->UninstallMultipleProtocolInterfaces (
|
|
Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&UsbKeyboardDevice->SimpleInput,
|
|
&gEfiHotPlugDeviceGuid,
|
|
NULL,
|
|
NULL
|
|
);
|
|
gBS->CloseEvent (UsbKeyboardDevice->SimpleInput.WaitForKey);
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
return Status;
|
|
}
|
|
|
|
UsbKeyboardDevice->ControllerNameTable = NULL;
|
|
AddUnicodeString (
|
|
"eng",
|
|
gUsbKeyboardComponentName.SupportedLanguages,
|
|
&UsbKeyboardDevice->ControllerNameTable,
|
|
L"Generic Usb Keyboard"
|
|
);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Stop.
|
|
|
|
@param This EFI_DRIVER_BINDING_PROTOCOL
|
|
@param Controller Controller handle
|
|
@param NumberOfChildren Child handle number
|
|
@param ChildHandleBuffer Child handle buffer
|
|
|
|
@retval EFI_SUCCESS Success
|
|
@retval EFI_UNSUPPORTED Can't support
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardDriverBindingStop (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN UINTN NumberOfChildren,
|
|
IN EFI_HANDLE *ChildHandleBuffer
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_SIMPLE_TEXT_INPUT_PROTOCOL *SimpleInput;
|
|
USB_KB_DEV *UsbKeyboardDevice;
|
|
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
(VOID **) &SimpleInput,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Get USB_KB_DEV instance.
|
|
//
|
|
UsbKeyboardDevice = USB_KB_DEV_FROM_THIS (SimpleInput);
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
//
|
|
// Uninstall the Asyn Interrupt Transfer from this device
|
|
// will disable the key data input from this device
|
|
//
|
|
KbdReportStatusCode (
|
|
UsbKeyboardDevice->DevicePath,
|
|
EFI_PROGRESS_CODE,
|
|
PcdGet32 (PcdStatusCodeValueKeyboardDisable)
|
|
);
|
|
|
|
//
|
|
// Destroy asynchronous interrupt transfer
|
|
//
|
|
UsbKeyboardDevice->UsbIo->UsbAsyncInterruptTransfer (
|
|
UsbKeyboardDevice->UsbIo,
|
|
UsbKeyboardDevice->IntEndpointDescriptor.EndpointAddress,
|
|
FALSE,
|
|
UsbKeyboardDevice->IntEndpointDescriptor.Interval,
|
|
0,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiUsbIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
Status = gBS->UninstallMultipleProtocolInterfaces (
|
|
Controller,
|
|
&gEfiSimpleTextInProtocolGuid,
|
|
&UsbKeyboardDevice->SimpleInput,
|
|
&gEfiHotPlugDeviceGuid,
|
|
NULL,
|
|
NULL
|
|
);
|
|
//
|
|
// free all the resources.
|
|
//
|
|
gBS->CloseEvent (UsbKeyboardDevice->RepeatTimer);
|
|
gBS->CloseEvent (UsbKeyboardDevice->DelayedRecoveryEvent);
|
|
gBS->CloseEvent ((UsbKeyboardDevice->SimpleInput).WaitForKey);
|
|
|
|
if (UsbKeyboardDevice->ControllerNameTable != NULL) {
|
|
FreeUnicodeStringTable (UsbKeyboardDevice->ControllerNameTable);
|
|
}
|
|
|
|
gBS->FreePool (UsbKeyboardDevice);
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Implements EFI_SIMPLE_TEXT_INPUT_PROTOCOL.Reset() function.
|
|
|
|
This The EFI_SIMPLE_TEXT_INPUT_PROTOCOL instance.
|
|
ExtendedVerification
|
|
Indicates that the driver may perform a more exhaustive
|
|
verification operation of the device during reset.
|
|
|
|
@retval EFI_SUCCESS Success
|
|
@retval EFI_DEVICE_ERROR Hardware Error
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardReset (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
IN BOOLEAN ExtendedVerification
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
USB_KB_DEV *UsbKeyboardDevice;
|
|
|
|
UsbKeyboardDevice = USB_KB_DEV_FROM_THIS (This);
|
|
|
|
KbdReportStatusCode (
|
|
UsbKeyboardDevice->DevicePath,
|
|
EFI_PROGRESS_CODE,
|
|
PcdGet32 (PcdStatusCodeValueKeyboardReset)
|
|
);
|
|
|
|
//
|
|
// Non Exhaustive reset:
|
|
// only reset private data structures.
|
|
//
|
|
if (!ExtendedVerification) {
|
|
//
|
|
// Clear the key buffer of this Usb keyboard
|
|
//
|
|
KbdReportStatusCode (
|
|
UsbKeyboardDevice->DevicePath,
|
|
EFI_PROGRESS_CODE,
|
|
PcdGet32 (PcdStatusCodeValueKeyboardClearBuffer)
|
|
);
|
|
|
|
InitUSBKeyBuffer (&(UsbKeyboardDevice->KeyboardBuffer));
|
|
UsbKeyboardDevice->CurKeyChar = 0;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Exhaustive reset
|
|
//
|
|
Status = InitUSBKeyboard (UsbKeyboardDevice);
|
|
UsbKeyboardDevice->CurKeyChar = 0;
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Implements EFI_SIMPLE_TEXT_INPUT_PROTOCOL.ReadKeyStroke() function.
|
|
|
|
This The EFI_SIMPLE_TEXT_INPUT_PROTOCOL instance.
|
|
Key A pointer to a buffer that is filled in with the keystroke
|
|
information for the key that was pressed.
|
|
|
|
@retval EFI_SUCCESS Success
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
USBKeyboardReadKeyStroke (
|
|
IN EFI_SIMPLE_TEXT_INPUT_PROTOCOL *This,
|
|
OUT EFI_INPUT_KEY *Key
|
|
)
|
|
{
|
|
USB_KB_DEV *UsbKeyboardDevice;
|
|
EFI_STATUS Status;
|
|
UINT8 KeyChar;
|
|
|
|
UsbKeyboardDevice = USB_KB_DEV_FROM_THIS (This);
|
|
|
|
//
|
|
// if there is no saved ASCII byte, fetch it
|
|
// by calling USBKeyboardCheckForKey().
|
|
//
|
|
if (UsbKeyboardDevice->CurKeyChar == 0) {
|
|
Status = USBKeyboardCheckForKey (UsbKeyboardDevice);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
Key->UnicodeChar = 0;
|
|
Key->ScanCode = SCAN_NULL;
|
|
|
|
KeyChar = UsbKeyboardDevice->CurKeyChar;
|
|
|
|
UsbKeyboardDevice->CurKeyChar = 0;
|
|
|
|
//
|
|
// Translate saved ASCII byte into EFI_INPUT_KEY
|
|
//
|
|
Status = USBKeyCodeToEFIScanCode (UsbKeyboardDevice, KeyChar, Key);
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
Handler function for WaitForKey event.
|
|
|
|
Event Event to be signaled when a key is pressed.
|
|
Context Points to USB_KB_DEV instance.
|
|
|
|
@return VOID
|
|
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
USBKeyboardWaitForKey (
|
|
IN EFI_EVENT Event,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
USB_KB_DEV *UsbKeyboardDevice;
|
|
|
|
UsbKeyboardDevice = (USB_KB_DEV *) Context;
|
|
|
|
if (UsbKeyboardDevice->CurKeyChar == 0) {
|
|
|
|
if (EFI_ERROR (USBKeyboardCheckForKey (UsbKeyboardDevice))) {
|
|
return ;
|
|
}
|
|
}
|
|
//
|
|
// If has key pending, signal the event.
|
|
//
|
|
gBS->SignalEvent (Event);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Check whether there is key pending.
|
|
|
|
UsbKeyboardDevice The USB_KB_DEV instance.
|
|
|
|
@retval EFI_SUCCESS Success
|
|
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
USBKeyboardCheckForKey (
|
|
IN USB_KB_DEV *UsbKeyboardDevice
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINT8 KeyChar;
|
|
|
|
//
|
|
// Fetch raw data from the USB keyboard input,
|
|
// and translate it into ASCII data.
|
|
//
|
|
Status = USBParseKey (UsbKeyboardDevice, &KeyChar);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
UsbKeyboardDevice->CurKeyChar = KeyChar;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Report Status Code in Usb Bot Driver
|
|
|
|
@param DevicePath Use this to get Device Path
|
|
@param CodeType Status Code Type
|
|
@param CodeValue Status Code Value
|
|
|
|
@return None
|
|
|
|
**/
|
|
VOID
|
|
KbdReportStatusCode (
|
|
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
|
|
IN EFI_STATUS_CODE_TYPE CodeType,
|
|
IN EFI_STATUS_CODE_VALUE Value
|
|
)
|
|
{
|
|
|
|
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
|
|
CodeType,
|
|
Value,
|
|
DevicePath
|
|
);
|
|
}
|