749 lines
18 KiB
C
749 lines
18 KiB
C
/*++
|
|
|
|
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)
|