moudep.c revision eb0398a29ff0e9c8456afeef89fbffca86a626e8
/*++
Copyright (c) 1990, 1991, 1992, 1993 Microsoft Corporation
Module Name:
Abstract:
The initialization and hardware-dependent portions of
the Intel i8042 port driver which are specific to
the auxiliary (PS/2 mouse) device.
Environment:
Kernel mode only.
Notes:
NOTES: (Future/outstanding issues)
- Powerfail not implemented.
- Consolidate duplicate code, where possible and appropriate.
Revision History:
--*/
// VBOX begin
// VBOX backdoor logging
//#define LOG_ENABLED
// VBOX end
#include "stdarg.h"
#include "stdio.h"
#include "string.h"
#include "ntddk.h"
#include "i8042prt.h"
#include "i8042log.h"
//
// Use the alloc_text pragma to specify the driver initialization routines
// (they can be paged out).
//
#ifdef ALLOC_PRAGMA
#endif
)
/*++
Routine Description:
This is the interrupt service routine for the mouse device.
Arguments:
Interrupt - A pointer to the interrupt object for this interrupt.
Context - A pointer to the device object.
Return Value:
Returns TRUE if the interrupt was expected (and therefore processed);
otherwise, FALSE is returned.
--*/
{
//
// Verify that this device really interrupted. Check the status
// register. The Output Buffer Full bit should be set, and the
// Auxiliary Device Output Buffer Full bit should be set.
//
//
// Stall and then try again. The Olivetti MIPS machine
// sometimes gets a mouse interrupt before the status
// register is set.
//
//
// Not our interrupt.
//
I8xPrint((
1,
"I8042PRT-I8042MouseInterruptService: not our interrupt!\n"
));
return(FALSE);
}
}
//
// Read the byte from the i8042 data port.
//
&byte
);
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: byte 0x%x\n",
));
//
// Watch the data stream for a reset completion (0xaa) followed by the
// device id
//
// this pattern can appear as part of a normal data packet as well. This
// code assumes that sending an enable to an already enabled mouse will:
// * not hang the mouse
// * abort the current packet and return an ACK.
//
(byte == 0x00)) {
I8xPrint((
1,
"I8042PRT-18042MouseInterruptService: reset detected in "
"data stream - current state is %d\n",
));
//
// help us track down any wierd problems in the field
//
errorPacketSize = sizeof(IO_ERROR_LOG_PACKET);
);
if (errorLogEntry != NULL) {
//
// If a reset occurred with the wheel mouse enabled make the message
// a warning and include the fact that the wheel is disabled in the
// message text
//
} else {
}
errorLogEntry->DumpDataSize = 0;
errorLogEntry->SequenceNumber = 0;
errorLogEntry->IoControlCode = 0;
errorLogEntry->RetryCount = 0;
errorLogEntry->FinalStatus = 0;
}
//
// send the command to enable the mouse and wait for acknowledge.
//
// NOTE - this should be synchronized with the keyboard code
//
(CCHAR) CommandPort,
);
);
//
// Set up state machine to look for acknowledgement.
//
}
//
// Take the appropriate action, depending on the current state.
// When the state is Idle, we expect to receive mouse button
// data. When the state is XMovement, we expect to receive mouse
// motion in the X direction data. When the state is YMovement,
// we expect to receive mouse motion in the Y direction data. Once
// the Y motion data has been received, the data is queued to the
// mouse InputData queue, the mouse ISR DPC is requested, and the
// state returns to Idle.
//
//
// It has been a long time since we got a byte of
// the data packet. Assume that we are now receiving
// the first byte of a new packet, and discard any
// partially received packet.
//
// N.B. We assume that SynchTickCount is ULONG, and avoid
// a LARGE_INTEGER compare with tickDelta...
//
I8xPrint((
1,
"I8042PRT-I8042MouseInterruptService: State was %d, synching\n",
));
}
//
// The mouse interrupted with a status byte. The status byte
// contains information on the mouse button state along with
// the sign and overflow bits for the (yet-to-be-received)
// X and Y motion bytes.
//
case MouseIdle: {
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: mouse status byte\n"
));
//
// Update CurrentInput with button transition data.
// the state of a given button has changed since we
// received the last packet.
//
if ((!(previousButtons & LEFT_BUTTON_DOWN))
&& (byte & LEFT_BUTTON_DOWN)) {
} else
if ((previousButtons & LEFT_BUTTON_DOWN)
&& !(byte & LEFT_BUTTON_DOWN)) {
}
if ((!(previousButtons & RIGHT_BUTTON_DOWN))
&& (byte & RIGHT_BUTTON_DOWN)) {
} else
if ((previousButtons & RIGHT_BUTTON_DOWN)
&& !(byte & RIGHT_BUTTON_DOWN)) {
}
if ((!(previousButtons & MIDDLE_BUTTON_DOWN))
&& (byte & MIDDLE_BUTTON_DOWN)) {
} else
if ((previousButtons & MIDDLE_BUTTON_DOWN)
&& !(byte & MIDDLE_BUTTON_DOWN)) {
}
//
// Save the button state for comparison the next time around.
//
//
// Save the sign and overflow information from the current byte.
//
//
// Update to the next state.
//
break;
}
//
// The mouse interrupted with the X motion byte. Apply
// the sign and overflow bits from the mouse status byte received
// previously. Attempt to correct for bogus changes in sign
// that occur with large, rapid mouse movements.
//
case XMovement: {
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: mouse LastX byte\n"
));
//
// Update CurrentInput with the X motion data.
//
& X_OVERFLOW) {
//
// Handle overflow in the X direction. If the previous
// mouse movement overflowed too, ensure that the current
// overflow is in the same direction (i.e., that the sign
// is the same as it was for the previous event). We do this
// to correct for hardware problems -- it should not be possible
// to overflow in one direction and then immediately overflow
// in the opposite direction.
//
if (previousSignAndOverflow & X_OVERFLOW) {
if ((previousSignAndOverflow & X_DATA_SIGN) !=
& X_DATA_SIGN)) {
^= X_DATA_SIGN;
}
}
else
} else {
//
// No overflow. Just store the data, correcting for the
// sign if necessary.
//
}
//
// Update to the next state.
//
break;
}
//
// The mouse interrupted with the Y motion byte. Apply
// the sign and overflow bits from the mouse status byte received
// previously. [Attempt to correct for bogus changes in sign
// that occur with large, rapid mouse movements.] Write the
// data to the mouse InputData queue, and queue the mouse ISR DPC
// to complete the interrupt processing.
//
case YMovement: {
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: mouse LastY byte\n"
));
//
// Update CurrentInput with the Y motion data.
//
& Y_OVERFLOW) {
//
// Handle overflow in the Y direction. If the previous
// mouse movement overflowed too, ensure that the current
// overflow is in the same direction (i.e., that the sign
// is the same as it was for the previous event). We do this
// to correct for hardware problems -- it should not be possible
// to overflow in one direction and then immediately overflow
// in the opposite direction.
//
if (previousSignAndOverflow & Y_OVERFLOW) {
if ((previousSignAndOverflow & Y_DATA_SIGN) !=
& Y_DATA_SIGN)) {
^= Y_DATA_SIGN;
}
}
else
} else {
//
// No overflow. Just store the data, correcting for the
// sign if necessary.
//
//
// Negate the LastY value (the hardware reports positive
// motion in the direction that we consider negative).
//
}
//
// Update our notion of the previous sign and overflow bits for
// the start of the next mouse input sequence.
//
//
// Choose the next state. The WheelMouse has an extra byte of data
// for us
//
} else {
// VBOX begin
// this field is sticky, so first reset it for original behavior
{ // open a new scope
if (req)
{
{
{
// make it an absolute move
}
}
else
{
dprintf(("i8042prt: ERROR querying mouse capabilities from VMMDev."
}
}
} // close scope
// VBOX end
}
break;
}
case ZMovement: {
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: mouse LastZ byte\n"
));
//
// Check to see if we got any z data
// If there were any changes in the button state, ignore the
// z data
//
// if((byte)&&(deviceExtension->MouseExtension.CurrentInput.Buttons == 0)) {
if(byte) {
//
// Sign extend the Z information and store it into the extra
// information field
//
if(byte & 0x80) {
} else {
}
}
// VBOX begin
// this field is sticky, so first reset it for original behavior
{ // open a new scope
if (req)
{
{
{
// make it an absolute move
}
}
else
{
dprintf(("i8042prt: ERROR querying mouse capabilities from VMMDev."
}
}
} // close scope
// VBOX end
//
// Pack the data on to the class driver
//
//
// Reset the state
//
break;
}
case MouseExpectingACK: {
//
// This is a special case. We hit this on one of the very
// first mouse interrupts following the IoConnectInterrupt.
// The interrupt is caused when we enable mouse transmissions
// via I8xMouseEnableTransmission() -- the hardware returns
// an ACK. Just toss this byte away, and set the input state
// to coincide with the start of a new mouse data packet.
//
I8xPrint((
1,
"I8042PRT-I8042MouseInterruptService: expecting ACK (0x%x), got 0x%x\n",
(ULONG) ACKNOWLEDGE,
));
//
// Resend the "Enable Mouse Transmission" sequence.
//
// NOTE: This is a hack for the Olivetti MIPS machine,
// which sends a resend response if a key is held down
// while we're attempting the I8xMouseEnableTransmission.
//
(CCHAR) CommandPort,
);
);
}
break;
}
default: {
I8xPrint((
3,
"I8042PRT-I8042MouseInterruptService: INVALID STATE\n"
));
//
// Queue a DPC to log an internal driver error.
//
);
break;
}
}
return(TRUE);
}
)
/*++
Routine Description:
This implements logitech's method for detecting the number of
mouse buttons. If anything doesn't go as expected then 0
is returned.
Calling this routine will set the mouse resolution to something
really low. The mouse resolution should be reset after this
call.
Arguments:
DeviceObject - Supplies the device object.
NumberOfMouseButtons - Returns the number of mouse buttons or 0 if
the device did not support this type of
mouse button detection.
Return Value:
An NTSTATUS code indicating success or failure.
--*/
{
ULONG i;
if (!NT_SUCCESS(status)) {
return status;
}
(UCHAR) 0x00);
if (!NT_SUCCESS(status)) {
return status;
}
for (i = 0; i < 3; i++) {
if (!NT_SUCCESS(status)) {
return status;
}
}
if (!NT_SUCCESS(status)) {
return status;
}
&byte);
if (!NT_SUCCESS(status)) {
return status;
}
&buttons);
if (!NT_SUCCESS(status)) {
return status;
}
&byte);
if (!NT_SUCCESS(status)) {
return status;
}
} else {
*NumberOfMouseButtons = 0;
}
return status;
}
)
/*++
Routine Description:
This routine initializes the i8042 mouse hardware. It is called
only at initialization, and does not synchronize access to the hardware.
Arguments:
DeviceObject - Pointer to the device object.
Return Value:
Returns status.
--*/
{
ULONG i;
#define DUMP_COUNT 4
for (i = 0; i < DUMP_COUNT; i++)
dumpData[i] = 0;
//
// Get the device extension.
//
//
// Reset the mouse. Send a Write To Auxiliary Device command to the
// 8042 controller. Then send the Reset Mouse command to the mouse
// through the 8042 data register. Expect to get back an ACK, followed
// by a completion code and the ID code (0x00).
//
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed mouse reset, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
//
// Get the mouse reset responses. The first response should be a
// MOUSE_COMPLETE. The second response should be the mouse ID.
// Note that it is usually necessary to stall a long time to get the
// experimentation.
//
//
for (i = 0; i < 11200; i++) {
&byte
);
//
// The reset completed successfully.
//
break;
} else {
//
// Stall, and then try again to get a response from
// the reset.
//
if (status == STATUS_IO_TIMEOUT) {
//
// Stall, and then try again to get a response from
// the reset.
//
} else {
break;
}
}
}
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed reset response 1, status 0x%x, byte 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
&byte
);
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed reset response 2, status 0x%x, byte 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
//
// Check to see if this is a wheel mouse
//
//
// Try to detect the number of mouse buttons.
//
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed to get buttons, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 3;
goto I8xInitializeMouseExit;
} else if (numButtons) {
}
//
// Set mouse sampling rate. Send a Write To Auxiliary Device command
// to the 8042 controller. Then send the Set Mouse Sampling Rate
// command to the mouse through the 8042 data register,
// followed by its parameter.
//
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed write set sample rate, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed write sample rate, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
//
// Set the mouse resolution. Send a Write To Auxiliary Device command
// to the 8042 controller. Then send the Set Mouse Resolution
// command to the mouse through the 8042 data register,
// followed by its parameter.
//
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed write set resolution, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xInitializeMouse: failed set mouse resolution, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
goto I8xInitializeMouseExit;
}
if (!NT_SUCCESS(status)) {
//
// The mouse initialization failed. Log an error.
//
if (errorCode != STATUS_SUCCESS) {
(UCHAR) (sizeof(IO_ERROR_LOG_PACKET)
);
if (errorLogEntry != NULL) {
errorLogEntry->SequenceNumber = 0;
errorLogEntry->IoControlCode = 0;
errorLogEntry->RetryCount = 0;
for (i = 0; i < dumpCount; i++)
}
}
}
//
// Initialize current mouse input packet state.
//
return(status);
}
)
/*++
Routine Description:
This routine retrieves the configuration information for the mouse.
Arguments:
InitializationData - Pointer to the temporary device extension and some
additional configuration information
RegistryPath - Pointer to the null-terminated Unicode name of the
registry path for this driver.
KeyboardDeviceName - Pointer to the Unicode string that will receive
the keyboard port device name.
PointerDeviceName - Pointer to the Unicode string that will receive
the pointer port device name.
Return Value:
None. As a side-effect, may set DeviceExtension->HardwarePresent.
--*/
{
ULONG i;
for (i = 0; i < MaximumInterfaceType; i++) {
//
// Get the registry information for this device.
//
interfaceType = i;
NULL,
NULL,
NULL,
//
// If we didn't already get these when determining the keyboard
// configuration, get the service parameters now (e.g.,
// user-configurable number of resends, polling iterations, etc.).
//
);
//
// Initialize mouse-specific configuration parameters.
//
break;
} else {
I8xPrint((
1,
"I8042PRT-I8xMouseConfiguration: IoQueryDeviceDescription for bus type %d failed\n",
));
}
}
}
)
/*++
Routine Description:
This routine sends an Enable command to the mouse hardware, causing
the mouse to begin transmissions. It is called at initialization
time, but only after the interrupt has been connected. This is
necessary so the driver can keep its notion of the mouse input data
state in sync with the hardware (i.e., for this type of mouse there is no
way to differentiate the first byte of a packet; if the user is randomly
moving the mouse during boot/initialization, the first mouse interrupt we
receive following IoConnectInterrupt could be for a byte that is not the
start of a packet, and we have no way to know that).
Arguments:
DeviceObject - Pointer to the device object.
Return Value:
Returns status.
--*/
{
ULONG i;
#define DUMP_COUNT 4
for (i = 0; i < DUMP_COUNT; i++)
dumpData[i] = 0;
//
// Get the device extension.
//
//
// Re-enable the mouse at the mouse hardware, so that it can transmit
// data packets in continuous mode. Note that this is not the same
// as enabling the mouse device at the 8042 controller. The mouse
// hardware is sent an Enable command here, because it was
// Disabled as a result of the mouse reset command performed
// in I8xInitializeMouse().
//
// Note that we don't wait for an ACKNOWLEDGE back. The
// ACKNOWLEDGE back will actually cause a mouse interrupt, which
// then gets handled in the mouse ISR.
//
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xMouseEnableTransmission: failed write enable transmission, status 0x%x\n",
));
//
// Set up error log info.
//
dumpCount = 4;
}
return(status);
}
)
/*++
Routine Description:
This is the callout routine sent as a parameter to
IoQueryDeviceDescription. It grabs the pointer controller and
peripheral configuration information.
Arguments:
Context - Context parameter that was passed in by the routine
that called IoQueryDeviceDescription.
PathName - The full pathname for the registry key.
BusType - Bus interface type (Isa, Eisa, Mca, etc.).
BusNumber - The bus sub-key (0, 1, etc.).
BusInformation - Pointer to the array of pointers to the full value
information for the bus.
ControllerType - The controller type (should be PointerController).
ControllerNumber - The controller sub-key (0, 1, etc.).
ControllerInformation - Pointer to the array of pointers to the full
value information for the controller key.
PeripheralType - The peripheral type (should be PointerPeripheral).
PeripheralNumber - The peripheral sub-key.
PeripheralInformation - Pointer to the array of pointers to the full
value information for the peripheral key.
Return Value:
None. If successful, will have the following side-effects:
- Sets DeviceObject->DeviceExtension->HardwarePresent.
- Sets configuration fields in
DeviceObject->DeviceExtension->Configuration.
--*/
{
ULONG i;
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Path @ 0x%x, Bus Type 0x%x, Bus Number 0x%x\n",
));
I8xPrint((
1,
" Controller Type 0x%x, Controller Number 0x%x, Controller info @ 0x%x\n",
));
I8xPrint((
1,
" Peripheral Type 0x%x, Peripheral Number 0x%x, Peripheral info @ 0x%x\n",
));
//
// Get the length of the peripheral identifier information.
//
//
// If we already have the configuration information for the
// pointer peripheral, or if the peripheral identifier is missing,
// just return.
//
|| (unicodeIdentifier.Length == 0)) {
return (status);
}
//
// Get the identifier information for the peripheral.
//
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Mouse type %ws\n",
//
// Verify that this is an i8042 mouse.
//
);
if (!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Could not convert identifier to Ansi\n"
));
return(status);
}
//
// There is a mouse on the i8042 controller.
//
}
return(status);
}
//
// If we don't already have the bus information as the result
// of the keyboard configuration, grab it now.
//
}
} else {
}
//
// Look through the controller's resource list for interrupt
// and (possibly) port configuration information.
//
for (i = 0; i < listCount; i++, resourceDescriptor++) {
switch(resourceDescriptor->Type) {
case CmResourceTypePort:
if (portInfoNeeded) {
//
// If we don't already have the port information as
// a result of the keyboard configuration, copy it
// to the port list.
//
}
break;
case CmResourceTypeInterrupt:
//
// Copy the interrupt information.
//
break;
default:
break;
}
}
}
//
// If no interrupt configuration information was found, use the
// mouse driver defaults.
//
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Using default mouse interrupt config\n"
));
}
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Mouse interrupt config --\n"
));
I8xPrint((
1,
"%s, %s, Irq = %d\n",
"Sharable" : "NonSharable",
"Latched" : "Level Sensitive",
));
//
// If no port configuration information was found, use the
// mouse driver defaults.
//
if (configuration->PortListCount == 0) {
//
// No port configuration information was found, so use
// the driver defaults.
//
I8xPrint((
1,
"I8042PRT-I8xMousePeripheralCallout: Using default port config\n"
));
//
// Kludge for Jazz machines. Their ARC firmware neglects to
// separate out the port addresses, so fix that up here.
//
} else {
//
// Put the lowest port address range in the DataPort element of
// the port list.
//
}
}
#ifdef PNP_IDENTIFY
//
// In any event we're going to use the pointer based on this data,
// so make sure we can tell PNP that we've claimed it later on
//
#endif
for (i = 0; i < configuration->PortListCount; i++) {
I8xPrint((
1,
" %s, Ports 0x%x - 0x%x\n",
));
}
return(status);
}
)
/*++
Routine Description:
This routine determines if the mouse is a Zoom mouse. The method
of detection is to set the sample rate to 200Hz, then 100Hz, then 80Hz
and then read the device ID. An ID of 3 indicates a zoom mouse.
If the registry entry "EnableWheelDetection" is false then this
routine will just return STATUS_NO_SUCH_DEVICE.
Arguments:
DeviceObject - Pointer to the device object
Return Value:
Returns status
Remarks:
As a side effect the sample rate is left at 80Hz and if a wheelmouse is
attached it is in the wheel mode where packets are different.
--*/
{
ULONG i;
#define DUMP_COUNT 4
SET_MOUSE_SAMPLING_RATE, 100,
GET_DEVICE_ID, 0 // NULL terminate
};
UCHAR commandCount = 0;
I8xPrint((1,
"I8042PRT-I8xFindWheelMouse: Detection disabled in registry\n"
));
return STATUS_NO_SUCH_DEVICE;
}
for(i = 0; i < DUMP_COUNT; i++)
dumpData[i] = 0;
while(ucCommands[commandCount] != 0) {
);
if(!NT_SUCCESS(status)) {
I8xPrint((
1,
"I8042PRT-I8xFindWheelMouse: failed write set sample rate, status 0x%x\n",
));
//
// Set up error log info
//
dumpCount = 4;
goto I8xFindWheelMouseExit;
}
commandCount++;
uniqueErrorValue += 5;
}
//
// Get the mouse ID
//
for(i = 0; i < 5; i++) {
&byte
);
if(NT_SUCCESS(status)) {
//
// Read was successful - the ID has been returned
break;
}
//
// If the read timed out, stall and retry.
// If some other error occurred handle it outside the loop
//
if(status == STATUS_IO_TIMEOUT) {
} else {
break;
}
}
if((!NT_SUCCESS(status)) ||
I8xPrint((
1,
"I8042PRT-I8xFindWheelMouse: failed ID, status 0x%x, byte 0x%x\n",
));
//
// Set up error log info
//
dumpCount = 4;
goto I8xFindWheelMouseExit;
} else if( byte == WHEELMOUSE_ID_BYTE) {
//
// Update the HardwarePresent to show a Z mouse is operational,
// and set the appropriate mouse type flags
//
// deviceExtension->MouseExtension.MsData.MouseType |=
// (DT_Z_MOUSE | DT_MOUSE);
I8xPrint((
1,
"I8042PRT-I8xFindWheelMouse: wheel mouse attached - running in wheel mode.\n"
));
} else {
I8xPrint((
1,
"I8042PRT-I8xFindWheelMouse: Mouse attached - running in mouse mode.\n"
));
}
if (!NT_SUCCESS(status)) {
//
// The mouse initialization failed. Log an error.
//
if(errorCode != STATUS_SUCCESS) {
(UCHAR) (sizeof(IO_ERROR_LOG_PACKET) +
);
if(errorLogEntry != NULL) {
errorLogEntry->SequenceNumber = 0;
errorLogEntry->IoControlCode = 0;
errorLogEntry->RetryCount = 0;
for(i = 0; i < dumpCount; i++) {
}
}
}
}
//
// Initialize current mouse input packet state
//
return status;
}
)
/*++
Routine Description:
This routine queues the current input data to be processed by a
DPC outside the ISR
Arguments:
DeviceObject - Pointer to the device object
Return Value:
None
--*/
{
#if 0 /* bird: unused */
#endif
//
// If the mouse is enabled, add the data to the InputData queue
// and queue the ISR DPC. One might wonder why we bother to
// do all this processing of the mouse packet, only to toss it
// away (i.e., not queue it) at this point. The answer is that
// this mouse provides no data to allow the driver to determine
// when the first byte of a packet is received -- if the driver
// doesn't process all interrupts from the start, there is no
// way to keep MouseExtension.InputState in synch with hardware
// reality.
//
if (deviceExtension->MouseEnableCount) {
if (!I8xWriteDataToMouseQueue(
)) {
//
// InputData queue overflowed.
//
// Queue a DPC to log an overrun error.
//
I8xPrint((
1,
"I8042PRT-I8042MouseInterruptService: queue overflow\n"
));
);
}
} else if (deviceExtension->DpcInterlockMouse >= 0) {
//
// The ISR DPC is already executing. Tell the ISR DPC it has
// more work to do by incrementing DpcInterlockMouse.
//
} else {
//
// Queue the ISR DPC.
//
);
}
}
return;
}