windows-xp/Source/XPSP1/NT/base/boot/detect/ia64/keybdc.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)