415 lines
13 KiB
C
415 lines
13 KiB
C
|
/*++
|
|||
|
|
|
|||
|
|
Copyright (c) 1990-1998 Microsoft Corporation, All Rights Reserved
|
|||
|
|
|
|||
|
|
Module Name:
|
|||
|
|
|
|||
|
|
moucmn.c
|
|||
|
|
|
|||
|
|
Abstract:
|
|||
|
|
|
|||
|
|
The common portions of the Intel i8042 port driver which
|
|||
|
|
apply 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:
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
|
|||
|
|
#include "stdarg.h"
|
|||
|
|
#include "stdio.h"
|
|||
|
|
#include "string.h"
|
|||
|
|
#include "i8042prt.h"
|
|||
|
|
|
|||
|
|
#ifdef ALLOC_PRAGMA
|
|||
|
|
|
|||
|
|
#if 1
|
|||
|
|
#pragma alloc_text(PAGEMOUC, I8042MouseIsrDpc)
|
|||
|
|
#pragma alloc_text(PAGEMOUC, I8xWriteDataToMouseQueue)
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
VOID
|
|||
|
|
I8042MouseIsrDpc(
|
|||
|
|
IN PKDPC Dpc,
|
|||
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|||
|
|
IN PIRP Irp,
|
|||
|
|
IN PVOID Context
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
This routine runs at DISPATCH_LEVEL IRQL to finish processing
|
|||
|
|
mouse interrupts. It is queued in the mouse ISR. The real
|
|||
|
|
work is done via a callback to the connected mouse class driver.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
Dpc - Pointer to the DPC object.
|
|||
|
|
|
|||
|
|
DeviceObject - Pointer to the device object.
|
|||
|
|
|
|||
|
|
Irp - Pointer to the Irp.
|
|||
|
|
|
|||
|
|
Context - Not used.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
None.
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
|
|||
|
|
{
|
|||
|
|
PPORT_MOUSE_EXTENSION deviceExtension;
|
|||
|
|
GET_DATA_POINTER_CONTEXT getPointerContext;
|
|||
|
|
SET_DATA_POINTER_CONTEXT setPointerContext;
|
|||
|
|
VARIABLE_OPERATION_CONTEXT operationContext;
|
|||
|
|
PVOID classService;
|
|||
|
|
PVOID classDeviceObject;
|
|||
|
|
LONG interlockedResult;
|
|||
|
|
BOOLEAN moreDpcProcessing;
|
|||
|
|
ULONG dataNotConsumed = 0;
|
|||
|
|
ULONG inputDataConsumed = 0;
|
|||
|
|
LARGE_INTEGER deltaTime;
|
|||
|
|
|
|||
|
|
UNREFERENCED_PARAMETER(Dpc);
|
|||
|
|
UNREFERENCED_PARAMETER(Irp);
|
|||
|
|
UNREFERENCED_PARAMETER(Context);
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_TRACE, ("I8042MouseIsrDpc: enter\n"));
|
|||
|
|
|
|||
|
|
deviceExtension = (PPORT_MOUSE_EXTENSION) DeviceObject->DeviceExtension;
|
|||
|
|
//
|
|||
|
|
// Use DpcInterlockMouse to determine whether the DPC is running
|
|||
|
|
// concurrently on another processor. We only want one instantiation
|
|||
|
|
// of the DPC to actually do any work. DpcInterlockMouse is -1
|
|||
|
|
// when no DPC is executing. We increment it, and if the result is
|
|||
|
|
// zero then the current instantiation is the only one executing, and it
|
|||
|
|
// is okay to proceed. Otherwise, we just return.
|
|||
|
|
//
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
operationContext.VariableAddress =
|
|||
|
|
&deviceExtension->DpcInterlockMouse;
|
|||
|
|
operationContext.Operation = IncrementOperation;
|
|||
|
|
operationContext.NewValue = &interlockedResult;
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xDpcVariableOperation,
|
|||
|
|
(PVOID) &operationContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
moreDpcProcessing = (interlockedResult == 0)? TRUE:FALSE;
|
|||
|
|
|
|||
|
|
while (moreDpcProcessing) {
|
|||
|
|
|
|||
|
|
dataNotConsumed = 0;
|
|||
|
|
inputDataConsumed = 0;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Get the port InputData queue pointers synchronously.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
getPointerContext.DeviceExtension = deviceExtension;
|
|||
|
|
setPointerContext.DeviceExtension = deviceExtension;
|
|||
|
|
getPointerContext.DeviceType = (CCHAR) MouseDeviceType;
|
|||
|
|
setPointerContext.DeviceType = (CCHAR) MouseDeviceType;
|
|||
|
|
setPointerContext.InputCount = 0;
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xGetDataQueuePointer,
|
|||
|
|
(PVOID) &getPointerContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
if (getPointerContext.InputCount != 0) {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Call the connected class driver's callback ISR with the
|
|||
|
|
// port InputData queue pointers. If we have to wrap the queue,
|
|||
|
|
// break the operation into two pieces, and call the class callback
|
|||
|
|
// ISR once for each piece.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
classDeviceObject =
|
|||
|
|
deviceExtension->ConnectData.ClassDeviceObject;
|
|||
|
|
classService =
|
|||
|
|
deviceExtension->ConnectData.ClassService;
|
|||
|
|
ASSERT(classService != NULL);
|
|||
|
|
|
|||
|
|
if (getPointerContext.DataOut >= getPointerContext.DataIn) {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// We'll have to wrap the InputData circular buffer. Call
|
|||
|
|
// the class callback ISR with the chunk of data starting at
|
|||
|
|
// DataOut and ending at the end of the queue.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_NOISE,
|
|||
|
|
("I8042MouseIsrDpc: calling class callback\n"
|
|||
|
|
));
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8042MouseIsrDpc: with Start 0x%x and End 0x%x\n",
|
|||
|
|
getPointerContext.DataOut,
|
|||
|
|
deviceExtension->DataEnd
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
(*(PSERVICE_CALLBACK_ROUTINE) classService)(
|
|||
|
|
classDeviceObject,
|
|||
|
|
getPointerContext.DataOut,
|
|||
|
|
deviceExtension->DataEnd,
|
|||
|
|
&inputDataConsumed
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
dataNotConsumed = ((ULONG)((PUCHAR)
|
|||
|
|
deviceExtension->DataEnd -
|
|||
|
|
(PUCHAR) getPointerContext.DataOut)
|
|||
|
|
/ sizeof(MOUSE_INPUT_DATA)) - inputDataConsumed;
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8042MouseIsrDpc: (Wrap) Call callback consumed %d items, left %d\n",
|
|||
|
|
inputDataConsumed,
|
|||
|
|
dataNotConsumed
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
setPointerContext.InputCount += inputDataConsumed;
|
|||
|
|
|
|||
|
|
if (dataNotConsumed) {
|
|||
|
|
setPointerContext.DataOut =
|
|||
|
|
((PUCHAR)getPointerContext.DataOut) +
|
|||
|
|
(inputDataConsumed * sizeof(MOUSE_INPUT_DATA));
|
|||
|
|
} else {
|
|||
|
|
setPointerContext.DataOut =
|
|||
|
|
deviceExtension->InputData;
|
|||
|
|
getPointerContext.DataOut = setPointerContext.DataOut;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Call the class callback ISR with data remaining in the queue.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if ((dataNotConsumed == 0) &&
|
|||
|
|
(inputDataConsumed < getPointerContext.InputCount)){
|
|||
|
|
Print(DBG_DPC_NOISE,
|
|||
|
|
("I8042MouseIsrDpc: calling class callback\n"
|
|||
|
|
));
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8042MouseIsrDpc: with Start 0x%x and End 0x%x\n",
|
|||
|
|
getPointerContext.DataOut,
|
|||
|
|
getPointerContext.DataIn
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
(*(PSERVICE_CALLBACK_ROUTINE) classService)(
|
|||
|
|
classDeviceObject,
|
|||
|
|
getPointerContext.DataOut,
|
|||
|
|
getPointerContext.DataIn,
|
|||
|
|
&inputDataConsumed
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
dataNotConsumed = ((ULONG)((PUCHAR) getPointerContext.DataIn -
|
|||
|
|
(PUCHAR) getPointerContext.DataOut)
|
|||
|
|
/ sizeof(MOUSE_INPUT_DATA)) - inputDataConsumed;
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8042MouseIsrDpc: Call callback consumed %d items, left %d\n",
|
|||
|
|
inputDataConsumed,
|
|||
|
|
dataNotConsumed
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
setPointerContext.DataOut =
|
|||
|
|
((PUCHAR)getPointerContext.DataOut) +
|
|||
|
|
(inputDataConsumed * sizeof(MOUSE_INPUT_DATA));
|
|||
|
|
setPointerContext.InputCount += inputDataConsumed;
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Update the port InputData queue DataOut pointer and InputCount
|
|||
|
|
// synchronously.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xSetDataQueuePointer,
|
|||
|
|
(PVOID) &setPointerContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (dataNotConsumed) {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The class driver was unable to consume all the data.
|
|||
|
|
// Reset the interlocked variable to -1. We do not want
|
|||
|
|
// to attempt to move more data to the class driver at this
|
|||
|
|
// point, because it is already overloaded. Need to wait a
|
|||
|
|
// while to give the Raw Input Thread a chance to read some
|
|||
|
|
// of the data out of the class driver's queue. We accomplish
|
|||
|
|
// this "wait" via a timer.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8042MouseIsrDpc: set timer in DPC\n"
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
operationContext.Operation = WriteOperation;
|
|||
|
|
interlockedResult = -1;
|
|||
|
|
operationContext.NewValue = &interlockedResult;
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xDpcVariableOperation,
|
|||
|
|
(PVOID) &operationContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
deltaTime.LowPart = (ULONG)(-10 * 1000 * 1000);
|
|||
|
|
deltaTime.HighPart = -1;
|
|||
|
|
|
|||
|
|
(VOID) KeSetTimer(
|
|||
|
|
&deviceExtension->DataConsumptionTimer,
|
|||
|
|
deltaTime,
|
|||
|
|
&deviceExtension->MouseIsrDpcRetry
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
moreDpcProcessing = FALSE;
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Decrement DpcInterlockMouse. If the result goes negative,
|
|||
|
|
// then we're all finished processing the DPC. Otherwise, either
|
|||
|
|
// the ISR incremented DpcInterlockMouse because it has more
|
|||
|
|
// work for the ISR DPC to do, or a concurrent DPC executed on
|
|||
|
|
// some processor while the current DPC was running (the
|
|||
|
|
// concurrent DPC wouldn't have done any work). Make sure that
|
|||
|
|
// the current DPC handles any extra work that is ready to be
|
|||
|
|
// done.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
operationContext.Operation = DecrementOperation;
|
|||
|
|
operationContext.NewValue = &interlockedResult;
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xDpcVariableOperation,
|
|||
|
|
(PVOID) &operationContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
if (interlockedResult != -1) {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The interlocked variable is still greater than or equal to
|
|||
|
|
// zero. Reset it to zero, so that we execute the loop one
|
|||
|
|
// more time (assuming no more DPCs execute and bump the
|
|||
|
|
// variable up again).
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
operationContext.Operation = WriteOperation;
|
|||
|
|
interlockedResult = 0;
|
|||
|
|
operationContext.NewValue = &interlockedResult;
|
|||
|
|
|
|||
|
|
KeSynchronizeExecution(
|
|||
|
|
deviceExtension->InterruptObject,
|
|||
|
|
(PKSYNCHRONIZE_ROUTINE) I8xDpcVariableOperation,
|
|||
|
|
(PVOID) &operationContext
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_INFO, ("I8042MouseIsrDpc: loop in DPC\n"));
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
moreDpcProcessing = FALSE;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_TRACE, ("I8042MouseIsrDpc: exit\n"));
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
BOOLEAN
|
|||
|
|
I8xWriteDataToMouseQueue(
|
|||
|
|
PPORT_MOUSE_EXTENSION MouseExtension,
|
|||
|
|
IN PMOUSE_INPUT_DATA InputData
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
This routine adds input data from the mouse to the InputData queue.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
MouseExtension - Pointer to the mouse portion of the device extension.
|
|||
|
|
|
|||
|
|
InputData - Pointer to the data to add to the InputData queue.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
Returns TRUE if the data was added, otherwise FALSE.
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
Print(DBG_CALL_TRACE, ("I8xWriteDataToMouseQueue: enter\n"));
|
|||
|
|
Print(DBG_CALL_NOISE,
|
|||
|
|
("I8xWriteDataToMouseQueue: DataIn 0x%x, DataOut 0x%x\n",
|
|||
|
|
MouseExtension->DataIn,
|
|||
|
|
MouseExtension->DataOut
|
|||
|
|
));
|
|||
|
|
Print(DBG_CALL_NOISE,
|
|||
|
|
("I8xWriteDataToMouseQueue: InputCount %d\n",
|
|||
|
|
MouseExtension->InputCount
|
|||
|
|
));
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Check for full input data queue.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if ((MouseExtension->DataIn == MouseExtension->DataOut) &&
|
|||
|
|
(MouseExtension->InputCount != 0)) {
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The input data queue is full. Intentionally ignore
|
|||
|
|
// the new data.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
Print(DBG_CALL_ERROR, ("I8xWriteDataToMouseQueue: OVERFLOW\n"));
|
|||
|
|
return(FALSE);
|
|||
|
|
|
|||
|
|
} else {
|
|||
|
|
*(MouseExtension->DataIn) = *InputData;
|
|||
|
|
MouseExtension->InputCount += 1;
|
|||
|
|
MouseExtension->DataIn++;
|
|||
|
|
Print(DBG_DPC_INFO,
|
|||
|
|
("I8xWriteDataToMouseQueue: new InputCount %d\n",
|
|||
|
|
MouseExtension->InputCount
|
|||
|
|
));
|
|||
|
|
if (MouseExtension->DataIn == MouseExtension->DataEnd) {
|
|||
|
|
Print(DBG_DPC_NOISE, ("I8xWriteDataToMouseQueue: wrap buffer\n"));
|
|||
|
|
MouseExtension->DataIn = MouseExtension->InputData;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Print(DBG_DPC_TRACE, ("I8xWriteDataToMouseQueue: exit\n"));
|
|||
|
|
|
|||
|
|
return(TRUE);
|
|||
|
|
}
|