[ros-diffs] [hpoussin] 19100: New serial mouse driver, which is PnP compliant

New serial mouse driver, which is PnP compliant
Added: trunk/reactos/drivers/input/sermouse/
Added: trunk/reactos/drivers/input/sermouse/createclose.c
Added: trunk/reactos/drivers/input/sermouse/detect.c
Added: trunk/reactos/drivers/input/sermouse/fdo.c
Added: trunk/reactos/drivers/input/sermouse/internaldevctl.c
Added: trunk/reactos/drivers/input/sermouse/misc.c
Added: trunk/reactos/drivers/input/sermouse/readmouse.c
Added: trunk/reactos/drivers/input/sermouse/sermouse.c
Added: trunk/reactos/drivers/input/sermouse/sermouse.h
Added: trunk/reactos/drivers/input/sermouse/sermouse.rc
Added: trunk/reactos/drivers/input/sermouse/sermouse.txt
Added: trunk/reactos/drivers/input/sermouse/sermouse.xml
  _____  

Added: trunk/reactos/drivers/input/sermouse/createclose.c
--- trunk/reactos/drivers/input/sermouse/createclose.c	2005-11-09
11:54:53 UTC (rev 19099)
+++ trunk/reactos/drivers/input/sermouse/createclose.c	2005-11-09
11:57:58 UTC (rev 19100)
@@ -0,0 +1,58 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/fdo.c
+ * PURPOSE:         IRP_MJ_CREATE and IRP_MJ_CLOSE operations
+ *
+ * PROGRAMMERS:     HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+NTSTATUS NTAPI
+SermouseStartDevice(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp); /* FIXME: remove the declaration */
+
+NTSTATUS NTAPI
+SermouseCreate(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	DPRINT("IRP_MJ_CREATE\n");
+
ASSERT(((PSERMOUSE_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->PnpS
tate == dsStarted);
+
+	Irp->IoStatus.Status = STATUS_SUCCESS;
+	Irp->IoStatus.Information = 0;
+	IoCompleteRequest(Irp, IO_NO_INCREMENT);
+	return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+SermouseClose(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	DPRINT("IRP_MJ_CLOSE\n");
+
+	Irp->IoStatus.Status = STATUS_SUCCESS;
+	Irp->IoStatus.Information = 0;
+	IoCompleteRequest(Irp, IO_NO_INCREMENT);
+	return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+SermouseCleanup(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	DPRINT("IRP_MJ_CLEANUP\n");
+
+	Irp->IoStatus.Status = STATUS_SUCCESS;
+	Irp->IoStatus.Information = 0;
+	IoCompleteRequest(Irp, IO_NO_INCREMENT);
+	return STATUS_SUCCESS;
+}
Property changes on: trunk/reactos/drivers/input/sermouse/createclose.c
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Added: trunk/reactos/drivers/input/sermouse/detect.c
--- trunk/reactos/drivers/input/sermouse/detect.c	2005-11-09
11:54:53 UTC (rev 19099)
+++ trunk/reactos/drivers/input/sermouse/detect.c	2005-11-09
11:57:58 UTC (rev 19100)
@@ -0,0 +1,282 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/detect.c
+ * PURPOSE:         Detect serial mouse type
+ *
+ * PROGRAMMERS:     Jason Filby (jasonfilby(a)yahoo.com)
+ *                  Filip Navara (xnavara(a)volny.cz)
+ *                  HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+/* Most of this file is ripped from
reactos/drivers/bus/serenum/detect.c */
+
+static NTSTATUS
+SermouseDeviceIoControl(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN ULONG CtlCode,
+	IN PVOID InputBuffer OPTIONAL,
+	IN ULONG InputBufferSize,
+	IN OUT PVOID OutputBuffer OPTIONAL,
+	IN OUT PULONG OutputBufferSize)
+{
+	KEVENT Event;
+	PIRP Irp;
+	IO_STATUS_BLOCK IoStatus;
+	NTSTATUS Status;
+
+	KeInitializeEvent (&Event, NotificationEvent, FALSE);
+
+	Irp = IoBuildDeviceIoControlRequest(CtlCode,
+		DeviceObject,
+		InputBuffer,
+		InputBufferSize,
+		OutputBuffer,
+		(OutputBufferSize) ? *OutputBufferSize : 0,
+		FALSE,
+		&Event,
+		&IoStatus);
+	if (Irp == NULL)
+	{
+		DPRINT("IoBuildDeviceIoControlRequest() failed\n");
+		return STATUS_INSUFFICIENT_RESOURCES;
+	}
+
+	Status = IoCallDriver(DeviceObject, Irp);
+
+	if (Status == STATUS_PENDING)
+	{
+		DPRINT("Operation pending\n");
+		KeWaitForSingleObject(&Event, Suspended, KernelMode,
FALSE, NULL);
+		Status = IoStatus.Status;
+	}
+
+	if (OutputBufferSize)
+	{
+		*OutputBufferSize = IoStatus.Information;
+	}
+
+	return Status;
+}
+
+static NTSTATUS
+SermouseSendIrp(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN ULONG MajorFunction)
+{
+	KEVENT Event;
+	PIRP Irp;
+	IO_STATUS_BLOCK IoStatus;
+	NTSTATUS Status;
+
+	KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+	Irp = IoBuildSynchronousFsdRequest(
+		MajorFunction,
+		DeviceObject,
+		NULL,
+		0,
+		NULL,
+		&Event,
+		&IoStatus);
+	if (Irp == NULL)
+	{
+		DPRINT("IoBuildSynchronousFsdRequest() failed\n");
+		return STATUS_INSUFFICIENT_RESOURCES;
+	}
+
+	Status = IoCallDriver(DeviceObject, Irp);
+
+	if (Status == STATUS_PENDING)
+	{
+		DPRINT("Operation pending\n");
+		KeWaitForSingleObject(&Event, Suspended, KernelMode,
FALSE, NULL);
+		Status = IoStatus.Status;
+	}
+
+	return Status;
+}
+
+static NTSTATUS
+ReadBytes(
+	IN PDEVICE_OBJECT LowerDevice,
+	OUT PUCHAR Buffer,
+	IN ULONG BufferSize,
+	OUT PULONG FilledBytes)
+{
+	PIRP Irp;
+	IO_STATUS_BLOCK ioStatus;
+	KEVENT event;
+	LARGE_INTEGER zero;
+	NTSTATUS Status;
+
+	KeInitializeEvent(&event, NotificationEvent, FALSE);
+	zero.QuadPart = 0;
+	Irp = IoBuildSynchronousFsdRequest(
+		IRP_MJ_READ,
+		LowerDevice,
+		Buffer, BufferSize,
+		&zero,
+		&event,
+		&ioStatus);
+	if (!Irp)
+		return FALSE;
+
+	Status = IoCallDriver(LowerDevice, Irp);
+	if (Status == STATUS_PENDING)
+	{
+		KeWaitForSingleObject(&event, Suspended, KernelMode,
FALSE, NULL);
+		Status = ioStatus.Status;
+	}
+	DPRINT("Bytes received: %lu/%lu\n",
+		ioStatus.Information, BufferSize);
+	*FilledBytes = ioStatus.Information;
+	return Status;
+}
+
+static NTSTATUS
+SermouseWait(ULONG milliseconds)
+{
+	KTIMER Timer;
+	LARGE_INTEGER DueTime;
+
+	DueTime.QuadPart = milliseconds * -10;
+	KeInitializeTimer(&Timer);
+	KeSetTimer(&Timer, DueTime, NULL);
+	return KeWaitForSingleObject(&Timer, Executive, KernelMode,
FALSE, NULL);
+}
+
+SERMOUSE_MOUSE_TYPE
+SermouseDetectLegacyDevice(
+	IN PDEVICE_OBJECT LowerDevice)
+{
+	ULONG Fcr, Mcr;
+	ULONG BaudRate;
+	ULONG Command;
+	SERIAL_TIMEOUTS Timeouts;
+	SERIAL_LINE_CONTROL LCR;
+	ULONG i, Count;
+	UCHAR Buffer[16];
+	SERMOUSE_MOUSE_TYPE MouseType = mtNone;
+	NTSTATUS Status;
+
+	RtlZeroMemory(Buffer, sizeof(Buffer));
+
+	/* Open port */
+	Status = SermouseSendIrp(LowerDevice, IRP_MJ_CREATE);
+	if (!NT_SUCCESS(Status)) return mtNone;
+
+	/* Reset UART */
+	CHECKPOINT;
+	Mcr = 0; /* MCR: DTR/RTS/OUT2 off */
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_MODEM_CONTROL,
+		&Mcr, sizeof(Mcr), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	/* Set communications parameters */
+	CHECKPOINT;
+	/* DLAB off */
+	Fcr = 0;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_FIFO_CONTROL,
+		&Fcr, sizeof(Fcr), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+	/* Set serial port speed */
+	BaudRate = SERIAL_BAUD_1200;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_BAUD_RATE,
+		&BaudRate, sizeof(BaudRate), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+	/* Set LCR */
+	LCR.WordLength = 7;
+	LCR.Parity = NO_PARITY;
+	LCR.StopBits = STOP_BITS_2;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_LINE_CONTROL,
+		&LCR, sizeof(LCR), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	/* Disable DTR/RTS */
+	CHECKPOINT;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_CLR_DTR,
+		NULL, 0, NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_CLR_RTS,
+		NULL, 0, NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	/* Flush receive buffer */
+	CHECKPOINT;
+	Command = SERIAL_PURGE_RXCLEAR;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_MODEM_CONTROL,
+		&Command, sizeof(Command), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+	/* Wait 100 ms */
+	SermouseWait(100);
+
+	/* Enable DTR/RTS */
+	CHECKPOINT;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_DTR,
+		NULL, 0, NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+	SermouseWait(200);
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_RTS,
+		NULL, 0, NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	/* Set timeout to 500 microseconds */
+	CHECKPOINT;
+	Timeouts.ReadIntervalTimeout = 0;
+	Timeouts.ReadTotalTimeoutMultiplier = 0;
+	Timeouts.ReadTotalTimeoutConstant = 500;
+	Timeouts.WriteTotalTimeoutMultiplier =
Timeouts.WriteTotalTimeoutConstant = 0;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_TIMEOUTS,
+		&Timeouts, sizeof(Timeouts), NULL, NULL);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	/* Fill the read buffer */
+	CHECKPOINT;
+	Status = ReadBytes(LowerDevice, Buffer,
sizeof(Buffer)/sizeof(Buffer[0]), &Count);
+	if (!NT_SUCCESS(Status)) goto ByeBye;
+
+	for (i = 0; i < Count; i++)
+	{
+		if (Buffer[i] == 'B')
+		{
+			/* Sign for Microsoft Ballpoint */
+			DPRINT1("Microsoft Ballpoint device detected.
THIS DEVICE IS NOT YET SUPPORTED");
+			MouseType = mtNone;
+			goto ByeBye;
+		}
+		else if (Buffer[i] == 'M')
+		{
+			/* Sign for Microsoft Mouse protocol followed by
button specifier */
+			if (i == sizeof(Buffer) - 1)
+			{
+				/* Overflow Error */
+				goto ByeBye;
+			}
+			switch (Buffer[i + 1])
+			{
+				case '3':
+					DPRINT("Microsoft Mouse with
3-buttons detected\n");
+					MouseType = mtLogitech;
+				case 'Z':
+					DPRINT("Microsoft Wheel Mouse
detected\n");
+					MouseType = mtWheelZ;
+				default:
+					DPRINT("Microsoft Mouse with
2-buttons detected\n");
+					MouseType = mtMicrosoft;
+			}
+			goto ByeBye;
+		}
+	}
+
+ByeBye:
+	/* Close port */
+	SermouseSendIrp(LowerDevice, IRP_MJ_CLOSE);
+	SermouseSendIrp(LowerDevice, IRP_MJ_CLEANUP);
+	return MouseType;
+}
Property changes on: trunk/reactos/drivers/input/sermouse/detect.c
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Added: trunk/reactos/drivers/input/sermouse/fdo.c
--- trunk/reactos/drivers/input/sermouse/fdo.c	2005-11-09 11:54:53 UTC
(rev 19099)
+++ trunk/reactos/drivers/input/sermouse/fdo.c	2005-11-09 11:57:58 UTC
(rev 19100)
@@ -0,0 +1,239 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/fdo.c
+ * PURPOSE:         IRP_MJ_PNP operations for FDOs
+ *
+ * PROGRAMMERS:     HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+NTSTATUS NTAPI
+SermouseAddDevice(
+	IN PDRIVER_OBJECT DriverObject,
+	IN PDEVICE_OBJECT Pdo)
+{
+	PSERMOUSE_DRIVER_EXTENSION DriverExtension;
+	ULONG DeviceId = 0;
+	ULONG PrefixLength;
+	UNICODE_STRING DeviceNameU;
+	PWSTR DeviceIdW = NULL; /* Pointer into DeviceNameU.Buffer */
+	PDEVICE_OBJECT Fdo;
+	PSERMOUSE_DEVICE_EXTENSION DeviceExtension;
+	NTSTATUS Status;
+
+	DPRINT("SermouseAddDevice called. Pdo = 0x%p\n", Pdo);
+
+	/* Create new device object */
+	DriverExtension = IoGetDriverObjectExtension(DriverObject,
DriverObject);
+	DeviceNameU.Length = 0;
+	DeviceNameU.MaximumLength =
+		wcslen(L"\\Device\\") * sizeof(WCHAR)           /*
"\Device\" */
+		+ DriverExtension->PointerDeviceBaseName.Length /*
"PointerPort" */
+		+ 4 * sizeof(WCHAR)                             /* Id
between 0 and 9999 */
+		+ sizeof(UNICODE_NULL);                         /* Final
NULL char */
+	DeviceNameU.Buffer = ExAllocatePool(PagedPool,
DeviceNameU.MaximumLength);
+	if (!DeviceNameU.Buffer)
+	{
+		DPRINT("ExAllocatePool() failed\n");
+		return STATUS_INSUFFICIENT_RESOURCES;
+	}
+	Status = RtlAppendUnicodeToString(&DeviceNameU, L"\\Device\\");
+	if (!NT_SUCCESS(Status))
+	{
+		DPRINT("RtlAppendUnicodeToString() failed with status
0x%08lx\n", Status);
+		goto cleanup;
+	}
+	Status = RtlAppendUnicodeStringToString(&DeviceNameU,
&DriverExtension->PointerDeviceBaseName);
+	if (!NT_SUCCESS(Status))
+	{
+		DPRINT("RtlAppendUnicodeStringToString() failed with
status 0x%08lx\n", Status);
+		goto cleanup;
+	}
+	PrefixLength = DeviceNameU.MaximumLength - 4 * sizeof(WCHAR) -
sizeof(UNICODE_NULL);
+	DeviceIdW = &DeviceNameU.Buffer[PrefixLength / sizeof(WCHAR)];
+	while (DeviceId < 9999)
+	{
+		DeviceNameU.Length = PrefixLength + swprintf(DeviceIdW,
L"%lu", DeviceId) * sizeof(WCHAR);
+		Status = IoCreateDevice(
+			DriverObject,
+			sizeof(SERMOUSE_DEVICE_EXTENSION),
+			&DeviceNameU,
+			FILE_DEVICE_SERIAL_MOUSE_PORT,
+			FILE_DEVICE_SECURE_OPEN,
+			TRUE,
+			&Fdo);
+		if (NT_SUCCESS(Status))
+			goto cleanup;
+		else if (Status != STATUS_OBJECT_NAME_COLLISION)
+		{
+			DPRINT("IoCreateDevice() failed with status
0x%08lx\n", Status);
+			goto cleanup;
+		}
+		DeviceId++;
+	}
+	DPRINT("Too much devices starting with '\\Device\\%wZ'\n",
&DriverExtension->PointerDeviceBaseName);
+	Status = STATUS_UNSUCCESSFUL;
+cleanup:
+	if (!NT_SUCCESS(Status))
+	{
+		ExFreePool(DeviceNameU.Buffer);
+		return Status;
+	}
+
+	DeviceExtension =
(PSERMOUSE_DEVICE_EXTENSION)Fdo->DeviceExtension;
+	RtlZeroMemory(DeviceExtension,
sizeof(SERMOUSE_DEVICE_EXTENSION));
+	DeviceExtension->MouseType = mtNone;
+	DeviceExtension->PnpState = dsStopped;
+	DeviceExtension->DriverExtension = DriverExtension;
+	KeInitializeEvent(&DeviceExtension->StopWorkerThreadEvent,
NotificationEvent, FALSE);
+	DeviceExtension->MouseInputData[0] =
ExAllocatePool(NonPagedPool,
DeviceExtension->DriverExtension->MouseDataQueueSize *
sizeof(MOUSE_INPUT_DATA));
+	if (!DeviceExtension->MouseInputData[0])
+	{
+		DPRINT("ExAllocatePool() failed\n");
+		Status = STATUS_INSUFFICIENT_RESOURCES;
+		goto cleanupFDO;
+	}
+	DeviceExtension->MouseInputData[1] =
ExAllocatePool(NonPagedPool,
DeviceExtension->DriverExtension->MouseDataQueueSize *
sizeof(MOUSE_INPUT_DATA));
+	if (!DeviceExtension->MouseInputData[1])
+	{
+		DPRINT("ExAllocatePool() failed\n");
+		Status = STATUS_INSUFFICIENT_RESOURCES;
+		goto cleanupFDO;
+	}
+	Fdo->Flags |= DO_POWER_PAGABLE;
+	Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo,
&DeviceExtension->LowerDevice);
+	if (!NT_SUCCESS(Status))
+	{
+		DPRINT("IoAttachDeviceToDeviceStackSafe() failed with
status 0x%08lx\n", Status);
+		goto cleanupFDO;
+	}
+	Fdo->Flags |= DO_BUFFERED_IO;
+	Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
+
+	/* FIXME: create registry entry in
HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP */
+
+	ExFreePool(DeviceNameU.Buffer);
+
+	return STATUS_SUCCESS;
+
+cleanupFDO:
+	if (DeviceExtension)
+	{
+		ExFreePool(DeviceExtension->MouseInputData[0]);
+		ExFreePool(DeviceExtension->MouseInputData[1]);
+	}
+	if (Fdo)
+	{
+		IoDeleteDevice(Fdo);
+	}
+	return Status;
+}
+
+NTSTATUS NTAPI
+SermouseStartDevice(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	PSERMOUSE_DEVICE_EXTENSION DeviceExtension;
+	SERMOUSE_MOUSE_TYPE MouseType;
+
+	DeviceExtension =
(PSERMOUSE_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+
+	ASSERT(DeviceExtension->PnpState == dsStopped);
+	ASSERT(DeviceExtension->LowerDevice);
+	MouseType =
SermouseDetectLegacyDevice(DeviceExtension->LowerDevice);
+	if (MouseType == mtNone)
+	{
+		DPRINT("No mouse connected to Fdo %p\n",
+			DeviceExtension->LowerDevice);
+		return STATUS_DEVICE_NOT_CONNECTED;
+	}
+
+	switch (MouseType)
+	{
+		case mtMicrosoft:
+
DeviceExtension->AttributesInformation.MouseIdentifier =
MOUSE_SERIAL_HARDWARE;
+
DeviceExtension->AttributesInformation.NumberOfButtons = 2;
+			break;
+		case mtLogitech:
+
DeviceExtension->AttributesInformation.MouseIdentifier =
MOUSE_SERIAL_HARDWARE;
+
DeviceExtension->AttributesInformation.NumberOfButtons = 3;
+			break;
+		case mtWheelZ:
+
DeviceExtension->AttributesInformation.MouseIdentifier =
WHEELMOUSE_SERIAL_HARDWARE;
+
DeviceExtension->AttributesInformation.NumberOfButtons = 3;
+			break;
+		default:
+			CHECKPOINT;
+			return STATUS_UNSUCCESSFUL;
+	}
+
+	if (DeviceExtension->DriverExtension->NumberOfButtons != 0)
+		/* Override the number of buttons */
+		DeviceExtension->AttributesInformation.NumberOfButtons =
DeviceExtension->DriverExtension->NumberOfButtons;
+
+	DeviceExtension->AttributesInformation.SampleRate = 1200 / 8;
+	DeviceExtension->AttributesInformation.InputDataQueueLength =
DeviceExtension->DriverExtension->MouseDataQueueSize;
+	DeviceExtension->MouseType = MouseType;
+	DeviceExtension->PnpState = dsStarted;
+
+	return STATUS_SUCCESS;
+}
+
+NTSTATUS NTAPI
+SermousePnp(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	ULONG MinorFunction;
+	PIO_STACK_LOCATION Stack;
+	ULONG Information = 0;
+	NTSTATUS Status;
+
+	Stack = IoGetCurrentIrpStackLocation(Irp);
+	MinorFunction = Stack->MinorFunction;
+
+	switch (MinorFunction)
+	{
+		/* FIXME: do all these minor functions
+		IRP_MN_QUERY_REMOVE_DEVICE 0x1
+		IRP_MN_REMOVE_DEVICE 0x2
+		IRP_MN_CANCEL_REMOVE_DEVICE 0x3
+		IRP_MN_STOP_DEVICE 0x4
+		IRP_MN_QUERY_STOP_DEVICE 0x5
+		IRP_MN_CANCEL_STOP_DEVICE 0x6
+		IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations (optional)
0x7
+		IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations
(optional) 0x7
+		IRP_MN_QUERY_INTERFACE (optional) 0x8
+		IRP_MN_QUERY_CAPABILITIES (optional) 0x9
+		IRP_MN_FILTER_RESOURCE_REQUIREMENTS (optional or
required) 0xd
+		IRP_MN_QUERY_PNP_DEVICE_STATE (optional) 0x14
+		IRP_MN_DEVICE_USAGE_NOTIFICATION (required or optional)
0x16
+		IRP_MN_SURPRISE_REMOVAL 0x17
+		*/
+		case IRP_MN_START_DEVICE: /* 0x0 */
+		{
+			DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
+			/* Call lower driver */
+			Status = ForwardIrpAndWait(DeviceObject, Irp);
+			if (NT_SUCCESS(Status))
+				Status =
SermouseStartDevice(DeviceObject, Irp);
+			break;
+		}
+		default:
+		{
+			DPRINT1("IRP_MJ_PNP / unknown minor function
0x%lx\n", MinorFunction);
+			return ForwardIrpAndForget(DeviceObject, Irp);
+		}
+	}
+
+	Irp->IoStatus.Information = Information;
+	Irp->IoStatus.Status = Status;
+	IoCompleteRequest(Irp, IO_NO_INCREMENT);
+	return Status;
+}
Property changes on: trunk/reactos/drivers/input/sermouse/fdo.c
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Added: trunk/reactos/drivers/input/sermouse/internaldevctl.c
--- trunk/reactos/drivers/input/sermouse/internaldevctl.c
2005-11-09 11:54:53 UTC (rev 19099)
+++ trunk/reactos/drivers/input/sermouse/internaldevctl.c
2005-11-09 11:57:58 UTC (rev 19100)
@@ -0,0 +1,89 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/internaldevctl.c
+ * PURPOSE:         IRP_MJ_INTERNAL_DEVICE_CONTROL operations
+ *
+ * PROGRAMMERS:     HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+NTSTATUS NTAPI
+SermouseInternalDeviceControl(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	PSERMOUSE_DEVICE_EXTENSION DeviceExtension;
+	PIO_STACK_LOCATION Stack;
+	NTSTATUS Status;
+
+	DeviceExtension =
(PSERMOUSE_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
+	Stack = IoGetCurrentIrpStackLocation(Irp);
+
+	switch (Stack->Parameters.DeviceIoControl.IoControlCode)
+	{
+		case IOCTL_INTERNAL_MOUSE_CONNECT:
+		{
+			DPRINT("IRP_MJ_INTERNAL_DEVICE_CONTROL /
IOCTL_INTERNAL_MOUSE_CONNECT\n");
+			DeviceExtension->ConnectData =
+
*((PCONNECT_DATA)Stack->Parameters.DeviceIoControl.Type3InputBuffer);
+
+			/* Start read loop */
+			Status = PsCreateSystemThread(
+				&DeviceExtension->WorkerThreadHandle,
+				(ACCESS_MASK)0L,
+				NULL,
+				NULL,
+				NULL,
+				SermouseDeviceWorker,
+				DeviceObject);
+			break;
+		}
+		case IOCTL_INTERNAL_MOUSE_DISCONNECT:
+		{
+			DPRINT("IRP_MJ_INTERNAL_DEVICE_CONTROL /
IOCTL_INTERNAL_MOUSE_DISCONNECT\n");
+
+			/* Ask read loop to end */
+
KeSetEvent(&DeviceExtension->StopWorkerThreadEvent, (KPRIORITY)0,
FALSE);
+			break;
+		}
+		case IOCTL_MOUSE_QUERY_ATTRIBUTES:
+		{
+			DPRINT("IRP_MJ_INTERNAL_DEVICE_CONTROL /
IOCTL_MOUSE_QUERY_ATTRIBUTES\n");
+			if
(Stack->Parameters.DeviceIoControl.OutputBufferLength >=
sizeof(MOUSE_ATTRIBUTES))
+			{
+
*(PMOUSE_ATTRIBUTES)Irp->AssociatedIrp.SystemBuffer =
+
DeviceExtension->AttributesInformation;
+				Irp->IoStatus.Information =
sizeof(MOUSE_ATTRIBUTES);
+				Status = STATUS_SUCCESS;
+			} else {
+				Status = STATUS_BUFFER_TOO_SMALL;
+			}
+			break;
+		}
+		default:
+		{
+			DPRINT1("IRP_MJ_INTERNAL_DEVICE_CONTROL /
unknown ioctl code 0x%lx\n",
+
Stack->Parameters.DeviceIoControl.IoControlCode);
+			Status = STATUS_INVALID_DEVICE_REQUEST;
+			break;
+		}
+	}
+
+	Irp->IoStatus.Status = Status;
+	if (Status == STATUS_PENDING)
+	{
+		IoMarkIrpPending(Irp);
+		IoStartPacket(DeviceObject, Irp, NULL, NULL);
+	}
+	else
+	{
+		IoCompleteRequest(Irp, IO_NO_INCREMENT);
+	}
+
+	return Status;
+}
Property changes on:
trunk/reactos/drivers/input/sermouse/internaldevctl.c
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Added: trunk/reactos/drivers/input/sermouse/misc.c
--- trunk/reactos/drivers/input/sermouse/misc.c	2005-11-09 11:54:53 UTC
(rev 19099)
+++ trunk/reactos/drivers/input/sermouse/misc.c	2005-11-09 11:57:58 UTC
(rev 19100)
@@ -0,0 +1,61 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/misc.c
+ * PURPOSE:         Misceallenous operations
+ *
+ * PROGRAMMERS:     HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+static NTSTATUS NTAPI
+ForwardIrpAndWaitCompletion(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp,
+	IN PVOID Context)
+{
+	if (Irp->PendingReturned)
+		KeSetEvent((PKEVENT)Context, IO_NO_INCREMENT, FALSE);
+	return STATUS_MORE_PROCESSING_REQUIRED;
+}
+
+NTSTATUS
+ForwardIrpAndWait(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	PDEVICE_OBJECT LowerDevice =
((PSERMOUSE_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice
;
+	KEVENT Event;
+	NTSTATUS Status;
+
+	KeInitializeEvent(&Event, NotificationEvent, FALSE);
+	IoCopyCurrentIrpStackLocationToNext(Irp);
+
+	DPRINT("Calling lower device %p [%wZ]\n", LowerDevice,
&LowerDevice->DriverObject->DriverName);
+	IoSetCompletionRoutine(Irp, ForwardIrpAndWaitCompletion, &Event,
TRUE, TRUE, TRUE);
+
+	Status = IoCallDriver(LowerDevice, Irp);
+	if (Status == STATUS_PENDING)
+	{
+		Status = KeWaitForSingleObject(&Event, Suspended,
KernelMode, FALSE, NULL);
+		if (NT_SUCCESS(Status))
+			Status = Irp->IoStatus.Status;
+	}
+
+	return Status;
+}
+
+NTSTATUS NTAPI
+ForwardIrpAndForget(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN PIRP Irp)
+{
+	PDEVICE_OBJECT LowerDevice =
((PSERMOUSE_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice
;
+
+	IoSkipCurrentIrpStackLocation(Irp);
+	return IoCallDriver(LowerDevice, Irp);
+}
Property changes on: trunk/reactos/drivers/input/sermouse/misc.c
___________________________________________________________________
Name: svn:eol-style
   + native
  _____  

Added: trunk/reactos/drivers/input/sermouse/readmouse.c
--- trunk/reactos/drivers/input/sermouse/readmouse.c	2005-11-09
11:54:53 UTC (rev 19099)
+++ trunk/reactos/drivers/input/sermouse/readmouse.c	2005-11-09
11:57:58 UTC (rev 19100)
@@ -0,0 +1,277 @@

+/*
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS Serial mouse driver
+ * FILE:            drivers/input/sermouse/readmouse.c
+ * PURPOSE:         Read mouse moves and send them to mouclass
+ *
+ * PROGRAMMERS:     Jason Filby (jasonfilby(a)yahoo.com)
+ *                  Filip Navara (xnavara(a)volny.cz)
+ *                  HervÚ Poussineau (hpoussin(a)reactos.org)
+ */
+
+#define NDEBUG
+#include <debug.h>
+
+#include "sermouse.h"
+
+static NTSTATUS
+SermouseDeviceIoControl(
+	IN PDEVICE_OBJECT DeviceObject,
+	IN ULONG CtlCode,
+	IN PVOID InputBuffer OPTIONAL,
+	IN ULONG InputBufferSize,
+	IN OUT PVOID OutputBuffer OPTIONAL,
+	IN OUT PULONG OutputBufferSize)
+{
+	KEVENT Event;
+	PIRP Irp;
+	IO_STATUS_BLOCK IoStatus;
+	NTSTATUS Status;
+
+	KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+	Irp = IoBuildDeviceIoControlRequest(CtlCode,
+		DeviceObject,
+		InputBuffer,
+		InputBufferSize,
+		OutputBuffer,
+		(OutputBufferSize) ? *OutputBufferSize : 0,
+		FALSE,
+		&Event,
+		&IoStatus);
+	if (Irp == NULL)
+	{
+		DPRINT("IoBuildDeviceIoControlRequest() failed\n");
+		return STATUS_INSUFFICIENT_RESOURCES;
+	}
+
+	Status = IoCallDriver(DeviceObject, Irp);
+
+	if (Status == STATUS_PENDING)
+	{
+		DPRINT("Operation pending\n");
+		KeWaitForSingleObject(&Event, Suspended, KernelMode,
FALSE, NULL);
+		Status = IoStatus.Status;
+	}
+
+	if (OutputBufferSize)
+	{
+		*OutputBufferSize = IoStatus.Information;
+	}
+
+	return Status;
+}
+
+VOID NTAPI
+SermouseDeviceWorker(
+	PVOID Context)
+{
+	PSERMOUSE_DEVICE_EXTENSION DeviceExtension;
+	PDEVICE_OBJECT LowerDevice;
+	UCHAR Buffer[PACKET_BUFFER_SIZE];
+	PIRP Irp;
+	IO_STATUS_BLOCK ioStatus;
+	KEVENT event;
+	PUCHAR PacketBuffer;
+	UCHAR ReceivedByte;
+	ULONG Queue;
+	PMOUSE_INPUT_DATA Input;
+	ULONG ButtonsDifference;
+	KIRQL OldIrql;
+	ULONG i;
+	ULONG Fcr;
+	ULONG BaudRate;
+	SERIAL_TIMEOUTS Timeouts;
+	SERIAL_LINE_CONTROL LCR;
+	LARGE_INTEGER Zero;
+	NTSTATUS Status;
+
+	DPRINT("SermouseDeviceWorker() called\n");
+
+	DeviceExtension =
(PSERMOUSE_DEVICE_EXTENSION)((PDEVICE_OBJECT)Context)->DeviceExtension;
+	LowerDevice = DeviceExtension->LowerDevice;
+	Zero.QuadPart = 0;
+	PacketBuffer = DeviceExtension->PacketBuffer;
+
+	ASSERT(LowerDevice);
+
+	/* Initialize device extension */
+	DeviceExtension->ActiveQueue = 0;
+	DeviceExtension->PacketBufferPosition = 0;
+	DeviceExtension->PreviousButtons = 0;
+
+	/* Initialize serial port */
+	Fcr = 0;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_FIFO_CONTROL,
+		&Fcr, sizeof(Fcr), NULL, NULL);
+	if (!NT_SUCCESS(Status)) PsTerminateSystemThread(Status);
+	/* Set serial port speed */
+	BaudRate = DeviceExtension->DriverExtension->SampleRate;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_BAUD_RATE,
+		&BaudRate, sizeof(BaudRate), NULL, NULL);
+	if (!NT_SUCCESS(Status)) PsTerminateSystemThread(Status);
+	/* Set LCR */
+	LCR.WordLength = 7;
+	LCR.Parity = NO_PARITY;
+	LCR.StopBits = STOP_BIT_1;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_LINE_CONTROL,
+		&LCR, sizeof(LCR), NULL, NULL);
+	if (!NT_SUCCESS(Status)) PsTerminateSystemThread(Status);
+
+	/* Set timeouts */
+	Timeouts.ReadTotalTimeoutConstant =
Timeouts.ReadTotalTimeoutMultiplier = 0;
+	Timeouts.ReadIntervalTimeout = 100;
+	Timeouts.WriteTotalTimeoutMultiplier =
Timeouts.WriteTotalTimeoutConstant = 0;
+	Status = SermouseDeviceIoControl(LowerDevice,
IOCTL_SERIAL_SET_TIMEOUTS,
+		&Timeouts, sizeof(Timeouts), NULL, NULL);
+	if (!NT_SUCCESS(Status)) PsTerminateSystemThread(Status);
+
+	/* main read loop */
+	while (TRUE)
+	{
+		Status = KeWaitForSingleObject(
+			&DeviceExtension->StopWorkerThreadEvent,
+			Executive,
+			KernelMode,
+			TRUE,
+			&Zero);
+		if (Status != STATUS_TIMEOUT)
+		{
+			/* we need to stop the worker thread */
+
KeResetEvent(&DeviceExtension->StopWorkerThreadEvent);
+			break;
+		}
+
+		KeInitializeEvent(&event, NotificationEvent, FALSE);
+		Irp = IoBuildSynchronousFsdRequest(
+			IRP_MJ_READ,
+			LowerDevice,
+			Buffer, PACKET_BUFFER_SIZE,
+			&Zero,
+			&event,
+			&ioStatus);
+		if (!Irp)
+		{
+			/* no memory actually, try later */
+			CHECKPOINT;
+			KeStallExecutionProcessor(10);
+			continue;
+		}
+
+		Status = IoCallDriver(LowerDevice, Irp);
+		if (Status == STATUS_PENDING)
+		{
+			KeWaitForSingleObject(&event, Suspended,
KernelMode, FALSE, NULL);
+			Status = ioStatus.Status;
+		}
+
+		if (!NT_SUCCESS(Status))
+			continue;
+
+		/* Read all available data and process */
+		for (i = 0; i < ioStatus.Information; i++)
+		{
+			ReceivedByte = Buffer[i];
+			DPRINT1("ReceivedByte 0x%02x\n", ReceivedByte);
+
+			/* Synchronize */
+			if ((ReceivedByte & 0x40) == 0x40)
+				DeviceExtension->PacketBufferPosition =
0;
+
+
PacketBuffer[DeviceExtension->PacketBufferPosition] = ReceivedByte &
0x7f;
+			DeviceExtension->PacketBufferPosition++;
+
+			/* Process packet if complete */
+			if (DeviceExtension->PacketBufferPosition >= 3)
+			{
+				Queue = DeviceExtension->ActiveQueue %
2;
+
+				/* Prevent buffer overflow */
+				if
(DeviceExtension->InputDataCount[Queue] ==
DeviceExtension->DriverExtension->MouseDataQueueSize)
+					continue;
+
+				Input =
&DeviceExtension->MouseInputData[Queue][DeviceExtension->InputDataCount[
Queue]];
+
+				if
(DeviceExtension->PacketBufferPosition == 3)
+				{
+					/* Retrieve change in x and y
from packet */
+					Input->LastX = (signed
char)(PacketBuffer[1] | ((PacketBuffer[0] & 0x03) << 6));
+					Input->LastY = (signed
char)(PacketBuffer[2] | ((PacketBuffer[0] & 0x0c) << 4));
+
+					/* Determine the current state
of the buttons */
+					Input->RawButtons =
(DeviceExtension->PreviousButtons & MOUSE_BUTTON_MIDDLE) |
+						((UCHAR)(PacketBuffer[0]
& LEFT_BUTTON_MASK) >> LEFT_BUTTON_SHIFT) |
+						((UCHAR)(PacketBuffer[0]
& RIGHT_BUTTON_MASK) >> RIGHT_BUTTON_SHIFT);
+				}
+				else if
(DeviceExtension->PacketBufferPosition == 4)
+				{
+
DeviceExtension->PacketBufferPosition = 0;
+					/* If middle button state
changed than report event */
+					if (((UCHAR)(PacketBuffer[3] &
MIDDLE_BUTTON_MASK) >> MIDDLE_BUTTON_SHIFT) ^
+
(DeviceExtension->PreviousButtons & MOUSE_BUTTON_MIDDLE))
+					{
+						Input->RawButtons ^=
MOUSE_BUTTON_MIDDLE;
+						Input->LastX = 0;
+						Input->LastY = 0;
+					}
+					else
+					{
+						continue;
+					}
+				}
[truncated at 1000 lines; 526 more skipped]