windows-server-2003/drivers/input/pnpi8042/i8042prt.h

/*

Copyright (c) 1990-1998 Microsoft Corporation, All Rights Reserved

Module Name:

    i8042prt.h

Abstract:

    These are the structures and defines that are used in the
    Intel i8042 port driver.

Revision History:

--*/

#ifndef _I8042PRT_
#define _I8042PRT_

#include "ntddk.h"
#include <ntddkbd.h>
#include <ntddmou.h>
#include <ntdd8042.h>
#include "kbdmou.h"
#include "wmilib.h"
#include "i8042cfg.h"
#include "i8042str.h"

#define I8042_POOL_TAG (ULONG) '2408'
#undef ExAllocatePool
#define ExAllocatePool(type, size) \
            ExAllocatePoolWithTag (type, size, I8042_POOL_TAG)

#if DBG
#ifdef PAGED_CODE
#undef PAGED_CODE
#endif

#define PAGED_CODE() \
    if (KeGetCurrentIrql() > APC_LEVEL) { \
    KdPrint(( "8042: Pageable code called at IRQL %d\n", KeGetCurrentIrql() )); \
        DbgBreakPoint(); \
        }
#endif

#define MOUSE_RECORD_ISR     DBG
#define I8042_VERBOSE        DBG 
#define KEYBOARD_RECORD_INIT DBG

#define DELAY_SYSBUTTON_COMPLETION 1

//
// Define the timer values.
//


#define I8042_ASYNC_NO_TIMEOUT -1
#define I8042_ASYNC_TIMEOUT     3

//
// Define the default number of entries in the input data queue.
//

#define DATA_QUEUE_SIZE    100

//
// Define the default stall value.
//

#define I8042_STALL_DEFAULT      50

//
// Custom resource type used when pruning the fdo's resource lists
// 
#define I8X_REMOVE_RESOURCE 0xef

//
// Length (including NULL) of the PnP string identifying the mouse
//
// New style mice will respond with MSHxxxx
// Old style mice will respond with pnpxxxx
// 
#define MOUSE_PNPID_LENGTH 8

//
// Number of times to poll the hardware (determined empiracally)
//
#define I8X_POLL_ITERATIONS_MAX (11200)

//
// Define the default "sync time" used to determine when the start
// of a new mouse data packet is expected.  The value is in units
// of 100 nanoseconds.
//

#define MOUSE_SYNCH_PACKET_100NS 10000000UL // 1 second, in 100 ns units

//
// Time, in ms, for the mouse to respond to the query ID sequence
//
#define WHEEL_DETECTION_TIMEOUT 1500

//
// Default for how to initialize the mouse
//
#define I8X_INIT_POLLED_DEFAULT 0


#define IOCTL_INTERNAL_MOUSE_RESET  \
            CTL_CODE(FILE_DEVICE_MOUSE, 0x0FFF, METHOD_NEITHER, FILE_ANY_ACCESS)

#define FAILED_RESET_STOP           (0)
#define FAILED_RESET_PROCEED        (1)
#define FAILED_RESET_PROCEED_ALWAYS (2)

#define FAILED_RESET_DEFAULT        FAILED_RESET_PROCEED
#define STR_FAILED_RESET            L"KeyboardFailedReset"

//
// Define booleans.
//
#define WAIT_FOR_ACKNOWLEDGE    TRUE
#define NO_WAIT_FOR_ACKNOWLEDGE FALSE
#define AND_OPERATION           TRUE
#define OR_OPERATION            FALSE
#define ENABLE_OPERATION        TRUE
#define DISABLE_OPERATION       FALSE

//
// Default keyboard scan code mode.
//

#define KEYBOARD_SCAN_CODE_SET 0x01

//
// Default number of function keys, number of LED indicators, and total
// number of keys located on the known types of keyboard.
//

#define NUM_KNOWN_KEYBOARD_TYPES                   8
#define KEYBOARD_TYPE_DEFAULT                      4
#define KEYBOARD_INDICATORS_DEFAULT                0

typedef struct _KEYBOARD_TYPE_INFORMATION {
    USHORT NumberOfFunctionKeys;
    USHORT NumberOfIndicators;
    USHORT NumberOfKeysTotal;
} KEYBOARD_TYPE_INFORMATION, *PKEYBOARD_TYPE_INFORMATION;

static const
KEYBOARD_TYPE_INFORMATION KeyboardTypeInformation[NUM_KNOWN_KEYBOARD_TYPES] = {
    {10, 3, 84},     // PC/XT 83- 84-key keyboard (and compatibles)
    {12, 3, 102},    // Olivetti M24 102-key keyboard (and compatibles)
    {10, 3, 84},     // All AT type keyboards (84-86 keys)
    {12, 3, 101},    // Enhanced 101- or 102-key keyboards (and compatibles)
    {12, 3, 101},    // 5:
    {12, 3, 101},    // 6:
    { 0, 0, 0},      // 7: Japanese Keyboard
    { 0, 0, 0}       // 8: Korean keyboard
};

typedef struct _KEYBOARD_OEM_INFORMATION {
    KEYBOARD_ID               KeyboardId;
    KEYBOARD_TYPE_INFORMATION KeyboardTypeInformation;
} KEYBOARD_OEM_INFORMATION, *PKEYBOARD_OEM_INFORMATION;

//
// Keyboard hardware OEM id. by MSKK
//
#define MSFT    0x0 // Microsoft
#define AX      0x1 // AX consortium
#define TOSHIBA 0x2 // TOSHIBA
#define EPSON   0x4 // EPSON
#define FJ      0x5 // Fujitsu
#define IBMJ    0x7 // IBM Japan
#define DECJ    0x8 // DEC Japan
#define PANA    0xA // Panasonic
#define NEC     0xD // NEC

#define FE_SUBTYPE(SubType,OemId) ((SubType)|((OemId<<4)))

#define IBM02_KEYBOARD(Id)     (((Id).Type == 0x7) && ((Id).Subtype == FE_SUBTYPE(3,MSFT)))
#define AX_KEYBOARD(Id)        (((Id).Type == 0x7) && ((Id).Subtype == FE_SUBTYPE(1,MSFT)))
#define OYAYUBI_KEYBOARD(Id)   (((Id).Type == 0x7) && ((Id).Subtype == FE_SUBTYPE(2,FJ)))
#define DEC_KANJI_KEYBOARD(Id) (((Id).Type == 0x7) && (((Id).Subtype == FE_SUBTYPE(1,DECJ)) || \
                                                       ((Id).Subtype == FE_SUBTYPE(2,DECJ))))

static const
KEYBOARD_OEM_INFORMATION KeyboardFarEastOemInformation[] = {
    {{7, FE_SUBTYPE(1,MSFT)}, {12,3,101}}, // PC/AT 101 Enhanced Japanese Keyboard
    {{7, FE_SUBTYPE(1,MSFT)}, {12,4,105}}, // AX standard Japanese keyboard
    {{7, FE_SUBTYPE(2,MSFT)}, {12,3,106}}, // PC/AT 106 Japanese Keyboard
    {{7, FE_SUBTYPE(3,MSFT)}, {12,3,106}}, // IBM 5576-002 keyboard
    {{7, FE_SUBTYPE(1,MSFT)}, {12,4,105}}, // AX consortium compatible keyboard
    {{7, FE_SUBTYPE(2,FJ  )}, {12,3,108}}, // Fujitsu OYAYUBI shift keyboard
    {{7, FE_SUBTYPE(1,DECJ)}, {17,3,111}}, // DEC LK411 (Ansi layout) keyboard
    {{7, FE_SUBTYPE(2,DECJ)}, {17,3,112}}, // DEC LK411 (JIS layout) keyboard
    {{8, FE_SUBTYPE(3,MSFT)}, {12,3,101}}, // PC/AT 101 Enhanced Korean Keyboard (A)
    {{8, FE_SUBTYPE(4,MSFT)}, {12,3,101}}, // PC/AT 101 Enhanced Korean Keyboard (B)
    {{8, FE_SUBTYPE(5,MSFT)}, {12,3,101}}, // PC/AT 101 Enhanced Korean Keyboard (C)
    {{8, FE_SUBTYPE(6,MSFT)}, {12,3,103}}, // PC/AT 103 Enhanced Korean Keyboard
    {{0, FE_SUBTYPE(0,MSFT)}, { 0,0,  0}}  // Array terminator
};


//
// Minimum, maximum, and default values for keyboard typematic rate and delay.
//

#define KEYBOARD_TYPEMATIC_RATE_MINIMUM     2
#define KEYBOARD_TYPEMATIC_RATE_MAXIMUM    30
#define KEYBOARD_TYPEMATIC_RATE_DEFAULT    30
#define KEYBOARD_TYPEMATIC_DELAY_MINIMUM  250
#define KEYBOARD_TYPEMATIC_DELAY_MAXIMUM 1000
#define KEYBOARD_TYPEMATIC_DELAY_DEFAULT  250


//
// Define the 8042 mouse status bits.
//
#define LEFT_BUTTON        0x01
#define RIGHT_BUTTON       0x02
#define MIDDLE_BUTTON      0x04
#define BUTTON_4           0x10
#define BUTTON_5           0x20

#define X_DATA_SIGN        0x10
#define Y_DATA_SIGN        0x20
#define X_OVERFLOW         0x40
#define Y_OVERFLOW         0x80

#define MOUSE_SIGN_OVERFLOW_MASK (X_DATA_SIGN | Y_DATA_SIGN | X_OVERFLOW | Y_OVERFLOW)

