able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/input/mouser/mseries.c

1086 lines
27 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990-1998 Microsoft Corporation, All Rights Reserved
Copyright (c) 1993 Logitech Inc.
Module Name:
mseries.c
Abstract:
Environment:
Kernel mode only.
Notes:
Revision History:
--*/
//
// Includes.
//
#include "ntddk.h"
#include "mouser.h"
#include "debug.h"
#include "cseries.h"
#include "mseries.h"
//
// Use the alloc_text pragma to specify the driver initialization routines
// (they can be paged out).
//
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE,MSerSetProtocol)
#pragma alloc_text(PAGE,MSerPowerUp)
#pragma alloc_text(PAGE,MSerPowerDown)
#pragma alloc_text(PAGE,MSerDetect)
#endif // ALLOC_PRAGMA
//
// Constants.
//
#define MSER_BAUDRATE 1200
#define MAX_RESET_BUFFER 8
#define MINIMUM_RESET_TIME (200 * MS_TO_100_NS)
//
// Microsoft Plus.
//
#define MP_SYNCH_BIT 0x40
#define MP_BUTTON_LEFT 0x20
#define MP_BUTTON_RIGHT 0x10
#define MP_BUTTON_MIDDLE 0x20
#define MP_BUTTON_LEFT_SR 5
#define MP_BUTTON_RIGHT_SR 3
#define MP_BUTTON_MIDDLE_SR 3
#define MP_BUTTON_MIDDLE_MASK 0x04
#define MP_UPPER_MASKX 0x03
#define MP_UPPER_MASKY 0x0C
#define MP_UPPER_MASKX_SL 6
#define MP_UPPER_MASKY_SL 4
//
// Microsoft BallPoint.
//
#define BP_SYNCH_BIT 0x40
#define BP_BUTTON_LEFT 0x20
#define BP_BUTTON_RIGHT 0x10
#define BP_BUTTON_3 0x04
#define BP_BUTTON_4 0x08
#define BP_BUTTON_LEFT_SR 5
#define BP_BUTTON_RIGHT_SR 3
#define BP_BUTTON_3_SL 0
#define BP_BUTTON_4_SL 0
#define BP_UPPER_MASKX 0x03
#define BP_UPPER_MASKY 0x0C
#define BP_UPPER_MASKX_SL 6
#define BP_UPPER_MASKY_SL 4
#define BP_SIGN_MASKX 0x01
#define BP_SIGN_MASKY 0x02
//
// Microsoft Magellan Mouse.
//
#define Z_SYNCH_BIT 0x40
#define Z_EXTRA_BIT 0x20
#define Z_BUTTON_LEFT 0x20
#define Z_BUTTON_RIGHT 0x10
#define Z_BUTTON_MIDDLE 0x10
#define Z_BUTTON_LEFT_SR 5
#define Z_BUTTON_RIGHT_SR 3
#define Z_BUTTON_MIDDLE_SR 3
#define Z_BUTTON_MIDDLE_MASK 0x04
#define Z_UPPER_MASKX 0x03
#define Z_UPPER_MASKY 0x0C
#define Z_UPPER_MASKZ 0x0F
#define Z_LOWER_MASKZ 0x0F
#define Z_UPPER_MASKX_SL 6
#define Z_UPPER_MASKY_SL 4
#define Z_UPPER_MASKZ_SL 4
//
// Type definitions.
//
typedef struct _PROTOCOL {
PPROTOCOL_HANDLER Handler;
// UCHAR LineCtrl;
SERIAL_LINE_CONTROL LineCtrl;
} PROTOCOL;
//
// This list is indexed by protocol values MSER_PROTOCOL_*.
//
static PROTOCOL Protocol[] = {
{
MSerHandlerMP, // Microsoft Plus
// ACE_7BW | ACE_1SB
{ STOP_BIT_1, NO_PARITY, 7 }
},
{
MSerHandlerBP, // BALLPOINT
// ACE_7BW | ACE_1SB
{ STOP_BIT_1, NO_PARITY, 7 }
},
{
MSerHandlerZ, // Magellan Mouse
// ACE_7BW | ACE_1SB
{ STOP_BIT_1, NO_PARITY, 7 }
}
};
PPROTOCOL_HANDLER
MSerSetProtocol(
PDEVICE_EXTENSION DeviceExtension,
UCHAR NewProtocol
)
/*++
Routine Description:
Set the mouse protocol. This function only sets the serial port
line control register.
Arguments:
Port - Pointer to the serial port.
NewProtocol - Index into the protocol table.
Return Value:
Pointer to the protocol handler function.
--*/
{
ASSERT(NewProtocol < MSER_PROTOCOL_MAX);
PAGED_CODE();
Print(DeviceExtension, DBG_SS_TRACE, ("MSerSetProtocol called\n"));
//
// Set the protocol
//
SerialMouseSetLineCtrl(DeviceExtension, &Protocol[NewProtocol].LineCtrl);
return Protocol[NewProtocol].Handler;
}
NTSTATUS
MSerPowerUp(
PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
Powers up the mouse. Just sets the RTS and DTR lines and returns.
Arguments:
Port - Pointer to the serial port.
Return Value:
TRUE.
--*/
{
IO_STATUS_BLOCK iosb;
NTSTATUS status;
KEVENT event;
PAGED_CODE();
Print(DeviceExtension, DBG_SS_TRACE, ("MSerPowerUp called\n"));
KeInitializeEvent(&event, NotificationEvent, FALSE);
//
// Clear DTR
//
Print(DeviceExtension, DBG_SS_NOISE, ("Clearing DTR...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_CLR_DTR,
DeviceExtension->TopOfStack,
&event,
&iosb
);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Clear RTS
//
Print(DeviceExtension, DBG_SS_NOISE, ("Clearing RTS...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_CLR_RTS,
DeviceExtension->TopOfStack,
&event,
&iosb
);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Set a timer for 200 ms
//
status = SerialMouseWait(DeviceExtension, -PAUSE_200_MS);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("Timer failed with status %x\n", status ));
return status;
}
//
// set DTR
//
Print(DeviceExtension, DBG_SS_NOISE, ("Setting DTR...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_SET_DTR,
DeviceExtension->TopOfStack,
&event,
&iosb
);
if (!NT_SUCCESS(status)) {
return status;
}
status = SerialMouseWait(DeviceExtension, -PAUSE_200_MS);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("Timer failed with status %x\n", status ));
return status;
}
//
// set RTS
//
Print(DeviceExtension, DBG_SS_NOISE, ("Setting RTS...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_SET_RTS,
DeviceExtension->TopOfStack,
&event,
&iosb
);
status = SerialMouseWait(DeviceExtension, -175 * MS_TO_100_NS);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("Timer failed with status %x\n", status ));
return status;
}
return status;
}
NTSTATUS
MSerPowerDown(
PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
Powers down the mouse. Sets the RTS line to an inactive state.
Arguments:
Port - Pointer to the serial port.
Return Value:
TRUE.
--*/
{
IO_STATUS_BLOCK iosb;
SERIAL_HANDFLOW shf;
KEVENT event;
NTSTATUS status;
ULONG bits;
PAGED_CODE();
Print(DeviceExtension, DBG_SS_TRACE, ("MSerPowerDown called\n"));
KeInitializeEvent(&event,
NotificationEvent,
FALSE
);
#if 0
//
// Set the handflow to default values
//
Print(DeviceExtension, DBG_SS_NOISE,
("Setting handflow to default values...\n"));
shf.ControlHandShake = SERIAL_DTR_CONTROL;
shf.FlowReplace = SERIAL_RTS_CONTROL;
shf.XonLimit = 0;
shf.XoffLimit = 0;
status = SerialMouseIoSyncIoctlEx(IOCTL_SERIAL_SET_HANDFLOW,
DeviceExtension->TopOfStack,
&event,
&iosb,
&shf,
sizeof(SERIAL_HANDFLOW),
NULL,
0);
if (!NT_SUCCESS(status)) {
return status;
}
#endif
//
// Set DTR
//
Print(DeviceExtension, DBG_SS_NOISE, ("Setting DTR...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_SET_DTR,
DeviceExtension->TopOfStack,
&event,
&iosb);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Clear RTS
//
Print(DeviceExtension, DBG_SS_NOISE, ("Clearing RTS...\n"));
status = SerialMouseIoSyncIoctl(IOCTL_SERIAL_CLR_RTS,
DeviceExtension->TopOfStack,
&event,
&iosb);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Set a timer for 200 ms
//
status = SerialMouseWait(DeviceExtension, -PAUSE_200_MS);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("Timer failed with status %x\n", status));
return status;
}
return status;
}
#define BUFFER_SIZE 256
MOUSETYPE
MSerDetect(
PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
Detection code for pointing devices that identify themselves at
power on time.
Arguments:
Port - Pointer to the serial port.
BaudClock - The external frequency driving the serial chip.
Return Value:
The type of mouse detected.
--*/
{
ULONG count = 0;
MOUSETYPE mouseType = NO_MOUSE;
NTSTATUS status;
ULONG i;
CHAR receiveBuffer[BUFFER_SIZE];
PAGED_CODE();
Print(DeviceExtension, DBG_SS_TRACE,
("MSerDetect enter\n"));
status = SerialMouseInitializePort(DeviceExtension);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("Initializing the port failed (%x)\n", status));
// return status;
}
status = MSerPowerDown(DeviceExtension);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR,
("PowerDown failed (%x)\n", status));
// return status;
}
//
// Set the baud rate.
//
SerialMouseSetBaudRate(DeviceExtension, MSER_BAUDRATE);
//
// Set the data format so that the possible answer can be recognized.
//
SerialMouseSetLineCtrl(DeviceExtension,
&Protocol[MSER_PROTOCOL_MP].LineCtrl);
//
// Clean possible garbage in uart input buffer.
//
SerialMouseFlushReadBuffer(DeviceExtension);
status = MSerPowerUp(DeviceExtension);
if (!NT_SUCCESS(status)) {
Print(DeviceExtension, DBG_SS_ERROR, ("Powerup failed (%x)\n", status));
}
//
// Get the possible first reset character ('M' or 'B'), followed
// by any other characters the hardware happens to send back.
//
// Note: Typically, we expect to get just one character ('M' or
// 'B'), perhaps followed by a '2' or '3' (to indicate the
// number of mouse buttons. On some machines, we're
// getting extraneous characters before the 'M'.
// We get extraneous characters after the expected data if this a
// true PnP comm device
//
ASSERT(CSER_POWER_UP >= MINIMUM_RESET_TIME);
status = SerialMouseSetReadTimeouts(DeviceExtension, 200);
if (NT_SUCCESS(SerialMouseReadChar(DeviceExtension,
&receiveBuffer[count]))) {
count++;
SerialMouseSetReadTimeouts(DeviceExtension, 100);
while (count < (BUFFER_SIZE - 1)) {
if (NT_SUCCESS(SerialMouseReadChar(DeviceExtension,
&receiveBuffer[count]))) {
count++;
} else {
break;
}
}
}
*(receiveBuffer + count) = 0;
Print(DeviceExtension, DBG_SS_NOISE, ("Receive buffer:\n"));
for (i = 0; i < count; i++) {
Print(DeviceExtension, DBG_SS_NOISE, ("\t0x%x\n", receiveBuffer[i]));
}
//
//
// Analyze the possible mouse answer. Start at the beginning of the
// "good" data in the receive buffer, ignoring extraneous characters
// that may have come in before the 'M' or 'B'.
//
for (i = 0; i < count; i++) {
if (receiveBuffer[i] == 'M') {
if (receiveBuffer[i + 1] == '3') {
Print(DeviceExtension, DBG_SS_INFO,
("Detected MSeries 3 buttons\n"));
mouseType = MOUSE_3B;
}
else if (receiveBuffer[i + 1] == 'Z') {
Print(DeviceExtension, DBG_SS_INFO,
("Detected Wheel Mouse\n"));
mouseType = MOUSE_Z;
}
else {
Print(DeviceExtension, DBG_SS_INFO,
("Detected MSeries 2 buttons\n"));
mouseType = MOUSE_2B;
}
break;
} else if (receiveBuffer[i] == 'B') {
Print(DeviceExtension, DBG_SS_INFO,
("Detected Ballpoint\n"));
mouseType = BALLPOINT;
break;
}
}
if (i >= count) {
//
// Special case: If another device is connected (CSeries, for
// example) and this device sends a character (movement), the
// minimum power up time might not be respected. Take
// care of this unlikely case.
//
if (count != 0) {
SerialMouseWait(DeviceExtension, -CSER_POWER_UP);
}
Print(DeviceExtension, DBG_SS_ERROR | DBG_SS_INFO,
("No MSeries detected\n"));
mouseType = NO_MOUSE;
}
//
// Make sure that all subsequent reads are blocking and do not timeout
//
if (mouseType != NO_MOUSE) {
SerialMouseSetReadTimeouts(DeviceExtension, 0);
}
Print(DeviceExtension, DBG_SS_INFO,
("mouse type is %d\n", (ULONG) mouseType));
return mouseType;
}
BOOLEAN
MSerHandlerMP(
IN PDEVICE_EXTENSION DeviceExtension,
IN PMOUSE_INPUT_DATA CurrentInput,
IN PHANDLER_DATA HandlerData,
IN UCHAR Value,
IN UCHAR LineState
)
/*++
Routine Description:
This is the protocol handler routine for the Microsoft Plus protocol.
Arguments:
CurrentInput - Pointer to the report packet.
HandlerData - Instance specific static data for the handler.
Value - The input buffer value.
LineState - The serial port line state.
Return Value:
Returns TRUE if the handler has a complete report ready.
--*/
{
BOOLEAN retval = FALSE;
ULONG middleButton;
Print(DeviceExtension, DBG_HANDLER_TRACE, ("MP protocol handler, enter\n"));
if ((Value & MP_SYNCH_BIT) && (HandlerData->State != STATE0)) {
if ((HandlerData->State != STATE3)) {
//
// We definitely have a synchronization problem (likely a data
// overrun).
//
HandlerData->Error++;
}
else if ((HandlerData->PreviousButtons & MOUSE_BUTTON_3) != 0) {
//
// We didn't receive the expected fourth byte. Missed it?
// Reset button 3 to zero.
//
HandlerData->PreviousButtons ^= MOUSE_BUTTON_3;
HandlerData->Error++;
}
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Synch error. State: %u\n",
HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & MP_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Synch error. State: %u\n",
HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
// if (LineState & ACE_LERR) {
if (0) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
Print(DeviceExtension, DBG_HANDLER_NOISE,
("State%u\n", HandlerData->State));
switch (HandlerData->State) {
case STATE0:
case STATE1:
HandlerData->State++;
break;
case STATE2:
HandlerData->State++;
//
// Build the report.
//
CurrentInput->RawButtons =
(HandlerData->Raw[0] & MP_BUTTON_LEFT) >> MP_BUTTON_LEFT_SR;
CurrentInput->RawButtons |=
(HandlerData->Raw[0] & MP_BUTTON_RIGHT) >> MP_BUTTON_RIGHT_SR;
CurrentInput->RawButtons |=
HandlerData->PreviousButtons & MOUSE_BUTTON_3;
CurrentInput->LastX =
(SCHAR)(HandlerData->Raw[1] |
((HandlerData->Raw[0] & MP_UPPER_MASKX) << MP_UPPER_MASKX_SL));
CurrentInput->LastY =
(SCHAR)(HandlerData->Raw[2] |
((HandlerData->Raw[0] & MP_UPPER_MASKY) << MP_UPPER_MASKY_SL));
retval = TRUE;
break;
case STATE3:
HandlerData->State = STATE0;
middleButton =
(HandlerData->Raw[STATE3] & MP_BUTTON_MIDDLE) >> MP_BUTTON_MIDDLE_SR;
//
// Send a report only if the middle button state changed.
//
if (middleButton ^ (HandlerData->PreviousButtons & MOUSE_BUTTON_3)) {
//
// Toggle the state of the middle button.
//
CurrentInput->RawButtons ^= MP_BUTTON_MIDDLE_MASK;
CurrentInput->LastX = 0;
CurrentInput->LastY = 0;
//
// Send the report one more time.
//
retval = TRUE;
}
break;
default:
Print(DeviceExtension, DBG_HANDLER_ERROR,
("MP Handler failure: incorrect state value.\n"
));
ASSERT(FALSE);
}
}
LExit:
Print(DeviceExtension, DBG_HANDLER_TRACE, ("MP protocol handler: exit\n"));
return retval;
}
BOOLEAN
MSerHandlerBP(
IN PDEVICE_EXTENSION DeviceExtension,
IN PMOUSE_INPUT_DATA CurrentInput,
IN PHANDLER_DATA HandlerData,
IN UCHAR Value,
IN UCHAR LineState
)
/*++
Routine Description:
This is the protocol handler routine for the Microsoft Ballpoint protocol.
Arguments:
CurrentInput - Pointer to the report packet.
HandlerData - Instance specific static data for the handler.
Value - The input buffer value.
LineState - The serial port line state.
Return Value:
Returns TRUE if the handler has a complete report ready.
--*/
{
BOOLEAN retval = FALSE;
Print(DeviceExtension, DBG_HANDLER_TRACE, ("BP protocol handler, enter\n"));
//
// Check for synchronization errors.
//
if ((Value & BP_SYNCH_BIT) && (HandlerData->State != STATE0)) {
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Synch error. State: %u\n", HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & BP_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Synch error. State: %u\n", HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
//if (LineState & ACE_LERR) {
if (0) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_NOISE,
("Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
Print(DeviceExtension, DBG_HANDLER_NOISE,
("State%u\n", HandlerData->State));
switch (HandlerData->State) {
case STATE0:
case STATE1:
case STATE2:
HandlerData->State++;
break;
case STATE3:
HandlerData->State = STATE0;
//
// Build the report.
//
CurrentInput->RawButtons =
(HandlerData->Raw[0] & BP_BUTTON_LEFT) >> BP_BUTTON_LEFT_SR;
CurrentInput->RawButtons |=
(HandlerData->Raw[0] & BP_BUTTON_RIGHT) >> BP_BUTTON_RIGHT_SR;
#if 0
CurrentInput->ButtonFlags |=
(HandlerData->Raw[3] & BP_BUTTON_3) << BP_BUTTON_3_SL;
CurrentInput->ButtonFlags |=
(HandlerData->Raw[3] & BP_BUTTON_4) << BP_BUTTON_4_SL;
#endif
CurrentInput->LastX = HandlerData->Raw[3] & BP_SIGN_MASKX ?
(LONG)(HandlerData->Raw[1] | (ULONG)(-1 & ~0xFF) |
((HandlerData->Raw[0] & BP_UPPER_MASKX) << BP_UPPER_MASKX_SL)):
(LONG)(HandlerData->Raw[1] |
((HandlerData->Raw[0] & BP_UPPER_MASKX) << BP_UPPER_MASKX_SL));
CurrentInput->LastY = HandlerData->Raw[3] & BP_SIGN_MASKY ?
(LONG)(HandlerData->Raw[2] | (ULONG)(-1 & ~0xFF) |
((HandlerData->Raw[0] & BP_UPPER_MASKY) << BP_UPPER_MASKY_SL)):
(LONG)(HandlerData->Raw[2] |
((HandlerData->Raw[0] & BP_UPPER_MASKY) << BP_UPPER_MASKY_SL));
retval = TRUE;
break;
default:
Print(DeviceExtension, DBG_HANDLER_ERROR,
("BP Handler failure: incorrect state value.\n"
));
ASSERT(FALSE);
}
}
LExit:
Print(DeviceExtension, DBG_HANDLER_TRACE, ("BP protocol handler: exit\n"));
return retval;
}
BOOLEAN
MSerHandlerZ(
IN PDEVICE_EXTENSION DeviceExtension,
IN PMOUSE_INPUT_DATA CurrentInput,
IN PHANDLER_DATA HandlerData,
IN UCHAR Value,
IN UCHAR LineState
)
/*++
Routine Description:
This is the protocol handler routine for the Microsoft Magellan Mouse
(wheel mouse)
Arguments:
CurrentInput - Pointer to the report packet.
HandlerData - Instance specific static data for the handler.
Value - The input buffer value.
LineState - The serial port line state.
Return Value:
Returns TRUE if the handler has a complete report ready.
--*/
{
BOOLEAN retval = FALSE;
ULONG middleButton;
CHAR zMotion = 0;
Print(DeviceExtension, DBG_HANDLER_TRACE, ("Z protocol handler, enter\n"));
if ((Value & Z_SYNCH_BIT) && (HandlerData->State != STATE0)) {
if ((HandlerData->State != STATE3)) {
//
// We definitely have a synchronization problem (likely a data
// overrun).
//
HandlerData->Error++;
}
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Z Synch error #1. State: %u\n", HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & Z_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Z Synch error #2. State: %u\n", HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
// if (LineState & ACE_LERR) {
if (0) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Z Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
Print(DeviceExtension, DBG_HANDLER_NOISE,
("Z State%u\n", HandlerData->State));
switch (HandlerData->State) {
case STATE0:
case STATE1:
case STATE2:
HandlerData->State++;
break;
case STATE3:
//
// Check to see if the mouse is going to the high bits of
// the wheel movement. If not, this is the last bit - transition
// back to state0
//
if((HandlerData->Raw[STATE3] & Z_EXTRA_BIT) == 0) {
HandlerData->State = STATE0;
HandlerData->Raw[STATE4] = 0;
retval = TRUE;
}
else {
HandlerData->State++;
}
break;
case STATE4:
Print(DeviceExtension, DBG_HANDLER_NOISE,
("Z Got that 5th byte\n"));
HandlerData->State = STATE0;
retval = TRUE;
break;
default:
Print(DeviceExtension, DBG_HANDLER_ERROR,
("Z Handler failure: incorrect state value.\n"
));
ASSERT(FALSE);
}
if (retval) {
CurrentInput->RawButtons = 0;
if(HandlerData->Raw[STATE0] & Z_BUTTON_LEFT) {
CurrentInput->RawButtons |= MOUSE_BUTTON_LEFT;
}
if(HandlerData->Raw[STATE0] & Z_BUTTON_RIGHT) {
CurrentInput->RawButtons |= MOUSE_BUTTON_RIGHT;
}
if(HandlerData->Raw[STATE3] & Z_BUTTON_MIDDLE) {
CurrentInput->RawButtons |= MOUSE_BUTTON_MIDDLE;
}
CurrentInput->LastX =
(SCHAR)(HandlerData->Raw[STATE1] |
((HandlerData->Raw[0] & Z_UPPER_MASKX) << Z_UPPER_MASKX_SL));
CurrentInput->LastY =
(SCHAR)(HandlerData->Raw[STATE2] |
((HandlerData->Raw[0] & Z_UPPER_MASKY) << Z_UPPER_MASKY_SL));
//
// If the extra bit isn't set then the 4th byte contains
// a 4 bit signed quantity for the wheel movement. if it
// is set, then we need to combine the z info from the
// two bytes
//
if((HandlerData->Raw[STATE3] & Z_EXTRA_BIT) == 0) {
zMotion = HandlerData->Raw[STATE3] & Z_LOWER_MASKZ;
//
// Sign extend the 4 bit
//
if(zMotion & 0x08) {
zMotion |= 0xf0;
}
} else {
zMotion = ((HandlerData->Raw[STATE3] & Z_LOWER_MASKZ) |
((HandlerData->Raw[STATE4] & Z_UPPER_MASKZ)
<< Z_UPPER_MASKZ_SL));
}
if(zMotion == 0) {
CurrentInput->ButtonData = 0;
} else {
CurrentInput->ButtonData = 0x0078;
if(zMotion & 0x80) {
CurrentInput->ButtonData = 0x0078;
} else {
CurrentInput->ButtonData = 0xff88;
}
CurrentInput->ButtonFlags |= MOUSE_WHEEL;
}
}
}
LExit:
Print(DeviceExtension, DBG_HANDLER_TRACE, ("Z protocol handler: exit\n"));
return retval;
}
Reference in a new issue Copy permalink