/** @file
ConsoleOut Routines that speak VGA.
Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
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
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "BiosKeyboard.h"
//
// EFI Driver Binding Protocol Instance
//
0x3,
NULL,
};
/**
Enqueue the key.
@param Queue The queue to be enqueued.
@param KeyData The key data to be enqueued.
@retval EFI_NOT_READY The queue is full.
@retval EFI_SUCCESS Successfully enqueued the key data.
**/
Enqueue (
)
{
return EFI_NOT_READY;
}
return EFI_SUCCESS;
}
/**
Dequeue the key.
@param Queue The queue to be dequeued.
@param KeyData The key data to be dequeued.
@retval EFI_NOT_READY The queue is empty.
@retval EFI_SUCCESS Successfully dequeued the key data.
**/
Dequeue (
)
{
return EFI_NOT_READY;
}
return EFI_SUCCESS;
}
/**
Check whether the queue is empty.
@param Queue The queue to be checked.
@retval EFI_NOT_READY The queue is empty.
@retval EFI_SUCCESS The queue is not empty.
**/
)
{
return EFI_NOT_READY;
}
return EFI_SUCCESS;
}
//
// EFI Driver Binding Protocol Functions
//
/**
Check whether the driver supports this device.
@param This The Udriver binding protocol.
@param Controller The controller handle to check.
@param RemainingDevicePath The remaining device path.
@retval EFI_SUCCESS The driver supports this controller.
@retval other This device isn't supported.
**/
)
{
//
// See if the Legacy BIOS Protocol is available
//
NULL,
(VOID **) &LegacyBios
);
return Status;
}
//
// Open the IO Abstraction(s) needed to perform the supported test
//
);
return Status;
}
//
// Use the ISA I/O Protocol to see if Controller is the Keyboard controller
//
if (IsaIo->ResourceList->Device.HID != EISA_PNP_ID (0x303) || IsaIo->ResourceList->Device.UID != 0) {
}
gBS->CloseProtocol (
);
return Status;
}
/**
Starts the device with this driver.
@param This The driver binding instance.
@param Controller Handle of device to bind driver to.
@param RemainingDevicePath Optional parameter use to pick a specific child
device to start.
@retval EFI_SUCCESS The controller is controlled by the driver.
@retval Other This controller cannot be started.
**/
)
{
StatusCode = 0;
//
// Get Ps2 policy to set. Will be use if present.
//
NULL,
);
//
// See if the Legacy BIOS Protocol is available
//
NULL,
(VOID **) &LegacyBios
);
return Status;
}
//
// Open the IO Abstraction(s) needed
//
);
return Status;
}
//
// Allocate the private device structure
//
if (NULL == BiosKeyboardPrivate) {
goto Done;
}
//
// Initialize the private device structure
//
//
// Report that the keyboard is being enabled
//
);
//
// Setup the WaitForKey event
//
);
goto Done;
}
);
goto Done;
}
//
// Setup a periodic timer, used for reading keystrokes at a fixed interval
//
);
goto Done;
}
);
goto Done;
}
//
// Report a Progress Code for an attempt to detect the precense of the keyboard device in the system
//
);
//
// Reset the keyboard device
//
);
goto Done;
}
//
// Do platform specific policy like port swapping and keyboard light default
//
Command = 0;
Command |= 4;
}
Command |= 2;
}
Command |= 1;
}
//
// Call Legacy BIOS Protocol to set whatever is necessary
//
}
//
// Get Configuration
//
0x15,
&Regs
);
if (!CarryFlag) {
//
// Check bit 6 of Feature Byte 2.
// If it is set, then Int 16 Func 09 is supported
//
//
// Get Keyboard Functionality
//
0x16,
&Regs
);
if (!CarryFlag) {
//
// Check bit 5 of AH.
// If it is set, then INT 16 Finc 10-12 are supported.
//
//
// Set the flag to use INT 16 Func 10-12
//
}
}
}
}
DEBUG ((EFI_D_INFO, "[KBD]Extended keystrokes supported by CSM16 - %02x\n", (UINTN)BiosKeyboardPrivate->ExtendedKeyboard));
//
// Install protocol interfaces for the keyboard device.
//
);
Done:
if (StatusCode != 0) {
//
// Report an Error Code for failing to start the keyboard device
//
);
}
if (BiosKeyboardPrivate != NULL) {
}
}
}
}
gBS->CloseProtocol (
);
}
}
return Status;
}
/**
Stop the device handled by this driver.
@param This The driver binding protocol.
@param Controller The controller to release.
@param NumberOfChildren The number of handles in ChildHandleBuffer.
@param ChildHandleBuffer The array of child handle.
@retval EFI_SUCCESS The device was stopped.
@retval EFI_DEVICE_ERROR The device could not be stopped due to a device error.
@retval Others Fail to uninstall protocols attached on the device.
**/
)
{
//
// Disable Keyboard
//
(VOID **) &SimpleTextIn,
);
return Status;
}
NULL,
);
return Status;
}
);
return Status;
}
//
// Release the IsaIo protocol on the controller handle
//
gBS->CloseProtocol (
);
//
// Free other resources
//
return EFI_SUCCESS;
}
/**
Read data byte from output buffer of Keyboard Controller without delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@return The data byte read from output buffer of Keyboard Controller from data port which often is port 60H.
**/
)
{
//
// Use IsaIo protocol to perform IO operations
//
1,
&Data
);
return Data;
}
/**
Read status byte from status register of Keyboard Controller without delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@return The status byte read from status register of Keyboard Controller from command port which often is port 64H.
**/
)
{
//
// Use IsaIo protocol to perform IO operations
//
1,
&Data
);
return Data;
}
/**
Write command byte to control register of Keyboard Controller without delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Data Data byte to write.
**/
)
{
//
// Use IsaIo protocol to perform IO operations
//
1,
&Data
);
}
/**
Write data byte to input buffer or input/output ports of Keyboard Controller without delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Data Data byte to write.
**/
)
{
//
// Use IsaIo protocol to perform IO operations
//
1,
&Data
);
}
/**
Read data byte from output buffer of Keyboard Controller with delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Data The pointer for data that being read out.
@retval EFI_SUCCESS The data byte read out successfully.
@retval EFI_TIMEOUT Timeout occurred during reading out data byte.
**/
)
{
TimeOut = 0;
RegFilled = 0;
//
// wait till output buffer full then perform the read
//
RegFilled = 1;
break;
}
}
if (RegFilled == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Write data byte to input buffer or input/output ports of Keyboard Controller with delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Data Data byte to write.
@retval EFI_SUCCESS The data byte is written successfully.
@retval EFI_TIMEOUT Timeout occurred during writing.
**/
)
{
TimeOut = 0;
RegEmptied = 0;
//
// wait for input buffer empty
//
RegEmptied = 1;
break;
}
}
if (RegEmptied == 0) {
return EFI_TIMEOUT;
}
//
// Write it
//
return EFI_SUCCESS;
}
/**
Write command byte to control register of Keyboard Controller with delay and waiting for buffer-empty state.
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Data Command byte to write.
@retval EFI_SUCCESS The command byte is written successfully.
@retval EFI_TIMEOUT Timeout occurred during writing.
**/
)
{
TimeOut = 0;
RegEmptied = 0;
//
// Wait For Input Buffer Empty
//
RegEmptied = 1;
break;
}
}
if (RegEmptied == 0) {
return EFI_TIMEOUT;
}
//
// issue the command
//
//
// Wait For Input Buffer Empty again
//
RegEmptied = 0;
RegEmptied = 1;
break;
}
}
if (RegEmptied == 0) {
return EFI_TIMEOUT;
}
return EFI_SUCCESS;
}
/**
Wait for a specific value to be presented in
Data register of Keyboard Controller by keyboard and then read it,
used in keyboard commands ack
@param BiosKeyboardPrivate Keyboard instance pointer.
@param Value The value to be waited for
@param WaitForValueTimeOut The limit of microseconds for timeout
@retval EFI_SUCCESS The command byte is written successfully.
@retval EFI_TIMEOUT Timeout occurred during writing.
**/
)
{
GotIt = 0;
TimeOut = 0;
SumTimeOut = 0;
//
// Make sure the initial value of 'Data' is different from 'Value'
//
Data = 0;
Data = 1;
}
//
// Read from 8042 (multiple times if needed)
// until the expected value appears
// use SumTimeOut to control the iteration
//
while (1) {
//
// Perform a read
//
break;
}
}
SumTimeOut += TimeOut;
GotIt = 1;
break;
}
if (SumTimeOut >= WaitForValueTimeOut) {
break;
}
}
//
// Check results
//
if (GotIt != 0) {
return EFI_SUCCESS;
} else {
return EFI_TIMEOUT;
}
}
/**
Reads the next keystroke from the input device. The WaitForKey Event can
be used to test for existance of a keystroke via WaitForEvent () call.
@param BiosKeyboardPrivate Bioskeyboard 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 availiable.
@retval EFI_DEVICE_ERROR The keystroke information was not returned due to
hardware errors.
@retval EFI_INVALID_PARAMETER KeyData is NULL.
**/
)
{
return EFI_INVALID_PARAMETER;
}
//
// Use TimerEvent callback funciton to check whether there's any key pressed
//
//
// Stall 1ms to give a chance to let other driver interrupt this routine for their timer event.
// Csm will be used to check whether there is a key pending, but the csm will disable all
// interrupt before switch to compatibility16, which mean all the efiCompatibility timer
// event will stop work during the compatibility16. And If a caller recursivly invoke this function,
// e.g. OS loader, other drivers which are driven by timer event will have a bad performance during this period,
// e.g. usb keyboard driver.
// Add a stall period can greatly increate other driver performance during the WaitForKey is recursivly invoked.
// 1ms delay will make little impact to the thunk keyboard driver, and user can not feel the delay at all when input.
//
//
// If there's no key, just return
//
return EFI_NOT_READY;
}
return EFI_SUCCESS;
}
//
// EFI Simple Text In Protocol Functions
//
/**
Reset the Keyboard and do BAT test for it, if (ExtendedVerification == TRUE) then do some extra keyboard validations.
@param This Pointer of simple text Protocol.
@param ExtendedVerification Whether perform the extra validation of keyboard. True: perform; FALSE: skip.
@retval EFI_SUCCESS The command byte is written successfully.
@retval EFI_DEVICE_ERROR Errors occurred during reseting keyboard.
**/
)
{
MouseEnable = FALSE;
//
// 1
// Report reset progress code
//
);
//
// Report a Progress Code for clearing the keyboard buffer
//
);
//
// 2
// Raise TPL to avoid mouse operation impact
//
//
//
// Exhaust output buffer data
//
do {
This,
&Key
);
//
// 3
// check for KBC itself firstly for setted-up already or not by reading SYSF (bit2) of status register via 64H
// if not skip step 4&5 and jump to step 6 to selftest KBC and report this
// else go step 4
//
//
// 4
// CheckMouseStatus to decide enable it later or not
//
//
// Read the command byte of KBC
//
);
goto Exit;
}
Status = KeyboardRead (
);
goto Exit;
}
//
// Check mouse enabled or not before
//
if ((CommandByte & KB_CMMBYTE_DISABLE_AUX) != 0) {
MouseEnable = FALSE;
} else {
MouseEnable = TRUE;
}
//
// 5
// disable mouse (via KBC) and Keyborad device
//
);
goto Exit;
}
);
goto Exit;
}
} else {
//
// 6
// KBC Self Test
//
//
// Report a Progress Code for performing a self test on the keyboard controller
//
);
);
goto Exit;
}
);
goto Exit;
}
}
//
// 7
// Disable Mouse interface, enable Keyboard interface and declare selftest success
//
// Mouse device will block keyboard interface before it be configured, so we should disable mouse first.
//
);
goto Exit;
}
//
// Write 8042 Command Byte, set System Flag
// While at the same time:
// 1. disable mouse interface,
// 2. enable kbd interface,
// 4. enable mouse and kbd interrupts
//
//Command Byte bits:
// 7: Reserved
// 5: Disable Auxiliary device interface
// 4: Disable keyboard interface
// 3: Reserved
// 2: System Flag
// 1: Enable Auxiliary device interrupt
// 0: Enable Keyboard interrupt
//
CommandByte = 0;
Status = KeyboardWrite (
(UINT8) ((CommandByte &
(~KB_CMMBYTE_DISABLE_KB)) |
);
//
// For reseting keyboard is not mandatory before booting OS and sometimes keyboard responses very slow,
// so we only do the real reseting for keyboard when user asks, and normally during booting an OS, it's skipped.
// Call CheckKeyboardConnect() to check whether keyboard is connected, if it is not connected,
// Real reset will not do.
//
//
// 8
// Send keyboard reset command then read ACK
//
Status = KeyboardWrite (
);
goto Exit;
}
);
goto Exit;
}
//
// 9
// Wait for keyboard return test OK.
//
);
goto Exit;
}
//
// 10
// set keyboard scan code set = 02 (standard configuration)
//
Status = KeyboardWrite (
);
goto Exit;
}
);
goto Exit;
}
Status = KeyboardWrite (
);
goto Exit;
}
);
goto Exit;
}
//
// 11
// enable keyboard itself (not via KBC) by writing CMD F4 via 60H
//
Status = KeyboardWrite (
);
goto Exit;
}
);
goto Exit;
}
//
// 12
// Additional validation, do it as follow:
// 1). check for status register of PARE && TIM via 64H
// 2). perform KB checking by writing ABh via 64H
//
if ((KeyReadStatusRegister (BiosKeyboardPrivate) & (KBC_STSREG_VIA64_PARE | KBC_STSREG_VIA64_TIM)) != 0) {
goto Exit;
}
);
goto Exit;
}
);
goto Exit;
}
}
//
// 13
// Done for validating keyboard. Enable keyboard (via KBC)
// and recover the command byte to proper value
//
);
goto Exit;
}
//
// 14
// conditionally enable mouse (via KBC)
//
if (MouseEnable) {
);
}
}
Exit:
//
// 15
// resume priority of task level
//
return Status;
}
/**
Read out the scan code of the key that has just been stroked.
@param This Pointer of simple text Protocol.
@param Key Pointer for store the key that read out.
@retval EFI_SUCCESS The key is read out successfully.
@retval other The key reading failed.
**/
)
{
return Status;
}
//
// Convert the Ctrl+[a-z] to Ctrl+[1-26]
//
if ((KeyData.KeyState.KeyShiftState & (EFI_LEFT_CONTROL_PRESSED | EFI_RIGHT_CONTROL_PRESSED)) != 0) {
}
}
return EFI_SUCCESS;
}
/**
Waiting on the keyboard event, if there's any key pressed by the user, signal the event
@param Event The event that be siganlled when any key has been stroked.
@param Context Pointer of the protocol EFI_SIMPLE_TEXT_INPUT_PROTOCOL.
**/
)
{
//
// Stall 1ms to give a chance to let other driver interrupt this routine for their timer event.
// Csm will be used to check whether there is a key pending, but the csm will disable all
// interrupt before switch to compatibility16, which mean all the efiCompatibility timer
// event will stop work during the compatibility16. And If a caller recursivly invoke this function,
// e.g. UI setup or Shell, other drivers which are driven by timer event will have a bad performance during this period,
// e.g. usb keyboard driver.
// Add a stall period can greatly increate other driver performance during the WaitForKey is recursivly invoked.
// 1ms delay will make little impact to the thunk keyboard driver, and user can not feel the delay at all when input.
//
//
// Use TimerEvent callback funciton to check whether there's any key pressed
//
}
}
/**
Check key buffer to get the key stroke status.
@param This Pointer of the protocol EFI_SIMPLE_TEXT_IN_PROTOCOL.
@retval EFI_SUCCESS A key is being pressed now.
@retval Other No key is now pressed.
**/
)
{
}
//
// Private worker functions
//
typedef struct _CONVERT_TABLE_ENTRY {
{
0x47,
},
{
0x48,
},
{
0x49,
},
{
0x4b,
},
{
0x4d,
},
{
0x4f,
},
{
0x50,
},
{
0x51,
},
{
0x52,
},
{
0x53,
},
//
// Function Keys are only valid if KeyChar == 0x00
// This function does not require KeyChar to be 0x00
//
{
0x3b,
},
{
0x3c,
},
{
0x3d,
},
{
0x3e,
},
{
0x3f,
},
{
0x40,
},
{
0x41,
},
{
0x42,
},
{
0x43,
},
{
0x44,
},
{
0x85,
},
{
0x86,
},
//
// Convert ALT + Fn keys
//
{
0x68,
},
{
0x69,
},
{
0x6a,
},
{
0x6b,
},
{
0x6c,
},
{
0x6d,
},
{
0x6e,
},
{
0x6f,
},
{
0x70,
},
{
0x71,
},
{
},
};
/**
Convert unicode combined with scan code of key to the counterpart of EFIScancode of it.
@param KeyChar Unicode of key.
@param ScanCode Scan code of key.
@return The value of EFI Scancode for the key.
@retval SCAN_NULL No corresponding value in the EFI convert table is found for the key.
**/
)
{
//
// Movement & Function Keys
//
for (Index = 0; (Index < sizeof (mConvertTable) / sizeof (CONVERT_TABLE_ENTRY)) && (mConvertTable[Index].ScanCode != TABLE_END); Index += 1) {
}
}
//
// Reach Table end, return default value
//
return SCAN_NULL;
} else {
return SCAN_NULL;
}
return EfiScanCode;
}
/**
Check whether there is Ps/2 Keyboard device in system by 0xF4 Keyboard Command
If Keyboard receives 0xF4, it will respond with 'ACK'. If it doesn't respond, the device
should not be in system.
@param BiosKeyboardPrivate Keyboard Private Data Struture
@retval TRUE Keyboard in System.
@retval FALSE Keyboard not in System.
**/
)
{
//
// enable keyboard itself and wait for its ack
// If can't receive ack, Keyboard should not be connected.
//
Status = KeyboardWrite (
);
);
return FALSE;
}
);
);
return FALSE;
}
return TRUE;
}
/**
Timer event handler: read a series of key stroke from 8042
and put them into memory key buffer.
It is registered as running under TPL_NOTIFY
@param Event The timer event
@param Context A BIOS_KEYBOARD_DEV pointer
**/
)
{
//
// Enter critical section
//
//
// if there is no key present, just return
//
if (BiosKeyboardPrivate->ExtendedKeyboard) {
} else {
}
0x16,
&Regs
);
return;
}
//
// Read the key
//
if (BiosKeyboardPrivate->ExtendedKeyboard) {
} else {
}
0x16,
&Regs
);
DEBUG ((
"[KBD]INT16 returns EFI_INPUT_KEY.ScanCode - %x, EFI_INPUT_KEY.UnicodeChar - %x\n",
));
//
// Leagcy Bios use Int 9 which is IRQ1 interrupt handler to get keystroke scancode to KB buffer in BDA (BIOS DATE AREA), then
// Int 16 depend KB buffer and some key bits in BDA to translate the scancode to ASCII code, and return both the scancode and ASCII
// code to Int 16 caller. This translation process works well if the Int 9 could response user input in time. But in Tiano enviorment, the Int 9
// will be disabled after the thunk call finish, which means if user crazy input during int 9 being disabled, some keystrokes will be lost when
// KB device own hardware buffer overflows. And if the lost keystroke code is CTRL or ALT or SHIFT release code, these function key flags bit
// in BDA will not be updated. So the Int 16 will believe the CTRL or ALT or SHIFT is still pressed, and Int 16 will translate later scancode
// to wrong ASCII code. We can increase the Thunk frequence to let Int 9 response in time, but this way will much hurt other dirvers
// performance, like USB.
//
// 1. If CTRL or ALT release code is missed, all later input keys will be translated to wrong ASCII codes which the Tiano cannot support. In
// this case, the KB input seems fail to work, and user input is blocked. To solve the problem, we can help to clear the CTRL or ALT flag in BDA
// after every Int 16 finish. Thus persist to press CTRL or ALT has same effection as only press one time. It is Ok, since user not often use the
// CTRL and ALT.
//
// 2. If SHIFT release code is missed, all later lowercase input will become capital. This is ugly, but not block user input. If user press the lost
// SHIFT again, the lowercase will come back to normal. Since user often use the SHIFT, it is not reasonable to help to clear the SHIFT flag in BDA,
// which will let persist to press SHIFT has same effection as only press one time.
//
//0040h:0017h - KEYBOARD - STATUS FLAGS 1
// 7 INSert active
// 6 Caps Lock active
// 5 Num Lock active
// 4 Scroll Lock active
// 3 either Alt pressed
// 2 either Ctrl pressed
// 1 Left Shift pressed
// 0 Right Shift pressed
//
// Clear the CTRL and ALT BDA flag
//
{
}
}
}
} else {
}
}
} else {
}
}
}
}
}
);
//
// Record toggle state
//
}
}
}
//
// Record shift state
//
KeyData.KeyState.KeyShiftState |= ((KbFlag2 & KB_LEFT_ALT_PRESSED) == KB_LEFT_ALT_PRESSED) ? EFI_LEFT_ALT_PRESSED : EFI_RIGHT_ALT_PRESSED;
}
KeyData.KeyState.KeyShiftState |= ((KbFlag2 & KB_LEFT_CTRL_PRESSED) == KB_LEFT_CTRL_PRESSED) ? EFI_LEFT_CONTROL_PRESSED : EFI_RIGHT_CONTROL_PRESSED;
}
}
}
//
// Clear left alt and left ctrl BDA flag
//
KbFlag1 &= ~0x0C;
//
//
if (KeyData.Key.UnicodeChar == CHAR_NULL || KeyData.Key.UnicodeChar == CHAR_SCANCODE || KeyData.Key.UnicodeChar == CHAR_ESC) {
} else {
}
//
// CSM16 has converted the Ctrl+[a-z] to [1-26], converted it back.
//
if ((KeyData.KeyState.KeyShiftState & (EFI_LEFT_CONTROL_PRESSED | EFI_RIGHT_CONTROL_PRESSED)) != 0) {
) {
} else {
}
}
}
DEBUG ((
"[KBD]Convert to EFI Scan Code, EFI_INPUT_KEY.ScanCode - %x, EFI_INPUT_KEY.UnicodeChar - %x\n",
));
//
// Need not return associated shift state if a class of printable characters that
// are normally adjusted by shift modifiers.
// e.g. Shift Key + 'f' key = 'F'; Shift Key + 'F' key = 'f'.
//
) {
DEBUG ((EFI_D_INFO, "[KBD]Shift key with a~z are pressed, remove shift state in EFI_KEY_STATE.\n"));
}
//
// Invoke notification functions if exist
//
for (Link = BiosKeyboardPrivate->NotifyList.ForwardLink; Link != &BiosKeyboardPrivate->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR (
Link,
);
}
}
//
// Leave critical section and return
//
return ;
}
/**
Free keyboard notify list.
@param ListHead The list head
@retval EFI_SUCCESS Free the notify list successfully
@retval EFI_INVALID_PARAMETER ListHead is invalid.
**/
)
{
return EFI_INVALID_PARAMETER;
}
while (!IsListEmpty (ListHead)) {
NotifyNode = CR (
);
}
return EFI_SUCCESS;
}
/**
Check if key is registered.
@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 FLASE Match failed.
**/
)
{
return FALSE;
}
//
// Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
//
return FALSE;
}
return FALSE;
}
return TRUE;
}
/**
Waiting on the keyboard event, if there's any key pressed by the user, signal the event
@param Event The event that be siganlled when any key has been stroked.
@param Context Pointer of the protocol EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL.
**/
)
{
}
/**
Reset the input device and optionaly 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.
**/
)
{
);
return EFI_DEVICE_ERROR;
}
return EFI_SUCCESS;
}
/**
Reads the next keystroke from the input device. The WaitForKey Event can
be used to test for existance 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 availiable.
@retval EFI_DEVICE_ERROR The keystroke information was not returned due to
hardware errors.
@retval EFI_INVALID_PARAMETER KeyData is NULL.
**/
)
{
return EFI_INVALID_PARAMETER;
}
}
/**
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.
**/
)
{
if (KeyToggleState == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Thunk keyboard driver doesn't support partial keystroke.
//
) {
return EFI_UNSUPPORTED;
}
//
// See if the Legacy BIOS Protocol is available
//
NULL,
(VOID **) &LegacyBios
);
//
// Enter critical section
//
Command = 0;
Command |= 4;
}
Command |= 2;
}
Command |= 1;
}
return EFI_DEVICE_ERROR;
}
return EFI_DEVICE_ERROR;
}
return EFI_DEVICE_ERROR;
}
//
// Call Legacy BIOS Protocol to set whatever is necessary
//
//
// Leave critical section and return
//
return Status;
}
/**
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 data for the key that was pressed.
@param KeyNotificationFunction Points to the function to be called when the key
sequence is typed specified by KeyData.
@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 necesssary data structures.
@retval EFI_INVALID_PARAMETER KeyData or NotifyHandle is NULL.
**/
)
{
return EFI_INVALID_PARAMETER;
}
//
// Enter critical section
//
//
// Return EFI_SUCCESS if the (KeyData, NotificationFunction) is already registered.
//
for (Link = BiosKeyboardPrivate->NotifyList.ForwardLink; Link != &BiosKeyboardPrivate->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR (
Link,
);
goto Exit;
}
}
}
//
// Allocate resource to save the notification function
//
NewNotify = (BIOS_KEYBOARD_CONSOLE_IN_EX_NOTIFY *) AllocateZeroPool (sizeof (BIOS_KEYBOARD_CONSOLE_IN_EX_NOTIFY));
goto Exit;
}
Exit:
//
// Leave critical section and return
//
return Status;
}
/**
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.
**/
)
{
//
// Check incoming notification handle
//
if (NotificationHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
if (((BIOS_KEYBOARD_CONSOLE_IN_EX_NOTIFY *) NotificationHandle)->Signature != BIOS_KEYBOARD_CONSOLE_IN_EX_NOTIFY_SIGNATURE) {
return EFI_INVALID_PARAMETER;
}
//
// Enter critical section
//
for (Link = BiosKeyboardPrivate->NotifyList.ForwardLink; Link != &BiosKeyboardPrivate->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR (
Link,
);
//
// Remove the notification function from NotifyList and free resources
//
goto Exit;
}
}
//
// Can not find the specified Notification Handle
//
Exit:
//
// Leave critical section and return
//
return Status;
}
/**
The user Entry Point for module BiosKeyboard. The user code starts with this function.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
)
{
//
// Install driver model protocol(s).
//
);
return Status;
}