//
// Define the maximum positive and negative values for mouse motion.
//

#define MOUSE_MAXIMUM_POSITIVE_DELTA 0x000000FF
#define MOUSE_MAXIMUM_NEGATIVE_DELTA 0xFFFFFF00

//
// Default number of buttons and sample rate for the i8042 mouse.
//

#define MOUSE_NUMBER_OF_BUTTONS     2
#define MOUSE_SAMPLE_RATE           60

//
// Define the mouse resolution specifier.  Note that (2**MOUSE_RESOLUTION)
// specifies counts-per-millimeter.  Counts-per-centimeter is
// (counts-per-millimeter * 10).
//

#define MOUSE_RESOLUTION            3

//
// Define the maximum number of resets we allow without success before we
// give up and consider the mouse dead
//
#define MOUSE_RESET_TIMEOUT         (1500 * 1000 * 10)

#define MOUSE_RESETS_MAX             3
#define MOUSE_RESENDS_MAX            4
#define MOUSE_RESET_RESENDS_MAX      10

//
// Defines and macros for Globals.ControllerData->HardwarePresent.
//
#define KEYBOARD_HARDWARE_PRESENT               0x001
#define MOUSE_HARDWARE_PRESENT                  0x002
#define BALLPOINT_HARDWARE_PRESENT              0x004
#define WHEELMOUSE_HARDWARE_PRESENT             0x008
#define DUP_KEYBOARD_HARDWARE_PRESENT           0x010
#define DUP_MOUSE_HARDWARE_PRESENT              0x020
#define KEYBOARD_HARDWARE_INITIALIZED           0x100
#define MOUSE_HARDWARE_INITIALIZED              0x200
#define FIVE_BUTTON_HARDWARE_PRESENT           0x1000
#define PHANTOM_KEYBOARD_HARDWARE_REPORTED     0x4000
#define PHANTOM_MOUSE_HARDWARE_REPORTED        0x8000

#define TEST_HARDWARE_PRESENT(bits)         \
 ((Globals.ControllerData->HardwarePresent & (bits)) == (bits))
#define CLEAR_HW_FLAGS(bits) (Globals.ControllerData->HardwarePresent &= ~(bits))
#define SET_HW_FLAGS(bits) (Globals.ControllerData->HardwarePresent |= (bits))
#define KEYBOARD_PRESENT()      TEST_HARDWARE_PRESENT(KEYBOARD_HARDWARE_PRESENT)
#define MOUSE_PRESENT()         TEST_HARDWARE_PRESENT(MOUSE_HARDWARE_PRESENT) 
#define WHEEL_PRESENT()         TEST_HARDWARE_PRESENT(WHEELMOUSE_HARDWARE_PRESENT)
#define FIVE_PRESENT()         TEST_HARDWARE_PRESENT(FIVE_BUTTON_HARDWARE_PRESENT)
#define KEYBOARD_INITIALIZED() \
                            TEST_HARDWARE_PRESENT(KEYBOARD_HARDWARE_INITIALIZED)
#define MOUSE_INITIALIZED()    \
                            TEST_HARDWARE_PRESENT(MOUSE_HARDWARE_INITIALIZED) 
#define KEYBOARD_STARTED() (Globals.KeyboardExtension          ?    \
                            Globals.KeyboardExtension->Started :    \
                            FALSE)                                  
#define MOUSE_STARTED() (Globals.MouseExtension          ?    \
                         Globals.MouseExtension->Started :    \
                         FALSE)                                  
#define CLEAR_MOUSE_PRESENT() CLEAR_HW_FLAGS(MOUSE_HARDWARE_INITIALIZED | MOUSE_HARDWARE_PRESENT | WHEELMOUSE_HARDWARE_PRESENT)
#define CLEAR_KEYBOARD_PRESENT() CLEAR_HW_FLAGS(KEYBOARD_HARDWARE_INITIALIZED | KEYBOARD_HARDWARE_PRESENT)

#define KBD_POWERED_UP_STARTED      0x00000001
#define KBD_POWERED_DOWN            0x00000002
#define MOU_POWERED_UP_STARTED      0x00000010
#define MOU_POWERED_DOWN            0x00000020
#define KBD_POWERED_UP_SUCCESS      0x00000100
#define KBD_POWERED_UP_FAILURE      0x00000200
#define MOU_POWERED_UP_SUCCESS      0x00001000
#define MOU_POWERED_UP_FAILURE      0x00002000

#define WORK_ITEM_QUEUED            0x10000000

#define MOU_POWER_FLAGS             (MOU_POWERED_DOWN       |   \
                                     MOU_POWERED_UP_STARTED |   \
                                     MOU_POWERED_UP_SUCCESS)

#define KBD_POWER_FLAGS             (KBD_POWERED_DOWN       |   \
                                     KBD_POWERED_UP_STARTED |   \
                                     KBD_POWERED_UP_SUCCESS)

#define SET_PWR_FLAGS(bits)     (Globals.PowerFlags |= (bits))
#define CMP_PWR_FLAGS(bits)     ((Globals.PowerFlags & (bits)) == (bits))
#define TEST_PWR_FLAGS(bits)    (Globals.PowerFlags & (bits))

#define KEYBOARD_POWERED_DOWN_SUCCESS() CMP_PWR_FLAGS(KBD_POWERED_DOWN)
#define MOUSE_POWERED_DOWN_SUCCESS()    CMP_PWR_FLAGS(MOU_POWERED_DOWN)

#define KEYBOARD_POWERED_UP_SUCCESSFULLY()  SET_PWR_FLAGS(KBD_POWERED_UP_SUCCESS)
#define MOUSE_POWERED_UP_SUCCESSFULLY()     SET_PWR_FLAGS(MOU_POWERED_UP_SUCCESS)

#define KEYBOARD_POWERED_UP_FAILURE()  SET_PWR_FLAGS(KBD_POWERED_UP_FAILURE)
#define MOUSE_POWERED_UP_FAILURE()     SET_PWR_FLAGS(MOU_POWERED_UP_FAILURE)

#define KEYBOARD_POWERED_UP_FAILED()  CMP_PWR_FLAGS(KBD_POWERED_UP_FAILURE)
#define MOUSE_POWERED_UP_FAILED()     CMP_PWR_FLAGS(MOU_POWERED_UP_FAILURE)

#define KEYBOARD_POWERED_UP_SUCCESS() CMP_PWR_FLAGS(KBD_POWERED_UP_SUCCESS)
#define MOUSE_POWERED_UP_SUCCESS()    CMP_PWR_FLAGS(MOU_POWERED_UP_SUCCESS)
#define A_POWERED_UP_SUCCEEDED() \
            TEST_PWR_FLAGS(KBD_POWERED_UP_SUCCESS | MOU_POWERED_UP_SUCCESS)
                    
#define IS_KEYBOARD(_devExt_) ((_devExt_)->IsKeyboard)
#define IS_MOUSE(_devExt_) ((_devExt_)->IsKeyboard == FALSE)

#define IS_LEVEL_TRIGGERED(_devExt_)   ((_devExt_)->InterruptDescriptor.Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE)
#define IS_EDGE_TRIGGERED(_devExt_)    ((_devExt_)->InterruptDescriptor.Flags == CM_RESOURCE_INTERRUPT_LATCHED)

#define DEVICE_START_SUCCESS(status)    (NT_SUCCESS((status)) || ((status) == STATUS_DEVICE_NOT_CONNECTED))

#define INIT_FIRST_TIME         0x00000001
#define INIT_KEYBOARD           0x00010000
#define INIT_MOUSE              0x00020000

#if _X86_
    #define WRAP_IO_FUNCTIONS 0
#else
    #define WRAP_IO_FUNCTIONS 1
#endif

typedef
UCHAR
(*PI8X_READ_UCHAR) (
    PUCHAR Address
    );

typedef
VOID
(*PI8X_WRITE_UCHAR) (
    PUCHAR Address,
    UCHAR Byte
    );

//
// Define macros for performing I/O on the 8042 command/status and data
// registers.
//
#define I8X_PUT_COMMAND_BYTE(Address, Byte)                                  \
    Globals.I8xWriteXxxUchar(Address, (UCHAR) Byte)
    
#define I8X_PUT_DATA_BYTE(Address, Byte)                                     \
    Globals.I8xWriteXxxUchar(Address, (UCHAR) Byte)
    
#define I8X_GET_STATUS_BYTE(Address)                                         \
    Globals.I8xReadXxxUchar(Address)
    
#define I8X_GET_DATA_BYTE(Address)                                           \
    Globals.I8xReadXxxUchar(Address)
    
#define I8X_WRITE_CMD_TO_MOUSE( )                                            \
    I8xPutByteAsynchronous(                                                  \
        (CCHAR) CommandPort,                                                 \
        (UCHAR) I8042_WRITE_TO_AUXILIARY_DEVICE                              \
        ) 

#define I8X_MOUSE_COMMAND( Byte )                                            \
    I8xPutByteAsynchronous(                                                  \
        (CCHAR) DataPort,                                                    \
        (UCHAR) Byte                                                         \
        )
        
//
// Define commands to the 8042 controller.
//
#define I8042_READ_CONTROLLER_COMMAND_BYTE      0x20
#define I8042_WRITE_CONTROLLER_COMMAND_BYTE     0x60
#define I8042_DISABLE_MOUSE_DEVICE              0xA7
#define I8042_ENABLE_MOUSE_DEVICE               0xA8
#define I8042_AUXILIARY_DEVICE_TEST             0xA9
#define I8042_KEYBOARD_DEVICE_TEST              0xAB
#define I8042_DISABLE_KEYBOARD_DEVICE           0xAD
#define I8042_ENABLE_KEYBOARD_DEVICE            0xAE
#define I8042_WRITE_TO_AUXILIARY_DEVICE         0xD4

