able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/boot/detect/ia64/keybdc.c

749 lines
18 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
abiosc.c
Abstract:
This module implements keybaord detection C routines.
Author:
Shie-Lin Tzong (shielint) 18-Dec-1991
Environment:
Real Mode.
Revision History:
--*/
#include "hwdetect.h"
#include "string.h"
#if !defined(_GAMBIT_)
extern
UCHAR
GetKeyboardFlags (
VOID
);
extern
USHORT
HwGetKey (
VOID
);
extern BOOLEAN NoBiosKbdCheck;
#endif // _GAMBIT_
#if defined(NEC_98)
ULONG
GetKeyboard2ndIDNEC98(
VOID
);
//
// Definitions for the keyboard type returned from
// the detect keyboard function.
//
#define PC98_106KEY 10
#define PC98_NmodeKEY 11
#define PC98_HmodeKEY 12
#define PC98_LaptopKEY 13
#define PC98_N106KEY 14
#define N5200E_KEY 15
#define PC98_KEYBOARD_ID_FIRST_BYTE 0xA0
#define PC98_KEYBOARD_ID_2ND_BYTE_STD 0x80
#define PC98_KEYBOARD_ID_2ND_BYTE_N106 0x82
#define PC98_KEYBOARD_ID_2ND_BYTE_Win95 0x83
#define READ_KEYBOARD_2ND_ID 0x96
#define PC98_8251_BUFFER_EMPTY 0x01
#define PC98_8251_DATA_READY 0x02
#define ACKNOWLEDGE 0xFA
#define RESEND 0xFC
#define STATUS_SUCCESS 0x00000000L // from ntstatus.h
#define STATUS_IO_TIMEOUT 0xC00000B5L // from ntstatus.h
#define POLLING_ITERATION 12000
#define RESEND_ITERATION 3
#define KBD_COMMAND_STATUS_PORT 0x43
#define KBD_DATA_PORT 0x41
#define PIC1_PORT1 0x02
#endif // PC98
//
// SavedKey is used to save the key left in the keyboard type-ahead buffer
// before we start our keyboard/mouse tests. The key will be push back
// to the type-ahead buffer once the mouse detection is done.
//
USHORT SavedKey = 0;
//
// String table to map keyboard id to an ascii string.
//
PUCHAR KeyboardIdentifier[] = {
"UNKNOWN_KEYBOARD",
"OLI_83KEY",
"OLI_102KEY",
"OLI_86KEY",
"OLI_A101_102KEY",
"XT_83KEY",
"ATT_302",
"PCAT_ENHANCED",
"PCAT_86KEY",
"PCXT_84KEY"
#if defined(NEC_98)
,
"PC98_106KEY",
"PC98_NmodeKEY",
"PC98_HmodeKEY",
"PC98_LaptopKEY",
"PC98_N106KEY",
"N5200/E_KEY"
#endif // PC98
};
UCHAR KeyboardType[] = {
-1,
1,
2,
3,
4,
1,
1,
4,
3,
1
#if defined(NEC_98)
,
7, //Japanese Keyboard Type
7, //Japanese Keyboard Type
7, //Japanese Keyboard Type
7, //Japanese Keyboard Type
7, //Japanese Keyboard Type
7 //Japanese Keyboard Type
#endif // PC98
};
UCHAR KeyboardSubtype[] = {
-1,
0,
1,
10,
4,
42,
4,
0,
0,
0
#if defined(NEC_98)
,
1, //10 PC-9800 Serise S/W Lock Keyboard
2, //11 PC-9801 VX/UX,PC-98XL/XL2 H/W Lock Keyboard
3, //12 PC-98XL/XL2 H/W Lock Keyboard
4, //13 PC-9800 Serise Laptop Keyboard
5, //14 PC-9801-116 Keyboard
6 //15 N5200/E Serise Keyboard
#endif // PC98
};
USHORT
GetKeyboardId(
VOID
)
/*++
Routine Description:
This routine determines the Id of the keyboard. It calls GetKeyboardIdBytes
to complete the task.
Arguments:
None.
Return Value:
Keyboard ID.
--*/
{
#if defined(_GAMBIT_)
return (7); // PCAT_ENHANCED
#else
#if defined(NEC_98)
char KeybID_Bytes[5];
int Num_ID_Bytes;
ULONG NEC2ndKeyID;
int keytype = UNKNOWN_KEYBOARD;
Num_ID_Bytes = GetKeyboardIdBytes(KeybID_Bytes, 0x05);
if (Num_ID_Bytes > 0) {
switch(KeybID_Bytes[0] & 0x00ff) {
case 0x80:
keytype = PC98_NmodeKEY;
break;
case 0x88:
keytype = PC98_HmodeKEY;
break;
case 0x40:
NEC2ndKeyID = GetKeyboard2ndIDNEC98();
if (NEC2ndKeyID == PC98_N106KEY) {
keytype = PC98_N106KEY;
}else{
keytype = PC98_106KEY;
}
break;
case 0x08:
case 0x48:
keytype = PC98_LaptopKEY;
break;
default:
keytype = UNKNOWN_KEYBOARD;
break;
}
} else {
keytype = PCAT_ENHANCED;
}
return(keytype);
#else // PC98
char KeybID_Bytes[5];
int Num_ID_Bytes;
int keytype = UNKNOWN_KEYBOARD;
SavedKey = HwGetKey();
Num_ID_Bytes = GetKeyboardIdBytes(KeybID_Bytes, 0x05);
if (Num_ID_Bytes > 0) {
switch(KeybID_Bytes[0] & 0x00ff) {
case 0x02:
keytype = OLI_83KEY;
break;
case 0x01:
keytype = OLI_102KEY;
break;
case 0x10:
keytype = OLI_86KEY;
break;
case 0x40:
keytype = OLI_A101_102KEY;
break;
case 0x42:
keytype = XT_83KEY;
break;
case 0x9c:
keytype = PCXT_84KEY;
break;
case 0x04:
keytype = ATT_302;
break;
case 0xfe:
Num_ID_Bytes = GetKeyboardIdBytes(KeybID_Bytes, 0xf2);
if (Num_ID_Bytes > 0) {
if ((KeybID_Bytes[0] & 0x00ff) == 0xfa) {
keytype = PCAT_86KEY;
} else if ((KeybID_Bytes[0] & 0x00ff) == 0xfe) {
keytype = PCAT_86KEY;
} else if (Num_ID_Bytes >= 3 &&
((KeybID_Bytes[1] & 0x00ff) == 0xAB) &&
((KeybID_Bytes[2] & 0x00ff) == 0x41)) {
keytype = PCAT_ENHANCED;
} else {
keytype = UNKNOWN_KEYBOARD;
}
} else {
keytype = UNKNOWN_KEYBOARD;
}
break;
default:
keytype = UNKNOWN_KEYBOARD;
break;
}
} else {
keytype = PCXT_84KEY;
}
if (!NoBiosKbdCheck) {
//
// Sometimes enhanced keyboards get detected as 84/86 key keyboards
// So we will look into the ROM DATA area (40:96) and see if the
// Enhanced Keyboard bit is set. If it is we will assume that the
// detection failed to detect the presence of an enhanced keyb.
//
if ((keytype == PCXT_84KEY) ||
(keytype == PCAT_86KEY) ||
(keytype == UNKNOWN_KEYBOARD)) {
if (IsEnhancedKeyboard()) {
keytype = PCAT_ENHANCED;
}
}
}
return(keytype);
#endif // PC98
#endif // _GAMBIT_
}
FPFWCONFIGURATION_COMPONENT_DATA
SetKeyboardConfigurationData (
USHORT KeyboardId
)
/*++
Routine Description:
This routine maps Keyboard Id information to an ASCII string and
stores the string in configuration data heap.
Arguments:
KeyboardId - Supplies a USHORT which describes the keyboard id information.
Buffer - Supplies a pointer to a buffer where to put the ascii.
Returns:
None.
--*/
{
FPFWCONFIGURATION_COMPONENT_DATA Controller, CurrentEntry;
FPFWCONFIGURATION_COMPONENT Component;
HWCONTROLLER_DATA ControlData;
FPHWRESOURCE_DESCRIPTOR_LIST DescriptorList;
CM_KEYBOARD_DEVICE_DATA far *KeyboardData;
USHORT z, Length;
//
// Set up Keyboard COntroller component
//
ControlData.NumberPortEntries = 0;
ControlData.NumberIrqEntries = 0;
ControlData.NumberMemoryEntries = 0;
ControlData.NumberDmaEntries = 0;
z = 0;
Controller = (FPFWCONFIGURATION_COMPONENT_DATA)HwAllocateHeap (
sizeof(FWCONFIGURATION_COMPONENT_DATA), TRUE);
Component = &Controller->ComponentEntry;
Component->Class = ControllerClass;
Component->Type = KeyboardController;
Component->Flags.ConsoleIn = 1;
Component->Flags.Input = 1;
Component->Version = 0;
Component->Key = 0;
Component->AffinityMask = 0xffffffff;
//
// Set up Port information
//
#if !defined(_GAMBIT_)
ControlData.NumberPortEntries = 2;
ControlData.DescriptorList[z].Type = RESOURCE_PORT;
ControlData.DescriptorList[z].ShareDisposition =
CmResourceShareDeviceExclusive;
ControlData.DescriptorList[z].Flags = CM_RESOURCE_PORT_IO;
#if defined(NEC_98)
ControlData.DescriptorList[z].u.Port.Start.LowPart = 0x41;
#else // PC98
ControlData.DescriptorList[z].u.Port.Start.LowPart = 0x60;
#endif // PC98
ControlData.DescriptorList[z].u.Port.Start.HighPart = 0;
ControlData.DescriptorList[z].u.Port.Length = 1;
z++;
ControlData.DescriptorList[z].Type = RESOURCE_PORT;
ControlData.DescriptorList[z].ShareDisposition =
CmResourceShareDeviceExclusive;
ControlData.DescriptorList[z].Flags = CM_RESOURCE_PORT_IO;
#if defined(NEC_98)
ControlData.DescriptorList[z].u.Port.Start.LowPart = 0x43;
#else // PC98
ControlData.DescriptorList[z].u.Port.Start.LowPart = 0x64;
#endif // PC98
ControlData.DescriptorList[z].u.Port.Start.HighPart = 0;
ControlData.DescriptorList[z].u.Port.Length = 1;
z++;
//
// Set up Irq information
//
ControlData.NumberIrqEntries = 1;
ControlData.DescriptorList[z].Type = RESOURCE_INTERRUPT;
ControlData.DescriptorList[z].ShareDisposition =
CmResourceShareUndetermined;
ControlData.DescriptorList[z].u.Interrupt.Affinity = ALL_PROCESSORS;
ControlData.DescriptorList[z].u.Interrupt.Level = 1;
ControlData.DescriptorList[z].u.Interrupt.Vector = 1;
if (HwBusType == MACHINE_TYPE_MCA) {
ControlData.DescriptorList[z].Flags = LEVEL_SENSITIVE;
} else {
//
// For EISA the LevelTriggered is temporarily set to FALSE.
//
ControlData.DescriptorList[z].Flags = EDGE_TRIGGERED;
}
#endif // _GAMBIT_
Controller->ConfigurationData =
HwSetUpResourceDescriptor(Component,
NULL,
&ControlData,
0,
NULL
);
//
// Set up Keyboard peripheral component
//
CurrentEntry = (FPFWCONFIGURATION_COMPONENT_DATA)HwAllocateHeap (
sizeof(FWCONFIGURATION_COMPONENT_DATA), TRUE);
Component = &CurrentEntry->ComponentEntry;
Component->Class = PeripheralClass;
Component->Type = KeyboardPeripheral;
Component->Flags.ConsoleIn = 1;
Component->Flags.Input = 1;
Component->Version = 0;
Component->Key = 0;
Component->AffinityMask = 0xffffffff;
Component->ConfigurationDataLength = 0;
CurrentEntry->ConfigurationData = (FPVOID)NULL;
Length = strlen(KeyboardIdentifier[KeyboardId]) + 1;
Component->IdentifierLength = Length;
Component->Identifier = HwAllocateHeap(Length, FALSE);
_fstrcpy(Component->Identifier, KeyboardIdentifier[KeyboardId]);
if (KeyboardId != UNKNOWN_KEYBOARD) {
Length = sizeof(HWRESOURCE_DESCRIPTOR_LIST) +
sizeof(CM_KEYBOARD_DEVICE_DATA);
DescriptorList = (FPHWRESOURCE_DESCRIPTOR_LIST)HwAllocateHeap(
Length,
TRUE);
CurrentEntry->ConfigurationData = DescriptorList;
Component->ConfigurationDataLength = Length;
DescriptorList->Count = 1;
DescriptorList->PartialDescriptors[0].Type = RESOURCE_DEVICE_DATA;
DescriptorList->PartialDescriptors[0].u.DeviceSpecificData.DataSize =
sizeof(CM_KEYBOARD_DEVICE_DATA);
KeyboardData = (CM_KEYBOARD_DEVICE_DATA far *)(DescriptorList + 1);
#if defined(_GAMBIT_)
KeyboardData->KeyboardFlags = 0;
#else
KeyboardData->KeyboardFlags = GetKeyboardFlags();
#endif
KeyboardData->Type = KeyboardType[KeyboardId];
KeyboardData->Subtype = KeyboardSubtype[KeyboardId];
}
Controller->Child = CurrentEntry;
Controller->Sibling = NULL;
CurrentEntry->Parent = Controller;
CurrentEntry->Sibling = NULL;
CurrentEntry->Child = NULL;
return(Controller);
}
#if defined(NEC_98)
ULONG
KbdGetBytePolled(
OUT PUCHAR Byte
)
/*++
--*/
{
ULONG i;
UCHAR response;
UCHAR desiredMask;
i = 0;
desiredMask = (UCHAR)PC98_8251_DATA_READY;
IoDelay(34); // 20 micro second
//
// Poll until we get back a controller status value that indicates
// the output buffer is full. If we want to read a byte from the mouse,
// further ensure that the auxiliary device output buffer full bit is
// set.
//
while ((i < POLLING_ITERATION ) &&
((UCHAR)((response = READ_PORT_UCHAR((PUCHAR)KBD_COMMAND_STATUS_PORT))
& desiredMask) != desiredMask)) {
IoDelay(83); // 50 micro second
i += 1;
}
if (i >= (ULONG)POLLING_ITERATION) {
return(STATUS_IO_TIMEOUT);
}
IoDelay(34); // 20 micro second
//
// Grab the byte from the hardware, and return success.
//
*Byte = READ_PORT_UCHAR((PUCHAR)KBD_DATA_PORT);
return(STATUS_SUCCESS);
}
ULONG
NEC98_KeyboardCommandByte(
IN UCHAR KeyboardCommand
)
/*++
Routine Description:
This routine is command out routine for NEC_98 Keyboard controller
Arguments:
KeyboardCommand - A command sent to keyboard.
Return Value:
None.
--*/
{
ULONG i,j;
ULONG Status;
WRITE_PORT_UCHAR( (PUCHAR)KBD_COMMAND_STATUS_PORT, (UCHAR)0x37 );
IoDelay(17); // 10 micro second
WRITE_PORT_UCHAR( (PUCHAR)KBD_DATA_PORT, (UCHAR)KeyboardCommand );
IoDelay(75); // 45 micro second
Status = STATUS_SUCCESS;
for (j = 0; j < RESEND_ITERATION; j++) {
//
// Make sure the Input Buffer Full controller status bit is clear.
// Time out if necessary.
//
i = 0;
while ((i++ < POLLING_ITERATION) &&
(READ_PORT_UCHAR((PUCHAR)KBD_COMMAND_STATUS_PORT)
& PC98_8251_BUFFER_EMPTY) != PC98_8251_BUFFER_EMPTY) {
IoDelay(83); // 50 micro second
}
if (i >= POLLING_ITERATION) {
Status = STATUS_IO_TIMEOUT;
break;
}
}
WRITE_PORT_UCHAR( (PUCHAR)KBD_COMMAND_STATUS_PORT, (UCHAR)0x16 );
IoDelay(167); // 100 micro second
return(Status);
}
ULONG
KbdPutBytePolled(
IN UCHAR Byte
)
/*++
Routine Description:
This routine sends a command or data byte to the controller or keyboard
or mouse, in polling mode. It waits for acknowledgment and resends
the command/data if necessary.
Arguments:
Byte - The byte to send to the hardware.
Return Value:
STATUS_IO_TIMEOUT - The hardware was not ready for input or did not
respond.
STATUS_SUCCESS - The byte was successfully sent to the hardware.
--*/
{
ULONG i,j;
UCHAR response;
ULONG status;
BOOLEAN keepTrying;
UCHAR byte, d;
for (j=0;j < RESEND_ITERATION;j++) {
//
// Drain the i8042 output buffer to get rid of stale data.
//
while (d = READ_PORT_UCHAR((PUCHAR)KBD_COMMAND_STATUS_PORT) &
PC98_8251_DATA_READY) {
//
// Eat the output buffer byte.
//
byte = READ_PORT_UCHAR((PUCHAR)KBD_DATA_PORT);
}
//
// Send the byte to the appropriate (command/data) hardware register.
//
status = NEC98_KeyboardCommandByte( Byte );
if (status != STATUS_SUCCESS){
return(status);
}
//
// Wait for an ACK back from the controller. If we get an ACK,
// the operation was successful. If we get a RESEND, break out to
// the for loop and try the operation again. Ignore anything other
// than ACK or RESEND.
//
keepTrying = FALSE;
while ((status = KbdGetBytePolled(&response)) == STATUS_SUCCESS) {
if (response == ACKNOWLEDGE) {
break;
} else if (response == RESEND) {
keepTrying = TRUE;
break;
}
//
// Ignore any other response, and keep trying.
//
}
if (!keepTrying)
break;
}
//
// Check to see if the number of allowable retries was exceeded.
//
if (j >= RESEND_ITERATION) {
status = STATUS_IO_TIMEOUT;
}
return(status);
}
ULONG
GetKeyboard2ndIDNEC98(
VOID
)
/*++
Routine Description:
This routine detects keyboard hardware for NEC_98.
Arguments:
Return Value:
keyboard type(see i8042prt.h)
--*/
{
UCHAR IDStatus = 0;
ULONG KeyboardType;
UCHAR temp;
KeyboardType = PC98_106KEY; // default keyboard type.
//
// mask keyboard interrupt.
//
_asm{ cli }
temp = READ_PORT_UCHAR((PUCHAR)PIC1_PORT1);
WRITE_PORT_UCHAR((PUCHAR)PIC1_PORT1,(temp | 0x02));
_asm{ sti }
if (KbdPutBytePolled( (UCHAR)READ_KEYBOARD_2ND_ID) == STATUS_SUCCESS) {
while( KbdGetBytePolled( &IDStatus ) != STATUS_SUCCESS);
switch(IDStatus){
case PC98_KEYBOARD_ID_FIRST_BYTE:
while ( KbdGetBytePolled( &IDStatus ) != STATUS_SUCCESS);
switch(IDStatus){
case PC98_KEYBOARD_ID_2ND_BYTE_N106:
KeyboardType = PC98_N106KEY;
break;
case PC98_KEYBOARD_ID_2ND_BYTE_Win95:
default:
break;
}
break;
default:
break;
}
}
//
// unmask keyboard interrupt.
//
WRITE_PORT_UCHAR((PUCHAR)PIC1_PORT1,temp);
return KeyboardType;
}
#endif // defined(NEC_98)
Reference in a new issue Copy permalink