--- /dev/null
+/*
+ * PROJECT: ReactOS i8042 (ps/2 keyboard-mouse controller) driver
+ * LICENSE: GPL - See COPYING in the top level directory
+ * FILE: drivers/input/i8042prt/mouse.c
+ * PURPOSE: Mouse specific functions
+ * PROGRAMMERS: Copyright Victor Kirhenshtein (sauros@iname.com)
+ Copyright Jason Filby (jasonfilby@yahoo.com)
+ Copyright Martijn Vernooij (o112w8r02@sneakemail.com)
+ Copyright 2006-2007 Hervé Poussineau (hpoussin@reactos.org)
+ Copyright 2008 Colin Finck (mail@colinfinck.de)
+ */
+
+/* INCLUDES ****************************************************************/
+
+#include "i8042prt.h"
+
+#include <debug.h>
+
+/* FUNCTIONS *****************************************************************/
+
+static KDEFERRED_ROUTINE i8042MouDpcRoutine;
+static KDEFERRED_ROUTINE i8042DpcRoutineMouseTimeout;
+
+/*
+ * These functions are callbacks for filter driver custom interrupt
+ * service routines.
+ */
+static VOID NTAPI
+i8042MouIsrWritePort(
+ IN PVOID Context,
+ IN UCHAR Value)
+{
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+
+ DeviceExtension = (PI8042_MOUSE_EXTENSION)Context;
+
+ if (DeviceExtension->MouseHook.IsrWritePort != i8042MouIsrWritePort)
+ {
+ DeviceExtension->MouseHook.IsrWritePort(
+ DeviceExtension->MouseHook.CallContext,
+ Value);
+ }
+ else
+ i8042IsrWritePort(DeviceExtension->Common.PortDeviceExtension, Value, CTRL_WRITE_MOUSE);
+}
+
+static VOID NTAPI
+i8042MouQueuePacket(
+ IN PVOID Context)
+{
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+
+ DeviceExtension = (PI8042_MOUSE_EXTENSION)Context;
+
+ DeviceExtension->MouseComplete = TRUE;
+ DeviceExtension->MouseInBuffer++;
+ if (DeviceExtension->MouseInBuffer >= DeviceExtension->Common.PortDeviceExtension->Settings.MouseDataQueueSize)
+ {
+ WARN_(I8042PRT, "Mouse buffer overflow\n");
+ DeviceExtension->MouseInBuffer--;
+ }
+
+ TRACE_(I8042PRT, "Irq completes mouse packet\n");
+ KeInsertQueueDpc(&DeviceExtension->DpcMouse, NULL, NULL);
+}
+
+VOID
+i8042MouHandle(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension,
+ IN UCHAR Output)
+{
+ PMOUSE_INPUT_DATA MouseInput;
+ CHAR Scroll;
+
+ MouseInput = DeviceExtension->MouseBuffer + DeviceExtension->MouseInBuffer;
+
+ switch (DeviceExtension->MouseState)
+ {
+ case MouseIdle:
+ /* This bit should be 1, if not drop the packet, we
+ * might be lucky and get in sync again
+ */
+ if (!(Output & 8)) {
+ WARN_(I8042PRT, "Bad input, dropping..\n");
+ return;
+ }
+
+ MouseInput->Buttons = 0;
+ MouseInput->RawButtons = 0;
+ MouseInput->Flags = MOUSE_MOVE_RELATIVE;
+
+ /* Note how we ignore the overflow bits, like Windows
+ * is said to do. There's no reasonable thing to do
+ * anyway.
+ */
+
+ if (Output & 16)
+ MouseInput->LastX = 1;
+ else
+ MouseInput->LastX = 0;
+ if (Output & 32)
+ MouseInput->LastY = 1;
+ else
+ MouseInput->LastY = 0;
+
+ if (Output & 1)
+ MouseInput->RawButtons |= MOUSE_LEFT_BUTTON_DOWN;
+ if (Output & 2)
+ MouseInput->RawButtons |= MOUSE_RIGHT_BUTTON_DOWN;
+ if (Output & 4)
+ MouseInput->RawButtons |= MOUSE_MIDDLE_BUTTON_DOWN;
+
+ DeviceExtension->MouseState = XMovement;
+ break;
+
+ case XMovement:
+ if (MouseInput->LastX)
+ MouseInput->LastX = (LONG) Output - 256;
+ else
+ MouseInput->LastX = Output;
+
+ DeviceExtension->MouseState = YMovement;
+ break;
+
+ case YMovement:
+ if (MouseInput->LastY)
+ MouseInput->LastY = (LONG)Output - 256;
+ else
+ MouseInput->LastY = (LONG)Output;
+
+ /* Windows wants it the other way around */
+ MouseInput->LastY = -MouseInput->LastY;
+
+ if (DeviceExtension->MouseType == GenericPS2 ||
+ DeviceExtension->MouseType == Ps2pp)
+ {
+ i8042MouHandleButtons(
+ DeviceExtension,
+ MOUSE_LEFT_BUTTON_DOWN |
+ MOUSE_RIGHT_BUTTON_DOWN |
+ MOUSE_MIDDLE_BUTTON_DOWN);
+ DeviceExtension->MouseHook.QueueMousePacket(DeviceExtension->MouseHook.CallContext);
+ DeviceExtension->MouseState = MouseIdle;
+ }
+ else
+ {
+ DeviceExtension->MouseState = ZMovement;
+ }
+ break;
+
+ case ZMovement:
+ Scroll = Output & 0x0f;
+ if (Scroll & 8)
+ Scroll |= 0xf0;
+
+ if (Scroll)
+ {
+ MouseInput->RawButtons |= MOUSE_WHEEL;
+ MouseInput->ButtonData = (USHORT)(Scroll * -WHEEL_DELTA);
+ }
+
+ if (DeviceExtension->MouseType == IntellimouseExplorer)
+ {
+ if (Output & 16)
+ MouseInput->RawButtons |= MOUSE_BUTTON_4_DOWN;
+ if (Output & 32)
+ MouseInput->RawButtons |= MOUSE_BUTTON_5_DOWN;
+ }
+ i8042MouHandleButtons(
+ DeviceExtension,
+ MOUSE_LEFT_BUTTON_DOWN |
+ MOUSE_RIGHT_BUTTON_DOWN |
+ MOUSE_MIDDLE_BUTTON_DOWN |
+ MOUSE_BUTTON_4_DOWN |
+ MOUSE_BUTTON_5_DOWN);
+ DeviceExtension->MouseHook.QueueMousePacket(DeviceExtension->MouseHook.CallContext);
+ DeviceExtension->MouseState = MouseIdle;
+ break;
+
+ default:
+ ERR_(I8042PRT, "Unexpected state 0x%lx!\n", DeviceExtension->MouseState);
+ ASSERT(FALSE);
+ }
+}
+
+/*
+ * Updates ButtonFlags according to RawButtons and a saved state;
+ * Only takes in account the bits that are set in Mask
+ */
+VOID
+i8042MouHandleButtons(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension,
+ IN USHORT Mask)
+{
+ PMOUSE_INPUT_DATA MouseInput;
+ USHORT NewButtonData;
+ USHORT ButtonDiff;
+
+ MouseInput = DeviceExtension->MouseBuffer + DeviceExtension->MouseInBuffer;
+ NewButtonData = (USHORT)(MouseInput->RawButtons & Mask);
+ ButtonDiff = (NewButtonData ^ DeviceExtension->MouseButtonState) & Mask;
+
+ /* Note that the defines are such:
+ * MOUSE_LEFT_BUTTON_DOWN 1
+ * MOUSE_LEFT_BUTTON_UP 2
+ */
+ MouseInput->ButtonFlags |= (NewButtonData & ButtonDiff) |
+ (((~(NewButtonData)) << 1) & (ButtonDiff << 1)) |
+ (MouseInput->RawButtons & 0xfc00);
+
+ INFO_(I8042PRT, "Left raw/up/down: %u/%u/%u\n",
+ MouseInput->RawButtons & MOUSE_LEFT_BUTTON_DOWN,
+ MouseInput->ButtonFlags & MOUSE_LEFT_BUTTON_DOWN,
+ MouseInput->ButtonFlags & MOUSE_LEFT_BUTTON_UP);
+
+ DeviceExtension->MouseButtonState =
+ (DeviceExtension->MouseButtonState & ~Mask) | (NewButtonData & Mask);
+}
+
+/* Does final initializations for the mouse. This method
+ * is called just before connecting the interrupt.
+ */
+NTSTATUS
+i8042MouInitialize(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension)
+{
+ NTSTATUS Status;
+ UCHAR Value;
+
+ /* Enable the PS/2 mouse port */
+ i8042Write(DeviceExtension->Common.PortDeviceExtension, DeviceExtension->Common.PortDeviceExtension->ControlPort, MOUSE_ENAB);
+
+ /* Enable the mouse */
+ if(!i8042IsrWritePort(DeviceExtension->Common.PortDeviceExtension, MOU_ENAB, CTRL_WRITE_MOUSE))
+ {
+ WARN_(I8042PRT, "Failed to enable mouse!\n");
+ return STATUS_IO_DEVICE_ERROR;
+ }
+
+ Status = i8042ReadDataWait(DeviceExtension->Common.PortDeviceExtension, &Value);
+ if (!NT_SUCCESS(Status))
+ {
+ WARN_(I8042PRT, "Failed to read the response of MOU_ENAB, status 0x%08lx\n", Status);
+ return Status;
+ }
+
+ if(Value == MOUSE_ACK)
+ {
+ INFO_(I8042PRT, "Mouse was enabled successfully!\n");
+ return STATUS_SUCCESS;
+ }
+
+ WARN_(I8042PRT, "Got 0x%02x instead of 0xFA\n", Value);
+ return STATUS_IO_DEVICE_ERROR;
+}
+
+static VOID NTAPI
+i8042MouDpcRoutine(
+ IN PKDPC Dpc,
+ IN PVOID DeferredContext,
+ IN PVOID SystemArgument1,
+ IN PVOID SystemArgument2)
+{
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+ PPORT_DEVICE_EXTENSION PortDeviceExtension;
+ ULONG MouseTransferred = 0;
+ ULONG MouseInBufferCopy;
+ KIRQL Irql;
+ LARGE_INTEGER Timeout;
+
+ UNREFERENCED_PARAMETER(Dpc);
+ UNREFERENCED_PARAMETER(SystemArgument1);
+ UNREFERENCED_PARAMETER(SystemArgument2);
+
+ __analysis_assume(DeferredContext != NULL);
+ DeviceExtension = DeferredContext;
+ PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
+
+ switch (DeviceExtension->MouseTimeoutState)
+ {
+ case TimeoutStart:
+ {
+ DeviceExtension->MouseTimeoutState = NoChange;
+ if (DeviceExtension->MouseTimeoutActive &&
+ !KeCancelTimer(&DeviceExtension->TimerMouseTimeout))
+ {
+ /* The timer fired already, give up */
+ DeviceExtension->MouseTimeoutActive = FALSE;
+ return;
+ }
+
+ Timeout.QuadPart = -15000000; /* 1.5 seconds, should be enough */
+
+ KeSetTimer(
+ &DeviceExtension->TimerMouseTimeout,
+ Timeout,
+ &DeviceExtension->DpcMouseTimeout);
+ DeviceExtension->MouseTimeoutActive = TRUE;
+ return;
+ }
+
+ case TimeoutCancel:
+ {
+ DeviceExtension->MouseTimeoutState = NoChange;
+ KeCancelTimer(&DeviceExtension->TimerMouseTimeout);
+ DeviceExtension->MouseTimeoutActive = FALSE;
+ }
+
+ default:
+ ;/* nothing, don't want a warning */
+ }
+
+ /* Should be unlikely */
+ if (!DeviceExtension->MouseComplete)
+ return;
+
+ Irql = KeAcquireInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt);
+
+ DeviceExtension->MouseComplete = FALSE;
+ MouseInBufferCopy = DeviceExtension->MouseInBuffer;
+
+ KeReleaseInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt, Irql);
+
+ TRACE_(I8042PRT, "Send a mouse packet\n");
+
+ if (!DeviceExtension->MouseData.ClassService)
+ return;
+
+ INFO_(I8042PRT, "Sending %lu mouse move(s)\n", MouseInBufferCopy);
+ (*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->MouseData.ClassService)(
+ DeviceExtension->MouseData.ClassDeviceObject,
+ DeviceExtension->MouseBuffer,
+ DeviceExtension->MouseBuffer + MouseInBufferCopy,
+ &MouseTransferred);
+
+ Irql = KeAcquireInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt);
+ DeviceExtension->MouseInBuffer -= MouseTransferred;
+ if (DeviceExtension->MouseInBuffer)
+ RtlMoveMemory(
+ DeviceExtension->MouseBuffer,
+ DeviceExtension->MouseBuffer + MouseTransferred,
+ DeviceExtension->MouseInBuffer * sizeof(MOUSE_INPUT_DATA));
+ KeReleaseInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt, Irql);
+}
+
+/* This timer DPC will be called when the mouse reset times out.
+ * I'll just send the 'disable mouse port' command to the controller
+ * and say the mouse doesn't exist.
+ */
+static VOID NTAPI
+i8042DpcRoutineMouseTimeout(
+ IN PKDPC Dpc,
+ IN PVOID DeferredContext,
+ IN PVOID SystemArgument1,
+ IN PVOID SystemArgument2)
+{
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+ PPORT_DEVICE_EXTENSION PortDeviceExtension;
+ KIRQL Irql;
+
+ UNREFERENCED_PARAMETER(Dpc);
+ UNREFERENCED_PARAMETER(SystemArgument1);
+ UNREFERENCED_PARAMETER(SystemArgument2);
+
+ __analysis_assume(DeferredContext != NULL);
+ DeviceExtension = DeferredContext;
+ PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
+
+ Irql = KeAcquireInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt);
+
+ WARN_(I8042PRT, "Mouse initialization timeout! (substate %x)\n",
+ DeviceExtension->MouseResetState);
+
+ PortDeviceExtension->Flags &= ~MOUSE_PRESENT;
+
+ KeReleaseInterruptSpinLock(PortDeviceExtension->HighestDIRQLInterrupt, Irql);
+}
+
+/*
+ * Runs the mouse IOCTL_INTERNAL dispatch.
+ */
+NTSTATUS NTAPI
+i8042MouInternalDeviceControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ PIO_STACK_LOCATION Stack;
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+ NTSTATUS Status;
+
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+ Irp->IoStatus.Information = 0;
+ DeviceExtension = (PI8042_MOUSE_EXTENSION)DeviceObject->DeviceExtension;
+
+ switch (Stack->Parameters.DeviceIoControl.IoControlCode)
+ {
+ case IOCTL_INTERNAL_MOUSE_CONNECT:
+ {
+ SIZE_T Size;
+ PIO_WORKITEM WorkItem = NULL;
+ PI8042_HOOK_WORKITEM WorkItemData = NULL;
+
+ TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_INTERNAL_MOUSE_CONNECT\n");
+ if (Stack->Parameters.DeviceIoControl.InputBufferLength != sizeof(CONNECT_DATA))
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ goto cleanup;
+ }
+
+ DeviceExtension->MouseData =
+ *((PCONNECT_DATA)Stack->Parameters.DeviceIoControl.Type3InputBuffer);
+
+ /* Send IOCTL_INTERNAL_I8042_HOOK_MOUSE to device stack */
+ WorkItem = IoAllocateWorkItem(DeviceObject);
+ if (!WorkItem)
+ {
+ WARN_(I8042PRT, "IoAllocateWorkItem() failed\n");
+ Status = STATUS_INSUFFICIENT_RESOURCES;
+ goto cleanup;
+ }
+ WorkItemData = ExAllocatePoolWithTag(
+ NonPagedPool,
+ sizeof(I8042_HOOK_WORKITEM),
+ I8042PRT_TAG);
+ if (!WorkItemData)
+ {
+ WARN_(I8042PRT, "ExAllocatePoolWithTag() failed\n");
+ Status = STATUS_NO_MEMORY;
+ goto cleanup;
+ }
+ WorkItemData->WorkItem = WorkItem;
+ WorkItemData->Irp = Irp;
+
+ /* Initialize extension */
+ DeviceExtension->Common.Type = Mouse;
+ Size = DeviceExtension->Common.PortDeviceExtension->Settings.MouseDataQueueSize * sizeof(MOUSE_INPUT_DATA);
+ DeviceExtension->MouseBuffer = ExAllocatePoolWithTag(
+ NonPagedPool,
+ Size,
+ I8042PRT_TAG);
+ if (!DeviceExtension->MouseBuffer)
+ {
+ WARN_(I8042PRT, "ExAllocatePoolWithTag() failed\n");
+ Status = STATUS_NO_MEMORY;
+ goto cleanup;
+ }
+ RtlZeroMemory(DeviceExtension->MouseBuffer, Size);
+ DeviceExtension->MouseAttributes.InputDataQueueLength =
+ DeviceExtension->Common.PortDeviceExtension->Settings.MouseDataQueueSize;
+ KeInitializeDpc(
+ &DeviceExtension->DpcMouse,
+ i8042MouDpcRoutine,
+ DeviceExtension);
+ KeInitializeDpc(
+ &DeviceExtension->DpcMouseTimeout,
+ i8042DpcRoutineMouseTimeout,
+ DeviceExtension);
+ KeInitializeTimer(&DeviceExtension->TimerMouseTimeout);
+ DeviceExtension->Common.PortDeviceExtension->MouseExtension = DeviceExtension;
+ DeviceExtension->Common.PortDeviceExtension->Flags |= MOUSE_CONNECTED;
+
+ IoMarkIrpPending(Irp);
+ DeviceExtension->MouseState = MouseResetting;
+ DeviceExtension->MouseResetState = ExpectingReset;
+ DeviceExtension->MouseHook.IsrWritePort = i8042MouIsrWritePort;
+ DeviceExtension->MouseHook.QueueMousePacket = i8042MouQueuePacket;
+ DeviceExtension->MouseHook.CallContext = DeviceExtension;
+ IoQueueWorkItem(WorkItem,
+ i8042SendHookWorkItem,
+ DelayedWorkQueue,
+ WorkItemData);
+ Status = STATUS_PENDING;
+ break;
+
+cleanup:
+ if (DeviceExtension->MouseBuffer)
+ ExFreePoolWithTag(DeviceExtension->MouseBuffer, I8042PRT_TAG);
+ if (WorkItem)
+ IoFreeWorkItem(WorkItem);
+ if (WorkItemData)
+ ExFreePoolWithTag(WorkItemData, I8042PRT_TAG);
+ break;
+ }
+ case IOCTL_INTERNAL_MOUSE_DISCONNECT:
+ {
+ TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_INTERNAL_MOUSE_DISCONNECT\n");
+ /* MSDN says that operation is to implemented.
+ * To implement it, we just have to do:
+ * DeviceExtension->MouseData.ClassService = NULL;
+ */
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ case IOCTL_INTERNAL_I8042_HOOK_MOUSE:
+ {
+ PINTERNAL_I8042_HOOK_MOUSE MouseHook;
+ TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_INTERNAL_I8042_HOOK_MOUSE\n");
+ if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(INTERNAL_I8042_HOOK_MOUSE))
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ break;
+ }
+ MouseHook = (PINTERNAL_I8042_HOOK_MOUSE)Stack->Parameters.DeviceIoControl.Type3InputBuffer;
+
+ DeviceExtension->MouseHook.Context = MouseHook->Context;
+ if (MouseHook->IsrRoutine)
+ DeviceExtension->MouseHook.IsrRoutine = MouseHook->IsrRoutine;
+
+ Status = STATUS_SUCCESS;
+ break;
+ }
+ case IOCTL_INTERNAL_I8042_MOUSE_WRITE_BUFFER:
+ {
+ DPRINT1("IOCTL_INTERNAL_I8042_MOUSE_WRITE_BUFFER not implemented\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ case IOCTL_INTERNAL_I8042_MOUSE_START_INFORMATION:
+ {
+ DPRINT1("IOCTL_INTERNAL_I8042_MOUSE_START_INFORMATION not implemented\n");
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ }
+ case IOCTL_MOUSE_QUERY_ATTRIBUTES:
+ {
+ TRACE_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / IOCTL_MOUSE_QUERY_ATTRIBUTES\n");
+ if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUSE_ATTRIBUTES))
+ {
+ Status = STATUS_BUFFER_TOO_SMALL;
+ break;
+ }
+
+ *(PMOUSE_ATTRIBUTES) Irp->AssociatedIrp.SystemBuffer = DeviceExtension->MouseAttributes;
+ Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
+ Status = STATUS_SUCCESS;
+ break;
+ }
+ default:
+ {
+ ERR_(I8042PRT, "IRP_MJ_INTERNAL_DEVICE_CONTROL / unknown ioctl code 0x%lx\n",
+ Stack->Parameters.DeviceIoControl.IoControlCode);
+ ASSERT(FALSE);
+ return ForwardIrpAndForget(DeviceObject, Irp);
+ }
+ }
+
+ if (Status != STATUS_PENDING)
+ {
+ Irp->IoStatus.Status = Status;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ }
+ return Status;
+}
+
+/* Test if packets are taking too long to come in. If they do, we
+ * might have gotten out of sync and should just drop what we have.
+ *
+ * If we want to be totally right, we'd also have to keep a count of
+ * errors, and totally reset the mouse after too much of them (can
+ * happen if the user is using a KVM switch and an OS on another port
+ * resets the mouse, or if the user hotplugs the mouse, or if we're just
+ * generally unlucky). Also note the input parsing routine where we
+ * drop invalid input packets.
+ */
+static VOID
+i8042MouInputTestTimeout(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension)
+{
+ ULARGE_INTEGER Now;
+
+ if (DeviceExtension->MouseState == MouseExpectingACK ||
+ DeviceExtension->MouseState == MouseResetting)
+ return;
+
+ Now.QuadPart = KeQueryInterruptTime();
+
+ if (DeviceExtension->MouseState != MouseIdle) {
+ /* Check if the last byte came too long ago */
+ if (Now.QuadPart - DeviceExtension->MousePacketStartTime.QuadPart >
+ DeviceExtension->Common.PortDeviceExtension->Settings.MouseSynchIn100ns)
+ {
+ WARN_(I8042PRT, "Mouse input packet timeout\n");
+ DeviceExtension->MouseState = MouseIdle;
+ }
+ }
+
+ if (DeviceExtension->MouseState == MouseIdle)
+ DeviceExtension->MousePacketStartTime.QuadPart = Now.QuadPart;
+}
+
+/*
+ * Call the customization hook. The ToReturn parameter is about wether
+ * we should go on with the interrupt. The return value is what
+ * we should return (indicating to the system wether someone else
+ * should try to handle the interrupt)
+ */
+static BOOLEAN
+i8042MouCallIsrHook(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension,
+ IN UCHAR Status,
+ IN UCHAR Input,
+ OUT PBOOLEAN ToReturn)
+{
+ BOOLEAN HookReturn, HookContinue;
+
+ HookContinue = FALSE;
+
+ if (DeviceExtension->MouseHook.IsrRoutine)
+ {
+ HookReturn = DeviceExtension->MouseHook.IsrRoutine(
+ DeviceExtension->MouseHook.Context,
+ DeviceExtension->MouseBuffer + DeviceExtension->MouseInBuffer,
+ &DeviceExtension->Common.PortDeviceExtension->Packet,
+ Status,
+ &Input,
+ &HookContinue,
+ &DeviceExtension->MouseState,
+ &DeviceExtension->MouseResetState);
+
+ if (!HookContinue)
+ {
+ *ToReturn = HookReturn;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+static BOOLEAN
+i8042MouResetIsr(
+ IN PI8042_MOUSE_EXTENSION DeviceExtension,
+ IN UCHAR Status,
+ IN UCHAR Value)
+{
+ PPORT_DEVICE_EXTENSION PortDeviceExtension;
+ BOOLEAN ToReturn = FALSE;
+
+ if (i8042MouCallIsrHook(DeviceExtension, Status, Value, &ToReturn))
+ return ToReturn;
+
+ if (MouseIdle == DeviceExtension->MouseState)
+ {
+ /* Magic packet value that indicates a reset */
+ if (0xAA == Value)
+ {
+ WARN_(I8042PRT, "Hot plugged mouse!\n");
+ DeviceExtension->MouseState = MouseResetting;
+ DeviceExtension->MouseResetState = ExpectingReset;
+ }
+ else
+ return FALSE;
+ }
+ else if (MouseResetting != DeviceExtension->MouseState)
+ return FALSE;
+
+ DeviceExtension->MouseTimeoutState = TimeoutStart;
+ PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
+
+ switch ((ULONG)DeviceExtension->MouseResetState)
+ {
+ case ExpectingReset:
+ if (MOUSE_ACK == Value)
+ {
+ WARN_(I8042PRT, "Dropping extra ACK\n");
+ return TRUE;
+ }
+
+ /* First, 0xFF is sent. The mouse is supposed to say AA00 if ok, FC00 if not. */
+ if (0xAA == Value)
+ {
+ DeviceExtension->MouseResetState++;
+ }
+ else
+ {
+ PortDeviceExtension->Flags &= ~MOUSE_PRESENT;
+ DeviceExtension->MouseState = MouseIdle;
+ WARN_(I8042PRT, "Mouse returned bad reset reply: %x (expected aa)\n", Value);
+ }
+ return TRUE;
+ case ExpectingResetId:
+ if (MOUSE_ACK == Value)
+ {
+ WARN_(I8042PRT, "Dropping extra ACK #2\n");
+ return TRUE;
+ }
+
+ if (0x00 == Value)
+ {
+ DeviceExtension->MouseResetState++;
+ DeviceExtension->MouseType = GenericPS2;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF2);
+ }
+ else
+ {
+ PortDeviceExtension->Flags &= ~MOUSE_PRESENT;
+ DeviceExtension->MouseState = MouseIdle;
+ WARN_(I8042PRT, "Mouse returned bad reset reply part two: %x (expected 0)\n", Value);
+ }
+ return TRUE;
+ case ExpectingGetDeviceIdACK:
+ if (MOUSE_ACK == Value)
+ {
+ DeviceExtension->MouseResetState++;
+ }
+ else if (MOUSE_NACK == Value || MOUSE_ERROR == Value)
+ {
+ DeviceExtension->MouseResetState++;
+ /* Act as if 00 (normal mouse) was received */
+ WARN_(I8042PRT, "Mouse doesn't support 0xd2, (returns %x, expected %x), faking\n", Value, MOUSE_ACK);
+ i8042MouResetIsr(DeviceExtension, Status, 0);
+ }
+ return TRUE;
+ case ExpectingGetDeviceIdValue:
+ switch (Value)
+ {
+ case 0x02:
+ DeviceExtension->MouseAttributes.MouseIdentifier =
+ BALLPOINT_I8042_HARDWARE;
+ break;
+ case 0x03:
+ case 0x04:
+ DeviceExtension->MouseAttributes.MouseIdentifier =
+ WHEELMOUSE_I8042_HARDWARE;
+ break;
+ default:
+ DeviceExtension->MouseAttributes.MouseIdentifier =
+ MOUSE_I8042_HARDWARE;
+ }
+ DeviceExtension->MouseResetState++;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xE8);
+ return TRUE;
+ case ExpectingSetResolutionDefaultACK:
+ DeviceExtension->MouseResetState++;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0x00);
+ return TRUE;
+ case ExpectingSetResolutionDefaultValueACK:
+ DeviceExtension->MouseResetState = ExpectingSetScaling1to1ACK;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xE6);
+ return TRUE;
+ case ExpectingSetScaling1to1ACK:
+ case ExpectingSetScaling1to1ACK2:
+ DeviceExtension->MouseResetState++;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xE6);
+ return TRUE;
+ case ExpectingSetScaling1to1ACK3:
+ DeviceExtension->MouseResetState++;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xE9);
+ return TRUE;
+ case ExpectingReadMouseStatusACK:
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case ExpectingReadMouseStatusByte1:
+ DeviceExtension->MouseLogiBuffer[0] = Value;
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case ExpectingReadMouseStatusByte2:
+ DeviceExtension->MouseLogiBuffer[1] = Value;
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case ExpectingReadMouseStatusByte3:
+ DeviceExtension->MouseLogiBuffer[2] = Value;
+ /* Now MouseLogiBuffer is a set of info. If the second
+ * byte is 0, the mouse didn't understand the magic
+ * code. Otherwise, it it a Logitech and the second byte
+ * is the number of buttons, bit 7 of the first byte tells
+ * if it understands special E7 commands, the rest is an ID.
+ */
+ if (DeviceExtension->MouseLogiBuffer[1])
+ {
+ DeviceExtension->MouseAttributes.NumberOfButtons =
+ DeviceExtension->MouseLogiBuffer[1];
+ DeviceExtension->MouseType = Ps2pp;
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState = ExpectingSetSamplingRateACK;
+ /* TODO: Go through EnableWheel and Enable5Buttons */
+ return TRUE;
+ }
+ DeviceExtension->MouseResetState = EnableWheel;
+ i8042MouResetIsr(DeviceExtension, Status, Value);
+ return TRUE;
+ case EnableWheel:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState = 1001;
+ return TRUE;
+ case 1001:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xC8);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1002:
+ case 1004:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1003:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0x64);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1005:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0x50);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1006:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF2);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1007:
+ /* Ignore ACK */
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1008:
+ if (0x03 == Value) {
+ /* It's either an Intellimouse or Intellimouse Explorer. */
+ DeviceExtension->MouseAttributes.NumberOfButtons = 3;
+ DeviceExtension->MouseAttributes.MouseIdentifier =
+ WHEELMOUSE_I8042_HARDWARE;
+ DeviceExtension->MouseType = Intellimouse;
+ DeviceExtension->MouseResetState = Enable5Buttons;
+ i8042MouResetIsr(DeviceExtension, Status, Value);
+ }
+ else
+ {
+ /* Just set the default settings and be done */
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState = ExpectingSetSamplingRateACK;
+ }
+ return TRUE;
+ case Enable5Buttons:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState = 1021;
+ return TRUE;
+ case 1022:
+ case 1024:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1021:
+ case 1023:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xC8);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1025:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0x50);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1026:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF2);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case 1027:
+ if (0x04 == Value)
+ {
+ DeviceExtension->MouseAttributes.NumberOfButtons = 5;
+ DeviceExtension->MouseAttributes.MouseIdentifier =
+ WHEELMOUSE_I8042_HARDWARE;
+ DeviceExtension->MouseType = IntellimouseExplorer;
+ }
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF3);
+ DeviceExtension->MouseResetState = ExpectingSetSamplingRateACK;
+ return TRUE;
+ case ExpectingSetSamplingRateACK:
+ DeviceExtension->MouseHook.IsrWritePort(
+ DeviceExtension->MouseHook.CallContext,
+ (UCHAR)DeviceExtension->MouseAttributes.SampleRate);
+ DeviceExtension->MouseResetState++;
+ return TRUE;
+ case ExpectingSetSamplingRateValueACK:
+ if (MOUSE_NACK == Value)
+ {
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0x3C);
+ DeviceExtension->MouseAttributes.SampleRate = (USHORT)PortDeviceExtension->Settings.SampleRate;
+ DeviceExtension->MouseResetState = 1040;
+ return TRUE;
+ }
+ case 1040: /* Fallthrough */
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xE8);
+ DeviceExtension->MouseResetState = ExpectingFinalResolutionACK;
+ return TRUE;
+ case ExpectingFinalResolutionACK:
+ DeviceExtension->MouseHook.IsrWritePort(
+ DeviceExtension->MouseHook.CallContext,
+ (UCHAR)(PortDeviceExtension->Settings.MouseResolution & 0xff));
+ INFO_(I8042PRT, "Mouse resolution %lu\n",
+ PortDeviceExtension->Settings.MouseResolution);
+ DeviceExtension->MouseResetState = ExpectingFinalResolutionValueACK;
+ return TRUE;
+ case ExpectingFinalResolutionValueACK:
+ DeviceExtension->MouseHook.IsrWritePort(DeviceExtension->MouseHook.CallContext, 0xF4);
+ DeviceExtension->MouseResetState = ExpectingEnableACK;
+ return TRUE;
+ case ExpectingEnableACK:
+ PortDeviceExtension->Flags |= MOUSE_PRESENT;
+ DeviceExtension->MouseState = MouseIdle;
+ DeviceExtension->MouseTimeoutState = TimeoutCancel;
+ INFO_(I8042PRT, "Mouse type = %u\n", DeviceExtension->MouseType);
+ return TRUE;
+ default:
+ if (DeviceExtension->MouseResetState < 100 || DeviceExtension->MouseResetState > 999)
+ ERR_(I8042PRT, "MouseResetState went out of range: %lu\n", DeviceExtension->MouseResetState);
+ return FALSE;
+ }
+}
+
+BOOLEAN NTAPI
+i8042MouInterruptService(
+ IN PKINTERRUPT Interrupt,
+ PVOID Context)
+{
+ PI8042_MOUSE_EXTENSION DeviceExtension;
+ PPORT_DEVICE_EXTENSION PortDeviceExtension;
+ ULONG Counter;
+ UCHAR Output = 0, PortStatus = 0;
+ NTSTATUS Status;
+
+ UNREFERENCED_PARAMETER(Interrupt);
+
+ __analysis_assume(Context != NULL);
+ DeviceExtension = Context;
+ PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
+ Counter = PortDeviceExtension->Settings.PollStatusIterations;
+
+ while (Counter)
+ {
+ Status = i8042ReadStatus(PortDeviceExtension, &PortStatus);
+ if (!NT_SUCCESS(Status))
+ {
+ WARN_(I8042PRT, "i8042ReadStatus() failed with status 0x%08lx\n", Status);
+ return FALSE;
+ }
+ Status = i8042ReadMouseData(PortDeviceExtension, &Output);
+ if (NT_SUCCESS(Status))
+ break;
+ KeStallExecutionProcessor(1);
+ Counter--;
+ }
+ if (Counter == 0)
+ {
+ WARN_(I8042PRT, "Spurious i8042 mouse interrupt\n");
+ return FALSE;
+ }
+
+ INFO_(I8042PRT, "Got: 0x%02x\n", Output);
+
+ if (i8042PacketIsr(PortDeviceExtension, Output))
+ {
+ if (PortDeviceExtension->PacketComplete)
+ {
+ TRACE_(I8042PRT, "Packet complete\n");
+ KeInsertQueueDpc(&DeviceExtension->DpcMouse, NULL, NULL);
+ }
+ TRACE_(I8042PRT, "Irq eaten by packet\n");
+ return TRUE;
+ }
+
+ TRACE_(I8042PRT, "Irq is mouse input\n");
+
+ i8042MouInputTestTimeout(DeviceExtension);
+
+ if (i8042MouResetIsr(DeviceExtension, PortStatus, Output))
+ {
+ TRACE_(I8042PRT, "Handled by ResetIsr or hooked Isr\n");
+ if (NoChange != DeviceExtension->MouseTimeoutState) {
+ KeInsertQueueDpc(&DeviceExtension->DpcMouse, NULL, NULL);
+ }
+ return TRUE;
+ }
+
+ if (DeviceExtension->MouseType == Ps2pp)
+ i8042MouHandlePs2pp(DeviceExtension, Output);
+ else
+ i8042MouHandle(DeviceExtension, Output);
+
+ return TRUE;
+}
projects / reactos.git / blobdiff