//
// Define the 8042 Controller Command Byte.
//

#define CCB_ENABLE_KEYBOARD_INTERRUPT 0x01
#define CCB_ENABLE_MOUSE_INTERRUPT    0x02
#define CCB_DISABLE_KEYBOARD_DEVICE   0x10
#define CCB_DISABLE_MOUSE_DEVICE      0x20
#define CCB_KEYBOARD_TRANSLATE_MODE   0x40


//
// Define the 8042 Controller Status Register bits.
//

#define OUTPUT_BUFFER_FULL       0x01
#define INPUT_BUFFER_FULL        0x02
#define MOUSE_OUTPUT_BUFFER_FULL 0x20

//
// Define the 8042 responses.
//
#define ACKNOWLEDGE         0xFA
#define RESEND              0xFE
#define FAILURE             0xFC

//
// Define commands to the keyboard (through the 8042 data port).
//

#define SET_KEYBOARD_INDICATORS           0xED
#define SELECT_SCAN_CODE_SET              0xF0
#define READ_KEYBOARD_ID                  0xF2
#define SET_KEYBOARD_TYPEMATIC            0xF3
#define SET_ALL_TYPEMATIC_MAKE_BREAK      0xFA
#define KEYBOARD_RESET                    0xFF

//
// Define the keyboard responses.
//

#define KEYBOARD_COMPLETE_SUCCESS 0xAA
#define KEYBOARD_COMPLETE_FAILURE 0xFC
#define KEYBOARD_BREAK_CODE       0xF0
#define KEYBOARD_DEBUG_HOTKEY_ENH 0x37 // SysReq scan code for Enhanced Keyboard
#define KEYBOARD_DEBUG_HOTKEY_AT  0x54 // SysReq scan code for 84-key Keyboard

//
// Define keyboard power scan codes
//
#define KEYBOARD_POWER_CODE        0x5E
#define KEYBOARD_SLEEP_CODE        0x5F
#define KEYBOARD_WAKE_CODE         0x63

/*
Power event 
        Set1:   Make = E0, 5E   Break = E0, DE
        Set2:   Make = E0, 37   Break = E0, F0, 37
Sleep event 
        Set1:   Make = E0, 5F   Break = E0, DF
        Set2:   Make = E0, 3F   Break = E0, F0, 3F
Wake event 
        Set1:   Make = E0, 63   Break = E0, E3
        Set2:   Make = E0, 5E   Break = E0, F0, 5E
*/

//
// Define commands to the mouse (through the 8042 data port).
//

#define SET_MOUSE_RESOLUTION              0xE8
#define SET_MOUSE_SAMPLING_RATE           0xF3
#define MOUSE_RESET                       0xFF
#define ENABLE_MOUSE_TRANSMISSION         0xF4
#define SET_MOUSE_SCALING_1TO1            0xE6
#define READ_MOUSE_STATUS                 0xE9
#define GET_DEVICE_ID                     0xF2

//
// Define the mouse responses.
//

#define MOUSE_COMPLETE      0xAA
#define MOUSE_ID_BYTE       0x00
#define WHEELMOUSE_ID_BYTE  0x03
#define FIVEBUTTON_ID_BYTE  0x04

//
// Define the i8042 controller input/output ports.
//

typedef enum _I8042_IO_PORT_TYPE {
    DataPort = 0,
    CommandPort,
    MaximumPortCount

} I8042_IO_PORT_TYPE;

//
// Define the device types attached to the i8042 controller.
//

typedef enum _I8042_DEVICE_TYPE {
    ControllerDeviceType,
    KeyboardDeviceType,
    MouseDeviceType,
    UndefinedDeviceType
} I8042_DEVICE_TYPE;

//
// Intel i8042 configuration information.
//
#ifdef FE_SB
#define KBD_IDENTIFIER  0x10
#endif

typedef struct _I8042_CONFIGURATION_INFORMATION {

    //
    // Bus interface type.
    //
    INTERFACE_TYPE InterfaceType;

    //
    // Bus Number.
    //
    ULONG BusNumber;

    //
    // The port/register resources used by this device.
    //
    CM_PARTIAL_RESOURCE_DESCRIPTOR PortList[MaximumPortCount];
    ULONG PortListCount;

    //
    // The highest IRQL between the two potential interrupts
    //
    KIRQL InterruptSynchIrql;

    //
    // Number of retries allowed.
    //
    USHORT ResendIterations;

    //
    // Number of polling iterations allowed.
    //
    USHORT PollingIterations;

    //
    // Maximum number of polling iterations allowed.
    //
    USHORT PollingIterationsMaximum;

    //
    // Maximum number of times to check the Status register in
    // the ISR before deciding the interrupt is spurious.
    //
    USHORT PollStatusIterations;

    //
    // Microseconds to stall in KeStallExecutionProcessor calls.
    //
    USHORT StallMicroseconds;

    //
    // Tracking resolution on the mouse
    //
    // USHORT MouseResolution;

    //
    // Flag that indicates whether floating point context should be saved.
    //
    BOOLEAN FloatingSave;

    //
    // Flag indicating if the interrupts should be shared
    //
    BOOLEAN SharedInterrupts;

#ifdef FE_SB
    //
    // Detected Device Identifier
    //
    WCHAR OverrideKeyboardIdentifier[KBD_IDENTIFIER];
#endif

} I8042_CONFIGURATION_INFORMATION, *PI8042_CONFIGURATION_INFORMATION;

//
// Define the common portion of the keyboard/mouse device extension.
//
typedef struct COMMON_DATA {
    //
    // Pointer back to the this extension's device object.
    //
    PDEVICE_OBJECT      Self;
 
    PKINTERRUPT InterruptObject;

    //
    // The spin lock guarding the object's ISR
    //
    KSPIN_LOCK          InterruptSpinLock;         
 
    //
    // The top of the stack before this filter was added.  AKA the location
    // to which all IRPS should be directed.
    //
    PDEVICE_OBJECT      TopOfStack;
 
    //
    // "THE PDO"  (ejected by root)
    //
    PDEVICE_OBJECT      PDO;
 
    //
    // Remove tracking
    //
    IO_REMOVE_LOCK RemoveLock;

    //
    // The IRP sent to the device to power it to D0
    //
    PIRP OutstandingPowerIrp;

    //
    // Current power state that the device is in
    //
    DEVICE_POWER_STATE PowerState;

    //
    // Current power state that the system in in
    //
    SYSTEM_POWER_STATE SystemState;

    POWER_ACTION ShutdownType; 

    // 
    // Number of input data items currently in the InputData queue
    //
    ULONG InputCount;
      
    //
    // Reference count for number of keyboard enables.
    //
    LONG EnableCount;

    //
    // Timer used to retry the ISR DPC routine when the class
    // driver is unable to consume all the port driver's data.
    //
    KTIMER DataConsumptionTimer;
 
    //
    // DPC queue for completion of requests that fail by exceeding
    // the maximum number of retries.
    //
    KDPC RetriesExceededDpc;

    //
    // DPC queue for logging overrun and internal driver errors.
    //
    KDPC ErrorLogDpc;

    //
    // DPC queue for command timeouts.
    //
    KDPC TimeOutDpc;

    //
    // DPC queue for resetting the device 
    //
    KDPC ResetDpc;

    //
    // Request sequence number (used for error logging).
    //
    ULONG SequenceNumber;
  
    //
    // Class connection data.
    //
    CONNECT_DATA ConnectData;

    //
    // WMI Information
    //
    WMILIB_CONTEXT WmiLibInfo;

    //
    // Current output buffer being written to the device
    //
    OUTPUT_PACKET CurrentOutput;

    //
    // Translated resource descriptor for the interrupt
    //
    CM_PARTIAL_RESOURCE_DESCRIPTOR InterruptDescriptor;

    PNP_DEVICE_STATE PnpDeviceState;

    //
    // Current resend count.
    //
    SHORT ResendCount;

    //
    // Indicates whether it is okay to log overflow errors.
    //
    BOOLEAN OkayToLogOverflow;

    BOOLEAN Initialized;

    BOOLEAN IsIsrActivated;

    BOOLEAN IsKeyboard;

    //
    // Has it been started?
    // Has the device been manually removed?
    //
    BOOLEAN Started;

} *PCOMMON_DATA;

#define GET_COMMON_DATA(ext) ((PCOMMON_DATA) ext)
#define MANUALLY_REMOVED(ext) ((ext)->PnpDeviceState & PNP_DEVICE_REMOVED)

