sermouse.h File Reference

#include <ntddk.h>
#include <ntddser.h>
#include <kbdmou.h>

Include dependency graph for sermouse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SERMOUSE_DRIVER_EXTENSION
struct	_SERMOUSE_DEVICE_EXTENSION

Macros
#define	SERMOUSE_TAG   'uoMS'
#define	PACKET_BUFFER_SIZE   4
#define	LEFT_BUTTON_MASK   0x20
#define	LEFT_BUTTON_SHIFT   5
#define	RIGHT_BUTTON_MASK   0x10
#define	RIGHT_BUTTON_SHIFT   3
#define	MIDDLE_BUTTON_MASK   0x20
#define	MIDDLE_BUTTON_SHIFT   3
#define	MOUSE_BUTTON_LEFT   0x01
#define	MOUSE_BUTTON_RIGHT   0x02
#define	MOUSE_BUTTON_MIDDLE   0x04

Typedefs
typedef struct _SERMOUSE_DRIVER_EXTENSION	SERMOUSE_DRIVER_EXTENSION
typedef struct _SERMOUSE_DRIVER_EXTENSION *	PSERMOUSE_DRIVER_EXTENSION
typedef struct _SERMOUSE_DEVICE_EXTENSION	SERMOUSE_DEVICE_EXTENSION
typedef struct _SERMOUSE_DEVICE_EXTENSION *	PSERMOUSE_DEVICE_EXTENSION

Enumerations
enum	SERMOUSE_DEVICE_STATE {   dsStopped , dsStarted , dsPaused , dsRemoved ,   dsSurpriseRemoved }
enum	SERMOUSE_MOUSE_TYPE { mtNone , mtMicrosoft , mtLogitech , mtWheelZ }

