archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/drivers/input/sermouse/mseries.c

965 lines
22 KiB
Raw Blame History

/*++
Copyright (c) 1993 Microsoft Corporation
Copyright (c) 1993 Logitech Inc.
Module Name:
mseries.c
Abstract:
Environment:
Kernel mode only.
Notes:
Revision History:
--*/
//
// Includes.
//
#include "ntddk.h"
#include "uart.h"
#include "sermouse.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(INIT,MSerSetProtocol)
#pragma alloc_text(INIT,MSerPowerUp)
#pragma alloc_text(INIT,MSerPowerDown)
#pragma alloc_text(INIT,MSerReset)
#pragma alloc_text(INIT,MSerDetect)
#endif // ALLOC_PRAGMA
//
// Constants.
//
#define MSER_BAUDRATE 1200
#define MAX_RESET_BUFFER 8
#define MINIMUM_RESET_TIME 200
//
// 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;
} PROTOCOL;
//
// This list is indexed by protocol values MSER_PROTOCOL_*.
//
static PROTOCOL Protocol[] = {
{
MSerHandlerMP, // Microsoft Plus
ACE_7BW | ACE_1SB
},
{
MSerHandlerBP, // BALLPOINT
ACE_7BW | ACE_1SB
},
{
MSerHandlerZ, // Magellan Mouse
ACE_7BW | ACE_1SB
}
};
PPROTOCOL_HANDLER
MSerSetProtocol(
PUCHAR Port,
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);
//
// Set the protocol
//
UARTSetLineCtrl(Port, Protocol[NewProtocol].LineCtrl);
return Protocol[NewProtocol].Handler;
}
BOOLEAN
MSerPowerUp(
PUCHAR Port
)
/*++
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.
--*/
{
//
// Turn RTS on to power the mouse up (DTR should already be on,
// but make extra sure).
//
UARTSetModemCtrl(Port, ACE_DTR | ACE_RTS);
//
// Wait 10 ms. The power-up response byte(s) should take at least
// this long to get transmitted.
//
KeStallExecutionProcessor(10 * MS_TO_MICROSECONDS);
return TRUE;
}
BOOLEAN
MSerPowerDown(
PUCHAR Port
)
/*++
Routine Description:
Powers down the mouse. Sets the RTS line to an inactive state.
Arguments:
Port - Pointer to the serial port.
Return Value:
TRUE.
--*/
{
UCHAR lineCtrl = UARTGetModemCtrl(Port);
SerMouPrint((
2,
"SERMOUSE-MSerPowerDown: The intial line control is: %#X\n",
lineCtrl & 0xFF
));
UARTSetModemCtrl(Port, (UCHAR) ((lineCtrl & ~ACE_RTS) | ACE_DTR));
//
// Keep RTS low for at least 150 ms, in order to correctly power
// down older Microsoft serial mice. Wait even longer to avoid
// sending some Logitech CSeries mice into the floating point world...
//
ASSERT(CSER_POWER_DOWN >= 150);
KeStallExecutionProcessor(CSER_POWER_DOWN * MS_TO_MICROSECONDS);
return TRUE;
}
BOOLEAN
MSerReset(
PUCHAR Port
)
/*++
Routine Description:
Reset the serial mouse.
Arguments:
Port - Pointer to the serial port.
Return Value:
TRUE.
--*/
{
//
// Remove mouse power if necessary.
//
MSerPowerDown(Port);
//
// Clean possible garbage in uart input buffer.
//
UARTFlushReadBuffer(Port);
//
// Power up the mouse (reset).
//
MSerPowerUp(Port);
return TRUE;
}
MOUSETYPE
MSerDetect(
PUCHAR Port,
ULONG BaudClock
)
/*++
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;
CHAR receiveBuffer[MAX_RESET_BUFFER];
ULONG i;
//
// Set the debug output to the main display to avoid timing problems.
//
SerMouSetDebugOutput(DBG_COLOR);
//
// Set the baud rate.
//
UARTSetBaudRate(Port, MSER_BAUDRATE, BaudClock);
//
// Set the data format so that the possible answer can be recognized.
//
UARTSetLineCtrl(Port, Protocol[MSER_PROTOCOL_MP].LineCtrl);
//
// Apply the reset to the mouse.
//
MSerReset(Port);
//
// 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'. Sometimes
// we get extraneous characters after the expected data, as
// well. They either get read in here, or get flushed
// when SerMouEnableInterrupts executes.
//
ASSERT(CSER_POWER_UP >= MINIMUM_RESET_TIME);
if (UARTReadChar(Port, &receiveBuffer[count], CSER_POWER_UP)) {
count++;
while (count < (MAX_RESET_BUFFER - 1)) {
if (UARTReadChar(Port, &receiveBuffer[count], 100)) {
count++;
} else {
break;
}
}
}
*(receiveBuffer + count) = 0;
SerMouPrint((2, "SERMOUSE-Receive buffer:\n"));
for (i = 0; i < count; i++) {
SerMouPrint((2, "\t0x%x\n", receiveBuffer[i]));
}
SerMouPrint((2, "\n"));
//
// Redirect the output to the serial port.
//
SerMouSetDebugOutput(DBG_SERIAL);
//
//
// 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') {
SerMouPrint((2, "SERMOUSE-Detected MSeries 3 buttons\n"));
mouseType = MOUSE_3B;
}
else if (receiveBuffer[i + 1] == 'Z') {
SerMouPrint((2, "SERMOUSE-Detected Wheel Mouse\n"));
mouseType = MOUSE_Z;
}
else {
SerMouPrint((2, "SERMOUSE-Detected MSeries 2 buttons\n"));
mouseType = MOUSE_2B;
}
break;
} else if (receiveBuffer[i] == 'B') {
SerMouPrint((2, "SERMOUSE-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) {
KeStallExecutionProcessor(CSER_POWER_UP * MS_TO_MICROSECONDS);
}
SerMouPrint((1, "SERMOUSE-No MSeries detected\n"));
mouseType = NO_MOUSE;
}
return mouseType;
}
BOOLEAN
MSerHandlerMP(
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;
SerMouPrint((2, "SERMOUSE-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++;
}
SerMouPrint((
1,
"SERMOUSE-Synch error. State: %u\n", HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & MP_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
SerMouPrint((
1,
"SERMOUSE-Synch error. State: %u\n", HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
if (LineState & ACE_LERR) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
SerMouPrint((1, "SERMOUSE-Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
SerMouPrint((3, "SERMOUSE-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:
SerMouPrint((
0,
"SERMOUSE-MP Handler failure: incorrect state value.\n"
));
ASSERT(FALSE);
}
}
LExit:
SerMouPrint((2, "SERMOUSE-MP protocol handler: exit\n"));
return retval;
}
BOOLEAN
MSerHandlerBP(
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;
SerMouPrint((2, "SERMOUSE-BP protocol handler: enter\n"));
//
// Check for synchronization errors.
//
if ((Value & BP_SYNCH_BIT) && (HandlerData->State != STATE0)) {
HandlerData->Error++;
SerMouPrint((
1,
"SERMOUSE-Synch error. State: %u\n", HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & BP_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
SerMouPrint((
1,
"SERMOUSE-Synch error. State: %u\n", HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
if (LineState & ACE_LERR) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
SerMouPrint((1, "SERMOUSE-Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
SerMouPrint((3, "SERMOUSE-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:
SerMouPrint((
0,
"SERMOUSE-BP Handler failure: incorrect state value.\n"
));
ASSERT(FALSE);
}
}
LExit:
SerMouPrint((2, "SERMOUSE-BP protocol handler: exit\n"));
return retval;
}
BOOLEAN
MSerHandlerZ(
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;
SerMouPrint((2, "SERMOUSE-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++;
}
SerMouPrint((
1,
"SERMOUSE-Z Synch error. State: %u\n", HandlerData->State
));
HandlerData->State = STATE0;
}
else if (!(Value & Z_SYNCH_BIT) && (HandlerData->State == STATE0)) {
HandlerData->Error++;
SerMouPrint((
1,
"SERMOUSE-Z Synch error. State: %u\n", HandlerData->State
));
goto LExit;
}
//
// Check for a line state error.
//
if (LineState & ACE_LERR) {
//
// Reset the handler state.
//
HandlerData->State = STATE0;
HandlerData->Error++;
SerMouPrint((1, "SERMOUSE-Z Line status error: %#x\n", LineState));
}
else {
//
// Set the untranslated value.
//
HandlerData->Raw[HandlerData->State] = Value;
SerMouPrint((3, "SERMOUSE-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;
}
break;
case STATE4:
DbgPrint("SERMOUSE-Z Got that 5th byte\n");
HandlerData->State = STATE0;
retval = TRUE;
break;
default:
SerMouPrint((
0,
"SERMOUSE-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:
SerMouPrint((2, "SERMOUSE-Z protocol handler: exit\n"));
return retval;
}