//
// Define the keyboard portion of the port device extension.
//
typedef struct _PORT_KEYBOARD_EXTENSION {

    // 
    // Data in common with the mouse extension;
    //
    struct COMMON_DATA;
     
    //
    // bitfield which represents the power capabilities of the kb
    //
    UCHAR PowerCaps;

    //
    // A newly found power event which we need to inform the PO system of
    //
    UCHAR PowerEvent;
    
    UCHAR CurrentScanCode, LastScanCode;

    //
    // Irp to be completed when one the power buttons is pressed
    //
    PIRP SysButtonEventIrp;

    //
    // DPC to handle power button events (updating our caps and completing
    // previous IOCTL requests)
    //
    KDPC SysButtonEventDpc; 

    //
    // Spin lock to guard the cancel routine and the IOCTL handler
    //
    KSPIN_LOCK SysButtonSpinLock;

    //
    // Symbolic name for the interface
    //
    UNICODE_STRING SysButtonInterfaceName; 

    //
    // Keyboard attributes.
    //
    KEYBOARD_ATTRIBUTES KeyboardAttributes;

    //
    // Extended keyboard ID
    //
    KEYBOARD_ID_EX KeyboardIdentifierEx;

    //
    // Initial values of keyboard typematic rate and delay.
    //
    KEYBOARD_TYPEMATIC_PARAMETERS KeyRepeatCurrent;

    //
    // Current indicator (LED) setting.
    //
    KEYBOARD_INDICATOR_PARAMETERS KeyboardIndicators;

    //
    // Keyboard ISR DPC queue.
    //
    KDPC KeyboardIsrDpc;

    //
    // Keyboard ISR DPC recall queue.
    //
    KDPC KeyboardIsrDpcRetry;

    //
    // Used by the ISR and the ISR DPC (in I8xDpcVariableOperation calls)
    // to control processing by the ISR DPC.
    //
    LONG DpcInterlockKeyboard;
 
    //
    // Start of the port keyboard input data queue (really a circular buffer).
    //
    PKEYBOARD_INPUT_DATA InputData;
 
    //
    // Insertion pointer for keyboard InputData.
    //
    PKEYBOARD_INPUT_DATA DataIn;
 
    //
    // Removal pointer for keyboard InputData.
    //
    PKEYBOARD_INPUT_DATA DataOut;
 
    //
    // Points one input packet past the end of the InputData buffer.
    //
    PKEYBOARD_INPUT_DATA DataEnd;
 
    //
    // Current keyboard input packet.
    //
    KEYBOARD_INPUT_DATA CurrentInput;
 
    //
    // Current keyboard scan input state.
    //
    KEYBOARD_SCAN_STATE CurrentScanState;
  
    //
    // Routine to call after the mouse is reset
    //
    PI8042_KEYBOARD_INITIALIZATION_ROUTINE InitializationHookCallback;
    
    //
    // Routine to call when a byte is received via the interrupt
    //
    PI8042_KEYBOARD_ISR IsrHookCallback;
     
    //
    // Context variable for InitializationRoutine
    //
    PVOID HookContext;

    //
    // Crash by key combination.
    //
    // CrashFlags used to be Dump1Keys
    //
    LONG CrashFlags;          // CrashDump call first press keys flag
                              //  7 6 5 4 3 2 1 0 bit
                              //    | | |   | | +--- Right Shift Key
                              //    | | |   | +----- Right Ctrl Key
                              //    | | |   +------- Right Alt Key
                              //    | | +----------- Left Shift Key
                              //    | +------------- Left Ctrl Key
                              //    +--------------- Left Alt Key
    //
    // CurrentCrashFlags used to be Dump2Key
    //
    LONG CurrentCrashFlags;           

    //
    // Key to be pressed 2 times to cause the crash dump
    //
    UCHAR CrashScanCode; 

    //
    // Alternate to CrashScanCode, used only for the print screen scan codes(s)
    //
    UCHAR CrashScanCode2;

    //
    // If FAILED_RESET_PROCEED, ignore the fact that the keyboard did not send
    // an ACK in response to the reset command and still look for the 
    // success/failure code in the i8042 controller.
    //
    UCHAR FailedReset;

} PORT_KEYBOARD_EXTENSION, *PPORT_KEYBOARD_EXTENSION;

//
// Define the structure used to enable the mouse
//
typedef struct _ENABLE_MOUSE { 
    KDPC Dpc;
    KTIMER Timer;

    USHORT    Count;
    BOOLEAN   FirstTime;
    BOOLEAN   Enabled;
} ENABLE_MOUSE;

typedef enum _INTERNAL_RESET_STATE {
    InternalContinueTimer = 0x0,
    InternalMouseReset,
    InternalPauseOneSec
} INTERNAL_RESET_STATE;

typedef enum _ISR_RESET_STATE {
    IsrResetNormal = 0x0,
    IsrResetStopResetting,

    IsrResetQueueReset,
    IsrResetPause 
} ISR_RESET_STATE;

typedef enum _ISR_DPC_CAUSE {
    IsrDpcCauseKeyboardWriteComplete = 1,
    IsrDpcCauseMouseWriteComplete,
    IsrDpcCauseMouseResetComplete
} ISR_DPC_CAUSE;

typedef struct _RESET_MOUSE {
    KDPC Dpc;
    KTIMER Timer;

    ISR_RESET_STATE IsrResetState;

} RESET_MOUSE;

#define I8X_MOUSE_INIT_COUNTERS(mouExt)                                     \
    {                                                                       \
        (mouExt)->ResetCount = (mouExt)->FailedCompleteResetCount = -1;     \
        (mouExt)->ResendCount = 0;                                          \
    }

//
// Define the mouse portion of the port device extension.
//
typedef struct _PORT_MOUSE_EXTENSION {

    struct COMMON_DATA;

    //
    // Mouse attributes.
    //
    MOUSE_ATTRIBUTES MouseAttributes;

    //
    // Reset IRP used in StartIO
    //
    PIRP ResetIrp;

    //
    // Mouse ISR DPC queue.
    //
    KDPC MouseIsrDpc;
 
    //
    // Mouse ISR DPC recall queue.
    //
    KDPC MouseIsrDpcRetry;

    //
    // Mouse ISR reset queue.
    //
    KDPC MouseIsrResetDpc;

    //
    // These two structs represent different methods of initialization.  
    //
    union {
        RESET_MOUSE  ResetMouse; 
        ENABLE_MOUSE EnableMouse;
    };

    //
    // Used by the ISR and the ISR DPC (in I8xDpcVariableOperation calls)
    // to control processing by the ISR DPC.
    //
    LONG DpcInterlockMouse;
 
    //
    // Start of the port mouse input data queue (really a circular buffer).
    //
    PMOUSE_INPUT_DATA InputData;
 
    //
    // Insertion pointer for mouse InputData.
    //
    PMOUSE_INPUT_DATA DataIn;
 
    //
    // Removal pointer for mouse InputData.
    //
    PMOUSE_INPUT_DATA DataOut;
 
    //
    // Points one input packet past the end of the InputData buffer.
    //
    PMOUSE_INPUT_DATA DataEnd;
 
    //
    // Current mouse input packet.                   (24 bytes)
    //
    MOUSE_INPUT_DATA CurrentInput;
 
    //
    // Current mouse input state.
    //
    MOUSE_STATE InputState;
    MOUSE_RESET_SUBSTATE InputResetSubState;
 
    MOUSE_RESET_SUBSTATE WorkerResetSubState;

    //
    // Count the number of times we have reset and failed
    //
    UCHAR ResetCount;

    //
    // Count the number of times we have reset and not gone through the entire
    // reset process
    //
    UCHAR FailedCompleteResetCount;

    //
    // Current mouse sign and overflow data.
    //
    UCHAR CurrentSignAndOverflow;
 
    //
    // Previous mouse sign and overflow data.
    //
    UCHAR PreviousSignAndOverflow;

    //
    // The tick count (since system boot) at which the mouse last interrupted.
    // Retrieved via KeQueryTickCount.  Used to determine whether a byte of
    // the mouse data packet has been lost.  Allows the driver to synch
    // up with the true mouse input state.
    //
    LARGE_INTEGER PreviousTick;
 
    //
    // Number of interval timer ticks to wait before deciding that the
    // next mouse interrupt is for the start of a new packet.  Used to
    // synch up again if a byte of the mouse packet gets lost.
    //
    ULONG SynchTickCount;

    //
    // The amount of time that is valid between sending a set sampling sequence
    //  (of 20, 40, and 60) and receiving the first pnp id packet from the mouse
    //
    // Expressed in terms of system ticks
    //
    ULONG WheelDetectionTimeout;

    //
    // Contains a multi sz list of pnp mouse IDs to check for a wheel mouse
    //
    UNICODE_STRING WheelDetectionIDs;

    //
    // Plug n Play ID received from the mouse during reset
    //
    WCHAR PnPID[MOUSE_PNPID_LENGTH];

    //
    // An upper filter callback hook to call when processing mouse bytes
    //
    PI8042_MOUSE_ISR IsrHookCallback;
     
    //
    // Context variable for IsrHookCallback
    //
    PVOID HookContext;

    PVOID NotificationEntry;

    //
    // List of sample rates to send to the mouse during a reset
    //
    PUCHAR SampleRates;

    ULONG MouseResetStallTime;

    //
    // Index into the SampleRates array
    //
    UCHAR SampleRatesIndex;

    //
    // Previous mouse button data.
    //
    UCHAR PreviousButtons;

    //
    // Statue to transition to after the last sample rate from SampleRates has
    // been sent to the mouse
    //
    USHORT PostSamplesState;

    //
    // Keep track of last byte of data received from mouse so we can detect
    // the two-byte string which indicates a potential reset
    //
    UCHAR LastByteReceived;

    //
    // Tracking resolution on the mouse
    //
    UCHAR Resolution;
 
    //
    // One of 3 states that determines whether we should try and detect the wheel
    // on the mouse or not
    //
    UCHAR EnableWheelDetection;
 
    //
    // Skip button detection if it overridden in the registry.  
    //
    UCHAR NumberOfButtonsOverride;

    //
    // If 0, then initalize the mouse via the interrupt, if non zero, initialize
    // the mouse via polling
    //
    UCHAR InitializePolled;

#if MOUSE_RECORD_ISR
    ULONG RecordHistoryFlags;
    ULONG RecordHistoryCount;
    ULONG RecordHistoryState;
#endif

} PORT_MOUSE_EXTENSION, *PPORT_MOUSE_EXTENSION;