Functions
SERMOUSE_MOUSE_TYPE	SermouseDetectLegacyDevice (IN PDEVICE_OBJECT LowerDevice)
NTSTATUS NTAPI	ForwardIrpAndForget (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	SermouseDeviceWorker (PVOID Context)

Variables
DRIVER_DISPATCH	SermouseCreate
DRIVER_DISPATCH	SermouseClose
DRIVER_DISPATCH	SermouseCleanup
DRIVER_ADD_DEVICE	SermouseAddDevice
DRIVER_DISPATCH	SermousePnp
DRIVER_DISPATCH	SermouseInternalDeviceControl

Macro Definition Documentation

LEFT_BUTTON_MASK

#define LEFT_BUTTON_MASK   0x20

Definition at line 31 of file sermouse.h.

LEFT_BUTTON_SHIFT

#define LEFT_BUTTON_SHIFT   5

Definition at line 33 of file sermouse.h.

MIDDLE_BUTTON_MASK

#define MIDDLE_BUTTON_MASK   0x20

Definition at line 39 of file sermouse.h.

MIDDLE_BUTTON_SHIFT

#define MIDDLE_BUTTON_SHIFT   3

Definition at line 41 of file sermouse.h.

MOUSE_BUTTON_LEFT

#define MOUSE_BUTTON_LEFT   0x01

Definition at line 44 of file sermouse.h.

MOUSE_BUTTON_MIDDLE

#define MOUSE_BUTTON_MIDDLE   0x04

Definition at line 48 of file sermouse.h.

MOUSE_BUTTON_RIGHT

#define MOUSE_BUTTON_RIGHT   0x02

Definition at line 46 of file sermouse.h.

PACKET_BUFFER_SIZE

#define PACKET_BUFFER_SIZE   4

Definition at line 28 of file sermouse.h.

RIGHT_BUTTON_MASK

#define RIGHT_BUTTON_MASK   0x10

Definition at line 35 of file sermouse.h.

RIGHT_BUTTON_SHIFT

#define RIGHT_BUTTON_SHIFT   3

Definition at line 37 of file sermouse.h.

SERMOUSE_TAG

#define SERMOUSE_TAG   'uoMS'

Definition at line 8 of file sermouse.h.

Typedef Documentation

PSERMOUSE_DEVICE_EXTENSION

typedef struct _SERMOUSE_DEVICE_EXTENSION * PSERMOUSE_DEVICE_EXTENSION

PSERMOUSE_DRIVER_EXTENSION

typedef struct _SERMOUSE_DRIVER_EXTENSION * PSERMOUSE_DRIVER_EXTENSION

SERMOUSE_DEVICE_EXTENSION

typedef struct _SERMOUSE_DEVICE_EXTENSION SERMOUSE_DEVICE_EXTENSION

SERMOUSE_DRIVER_EXTENSION

typedef struct _SERMOUSE_DRIVER_EXTENSION SERMOUSE_DRIVER_EXTENSION

Enumeration Type Documentation

SERMOUSE_DEVICE_STATE

enum SERMOUSE_DEVICE_STATE

Enumerator
dsStopped
dsStarted
dsPaused
dsRemoved
dsSurpriseRemoved

Definition at line 10 of file sermouse.h.

{
  dsStopped,
  dsStarted,
  dsPaused,
  dsRemoved,
  dsSurpriseRemoved
} SERMOUSE_DEVICE_STATE;

SERMOUSE_MOUSE_TYPE

enum SERMOUSE_MOUSE_TYPE

Enumerator
mtNone
mtMicrosoft
mtLogitech
mtWheelZ

Definition at line 19 of file sermouse.h.

{
    mtNone,      /* No Mouse */
    mtMicrosoft, /* Microsoft Mouse with 2 buttons */
    mtLogitech,  /* Logitech Mouse with 3 buttons */
    mtWheelZ     /* Microsoft Wheel Mouse (aka Z Mouse) */
} SERMOUSE_MOUSE_TYPE;

Function Documentation

ForwardIrpAndForget()

NTSTATUS NTAPI ForwardIrpAndForget	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 18 of file misc.c.

{
    PDEVICE_OBJECT LowerDevice = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->LowerDevice;
 
    ASSERT(LowerDevice);
 
    IoSkipCurrentIrpStackLocation(Irp);
    return IoCallDriver(LowerDevice, Irp);
}

SermouseDetectLegacyDevice()

SERMOUSE_MOUSE_TYPE SermouseDetectLegacyDevice

(

IN PDEVICE_OBJECT

LowerDevice

)

Definition at line 117 of file detect.c.

{
    HANDLE Handle;
    ULONG Fcr, Mcr;
    ULONG BaudRate;
    ULONG Command;
    SERIAL_TIMEOUTS Timeouts;
    SERIAL_LINE_CONTROL LCR;
    ULONG_PTR i, Count = 0;
    UCHAR Buffer[16];
    SERMOUSE_MOUSE_TYPE MouseType = mtNone;
    NTSTATUS Status;
 
    TRACE_(SERMOUSE, "SermouseDetectLegacyDevice(LowerDevice %p)\n", LowerDevice);
 
    RtlZeroMemory(Buffer, sizeof(Buffer));
 
    /* Open port */
    Status = ObOpenObjectByPointer(
        LowerDevice,
        OBJ_KERNEL_HANDLE,
        NULL,
        0,
        NULL,
        KernelMode,
        &Handle);
    if (!NT_SUCCESS(Status)) return mtNone;
 
    /* Reset UART */
    TRACE_(SERMOUSE, "Reset UART\n");
    Mcr = 0; /* MCR: DTR/RTS/OUT2 off */
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL,
        &Mcr, sizeof(Mcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Set communications parameters */
    TRACE_(SERMOUSE, "Set communications parameters\n");
    /* DLAB off */
    Fcr = 0;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_FIFO_CONTROL,
        &Fcr, sizeof(Fcr), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    /* Set serial port speed */
    BaudRate = 1200;
    Status = DeviceIoControl(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 = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_LINE_CONTROL,
        &LCR, sizeof(LCR), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Flush receive buffer */
    TRACE_(SERMOUSE, "Flush receive buffer\n");
    Command = SERIAL_PURGE_RXCLEAR;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_MODEM_CONTROL,
        &Command, sizeof(Command), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    /* Wait 100 ms */
    Wait(100);
 
    /* Enable DTR/RTS */
    TRACE_(SERMOUSE, "Enable DTR/RTS\n");
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_DTR,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_RTS,
        NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Set timeout to 500 microseconds */
    TRACE_(SERMOUSE, "Set timeout to 500 microseconds\n");
    Timeouts.ReadIntervalTimeout = 100;
    Timeouts.ReadTotalTimeoutMultiplier = 0;
    Timeouts.ReadTotalTimeoutConstant = 500;
    Timeouts.WriteTotalTimeoutMultiplier = Timeouts.WriteTotalTimeoutConstant = 0;
    Status = DeviceIoControl(LowerDevice, IOCTL_SERIAL_SET_TIMEOUTS,
        &Timeouts, sizeof(Timeouts), NULL, NULL);
    if (!NT_SUCCESS(Status)) goto ByeBye;
 
    /* Fill the read buffer */
    TRACE_(SERMOUSE, "Fill the read buffer\n");
    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 */
            ERR_(SERMOUSE, "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':
                    INFO_(SERMOUSE, "Microsoft Mouse with 3-buttons detected\n");
                    MouseType = mtLogitech;
                    break;
                case 'Z':
                    INFO_(SERMOUSE, "Microsoft Wheel Mouse detected\n");
                    MouseType = mtWheelZ;
                    break;
                default:
                    INFO_(SERMOUSE, "Microsoft Mouse with 2-buttons detected\n");
                    MouseType = mtMicrosoft;
                    break;
            }
            goto ByeBye;
        }
    }
 
ByeBye:
    /* Close port */
    if (Handle)
        ZwClose(Handle);
    return MouseType;
}

Referenced by SermouseStartDevice().

SermouseDeviceWorker()

VOID NTAPI SermouseDeviceWorker

(

PVOID

Context

)

Definition at line 64 of file readmouse.c.

{
    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;
 
    TRACE_(SERMOUSE, "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->AttributesInformation.SampleRate * 8;
    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 */
    RtlZeroMemory(Buffer, PACKET_BUFFER_SIZE);
    while (TRUE)
    {
        Status = KeWaitForSingleObject(
            &DeviceExtension->StopWorkerThreadEvent,
            Executive,
            KernelMode,
            TRUE,
            &Zero);
        if (Status != STATUS_TIMEOUT)
        {
            /* we need to stop the worker thread */
            KeClearEvent(&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 */
            INFO_(SERMOUSE, "No memory actually, trying again\n");
            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];
            INFO_(SERMOUSE, "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] == 1)
                    continue;
 
                Input = &DeviceExtension->MouseInputData[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;
                    }
                }
 
                /* Determine ButtonFlags */
                Input->ButtonFlags = 0;
                ButtonsDifference = DeviceExtension->PreviousButtons ^ Input->RawButtons;
 
                if (ButtonsDifference != 0)
                {
                    if (ButtonsDifference & MOUSE_BUTTON_LEFT
                        && DeviceExtension->AttributesInformation.NumberOfButtons >= 1)
                    {
                        if (Input->RawButtons & MOUSE_BUTTON_LEFT)
                            Input->ButtonFlags |= MOUSE_LEFT_BUTTON_DOWN;
                        else
                            Input->ButtonFlags |= MOUSE_LEFT_BUTTON_UP;
                    }
 
                    if (ButtonsDifference & MOUSE_BUTTON_RIGHT
                        && DeviceExtension->AttributesInformation.NumberOfButtons >= 2)
                    {
                        if (Input->RawButtons & MOUSE_BUTTON_RIGHT)
                            Input->ButtonFlags |= MOUSE_RIGHT_BUTTON_DOWN;
                        else
                            Input->ButtonFlags |= MOUSE_RIGHT_BUTTON_UP;
                    }
 
                    if (ButtonsDifference & MOUSE_BUTTON_MIDDLE
                        && DeviceExtension->AttributesInformation.NumberOfButtons >= 3)
                    {
                        if (Input->RawButtons & MOUSE_BUTTON_MIDDLE)
                            Input->ButtonFlags |= MOUSE_MIDDLE_BUTTON_DOWN;
                        else
                            Input->ButtonFlags |= MOUSE_MIDDLE_BUTTON_UP;
                    }
                }
 
                /* Send the Input data to the Mouse Class driver */
                DeviceExtension->InputDataCount[Queue]++;
 
                KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
                InterlockedIncrement((PLONG)&DeviceExtension->ActiveQueue);
                (*(PSERVICE_CALLBACK_ROUTINE)DeviceExtension->ConnectData.ClassService)(
                    DeviceExtension->ConnectData.ClassDeviceObject,
                    &DeviceExtension->MouseInputData[Queue],
                    &DeviceExtension->MouseInputData[Queue] + 1,
                    &DeviceExtension->InputDataCount[Queue]);
                KeLowerIrql(OldIrql);
                DeviceExtension->InputDataCount[Queue] = 0;
 
                /* Copy RawButtons to Previous Buttons for Input */
                DeviceExtension->PreviousButtons = Input->RawButtons;
            }
        }
    }
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by SermouseStartDevice().

Variable Documentation

SermouseAddDevice

DRIVER_ADD_DEVICE SermouseAddDevice

Definition at line 91 of file sermouse.h.

Referenced by DriverEntry().

SermouseCleanup

DRIVER_DISPATCH SermouseCleanup

Definition at line 81 of file sermouse.h.

Referenced by DriverEntry().

SermouseClose

DRIVER_DISPATCH SermouseClose

Definition at line 79 of file sermouse.h.

Referenced by DriverEntry().

SermouseCreate

DRIVER_DISPATCH SermouseCreate

Definition at line 77 of file sermouse.h.

Referenced by DriverEntry().

SermouseInternalDeviceControl

DRIVER_DISPATCH SermouseInternalDeviceControl

Definition at line 97 of file sermouse.h.

Referenced by DriverEntry().

SermousePnp

DRIVER_DISPATCH SermousePnp

Definition at line 93 of file sermouse.h.

Referenced by DriverEntry().