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.
1715 lines
58 KiB
1715 lines
58 KiB
|
|
/*++
|
|
|
|
Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
hidjoy.c
|
|
|
|
Abstract: This module contains routines Generate the HID report and
|
|
configure the joystick.
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
@@BEGIN_DDKSPLIT
|
|
Author:
|
|
|
|
Eliyas Yakub (Mar, 11, 1997)
|
|
|
|
Revision History:
|
|
|
|
Updated by Eliyas on Feb 5 1998
|
|
|
|
@@END_DDKSPLIT
|
|
|
|
--*/
|
|
|
|
#include "hidgame.h"
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text (INIT, HGM_DriverInit)
|
|
#pragma alloc_text (PAGE, HGM_SetupButtons)
|
|
#pragma alloc_text (PAGE, HGM_MapAxesFromDevExt)
|
|
#pragma alloc_text (PAGE, HGM_GenerateReport)
|
|
#pragma alloc_text (PAGE, HGM_JoystickConfig)
|
|
#pragma alloc_text (PAGE, HGM_InitAnalog)
|
|
/* Sample only functions */
|
|
#ifdef CHANGE_DEVICE
|
|
#pragma alloc_text (PAGE, HGM_ChangeHandler)
|
|
#pragma alloc_text (PAGE, HGM_DeviceChanged)
|
|
#endif /* CHANGE_DEVICE */
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* A few look up tables to translate the JOY_HWS_* flags into axis masks.
|
|
* These flags allow any axis to be polled on any of the four axis bits in
|
|
* the gameport. For example, the X axis on a standard joystick is found on
|
|
* bit 0 (LSB) and the Y axis is on bit 1; however many steering wheel/pedal
|
|
* controllers have X on bit 0 but Y on bit 2. Although very few of these
|
|
* combinations are known to be used, supporting all the flags only causes a
|
|
* little extra work on setup. For each axis, there are three flags, one for
|
|
* each of the possible non-standard bit masks. Since it is possible that
|
|
* more than one of these may be set the invalid combinations are marked so
|
|
* that they can be refused.
|
|
*/
|
|
|
|
|
|
|
|
#define NA ( 0x80 )
|
|
|
|
/*
|
|
* Short versions of bit masks for axes
|
|
*/
|
|
#define X1 AXIS_X
|
|
#define Y1 AXIS_Y
|
|
#define X2 AXIS_R
|
|
#define Y2 AXIS_Z
|
|
|
|
/*
|
|
* Per axis flag masks and look up tables.
|
|
* In each case, combinations with more than one bit set are invalid
|
|
*/
|
|
#define XMAPBITS (JOY_HWS_XISJ2Y | JOY_HWS_XISJ2X | JOY_HWS_XISJ1Y)
|
|
/*
|
|
* 0 0 0 0001
|
|
* 0 0 1 0010
|
|
* 0 1 0 0100
|
|
* 1 0 0 1000
|
|
*/
|
|
static const unsigned char XLU[8] = { X1,Y1,X2,NA,Y2,NA,NA,NA };
|
|
#define XMAPSHFT 7
|
|
|
|
#define YMAPBITS (JOY_HWS_YISJ2Y | JOY_HWS_YISJ2X | JOY_HWS_YISJ1X)
|
|
/* 0 0 0 0010
|
|
* 0 0 1 0001
|
|
* 0 1 0 0100
|
|
* 1 0 0 1000
|
|
*/
|
|
static const unsigned char YLU[8] = { Y1,X1,X2,NA,Y2,NA,NA,NA };
|
|
#define YMAPSHFT 10
|
|
|
|
#define RMAPBITS (JOY_HWS_RISJ2Y | JOY_HWS_RISJ1X | JOY_HWS_RISJ1Y)
|
|
/* 0 0 0 0100
|
|
* 0 0 1 0010
|
|
* 0 1 0 0001
|
|
* 1 0 0 1000
|
|
*/
|
|
static const unsigned char RLU[8] = { X2,Y1,X1,NA,Y2,NA,NA,NA };
|
|
#define RMAPSHFT 20
|
|
|
|
#define ZMAPBITS (JOY_HWS_ZISJ2X | JOY_HWS_ZISJ1X | JOY_HWS_ZISJ1Y)
|
|
/* 0 0 0 1000
|
|
* 0 0 1 0010
|
|
* 0 1 0 0001
|
|
* 1 0 0 0100
|
|
*/
|
|
static const unsigned char ZLU[8] = { Y2,Y1,X1,NA,X2,NA,NA,NA };
|
|
#define ZMAPSHFT 13
|
|
#define POVMAPBITS (JOY_HWS_POVISJ2X | JOY_HWS_POVISJ1X | JOY_HWS_POVISJ1Y)
|
|
/*
|
|
* POV is the same as Z but with a larger shift
|
|
*/
|
|
#define POVMAPSHFT 16
|
|
|
|
#undef X1
|
|
#undef Y1
|
|
#undef X2
|
|
#undef Y2
|
|
|
|
/*
|
|
* This translates from an axis bitmask to an axis value index. The elements
|
|
* used should be as follows (X marks unsed) { X, 0, 1, X, 2, X, X, X, 3 }.
|
|
*/
|
|
static const unsigned char cAxisIndexTable[9] = { 0, 0, 1, 0, 2, 0, 0, 0, 3 };
|
|
|
|
|
|
typedef enum _POV1
|
|
{
|
|
P1_NULL = 0x80,
|
|
P1_0,
|
|
P1_90,
|
|
P1_180,
|
|
P1_270
|
|
} POV1;
|
|
|
|
typedef enum _POV2
|
|
{
|
|
P2_NULL = 0xc0,
|
|
P2_0,
|
|
P2_90,
|
|
P2_180,
|
|
P2_270
|
|
} POV2;
|
|
|
|
#define POV_MASK ((unsigned char)(~(P1_NULL | P2_NULL)))
|
|
/*
|
|
* Look up tables for button combos
|
|
* Buttons are zero based so use P1_NULL for a zero input so we don't have to
|
|
* special case it as a do nothing button.
|
|
* The 7th Button can be mapped either from it's unique combination or as
|
|
* foreward on a second POV being read as buttons 7 - 10.
|
|
*/
|
|
static const unsigned char c1PComboLU[] = { P1_NULL,0, 1, P1_270,
|
|
2, 4, 8, P1_180,
|
|
3, 5, 7, P1_90,
|
|
9, 6, 6, P1_0 };
|
|
|
|
static const unsigned char c2PComboLU[] = { P1_NULL,0, 1, P1_270,
|
|
2, 4, P2_180, P1_180,
|
|
3, 5, P2_90, P1_90,
|
|
P2_270, 6, P2_0, P1_0 };
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_DriverInit |
|
|
*
|
|
* Perform global initialization.
|
|
* <nl>This is called from DriverEntry. Try to initialize a CPU
|
|
* specific timer but if it fails set up default
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_UNSUCCESSFUL | not success
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS EXTERNAL
|
|
HGM_DriverInit( void )
|
|
{
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
|
|
if( !HGM_CPUCounterInit() )
|
|
{
|
|
LARGE_INTEGER QPCFrequency;
|
|
|
|
KeQueryPerformanceCounter( &QPCFrequency );
|
|
|
|
if( ( QPCFrequency.HighPart == 0 )
|
|
&& ( QPCFrequency.LowPart <= 10000 ) )
|
|
{
|
|
ntStatus = STATUS_UNSUCCESSFUL;
|
|
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("QPC at %I64u Hz is unusable",
|
|
QPCFrequency.QuadPart ));
|
|
}
|
|
else
|
|
{
|
|
Global.CounterScale = CALCULATE_SCALE( QPCFrequency.QuadPart );
|
|
Global.ReadCounter = (COUNTER_FUNCTION)&KeQueryPerformanceCounter;
|
|
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE,\
|
|
("QPC at %I64u Hz used with scale %d",
|
|
QPCFrequency.QuadPart, Global.CounterScale ));
|
|
}
|
|
}
|
|
|
|
return ntStatus;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_SetupButtons |
|
|
*
|
|
* Use the flags in the DeviceExtension to check and set up buttons.
|
|
* <nl>This is called both from HGM_JoystickConfig to validate the
|
|
* configuration and HGM_GenerateReport to prepare for polling.
|
|
*
|
|
* @parm IN OUT PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the minidriver device extension
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DEVICE_CONFIGURATION_ERROR | The configuration is invalid
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_SetupButtons
|
|
(
|
|
IN OUT PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
|
|
if( DeviceExtension->fSiblingFound )
|
|
{
|
|
if( DeviceExtension->nButtons > 2 )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of sibling device with %u buttons",\
|
|
DeviceExtension->nButtons));
|
|
}
|
|
if( DeviceExtension->HidGameOemData.OemData[1].joy_hws_dwFlags & JOY_HWS_POVISBUTTONCOMBOS )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of sibling device with combo buttons" ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->HidGameOemData.OemData[0].joy_hws_dwFlags & JOY_HWS_POVISBUTTONCOMBOS )
|
|
{
|
|
if( DeviceExtension->nButtons > MAX_BUTTONS )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of button combo device with %u buttons",\
|
|
DeviceExtension->nButtons));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->nButtons > 4 )
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AXIS_R )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of device with R axis and %u buttons",\
|
|
DeviceExtension->nButtons));
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* 5th button always read from R axis.
|
|
* Set the inital on/off boundary low
|
|
*/
|
|
DeviceExtension->resistiveInputMask |= AXIS_R;
|
|
DeviceExtension->button5limit = 2;
|
|
}
|
|
|
|
if( DeviceExtension->nButtons > 5 )
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AXIS_Z )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of device with Z axis and %u buttons",\
|
|
DeviceExtension->nButtons));
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* 6th button always read from Z axis.
|
|
* Set the inital on/off boundary low
|
|
*/
|
|
DeviceExtension->resistiveInputMask |= AXIS_Z;
|
|
DeviceExtension->button6limit = 2;
|
|
}
|
|
|
|
if( DeviceExtension->nButtons > 6 )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_SetupButtons: failing config of device with %u buttons",\
|
|
DeviceExtension->nButtons));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( ntStatus );
|
|
} /* HGM_SetupButtons */
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_MapAxesFromDevExt |
|
|
*
|
|
* Use the flags in the DeviceExtension to generate mappings for each
|
|
* axis.
|
|
* <nl>This is called both from HGM_JoystickConfig to validate the
|
|
* configuration and HGM_GenerateReport to use the axis maps.
|
|
*
|
|
*
|
|
* @parm IN OUT PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the minidriver device extension
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DEVICE_CONFIGURATION_ERROR | The configuration is invalid
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS EXTERNAL
|
|
HGM_MapAxesFromDevExt
|
|
(
|
|
IN OUT PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
ULONG dwFlags;
|
|
int nAxis;
|
|
UCHAR AxisMask;
|
|
|
|
ntStatus = STATUS_SUCCESS;
|
|
|
|
|
|
|
|
dwFlags = DeviceExtension->HidGameOemData.OemData[(DeviceExtension->fSiblingFound!=0)].joy_hws_dwFlags;
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2,\
|
|
("HGM_MapAxesFromDevExt: - - - dwFlags=0x%x - - -", dwFlags));
|
|
|
|
#define XIS (0)
|
|
#define YIS (1)
|
|
#define ZIS (2)
|
|
#define RIS (3)
|
|
|
|
/*
|
|
* Check X and Y last as Z, R and POV must not overlap
|
|
* The are no flags to indicate the presence of X or Y so if they
|
|
* overlap, this indicates that they are not used,
|
|
*/
|
|
|
|
DeviceExtension->resistiveInputMask = 0;
|
|
for( nAxis=MAX_AXES; nAxis>=0; nAxis-- )
|
|
{
|
|
DeviceExtension->AxisMap[nAxis] = INVALID_INDEX;
|
|
}
|
|
nAxis = 0;
|
|
DeviceExtension->povMap = INVALID_INDEX;
|
|
|
|
if( dwFlags & JOY_HWS_HASZ )
|
|
{
|
|
AxisMask = ZLU[(dwFlags & ZMAPBITS) >> ZMAPSHFT];
|
|
if( AxisMask >= NA )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: Z axis mapping error dwFlags=0x%x",\
|
|
dwFlags));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
}
|
|
else
|
|
{
|
|
nAxis = 1;
|
|
DeviceExtension->resistiveInputMask = AxisMask;
|
|
DeviceExtension->AxisMap[ZIS] = cAxisIndexTable[AxisMask];
|
|
}
|
|
}
|
|
|
|
|
|
if( dwFlags & JOY_HWS_HASR )
|
|
{
|
|
AxisMask = RLU[(dwFlags & RMAPBITS) >> RMAPSHFT];
|
|
if( AxisMask >= NA )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: R axis mapping error dwFlags=0x%x",\
|
|
dwFlags));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AxisMask )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR, \
|
|
("HGM_MapAxesFromDevExt: R axis mapped to same as Z axis"));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
else
|
|
{
|
|
nAxis++;
|
|
DeviceExtension->resistiveInputMask |= AxisMask;
|
|
DeviceExtension->AxisMap[RIS] = cAxisIndexTable[AxisMask];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if( dwFlags & JOY_HWS_HASPOV )
|
|
{
|
|
switch( dwFlags & ( JOY_HWS_POVISPOLL | JOY_HWS_POVISBUTTONCOMBOS ) )
|
|
{
|
|
case 0:
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: POV is not polled or button combo"));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
break;
|
|
|
|
case JOY_HWS_POVISBUTTONCOMBOS:
|
|
break;
|
|
|
|
case JOY_HWS_POVISPOLL:
|
|
AxisMask = ZLU[(dwFlags & POVMAPBITS) >> POVMAPSHFT];
|
|
if( AxisMask >= NA )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: POV axis mapping error dwFlags=0x%x",\
|
|
dwFlags));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AxisMask )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: POV axis mapped to same as Z or R axis") );
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
else
|
|
{
|
|
DeviceExtension->resistiveInputMask |= AxisMask;
|
|
DeviceExtension->povMap = cAxisIndexTable[AxisMask];
|
|
}
|
|
}
|
|
break;
|
|
|
|
case JOY_HWS_POVISPOLL | JOY_HWS_POVISBUTTONCOMBOS:
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: POV reports button combo and polled"));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else if( dwFlags & ( JOY_HWS_POVISPOLL | JOY_HWS_POVISBUTTONCOMBOS ) )
|
|
{
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: non-existant POV is polled or button combo"));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
|
|
|
|
AxisMask = XLU[( dwFlags & XMAPBITS ) >> XMAPSHFT];
|
|
if( AxisMask >= NA )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: X axis mapping error dwFlags=0x%x",\
|
|
dwFlags));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AxisMask )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_WARN,\
|
|
("HGM_MapAxesFromDevExt: X axis mapped to same as another axis") );
|
|
}
|
|
else
|
|
{
|
|
nAxis++;
|
|
DeviceExtension->resistiveInputMask |= AxisMask;
|
|
DeviceExtension->AxisMap[XIS] = cAxisIndexTable[AxisMask];
|
|
}
|
|
}
|
|
|
|
|
|
AxisMask = YLU[( dwFlags & YMAPBITS ) >> YMAPSHFT];
|
|
if( AxisMask >= NA )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: Y axis mapping error dwFlags=0x%x",\
|
|
dwFlags));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->resistiveInputMask & AxisMask )
|
|
{
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_WARN,\
|
|
("HGM_MapAxesFromDevExt: Y axis mapped to same as another axis") );
|
|
}
|
|
else
|
|
{
|
|
nAxis++;
|
|
DeviceExtension->resistiveInputMask |= AxisMask;
|
|
DeviceExtension->AxisMap[YIS] = cAxisIndexTable[AxisMask];
|
|
}
|
|
}
|
|
|
|
#undef XIS
|
|
#undef YIS
|
|
#undef ZIS
|
|
#undef RIS
|
|
|
|
#undef NA
|
|
|
|
/*
|
|
* Don't fail for this if CHANGE_DEVICE is defined because an exposed
|
|
* sibling will always have an nAxis of zero.
|
|
*/
|
|
#ifdef CHANGE_DEVICE
|
|
if( DeviceExtension->nAxes )
|
|
{
|
|
#endif /* CHANGE_DEVICE */
|
|
if( nAxis != DeviceExtension->nAxes )
|
|
{
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR ;
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_MapAxesFromDevExt: nAxis(%d) != DeviceExtension->nAxes(%d)", \
|
|
nAxis, (int) DeviceExtension->nAxes));
|
|
}
|
|
#ifdef CHANGE_DEVICE
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* This must be an exposed sibling so store the calculated nAxis and
|
|
* a nButton just to look different.
|
|
*/
|
|
DeviceExtension->nAxes = (USHORT)nAxis;
|
|
DeviceExtension->nButtons = MAX_BUTTONS;
|
|
}
|
|
#endif /* CHANGE_DEVICE */
|
|
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE,\
|
|
("HGM_MapAxesFromDevExt: uResistiveInputMask=0x%x",\
|
|
DeviceExtension->resistiveInputMask) );
|
|
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
ntStatus = HGM_SetupButtons( DeviceExtension );
|
|
}
|
|
|
|
return( ntStatus );
|
|
} /* HGM_MapAxesFromDevExt */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_GenerateReport |
|
|
*
|
|
* Generates a hid report descriptor for a n-axis, m-button joystick,
|
|
* depending on number of buttons and joy_hws_flags field.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @parm IN OUT UCHAR * | rgGameReport[MAXBYTES_GAME_REPORT] |
|
|
*
|
|
* Array that receives the HID report descriptor
|
|
*
|
|
* @parm OUT PUSHORT | pCbReport |
|
|
*
|
|
* Address of a short integer that receives size of
|
|
* HID report descriptor.
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_BUFFER_TOO_SMALL | Need more memory for HID descriptor
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_GenerateReport
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
OUT UCHAR rgGameReport[MAXBYTES_GAME_REPORT],
|
|
OUT PUSHORT pCbReport
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
UCHAR *pucReport;
|
|
int Idx;
|
|
int UsageIdx;
|
|
ULONG dwFlags;
|
|
|
|
int InitialAxisMappings[MAX_AXES];
|
|
|
|
|
|
typedef struct _USAGES
|
|
{
|
|
UCHAR UsagePage;
|
|
UCHAR Usage;
|
|
} USAGES, *PUSAGE;
|
|
|
|
typedef struct _JOYCLASSPARAMS
|
|
{
|
|
UCHAR TopLevelUsage;
|
|
USAGES Usages[MAX_AXES];
|
|
} JOYCLASSPARAMS, *PJOYCLASSPARAMS;
|
|
|
|
PJOYCLASSPARAMS pJoyParams;
|
|
|
|
/*
|
|
* Canned parameters for devices
|
|
* The top-level usage must be either HID_USAGE_GENERIC_JOYSTICK or
|
|
* HID_USAGE_GENERIC_GAMEPAD in order for the device to be treated as a
|
|
* game controller.
|
|
* The poll limits are specified in uSecs so the value stored here is 1000000/x
|
|
*/
|
|
|
|
JOYCLASSPARAMS JoystickParams =
|
|
{
|
|
HID_USAGE_GENERIC_JOYSTICK,
|
|
{ { HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X} ,
|
|
{ HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER} }
|
|
};
|
|
|
|
JOYCLASSPARAMS GamepadParams =
|
|
{
|
|
HID_USAGE_GENERIC_GAMEPAD,
|
|
{ { HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X} ,
|
|
{ HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER} }
|
|
};
|
|
|
|
JOYCLASSPARAMS CarCtrlParams =
|
|
{
|
|
HID_USAGE_GENERIC_JOYSTICK,
|
|
{ { HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X} ,
|
|
{ HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER} }
|
|
};
|
|
|
|
JOYCLASSPARAMS FlightYokeParams =
|
|
{
|
|
HID_USAGE_GENERIC_JOYSTICK,
|
|
{ { HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X} ,
|
|
{ HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_Y} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_THROTTLE} ,
|
|
{ HID_USAGE_PAGE_SIMULATION, HID_USAGE_SIMULATION_RUDDER} }
|
|
};
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_FENTRY,\
|
|
("HGM_GenerateReport(ucIn=0x%x,DeviceObject=0x%x)",\
|
|
rgGameReport, DeviceObject) );
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
/*
|
|
* Although the axes have already been validated and mapped in
|
|
* HGM_JoystickConfig this function destroys the mapping when it compacts
|
|
* the axes towards the start of the descriptor report. Since this
|
|
* function will be called once to find the descriptor length and then
|
|
* again to read the report, the mappings are regenerated again each
|
|
* time through. Although this results in the parameters being
|
|
* interpreted three times (for validation, descriptor size and
|
|
* descriptor content) it avoids the possibility of a discrepancy in
|
|
* implementation of separate functions.
|
|
*/
|
|
|
|
ntStatus = HGM_MapAxesFromDevExt( DeviceExtension );
|
|
ASSERTMSG( "HGM_GenerateReport:", ntStatus == STATUS_SUCCESS );
|
|
|
|
pucReport = rgGameReport;
|
|
|
|
dwFlags = DeviceExtension->HidGameOemData.OemData[(DeviceExtension->fSiblingFound!=0)].joy_hws_dwFlags;
|
|
|
|
|
|
/*
|
|
* What manner of beast have we ?
|
|
*/
|
|
if( dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
pJoyParams = &GamepadParams;
|
|
}
|
|
else if( dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
pJoyParams = &FlightYokeParams;
|
|
}
|
|
else if( dwFlags & JOY_HWS_ISCARCTRL )
|
|
{
|
|
pJoyParams = &CarCtrlParams;
|
|
}
|
|
else
|
|
{
|
|
pJoyParams = &JoystickParams;
|
|
}
|
|
|
|
#define NEXT_BYTE( pReport, Data ) \
|
|
ASSERTMSG( "HGM_GenerateReport:", pReport+sizeof(UCHAR)-rgGameReport < MAXBYTES_GAME_REPORT ); \
|
|
*pReport++ = Data;
|
|
|
|
#define NEXT_LONG( pReport, Data ) \
|
|
ASSERTMSG( "HGM_GenerateReport:", pReport+sizeof(ULONG)-rgGameReport < MAXBYTES_GAME_REPORT); \
|
|
*(((LONG UNALIGNED*)(pReport))++) = Data;
|
|
|
|
#define ITEM_DEFAULT 0x00 /* Data, Array, Absolute, No Wrap, Linear, Preferred State, Has no NULL */
|
|
#define ITEM_VARIABLE 0x02 /* as ITEM_DEFAULT but value is a variable, not an array */
|
|
#define ITEM_HASNULL 0x40 /* as ITEM_DEFAULT but values out of range are considered NULL */
|
|
#define ITEM_ANALOG_AXIS ITEM_VARIABLE
|
|
#define ITEM_DIGITAL_POV (ITEM_VARIABLE|ITEM_HASNULL)
|
|
#define ITEM_BUTTON ITEM_VARIABLE
|
|
#define ITEM_PADDING 0x01 /* Constant (nothing else applies) */
|
|
|
|
|
|
/* USAGE_PAGE (Generic Desktop) */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_USAGE_PAGE_1);
|
|
NEXT_BYTE(pucReport, HID_USAGE_PAGE_GENERIC);
|
|
|
|
/* USAGE (Joystick | GamePad ) */
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_1);
|
|
NEXT_BYTE(pucReport, pJoyParams->TopLevelUsage);
|
|
|
|
/* Logical Min is the smallest value that could be produced by a poll */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_LOG_MIN_4);
|
|
NEXT_LONG(pucReport, 0 );
|
|
|
|
/* Logical Max is the largest value that could be produced by a poll */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_LOG_MAX_4);
|
|
NEXT_LONG(pucReport, AXIS_FULL_SCALE );
|
|
|
|
/* Start a Linked collection */
|
|
/*
|
|
* Since this is a generic driver we know knothing about the physical
|
|
* distribution of controls on the device so we put everything in a
|
|
* single collection. If, for instance, we knew that some buttons were
|
|
* on the base and some on the stick we could better describe them by
|
|
* reporting them in separate collections.
|
|
*/
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_COLLECTION);
|
|
NEXT_BYTE(pucReport, 0x0 );
|
|
|
|
/* Define one axis at a time */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_COUNT_1);
|
|
NEXT_BYTE(pucReport, 0x1);
|
|
|
|
/* Each axis is a 32 bits value */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 8 * sizeof(ULONG) );
|
|
|
|
/*
|
|
* Do the axis
|
|
* Although HID could cope with the "active" axes being mixed with the
|
|
* dummy ones, it makes life simpler to move them to the start.
|
|
* Pass through all the axis maps generated by HGM_JoystickConfig
|
|
* and map all the active ones into the descriptor, copying the usages
|
|
* appropriate for the type of device.
|
|
* Since a polled POV is nothing more than a different interpretation
|
|
* of axis data, this is added after any axes.
|
|
*/
|
|
C_ASSERT( sizeof( InitialAxisMappings ) == sizeof( DeviceExtension->AxisMap ) );
|
|
RtlCopyMemory( InitialAxisMappings, DeviceExtension->AxisMap, sizeof( InitialAxisMappings ) );
|
|
|
|
|
|
|
|
Idx = 0;
|
|
for( UsageIdx = 0; UsageIdx < MAX_AXES; UsageIdx++ )
|
|
{
|
|
if( InitialAxisMappings[UsageIdx] >= INVALID_INDEX )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
DeviceExtension->AxisMap[Idx] = InitialAxisMappings[UsageIdx];
|
|
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_4);
|
|
NEXT_BYTE(pucReport, pJoyParams->Usages[UsageIdx].Usage);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
NEXT_BYTE(pucReport, pJoyParams->Usages[UsageIdx].UsagePage);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
|
|
/* Data Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_ANALOG_AXIS);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Idx=%d, UsageIdx=%d, Mapping=%d, Usage=%02x, Page=%02x",\
|
|
Idx, UsageIdx, DeviceExtension->AxisMap[UsageIdx], \
|
|
pJoyParams->Usages[UsageIdx].Usage, pJoyParams->Usages[UsageIdx].UsagePage ) ) ;
|
|
Idx++;
|
|
}
|
|
|
|
if( dwFlags & JOY_HWS_POVISPOLL )
|
|
{
|
|
/*
|
|
* A polled POV is just the same as an axis.
|
|
* Note, we have already checked that there is an axis for use as the POV.
|
|
* Also, this type of POV can be distinguished from a digital POV by it's
|
|
* lack of a NULL value.
|
|
*/
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_4);
|
|
NEXT_BYTE(pucReport, HID_USAGE_GENERIC_HATSWITCH);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
NEXT_BYTE(pucReport, HID_USAGE_PAGE_GENERIC);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
|
|
/* Data Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_ANALOG_AXIS);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Idx=%d, Set to polled POV", Idx ) ) ;
|
|
Idx++;
|
|
}
|
|
|
|
/*
|
|
* Now fill in any remaining axis values as dummys
|
|
*/
|
|
while( Idx < MAX_AXES )
|
|
{
|
|
/* Constant Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Idx=%d, Set to constant field", Idx ) ) ;
|
|
Idx++;
|
|
}
|
|
|
|
|
|
/*
|
|
* Now move on to the byte sized fields
|
|
*/
|
|
|
|
|
|
if( dwFlags & JOY_HWS_POVISBUTTONCOMBOS )
|
|
{
|
|
/*
|
|
* Redefine the logical and physical ranges from now on
|
|
* A digital POV has a NULL value (a value outside the logical range)
|
|
* when the POV is centered. To make life easier call the NULL value
|
|
* zero, so the logical range is from 1 to 4.
|
|
|
|
/* Logical Min */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_LOG_MIN_1);
|
|
NEXT_BYTE(pucReport, 1 );
|
|
|
|
/* Logical Max */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_LOG_MAX_1);
|
|
NEXT_BYTE(pucReport, 4 );
|
|
|
|
/*
|
|
* report for digital POV is 3 bits data plus 5 constant bits to fill
|
|
* the byte.
|
|
*/
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_4);
|
|
NEXT_BYTE(pucReport, HID_USAGE_GENERIC_HATSWITCH);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
NEXT_BYTE(pucReport, HID_USAGE_PAGE_GENERIC);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
|
|
/* Data Field */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x3);
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_DIGITAL_POV);
|
|
|
|
/* top 5 bits constant */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x5);
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:First button combo POV is on" ) ) ;
|
|
|
|
if( dwFlags & JOY_HWS_HASPOV2 )
|
|
{
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_4);
|
|
NEXT_BYTE(pucReport, HID_USAGE_GENERIC_HATSWITCH);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
NEXT_BYTE(pucReport, HID_USAGE_PAGE_GENERIC);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
|
|
/* Data Field */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x3);
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_DIGITAL_POV);
|
|
|
|
/* top 5 bits constant */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x5);
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Second button combo POV is on" ) ) ;
|
|
}
|
|
else
|
|
{
|
|
/* 8 bits of constant data instead of second POV */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x8);
|
|
|
|
/* Constant Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:No second button combo POV" ) ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* 16 bits of constant data instead of button combo POVs */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x10);
|
|
|
|
/* Constant Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Button combo POV are off" ) ) ;
|
|
}
|
|
|
|
|
|
/*
|
|
* Now the buttons
|
|
*/
|
|
for( Idx = 0x0; Idx < DeviceExtension->nButtons; Idx++ )
|
|
{
|
|
/* Report size is 1 bit for button */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x1);
|
|
|
|
NEXT_BYTE(pucReport, HIDP_LOCAL_USAGE_4);
|
|
NEXT_BYTE(pucReport, (UCHAR)(Idx + 1) );
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
NEXT_BYTE(pucReport, HID_USAGE_PAGE_BUTTON);
|
|
NEXT_BYTE(pucReport, 0x0);
|
|
|
|
/* Data field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_BUTTON);
|
|
|
|
/* 7 bits of constant data */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, 0x7);
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Button %u on",Idx ) ) ;
|
|
}
|
|
|
|
if( Idx < MAX_BUTTONS )
|
|
{
|
|
/* Constant report for 8 * unused buttons bits */
|
|
NEXT_BYTE(pucReport, HIDP_GLOBAL_REPORT_SIZE);
|
|
NEXT_BYTE(pucReport, (UCHAR)((MAX_BUTTONS-Idx)*8) );
|
|
|
|
/* Constant Field */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_INPUT_1);
|
|
NEXT_BYTE(pucReport, ITEM_PADDING);
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT, \
|
|
("HGM_GenerateReport:Last %u buttons off",MAX_BUTTONS-Idx ) ) ;
|
|
}
|
|
|
|
/* End of collection, We're done ! */
|
|
NEXT_BYTE(pucReport, HIDP_MAIN_ENDCOLLECTION);
|
|
|
|
|
|
#undef NEXT_BYTE
|
|
#undef NEXT_LONG
|
|
|
|
if( pucReport - rgGameReport > MAXBYTES_GAME_REPORT)
|
|
{
|
|
ntStatus = STATUS_BUFFER_TOO_SMALL;
|
|
*pCbReport = 0x0;
|
|
RtlZeroMemory(rgGameReport, sizeof(rgGameReport));
|
|
} else
|
|
{
|
|
*pCbReport = (USHORT) (pucReport - rgGameReport);
|
|
ntStatus = STATUS_SUCCESS;
|
|
}
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_GEN_REPORT,\
|
|
("HGM_GenerateReport: ReportSize=0x%x",\
|
|
*pCbReport) );
|
|
|
|
HGM_EXITPROC(FILE_HIDJOY | HGM_FEXIT_STATUSOK, "HGM_GenerateReport", ntStatus);
|
|
|
|
return ( ntStatus );
|
|
} /* HGM_GenerateReport */
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_JoystickConfig |
|
|
*
|
|
* Check that the configuration is valid whilst there is still time
|
|
* to refuse it.
|
|
* <nl>HGM_GenerateReport uses the results generated here if the
|
|
* settings are OK.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DEVICE_CONFIGURATION_ERROR | Invalid configuration specified
|
|
*
|
|
*****************************************************************************/
|
|
NTSTATUS INTERNAL
|
|
HGM_JoystickConfig
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
)
|
|
{
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
NTSTATUS ntStatus;
|
|
int Idx;
|
|
|
|
PAGED_CODE();
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_FENTRY,\
|
|
("HGM_JoystickConfig(DeviceObject=0x%x)",\
|
|
DeviceObject) );
|
|
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
ntStatus = HGM_MapAxesFromDevExt( DeviceExtension );
|
|
|
|
if( DeviceExtension->ReadAccessorDigital )
|
|
{
|
|
DeviceExtension->ScaledTimeout = AXIS_TIMEOUT;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Calculate time thresholds for analog device
|
|
*/
|
|
if( ( DeviceExtension->HidGameOemData.OemData[0].Timeout < ANALOG_POLL_TIMEOUT_MIN )
|
|
||( DeviceExtension->HidGameOemData.OemData[0].Timeout > ANALOG_POLL_TIMEOUT_MAX ) )
|
|
{
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE,\
|
|
("Ignoring out of range timeout: %u uSecs",\
|
|
DeviceExtension->HidGameOemData.OemData[0].Timeout));
|
|
|
|
DeviceExtension->ScaledTimeout = (ULONG)( ( (ULONGLONG)ANALOG_POLL_TIMEOUT_DFT
|
|
* (ULONGLONG)(AXIS_FULL_SCALE<<SCALE_SHIFT) )
|
|
/ (ULONGLONG)ANALOG_POLL_TIMEOUT_MAX );
|
|
}
|
|
else
|
|
{
|
|
DeviceExtension->ScaledTimeout = (ULONG)( ( (ULONGLONG)DeviceExtension->HidGameOemData.OemData[0].Timeout
|
|
* (ULONGLONG)(AXIS_FULL_SCALE<<SCALE_SHIFT) )
|
|
/ (ULONGLONG)ANALOG_POLL_TIMEOUT_MAX );
|
|
}
|
|
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE,\
|
|
("ScaledTimeout: %u",\
|
|
DeviceExtension->ScaledTimeout));
|
|
|
|
/*
|
|
* Use one quarter of the minimum poll timeout as a starting value
|
|
* for the time between two polls which will be considered to have
|
|
* been interrupted.
|
|
*/
|
|
DeviceExtension->ScaledThreshold = (ULONG)( ( (ULONGLONG)ANALOG_POLL_TIMEOUT_MIN
|
|
* (ULONGLONG)AXIS_FULL_SCALE )
|
|
/ (ULONGLONG)ANALOG_POLL_TIMEOUT_MAX )>>2;
|
|
}
|
|
|
|
|
|
/*
|
|
* Set initial values of LastGoodAxis so that the device will not show
|
|
* up as present until we get at least one valid poll.
|
|
*/
|
|
for( Idx = MAX_AXES; Idx >= 0; Idx-- )
|
|
{
|
|
DeviceExtension->LastGoodAxis[Idx] = AXIS_TIMEOUT;
|
|
}
|
|
|
|
HGM_EXITPROC(FILE_HIDJOY | HGM_FEXIT_STATUSOK, "HGM_JoystickConfig", ntStatus);
|
|
|
|
return ntStatus;
|
|
} /* HGM_JoystickConfig */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func NTSTATUS | HGM_InitAnalog |
|
|
*
|
|
* Check that the configuration is valid whilst there is still time
|
|
* to refuse it.
|
|
* <nl>Detect and validate sibling relationships and call
|
|
* HGM_JoystickConfig for the rest of the work.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @rvalue STATUS_SUCCESS | success
|
|
* @rvalue STATUS_DEVICE_CONFIGURATION_ERROR | Invalid configuration specified
|
|
*
|
|
*****************************************************************************/
|
|
/*
|
|
* Disable warning for variable used before set as it is hard for a compiler
|
|
* to see that the use of DeviceExtension_Sibling is gated by a flag which
|
|
* can only be set after DeviceExtension_Sibling is initialized.
|
|
*/
|
|
#pragma warning( disable:4701 )
|
|
NTSTATUS EXTERNAL
|
|
HGM_InitAnalog
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
PDEVICE_EXTENSION DeviceExtension_Sibling;
|
|
PLIST_ENTRY pEntry;
|
|
|
|
#define ARE_WE_RELATED(_x_, _y_) \
|
|
( \
|
|
(_x_)->GameContext == (_y_)->GameContext && \
|
|
(_x_)->WriteAccessor == (_y_)->WriteAccessor && \
|
|
(_x_)->ReadAccessor == (_y_)->ReadAccessor \
|
|
)
|
|
|
|
PAGED_CODE ();
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
|
|
/*
|
|
* No modifications to the Global List while we are looking at it
|
|
*/
|
|
ExAcquireFastMutex (&Global.Mutex);
|
|
|
|
/*
|
|
* For two joysticks interface two fdos are created to service them
|
|
* but physically they both share the same port.
|
|
* For the second sibling certain extra rules must be applied so we
|
|
* search our list of devices for another device using the same port
|
|
* and if we find one mark this one as a sibling.
|
|
*/
|
|
for(pEntry = Global.DeviceListHead.Flink;
|
|
pEntry != &Global.DeviceListHead;
|
|
pEntry = pEntry->Flink)
|
|
{
|
|
|
|
/*
|
|
* Obtain the device Extension of the Sibling
|
|
*/
|
|
DeviceExtension_Sibling = CONTAINING_RECORD(pEntry, DEVICE_EXTENSION, Link);
|
|
|
|
if( DeviceExtension_Sibling != DeviceExtension
|
|
&& TRUE == ARE_WE_RELATED(DeviceExtension, DeviceExtension_Sibling)
|
|
&& TRUE == DeviceExtension_Sibling->fStarted )
|
|
{
|
|
#ifdef CHANGE_DEVICE
|
|
if( DeviceExtension_Sibling->fReplaced )
|
|
{
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE, ("Outgoing Sibling found (0x%x)", DeviceExtension_Sibling));
|
|
}
|
|
else
|
|
{
|
|
#endif /* CHANGE_DEVICE */
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE, ("Sibling found (0x%x)", DeviceExtension_Sibling));
|
|
|
|
DeviceExtension->fSiblingFound = TRUE;
|
|
#ifdef CHANGE_DEVICE
|
|
}
|
|
#endif /* CHANGE_DEVICE */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* We are done, release the Mutex
|
|
*/
|
|
ExReleaseFastMutex (&Global.Mutex);
|
|
|
|
/*
|
|
* check the axis and button configuration for the joystick
|
|
*/
|
|
ntStatus = HGM_JoystickConfig(DeviceObject);
|
|
|
|
if( NT_SUCCESS( ntStatus ) )
|
|
{
|
|
/*
|
|
* Make sure that sibling axes are not overlapped
|
|
*/
|
|
if( DeviceExtension->fSiblingFound &&
|
|
(DeviceExtension_Sibling->resistiveInputMask & DeviceExtension->resistiveInputMask) != 0x0 )
|
|
{
|
|
|
|
HGM_DBGPRINT(FILE_HIDJOY |HGM_ERROR,\
|
|
("HGM_InitDevice: OverLapping Resources ResisitiveInputMask(0x%x) Sibling(0x%x)",\
|
|
DeviceExtension->resistiveInputMask,DeviceExtension_Sibling->resistiveInputMask ));
|
|
ntStatus = STATUS_DEVICE_CONFIGURATION_ERROR;
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("HGM_InitDevice: JoystickConfig Failed"));
|
|
}
|
|
|
|
return( ntStatus );
|
|
|
|
} /* HGM_InitAnalog */
|
|
|
|
|
|
|
|
/*
|
|
* Change device sample only code
|
|
*/
|
|
#ifdef CHANGE_DEVICE
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func VOID | HGM_ChangeHandler |
|
|
*
|
|
* Use IOCTL_GAMEENUM_EXPOSE_SIBLING and IOCTL_GAMEENUM_REMOVE_SELF
|
|
* to change the attributes of the device.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @parm PIO_WORKITEM | WorkItem |
|
|
*
|
|
* The work item that this call is being processed under.
|
|
*
|
|
*****************************************************************************/
|
|
VOID
|
|
HGM_ChangeHandler
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
PIO_WORKITEM WorkItem
|
|
)
|
|
{
|
|
NTSTATUS ntStatus = STATUS_SUCCESS;
|
|
PDEVICE_EXTENSION DeviceExtension;
|
|
KEVENT IoctlCompleteEvent;
|
|
IO_STATUS_BLOCK IoStatus;
|
|
PIO_STACK_LOCATION irpStack, nextStack;
|
|
PIRP pIrp;
|
|
PVOID SiblingHandle;
|
|
|
|
GAMEENUM_EXPOSE_SIBLING ExposeSibling;
|
|
|
|
PAGED_CODE ();
|
|
|
|
/*
|
|
* Get a pointer to the device extension
|
|
*/
|
|
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION(DeviceObject);
|
|
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_FENTRY,\
|
|
("HGM_ChangeHandler(DeviceExtension=0x%x)", DeviceExtension));
|
|
|
|
KeInitializeEvent(&IoctlCompleteEvent, NotificationEvent, FALSE);
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest (
|
|
IOCTL_GAMEENUM_EXPOSE_SIBLING,
|
|
DeviceExtension->NextDeviceObject,
|
|
&ExposeSibling,
|
|
sizeof( ExposeSibling ),
|
|
&ExposeSibling,
|
|
sizeof( ExposeSibling ),
|
|
TRUE,
|
|
&IoctlCompleteEvent,
|
|
&IoStatus);
|
|
|
|
if( pIrp )
|
|
{
|
|
/*
|
|
* For demonstration purposes only, we don't actually change the
|
|
* device, we just re-expose the same one. If the device really
|
|
* needs to be changed, this would be signalled either by a
|
|
* change in the OemData on the newly exposed device or by using
|
|
* a specific HardwareID string.
|
|
* Note the nAxis and nButton fields will always be zero for an
|
|
* exposed sibling.
|
|
*/
|
|
RtlZeroMemory( &ExposeSibling, sizeof( ExposeSibling ) );
|
|
ExposeSibling.Size = sizeof( ExposeSibling );
|
|
ExposeSibling.HardwareHandle = &SiblingHandle;
|
|
|
|
C_ASSERT( sizeof( ExposeSibling.OemData ) == sizeof( DeviceExtension->HidGameOemData.Game_Oem_Data ) );
|
|
RtlCopyMemory(ExposeSibling.OemData, DeviceExtension->HidGameOemData.Game_Oem_Data, sizeof(ExposeSibling.OemData));
|
|
ASSERT( ExposeSibling.UnitID == 0 );
|
|
|
|
/*
|
|
* Setting a NULL pointer causes the HardwareID of this sibling to be used
|
|
*/
|
|
ExposeSibling.HardwareIDs = NULL;
|
|
|
|
|
|
/*
|
|
* issue a synchronous request to GameEnum to expose this new sibling
|
|
*/
|
|
ntStatus = IoCallDriver( DeviceExtension->NextDeviceObject, pIrp );
|
|
|
|
if( ntStatus == STATUS_PENDING )
|
|
{
|
|
ntStatus = KeWaitForSingleObject (&IoctlCompleteEvent, Executive, KernelMode, FALSE, NULL);
|
|
}
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
/*
|
|
* All went well so remove self
|
|
*/
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE, ("Sibling exposed!"));
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest (
|
|
IOCTL_GAMEENUM_REMOVE_SELF,
|
|
DeviceExtension->NextDeviceObject,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
0,
|
|
TRUE,
|
|
&IoctlCompleteEvent,
|
|
&IoStatus);
|
|
|
|
if( pIrp )
|
|
{
|
|
/*
|
|
* issue a synchronous request to GameEnum to remove self
|
|
*/
|
|
ntStatus = IoCallDriver( DeviceExtension->NextDeviceObject, pIrp );
|
|
|
|
if( ntStatus == STATUS_PENDING )
|
|
{
|
|
ntStatus = KeWaitForSingleObject( &IoctlCompleteEvent, Executive, KernelMode, FALSE, NULL );
|
|
}
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
/*
|
|
* All done
|
|
*/
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_BABBLE, ("Removed self!"));
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Something bad happened but there's little we can do
|
|
*/
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR,\
|
|
("Failed to remove self with GameEnum error: 0x%08x", \
|
|
ntStatus));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ntStatus = STATUS_NO_MEMORY;
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR, \
|
|
("Failed to create IRP for remove self") );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Something bad happened so reset the flag and carry on
|
|
*/
|
|
DeviceExtension->fReplaced = FALSE;
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_WARN,\
|
|
("Failed to expose sibling with GameEnum error: 0x%08x", ntStatus));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ntStatus = STATUS_NO_MEMORY;
|
|
DeviceExtension->fReplaced = FALSE;
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_ERROR, \
|
|
("Failed to create IRP for expose sibling") );
|
|
}
|
|
|
|
/*
|
|
* The work is done, so free the resources
|
|
*/
|
|
IoFreeWorkItem( WorkItem );
|
|
|
|
/*
|
|
* We've finished touching the DeviceExtension now.
|
|
*/
|
|
HGM_DecRequestCount( DeviceExtension );
|
|
|
|
HGM_EXITPROC(FILE_HIDJOY|HGM_FEXIT_STATUSOK, "HGM_ChangeHandler", ntStatus);
|
|
|
|
return;
|
|
} /* HGM_ChangeHandler */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func VOID | HGM_DeviceChanged |
|
|
*
|
|
* Start the process of changing the device attributes by stashing
|
|
* away all the data needed and then initializing and queuing a work
|
|
* item to call the IOCTL at the required PASSIVE_LEVEL.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @parm IN OUT PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the mini-driver device extension.
|
|
*
|
|
*****************************************************************************/
|
|
VOID
|
|
HGM_DeviceChanged
|
|
(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN OUT PDEVICE_EXTENSION DeviceExtension
|
|
)
|
|
{
|
|
NTSTATUS ntStatus;
|
|
PIO_WORKITEM WorkItem;
|
|
|
|
/*
|
|
* Since the work item will use the device extension, bump the usage
|
|
* count up one in case anyone tries to remove the device between
|
|
* now and when the work item gets to run. If that fails, forget it.
|
|
*/
|
|
ntStatus = HGM_IncRequestCount( DeviceExtension );
|
|
|
|
if( NT_SUCCESS(ntStatus) )
|
|
{
|
|
WorkItem = IoAllocateWorkItem( DeviceObject );
|
|
if( WorkItem )
|
|
{
|
|
DeviceExtension->fReplaced = TRUE;
|
|
IoQueueWorkItem( WorkItem, (PIO_WORKITEM_ROUTINE)HGM_ChangeHandler,
|
|
DelayedWorkQueue, WorkItem );
|
|
}
|
|
else
|
|
{
|
|
HGM_DecRequestCount( DeviceExtension );
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_WARN, ("Failed to allocate work item to change device") );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HGM_DBGPRINT(FILE_HIDJOY | HGM_WARN, ("Failed to change device as device is being removed") );
|
|
}
|
|
} /* HGM_DeviceChanged */
|
|
|
|
#endif /* CHANGE_DEVICE */
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func VOID | HGM_Game2HID |
|
|
*
|
|
* Process the data returned from polling the gameport into values
|
|
* and buttons for returning to HID.
|
|
* <nl>The meaning of the data is interpreted according to the
|
|
* characteristics of the device described in the hardware settings
|
|
* flags.
|
|
*
|
|
* @parm IN PDEVICE_OBJECT | DeviceObject |
|
|
*
|
|
* Pointer to the device object
|
|
*
|
|
* @parm IN PDEVICE_EXTENSION | DeviceExtension |
|
|
*
|
|
* Pointer to the mini-driver device extension.
|
|
*
|
|
* @parm IN OUT PUHIDGAME_INPUT_DATA | pHIDData |
|
|
*
|
|
* Pointer to the buffer into which the HID report should be written.
|
|
* This buffer must be assumed to be unaligned.
|
|
*
|
|
*****************************************************************************/
|
|
VOID
|
|
HGM_Game2HID
|
|
(
|
|
#ifdef CHANGE_DEVICE
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
#endif /* CHANGE_DEVICE */
|
|
IN PDEVICE_EXTENSION DeviceExtension,
|
|
IN OUT PUHIDGAME_INPUT_DATA pHIDData
|
|
)
|
|
{
|
|
LONG Idx;
|
|
|
|
/*
|
|
* Use a local buffer to assemble the report as the real buffer may not
|
|
* be aligned.
|
|
*/
|
|
HIDGAME_INPUT_DATA LocalBuffer;
|
|
|
|
RtlZeroMemory( &LocalBuffer, sizeof( LocalBuffer ) );
|
|
|
|
/*
|
|
* Remap axis
|
|
*/
|
|
for(Idx = 0x0; Idx < DeviceExtension->nAxes; Idx++ )
|
|
{
|
|
LocalBuffer.Axis[Idx] = DeviceExtension->LastGoodAxis[DeviceExtension->AxisMap[Idx]];
|
|
}
|
|
|
|
/*
|
|
* Copy buttons and remap any POVs
|
|
*/
|
|
|
|
if( DeviceExtension->fSiblingFound )
|
|
{
|
|
/*
|
|
* Simplest case, 2nd half poll must be 2A 2B
|
|
*/
|
|
LocalBuffer.Button[0] = DeviceExtension->LastGoodButton[2];
|
|
LocalBuffer.Button[1] = DeviceExtension->LastGoodButton[3];
|
|
}
|
|
else if( DeviceExtension->HidGameOemData.OemData[0].joy_hws_dwFlags & JOY_HWS_POVISBUTTONCOMBOS )
|
|
{
|
|
UCHAR Buttons = 0;
|
|
|
|
for( Idx = 3; Idx >=0; Idx-- )
|
|
{
|
|
Buttons <<= 1;
|
|
Buttons = (UCHAR)(Buttons + (UCHAR)(DeviceExtension->LastGoodButton[Idx] >> BUTTON_BIT));
|
|
}
|
|
|
|
if( DeviceExtension->HidGameOemData.OemData[0].joy_hws_dwFlags & JOY_HWS_HASPOV2 )
|
|
{
|
|
Idx = c2PComboLU[Buttons];
|
|
}
|
|
else
|
|
{
|
|
Idx = c1PComboLU[Buttons];
|
|
}
|
|
|
|
if( Idx >= P1_NULL )
|
|
{
|
|
if( Idx < P2_NULL )
|
|
{
|
|
LocalBuffer.hatswitch[0] = (UCHAR)(Idx & POV_MASK);
|
|
}
|
|
else
|
|
{
|
|
LocalBuffer.hatswitch[1] = (UCHAR)(Idx & POV_MASK);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#ifdef CHANGE_DEVICE
|
|
if( ( Idx >= DeviceExtension->nButtons ) && ( !DeviceExtension->fReplaced ) )
|
|
{
|
|
/*
|
|
* If a higher button was pressed than expected, use
|
|
* remove_self/expose_sibling to change expectations.
|
|
*/
|
|
HGM_DeviceChanged( DeviceObject, DeviceExtension );
|
|
}
|
|
#endif /* CHANGE_DEVICE */
|
|
LocalBuffer.Button[Idx] = BUTTON_ON;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( DeviceExtension->HidGameOemData.OemData[0].joy_hws_dwFlags & JOY_HWS_POVISPOLL )
|
|
{
|
|
/*
|
|
* Following the axis mapping loop, Idx is one larger than
|
|
* DeviceExtension->nAxes which is the correct index for a
|
|
* polled POV.
|
|
*/
|
|
LocalBuffer.Axis[Idx] = DeviceExtension->LastGoodAxis[DeviceExtension->povMap];
|
|
}
|
|
|
|
|
|
/*
|
|
* Check buttons on R and Z axes
|
|
*/
|
|
if( DeviceExtension->nButtons > 5 )
|
|
{
|
|
if( DeviceExtension->LastGoodAxis[3] > DeviceExtension->button6limit )
|
|
{
|
|
/*
|
|
* New max found so button is off
|
|
*/
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2, \
|
|
("HGM_Game2HID: Changing button 6 limit from %u to %u", \
|
|
DeviceExtension->button6limit, DeviceExtension->LastGoodAxis[3] ) ) ;
|
|
DeviceExtension->button6limit = DeviceExtension->LastGoodAxis[3];
|
|
}
|
|
else if( DeviceExtension->LastGoodAxis[3] < (DeviceExtension->button6limit>>1) )
|
|
{
|
|
LocalBuffer.Button[5] = BUTTON_ON;
|
|
}
|
|
}
|
|
if( DeviceExtension->nButtons > 4 )
|
|
{
|
|
Idx = 4;
|
|
|
|
if( DeviceExtension->LastGoodAxis[2] > DeviceExtension->button5limit )
|
|
{
|
|
/*
|
|
* New max found so button is off
|
|
*/
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2, \
|
|
("HGM_Game2HID: Changing button 5 limit from %u to %u", \
|
|
DeviceExtension->button5limit, DeviceExtension->LastGoodAxis[2] ) ) ;
|
|
DeviceExtension->button5limit = DeviceExtension->LastGoodAxis[2];
|
|
}
|
|
else if( DeviceExtension->LastGoodAxis[2] < (DeviceExtension->button5limit>>1) )
|
|
{
|
|
LocalBuffer.Button[4] = BUTTON_ON;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Idx = DeviceExtension->nButtons;
|
|
}
|
|
|
|
|
|
/*
|
|
* Copy all standard buttons
|
|
*/
|
|
while( Idx-- )
|
|
{
|
|
LocalBuffer.Button[Idx] = DeviceExtension->LastGoodButton[Idx];
|
|
}
|
|
|
|
}
|
|
|
|
C_ASSERT( sizeof( *pHIDData ) == sizeof( LocalBuffer ) );
|
|
RtlCopyMemory( pHIDData, &LocalBuffer, sizeof( LocalBuffer ) );
|
|
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2, \
|
|
("HGM_Game2HID: Axes: X: %08x Y: %08x Z: %08x R: %08x", \
|
|
LocalBuffer.Axis[0], LocalBuffer.Axis[1], LocalBuffer.Axis[2], LocalBuffer.Axis[3] ) ) ;
|
|
HGM_DBGPRINT( FILE_HIDJOY | HGM_BABBLE2, \
|
|
("HGM_Game2HID: P1: %d P2: %d Buttons %d, %d, %d, %d, %d, %d, %d, %d, %d, %d", \
|
|
LocalBuffer.hatswitch[0], LocalBuffer.hatswitch[1], \
|
|
LocalBuffer.Button[0], LocalBuffer.Button[1], LocalBuffer.Button[2], LocalBuffer.Button[3], LocalBuffer.Button[4], \
|
|
LocalBuffer.Button[5], LocalBuffer.Button[6], LocalBuffer.Button[7], LocalBuffer.Button[8], LocalBuffer.Button[9] ) ) ;
|
|
} /* HGM_Game2HID */
|
|
|
|
|