//
// controller specific data used by both devices
//
typedef struct _CONTROLLER_DATA { 

    //
    // Indicate which hardware is actually present (keyboard and/or mouse).
    //
    ULONG HardwarePresent;
    
    //
    // IOCTL synchronization object
    //
    PCONTROLLER_OBJECT ControllerObject;

    //
    // Port configuration information.
    //
    I8042_CONFIGURATION_INFORMATION Configuration; 

    //
    // Timer used to timeout i8042 commands.
    //
    KTIMER CommandTimer;

    //
    // Spin lock to guard freeing of bytes written to device
    //
    KSPIN_LOCK BytesSpinLock;

    //
    // Spin lock to guard powering the devices back up
    //
    KSPIN_LOCK PowerSpinLock;

    //
    // Default buffer to use for a write to a device if the request <=4 bytes
    // (avoid lots of tiny sized allocs)
    //
    UCHAR DefaultBuffer[4];

    //
    // Timer count used by the command time out routine.
    //
    LONG TimerCount;

    //
    // Interrupt to synchronize against
    //
    // IN PKINTERRUPT HigherInterrupt;

    //
    // The mapped addresses for this device's registers.
    //
    PUCHAR DeviceRegisters[MaximumPortCount];

    //
    // List of ports in IRP_MN_FILTER_RESOURCE_REQUIREMENTS
    //
    PHYSICAL_ADDRESS KnownPorts[MaximumPortCount];

    ULONG KnownPortsCount;

#if DBG
    ULONG CurrentIoControlCode;
#endif

} CONTROLLER_DATA, *PCONTROLLER_DATA;

#define POST_BUTTONDETECT_COMMAND                 (SET_MOUSE_RESOLUTION)
#define POST_BUTTONDETECT_COMMAND_SUBSTATE        (ExpectingSetResolutionDefaultACK)

#define POST_WHEEL_DETECT_COMMAND                 (GET_DEVICE_ID)
#define POST_WHEEL_DETECT_COMMAND_SUBSTATE        (ExpectingGetDeviceId2ACK)

#define ExpectingPnpId                            (I8042ReservedMinimum+  2)
#define PostWheelDetectState                      (I8042ReservedMinimum+  3)
#define PostEnableWheelState                      (I8042ReservedMinimum+  4)

#define QueueingMouseReset                        (I8042ReservedMinimum+100)
#define MouseResetFailed                          (I8042ReservedMinimum+101)

#define ExpectingLegacyPnpIdByte2_Make            (I8042ReservedMinimum+200)
#define ExpectingLegacyPnpIdByte2_Break           (I8042ReservedMinimum+201)
#define ExpectingLegacyPnpIdByte3_Make            (I8042ReservedMinimum+202)
#define ExpectingLegacyPnpIdByte3_Break           (I8042ReservedMinimum+203)
#define ExpectingLegacyPnpIdByte4_Make            (I8042ReservedMinimum+204)
#define ExpectingLegacyPnpIdByte4_Break           (I8042ReservedMinimum+205)
#define ExpectingLegacyPnpIdByte5_Make            (I8042ReservedMinimum+206)
#define ExpectingLegacyPnpIdByte5_Break           (I8042ReservedMinimum+207)
#define ExpectingLegacyPnpIdByte6_Make            (I8042ReservedMinimum+208)
#define ExpectingLegacyPnpIdByte6_Break           (I8042ReservedMinimum+209)
#define ExpectingLegacyPnpIdByte7_Make            (I8042ReservedMinimum+210)
#define ExpectingLegacyPnpIdByte7_Break           (I8042ReservedMinimum+211)

#define QueueingMousePolledReset                  (I8042ReservedMinimum+300)

#define KeepOldSubState                           (I8042ReservedMinimum+400)

typedef struct _GLOBALS {
 
#if I8042_VERBOSE
    //
    // Flags:  Bit field for enabling debugging print statements
    // Level:  Legacy way of controllign debugging statements
    //
    ULONG DebugFlags;
    ULONG IsrDebugFlags;
#endif 

    //
    // Pointer to controller specific data that both extensions may access it
    //
    PCONTROLLER_DATA ControllerData;

    //
    // The two possible extensions that can be created
    //
    PPORT_MOUSE_EXTENSION MouseExtension;
    PPORT_KEYBOARD_EXTENSION KeyboardExtension;

    //
    // Generic read and write functions.  Since we can use both memory and port
    // type resources, we must use a function pointer to abstract access to them.
    //
    PI8X_READ_UCHAR I8xReadXxxUchar;

    PI8X_WRITE_UCHAR I8xWriteXxxUchar;

    // 
    // Path to the driver's entry in the registry
    //
    UNICODE_STRING RegistryPath;

    //
    // Keep track of the number of AddDevice and StartDevice calls.  Want to 
    // postpone h/w initialization until the last StartDevice is received
    // (due to some h/w which freezes if initialized more than once)
    //
    LONG AddedKeyboards;
    LONG AddedMice;
    LONG StartedDevices;
    ULONG PowerFlags;
    
    //
    // Provide mutual exclusion during dispatch functions
    //
    FAST_MUTEX DispatchMutex; 

    //
    // Set during the first H/W intialization to indicate that the register
    // addresses must be unmapped when the driver is unloaded.  It is also used 
    // when calling I8X_PUT_COMMAND_BYTE, I8X_PUT_DATA_BYTE, I8X_GET_STATUS_BYTE,
    // I8X_GET_DATA_BYTE.
    //
    BOOLEAN RegistersMapped;

    BOOLEAN BreakOnSysRq;

    BOOLEAN Headless;

    BOOLEAN ReportResetErrors;

} GLOBALS;

extern GLOBALS Globals;

#define RECORD_INIT               0x00000001
#define RECORD_RESUME_FROM_POWER  0x00000002
#define RECORD_DPC_RESET          0x00000004
#define RECORD_DPC_RESET_POLLED   0x00000008
#define RECORD_HW_PROFILE_CHANGE  0x00000010

#if MOUSE_RECORD_ISR
typedef struct _MOUSE_STATE_RECORD {
    USHORT InputResetSubState;
    USHORT InputState;
    UCHAR  LastByte;
    UCHAR  Reserved;
    UCHAR  Byte;
    UCHAR  Command;
    LARGE_INTEGER Time;
} MOUSE_STATE_RECORD, *PMOUSE_STATE_RECORD;

extern PMOUSE_STATE_RECORD IsrStateHistory;
extern PMOUSE_STATE_RECORD CurrentIsrState;
extern PMOUSE_STATE_RECORD IsrStateHistoryEnd;
extern ULONG               IsrStateCount;

#define RECORD_ISR_STATE(devExt, byte, lastbyte, time)                  \
    if ((devExt->RecordHistoryFlags & devExt->RecordHistoryState)) {    \
        if (CurrentIsrState >= IsrStateHistoryEnd) {                    \
            CurrentIsrState = IsrStateHistory;                          \
            RtlFillMemory(CurrentIsrState, sizeof(MOUSE_STATE_RECORD), 0x88);  \
            CurrentIsrState++;                                          \
        }                                                               \
        CurrentIsrState->InputState = (USHORT) devExt->InputState;      \
        CurrentIsrState->InputResetSubState = (USHORT) devExt->InputResetSubState;    \
        CurrentIsrState->Byte = byte;                                   \
        CurrentIsrState->LastByte = lastbyte;                           \
        CurrentIsrState->Time = time;                                   \
        CurrentIsrState++;                                              \
    }

#define RECORD_ISR_STATE_COMMAND(devExt, command)                     \
    if ((devExt->RecordHistoryFlags & devExt->RecordHistoryState))    \
            CurrentIsrState->Command = command;                       

#define RECORD_ISR_STATE_TRANSITION(devExt, state)                          \
    if ((devExt->RecordHistoryFlags & devExt->RecordHistoryState)) {        \
        if (CurrentIsrState >= IsrStateHistoryEnd) CurrentIsrState = IsrStateHistory; \
        RtlFillMemory(CurrentIsrState, sizeof(MOUSE_STATE_RECORD), 0xFF);   \
        CurrentIsrState->Time.LowPart  = state;                             \
        CurrentIsrState++;                                                  \
    }

#define SET_RECORD_STATE(devExt, state)                                 \
    {                                                                   \
        if (IsrStateHistory) devExt->RecordHistoryState |= (state);     \
        RECORD_ISR_STATE_TRANSITION(devExt, state);                     \
    }

#define CLEAR_RECORD_STATE(devExt) devExt->RecordHistoryState = 0x0;

#define SET_RECORD_FLAGS(devExt, flags) if (IsrStateHistory) devExt->RecordHistoryFlags |= (flags)
#define CLEAR_RECORD_FLAGS(devExt, flags) devExt->RecordHistoryFlags &= ~(flags)

#else

#define RECORD_ISR_STATE(devExt, byte, lastbyte, time) 
#define RECORD_ISR_STATE_COMMAND(devExt, command)
#define SET_RECORD_STATE(devExt, state)
#define CLEAR_RECORD_STATE(devExt)
#define SET_RECORD_FLAGS(devExt, flags) 
#define CLEAN_RECORD_FLAGS(devExt, flags) 

#endif // MOUSE_RECORD_ISR

typedef struct _I8X_KEYBOARD_WORK_ITEM {
    PIO_WORKITEM  Item;
    ULONG MakeCode;
    PIRP Irp;
} I8X_KEYBOARD_WORK_ITEM, *PI8X_KEYBOARD_WORK_ITEM;

typedef struct _I8X_MOUSE_RESET_INFO {
    PPORT_MOUSE_EXTENSION MouseExtension;
    INTERNAL_RESET_STATE  InternalResetState;
} I8X_MOUSE_RESET_INFO, * PI8X_MOUSE_RESET_INFO;

//
// Define the port TransmitControllerCommandByte context structure.
//
typedef struct _I8042_TRANSMIT_CCB_CONTEXT {
    IN ULONG HardwareDisableEnableMask;
    IN BOOLEAN AndOperation;
    IN UCHAR ByteMask;
    OUT NTSTATUS Status;
} I8042_TRANSMIT_CCB_CONTEXT, *PI8042_TRANSMIT_CCB_CONTEXT;

//
// Define the port InitializeDataQueue context structure.
//
typedef struct _I8042_INITIALIZE_DATA_CONTEXT {
    IN PVOID DeviceExtension;
    IN CCHAR DeviceType;
} I8042_INITIALIZE_DATA_CONTEXT, *PI8042_INITIALIZE_DATA_CONTEXT;

//
// Define the port Get/SetDataQueuePointer context structures.
//
typedef struct _GET_DATA_POINTER_CONTEXT {
    IN PVOID DeviceExtension;
    IN CCHAR DeviceType;
    OUT PVOID DataIn;
    OUT PVOID DataOut;
    OUT ULONG InputCount;
} GET_DATA_POINTER_CONTEXT, *PGET_DATA_POINTER_CONTEXT;

typedef struct _SET_DATA_POINTER_CONTEXT {
    IN PVOID DeviceExtension;
    IN CCHAR DeviceType;
    IN ULONG InputCount;
    IN PVOID DataOut;
} SET_DATA_POINTER_CONTEXT, *PSET_DATA_POINTER_CONTEXT;

typedef struct _POWER_UP_WORK_ITEM {
    WORK_QUEUE_ITEM Item;
    PIRP MousePowerIrp;
    PIRP KeyboardPowerIrp;
} POWER_UP_WORK_ITEM, *PPOWER_UP_WORK_ITEM;

//
// Define the port timer context structure.
//
typedef struct _TIMER_CONTEXT {
    IN PDEVICE_OBJECT DeviceObject;
    IN PLONG TimerCounter;
    OUT LONG NewTimerCount;
} TIMER_CONTEXT, *PTIMER_CONTEXT;

//
// Define the device InitiateOutput context structure.
//
typedef struct INITIATE_OUTPUT_CONTEXT {
    IN PDEVICE_OBJECT DeviceObject;
    IN PUCHAR Bytes;
    IN ULONG ByteCount;
} INITIATE_OUTPUT_CONTEXT, *PINITIATE_OUTPUT_CONTEXT;

//
// Statically allocate the (known) scancode-to-indicator-light mapping.
// This information is returned by the
// IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION device control request.
//

#define KEYBOARD_NUMBER_OF_INDICATORS              3

static const INDICATOR_LIST IndicatorList[KEYBOARD_NUMBER_OF_INDICATORS] = {
        {0x3A, KEYBOARD_CAPS_LOCK_ON},
        {0x45, KEYBOARD_NUM_LOCK_ON},
        {0x46, KEYBOARD_SCROLL_LOCK_ON}};

//
// Define the context structure and operations for I8xDpcVariableOperation.
//
typedef enum _OPERATION_TYPE {
        IncrementOperation,
        DecrementOperation,
        WriteOperation,
        ReadOperation
} OPERATION_TYPE;

typedef struct _VARIABLE_OPERATION_CONTEXT {
    IN PLONG VariableAddress;
    IN OPERATION_TYPE Operation;
    IN OUT PLONG NewValue;
} VARIABLE_OPERATION_CONTEXT, *PVARIABLE_OPERATION_CONTEXT;

//
// Define the actions to be taked on processing a system button
//
typedef enum _SYS_BUTTON_ACTION {
    NoAction =0,
    SendAction,
    UpdateAction
} SYS_BUTTON_ACTION;

//
// Function prototypes.
//

// begin_i8042dep
NTSTATUS
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    );

BOOLEAN
I8xDetermineSharedInterrupts(
    VOID
    );

VOID
I8xDrainOutputBuffer(
    IN PUCHAR DataAddress,
    IN PUCHAR CommandAddress
    );

VOID
I8xGetByteAsynchronous(
    IN CCHAR DeviceType,
    OUT PUCHAR Byte
    );

NTSTATUS
I8xGetBytePolled(
    IN CCHAR DeviceType,
    OUT PUCHAR Byte
    );

VOID
I8xGetDataQueuePointer(
    IN PGET_DATA_POINTER_CONTEXT Context
    );

VOID
I8xInitializeHardware(
    NTSTATUS *KeyboardStatus,
    NTSTATUS *MouseStatus,
    ULONG    InitFlags 
    );

NTSTATUS
I8xInitializeHardwareAtBoot(
    NTSTATUS *KeyboardStatus,
    NTSTATUS *MouseStatus
    );

VOID
I8xLogError(
    IN PDEVICE_OBJECT DeviceObject,
    IN NTSTATUS ErrorCode,
    IN ULONG UniqueErrorValue,
    IN NTSTATUS FinalStatus,
    IN PULONG DumpData,
    IN ULONG DumpCount
    );

VOID
I8xPutByteAsynchronous(
    IN CCHAR PortType,
    IN UCHAR Byte
    );

NTSTATUS
I8xPutBytePolled(
    IN CCHAR PortType,
    IN BOOLEAN WaitForAcknowledge,
    IN CCHAR AckDeviceType,
    IN UCHAR Byte
    );

VOID
I8xReinitializeHardware (
    PPOWER_UP_WORK_ITEM Item
    );

VOID
I8xServiceParameters(
    IN PUNICODE_STRING RegistryPath
    );

NTSTATUS
I8xGetControllerCommand(
    IN ULONG HardwareDisableEnableMask,
    OUT PUCHAR Byte
    );

NTSTATUS
I8xPutControllerCommand(
    IN UCHAR Byte
    );

NTSTATUS
I8xToggleInterrupts(
    BOOLEAN State
    );

NTSTATUS
I8xPutControllerCommand(
    IN UCHAR Byte
    );

VOID
I8xTransmitControllerCommand(
    IN PI8042_TRANSMIT_CCB_CONTEXT TransmitCCBContext
    );
// end_i8042dep

// begin_i8042cmn
NTSTATUS
I8xClose (
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    );

VOID
I8042CompletionDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN ISR_DPC_CAUSE IsrDpcCause
    );

IO_ALLOCATION_ACTION
I8xControllerRoutine (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp,
    IN PVOID          MapRegisterBase,
    IN PVOID          Context
    );

NTSTATUS
I8xCreate (
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    );

VOID
I8xDecrementTimer(
    IN PTIMER_CONTEXT Context
    );

VOID
I8xDpcVariableOperation(
    IN  PVOID Context
    );

VOID
I8042ErrorLogDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

NTSTATUS
I8xFlush(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
I8xInitializeDataQueue(
    IN PI8042_INITIALIZE_DATA_CONTEXT InitializeDataContext
    );

VOID
I8xInitiateOutputWrapper(
    IN PINITIATE_OUTPUT_CONTEXT InitiateContext 
    );

VOID
I8xInitiateIo(
    IN PDEVICE_OBJECT DeviceObject
    );

NTSTATUS
I8xDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
I8xInternalDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
I8042RetriesExceededDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

BOOLEAN
I8xSanityCheckResources(
    VOID
    );

NTSTATUS
I8xSendIoctl(
    PDEVICE_OBJECT      Target,
    ULONG               Ioctl,
    PVOID               InputBuffer,
    ULONG               InputBufferLength
    );

VOID
I8xSetDataQueuePointer(
    IN PSET_DATA_POINTER_CONTEXT Context
    );

VOID
I8xStartIo(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

VOID
I8xCompletePendedRequest(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp,
    ULONG_PTR Information,
    NTSTATUS Status
    );

VOID
I8xFinishResetRequest(
    PPORT_MOUSE_EXTENSION MouseExtension,
    BOOLEAN Failed,
    BOOLEAN RaiseIrql,
    BOOLEAN CancelTimer
    );

VOID
I8042TimeOutDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PVOID SystemContext1,
    IN PVOID SystemContext2
    );
// end_i8042cmn

// begin_kbddep
UCHAR
I8xConvertTypematicParameters(
    IN USHORT Rate,
    IN USHORT Delay
    );

NTSTATUS
I8xInitializeKeyboard(
    IN PPORT_KEYBOARD_EXTENSION KeyboardExtension
    );

NTSTATUS
I8xKeyboardConfiguration(
    IN PPORT_KEYBOARD_EXTENSION KeyboardExtension,
    IN PCM_RESOURCE_LIST ResourceList
    );

BOOLEAN
I8042KeyboardInterruptService(
    IN PKINTERRUPT Interrupt,
    IN PDEVICE_OBJECT DeviceObject
    );

VOID
I8xKeyboardServiceParameters(
    IN PUNICODE_STRING          RegistryPath,
    IN PPORT_KEYBOARD_EXTENSION KeyboardExtension
    );

VOID
I8xQueueCurrentKeyboardInput(
    IN PDEVICE_OBJECT DeviceObject
    );
// end_kbddep

// begin_kbdcmn
VOID
I8042KeyboardIsrDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

BOOLEAN
I8xWriteDataToKeyboardQueue(
    IN PPORT_KEYBOARD_EXTENSION KeyboardExtension,
    IN PKEYBOARD_INPUT_DATA InputData
    );
// end_kbdcmn

// begin_kbdpnp
NTSTATUS
I8xKeyboardConnectInterrupt(
    PPORT_KEYBOARD_EXTENSION KeyboardExtension
    );

NTSTATUS
I8xKeyboardInitializeHardware(
    PPORT_KEYBOARD_EXTENSION    KeyboardExtension,
    PPORT_MOUSE_EXTENSION       MouseExtension
    );

VOID
I8xKeyboardRemoveDevice(
    PDEVICE_OBJECT DeviceObject
    );

NTSTATUS
I8xKeyboardStartDevice(
    IN OUT PPORT_KEYBOARD_EXTENSION KeyboardExtension,
    IN PCM_RESOURCE_LIST ResourceList
    );
// end_kbdpnp

// begin_moucmn
VOID
I8042MouseIsrDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

BOOLEAN
I8xWriteDataToMouseQueue(
    IN PPORT_MOUSE_EXTENSION MouseExtension,
    IN PMOUSE_INPUT_DATA InputData
    );
// end_moucmn

// begin_moudep
NTSTATUS
I8xMouseConfiguration(
    IN PPORT_MOUSE_EXTENSION MouseExtension,
    IN PCM_RESOURCE_LIST ResourceList
    );

VOID
MouseCopyWheelIDs(
    PUNICODE_STRING Destination,
    PUNICODE_STRING Source
    );

NTSTATUS
I8xMouseEnableTransmission(
    IN PPORT_MOUSE_EXTENSION MouseExtension
    );

NTSTATUS
I8xTransmitByteSequence(
    PUCHAR Bytes,
    ULONG* UniqueErrorValue,
    ULONG* ErrorCode,
    ULONG* DumpData,
    ULONG* DumpCount
    );

NTSTATUS
I8xGetBytePolledIterated(
    IN CCHAR DeviceType,
    OUT PUCHAR Byte,
    ULONG Attempts
    );

NTSTATUS
I8xFindWheelMouse(
    IN PPORT_MOUSE_EXTENSION MouseExtension
    );

NTSTATUS
I8xInitializeMouse(
    IN PPORT_MOUSE_EXTENSION MouseExension
    );

BOOLEAN
I8042MouseInterruptService(
    IN PKINTERRUPT Interrupt,
    IN PVOID Context
    );

NTSTATUS
I8xQueryNumberOfMouseButtons(
    OUT PUCHAR          NumberOfMouseButtons
    );

NTSTATUS
I8xResetMouse(
    PPORT_MOUSE_EXTENSION MouseExtension
    );

VOID
I8xResetMouseFailed(
    PPORT_MOUSE_EXTENSION MouseExtension
    );

VOID
I8xSendResetCommand (
    PPORT_MOUSE_EXTENSION MouseExtension
    );

VOID
I8xMouseServiceParameters(
    IN PUNICODE_STRING       RegistryPath,
    IN PPORT_MOUSE_EXTENSION MouseExtension
    );

VOID
I8xQueueCurrentMouseInput(
    IN PDEVICE_OBJECT DeviceObject
    );

BOOLEAN
I8xVerifyMousePnPID(
    PPORT_MOUSE_EXTENSION   MouseExtension,
    PWSTR                   MouseID
    );
// end_moudep

// begin_moupnp
NTSTATUS
I8xMouseConnectInterruptAndEnable(
    PPORT_MOUSE_EXTENSION MouseExtension,
    BOOLEAN Reset
    );

NTSTATUS
I8xMouseInitializeHardware(
    PPORT_KEYBOARD_EXTENSION    KeyboardExtension,
    PPORT_MOUSE_EXTENSION       MouseExtension
    );

NTSTATUS
I8xProfileNotificationCallback(
    IN PHWPROFILE_CHANGE_NOTIFICATION NotificationStructure,
    PPORT_MOUSE_EXTENSION MouseExtension
    );

VOID
I8xMouseRemoveDevice(
    PDEVICE_OBJECT DeviceObject
    );

NTSTATUS
I8xMouseStartDevice(
    PPORT_MOUSE_EXTENSION MouseExtension,
    IN PCM_RESOURCE_LIST ResourceList
    );

BOOLEAN
I8xMouseEnableSynchRoutine(
    IN PPORT_MOUSE_EXTENSION    MouseExtension
    );

VOID
I8xMouseEnableDpc(
    IN PKDPC                    Dpc,
    IN PPORT_MOUSE_EXTENSION    MouseExtension,
    IN PVOID                    SystemArg1, 
    IN PVOID                    SystemArg2
    );

VOID 
I8xIsrResetDpc(
    IN PKDPC                    Dpc,
    IN PPORT_MOUSE_EXTENSION    MouseExtension,
    IN ULONG                    ResetPolled,
    IN PVOID                    SystemArg2
    );

VOID
I8xMouseResetTimeoutProc(
    IN PKDPC                    Dpc,
    IN PPORT_MOUSE_EXTENSION    MouseExtension,
    IN PVOID                    SystemArg1, 
    IN PVOID                    SystemArg2
    );

BOOLEAN
I8xMouseResetSynchRoutine(
    PI8X_MOUSE_RESET_INFO ResetInfo 
    );

VOID
I8xMouseInitializeInterruptWorker(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIO_WORKITEM   Item 
    );

VOID
I8xMouseInitializePolledWorker(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIO_WORKITEM   Item 
    );
// end_moupnp

// begin_pnp
NTSTATUS
I8xAddDevice (
    IN PDRIVER_OBJECT   Driver,
    IN PDEVICE_OBJECT   PDO
    );

NTSTATUS
I8xFilterResourceRequirements(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

NTSTATUS
I8xFindPortCallout(
    IN PVOID                        Context,
    IN PUNICODE_STRING              PathName,
    IN INTERFACE_TYPE               BusType,
    IN ULONG                        BusNumber,
    IN PKEY_VALUE_FULL_INFORMATION *BusInformation,
    IN CONFIGURATION_TYPE           ControllerType,
    IN ULONG                        ControllerNumber,
    IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation,
    IN CONFIGURATION_TYPE           PeripheralType,
    IN ULONG                        PeripheralNumber,
    IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation
    );

LONG
I8xManuallyRemoveDevice(
    PCOMMON_DATA CommonData
    );

NTSTATUS
I8xPnP (
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    );

NTSTATUS
I8xPnPComplete (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PKEVENT Event
    );

NTSTATUS
I8xPower (
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    );

NTSTATUS
I8xPowerUpToD0Complete(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

void
I8xSetPowerFlag(
    IN ULONG Flag,
    IN BOOLEAN Set
    );

NTSTATUS
I8xRegisterDeviceInterface(
    PDEVICE_OBJECT PDO,
    CONST GUID *Guid,
    PUNICODE_STRING SymbolicName
    );

BOOLEAN
I8xRemovePort(
    IN PIO_RESOURCE_DESCRIPTOR ResDesc
    );

NTSTATUS
I8xSendIrpSynchronously (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN BOOLEAN Strict
    );

VOID
I8xUnload(
    IN PDRIVER_OBJECT DriverObject
    );
// end_pnp

// begin_sysbtn
VOID
I8xCompleteSysButtonIrp(
    PIRP Irp,
    ULONG Event,
    NTSTATUS Status
    );

#if DELAY_SYSBUTTON_COMPLETION
VOID 
I8xCompleteSysButtonEventWorker(
    IN PDEVICE_OBJECT DeviceObject,
    IN PI8X_KEYBOARD_WORK_ITEM Item
    );
#endif

NTSTATUS
I8xKeyboardGetSysButtonCaps(
    PPORT_KEYBOARD_EXTENSION KeyboardExtension,
    PIRP Irp
    );

NTSTATUS 
I8xKeyboardGetSysButtonEvent(
    PPORT_KEYBOARD_EXTENSION KeyboardExtension,
    PIRP Irp
    );

VOID
I8xKeyboardSysButtonEventDpc(
    IN PKDPC Dpc,
    IN PDEVICE_OBJECT DeviceObject,
    IN SYS_BUTTON_ACTION Action, 
    IN ULONG ButtonEvent 
    );

VOID
I8xSysButtonCancelRoutine( 
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );
// end_sysbtn

// begin_hook
VOID
I8xMouseIsrWritePort(
    IN PDEVICE_OBJECT   DeviceObject,
    IN UCHAR            Value
    );

VOID
I8xKeyboardIsrWritePort(
    IN PDEVICE_OBJECT   DeviceObject,
    IN UCHAR            Value
    );

NTSTATUS 
I8xKeyboardSynchReadPort (
    IN PDEVICE_OBJECT   DeviceObject,
    IN PUCHAR           Value,
    IN BOOLEAN          Dummy
    );

NTSTATUS 
I8xKeyboardSynchWritePort (
    IN PDEVICE_OBJECT   DeviceObject,                           
    IN UCHAR            Value,
    IN BOOLEAN          WaitForACK
    );
// end_hook

// begin_wmi
NTSTATUS
I8xSystemControl (
    IN PDEVICE_OBJECT    DeviceObject,
    IN PIRP              Irp
    );

NTSTATUS
I8xInitWmi(
    PCOMMON_DATA CommonData
    );

NTSTATUS
I8xSetWmiDataBlock(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            GuidIndex,
    IN ULONG            InstanceIndex,
    IN ULONG            BufferSize,
    IN PUCHAR           Buffer
    );

NTSTATUS
I8xSetWmiDataItem(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            GuidIndex,
    IN ULONG            InstanceIndex,
    IN ULONG            DataItemId,
    IN ULONG            BufferSize,
    IN PUCHAR           Buffer
    );

NTSTATUS
I8xKeyboardQueryWmiDataBlock(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            GuidIndex,
    IN ULONG            InstanceIndex,
    IN ULONG            InstanceCount,
    IN OUT PULONG       InstanceLengthArray,
    IN ULONG            BufferAvail,
    OUT PUCHAR          Buffer
    );

NTSTATUS
I8xMouseQueryWmiDataBlock(
    IN PDEVICE_OBJECT   DeviceObject,
    IN PIRP             Irp,
    IN ULONG            GuidIndex,
    IN ULONG            InstanceIndex,
    IN ULONG            InstanceCount,
    IN OUT PULONG       InstanceLengthArray,
    IN ULONG            BufferAvail,
    OUT PUCHAR          Buffer
    );

NTSTATUS
I8xQueryWmiRegInfo(
    IN PDEVICE_OBJECT   DeviceObject,
    OUT PULONG          RegFlags,
    OUT PUNICODE_STRING InstanceName,
    OUT PUNICODE_STRING *RegistryPath,
    OUT PUNICODE_STRING MofResourceName,
    OUT PDEVICE_OBJECT  *Pdo
    );


// end_wmi

//
// Flags to represent modifier key states 
//
#define CRASH_R_SHIFT  0x01
#define CRASH_R_CTRL   0x02
#define CRASH_R_ALT    0x04

#define CRASH_L_SHIFT  0x10
#define CRASH_L_CTRL   0x20
#define CRASH_L_ALT    0x40

#define CRASH_FIRST_TIME   0x100
#define CRASH_SECOND_TIME  0x200
#define CRASH_BOTH_TIMES (CRASH_FIRST_TIME | CRASH_SECOND_TIME)

VOID
I8xProcessCrashDump(
    PPORT_KEYBOARD_EXTENSION DeviceExtension,
    UCHAR ScanCode,
    KEYBOARD_SCAN_STATE ScanState
    );

VOID
I8xServiceCrashDump(
    IN PPORT_KEYBOARD_EXTENSION DeviceExtension,
    IN PUNICODE_STRING          RegistryPath
    );

#if defined(_X86_)
#ifndef _FJKBD_H_
#define _FJKBD_H_

//
// oyayubi-shift keyboard internal input mode value.
//
#define THUMB_NOROMAN_ALPHA_CAPSON     0x01
#define THUMB_NOROMAN_ALPHA_CAPSOFF    0x02
#define THUMB_NOROMAN_HIRAGANA         0x03
#define THUMB_NOROMAN_KATAKANA         0x04
#define THUMB_ROMAN_ALPHA_CAPSON       0x05
#define THUMB_ROMAN_ALPHA_CAPSOFF      0x06
#define THUMB_ROMAN_HIRAGANA           0x07
#define THUMB_ROMAN_KATAKANA           0x08

//
// Following functions are oyayubi-shift keyboard use only.
//
NTSTATUS
I8042SetIMEStatusForOasys(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN OUT PINITIATE_OUTPUT_CONTEXT InitiateContext
    );

ULONG
I8042QueryIMEStatusForOasys(
    IN PKEYBOARD_IME_STATUS KeyboardIMEStatus
    );

VOID
I8xKeyboardInitiateIoForOasys(
    IN PDEVICE_OBJECT DeviceObject
    );
#endif // _FJKBD_H_
#endif // _X86_

#if DBG
#define DEFAULT_DEBUG_FLAGS 0x88888808 // 0x8cc8888f
#else 
#define DEFAULT_DEBUG_FLAGS 0x0 
#endif


#if I8042_VERBOSE
//
//Debug messaging and breakpoint macros
//
#define DBG_ALWAYS                 0x00000000

#define DBG_STARTUP_SHUTDOWN_MASK  0x0000000F
#define DBG_SS_NOISE               0x00000001
#define DBG_SS_TRACE               0x00000002
#define DBG_SS_INFO                0x00000004
#define DBG_SS_ERROR               0x00000008

#define DBG_CALL_MASK              0x000000F0
#define DBG_CALL_NOISE             0x00000010
#define DBG_CALL_TRACE             0x00000020
#define DBG_CALL_INFO              0x00000040
#define DBG_CALL_ERROR             0x00000080

#define DBG_IOCTL_MASK             0x00000F00
#define DBG_IOCTL_NOISE            0x00000100
#define DBG_IOCTL_TRACE            0x00000200
#define DBG_IOCTL_INFO             0x00000400
#define DBG_IOCTL_ERROR            0x00000800

#define DBG_DPC_MASK              0x0000F000
#define DBG_DPC_NOISE             0x00001000
#define DBG_DPC_TRACE             0x00002000
#define DBG_DPC_INFO              0x00004000
#define DBG_DPC_ERROR             0x00008000

#define DBG_CREATE_CLOSE_MASK      0x000F0000
#define DBG_CC_NOISE               0x00010000
#define DBG_CC_TRACE               0x00020000
#define DBG_CC_INFO                0x00040000
#define DBG_CC_ERROR               0x00080000

#define DBG_POWER_MASK             0x00F00000
#define DBG_POWER_NOISE            0x00100000
#define DBG_POWER_TRACE            0x00200000
#define DBG_POWER_INFO             0x00400000
#define DBG_POWER_ERROR            0x00800000

#define DBG_PNP_MASK               0x0F000000
#define DBG_PNP_NOISE              0x01000000
#define DBG_PNP_TRACE              0x02000000
#define DBG_PNP_INFO               0x04000000
#define DBG_PNP_ERROR              0x08000000

#define DBG_BUFIO_MASK            0xF0000000
#define DBG_BUFIO_NOISE           0x10000000
#define DBG_BUFIO_TRACE           0x20000000
#define DBG_BUFIO_INFO            0x40000000
#define DBG_BUFIO_ERROR           0x80000000

#define DBG_KBISR_NOISE           0x00000001
#define DBG_KBISR_TRACE           0x00000002
#define DBG_KBISR_INFO            0x00000004
#define DBG_KBISR_ERROR           0x00000008

#define DBG_KBISR_STATE           0x00000010
#define DBG_KBISR_SCODE           0x00000020
#define DBG_KBISR_BREAK           0x00000040
#define DBG_KBISR_EMUL            0x00000080

#define DBG_KBISR_POWER            0x00000100

#define DBG_MOUISR_MASK            0x000F0000
#define DBG_MOUISR_NOISE           0x00010000
#define DBG_MOUISR_TRACE           0x00020000
#define DBG_MOUISR_INFO            0x00040000
#define DBG_MOUISR_ERROR           0x00080000

#define DBG_MOUISR_STATE           0x00100000
#define DBG_MOUISR_BYTE            0x00200000
#define DBG_MOUISR_RESETTING       0x00400000
#define DBG_MOUISR_ACK             0x00800000

#define DBG_MOUISR_PNPID           0x01000000
#define DBG_MOUISR_BREAK           0x02000000
// #define DBG_MOUISR_BREAK           0x04000000

#define Print(_flags_, _x_) \
            if (Globals.DebugFlags & (_flags_) || !(_flags_)) { \
                DbgPrint (pDriverName); \
                DbgPrint _x_; \
            }
#define IsrPrint(_flags_, _x_) \
            if (Globals.IsrDebugFlags & (_flags_) || !(_flags_)) { \
                DbgPrint (((ULONG)(_flags_)) >= 0x0001000 ? pIsrMou : pIsrKb); \
                DbgPrint _x_; \
            }
#define TRAP() DbgBreakPoint()

#else

#define Print(_l_,_x_)
#define IsrPrint(_l_,_x_)
#define TRAP()

#endif  // I8042_VERBOSE

static UCHAR ScanCodeToUChar[] = {
    0x00,            // Nothing
    0x00,            // Esc
    '1',
    '2',
    '3',
    '4',
    '5',
    '6',
    '7',
    '8',
    '9',
    '0',
    '-',
    '=',
    0x00,           // Backspace
    0x00,           // Tab
    'Q',
    'W',
    'E',
    'R',
    'T',
    'Y',
    'U',
    'I',
    'O',
    'P',
    '[',
    ']',
    '\\',
    0x00,            // Caps lock
    'A',
    'S',
    'D',
    'F',
    'G',
    'H',
    'I',
    'J',
    'K',
    'L',
    ';',
    '\'',
    0x00,           // Return
    0x00,           // Shift left
    'Z',
    'X',
    'C',
    'V',
    'B',
    'N',
    'M',
    ',',
    '.',
    '/'
    };


static const int ScanCodeToUCharCount = sizeof(ScanCodeToUChar)/sizeof(UCHAR);
    /*
    0x00,           // Shift right
    0x00,           // Ctrl left
    0x00,           // Alt left
    ' ', 
    0x00,           // Alt right
    0x00,           // Ctrl right
    0x00,           // num lock
    */

#define CTRL_SCANCODE          0x1d
#define LEFT_SHIFT_SCANCODE    0x2A
#define RIGHT_SHIFT_SCANCODE   0x36
#define ALT_SCANCODE           0x38
#define SCROLL_LOCK_SCANCODE   0x46

#endif // _I8042PRT_