4651 lines
165 KiB
C
4651 lines
165 KiB
C
/*****************************************************************************
|
|
*
|
|
* DIHidIni.c
|
|
*
|
|
* Copyright (c) 1996 - 2000 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* Abstract:
|
|
*
|
|
* The initialization-related functions of the HID device callback.
|
|
*
|
|
* All the HID support is getting kind of bulky, so I've broken
|
|
* it out into submodules.
|
|
*
|
|
* Contents:
|
|
*
|
|
* CHid_Init
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "dinputpr.h"
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* The sqiffle for this file.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define sqfl sqflHidIni
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Hid devices are totally arbitrary, so there is nothing static we
|
|
* can cook up to describe them. We generate all the information on
|
|
* the fly.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func UINT | CHid_LoadCalibrations |
|
|
*
|
|
* Load calibration information from the registry (or wherever).
|
|
* This is done when the device is created, and whenever we
|
|
* receive a recalibration message.
|
|
*
|
|
* @returns
|
|
*
|
|
* Returns the number of axes we calibrated. This information
|
|
* is used during device initialization to see if we need to
|
|
* worry about calibration in the future.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
UINT EXTERNAL
|
|
CHid_LoadCalibrations(PCHID this)
|
|
{
|
|
UINT uiObj;
|
|
UINT uiRc = 0;
|
|
|
|
/*
|
|
* Preinitialize the HIDP_DATA indices to -1 to indicate
|
|
* that they aren't there. We must do this before we
|
|
* mess with AddDeviceData, which assumes that all the
|
|
* indices are properly set up.
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
PJOYRANGECONVERT pjrc = this->rghoc[uiObj].pjrc;
|
|
PHIDGROUPCAPS pcaps = this->rghoc[uiObj].pcaps;
|
|
if(pjrc && pcaps)
|
|
{
|
|
LPDIOBJECTDATAFORMAT podf = &this->df.rgodf[uiObj];
|
|
DIOBJECTCALIBRATION cal;
|
|
#ifdef WINNT
|
|
DIPOVCALIBRATION pov;
|
|
#endif
|
|
D(LPCTSTR ptszWhence;)
|
|
|
|
/*
|
|
* Note, we do not have to deal with mice on Win2k, yet...
|
|
*/
|
|
#ifdef WINNT
|
|
HRESULT hres;
|
|
HKEY hk;
|
|
|
|
D( ptszWhence = TEXT("unknown") );
|
|
|
|
if( podf->dwType & DIDFT_POV )
|
|
{
|
|
if( pcaps->IsPolledPOV ) {
|
|
ZeroX( pov );
|
|
hres = CType_OpenIdSubkey(this->hkInstType, podf->dwType,
|
|
KEY_QUERY_VALUE, &hk);
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
hres = JoyReg_GetValue(hk, TEXT("Calibration"),
|
|
REG_BINARY, &pov,
|
|
cbX(DIPOVCALIBRATION));
|
|
RegCloseKey(hk);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
ZeroX( cal );
|
|
|
|
hres = CType_OpenIdSubkey(this->hkInstType, podf->dwType,
|
|
KEY_QUERY_VALUE, &hk);
|
|
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
hres = JoyReg_GetValue(hk, TEXT("Calibration"),
|
|
REG_BINARY, &cal,
|
|
cbX(DIOBJECTCALIBRATION));
|
|
RegCloseKey(hk);
|
|
}
|
|
|
|
/*
|
|
* If there is no calibration data, then create
|
|
* some defaults based on the logical min/max.
|
|
*/
|
|
if(FAILED(hres))
|
|
{
|
|
/*
|
|
* But only if the logical min/max is sane!
|
|
*/
|
|
if(pcaps->Logical.Min < pcaps->Logical.Max)
|
|
{
|
|
cal.lMin = pcaps->Logical.Min;
|
|
/*
|
|
* HACKHACK
|
|
* The analog joystick driver cannot report the true
|
|
* range of the device, so to keep the sample driver
|
|
* pure, it reports a range of zero to the point at
|
|
* which it would consider the axis absent. This is
|
|
* good in terms of reporting healthy HID data but
|
|
* it means that any normal joystick will only return
|
|
* values in a fraction of this range. So if this
|
|
* device is an analog device default the calibration
|
|
* to the typical range.
|
|
*/
|
|
if( ( this->VendorID == MSFT_SYSTEM_VID )
|
|
&&( ( this->ProductID & 0xff00 ) == MSFT_SYSTEM_PID ) )
|
|
{
|
|
/*
|
|
* To be extra safe, compute the max from the
|
|
* reported range. The divisor is a fudge factor
|
|
* derived by what looked about right to MarcAnd.
|
|
*/
|
|
cal.lMax = pcaps->Logical.Min +
|
|
( ( pcaps->Logical.Max - pcaps->Logical.Min ) / 11 );
|
|
D(ptszWhence = TEXT("log (adj)"));
|
|
}
|
|
else
|
|
{
|
|
cal.lMax = pcaps->Logical.Max;
|
|
D(ptszWhence = TEXT("log"));
|
|
}
|
|
} else
|
|
{
|
|
D(ptszWhence = TEXT("def"));
|
|
cal.lMin = 0;
|
|
cal.lMax = 655;
|
|
}
|
|
cal.lCenter = CCal_Midpoint(cal.lMin, cal.lMax);
|
|
} else
|
|
{
|
|
D(ptszWhence = TEXT("reg"));
|
|
}
|
|
}
|
|
|
|
#else
|
|
if( GET_DIDEVICE_TYPE(this->dwDevType) == DI8DEVTYPE_MOUSE )
|
|
{
|
|
if( this->df.rgodf[uiObj].dwType & DIDFT_ABSAXIS )
|
|
{
|
|
if(pcaps->Logical.Min < pcaps->Logical.Max)
|
|
{
|
|
cal.lMin = pcaps->Logical.Min;
|
|
cal.lMax = pcaps->Logical.Max;
|
|
D(ptszWhence = TEXT("mouse log"));
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Absolute mice traditionally report 0 - 64K
|
|
*/
|
|
cal.lMin = 0;
|
|
cal.lMax = 65535;
|
|
D(ptszWhence = TEXT("mouse def"));
|
|
}
|
|
cal.lCenter = CCal_Midpoint(cal.lMin, cal.lMax);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Relative mouse axis, just zero to keep sane
|
|
*/
|
|
ZeroX( cal );
|
|
}
|
|
} else if ( this->idJoy < 0 ) //See manbug 50591
|
|
{
|
|
HRESULT hres;
|
|
HKEY hk;
|
|
|
|
ZeroX( cal );
|
|
|
|
hres = CType_OpenIdSubkey(this->hkInstType, podf->dwType,
|
|
KEY_QUERY_VALUE, &hk);
|
|
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
hres = JoyReg_GetValue(hk, TEXT("Calibration"),
|
|
REG_BINARY, &cal,
|
|
cbX(DIOBJECTCALIBRATION));
|
|
RegCloseKey(hk);
|
|
} else {
|
|
/*
|
|
* But only if the logical min/max is sane!
|
|
*/
|
|
if(pcaps->Logical.Min < pcaps->Logical.Max)
|
|
{
|
|
cal.lMin = pcaps->Logical.Min;
|
|
cal.lMax = pcaps->Logical.Max;
|
|
} else
|
|
{
|
|
cal.lMin = 0;
|
|
cal.lMax = 655; //best guess
|
|
}
|
|
|
|
cal.lCenter = CCal_Midpoint(cal.lMin, cal.lMax);
|
|
}
|
|
|
|
D(ptszWhence = TEXT("non-gamecontroller"));
|
|
} else
|
|
{
|
|
ZeroX( cal );
|
|
|
|
/*
|
|
* Because the CPL on Win9x only updates calibration in MediaResources,
|
|
* We need read that calibration information and update for HID.
|
|
*/
|
|
CHid_UpdateCalibrationFromVjoyd(this, uiObj, &cal);
|
|
|
|
D(ptszWhence = TEXT("WinMM Reg"));
|
|
}
|
|
#endif
|
|
|
|
#ifdef WINNT
|
|
if( podf->dwType & DIDFT_POV )
|
|
{
|
|
if( pcaps->IsPolledPOV ) {
|
|
memcpy( pjrc->lMinPOV, pov.lMin, cbX(pjrc->lMinPOV) );
|
|
memcpy( pjrc->lMaxPOV, pov.lMax, cbX(pjrc->lMaxPOV) );
|
|
}
|
|
} else
|
|
#endif
|
|
{
|
|
D(SquirtSqflPtszV(sqflHidParse,
|
|
TEXT(" Calibration(%d) %s %d..%d..%d"),
|
|
CHid_ObjFromType(this, podf->dwType), ptszWhence,
|
|
cal.lMin, cal.lCenter, cal.lMax));
|
|
|
|
/*
|
|
* Saturation always defaults to 100%.
|
|
*/
|
|
pjrc->dwPmin = cal.lMin;
|
|
pjrc->dwPmax = cal.lMax;
|
|
pjrc->dwPc = cal.lCenter;
|
|
|
|
if( pjrc->dwCPointsNum == 0 ) {
|
|
//use two control points by default
|
|
pjrc->dwCPointsNum = 2;
|
|
pjrc->cp[0].lP = pjrc->dwPmin;
|
|
pjrc->cp[0].dwLog = 0;
|
|
pjrc->cp[1].lP = pjrc->dwPmax;
|
|
pjrc->cp[1].dwLog = RANGEDIVISIONS;
|
|
} else {
|
|
pjrc->cp[0].lP = pjrc->dwPmin;
|
|
pjrc->cp[pjrc->dwCPointsNum-1].lP = pjrc->dwPmax;
|
|
}
|
|
|
|
CCal_RecalcRange(pjrc);
|
|
|
|
uiRc++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return uiRc;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | CHid_SortCaps |
|
|
*
|
|
* Sort the capabilities by Data Index. This is important
|
|
* so that the items are assigned numbers in the same order
|
|
* by both DirectInput and HID.
|
|
*
|
|
* Note that we exploit the not-exactly-a-coincidence
|
|
* that a <t HIDP_VALUE_CAPS> and a
|
|
* <t HIDP_BUTTON_CAPS> are identical wherever they overlap.
|
|
*
|
|
* @parm PV | rgv |
|
|
*
|
|
* Array of either <t HIDP_VALUE_CAPS> or <t HIDP_BUTTON_CAPS>
|
|
* structures.
|
|
*
|
|
* @parm UINT | cv |
|
|
*
|
|
* Number of structures that need to be sorted.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
CHid_SortCaps(PV rgv, UINT cv)
|
|
{
|
|
/*
|
|
* For concreteness, we use HIDP_VALUE_CAPS.
|
|
*/
|
|
PHIDP_VALUE_CAPS rgvcaps = rgv;
|
|
UINT ivcaps;
|
|
|
|
/*
|
|
* There are several non-coincidences which we exploit.
|
|
*
|
|
* HIDP_VALUE_CAPS and HIDP_BUTTON_CAPS are the same size.
|
|
*
|
|
* HIDP_VALUE_CAPS.Range.DataIndexMin,
|
|
* HIDP_VALUE_CAPS.NotRange.DataIndex,
|
|
* HIDP_BUTTON_CAPS.Range.DataIndexMin, and
|
|
* HIDP_BUTTON_CAPS.NotRange.DataIndex are all at the same offset.
|
|
*/
|
|
CAssertF(cbX(HIDP_VALUE_CAPS) == cbX(HIDP_BUTTON_CAPS));
|
|
|
|
/*
|
|
* For some reason, the compiler doesn't think that these
|
|
* expressions are constant so I can't use CAssertF.
|
|
*/
|
|
AssertF(FIELD_OFFSET(HIDP_VALUE_CAPS, NotRange.DataIndex) ==
|
|
FIELD_OFFSET(HIDP_VALUE_CAPS, Range.DataIndexMin));
|
|
AssertF(FIELD_OFFSET(HIDP_VALUE_CAPS, Range.DataIndexMin) ==
|
|
FIELD_OFFSET(HIDP_BUTTON_CAPS, Range.DataIndexMin));
|
|
AssertF(FIELD_OFFSET(HIDP_BUTTON_CAPS, Range.DataIndexMin) ==
|
|
FIELD_OFFSET(HIDP_BUTTON_CAPS, NotRange.DataIndex));
|
|
|
|
#ifdef REALLY_ANNOYING
|
|
/*
|
|
* Dump the Before list.
|
|
*/
|
|
for(ivcaps = 0; ivcaps < cv; ivcaps++)
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("HidP_SortCaps:%2d = %04x"),
|
|
ivcaps, rgvcaps[ivcaps].Range.DataIndexMin);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Since there are typically not very many caps, we will use
|
|
* a simple insertion sort.
|
|
*
|
|
* Note if caps entries have the same data index they are
|
|
* aliases. Make sure the primary alias will be the first
|
|
* in the sorted list.
|
|
*/
|
|
|
|
for(ivcaps = 1; ivcaps < cv; ivcaps++)
|
|
{
|
|
int ivcapsT;
|
|
HIDP_VALUE_CAPS vcaps = rgvcaps[ivcaps];
|
|
|
|
ivcapsT = ivcaps;
|
|
while( ( --ivcapsT >= 0 )
|
|
&&( ( rgvcaps[ivcapsT].Range.DataIndexMin >
|
|
vcaps.Range.DataIndexMin )
|
|
||( ( rgvcaps[ivcapsT].Range.DataIndexMin ==
|
|
vcaps.Range.DataIndexMin )
|
|
&&( rgvcaps[ivcapsT].IsAlias ) ) ) )
|
|
{
|
|
rgvcaps[ivcapsT+1] = rgvcaps[ivcapsT];
|
|
}
|
|
rgvcaps[ivcapsT+1] = vcaps;
|
|
}
|
|
|
|
#ifdef REALLY_ANNOYING
|
|
/*
|
|
* Dump the After list.
|
|
*/
|
|
for(ivcaps = 0; ivcaps < cv; ivcaps++)
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("HidP_SortCaps:%2d = %04x"),
|
|
ivcaps, rgvcaps[ivcaps].Range.DataIndexMin);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Assert that everything is weakly monotonically sorted.
|
|
*
|
|
* If two items are equal, then it means that HID messed up
|
|
* or the values are aliases.
|
|
* We don't complain about it here; we will notice later.
|
|
*/
|
|
for(ivcaps = 1; ivcaps < cv; ivcaps++)
|
|
{
|
|
AssertF(rgvcaps[ivcaps-1].Range.DataIndexMin <=
|
|
rgvcaps[ivcaps ].Range.DataIndexMin);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func DWORD | CHid_FindAspect |
|
|
*
|
|
* Try to determine the aspect flags for this value.
|
|
*
|
|
* @parm PHIDP_VALUE_CAPS | pvcaps |
|
|
*
|
|
* Pointer to HID value caps to search through
|
|
* structures.
|
|
*
|
|
* @returns
|
|
*
|
|
* Flags set for the aspect if found
|
|
*
|
|
* @comm
|
|
* Currently (08-Dec-98) most devices and drivers do not
|
|
* declare units but since drivers must use the generic
|
|
* position usages in order to be recognized assume that
|
|
* these imply that position data is being returned.
|
|
*
|
|
*****************************************************************************/
|
|
DWORD CHID_FindAspect
|
|
(
|
|
PHIDP_VALUE_CAPS pvcaps
|
|
)
|
|
{
|
|
DWORD dwAspect = 0;
|
|
|
|
if( pvcaps->Units )
|
|
{
|
|
#define HID_UNIT_SYSTEM_MASK 0x0000000fL
|
|
#define HID_UNIT_LENGTH_MASK 0x000000f0L
|
|
#define HID_UNIT_MASS_MASK 0x00000f00L
|
|
#define HID_UNIT_TIME_MASK 0x0000f000L
|
|
/*
|
|
* If available, use the units to derive the DI aspect
|
|
* flags for input objects.
|
|
*/
|
|
|
|
if( pvcaps->Units & ~( HID_UNIT_SYSTEM_MASK
|
|
| HID_UNIT_LENGTH_MASK
|
|
| HID_UNIT_MASS_MASK
|
|
| HID_UNIT_TIME_MASK ) )
|
|
{
|
|
SquirtSqflPtszV(sqflTrace | sqflHidParse,
|
|
TEXT("Unit 0x%08x contains basic units that cannot be translated to aspects"),
|
|
pvcaps->Units );
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* The system of measurement should be one of the
|
|
* four defined systems and the length must be one
|
|
* dimensional.
|
|
*/
|
|
if( ( ( pvcaps->Units & ( HID_UNIT_SYSTEM_MASK | HID_UNIT_LENGTH_MASK ) ) >= 0x11 )
|
|
&&( ( pvcaps->Units & ( HID_UNIT_SYSTEM_MASK | HID_UNIT_LENGTH_MASK ) ) <= 0x14 ) )
|
|
{
|
|
switch( pvcaps->Units & ( HID_UNIT_TIME_MASK | HID_UNIT_MASS_MASK ) )
|
|
{
|
|
case 0x0000:
|
|
dwAspect = DIDOI_ASPECTPOSITION;
|
|
break;
|
|
case 0xf000:
|
|
dwAspect = DIDOI_ASPECTVELOCITY;
|
|
break;
|
|
case 0xe000:
|
|
dwAspect = DIDOI_ASPECTACCEL;
|
|
break;
|
|
case 0xe100:
|
|
dwAspect = DIDOI_ASPECTFORCE;
|
|
break;
|
|
default:
|
|
if( 0x0004 == ( pvcaps->Units & ( HID_UNIT_TIME_MASK | HID_UNIT_MASS_MASK | HID_UNIT_SYSTEM_MASK ) ) )
|
|
{
|
|
SquirtSqflPtszV(sqflTrace | sqflHidParse,
|
|
TEXT("Unit \"degrees\" will not be mapped to a DI aspect (probably a POV)") );
|
|
}
|
|
else
|
|
{
|
|
SquirtSqflPtszV(sqflTrace | sqflHidParse,
|
|
TEXT("Unit 0x%04x represents a mass/time unit that cannot be translated to aspects"),
|
|
pvcaps->Units );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SquirtSqflPtszV(sqflTrace | sqflHidParse,
|
|
TEXT("Unit 0x%04x contains represents a length/system unit that cannot be translated to aspects"),
|
|
pvcaps->Units );
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if( dwAspect )
|
|
{
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("Unit 0x%04x translated to aspect 0x%04x"),
|
|
pvcaps->Units, dwAspect );
|
|
}
|
|
#endif
|
|
|
|
#undef HID_UNIT_SYSTEM_MASK
|
|
#undef HID_UNIT_LENGTH_MASK
|
|
#undef HID_UNIT_MASS_MASK
|
|
#undef HID_UNIT_TIME_MASK
|
|
|
|
}
|
|
else
|
|
{
|
|
PHIDUSAGEMAP phum;
|
|
|
|
phum = UsageToUsageMap( DIMAKEUSAGEDWORD( pvcaps->UsagePage,
|
|
pvcaps->Range.UsageMin ) );
|
|
|
|
if( phum && phum->bPosAxis <= 6 )
|
|
{
|
|
phum = UsageToUsageMap( DIMAKEUSAGEDWORD( pvcaps->UsagePage,
|
|
pvcaps->Range.UsageMax ) );
|
|
|
|
if( phum && phum->bPosAxis <= 6 )
|
|
{
|
|
dwAspect = DIDOI_ASPECTPOSITION;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SquirtSqflPtszV(sqflTrace | sqflHidParse,
|
|
TEXT("No aspect found for 0x%04x page usage 0x%04x-0x%04x"),
|
|
pvcaps->UsagePage, pvcaps->Range.UsageMin, pvcaps->Range.UsageMax );
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if( dwAspect )
|
|
{
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("Usage (page:min-max) 0x%04x:0x%04x-0x%04x translated to aspect 0x%04x"),
|
|
pvcaps->UsagePage, pvcaps->Range.UsageMin, pvcaps->Range.UsageMax, dwAspect );
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
return dwAspect;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitAxisClass |
|
|
*
|
|
* Initialize one class (input, feature, output) of axes.
|
|
*
|
|
* @parm PHIDGROUPCAPS | rgcaps |
|
|
*
|
|
* Array of <t HIDGROUPCAPS> structures to receive the caps
|
|
* of the axes in the class.
|
|
*
|
|
* @parm USHORT | ccaps |
|
|
*
|
|
* Number of <t HIDGROUPCAPS> structures we expect to find.
|
|
*
|
|
* @parm HIDP_REPORT_TYPE | type |
|
|
*
|
|
* One of the values
|
|
* <c HidP_Input>,
|
|
* <c HidP_Feature> or
|
|
* <c HidP_Output>.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitAxisClass(PCHID this, PHIDGROUPCAPS rgcaps, USHORT ccaps,
|
|
HIDP_REPORT_TYPE type)
|
|
{
|
|
USHORT cvcaps;
|
|
NTSTATUS stat;
|
|
HRESULT hres;
|
|
DWORD ivcaps;
|
|
LONG lSignedMask;
|
|
PHIDP_VALUE_CAPS rgvcaps;
|
|
|
|
AssertF(rgcaps >= this->rgcaps);
|
|
AssertF(rgcaps + ccaps <= &this->rgcaps[this->ccaps]);
|
|
|
|
/*
|
|
* Annoying quirk:
|
|
*
|
|
* HID doesn't like it when you pass 0 to HidP_GetValueCaps,
|
|
* so we need to special-case the "no axes" scenario.
|
|
*/
|
|
if(ccaps == 0)
|
|
{
|
|
hres = S_OK;
|
|
goto done;
|
|
}
|
|
|
|
hres = AllocCbPpv(cbCxX(ccaps, HIDP_VALUE_CAPS), &rgvcaps);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
cvcaps = ccaps;
|
|
stat = HidP_GetValueCaps(type, rgvcaps, &cvcaps, this->ppd);
|
|
if(FAILED(stat))
|
|
{
|
|
RPF("HidP_GetValueCaps failed - can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
if(cvcaps != ccaps)
|
|
{
|
|
RPF("HidP_GetValueCaps inconsistent with HidP_GetCaps - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
CHid_SortCaps(rgvcaps, cvcaps);
|
|
|
|
for(ivcaps = 0; ivcaps < cvcaps; ivcaps++)
|
|
{
|
|
PHIDP_VALUE_CAPS pvcaps = &rgvcaps[ivcaps];
|
|
PHIDGROUPCAPS pcaps = &rgcaps[ivcaps];
|
|
BOOL fPOV;
|
|
UINT uiObj;
|
|
UINT duiObj;
|
|
DWORD dwAspect;
|
|
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd Ignoring report count
|
|
* We ignore the report count which may be bad, need
|
|
* to test device with values declared in a range to see what HID
|
|
* really gives us.
|
|
* At the descriptor level, values can be delared in a range with
|
|
* usages and the last usage is repeated for any excess values.
|
|
*/
|
|
if(pvcaps->IsRange)
|
|
{
|
|
if(pvcaps->Range.DataIndexMax - pvcaps->Range.DataIndexMin !=
|
|
pvcaps->Range.UsageMax - pvcaps->Range.UsageMin)
|
|
{
|
|
RPF("HidP_GetValueCaps corrupted VALUE_CAPS - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
} else
|
|
{
|
|
pvcaps->Range.UsageMax = pvcaps->Range.UsageMin;
|
|
}
|
|
|
|
if( ( type == HidP_Input ) && !pvcaps->IsAlias )
|
|
{
|
|
/*
|
|
* The values are sorted by data index with the primary alias
|
|
* before any other. So find out the aspect of the axis each
|
|
* time we get a new primary and use it for any alias that follow.
|
|
*/
|
|
dwAspect = CHID_FindAspect( pvcaps );
|
|
}
|
|
|
|
pcaps->wReportId = pvcaps->ReportID;
|
|
this->wMaxReportId[type] = max(pcaps->wReportId, this->wMaxReportId[type]);
|
|
|
|
pcaps->UsagePage = pvcaps->UsagePage;
|
|
pcaps->UsageMin = pvcaps->Range.UsageMin;
|
|
pcaps->DataIndexMin = pvcaps->Range.DataIndexMin;
|
|
|
|
pcaps->cObj = pvcaps->Range.UsageMax -
|
|
pvcaps->Range.UsageMin + 1;
|
|
|
|
/*
|
|
* The mask consists of the top bit of the BitSize and
|
|
* all bits above it. Examples:
|
|
*
|
|
* BitSize 8 32
|
|
* BitSize - 1 7 31
|
|
* 1 << (BitSize - 1) 0x00000080 0x80000000
|
|
* (1 << (BitSize - 1)) - 1 0x0000007F 0x7FFFFFFF
|
|
* ~((1 << (BitSize - 1)) - 1) 0xFFFFFF80 0x80000000
|
|
*
|
|
*/
|
|
|
|
pcaps->BitSize = pvcaps->BitSize;
|
|
pcaps->lMask = ~((1 << (pcaps->BitSize - 1)) - 1);
|
|
lSignedMask = max( 1, ( 1 << pcaps->BitSize) -1 );
|
|
|
|
pcaps->LinkCollection = pvcaps->LinkCollection;
|
|
pcaps->Units = pvcaps->Units;
|
|
pcaps->Exponent = LOWORD(pvcaps->UnitsExp);
|
|
|
|
pcaps->Logical.Min = pvcaps->LogicalMin;
|
|
pcaps->Logical.Max = pvcaps->LogicalMax;
|
|
|
|
pcaps->Physical.Min = pvcaps->PhysicalMin;
|
|
pcaps->Physical.Max = pvcaps->PhysicalMax;
|
|
|
|
if(pcaps->Logical.Min >= pcaps->Logical.Max)
|
|
{
|
|
RPF("HidP_GetValueCaps Logical Min >= Logical Max - ");
|
|
|
|
if( pcaps->Physical.Min < pcaps->Physical.Max )
|
|
{
|
|
pcaps->Logical = pcaps->Physical;
|
|
} else
|
|
{
|
|
pcaps->Logical.Min = pcaps->lMask;
|
|
pcaps->Logical.Max = ~pcaps->lMask;
|
|
}
|
|
|
|
SquirtSqflPtszV(sqflHidParse | sqflVerbose,
|
|
TEXT("HidP_GetValueCaps:")
|
|
TEXT("Logical Min(was:%d now:%d)")
|
|
TEXT("Logical Max(was:%d now:%d)"),
|
|
pvcaps->LogicalMin, pcaps->Logical.Min,
|
|
pvcaps->LogicalMax, pcaps->Logical.Max);
|
|
|
|
}
|
|
|
|
/*
|
|
* the range for LogicalMin / LogicalMax had better fall
|
|
* within the range of values the device can possibly
|
|
* report.
|
|
*
|
|
* The lMask value happens also to be the smallest possible
|
|
* negative value, and the bitwise negation of it happens
|
|
* to be the largest possible positive value. The wonders
|
|
* of two-s complement arithmetic.
|
|
*/
|
|
|
|
/*
|
|
* Extra case is fix for 268519
|
|
*/
|
|
if(pcaps->Physical.Min > pcaps->Physical.Max)
|
|
{
|
|
RPF("HidP_GetValueCaps Physical Min/Max(%d/%d) is bad setting all to zero to %d"
|
|
"device may have bad firmware", pcaps->Physical.Min, pcaps->Physical.Max, lSignedMask);
|
|
|
|
pcaps->Logical.Min = 0;
|
|
pcaps->Physical.Min = 0;
|
|
pcaps->Logical.Max = lSignedMask;
|
|
pcaps->Physical.Max = lSignedMask;
|
|
pcaps->lMask = lSignedMask;
|
|
pcaps->IsSigned = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if(pcaps->Physical.Min == pcaps->Physical.Max)
|
|
{
|
|
pcaps->Physical = pcaps->Logical;
|
|
}
|
|
|
|
if(pcaps->Logical.Min >= pcaps->lMask && // Logical Min / Max are signed
|
|
pcaps->Logical.Max <= ~pcaps->lMask)
|
|
{
|
|
pcaps->IsSigned = TRUE;
|
|
|
|
} else if(pcaps->Logical.Min >= 0 &&
|
|
pcaps->Logical.Max <= lSignedMask )
|
|
{ // Logical Min / Max are unsigned
|
|
pcaps->lMask = lSignedMask;
|
|
pcaps->IsSigned = FALSE;
|
|
|
|
} else if (pcaps->UsagePage >= HID_USAGE_PAGE_VENDOR )
|
|
{
|
|
// Let this one pass, hopefully the broken descriptors are for
|
|
// usages that are vendor specific and will not effect too many folks
|
|
RPF("HidP_GetValueCaps Logical Min/Max(%d/%d) don't fit in BitSize(%d) - "
|
|
"device may have bad firmware", pcaps->Logical.Min, pcaps->Logical.Max, pcaps->BitSize);
|
|
|
|
pcaps->Logical.Min = pcaps->lMask;
|
|
pcaps->Logical.Max = ~pcaps->lMask;
|
|
pcaps->IsSigned = TRUE;
|
|
|
|
}else
|
|
{
|
|
RPF("HidP_GetValueCaps UsagePage(0x%x)Usage(0x%x) Logical Min/Max(%d/%d) don't fit in BitSize(%d) - "
|
|
"can't use device", pcaps->UsagePage, pcaps->UsageMin, pcaps->Logical.Min, pcaps->Logical.Max, pcaps->BitSize);
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
}
|
|
|
|
AssertF(pcaps->Physical.Min < pcaps->Physical.Max);
|
|
|
|
pcaps->StringMin = pvcaps->Range.StringMin;
|
|
pcaps->StringMax = pvcaps->IsStringRange ?
|
|
pvcaps->Range.StringMax :
|
|
pvcaps->Range.StringMin;
|
|
|
|
pcaps->DesignatorMin = pvcaps->Range.DesignatorMin;
|
|
pcaps->DesignatorMax = pvcaps->IsDesignatorRange ?
|
|
pvcaps->Range.DesignatorMax :
|
|
pvcaps->Range.DesignatorMin;
|
|
|
|
pcaps->IsAbsolute = pvcaps->IsAbsolute;
|
|
pcaps->IsValue = TRUE;
|
|
pcaps->IsAlias = pvcaps->IsAlias;
|
|
pcaps->type = type;
|
|
|
|
/*
|
|
* HID reports axes and POVs as the same thing, and the two
|
|
* POV usages we recognize are in different pages, so you
|
|
* will never get multiple POVs coming through in a single
|
|
* value-caps.
|
|
*
|
|
* ISSUE-2001/03/06-MarcAnd POVs within caps are treated as axes
|
|
* There is, however, the problem of a POV buried inside
|
|
* a larger value-cap that describes axes. Tough. Those
|
|
* POVs are in trouble.
|
|
*/
|
|
|
|
#define HID_USAGE_GAME_POV ((USAGE) 0x20)
|
|
|
|
fPOV = pcaps->cObj == 1
|
|
&& ( ( pcaps->UsagePage == HID_USAGE_PAGE_GENERIC
|
|
&&pcaps->UsageMin == HID_USAGE_GENERIC_HATSWITCH )
|
|
||( pcaps->UsagePage == HID_USAGE_PAGE_GAME
|
|
&&pcaps->UsageMin == HID_USAGE_GAME_POV ) );
|
|
|
|
|
|
if(fPOV)
|
|
{
|
|
LONG lUnits;
|
|
|
|
/*
|
|
* POVs are assumed to start at north and increase
|
|
* clockwise through the logical maximum.
|
|
*/
|
|
lUnits = pcaps->Logical.Max - pcaps->Logical.Min + 1;
|
|
if(lUnits)
|
|
{
|
|
pcaps->usGranularity = (USHORT)(36000U / lUnits);
|
|
}
|
|
} else
|
|
{
|
|
if( ( pcaps->UsagePage == HID_USAGE_PAGE_GENERIC &&
|
|
pcaps->UsageMin <= HID_USAGE_GENERIC_HATSWITCH &&
|
|
pvcaps->Range.UsageMax >= HID_USAGE_GENERIC_HATSWITCH )
|
|
||( pcaps->UsagePage == HID_USAGE_PAGE_GAME &&
|
|
pcaps->UsageMin <= HID_USAGE_GAME_POV &&
|
|
pvcaps->Range.UsageMax >= HID_USAGE_GAME_POV ) )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("HidP_GetValueCaps - multi-usage cap ")
|
|
TEXT("includes hatswitch or POV - will be treated")
|
|
TEXT("as axis"));
|
|
}
|
|
}
|
|
|
|
#undef HID_USAGE_GAME_POV
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Objs = %d"),
|
|
type, ivcaps, pcaps->cObj);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Index %d ..."),
|
|
type, ivcaps,
|
|
pcaps->DataIndexMin);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Logical = %d..%d"),
|
|
type, ivcaps,
|
|
pcaps->Logical.Min, pcaps->Logical.Max);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Physical = %d..%d"),
|
|
type, ivcaps,
|
|
pcaps->Physical.Min, pcaps->Physical.Max);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Units = 0x%08x"),
|
|
type, ivcaps,
|
|
pcaps->Units);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: IsAbs = %d"),
|
|
type, ivcaps,
|
|
pcaps->IsAbsolute);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: BitSize = %d"),
|
|
type, ivcaps,
|
|
pcaps->BitSize);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: IsAlias = %d"),
|
|
type, ivcaps,
|
|
pcaps->IsAlias);
|
|
if(pcaps->LinkCollection)
|
|
{
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: ")
|
|
TEXT("LinkCollection %d"),
|
|
type, ivcaps,
|
|
pcaps->LinkCollection);
|
|
}
|
|
|
|
/*
|
|
* Come up with a decent Null value if possible.
|
|
* The traditional Null value is the arithmetically
|
|
* smallest value which lies outside the
|
|
* LogicalMin/LogicalMax range. Conveniently, the
|
|
* pcaps->lMask is the most negative value that is
|
|
* in range.
|
|
*/
|
|
AssertF(pcaps->Null == 0);
|
|
if(pvcaps->HasNull)
|
|
{
|
|
#ifdef WINNT
|
|
pcaps->IsPolledPOV = FALSE;
|
|
#endif
|
|
|
|
if(pcaps->lMask < pcaps->Logical.Min)
|
|
{
|
|
pcaps->Null = pcaps->lMask;
|
|
} else if(!(pcaps->lMask & (pcaps->Logical.Max + 1)))
|
|
{
|
|
pcaps->Null = pcaps->Logical.Max + 1;
|
|
} else if( ! pcaps->IsSigned )
|
|
{
|
|
pcaps->Null = 0x0;
|
|
} else
|
|
{
|
|
SquirtSqflPtszV(sqflTrace,
|
|
TEXT("VALUE_CAPS claims Null but no room!"));
|
|
}
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Null = %d"),
|
|
type, ivcaps,
|
|
pcaps->Null);
|
|
} else {
|
|
#ifdef WINNT
|
|
if( fPOV &&
|
|
(this->VendorID == MSFT_SYSTEM_VID ) &&
|
|
( (this->ProductID & 0xff00) == MSFT_SYSTEM_PID) )
|
|
{
|
|
LONG lUnits;
|
|
|
|
lUnits = pcaps->Logical.Max - pcaps->Logical.Min + 1;
|
|
if(lUnits)
|
|
{
|
|
pcaps->usGranularity = (USHORT)9000;
|
|
}
|
|
|
|
pcaps->IsPolledPOV = TRUE;
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetValueCaps(%d)[%d]: Null = %d (Polled POV)."),
|
|
type, ivcaps,
|
|
pcaps->Null);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
uiObj = this->rgdwBase[type] + pcaps->DataIndexMin;
|
|
for(duiObj = 0; duiObj < pcaps->cObj; duiObj++)
|
|
{
|
|
DWORD dwObjType;
|
|
LPDIOBJECTDATAFORMAT podf;
|
|
|
|
/*
|
|
* If HID messed up and gave us something out of range,
|
|
* then give up on this value caps (since the rest are
|
|
* also out of range) and move on to the next one.
|
|
*/
|
|
if(uiObj + duiObj >= this->df.dwNumObjs)
|
|
{
|
|
RPF("HidP_GetValueCaps inconsistent with NumberDataIndices - "
|
|
"skipping object (sorry)");
|
|
break;
|
|
}
|
|
|
|
AssertF(uiObj + duiObj < this->df.dwNumObjs);
|
|
|
|
if(this->rghoc[uiObj + duiObj].pcaps)
|
|
{
|
|
RPF("HidP_GetValueCaps inconsistent - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
this->rghoc[uiObj + duiObj].pcaps = pcaps;
|
|
podf = &this->df.rgodf[uiObj + duiObj];
|
|
|
|
/*
|
|
* HACKHACK! Wheels are identified by
|
|
* UsageToUsageMap as GUID_Slider, but we
|
|
* want them to be GUID_ZAxis if we are a mouse.
|
|
*
|
|
* We also set the granularity here.
|
|
*/
|
|
if(GET_DIDEVICE_TYPE(this->dwDevType) == DI8DEVTYPE_MOUSE &&
|
|
pcaps->UsageMin + duiObj == HID_USAGE_GENERIC_WHEEL &&
|
|
pcaps->UsagePage == HID_USAGE_PAGE_GENERIC)
|
|
{
|
|
podf->pguid = &GUID_ZAxis;
|
|
pcaps->usGranularity = (USHORT)g_lWheelGranularity;
|
|
} else if( type == HidP_Input )
|
|
{
|
|
PHIDUSAGEMAP phum;
|
|
|
|
phum = UsageToUsageMap( DIMAKEUSAGEDWORD( pcaps->UsagePage,
|
|
pcaps->UsageMin + duiObj ) );
|
|
if(phum)
|
|
{
|
|
podf->pguid = phum->pguid;
|
|
} else
|
|
{
|
|
podf->pguid = &GUID_Unknown;
|
|
}
|
|
} else
|
|
{
|
|
podf->pguid = &GUID_Unknown;
|
|
}
|
|
|
|
/*
|
|
* Set a default instance. This will be overwritten later
|
|
* if this object is of a type we fully understand.
|
|
*/
|
|
dwObjType = DIDFT_MAKEINSTANCE(uiObj + duiObj);
|
|
|
|
if( pcaps->IsAlias )
|
|
{
|
|
dwObjType |= DIDFT_ALIAS;
|
|
}
|
|
|
|
if(pcaps->UsagePage >= HID_USAGE_PAGE_VENDOR )
|
|
{
|
|
dwObjType |= DIDFT_VENDORDEFINED;
|
|
}
|
|
else if(podf->pguid == &GUID_POV)
|
|
{
|
|
/* Note, this must be an input to have been mapped */
|
|
dwObjType |= DIDFT_POV;
|
|
if( !pcaps->IsAlias )
|
|
{
|
|
this->dwPOVs++;
|
|
}
|
|
}
|
|
else if( type == HidP_Input )
|
|
{
|
|
/*
|
|
* In order to reduce the likelyhood of an app picking up an
|
|
* input value that is not a user controlled axis, only mark
|
|
* values as axes if they are inputs on a usage page that
|
|
* contains such usages.
|
|
* ISSUE-2000/11/07-MarcAnd ideally we should be looking at
|
|
* not only the usage of the object but at the collections
|
|
* that contain it.
|
|
*/
|
|
switch( pcaps->UsagePage )
|
|
{
|
|
case HID_USAGE_PAGE_BUTTON:
|
|
/*
|
|
* The plan was that an absolute input axis on the button
|
|
* page would be an analog button. Unfortunately it
|
|
* could be a mis-declared button array selector (482186).
|
|
* Safest thing is to ignore the thing completely.
|
|
*/
|
|
SquirtSqflPtszV(sqfl | sqflVerbose,
|
|
TEXT("Ignoring value on button page usage ID 0x%04X"),
|
|
pcaps->UsageMin + duiObj );
|
|
break;
|
|
|
|
case HID_USAGE_PAGE_GENERIC:
|
|
if( pcaps->UsageMin + duiObj == HID_USAGE_GENERIC_COUNTED_BUFFER )
|
|
{
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Leaving counted buffer as unclassified object") );
|
|
break;
|
|
}
|
|
|
|
if( pcaps->UsageMin + duiObj == HID_USAGE_GENERIC_BYTE_COUNT )
|
|
{
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Leaving byte count as unclassified object") );
|
|
break;
|
|
}
|
|
|
|
case HID_USAGE_PAGE_SIMULATION:
|
|
case HID_USAGE_PAGE_VR:
|
|
case HID_USAGE_PAGE_SPORT:
|
|
case HID_USAGE_PAGE_GAME:
|
|
case HID_USAGE_PAGE_KEYBOARD:
|
|
case HID_USAGE_PAGE_CONSUMER:
|
|
case HID_USAGE_PAGE_DIGITIZER:
|
|
if( pcaps->IsAbsolute)
|
|
{
|
|
dwObjType |= DIDFT_ABSAXIS;
|
|
}
|
|
else
|
|
{
|
|
dwObjType |= DIDFT_RELAXIS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Assuming value 0x%04X:0x%04X is not a user control"),
|
|
pcaps->UsagePage,pcaps->UsageMin + duiObj );
|
|
}
|
|
|
|
if( ( dwObjType & DIDFT_AXIS ) && !pcaps->IsAlias )
|
|
{
|
|
this->dwAxes++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Objects must have an offset to be accessed
|
|
*/
|
|
podf->dwOfs = this->df.dwDataSize;
|
|
if( !pcaps->IsAlias)
|
|
{
|
|
this->df.dwDataSize += cbX(DWORD);
|
|
}
|
|
|
|
if(HidP_IsOutputLike(type))
|
|
{
|
|
/*
|
|
* Input and feature allow data; output does not.
|
|
*/
|
|
if(type == HidP_Output)
|
|
{
|
|
dwObjType |= ( DIDFT_NODATA | DIDFT_OUTPUT );
|
|
}
|
|
else
|
|
{
|
|
dwObjType |= DIDFT_OUTPUT;
|
|
}
|
|
}
|
|
|
|
podf->dwType = dwObjType;
|
|
|
|
|
|
if(type != HidP_Input )
|
|
{
|
|
podf->dwFlags = DIDOI_POLLED | DIDOI_NOTINPUT;
|
|
}
|
|
else if(this->IsPolledInput )
|
|
{
|
|
podf->dwFlags = dwAspect | DIDOI_POLLED;
|
|
} else
|
|
{
|
|
podf->dwFlags = dwAspect;
|
|
}
|
|
|
|
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd DIDOI FF attributes
|
|
*/
|
|
if( this->fPIDdevice // FF device
|
|
&& ! IsEqualGUID(podf->pguid, &GUID_Unknown ) ) // We map the axis
|
|
{
|
|
NTSTATUS ntStat;
|
|
USHORT cAButton=0x0;
|
|
|
|
ntStat = HidP_GetSpecificButtonCaps
|
|
(
|
|
HidP_Output, // ReportType
|
|
pcaps->UsagePage, // UsagePage
|
|
0x0, // Link Collection
|
|
(USAGE)(pcaps->UsageMin + duiObj), // Usage
|
|
NULL, // ValueCaps
|
|
&cAButton, // ValueCapsLength
|
|
this->ppd // PreparsedData
|
|
);
|
|
|
|
if( SUCCEEDED(ntStat)
|
|
|| (ntStat == HIDP_STATUS_BUFFER_TOO_SMALL) )// In case someone has more than one
|
|
|
|
{
|
|
podf->dwFlags |= DIDOI_FFACTUATOR;
|
|
podf->dwType |= DIDFT_MAKEATTR(DIDOI_FFACTUATOR);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Note that we do not calibrate relative axes,
|
|
* since there's really nothing to calibrate.
|
|
*
|
|
* Note also that we calibrate only inputs.
|
|
* We don't want to do de-calibration on outputs.
|
|
* (And since features are input+output, we don't
|
|
* do it on features either.)
|
|
*
|
|
* We merely set up the calibration here; the
|
|
* reading of the calibration values is done
|
|
* by CHid_LoadCalibrations.
|
|
*
|
|
*/
|
|
if(type == HidP_Input)
|
|
{
|
|
|
|
PJOYRANGECONVERT pjrc = this->pjrcNext++;
|
|
|
|
this->rghoc[uiObj + duiObj].pjrc = pjrc;
|
|
|
|
/*
|
|
* Saturation always defaults to 100%.
|
|
*/
|
|
pjrc->dwSat = RANGEDIVISIONS;
|
|
AssertF(pjrc->dwDz == 0);
|
|
|
|
if( dwObjType & DIDFT_ABSAXIS )
|
|
{
|
|
pjrc->lMin = 0;
|
|
pjrc->lMax = 65535;
|
|
pjrc->lC = 65535/2;
|
|
}
|
|
#ifdef WINNT
|
|
else if( (dwObjType & DIDFT_POV) && pcaps->IsPolledPOV )
|
|
{
|
|
pjrc->fPolledPOV = TRUE;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
D(pcaps->dwSignature = HIDGROUPCAPS_SIGNATURE);
|
|
}
|
|
|
|
hres = S_OK;
|
|
|
|
freedone:;
|
|
FreePv(rgvcaps);
|
|
|
|
done:;
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitAxes |
|
|
*
|
|
* Identify and initialize the axes: input, feature and output.
|
|
*
|
|
* HID calls them "values" because they might not really
|
|
* be axes in the joystick sense.
|
|
*
|
|
* The input axes come first, then the feature axes,
|
|
* then the output axes.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitAxes(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
DWORD ccaps;
|
|
|
|
/*
|
|
* Do the input axes...
|
|
*/
|
|
hres = CHid_InitAxisClass(this, &this->rgcaps[0],
|
|
this->caps.NumberInputValueCaps,
|
|
HidP_Input);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
ccaps = this->caps.NumberInputValueCaps;
|
|
|
|
/*
|
|
* Do the feature axes...
|
|
*/
|
|
hres = CHid_InitAxisClass(this, &this->rgcaps[ccaps],
|
|
this->caps.NumberFeatureValueCaps,
|
|
HidP_Feature);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
ccaps += this->caps.NumberFeatureValueCaps;
|
|
|
|
/*
|
|
* Do the output axes...
|
|
*/
|
|
hres = CHid_InitAxisClass(this, &this->rgcaps[ccaps],
|
|
this->caps.NumberOutputValueCaps,
|
|
HidP_Output);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
done:;
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitButtonClass |
|
|
*
|
|
* Initialize one class (input, feature, output) of buttons.
|
|
*
|
|
* @parm PHIDGROUPCAPS | rgcaps |
|
|
*
|
|
* Array of <t HIDGROUPCAPS> structures to receive the caps
|
|
* of the buttons in the class.
|
|
*
|
|
* @parm USHORT | ccaps |
|
|
*
|
|
* Number of <t HIDGROUPCAPS> structures we expect to find.
|
|
*
|
|
* @parm HIDP_REPORT_TYPE | type |
|
|
*
|
|
* One of the values
|
|
* <c HidP_Input>,
|
|
* <c HidP_Feature> or
|
|
* <c HidP_Output>.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL CHid_InitButtonClass
|
|
(
|
|
PCHID this,
|
|
PHIDGROUPCAPS rgcaps,
|
|
PBYTE rgbReportIDs,
|
|
USHORT ccaps,
|
|
HIDP_REPORT_TYPE type
|
|
)
|
|
{
|
|
USHORT cbcaps;
|
|
NTSTATUS stat;
|
|
HRESULT hres;
|
|
DWORD ibcaps;
|
|
PHIDP_BUTTON_CAPS rgbcaps;
|
|
|
|
AssertF(rgcaps >= this->rgcaps);
|
|
AssertF(rgcaps + ccaps <= &this->rgcaps[this->ccaps]);
|
|
|
|
/*
|
|
* Annoying quirk:
|
|
*
|
|
* HID doesn't like it when you pass 0 to HidP_GetButtonCaps,
|
|
* so we need to special-case the "no buttons" scenario.
|
|
*/
|
|
if(ccaps == 0)
|
|
{
|
|
hres = S_OK;
|
|
goto done;
|
|
}
|
|
|
|
hres = AllocCbPpv(cbCxX(ccaps, HIDP_BUTTON_CAPS), &rgbcaps);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
cbcaps = ccaps;
|
|
|
|
stat = HidP_GetButtonCaps(type, rgbcaps, &cbcaps, this->ppd);
|
|
|
|
if(FAILED(stat))
|
|
{
|
|
RPF("HidP_GetButtonCaps failed - can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
/* HidP_GetCaps has the annoying habit of treating everything that is
|
|
* single bit as a button.
|
|
* This causes some problems. For example the ALPS gamepad declares its
|
|
* POVs as single bit values, (not buttons though).
|
|
* Hence we need to be prepared for the buttons being less than advertised
|
|
*/
|
|
|
|
if(cbcaps != ccaps)
|
|
{
|
|
RPF("HidP_GetButtonCaps(%d) (%d) inconsistent "
|
|
"with HidP_GetCaps (%d) - "
|
|
"can't use device", type, cbcaps, ccaps);
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
CHid_SortCaps(rgbcaps, cbcaps);
|
|
|
|
for(ibcaps = 0; ibcaps < cbcaps; ibcaps++)
|
|
{
|
|
PHIDP_BUTTON_CAPS pbcaps = &rgbcaps[ibcaps];
|
|
PHIDGROUPCAPS pcaps = &rgcaps[ibcaps];
|
|
UINT uiObj;
|
|
UINT duiObj;
|
|
|
|
if(pbcaps->IsRange)
|
|
{
|
|
if(pbcaps->Range.DataIndexMax - pbcaps->Range.DataIndexMin !=
|
|
pbcaps->Range.UsageMax - pbcaps->Range.UsageMin)
|
|
{
|
|
RPF("HidP_GetButtonCaps corrupted BUTTON_CAPS - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
} else
|
|
{
|
|
pbcaps->Range.UsageMax = pbcaps->Range.UsageMin;
|
|
}
|
|
|
|
pcaps->wReportId = pbcaps->ReportID;
|
|
this->wMaxReportId[type] = max(pcaps->wReportId, this->wMaxReportId[type]);
|
|
|
|
pcaps->UsagePage = pbcaps->UsagePage;
|
|
pcaps->UsageMin = pbcaps->Range.UsageMin;
|
|
pcaps->DataIndexMin = pbcaps->Range.DataIndexMin;
|
|
|
|
pcaps->cObj = pbcaps->Range.UsageMax -
|
|
pbcaps->Range.UsageMin + 1;
|
|
|
|
/*
|
|
* Buttons are (from the HID definition) items with
|
|
* a bit size of 1.
|
|
*/
|
|
pcaps->BitSize = 1;
|
|
pcaps->lMask = ~((1 << (pcaps->BitSize - 1)) - 1);
|
|
/*
|
|
* Not applicable for buttons:
|
|
*
|
|
* LogicalMin/Max, PhysicalMin/Max, Units.
|
|
*/
|
|
pcaps->LinkCollection = pbcaps->LinkCollection;
|
|
|
|
pcaps->StringMin = pbcaps->Range.StringMin;
|
|
pcaps->StringMax = pbcaps->IsStringRange ?
|
|
pbcaps->Range.StringMax :
|
|
pbcaps->Range.StringMin;
|
|
|
|
pcaps->DesignatorMin = pbcaps->Range.DesignatorMin;
|
|
pcaps->DesignatorMax = pbcaps->IsDesignatorRange ?
|
|
pbcaps->Range.DesignatorMax :
|
|
pbcaps->Range.DesignatorMin;
|
|
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd What does IsAbsolute mean for a button?
|
|
*/
|
|
pcaps->IsAbsolute = pbcaps->IsAbsolute;
|
|
|
|
AssertF(!pcaps->IsValue);
|
|
|
|
pcaps->type = type;
|
|
|
|
pcaps->IsAlias = pbcaps->IsAlias;
|
|
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetButtonCaps(%d)[%d]: ")
|
|
TEXT("Objs=%2d ")
|
|
TEXT("idx=%2d... ")
|
|
TEXT("coll=%d")
|
|
TEXT("IsAlias=%d"),
|
|
type, ibcaps,
|
|
pcaps->cObj,
|
|
pcaps->DataIndexMin,
|
|
pcaps->LinkCollection,
|
|
pcaps->IsAlias);
|
|
|
|
uiObj = this->rgdwBase[type] + pcaps->DataIndexMin;
|
|
for(duiObj = 0; duiObj < pcaps->cObj; duiObj++)
|
|
{
|
|
DWORD dwObjType;
|
|
LPDIOBJECTDATAFORMAT podf;
|
|
/*
|
|
* If HID messed up and gave us something out of range,
|
|
* then give up on this value caps (since the rest are
|
|
* also out of range) and move on to the next one.
|
|
*/
|
|
if(uiObj + duiObj >= this->df.dwNumObjs)
|
|
{
|
|
RPF("HidP_GetButtonCaps inconsistent with NumberDataIndices - "
|
|
"skipping object (sorry)");
|
|
break;
|
|
}
|
|
|
|
AssertF(uiObj + duiObj < this->df.dwNumObjs);
|
|
|
|
if(this->rghoc[uiObj + duiObj].pcaps)
|
|
{
|
|
RPF("HidP_GetButtonCaps inconsistent - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
/*
|
|
* No fatal errors have been detected so store the object details
|
|
*/
|
|
AssertF( rgbReportIDs[uiObj + duiObj] == 0 );
|
|
rgbReportIDs[uiObj + duiObj] = pbcaps->ReportID;
|
|
|
|
this->rghoc[uiObj + duiObj].pcaps = pcaps;
|
|
podf = &this->df.rgodf[uiObj + duiObj];
|
|
|
|
/*
|
|
* Set a default instance. This will be overwritten later
|
|
* if this object is of a type we fully understand.
|
|
*/
|
|
dwObjType = DIDFT_MAKEINSTANCE(uiObj + duiObj);
|
|
|
|
if(pcaps->UsagePage >= HID_USAGE_PAGE_VENDOR )
|
|
{
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd vendor defined objects
|
|
* An aliased vendor defined usage may have a standard (not
|
|
* vendor defined) alias but the whole object will still be
|
|
* marked as vendor defined
|
|
*/
|
|
if( pcaps->IsAlias )
|
|
{
|
|
dwObjType |= DIDFT_ALIAS;
|
|
}
|
|
dwObjType |= DIDFT_VENDORDEFINED;
|
|
podf->pguid = &GUID_Unknown;
|
|
}
|
|
else
|
|
{
|
|
if( pcaps->IsAlias )
|
|
{
|
|
dwObjType |= DIDFT_ALIAS;
|
|
}
|
|
/*
|
|
* In order to reduce the likelyhood of an app picking up a
|
|
* bit that is not a user controlled button, only mark bits
|
|
* as buttons if they are inputs on a usage page that
|
|
* contains such usages.
|
|
* ISSUE-2000/11/07-MarcAnd ideally we should be looking at
|
|
* not only the usage of the object but at the collections
|
|
* that contain it.
|
|
*/
|
|
if( type == HidP_Input )
|
|
{
|
|
switch( pcaps->UsagePage )
|
|
{
|
|
case HID_USAGE_PAGE_KEYBOARD:
|
|
podf->pguid = &GUID_Key;
|
|
break;
|
|
|
|
case HID_USAGE_PAGE_BUTTON:
|
|
if( ( duiObj == 0 )
|
|
&& ( pcaps->UsageMin == 0 ) )
|
|
{
|
|
/*
|
|
* Special case button zero means no buttons
|
|
* are pressed
|
|
*/
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Ignoring \"No button\" button") );
|
|
goto IgnoreButton;
|
|
}
|
|
case HID_USAGE_PAGE_GENERIC:
|
|
case HID_USAGE_PAGE_SIMULATION:
|
|
case HID_USAGE_PAGE_VR:
|
|
case HID_USAGE_PAGE_SPORT:
|
|
case HID_USAGE_PAGE_GAME:
|
|
case HID_USAGE_PAGE_CONSUMER:
|
|
case HID_USAGE_PAGE_DIGITIZER:
|
|
podf->pguid = &GUID_Button;
|
|
break;
|
|
default:
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Assuming button 0x%04X:0x%04X is not a user control"),
|
|
pcaps->UsagePage,pcaps->UsageMin + duiObj );
|
|
goto IgnoreButton;
|
|
}
|
|
|
|
dwObjType |= DIDFT_PSHBUTTON;
|
|
if( !pcaps->IsAlias )
|
|
{
|
|
this->dwButtons++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SquirtSqflPtszV(sqfl | sqflTrace,
|
|
TEXT("Assuming non-input bit 0x%04X:0x%04X is not a user control"),
|
|
pcaps->UsagePage,pcaps->UsageMin + duiObj );
|
|
IgnoreButton:;
|
|
podf->pguid = &GUID_Unknown;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Objects must have an offset to be accessed
|
|
*/
|
|
podf->dwOfs = this->df.dwDataSize;
|
|
if( !pcaps->IsAlias)
|
|
{
|
|
this->df.dwDataSize += cbX(BYTE);
|
|
}
|
|
|
|
if(HidP_IsOutputLike(type))
|
|
{
|
|
/*
|
|
* Input and feature allow data; output does not.
|
|
*/
|
|
if(type == HidP_Output)
|
|
{
|
|
dwObjType |= ( DIDFT_NODATA | DIDFT_OUTPUT );
|
|
}
|
|
else
|
|
{
|
|
dwObjType |= DIDFT_OUTPUT;
|
|
}
|
|
}
|
|
|
|
podf->dwType = dwObjType;
|
|
|
|
if(type != HidP_Input )
|
|
{
|
|
podf->dwFlags = DIDOI_POLLED | DIDOI_NOTINPUT;
|
|
} else if( this->IsPolledInput )
|
|
{
|
|
podf->dwFlags = DIDOI_POLLED;
|
|
} else
|
|
{
|
|
podf->dwFlags = 0;
|
|
}
|
|
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd DIDOI FF attributes if not defined in registry
|
|
*/
|
|
if( this->fPIDdevice
|
|
&& ( dwObjType & DIDFT_PSHBUTTON ) )
|
|
{
|
|
podf->dwFlags |= DIDOI_FFEFFECTTRIGGER;
|
|
podf->dwType |= DIDFT_MAKEATTR(DIDOI_FFEFFECTTRIGGER);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
D(pcaps->dwSignature = HIDGROUPCAPS_SIGNATURE);
|
|
}
|
|
|
|
hres = S_OK;
|
|
|
|
freedone:;
|
|
FreePv(rgbcaps);
|
|
|
|
done:;
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitButtons |
|
|
*
|
|
* Identify and initialize the buttons: input, feature, and output.
|
|
*
|
|
* The input buttons come first, then the feature buttons,
|
|
* then the output buttons.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitButtons(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
DWORD ccaps;
|
|
PBYTE rgbReportIDs;
|
|
UINT cbReportIDs;
|
|
UINT uMaxReportId;
|
|
|
|
this->ibButtonData = this->df.dwDataSize;
|
|
|
|
/*
|
|
* Skip over the value caps to get to the buttons ...
|
|
*/
|
|
ccaps = this->caps.NumberInputValueCaps +
|
|
this->caps.NumberFeatureValueCaps +
|
|
this->caps.NumberOutputValueCaps;
|
|
|
|
/*
|
|
* Allocate a temporary buffer to store the report ID of each button.
|
|
* We use the sum of all data indices and collections so that the
|
|
* internal object index of each button can be used as the index into
|
|
* the buffer. We leave value and collection elements alone so they
|
|
* are just a small waste of space.
|
|
*/
|
|
|
|
cbReportIDs = this->caps.NumberInputDataIndices +
|
|
this->caps.NumberFeatureDataIndices +
|
|
this->caps.NumberOutputDataIndices +
|
|
this->caps.NumberLinkCollectionNodes;
|
|
|
|
hres = AllocCbPpv( cbReportIDs, &rgbReportIDs );
|
|
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
* Do the input buttons...
|
|
*/
|
|
|
|
hres = CHid_InitButtonClass(this,
|
|
&this->rgcaps[ccaps],
|
|
rgbReportIDs,
|
|
this->caps.NumberInputButtonCaps,
|
|
HidP_Input);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
ccaps += this->caps.NumberInputButtonCaps;
|
|
|
|
/*
|
|
* Do the feature buttons...
|
|
*/
|
|
hres = CHid_InitButtonClass(this,
|
|
&this->rgcaps[ccaps],
|
|
rgbReportIDs,
|
|
this->caps.NumberFeatureButtonCaps,
|
|
HidP_Feature);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
ccaps += this->caps.NumberFeatureButtonCaps;
|
|
|
|
/*
|
|
* Do the output buttons...
|
|
*/
|
|
hres = CHid_InitButtonClass(this,
|
|
&this->rgcaps[ccaps],
|
|
rgbReportIDs,
|
|
this->caps.NumberOutputButtonCaps,
|
|
HidP_Output);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
this->cbButtonData = this->df.dwDataSize - this->ibButtonData;
|
|
|
|
/*
|
|
* If this device only has one report ID, it must be ID zero
|
|
*/
|
|
uMaxReportId = (UINT) max( this->wMaxReportId[HidP_Input],
|
|
max( this->wMaxReportId[HidP_Feature],
|
|
this->wMaxReportId[HidP_Output] ) );
|
|
|
|
/*
|
|
* If there's only one report or there are no buttons there's
|
|
* no need to set up the arrays of data masks for each report.
|
|
*/
|
|
if( uMaxReportId == 0 )
|
|
{
|
|
AssertF( this->rgpbButtonMasks == NULL );
|
|
}
|
|
else if( this->cbButtonData == 0 )
|
|
{
|
|
AssertF( this->rgpbButtonMasks == NULL );
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Allocate enough space for a mask array and a pointer to the array
|
|
* for each report.
|
|
*/
|
|
hres = AllocCbPpv( uMaxReportId * ( this->cbButtonData + cbX( PV ) ),
|
|
&this->rgpbButtonMasks );
|
|
|
|
if( SUCCEEDED( hres ) )
|
|
{
|
|
UINT uReportId;
|
|
UINT uDataIdx;
|
|
UINT uBtnIdx;
|
|
UINT_PTR uCurrentMaskOfs;
|
|
|
|
/*
|
|
* The masks start after the last pointer to masks
|
|
*/
|
|
uCurrentMaskOfs = uMaxReportId * cbX( this->rgpbButtonMasks[0] );
|
|
memset( (PBYTE)this->rgpbButtonMasks + uCurrentMaskOfs , 0xFF, this->cbButtonData * uMaxReportId );
|
|
|
|
|
|
/*
|
|
* Search through our temp buffer once for each report
|
|
*/
|
|
for( uReportId=0; uReportId<uMaxReportId; uReportId++ )
|
|
{
|
|
for( uBtnIdx=uDataIdx=0; uDataIdx<cbReportIDs; uDataIdx++ )
|
|
{
|
|
/*
|
|
* Report IDs are one based but we use a zero based array
|
|
* so adjust when testing for a matching ID
|
|
*/
|
|
if( rgbReportIDs[uDataIdx] == uReportId+1 )
|
|
{
|
|
/*
|
|
* Set the offset for this report to the current
|
|
* mask array. An offset is used so that when the
|
|
* memory is realloc'ed down to the size actually
|
|
* used, it is easier to generate pointers. If a
|
|
* report contains more than one button the same
|
|
* value will be set repeatedly.
|
|
*/
|
|
this->rgpbButtonMasks[uReportId] = (PBYTE)uCurrentMaskOfs;
|
|
|
|
/*
|
|
* The final result is an AND mask so clear all bits
|
|
* so this button will be cleared when this report
|
|
* is being processed
|
|
*/
|
|
((PBYTE)this->rgpbButtonMasks)[uCurrentMaskOfs+uBtnIdx] = 0;
|
|
}
|
|
|
|
/*
|
|
* Just in case there are gaps in the HID report we
|
|
* use our own counter of button index which is only
|
|
* incremented when we find a button to keep in line
|
|
* with the contiguous block of buttons that we use.
|
|
*/
|
|
if( rgbReportIDs[uDataIdx] != 0 )
|
|
{
|
|
uBtnIdx++;
|
|
AssertF( uBtnIdx <= this->cbButtonData );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* There should always be exactly as many buttons in
|
|
* all the reports combined as we found when counting
|
|
* how many buttons there were of each type.
|
|
*/
|
|
AssertF( uBtnIdx == this->cbButtonData );
|
|
|
|
/*
|
|
* If any buttons were found in this report, use next mask
|
|
*/
|
|
if( this->rgpbButtonMasks[uReportId] == (PBYTE)uCurrentMaskOfs )
|
|
{
|
|
uCurrentMaskOfs += this->cbButtonData;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* At least one report had to have a button in it.
|
|
*/
|
|
AssertF( uCurrentMaskOfs != uMaxReportId * cbX( this->rgpbButtonMasks[0] ) );
|
|
|
|
/*
|
|
* Try to reduce the allocation to what we actually used
|
|
* In the worst case we only land up using excess memory
|
|
*/
|
|
ReallocCbPpv( (UINT)uCurrentMaskOfs, &this->rgpbButtonMasks );
|
|
|
|
/*
|
|
* Convert the table of offsets into pointers
|
|
*/
|
|
for( uReportId=0; uReportId<uMaxReportId; uReportId++ )
|
|
{
|
|
if( this->rgpbButtonMasks[uReportId] )
|
|
{
|
|
this->rgpbButtonMasks[uReportId] += (UINT_PTR)this->rgpbButtonMasks;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
done:;
|
|
|
|
FreePpv( &rgbReportIDs );
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method void | CHid | InitCollections |
|
|
*
|
|
* Identify and initialize the HID link collections.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitCollections(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
NTSTATUS stat;
|
|
DWORD icoll, ccoll, ccaps;
|
|
PHIDP_LINK_COLLECTION_NODE rgcoll;
|
|
|
|
ccoll = this->caps.NumberLinkCollectionNodes;
|
|
|
|
/*
|
|
* Annoying quirk:
|
|
*
|
|
* HID doesn't like it when you pass 0 to HidP_GetLinkCollectionNodes,
|
|
* so we need to special-case the "no collections" scenario.
|
|
*/
|
|
if(ccoll == 0)
|
|
{
|
|
hres = S_OK;
|
|
goto done;
|
|
}
|
|
|
|
hres = AllocCbPpv(cbCxX(ccoll, HIDP_LINK_COLLECTION_NODE), &rgcoll);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
* Get the collections...
|
|
*/
|
|
stat = HidP_GetLinkCollectionNodes(rgcoll, &ccoll, this->ppd);
|
|
if(FAILED(stat))
|
|
{
|
|
RPF("HidP_GetLinkCollectionNodes failed - can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
if(ccoll != this->caps.NumberLinkCollectionNodes)
|
|
{
|
|
RPF("HidP_GetLinkCollectionNodes inconsistent with HidP_GetCaps - "
|
|
"can't use device");
|
|
hres = E_FAIL;
|
|
goto freedone;
|
|
}
|
|
|
|
ccaps = this->caps.NumberInputValueCaps +
|
|
this->caps.NumberFeatureValueCaps +
|
|
this->caps.NumberOutputValueCaps +
|
|
this->caps.NumberInputButtonCaps +
|
|
this->caps.NumberFeatureButtonCaps +
|
|
this->caps.NumberOutputButtonCaps;
|
|
|
|
AssertF(ccaps + ccoll == this->ccaps);
|
|
|
|
for(icoll = 0; icoll < ccoll; icoll++)
|
|
{
|
|
PHIDP_LINK_COLLECTION_NODE pcoll = &rgcoll[icoll];
|
|
PHIDGROUPCAPS pcaps = &this->rgcaps[ccaps + icoll];
|
|
UINT uiObj;
|
|
LPDIOBJECTDATAFORMAT podf;
|
|
|
|
pcaps->UsagePage = pcoll->LinkUsagePage;
|
|
pcaps->UsageMin = pcoll->LinkUsage;
|
|
pcaps->cObj = 1;
|
|
pcaps->IsAlias = pcoll->IsAlias;
|
|
|
|
/*
|
|
* Not applicable for collections:
|
|
*
|
|
* StringMin/Max,
|
|
* DesignatorMin/Max,
|
|
* BitSize, LogicalMin/Max, PhysicalMin/Max, Units.
|
|
* IsAbsolute
|
|
*/
|
|
pcaps->LinkCollection = pcoll->Parent;
|
|
|
|
pcaps->type = HidP_Coll;
|
|
|
|
/*
|
|
* We cook up DataIndexMin to correspond to this item.
|
|
*/
|
|
pcaps->DataIndexMin = (USHORT)icoll;
|
|
|
|
uiObj = this->rgdwBase[HidP_Coll] + pcaps->DataIndexMin;
|
|
|
|
/*
|
|
* We generated these indices on our own, so they
|
|
* can't possible be wrong.
|
|
*/
|
|
AssertF(uiObj < this->df.dwNumObjs);
|
|
|
|
this->rghoc[uiObj].pcaps = pcaps;
|
|
podf = &this->df.rgodf[uiObj];
|
|
|
|
/*
|
|
* ISSUE-2001/03/06-MarcAnd collections have GUID_Unknown
|
|
* Collections are more or less hidden and therefore unusable.
|
|
*/
|
|
podf->pguid = &GUID_Unknown;
|
|
|
|
/*
|
|
* Set a default instance. This will be overwritten later
|
|
* if this object is of a type we fully understand.
|
|
*/
|
|
podf->dwType = DIDFT_MAKEINSTANCE(uiObj) | DIDFT_COLLECTION | DIDFT_NODATA;
|
|
|
|
if(pcaps->UsagePage >= HID_USAGE_PAGE_VENDOR )
|
|
{
|
|
podf->dwType |= DIDFT_VENDORDEFINED;
|
|
}
|
|
|
|
podf->dwFlags = 0;
|
|
|
|
/*
|
|
* CHid_ObjFromType relies on dwCollections not being split between
|
|
* aliased and unaliased.
|
|
*/
|
|
this->dwCollections++;
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetLinkCollectionNodes(%d)[%d]: ")
|
|
TEXT("Objs=%2d ")
|
|
TEXT("idx=%2d... ")
|
|
TEXT("coll=%d")
|
|
TEXT("IsAlias=%d"),
|
|
pcaps->type, icoll,
|
|
pcaps->cObj,
|
|
pcaps->DataIndexMin,
|
|
pcaps->LinkCollection,
|
|
pcaps->IsAlias);
|
|
|
|
D(pcaps->dwSignature = HIDGROUPCAPS_SIGNATURE);
|
|
}
|
|
|
|
hres = S_OK;
|
|
|
|
freedone:;
|
|
FreePv(rgcoll);
|
|
|
|
done:;
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | AllocObjectMemory |
|
|
*
|
|
* Allocate all the memory that will be used to store object
|
|
* information.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_AllocObjectMemory(PCHID this)
|
|
{
|
|
DWORD cb;
|
|
DWORD cvcaps, cbcaps, ccoll, cjrc;
|
|
HRESULT hres;
|
|
|
|
/*
|
|
* Some trace squirties because HID is tricky.
|
|
*/
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberInputDataIndices = %d"),
|
|
this->caps.NumberInputDataIndices);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberOutputDataIndices = %d"),
|
|
this->caps.NumberOutputDataIndices);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberFeatureDataIndices = %d"),
|
|
this->caps.NumberFeatureDataIndices);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberLinkCollectionNodes = %d"),
|
|
this->caps.NumberLinkCollectionNodes);
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberInputValueCaps = %d"),
|
|
this->caps.NumberInputValueCaps);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberOutputValueCaps = %d"),
|
|
this->caps.NumberOutputValueCaps);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberFeatureValueCaps = %d"),
|
|
this->caps.NumberFeatureValueCaps);
|
|
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberInputButtonCaps = %d"),
|
|
this->caps.NumberInputButtonCaps);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberOutputButtonCaps = %d"),
|
|
this->caps.NumberOutputButtonCaps);
|
|
SquirtSqflPtszV(sqflVerbose | sqflHidParse,
|
|
TEXT("HidP_GetCaps: NumberFeatureButtonCaps = %d"),
|
|
this->caps.NumberFeatureButtonCaps);
|
|
|
|
/*
|
|
* Allocate the memory into which we place
|
|
* the DIOBJECTDATAFORMATs we build.
|
|
*/
|
|
this->df.dwNumObjs = this->caps.NumberInputDataIndices +
|
|
this->caps.NumberOutputDataIndices +
|
|
this->caps.NumberFeatureDataIndices +
|
|
this->caps.NumberLinkCollectionNodes;
|
|
if(this->df.dwNumObjs >= DIDFT_GETINSTANCE(DIDFT_ANYINSTANCE))
|
|
{
|
|
("Too many objects in HID device (%d) - can't use device",
|
|
this->df.dwNumObjs);
|
|
hres = E_FAIL;
|
|
goto done;
|
|
}
|
|
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_AllocObjectMemory: dwNumObjs = %d"),
|
|
this->df.dwNumObjs);
|
|
|
|
/*
|
|
* ISSUE-2001/10/17-MarcAnd Axes declared in ranges cause AVs
|
|
* We only allocate as many JOYRANGECONVERT elements as there are value
|
|
* caps in HID but multiple axes may be declared in a range which will
|
|
* be reported in a single value caps.
|
|
*/
|
|
cjrc = this->caps.NumberInputValueCaps;
|
|
|
|
cvcaps = this->caps.NumberInputValueCaps +
|
|
this->caps.NumberFeatureValueCaps +
|
|
this->caps.NumberOutputValueCaps;
|
|
|
|
cbcaps = this->caps.NumberInputButtonCaps +
|
|
this->caps.NumberFeatureButtonCaps +
|
|
this->caps.NumberOutputButtonCaps;
|
|
|
|
ccoll = this->caps.NumberLinkCollectionNodes;
|
|
|
|
this->ccaps = cvcaps + cbcaps + ccoll;
|
|
|
|
/*
|
|
* Allocating the memory is done in four phases.
|
|
*
|
|
* 1. Tally up how much memory we need,
|
|
* 2. Allocate that memory,
|
|
* 3. Dole out the memory we allocated,
|
|
* 4. Check that we didn't mess up.
|
|
*
|
|
* Since this is extremely error-prone (I've messed it up at least
|
|
* once), the work is hidden inside macros.
|
|
*
|
|
* The macro THINGS expands to a series of THING()s, each of which
|
|
* specifies a field name and the size it should be. Each time you
|
|
* want to iterate over the fields, use the THINGS macro.
|
|
*/
|
|
|
|
#define THINGS() \
|
|
THING(df.rgodf, cbCxX(this->df.dwNumObjs, DIOBJECTDATAFORMAT)); \
|
|
THING(rghoc, cbCxX(this->df.dwNumObjs, HIDOBJCAPS)); \
|
|
THING(rgcaps, cbCxX(this->ccaps, HIDGROUPCAPS)); \
|
|
THING(pjrcNext, cbCxX(cjrc, JOYRANGECONVERT)); \
|
|
|
|
/*
|
|
* Make a pass through the fields adding up the memory requirements.
|
|
*/
|
|
#define THING(f, cbF) cb += cbF
|
|
cb = 0;
|
|
THINGS();
|
|
#undef THING
|
|
|
|
hres = ReallocCbPpv(cb, &this->df.rgodf);
|
|
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
|
|
PV pv;
|
|
|
|
/*
|
|
* Make a pass through the fields carving up the memory block
|
|
* and handing out pieces of it.
|
|
*/
|
|
#define THING(f, cbF) this->f = pv; pv = pvAddPvCb(pv, cbF)
|
|
pv = this->df.rgodf;
|
|
THINGS();
|
|
#undef THING
|
|
|
|
/*
|
|
* There should be no byte left over.
|
|
*/
|
|
AssertF(pvAddPvCb(this->df.rgodf, cb) == pv);
|
|
|
|
}
|
|
|
|
#undef THINGS
|
|
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_AllocObjectMemory: pv = %08x, cb = 0x%08x"),
|
|
this->df.rgodf, cb);
|
|
|
|
done:;
|
|
return hres;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | EnumKeyboardMunge |
|
|
*
|
|
* Enumerate the objects in the list, indicating whether
|
|
* each object is "keyboardlike" or "otherlike".
|
|
*
|
|
* @parm LPBYTE | pb |
|
|
*
|
|
* Pointer to translation table that converts HID usages
|
|
* into keyboard scan codes.
|
|
*
|
|
* @parm KBDMUNGECALLBACK | Munge |
|
|
*
|
|
* Callback function that handles each object as we find it.
|
|
*
|
|
* @parm PV | pvRef |
|
|
*
|
|
* Reference data for callback.
|
|
*
|
|
* @cb void CALLBACK | KbdMungeCallback |
|
|
*
|
|
* Called once for each object on a keyboard HID device.
|
|
*
|
|
* @parm PCHID | this |
|
|
*
|
|
* The device itself.
|
|
*
|
|
* @parm UINT | uiObj |
|
|
*
|
|
* The object being enumerated.
|
|
*
|
|
* @parm UINT | dik |
|
|
*
|
|
* DirectInput scan code for the object, or a value greater than
|
|
* or equal to <c DIKBD_CKEYS> if it's a fake instance number
|
|
* concocted for a non-AT key.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef void (CALLBACK *KBDMUNGECALLBACK)(PCHID this, UINT uiObj, UINT dik);
|
|
|
|
void INTERNAL
|
|
CHid_EnumKeyboardMunge(PCHID this, LPBYTE pb, KBDMUNGECALLBACK Munge)
|
|
{
|
|
UINT uiObj;
|
|
BYTE rgbSeen[DIKBD_CKEYS];
|
|
UINT uiCollections;
|
|
|
|
/*
|
|
* In principle we could walk the this->rgcaps array, but
|
|
* that would open the risk that the this->rgcaps array
|
|
* and this->df.rgodf array are out of sync for some
|
|
* bizarre reason. Do it the slow way just to be safe.
|
|
*
|
|
* Furthermore, only the first item with a particular
|
|
* keyboard usage gets mapped into the DirectInput table.
|
|
* So if a keyboard has two ESCAPE keys, only the first
|
|
* one shows up in the DirectInput table; the second one
|
|
* shows up as "just another key".
|
|
*/
|
|
|
|
this->uiInstanceMax = DIKBD_CKEYS;
|
|
ZeroX(rgbSeen);
|
|
for(uiCollections = uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
PHIDGROUPCAPS pcaps;
|
|
UINT dik;
|
|
UINT duiObj;
|
|
UINT DataIndex;
|
|
UINT Usage;
|
|
|
|
pcaps = this->rghoc[uiObj].pcaps;
|
|
|
|
if( pcaps->type == HidP_Coll )
|
|
{
|
|
dik = uiCollections++;
|
|
}
|
|
else
|
|
{
|
|
AssertF( HidP_IsValidReportType(pcaps->type) );
|
|
|
|
DataIndex = uiObj - this->rgdwBase[pcaps->type];
|
|
duiObj = DataIndex - pcaps->DataIndexMin;
|
|
|
|
AssertF(duiObj < pcaps->cObj);
|
|
|
|
Usage = pcaps->UsageMin + duiObj;
|
|
|
|
if(pcaps->UsagePage == HID_USAGE_PAGE_KEYBOARD)
|
|
{
|
|
if(Usage < DIKBD_CKEYS && pb[Usage] && !rgbSeen[pb[Usage]])
|
|
{
|
|
rgbSeen[pb[Usage]] = 1;
|
|
dik = pb[Usage];
|
|
} else
|
|
{
|
|
dik = this->uiInstanceMax++;
|
|
}
|
|
|
|
} else
|
|
{
|
|
dik = this->uiInstanceMax++;
|
|
}
|
|
|
|
}
|
|
Munge(this, uiObj, dik);
|
|
}
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method void | CHid | TallyKeyboardObjs |
|
|
*
|
|
* Callback function used during preliminary tallying to
|
|
* tot up how many of the objects can be treated as
|
|
* AT-compatible keyboard gizmos and how many are HID-specific.
|
|
*
|
|
* @parm UINT | uiObj |
|
|
*
|
|
* The object being enumerated.
|
|
*
|
|
* @parm UINT | dik |
|
|
*
|
|
* DirectInput scan code for the object, or a value greater than
|
|
* or equal to <c DIKBD_CKEYS> if it's a fake instance number
|
|
* concocted for a non-AT key.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
CHid_TallyKeyboardObjs(PCHID this, UINT uiObj, UINT dik)
|
|
{
|
|
this;
|
|
uiObj;
|
|
dik;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method void | CHid | ReassignKeyboardObjs |
|
|
*
|
|
* Callback function used to shuffle instance numbers around
|
|
* to make them AT-compatible when possible.
|
|
*
|
|
* @parm UINT | uiObj |
|
|
*
|
|
* The object being enumerated.
|
|
*
|
|
* @parm UINT | dik |
|
|
*
|
|
* DirectInput scan code for the object, or a value greater than
|
|
* or equal to <c DIKBD_CKEYS> if it's a fake instance number
|
|
* concocted for a non-AT key or an index number for a collection.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
CHid_ReassignKeyboardObjs(PCHID this, UINT uiObj, UINT dik)
|
|
{
|
|
if( this->df.rgodf[uiObj].dwType & DIDFT_COLLECTION )
|
|
{
|
|
this->rgicoll[dik] = uiObj;
|
|
}
|
|
else
|
|
{
|
|
this->rgiobj[dik] = uiObj;
|
|
}
|
|
|
|
SquirtSqflPtszV(sqfl | sqflVerbose,
|
|
TEXT("CHid_ReassignKeyboardObjs: ")
|
|
TEXT("uiObj = %03x, dwType = %08x, dik=%04x"),
|
|
uiObj, this->df.rgodf[uiObj].dwType,
|
|
dik);
|
|
|
|
this->df.rgodf[uiObj].dwType =
|
|
(this->df.rgodf[uiObj].dwType & ~DIDFT_INSTANCEMASK) |
|
|
DIDFT_MAKEINSTANCE(dik);
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | MungeKeyboard |
|
|
*
|
|
* We just created a keyboard device.
|
|
*
|
|
* Unfortunately, DirectInput has some annoying requirements
|
|
* for keyboard devices, so here is where we swizzle the instance
|
|
* numbers around to keep DirectInput happy.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_MungeKeyboard(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
LPBYTE pb;
|
|
|
|
AssertF(this->rgiobj == 0);
|
|
|
|
pb = pvFindResource(g_hinst, IDDATA_HIDMAP, RT_RCDATA);
|
|
if(pb)
|
|
{
|
|
/*
|
|
* Count up the number of non-keyboard things on this device.
|
|
* They will get instance numbers starting at DIKBD_CKEYS.
|
|
*/
|
|
|
|
CHid_EnumKeyboardMunge(this, pb, CHid_TallyKeyboardObjs);
|
|
|
|
/*
|
|
* Now that we know how many nonstandard keyboard thingies
|
|
* we have, allocate room for the translation table
|
|
* and work all the instance values around to keep
|
|
* legacy apps happy.
|
|
*/
|
|
|
|
hres = ReallocCbPpv(cbCdw(this->uiInstanceMax + this->dwCollections), &this->rgiobj);
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
memset(this->rgiobj, 0xFF, cbCxX(this->uiInstanceMax + this->dwCollections, INT));
|
|
|
|
/*
|
|
* In case a keyboard comes along with non-button inputs,
|
|
* set up the other types of pointers to the same buffer.
|
|
*/
|
|
this->rgipov = this->rgiaxis = this->rgiobj;
|
|
|
|
/*
|
|
* Put collections at the end, there should be at least one
|
|
*/
|
|
AssertF( this->dwCollections );
|
|
this->rgicoll = &this->rgiobj[this->uiInstanceMax];
|
|
|
|
CHid_EnumKeyboardMunge(this, pb, CHid_ReassignKeyboardObjs);
|
|
|
|
hres = S_OK;
|
|
}
|
|
|
|
/*
|
|
* Prefix warns that the resource is leaked (mb:34650) but there is
|
|
* no API to release a raw resource (FreeResource is a stub) so there
|
|
* is nothing we can do.
|
|
*/
|
|
} else
|
|
{
|
|
hres = E_FAIL;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | MungeNotKeyboard |
|
|
*
|
|
* We just created a device that is not a keyboard.
|
|
*
|
|
* Since we need the instance for each object to be relative only to
|
|
* objects of that type, we need to replace the device relative
|
|
* values generated into type relative ones. In addition, to
|
|
* maintain compatability with pre-HID object instances we need to
|
|
* use axis instance numbers that would be generated for a WinMM
|
|
* mapped axis.
|
|
* Aliased objects must be given the same instance number as the
|
|
* primary alias so that the only difference between them is their
|
|
* usage. This prevents a data format being generated using multiple
|
|
* aliases of the same object.
|
|
*
|
|
* ISSUE-2001/03/13-MarcAnd HID object munging is incomplete
|
|
* 1. Multiple values on a single axis (force and position)
|
|
* 2. Multiple instances of an axis type (two throttles)
|
|
* 3. Does not distinguish output only values (actuators) from axes
|
|
* 4. Keyboards with anything other than buttons should have this
|
|
* done but won't
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Internal function to convert all the attributes of one object to another
|
|
*
|
|
* If an axis needs to be reinterpreted here, both the axis semantic and the
|
|
* object GUID need to be changed so that the axis will be used consistently
|
|
* in both semantic mapper and data format games.
|
|
*
|
|
* Note, multiple instances of an axis type are not handled well.
|
|
*/
|
|
void INTERNAL ReinterpretObject
|
|
(
|
|
PCHID this,
|
|
PDWORD pdwHints,
|
|
int cAxes,
|
|
PDWORD pdwTypeFlags,
|
|
DWORD dwSrcHint,
|
|
DWORD dwDstHint,
|
|
BYTE bSemFlags,
|
|
PCGUID pgNew
|
|
)
|
|
{
|
|
|
|
if( ( *pdwTypeFlags & ( dwSrcHint | dwDstHint ) ) == dwSrcHint )
|
|
{
|
|
int idx;
|
|
|
|
for( idx = 0; idx < cAxes + 6; idx++ )
|
|
{
|
|
if( pdwHints[idx] == dwSrcHint )
|
|
{
|
|
*pdwTypeFlags ^= ( dwSrcHint | dwDstHint );
|
|
pdwHints[idx] = dwDstHint;
|
|
this->rgbaxissemflags[idx] = bSemFlags;
|
|
this->df.rgodf[this->rgiaxis[idx]].pguid = pgNew;
|
|
break;
|
|
}
|
|
}
|
|
AssertF( idx < cAxes + 6 );
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT INTERNAL
|
|
CHid_MungeNotKeyboard(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
|
|
unsigned int uiObj;
|
|
int iButton;
|
|
int iCollection = 0;
|
|
int iPOV = 0;
|
|
int iAxis = 0;
|
|
//to indicate the index of the last "actual" button
|
|
int iLastButtonIndex = 0;
|
|
//to indicate the number of "non-actual" buttons
|
|
int iOtherButton = 0;
|
|
|
|
PINT piRemap = 0;
|
|
|
|
BOOL fCarController = FALSE;
|
|
|
|
DWORD dwTypeFlags = 0;
|
|
int cAxes;
|
|
|
|
D( iButton = 0; )
|
|
AssertF(this->rgiobj == 0);
|
|
|
|
/*
|
|
* First count the distinct types so we know how to segment rgiobj
|
|
*/
|
|
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflVerbose,
|
|
TEXT("CHid_MungeNotKeyboard: uiObj: %d starts as dwType 0x%08x"),
|
|
uiObj, this->df.rgodf[uiObj].dwType );
|
|
|
|
if( !this->rghoc[uiObj].pcaps )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( this->rghoc[uiObj].pcaps->IsAlias )
|
|
{
|
|
/*
|
|
* If there's a steering wheel anywhere, we need to know
|
|
*/
|
|
if( ( DIDFT_AXIS == ( this->df.rgodf[uiObj].dwType & ( DIDFT_AXIS | DIDFT_NODATA ) ) )
|
|
&& ( this->rghoc[uiObj].pcaps->UsagePage == HID_USAGE_PAGE_SIMULATION )
|
|
&& ( HID_USAGE_SIMULATION_STEERING ==
|
|
( this->rghoc[uiObj].pcaps->UsageMin + uiObj
|
|
- this->rgdwBase[this->rghoc[uiObj].pcaps->type]
|
|
- this->rghoc[uiObj].pcaps->DataIndexMin ) ) )
|
|
{
|
|
fCarController = TRUE;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
|
|
/*
|
|
* Don't bother taking pointer to dwType in this simple
|
|
* loop as it should be enregistered anyway.
|
|
*/
|
|
if( this->df.rgodf[uiObj].dwType & DIDFT_COLLECTION )
|
|
{
|
|
iCollection++;
|
|
}
|
|
else if( this->df.rgodf[uiObj].dwType & DIDFT_NODATA )
|
|
{
|
|
/*
|
|
* Don't count objects that report no data
|
|
*/
|
|
continue;
|
|
}
|
|
else if( this->df.rgodf[uiObj].dwType & DIDFT_BUTTON )
|
|
{
|
|
//HID reports everything that has size 1 bit as a button.
|
|
//We need to know the index of the highest "actual" button -- the one that has USAGE_PAGE_BUTTON
|
|
//And then we also need to know how many "non-actual" buttons there are.
|
|
//The total amount of memory we need to allocate for buttons is the sum of those 2.
|
|
if (this->rghoc[uiObj].pcaps->UsagePage == HID_USAGE_PAGE_BUTTON)
|
|
{
|
|
int iUsage = ( this->rghoc[uiObj].pcaps->UsageMin
|
|
+ uiObj
|
|
- this->rgdwBase[this->rghoc[uiObj].pcaps->type]
|
|
- this->rghoc[uiObj].pcaps->DataIndexMin );
|
|
if (iUsage > iLastButtonIndex)
|
|
{
|
|
iLastButtonIndex = iUsage;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iOtherButton++;
|
|
}
|
|
D( iButton++; )
|
|
}
|
|
else if( this->df.rgodf[uiObj].dwType & DIDFT_AXIS )
|
|
{
|
|
iAxis++;
|
|
}
|
|
else if( this->df.rgodf[uiObj].dwType & DIDFT_POV )
|
|
{
|
|
iPOV++;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Assert that we counted everything OK while we have a button count
|
|
*/
|
|
AssertF( (int)this->df.dwNumObjs >= ( iPOV + iButton + iAxis + iCollection ) );
|
|
|
|
/*
|
|
* The total amount of memory we need to allocate for buttons is the sum of
|
|
* the highest "actual" button index and the number of "non-actual" buttons.
|
|
*/
|
|
iButton = iOtherButton + iLastButtonIndex;
|
|
AssertF(iButton >= 0);
|
|
|
|
/*
|
|
* You can go to a whole lot of trouble finding out exactly what gaps
|
|
* are left by the WinMM mapping but in the end, it's only 24 bytes of
|
|
* data and it takes way more to work out how to save them.
|
|
* So just allocate 6 extra in case all the axes are non-WinMM.
|
|
* Note, there is weirdnes involved in WinMM axes as a real WinMM device
|
|
* always have the U (Ry) and V (Rx) axes mapped to S0 and S1 however HID
|
|
* devices have more flexible mappings. Since the main reason to try to
|
|
* keep WinMM and HID axes the same is for FF, only X and Y are critical.
|
|
* Keep the button count in cAxes so we can reference it when we need to
|
|
* without worrying about whether iAxis is the current max or the real
|
|
* max. Should do this for the other counts as well but that can wait
|
|
* until this function gets its long overdue restructuring.
|
|
*/
|
|
cAxes = iAxis;
|
|
this->uiInstanceMax = iCollection + iButton + cAxes + iPOV + 6;
|
|
|
|
/*
|
|
* Note, piRemap received a pointer to a buffer user for workspace.
|
|
* The single allocation is subdivided as follows:
|
|
* a buffer for an array of ints for matched objects,
|
|
* an array of USAGES for axes and
|
|
* and array of DWORDs for hint flags.
|
|
*/
|
|
if( SUCCEEDED( hres = ReallocCbPpv(cbCdw(this->uiInstanceMax), &this->rgiobj) )
|
|
&& SUCCEEDED( hres = AllocCbPpv( ( cbCdw( 2 * (cAxes + 6) ) + cbCxX(this->uiInstanceMax, INT) ), &piRemap ) )
|
|
&& SUCCEEDED( hres = AllocCbPpv( cAxes + 6, &this->rgbaxissemflags ) ) )
|
|
{
|
|
/*
|
|
* NOTE - this is not the order they are stored in the registry - but the macro used for
|
|
* generating them internally has been reversed somewhere along the track.
|
|
*/
|
|
typedef union _USAGES
|
|
{
|
|
struct
|
|
{
|
|
USAGE Usage;
|
|
USAGE UsagePage;
|
|
};
|
|
DWORD dwUsages;
|
|
} USAGES, *PUSAGES;
|
|
|
|
PUSAGES pUsageMatches;
|
|
PDWORD pdwHints;
|
|
int iNops = 0;
|
|
int iUsages = 0;
|
|
int iAxisIdx;
|
|
HKEY hkAxis;
|
|
|
|
DWORD dwTestType = 0;
|
|
int iTypeAxes = 0;
|
|
BOOL bAllMatch=TRUE;
|
|
|
|
ZeroMemory( this->rgbaxissemflags, cAxes + 6 );
|
|
memset(piRemap, 0xFF, cbCxX(this->uiInstanceMax, INT));
|
|
memset(this->rgiobj, 0xFF, cbCxX(this->uiInstanceMax, INT));
|
|
|
|
/*
|
|
* CHid_ObjFromType relies on the order of these for range checking
|
|
*/
|
|
this->rgipov = &this->rgiobj[iButton];
|
|
this->rgiaxis = &this->rgipov[iPOV];
|
|
this->rgicoll = &this->rgipov[cAxes+6];
|
|
|
|
|
|
/*
|
|
* In order to allow IHVs to describe their devices with usages
|
|
* that we don't have in our table but still work for legacy apps, we
|
|
* allow axes to be selected using the DIOBJECTATTRIBUTES in the
|
|
* registry.
|
|
*/
|
|
pUsageMatches = (PUSAGES)&piRemap[this->uiInstanceMax];
|
|
pdwHints = &pUsageMatches[cAxes + 6].dwUsages;
|
|
|
|
/*
|
|
* Assert that we can treat the combined usage page / usage
|
|
* WORDs using a union of a DWORD and two WORDs.
|
|
CAssertF( ( FIELD_OFFSET( DIOBJECTATTRIBUTES, wUsage )
|
|
- FIELD_OFFSET( DIOBJECTATTRIBUTES, wUsagePage ) )
|
|
== ( FIELD_OFFSET( USAGES, Usage )
|
|
- FIELD_OFFSET( USAGES, UsagePage ) ) );
|
|
*/
|
|
|
|
/*
|
|
* Fetch IHV matches for all reasonable axes.
|
|
*/
|
|
for( iAxisIdx = 0; iAxisIdx < cAxes + 5; iAxisIdx++ )
|
|
{
|
|
if( SUCCEEDED( CType_OpenIdSubkey( this->hkType,
|
|
DIDFT_AXIS | DIDFT_MAKEINSTANCE( iAxisIdx ),
|
|
KEY_QUERY_VALUE, &hkAxis ) ) )
|
|
{
|
|
DIOBJECTATTRIBUTES attr;
|
|
|
|
if( ( SUCCEEDED( JoyReg_GetValue( hkAxis, TEXT("Attributes"),
|
|
REG_BINARY, &attr, cbX(attr) ) ) )
|
|
&& ( *(PDWORD)&attr.wUsagePage ) )
|
|
{
|
|
pUsageMatches[iAxisIdx].UsagePage = attr.wUsagePage;
|
|
pUsageMatches[iAxisIdx].Usage = attr.wUsage;
|
|
iUsages++;
|
|
/*
|
|
* Check it really exists on the device
|
|
* New behaviour is to ignore ALL registry mappings
|
|
* and dfault to DX7 implementation if a bogus
|
|
* control is found
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
if( ( this->df.rgodf[uiObj].dwType & DIDFT_AXIS )
|
|
&& ( this->rghoc[uiObj].pcaps )
|
|
&& ( this->rghoc[uiObj].pcaps->type == HidP_Input ) )
|
|
{
|
|
USAGES Usages;
|
|
UINT uidObj;
|
|
|
|
Usages.UsagePage = this->rghoc[uiObj].pcaps->UsagePage;
|
|
uidObj = uiObj - ( this->rgdwBase[HidP_Input] + this->rghoc[uiObj].pcaps->DataIndexMin );
|
|
Usages.Usage = this->rghoc[uiObj].pcaps->UsageMin + uidObj;
|
|
if( Usages.dwUsages == pUsageMatches[iAxisIdx].dwUsages )
|
|
{
|
|
SquirtSqflPtszV(sqfl | sqflVerbose,
|
|
TEXT("CHid_MungeNotKeyboard: Object %d matches 0x%08x"),
|
|
uiObj, pUsageMatches[iAxisIdx].dwUsages );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (uiObj >= this->df.dwNumObjs)
|
|
{
|
|
//Error in registry settings - usage/usagepage pair not present on device
|
|
//reset
|
|
SquirtSqflPtszV(sqfl | sqflVerbose,
|
|
TEXT("CHid_MungeNotKeyboard: No matches for 0x%08x - abandoning IHV map"),
|
|
pUsageMatches[iAxisIdx].dwUsages );
|
|
iUsages=0;
|
|
memset(piRemap, 0xFF, cbCxX(this->uiInstanceMax, INT));
|
|
bAllMatch=FALSE;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iNops++;
|
|
}
|
|
|
|
RegCloseKey( hkAxis );
|
|
|
|
if( iUsages + iNops == cAxes )
|
|
{
|
|
/*
|
|
* We've opened as many keys as we have axes
|
|
* continue the loop in debug as sanity check.
|
|
*/
|
|
#ifdef XDEBUG
|
|
int iDbgIdx;
|
|
for( iDbgIdx = iAxisIdx + 1; iDbgIdx < cAxes + 5; iDbgIdx++ )
|
|
{
|
|
if( SUCCEEDED( CType_OpenIdSubkey( this->hkType,
|
|
DIDFT_AXIS | DIDFT_MAKEINSTANCE( iDbgIdx ),
|
|
KEY_QUERY_VALUE, &hkAxis ) ) )
|
|
{
|
|
RPF( "More axis keys than axes on device %04x:%04x!",
|
|
this->VendorID, this->ProductID );
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go through all input axes, including aliases, trying to find a match
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs && bAllMatch; uiObj++)
|
|
{
|
|
UINT uiObjPrimary;
|
|
int iUsageIdx;
|
|
|
|
if( ( this->df.rgodf[uiObj].dwType & DIDFT_AXIS )
|
|
&& ( this->rghoc[uiObj].pcaps )
|
|
&& ( this->rghoc[uiObj].pcaps->type == HidP_Input ) )
|
|
{
|
|
USAGES Usages;
|
|
UINT uidObj;
|
|
|
|
if( !this->rghoc[uiObj].pcaps->IsAlias )
|
|
{
|
|
uiObjPrimary = uiObj;
|
|
}
|
|
|
|
|
|
Usages.UsagePage = this->rghoc[uiObj].pcaps->UsagePage;
|
|
uidObj = uiObj - ( this->rgdwBase[HidP_Input] + this->rghoc[uiObj].pcaps->DataIndexMin );
|
|
Usages.Usage = this->rghoc[uiObj].pcaps->UsageMin + uidObj;
|
|
|
|
/*
|
|
* Use incremental loop for better JoyHID consistency
|
|
*/
|
|
for( iUsageIdx = 0; iUsageIdx <= iAxisIdx; iUsageIdx++ )
|
|
{
|
|
if( Usages.dwUsages == pUsageMatches[iUsageIdx].dwUsages )
|
|
{
|
|
PHIDUSAGEMAP phum;
|
|
LPDIOBJECTDATAFORMAT podf;
|
|
|
|
/*
|
|
* Remember this one for later and
|
|
* discount it from further matches.
|
|
*/
|
|
piRemap[uiObjPrimary] = iUsageIdx;
|
|
pUsageMatches[iUsageIdx].dwUsages = 0;
|
|
|
|
/*
|
|
* Try to fix up the object GUID
|
|
* Use a usage page usage match if possible
|
|
* otherwise pretend this is a generic axis
|
|
* of the appropriate type or settle for
|
|
* unknown.
|
|
*/
|
|
podf = &this->df.rgodf[uiObj + uidObj];
|
|
if( iUsageIdx < 6 )
|
|
{
|
|
phum = UsageToUsageMap( DIMAKEUSAGEDWORD(
|
|
HID_USAGE_PAGE_GENERIC, HID_USAGE_GENERIC_X + iUsageIdx ) );
|
|
AssertF( phum );
|
|
podf->pguid = phum->pguid;
|
|
this->rgbaxissemflags[iUsageIdx] = phum->bSemFlag;
|
|
pdwHints[iUsageIdx] = phum->dwSemHint;
|
|
dwTypeFlags |= phum->dwSemHint;
|
|
}
|
|
else if (iUsageIdx < 8)
|
|
{
|
|
podf->pguid = &GUID_Slider;
|
|
this->rgbaxissemflags[iUsageIdx] = DISEM_FLAGS_GET( DISEM_FLAGS_S );
|
|
}
|
|
else
|
|
{
|
|
podf->pguid = &GUID_Unknown;
|
|
this->rgbaxissemflags[iUsageIdx] = DISEM_FLAGS_GET( DISEM_FLAGS_S );
|
|
}
|
|
|
|
/*
|
|
* Mark the primary axis associated with
|
|
* the matched axis as already set up.
|
|
*/
|
|
this->rgiaxis[iUsageIdx] = uiObjPrimary;
|
|
this->df.rgodf[uiObjPrimary].dwType &= ~DIDFT_INSTANCEMASK;
|
|
this->df.rgodf[uiObjPrimary].dwType |= DIDFT_MAKEINSTANCE(iUsageIdx);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Not an axis, with caps and input */
|
|
}
|
|
}
|
|
|
|
|
|
iCollection = 0;
|
|
iButton = 0;
|
|
iPOV = 0;
|
|
iAxis = 6;
|
|
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
PHIDUSAGEMAP phum;
|
|
PDWORD pdwType;
|
|
|
|
pdwType = &this->df.rgodf[uiObj].dwType;
|
|
|
|
if( !this->rghoc[uiObj].pcaps || this->rghoc[uiObj].pcaps->IsAlias
|
|
||!( *pdwType & ( DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV | DIDFT_COLLECTION ) ))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( *pdwType & DIDFT_COLLECTION )
|
|
{
|
|
*pdwType = (*pdwType & ~DIDFT_INSTANCEMASK) | DIDFT_MAKEINSTANCE(iCollection);
|
|
this->rgicoll[iCollection++] = uiObj;
|
|
continue;
|
|
}
|
|
else if( *pdwType & DIDFT_NODATA )
|
|
{
|
|
/*
|
|
* Leave other no data objects alone
|
|
*/
|
|
continue;
|
|
}
|
|
|
|
if( *pdwType & DIDFT_BUTTON )
|
|
{
|
|
*pdwType &= ~DIDFT_INSTANCEMASK;
|
|
//The buttons need to be sorted (manbug 30320) --
|
|
//the ones that have USAGE_PAGE_BUTTON come first, sorted by button number,
|
|
//w/ gaps for missing numbers if necessary;
|
|
//then add on those that do not have USAGE_PAGE_BUTTON
|
|
//(since HID reports anything w/ size 1 bit is a button), unsorted.
|
|
|
|
if (this->rghoc[uiObj].pcaps->UsagePage == HID_USAGE_PAGE_BUTTON)
|
|
{
|
|
//put in the correct position, leaving gaps if needed.
|
|
//Usage - 1 will give us the position, since HID usages are 1-based,
|
|
//but DInput button indeces are 0-based.
|
|
int iPosition = ( this->rghoc[uiObj].pcaps->UsageMin
|
|
+ uiObj
|
|
- this->rgdwBase[this->rghoc[uiObj].pcaps->type]
|
|
- this->rghoc[uiObj].pcaps->DataIndexMin ) - 1;
|
|
AssertF(iPosition >= 0);
|
|
*pdwType |= DIDFT_MAKEINSTANCE(iPosition);
|
|
this->rgiobj[iPosition] = uiObj;
|
|
}
|
|
else
|
|
{
|
|
//iLastIndex indicates where to put the non-USAGE_PAGE_BUTTON things
|
|
//in the order that they come in the report
|
|
*pdwType |= DIDFT_MAKEINSTANCE(iLastButtonIndex);
|
|
this->rgiobj[iLastButtonIndex++] = uiObj;
|
|
}
|
|
|
|
//increment the count of how many real things (excluing gaps) we've got
|
|
iButton++;
|
|
}
|
|
else if( *pdwType & DIDFT_AXIS )
|
|
{
|
|
if( piRemap[uiObj] == -1 )
|
|
{
|
|
|
|
WORD wUsage;
|
|
UINT uiObjPrimary = uiObj;
|
|
|
|
*pdwType &= ~DIDFT_INSTANCEMASK;
|
|
/*
|
|
* Check this axis and it's aliases for a match
|
|
*/
|
|
while( TRUE )
|
|
{
|
|
wUsage = (WORD) ( this->rghoc[uiObj].pcaps->UsageMin
|
|
+ uiObj
|
|
- this->rgdwBase[this->rghoc[uiObj].pcaps->type]
|
|
- this->rghoc[uiObj].pcaps->DataIndexMin );
|
|
|
|
phum = UsageToUsageMap( DIMAKEUSAGEDWORD(
|
|
this->rghoc[uiObj].pcaps->UsagePage, wUsage ) );
|
|
/*
|
|
* Slightly odd loop structure to avoid incrementing
|
|
* uiObj on the last iteration. This makes sure we
|
|
* don't miss anything in the outer loop and that
|
|
* uiObj relates to the alias we matched when testing
|
|
* for default semantic mappings.
|
|
*/
|
|
if( phum || (uiObj+1 == this->df.dwNumObjs)
|
|
|| !this->rghoc[uiObj+1].pcaps->IsAlias )
|
|
{
|
|
break;
|
|
}
|
|
uiObj++;
|
|
}
|
|
if( phum )
|
|
{
|
|
/*
|
|
* Since the axis is recognixed up the count
|
|
*/
|
|
iTypeAxes++;
|
|
|
|
/*
|
|
* Find it's position keeping WinMM in mind.
|
|
*/
|
|
if( ( phum->bPosAxis < 6 )
|
|
&&( this->rgiaxis[phum->bPosAxis] == -1 ) )
|
|
{
|
|
this->rgiaxis[phum->bPosAxis] = uiObjPrimary ;
|
|
*pdwType |= DIDFT_MAKEINSTANCE(phum->bPosAxis);
|
|
}
|
|
else if( ( phum->bPosAxis == 6 )
|
|
&&( this->rgiaxis[2] == -1 ) )
|
|
{
|
|
this->rgiaxis[2] = uiObjPrimary;
|
|
*pdwType |= DIDFT_MAKEINSTANCE(2);
|
|
}
|
|
else
|
|
{
|
|
*pdwType |= DIDFT_MAKEINSTANCE(iAxis);
|
|
this->rgiaxis[iAxis++] = uiObjPrimary ;
|
|
}
|
|
|
|
/*
|
|
* While we know which usage is most recognizable, add in
|
|
* flags to help us refine the device type and save off
|
|
* flags for default semantic mapping of this axis.
|
|
*/
|
|
this->rgbaxissemflags[DIDFT_GETINSTANCE(*pdwType)] = phum->bSemFlag;
|
|
pdwHints[DIDFT_GETINSTANCE(*pdwType)] = phum->dwSemHint;
|
|
dwTypeFlags |= phum->dwSemHint;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Unfortunately, the current HID parser does not
|
|
* implement more unusual HID caps like "preferred
|
|
* state" so just assume any other axes are sliders.
|
|
*/
|
|
if( this->rghoc[uiObj].pcaps->UsagePage == HID_USAGE_PAGE_SIMULATION )
|
|
{
|
|
if( wUsage == HID_USAGE_SIMULATION_CLUTCH )
|
|
{
|
|
dwTypeFlags |= DISEM_HINT_CLUTCH;
|
|
pdwHints[iAxis] = DISEM_HINT_CLUTCH;
|
|
this->rgbaxissemflags[iAxis] = DISEM_FLAGS_GET( DISEM_FLAGS_C );
|
|
iTypeAxes++;
|
|
}
|
|
else
|
|
{
|
|
if( wUsage == HID_USAGE_SIMULATION_SHIFTER )
|
|
{
|
|
dwTypeFlags |= DISEM_HINT_SHIFTER;
|
|
pdwHints[iAxis] = DISEM_HINT_CLUTCH;
|
|
iTypeAxes++;
|
|
}
|
|
else
|
|
{
|
|
pdwHints[iAxis] = DISEM_HINT_SLIDER;
|
|
}
|
|
this->rgbaxissemflags[iAxis] = DISEM_FLAGS_GET( DISEM_FLAGS_S );
|
|
}
|
|
}
|
|
*pdwType |= DIDFT_MAKEINSTANCE(iAxis);
|
|
this->rgiaxis[iAxis++] = uiObjPrimary ;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* We already checked that it's one of the above or a POV
|
|
* so it must be a POV.
|
|
*/
|
|
AssertF( *pdwType & DIDFT_POV );
|
|
*pdwType &= ~DIDFT_INSTANCEMASK;
|
|
*pdwType |= DIDFT_MAKEINSTANCE(iPOV);
|
|
this->rgipov[iPOV++] = uiObj;
|
|
dwTypeFlags |= DISEM_HINT_POV;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now that we know about all the controls we base our type
|
|
* decisions on, setup/validate the type and subtype.
|
|
*/
|
|
|
|
AssertF( GET_DIDEVICE_TYPE( this->dwDevType ) != DI8DEVTYPE_KEYBOARD );
|
|
|
|
if( GET_DIDEVICE_TYPE( this->dwDevType ) == DI8DEVTYPE_MOUSE )
|
|
{
|
|
if( dwTypeFlags & DISEM_HINT_ABSOLUTE )
|
|
{
|
|
this->dwDevType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_MOUSE,
|
|
DI8DEVTYPEMOUSE_ABSOLUTE)
|
|
| DIDEVTYPE_HID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DWORD dwFlags2;
|
|
JOYREGHWSETTINGS hws;
|
|
|
|
/*
|
|
* Get the old registry flags for initial hints in case this
|
|
* device has more generic usages than it needed to have and
|
|
* these have registry overrides.
|
|
* Only look for flags that are less generic to avoid a case
|
|
* where an older DInput (or JoyHID) labelled this device
|
|
* inadequately.
|
|
* If the call fails the buffer is zeroed
|
|
*/
|
|
|
|
JoyReg_GetValue(this->hkType, REGSTR_VAL_JOYOEMDATA,
|
|
REG_BINARY, &hws, cbX(hws));
|
|
|
|
if( this->hkProp )
|
|
{
|
|
JoyReg_GetValue( this->hkProp, REGSTR_VAL_FLAGS2, REG_BINARY,
|
|
&dwFlags2, cbX(dwFlags2) );
|
|
}
|
|
|
|
CAssertF( ( DISEM_HINT_THROTTLE >> 6 ) == JOY_HWS_HASZ );
|
|
CAssertF( ( DISEM_HINT_POV >> 6 ) == JOY_HWS_HASPOV );
|
|
|
|
dwTestType = GetValidDI8DevType( dwFlags2, iButton, dwTypeFlags >> 14 );
|
|
|
|
if( dwTestType )
|
|
{
|
|
/*
|
|
* If a valid override exists just use it
|
|
*/
|
|
this->dwDevType = dwTestType | DIDEVTYPE_HID;
|
|
}
|
|
else
|
|
{
|
|
|
|
#ifdef XDEBUG
|
|
/*
|
|
* Fetch the value again in debug so we can report failures.
|
|
*/
|
|
if( this->hkProp )
|
|
{
|
|
DWORD dwDbgFlags2;
|
|
JoyReg_GetValue( this->hkProp, REGSTR_VAL_FLAGS2, REG_BINARY,
|
|
&dwDbgFlags2, cbX(dwDbgFlags2) );
|
|
|
|
if( GET_DIDEVICE_TYPEANDSUBTYPE( dwDbgFlags2 ) )
|
|
{
|
|
RPF( "Ignoring invalid type/subtype Flags2 value 0x%08x for HID", dwDbgFlags2 );
|
|
}
|
|
}
|
|
#endif
|
|
/*
|
|
* This one is straight forward
|
|
*/
|
|
if( hws.dwFlags & JOY_HWS_ISHEADTRACKER )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_HEADTRACKER );
|
|
goto MNK_CheckType;
|
|
}
|
|
|
|
if( hws.dwFlags & JOY_HWS_ISYOKE )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_FLIGHT,
|
|
DI8DEVTYPEFLIGHT_YOKE);
|
|
goto MNK_CheckType;
|
|
}
|
|
|
|
/*
|
|
* Other registry flags only relate to the type so the
|
|
* subtype will still need to be found.
|
|
*/
|
|
if( hws.dwFlags & JOY_HWS_ISGAMEPAD )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_GAMEPAD, DI8DEVTYPEGAMEPAD_STANDARD);
|
|
goto MNK_AdjustType;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* If we have somehow recognized this as a car controller, do any
|
|
* processing necessary to munge the axes.
|
|
* Note we have to go through this path, even if the device has a
|
|
* registry override type and subtype so that the right axes get
|
|
* used for a device which has been changed into a car controller
|
|
*/
|
|
if( ( hws.dwFlags & JOY_HWS_ISCARCTRL )
|
|
|| fCarController
|
|
|| ( GET_DIDEVICE_TYPE( this->dwDevType ) == DI8DEVTYPE_DRIVING ) )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_DRIVING, 0);
|
|
|
|
if( DISEM_HINT_X == ( dwTypeFlags & ( DISEM_HINT_X | DISEM_HINT_STEERING ) ) )
|
|
{
|
|
/*
|
|
* If the device has no wheel but has an X axis
|
|
* use that instead. The semantic flags are the
|
|
* same so just switch the hints.
|
|
*/
|
|
dwTypeFlags ^= ( DISEM_HINT_X | DISEM_HINT_STEERING );
|
|
}
|
|
|
|
if( ( dwTypeFlags & DISEM_HINT_STEERING ) == 0 )
|
|
{
|
|
/*
|
|
* If there's still no steering wheel, make the type
|
|
* device so it can be processed into a supplemental
|
|
*/
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_DEVICE, 0 );
|
|
}
|
|
|
|
/*
|
|
* In terms of HID usages, the common forms of pedals are:
|
|
*
|
|
* 1) Accellerator and Brake
|
|
* 2) Split Y axis, below center accel, above brake
|
|
* 3) Z accel, Y brake
|
|
* 4) Y accel, Rz brake
|
|
* 5) Z accel, Rz brake
|
|
*
|
|
* The first form is ideal so all that is needed is to
|
|
* make sure that any further processing does not disturb
|
|
* those axes whilst allowing for only one being exact.
|
|
* The second form is assumed for a car controller with
|
|
* only a Y (in addition to a possible X).
|
|
* The other two forms are distinguished either by an
|
|
* explicite registry flag or by the exact match of Y and
|
|
* Rz with none of Z, accel or brake for the latter form.
|
|
* Since a real Z axis would be an oddity on a steering
|
|
* wheel, assume that the IHVs who have taken the Y, Rz
|
|
* path are not going to add a Z.
|
|
*/
|
|
|
|
|
|
/*
|
|
* If there is an override to Y split pedals and a Y is
|
|
* present then set type and subtype and bypass the rest.
|
|
*/
|
|
|
|
switch( dwFlags2 & JOYTYPE_INFOMASK )
|
|
{
|
|
case JOYTYPE_INFODEFAULT:
|
|
break;
|
|
case JOYTYPE_INFOYYPEDALS:
|
|
if( dwTypeFlags & DISEM_HINT_Y )
|
|
{
|
|
if( dwTypeFlags & DISEM_HINT_STEERING )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_DRIVING, DI8DEVTYPEDRIVING_COMBINEDPEDALS );
|
|
}
|
|
else
|
|
{
|
|
AssertF( GET_DIDEVICE_TYPEANDSUBTYPE( dwTestType ) == MAKE_DIDEVICE_TYPE( DI8DEVTYPE_DEVICE, 0 ) );
|
|
}
|
|
goto MNK_CheckType;
|
|
}
|
|
RPF( "JOYTYPE_INFOYYPEDALS set but device has no Y" );
|
|
break;
|
|
|
|
case JOYTYPE_INFOZYPEDALS:
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Y, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Z, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_THROTTLE, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
break;
|
|
|
|
case JOYTYPE_INFOYRPEDALS:
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_RZ, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Y, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
break;
|
|
|
|
case JOYTYPE_INFOZRPEDALS:
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_RZ, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Z, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_THROTTLE, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
break;
|
|
|
|
default:
|
|
RPF( "Ignoring invalid JOYTYPE_INFO* Flags in 0x%08x", dwFlags2 & JOYTYPE_INFOMASK );
|
|
}
|
|
|
|
/*
|
|
* In the absence of an override, first see if there's
|
|
* anything worth reinterpreting.
|
|
*/
|
|
if( 0 == ( dwTypeFlags &
|
|
( DISEM_HINT_Z | DISEM_HINT_ACCELERATOR | DISEM_HINT_THROTTLE
|
|
| DISEM_HINT_RZ | DISEM_HINT_BRAKE | DISEM_HINT_ACCELERATOR ) ) )
|
|
{
|
|
if( ( dwTypeFlags & ( DISEM_HINT_STEERING | DISEM_HINT_Y ) )
|
|
== ( DISEM_HINT_STEERING | DISEM_HINT_Y ) )
|
|
{
|
|
/*
|
|
* Combined pedal device
|
|
*/
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_DRIVING, DI8DEVTYPEDRIVING_COMBINEDPEDALS );
|
|
}
|
|
else
|
|
{
|
|
AssertF( GET_DIDEVICE_TYPEANDSUBTYPE( dwTestType ) == MAKE_DIDEVICE_TYPE( DI8DEVTYPE_DEVICE, 0 ) );
|
|
}
|
|
goto MNK_CheckType;
|
|
}
|
|
else if( ( DISEM_HINT_Y | DISEM_HINT_RZ ) ==
|
|
( dwTypeFlags
|
|
& ( DISEM_HINT_Y | DISEM_HINT_Z | DISEM_HINT_RZ | DISEM_HINT_BRAKE | DISEM_HINT_ACCELERATOR ) ) )
|
|
{
|
|
/*
|
|
* Although the axis GUIDs accel == Y and brake == RZ are
|
|
* already correct, use the common function to change the
|
|
* semantic flags or I'll forget to change the axis flags.
|
|
*/
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Y, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_RZ, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Both of the other split pedal types have a Z-like accelerator
|
|
*/
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Z, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_THROTTLE, DISEM_HINT_ACCELERATOR,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_A_1), &GUID_YAxis );
|
|
|
|
|
|
/*
|
|
* Look for a brake on RZ before Y as a device with RZ
|
|
* is very likely to report a Y as well.
|
|
*/
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_RZ, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Y, DISEM_HINT_BRAKE,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_B_1), &GUID_RzAxis );
|
|
|
|
}
|
|
|
|
/*
|
|
* If somehow we have found an accellerator, make sure we
|
|
* don't expose any Y axes as well or the accellerator
|
|
* may get bumped from the default Y position.
|
|
*/
|
|
if( dwTypeFlags & DISEM_HINT_ACCELERATOR )
|
|
{
|
|
int idx;
|
|
|
|
dwTypeFlags &= ~DISEM_HINT_Y;
|
|
for( idx = 0; idx < cAxes + 6; idx++ )
|
|
{
|
|
if( pdwHints[idx] == DISEM_HINT_Y )
|
|
{
|
|
pdwHints[idx] = DISEM_HINT_SLIDER;
|
|
dwTypeFlags |= DISEM_HINT_SLIDER;
|
|
this->rgbaxissemflags[idx] = DISEM_FLAGS_GET(DIAXIS_ANY_S_1);
|
|
this->df.rgodf[this->rgiaxis[idx]].pguid = &GUID_Slider;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Just take the default calculated from the HID caps (or the override)
|
|
*/
|
|
dwTestType = this->dwDevType;
|
|
#ifdef XDEBUG
|
|
if( GET_DIDEVICE_TYPEANDSUBTYPE( dwTestType ) != GET_DIDEVICE_TYPEANDSUBTYPE( dwFlags2 ) )
|
|
{
|
|
switch( GET_DIDEVICE_TYPE( dwTestType ) )
|
|
{
|
|
case DI8DEVTYPE_DEVICE:
|
|
AssertF( GET_DIDEVICE_SUBTYPE( dwTestType ) == 0 );
|
|
break;
|
|
case DI8DEVTYPE_JOYSTICK:
|
|
AssertF( GET_DIDEVICE_SUBTYPE( dwTestType ) == DI8DEVTYPEJOYSTICK_STANDARD );
|
|
break;
|
|
case DI8DEVTYPE_GAMEPAD:
|
|
AssertF( GET_DIDEVICE_SUBTYPE( dwTestType ) == DI8DEVTYPEGAMEPAD_STANDARD );
|
|
break;
|
|
default:
|
|
RPF( "Invalid type %02x", GET_DIDEVICE_TYPE( dwTestType ) );
|
|
AssertF( !"Invalid type!" );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Check for Z axis behavior overrides
|
|
* Since the default behavior is to always use a Z as a Z,
|
|
* only the override to slider is needed here.
|
|
*/
|
|
if( dwFlags2 & JOYTYPE_INFOZISSLIDER )
|
|
{
|
|
if( dwTypeFlags & DISEM_HINT_Z )
|
|
{
|
|
/*
|
|
* Reset the slider flag as ReinterpretObject does
|
|
* not change axes if the target this axis
|
|
*/
|
|
dwTypeFlags &= ~DISEM_HINT_SLIDER;
|
|
ReinterpretObject( this, pdwHints, cAxes, &dwTypeFlags,
|
|
DISEM_HINT_Z, DISEM_HINT_SLIDER,
|
|
DISEM_FLAGS_GET(DIAXIS_ANY_S_1), &GUID_Slider );
|
|
}
|
|
else
|
|
{
|
|
RPF( "JOYTYPE_INFOZISSLIDER set but device has no Z" );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the dwFlags2 and dwTestType are the same, we are using a
|
|
* registry override so don't try to refine it.
|
|
*/
|
|
if( GET_DIDEVICE_TYPEANDSUBTYPE( dwTestType ) != GET_DIDEVICE_TYPEANDSUBTYPE( dwFlags2 ) )
|
|
{
|
|
if( dwTypeFlags & DISEM_HINT_STEERING )
|
|
{
|
|
/*
|
|
* If it has a steering wheel, it's a driving device
|
|
*/
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_DRIVING, 0 );
|
|
}
|
|
else if( ( dwTypeFlags & DISEM_HINT_SIXDOF ) == DISEM_HINT_SIXDOF )
|
|
{
|
|
/*
|
|
* Special case six degree of freedom devices
|
|
*/
|
|
dwTestType = MAKE_DIDEVICE_TYPE(DI8DEVTYPE_1STPERSON,
|
|
DI8DEVTYPE1STPERSON_SIXDOF );
|
|
goto MNK_CheckType;
|
|
}
|
|
|
|
MNK_AdjustType:;
|
|
/*
|
|
* We should be left with only the following device types:
|
|
* joystick, gamepad, driving and device
|
|
* For the first three only subtypes need to be found.
|
|
* For DI8DEVTYPE_DEVICE some may be changed to
|
|
* DI8DEVTYPE_SUPPLEMENTAL if an appropriate subtype can be
|
|
* found.
|
|
*/
|
|
switch( GET_DIDEVICE_TYPE( dwTestType ) )
|
|
{
|
|
case DI8DEVTYPE_DEVICE:
|
|
/*
|
|
* Since this is not a joystick or gamepad, only use it
|
|
* if it has the vehicle simulation controls we support.
|
|
*/
|
|
if( ( dwTypeFlags & ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE | DISEM_HINT_CLUTCH ) )
|
|
== ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE | DISEM_HINT_CLUTCH ) )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_THREEPEDALS );
|
|
}
|
|
else if( ( dwTypeFlags & ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE ) )
|
|
== ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE ) )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_DUALPEDALS );
|
|
}
|
|
else if( dwTypeFlags & DISEM_HINT_THROTTLE )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_THROTTLE );
|
|
}
|
|
else if( dwTypeFlags & DISEM_HINT_SHIFTER )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_SHIFTER );
|
|
}
|
|
else if( dwTypeFlags & DISEM_HINT_RUDDER )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_RUDDERPEDALS );
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* Totally unknown so leave it as device
|
|
* Allowing other devices to be treated as game
|
|
* controllers can cause HID controls on devices
|
|
* such as speakers to be included.
|
|
*/
|
|
}
|
|
break;
|
|
case DI8DEVTYPE_JOYSTICK:
|
|
case DI8DEVTYPE_GAMEPAD:
|
|
if( ( dwTypeFlags & ( DISEM_HINT_X | DISEM_HINT_Y ) ) != ( DISEM_HINT_X | DISEM_HINT_Y ) )
|
|
{
|
|
dwTestType = MAKE_DIDEVICE_TYPE( DI8DEVTYPE_SUPPLEMENTAL,
|
|
DI8DEVTYPESUPPLEMENTAL_UNKNOWN );
|
|
}
|
|
break;
|
|
|
|
case DI8DEVTYPE_DRIVING:
|
|
if( ( dwTypeFlags & ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE | DISEM_HINT_CLUTCH ) )
|
|
== ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE | DISEM_HINT_CLUTCH ) )
|
|
{
|
|
dwTestType |= MAKE_DIDEVICE_TYPE( 0, DI8DEVTYPEDRIVING_THREEPEDALS );
|
|
}
|
|
else if( ( dwTypeFlags & ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE ) )
|
|
== ( DISEM_HINT_ACCELERATOR | DISEM_HINT_BRAKE ) )
|
|
{
|
|
dwTestType |= MAKE_DIDEVICE_TYPE( 0, DI8DEVTYPEDRIVING_DUALPEDALS );
|
|
}
|
|
else if( dwTypeFlags & DISEM_HINT_Y )
|
|
{
|
|
dwTestType |= MAKE_DIDEVICE_TYPE( 0, DI8DEVTYPEDRIVING_COMBINEDPEDALS );
|
|
}
|
|
else
|
|
{
|
|
dwTestType |= MAKE_DIDEVICE_TYPE( 0, DI8DEVTYPEDRIVING_LIMITED );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
AssertF( !"Unexpected device type" );
|
|
}
|
|
|
|
|
|
/*
|
|
* Use the common function to make this a limited type if the
|
|
* number of buttons or flags dictate it.
|
|
* Since the type and subtype are known to be valid, the return
|
|
* value should never be a failure (zero).
|
|
*/
|
|
MNK_CheckType:;
|
|
this->dwDevType = DIDEVTYPE_HID
|
|
| GetValidDI8DevType( dwTestType, iButton, hws.dwFlags );
|
|
AssertF( this->dwDevType & ~DIDEVTYPE_HID );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Finally, mark all secondary aliases with the primary alias
|
|
* instance and sqfl all the translations.
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
int iPrimary;
|
|
D( iPrimary = -1; )
|
|
|
|
if( this->rghoc[uiObj].pcaps )
|
|
{
|
|
if( !this->rghoc[uiObj].pcaps->IsAlias )
|
|
{
|
|
iPrimary = this->df.rgodf[uiObj].dwType;
|
|
}
|
|
else
|
|
{
|
|
D( AssertF( iPrimary != -1 ) );
|
|
/*
|
|
* Prefix notices that iPrimary would be uninitialized if
|
|
* we find the alias before the primary but that should
|
|
* never happen as the object are sorted by definition.
|
|
*/
|
|
if( DIDFT_GETTYPE(iPrimary) != DIDFT_GETTYPE(this->df.rgodf[uiObj].dwType) )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("CHid_MungeNotKeyboard: uiObj: %d dwType 0x%08x ")
|
|
TEXT("does not match primary 0x%08x"),
|
|
uiObj, this->df.rgodf[uiObj].dwType, iPrimary );
|
|
}
|
|
/*
|
|
* There are very few attributes of an alias that are not
|
|
* overridden by the primary.
|
|
*/
|
|
this->df.rgodf[uiObj].dwType = ( iPrimary & ~DIDFT_ALIASATTRMASK )
|
|
| ( this->df.rgodf[uiObj].dwType & DIDFT_ALIASATTRMASK );
|
|
}
|
|
SquirtSqflPtszV(sqflHidParse | sqflVerbose,
|
|
TEXT("CHid_MungeNotKeyboard: uiObj: %d set to dwType 0x%08x"),
|
|
uiObj, this->df.rgodf[uiObj].dwType );
|
|
}
|
|
else
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflVerbose,
|
|
TEXT("CHid_MungeNotKeyboard: uiObj: %d has pcaps == NULL"),
|
|
uiObj );
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
FreePpv( &this->rgbaxissemflags );
|
|
}
|
|
FreePpv( &piRemap );
|
|
|
|
return hres;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitObjects |
|
|
*
|
|
* Identify and initialize the objects supported by the device.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitObjects(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
UINT uiObj;
|
|
UINT iType;
|
|
/*
|
|
* Build the base array table to convert HID item indexes
|
|
* into DirectInput ID instance numbers.
|
|
*/
|
|
AssertF(this->rgdwBase[HidP_Input] == 0);
|
|
this->rgdwBase[HidP_Feature] = this->caps.NumberInputDataIndices;
|
|
this->rgdwBase[HidP_Output ] = this->rgdwBase[HidP_Feature] +
|
|
this->caps.NumberFeatureDataIndices;
|
|
this->rgdwBase[HidP_Coll ] = this->rgdwBase[HidP_Output ] +
|
|
this->caps.NumberOutputDataIndices;
|
|
|
|
|
|
/*
|
|
* Determine if this device supports PID
|
|
*/
|
|
this->fPIDdevice = FALSE;
|
|
if( this->caps.NumberOutputValueCaps != 0x0
|
|
&& this->caps.NumberOutputButtonCaps != 0x0 )
|
|
{
|
|
NTSTATUS ntStat;
|
|
USHORT cAButton=0x0;
|
|
|
|
ntStat = HidP_GetSpecificButtonCaps
|
|
(
|
|
HidP_Output, // ReportType
|
|
HID_USAGE_PAGE_PID, // UsagePage
|
|
0x0, // Link Collection
|
|
0x0, // Usage
|
|
NULL, // ValueCaps
|
|
&cAButton, // ValueCapsLength
|
|
this->ppd // PreparsedData
|
|
);
|
|
|
|
|
|
if( ntStat == HIDP_STATUS_BUFFER_TOO_SMALL
|
|
&& cAButton > 0x2 // Is this enough for PID device ??
|
|
)
|
|
{
|
|
this->fPIDdevice = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Note that we must do axes first because that keeps
|
|
* everything aligned.
|
|
*
|
|
* Warning, diem.c assumes axes come first.
|
|
*/
|
|
hres = CHid_InitAxes(this);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
hres = CHid_InitButtons(this);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
hres = CHid_InitCollections(this);
|
|
if(FAILED(hres))
|
|
{
|
|
goto done;
|
|
}
|
|
|
|
/*
|
|
* Round the data size up to the nearest DWORD.
|
|
*/
|
|
this->df.dwDataSize = (this->df.dwDataSize + 3) & ~3;
|
|
|
|
/*
|
|
* Allocate memory for report ID enable flags
|
|
*
|
|
* ISSUE-2001/05/12-MarcAnd Memory allocations should be merged
|
|
* These memory blocks could be merged. For most devices the total memory
|
|
* needed is only one or two bytes so there may be better ways.
|
|
*/
|
|
for( iType = HidP_Input; iType < HidP_Max; iType++ )
|
|
{
|
|
this->wMaxReportId[iType] += 1;
|
|
hres = AllocCbPpv(this->wMaxReportId[iType], &this->pEnableReportId[iType]);
|
|
if( FAILED(hres) )
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
AssertF(this->rgiobj == 0);
|
|
|
|
/*
|
|
* Munge the data before trying to look up supplemental
|
|
* information in the registry.
|
|
*/
|
|
if(GET_DIDEVICE_TYPE(this->dwDevType) == DI8DEVTYPE_KEYBOARD)
|
|
{
|
|
CHid_MungeKeyboard(this);
|
|
}
|
|
else
|
|
{
|
|
CHid_MungeNotKeyboard(this);
|
|
}
|
|
|
|
/*
|
|
* Collect attributes for each object and add them to the
|
|
* device type code. This allows the registry to enable
|
|
* things like force feedback.
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
CType_RegGetTypeInfo(this->hkType, &this->df.rgodf[uiObj], this->fPIDdevice);
|
|
if( ( GET_DIDEVICE_TYPE(this->dwDevType) == DI8DEVTYPE_DRIVING )
|
|
&& ( this->df.rgodf[uiObj].dwFlags & DIDOI_FFACTUATOR )
|
|
&& ( this->df.rgodf[uiObj].pguid != &GUID_XAxis ) )
|
|
{
|
|
/*
|
|
* IHVs set FF attributes on non-FF axes for wheels because
|
|
* first generation FF apps were only written to support joysticks.
|
|
* Since we now munge the various configurations of pedal axes to
|
|
* report all split pedals in the same way, the fake Y axis can
|
|
* land up on different axes, usually Slider0. Rather than have
|
|
* people code to these different fake axes, strip out actuator
|
|
* status from any driving axis except the wheel.
|
|
*/
|
|
this->df.rgodf[uiObj].dwFlags &= ~DIDOI_FFACTUATOR;
|
|
this->df.rgodf[uiObj].dwType &= ~DIDFT_FFACTUATOR;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
PHIDGROUPCAPS pcaps;
|
|
UINT uiObjReal =
|
|
CHid_ObjFromType(this, this->df.rgodf[uiObj].dwType);
|
|
pcaps = this->rghoc[uiObjReal].pcaps;
|
|
if(pcaps)
|
|
{
|
|
AssertF(pcaps->dwSignature == HIDGROUPCAPS_SIGNATURE);
|
|
}
|
|
|
|
if( uiObjReal != uiObj )
|
|
{
|
|
RPF( "uiObj = 0x%08x, type = 0x%08x, exposed Obj = 0x%08x",
|
|
uiObj, this->df.rgodf[uiObj].dwType, uiObjReal );
|
|
}
|
|
AssertF(CHid_ObjFromType(this, this->df.rgodf[uiObj].dwType)
|
|
== uiObj);
|
|
|
|
/*
|
|
* Anything that is DIDFT_AXIS must be a HID axis. However,
|
|
* the converse is not true for the case of analog buttons.
|
|
*/
|
|
AssertF(fLimpFF(this->df.rgodf[uiObj].dwType & DIDFT_AXIS,
|
|
pcaps->IsValue));
|
|
|
|
SquirtSqflPtszV(sqfl | sqflVerbose,
|
|
TEXT("CHid_InitObj: uiObj = %02x, dwType = %08x"),
|
|
uiObj, this->df.rgodf[uiObj].dwType);
|
|
|
|
}
|
|
#endif
|
|
|
|
hres = S_OK;
|
|
|
|
done:;
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitParse |
|
|
*
|
|
* Identify and initialize the data structures needed for
|
|
* parsing reports.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT INTERNAL
|
|
CHid_InitParse(PCHID this)
|
|
{
|
|
DWORD cb;
|
|
HRESULT hres;
|
|
|
|
/*
|
|
* Obtain the maximum number of HIDP_DATA structures
|
|
* that will be returned at one go.
|
|
*/
|
|
|
|
this->hriIn .cdataMax = HidP_MaxDataListLength(HidP_Input , this->ppd);
|
|
this->hriOut.cdataMax = HidP_MaxDataListLength(HidP_Output, this->ppd);
|
|
this->hriFea.cdataMax = HidP_MaxDataListLength(HidP_Feature, this->ppd);
|
|
|
|
/*
|
|
* More annoyances.
|
|
*/
|
|
this->hriIn .cbReport = this->caps. InputReportByteLength;
|
|
this->hriOut.cbReport = this->caps. OutputReportByteLength;
|
|
this->hriFea.cbReport = this->caps.FeatureReportByteLength;
|
|
|
|
/*
|
|
* Some trace squirties because HID is tricky.
|
|
*/
|
|
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: MaxDataListLength(Input) = %d"),
|
|
this->hriIn.cdataMax);
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: MaxDataListLength(Output) = %d"),
|
|
this->hriOut.cdataMax);
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: MaxDataListLength(Feature)= %d"),
|
|
this->hriFea.cdataMax);
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: InputReportByteLength = %d"),
|
|
this->caps.InputReportByteLength);
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: OutputReportByteLength = %d"),
|
|
this->caps.OutputReportByteLength);
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_InitParse: FeatureReportByteLength = %d"),
|
|
this->caps.FeatureReportByteLength);
|
|
|
|
/*
|
|
* Now allocate all the report-related memory.
|
|
*/
|
|
this->cbPhys = this->df.dwDataSize;
|
|
|
|
/*
|
|
* Allocating the memory is done in four phases.
|
|
*
|
|
* 1. Tally up how much memory we need,
|
|
* 2. Allocate that memory,
|
|
* 3. Dole out the memory we allocated,
|
|
* 4. Check that we didn't mess up.
|
|
*
|
|
* Since this is extremely error-prone (I've messed it up at least
|
|
* once), the work is hidden inside macros.
|
|
*
|
|
* The macro THINGS expands to a series of THING()s, each of which
|
|
* specifies a field name and the size it should be. Each time you
|
|
* want to iterate over the fields, use the THINGS macro.
|
|
*
|
|
* (Yes, this is the same comment block as when we did this before.)
|
|
*
|
|
* Note, the arrays of HIDP_DATA structures must be correctly
|
|
* aligned in some architechtures.
|
|
*/
|
|
CAssertF( FIELD_OFFSET(CHID, hriIn.rgdata) == FIELD_OFFSET(CHID, pvGroup2) );
|
|
|
|
#define THINGS() \
|
|
THING(hriIn.rgdata, cbCxX(this->hriIn.cdataMax, HIDP_DATA)); \
|
|
THING(hriOut.rgdata, cbCxX(this->hriOut.cdataMax, HIDP_DATA)); \
|
|
THING(hriFea.rgdata, cbCxX(this->hriFea.cdataMax, HIDP_DATA)); \
|
|
THING(hriIn.pvReport, this->hriIn.cbReport); \
|
|
THING(hriOut.pvReport, this->hriOut.cbReport); \
|
|
THING(hriFea.pvReport, this->hriFea.cbReport); \
|
|
THING(pvPhys, this->cbPhys); \
|
|
THING(pvStage, this->cbPhys); \
|
|
|
|
/*
|
|
* Make a pass through the fields adding up the memory requirements.
|
|
*/
|
|
#define THING(f, cbF) cb += cbF
|
|
cb = 0;
|
|
THINGS();
|
|
#undef THING
|
|
|
|
hres = ReallocCbPpv(cb, &this->pvGroup2);
|
|
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
|
|
PV pv;
|
|
|
|
/*
|
|
* Assert that the allocation is aligned
|
|
*/
|
|
AssertF( !( ((UINT_PTR)this->pvGroup2) & ( MAX_NATURAL_ALIGNMENT - 1 ) ) );
|
|
|
|
/*
|
|
* Make a pass through the fields carving up the memory block
|
|
* and handing out pieces of it.
|
|
*/
|
|
#define THING(f, cbF) this->f = pv; pv = pvAddPvCb(pv, cbF)
|
|
pv = this->pvGroup2;
|
|
THINGS();
|
|
#undef THING
|
|
|
|
/*
|
|
* There should be no byte left over.
|
|
*/
|
|
AssertF(pvAddPvCb(this->pvGroup2, cb) == pv);
|
|
|
|
}
|
|
|
|
#undef THINGS
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitParseData |
|
|
*
|
|
* Post-init pass to set up all the data used by parsing.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL
|
|
CHid_InitParseData(PCHID this)
|
|
{
|
|
HRESULT hres;
|
|
UINT uiObj;
|
|
|
|
/*
|
|
* Preinitialize the HIDP_DATA indices to -1 to indicate
|
|
* that they aren't there. We must do this before we
|
|
* mess with AddDeviceData, which assumes that all the
|
|
* indices are properly set up.
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
this->rghoc[uiObj].idata = -1;
|
|
}
|
|
|
|
/*
|
|
* Now do some initialization of each object.
|
|
*/
|
|
for(uiObj = 0; uiObj < this->df.dwNumObjs; uiObj++)
|
|
{
|
|
PHIDGROUPCAPS pcaps = this->rghoc[uiObj].pcaps;
|
|
LPDIOBJECTDATAFORMAT podf = &this->df.rgodf[uiObj];
|
|
|
|
/*
|
|
* ISSUE-2001/03/13-MarcAnd Should we panic if this assertion fails?
|
|
*/
|
|
AssertF(pcaps);
|
|
|
|
if(pcaps)
|
|
{
|
|
/*
|
|
* For input-like objects, we need to initialize the
|
|
* physical state fields to sane defaults so apps
|
|
* don't get confused if they issue a read before the first
|
|
* report arrives.
|
|
*
|
|
* Buttons start out not pressed, which means we don't need
|
|
* to do anything since it's already zero-initialized.
|
|
*
|
|
* Relative axes start out not moving, which means we don't need
|
|
* to do anything since it's already zero-initialized.
|
|
*
|
|
* Absolute axes start out centered.
|
|
*
|
|
* POVs start out neutral.
|
|
*
|
|
*/
|
|
|
|
/* No calibration for features as they are input / output */
|
|
|
|
if(pcaps->type == HidP_Input )
|
|
{
|
|
LONG UNALIGNED * pl;
|
|
|
|
pl = pvAddPvCb(this->pvPhys, podf->dwOfs);
|
|
|
|
if(podf->dwType & DIDFT_ABSAXIS )
|
|
{
|
|
if( this->rghoc[uiObj].pjrc->fRaw )
|
|
*pl = (this->rghoc[uiObj].pcaps->Logical.Min + this->rghoc[uiObj].pcaps->Logical.Max) / 2;
|
|
else
|
|
*pl = this->rghoc[uiObj].pjrc->lC;
|
|
} else if(podf->dwType & DIDFT_POV)
|
|
{
|
|
*pl = JOY_POVCENTERED;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ISSUE-2001/03/13-MarcAnd output objects uninitialized
|
|
* For output-like objects, we would have liked to have set the
|
|
* value to Null if possible to keep things vaguely sane.
|
|
* Unfortunately code like:
|
|
* if(HidP_IsOutputLike(pcaps->type))
|
|
* {
|
|
* CHid_AddDeviceData(this, uiObj,pcaps->Null);
|
|
* }
|
|
* Does not work!
|
|
*/
|
|
}
|
|
}
|
|
|
|
hres = S_OK;
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | InitAttributes |
|
|
*
|
|
* Pull out the <t HIDD_ATTRIBUTES> and squirrel away the
|
|
* information we like. Doing this up front is important
|
|
* in case the device gets unplugged later and we lose the
|
|
* ability to talk to it.
|
|
*
|
|
* @parm PHIDD_ATTRIBUTES | pattr |
|
|
*
|
|
* <t HIDD_ATTRIBUTES> containing attributes of device.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL
|
|
CHid_InitAttributes(PCHID this, PHIDD_ATTRIBUTES pattr)
|
|
{
|
|
HRESULT hres;
|
|
|
|
TCHAR tszType[20];
|
|
#ifndef UNICODE
|
|
WCHAR wszType[20];
|
|
#endif
|
|
int ctch;
|
|
|
|
// Input report is disabled until we read flags2 from registry.
|
|
this->fEnableInputReport = FALSE;
|
|
this->fFlags2Checked = FALSE;
|
|
|
|
this->ProductID = pattr->ProductID;
|
|
this->VendorID = pattr->VendorID;
|
|
|
|
AssertF(this->hkType == 0);
|
|
|
|
if( ( this->VendorID == MSFT_SYSTEM_VID )
|
|
&&( ( this->ProductID >= MSFT_SYSTEM_PID + JOY_HW_PREDEFMIN )
|
|
&&( this->ProductID < MSFT_SYSTEM_PID + JOY_HW_PREDEFMAX ) ) )
|
|
{
|
|
/*
|
|
* Predefined types don't have keys
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* The type key for HID devices is "VID_xxxx&PID_yyyy",
|
|
* mirroring the format used by plug and play.
|
|
*/
|
|
ctch = wsprintf(tszType, VID_PID_TEMPLATE,
|
|
this->VendorID, this->ProductID);
|
|
|
|
AssertF(ctch < cA(tszType));
|
|
|
|
#ifdef UNICODE
|
|
hres = JoyReg_OpenTypeKey(tszType, MAXIMUM_ALLOWED, REG_OPTION_NON_VOLATILE, &this->hkType);
|
|
JoyReg_OpenPropKey(tszType, MAXIMUM_ALLOWED, REG_OPTION_NON_VOLATILE, &this->hkProp);
|
|
/*
|
|
* If we fail to open the prop key - we will continue to function with loss in functionality
|
|
* Specifically no device images, etc
|
|
*/
|
|
#else
|
|
TToU(wszType, cA(wszType), tszType);
|
|
hres = JoyReg_OpenTypeKey(wszType, MAXIMUM_ALLOWED, REG_OPTION_NON_VOLATILE, &this->hkType);
|
|
JoyReg_OpenPropKey(wszType, MAXIMUM_ALLOWED, REG_OPTION_NON_VOLATILE, &this->hkProp);
|
|
/*
|
|
* If we fail to open the prop key - we will continue to function with loss in functionality
|
|
* Specifically no device images, etc
|
|
*/
|
|
|
|
#endif
|
|
|
|
/*
|
|
* It is not a problem if we can't open the type key.
|
|
* The device will run suboptimally, but it will still run.
|
|
*/
|
|
AssertF(fLeqvFF(SUCCEEDED(hres), this->hkType));
|
|
|
|
|
|
}
|
|
hres = S_OK;
|
|
|
|
return hres;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | CHid_DoPathAndIdMatch |
|
|
*
|
|
* Given a device name, obtain the corresponding path
|
|
* ("device interface") associated with it, and check
|
|
* that it's the right string.
|
|
*
|
|
* @parm LPCTSTR | ptszId |
|
|
*
|
|
* The device name.
|
|
*
|
|
* @parm LPCTSTR | ptszPath |
|
|
*
|
|
* The path we should get back.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL INTERNAL
|
|
CHid_DoPathAndIdMatch(LPCTSTR ptszId, LPCTSTR ptszPath)
|
|
{
|
|
GUID guidHid;
|
|
HDEVINFO hdev;
|
|
BOOL fRc;
|
|
|
|
HidD_GetHidGuid(&guidHid);
|
|
|
|
hdev = SetupDiGetClassDevs(&guidHid, ptszId, 0,
|
|
DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
|
if(hdev != INVALID_HANDLE_VALUE)
|
|
{
|
|
SP_DEVICE_INTERFACE_DATA did;
|
|
PSP_DEVICE_INTERFACE_DETAIL_DATA pdidd;
|
|
|
|
/*
|
|
* SetupDI requires that the caller initialize cbSize.
|
|
*/
|
|
did.cbSize = cbX(did);
|
|
|
|
if(SetupDiEnumDeviceInterfaces(hdev, 0, &guidHid, 0, &did))
|
|
{
|
|
pdidd = NULL;
|
|
if(DIHid_GetDevicePath(hdev, &did, &pdidd, NULL))
|
|
{
|
|
fRc = ( lstrcmpi(pdidd->DevicePath, ptszPath) == 0x0 );
|
|
if( fRc == FALSE )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("pdidd->DevicePath = %s")
|
|
TEXT("ptszPath = %s "),
|
|
pdidd->DevicePath, ptszPath
|
|
);
|
|
}
|
|
FreePv(pdidd);
|
|
} else // GetDevicePath FAILED
|
|
{
|
|
fRc = FALSE;
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("GetDevicePath FAILED"));
|
|
}
|
|
} else // SetupDiEnumDeviceInterface FAILED
|
|
{
|
|
fRc = FALSE;
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("SetupDiEnumDeviceInterface FAILED"));
|
|
}
|
|
SetupDiDestroyDeviceInfoList(hdev);
|
|
} else // SetupDiGetClassDevs FAILED
|
|
{
|
|
fRc = FALSE;
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("SetupDiGetClassDevs FAILED"));
|
|
}
|
|
|
|
return fRc;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | IsPolledDevice |
|
|
*
|
|
* Returns true if this device has to be polled for input data
|
|
* False if this device supports event driven input
|
|
*
|
|
* @parm HANDLE | hdev |
|
|
*
|
|
* File Handle to a HID device
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL EXTERNAL CHid_IsPolledDevice( HANDLE hdev )
|
|
{
|
|
|
|
/*
|
|
* To determine if a device is polled, we send it an IOCTL to set its
|
|
* poll frequency. If the device responds with a, huh!
|
|
* (STATUS_INVALID_DEVICE_REQUEST) then we know the device is not polled.
|
|
* On Win2k we use the poll interval value zero which is a special value
|
|
* that signals HID that we want to do opportunistic polls rather than
|
|
* polls on a background timer. In this case, as long as polls are not
|
|
* faster than the predefined minimum (currently 5ms) the poll will be
|
|
* completed either with recent data or the result of an immediate poll.
|
|
* On Win98 Gold opportunistic polls are not implemented so we always
|
|
* use HIDs background polling, with an interval set to keep the device
|
|
* responsive without swamping the system. To make sure we use a read
|
|
* thread, rather than a blocking read, we have to treat this devices as
|
|
* interrupt driven.
|
|
* HID makes this change the polling interval specific to our handle so
|
|
* that other apps reading from this device will not be damaged.
|
|
*/
|
|
BOOL frc;
|
|
ULONG uPollingFreq;
|
|
DWORD cbRc;
|
|
|
|
#ifdef WINNT
|
|
BOOL fRet;
|
|
uPollingFreq = 0;
|
|
#else
|
|
uPollingFreq = 40;
|
|
#endif
|
|
|
|
frc = DeviceIoControl (hdev,
|
|
IOCTL_HID_SET_POLL_FREQUENCY_MSEC,
|
|
&uPollingFreq, cbX(uPollingFreq),
|
|
&uPollingFreq, cbX(uPollingFreq),
|
|
&cbRc, NULL);
|
|
#ifdef WINNT
|
|
if( frc )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_IsPolledDevice: Opportunistic polling set") );
|
|
fRet = TRUE;
|
|
} else
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_IsPolledDevice: NOT POLLED, LastError = 0x%x"),
|
|
GetLastError());
|
|
fRet = FALSE;
|
|
}
|
|
return fRet;
|
|
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func HANDLE | CHid_OpenDevicePath |
|
|
*
|
|
* Given a device name, open the device via its
|
|
* device interface.
|
|
*
|
|
* @parm LPCTSTR | ptszId |
|
|
*
|
|
* @parm DWORD | dwAttributes |
|
|
*
|
|
* Create File attributes
|
|
*
|
|
* The device name.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HANDLE EXTERNAL
|
|
CHid_OpenDevicePath(PCHID this, DWORD dwAttributes)
|
|
{
|
|
HANDLE hDev;
|
|
|
|
hDev = CreateFile(this->ptszPath,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
0, /* no SECURITY_ATTRIBUTES */
|
|
OPEN_EXISTING,
|
|
dwAttributes, /* attributes */
|
|
0); /* template */
|
|
|
|
if( hDev == INVALID_HANDLE_VALUE )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflBenign,
|
|
TEXT("Failed to open HID %s, le=%d"), this->ptszPath, GetLastError() );
|
|
}
|
|
|
|
this->IsPolledInput = CHid_IsPolledDevice(hDev);
|
|
|
|
return hDev;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | GetHdevInfo |
|
|
*
|
|
* Get information about the device that is kept in the
|
|
* HANDLE itself. We create the handle, get the goo, and
|
|
* then close the handle.
|
|
*
|
|
* The preparsed data is stashed into the <e CHid.ppd>
|
|
* field of the <t CHid> structure.
|
|
*
|
|
* @parm PHIDD_ATTRIBUTES | pattr |
|
|
*
|
|
* Receives the <t HIDD_ATTRIBUTES> of the device.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL INTERNAL
|
|
CHid_GetHdevInfo(PCHID this, PHIDD_ATTRIBUTES pattr)
|
|
{
|
|
HANDLE hdev;
|
|
BOOL fRc = FALSE;
|
|
|
|
hdev = CHid_OpenDevicePath(this, FILE_FLAG_OVERLAPPED);
|
|
if(hdev != INVALID_HANDLE_VALUE)
|
|
{
|
|
pattr->Size = cbX(*pattr);
|
|
if( HidD_GetAttributes(hdev, pattr) )
|
|
{
|
|
if( HidD_GetPreparsedData(hdev, &this->ppd) )
|
|
{
|
|
fRc = TRUE;
|
|
}
|
|
else
|
|
{
|
|
RPF( "HidD_GetPreparsedData failed, le=%d", GetLastError() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RPF( "HidD_GetAttributes failed, le=%d", GetLastError() );
|
|
}
|
|
CloseHandle(hdev);
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @method HRESULT | CHid | Init |
|
|
*
|
|
* Initialize the object.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT EXTERNAL
|
|
CHid_Init(PCHID this, REFGUID rguid)
|
|
{
|
|
HRESULT hres = E_FAIL;
|
|
PHIDDEVICEINFO phdi;
|
|
EnterProc(CHid_Init, (_ "p", this));
|
|
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_Init: Starting %08x"), rguid->Data1);
|
|
|
|
this->df.dwSize = cbX(DIDATAFORMAT);
|
|
this->df.dwObjSize = cbX(DIOBJECTDATAFORMAT);
|
|
|
|
AssertF(this->df.dwDataSize == 0);
|
|
AssertF(this->df.rgodf == 0);
|
|
AssertF(this->df.dwFlags == 0);
|
|
AssertF(this->df.dwNumObjs == 0);
|
|
AssertF(this->dwAxes == 0);
|
|
AssertF(this->dwButtons == 0);
|
|
AssertF(this->dwCollections == 0);
|
|
|
|
this->idJoy = -1; /* Unknown associated VJOYD device */
|
|
this->hdev = INVALID_HANDLE_VALUE;
|
|
this->hdevEm = INVALID_HANDLE_VALUE;
|
|
|
|
this->diHacks.nMaxDeviceNameLength = MAX_PATH;
|
|
|
|
DllEnterCrit();
|
|
|
|
phdi = phdiFindHIDInstanceGUID(rguid);
|
|
|
|
if(phdi)
|
|
{
|
|
this->dwDevType = phdi->osd.dwDevType;
|
|
this->idJoy = phdi->idJoy;
|
|
|
|
/*
|
|
* Dup the registry key so we can hang onto it after
|
|
* the original has been closed. If the RegOpenKeyEx
|
|
* fails, the value of this->hkInstType will stay zero
|
|
* so we won't run with garbage.
|
|
*/
|
|
AssertF(this->hkInstType == 0);
|
|
|
|
hres = hresMumbleKeyEx(phdi->hk,
|
|
TEXT("Type"),
|
|
DI_KEY_ALL_ACCESS,
|
|
REG_OPTION_NON_VOLATILE,
|
|
&this->hkInstType);
|
|
/*
|
|
* Dup the paths and stuff.
|
|
*/
|
|
hres = hresDupPtszPptsz(phdi->pdidd->DevicePath, &this->ptszPath);
|
|
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
hres = hresDupPtszPptsz(phdi->ptszId, &this->ptszId);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Get out of the critical section as quickly as possible.
|
|
* Note phdi is invalid once we leave the critical section however
|
|
* we can safely use is as a flag that the GUID was found.
|
|
*/
|
|
DllLeaveCrit();
|
|
|
|
if(phdi)
|
|
{
|
|
if(SUCCEEDED(hres))
|
|
{
|
|
HIDD_ATTRIBUTES attr;
|
|
|
|
if( !CHid_GetHdevInfo(this, &attr) )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("%hs: CHid_GetHdevInfo failed"), s_szProc );
|
|
hres = E_FAIL;
|
|
}
|
|
else if( FAILED(HidP_GetCaps(this->ppd, &this->caps) ) )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("%hs: HidP_GetCaps failed, le=%d"), s_szProc, GetLastError() );
|
|
hres = E_FAIL;
|
|
}
|
|
else if( !CHid_DoPathAndIdMatch(this->ptszId, this->ptszPath) )
|
|
{
|
|
SquirtSqflPtszV(sqflHidParse | sqflError,
|
|
TEXT("%hs: Path and HW ID do not match"), s_szProc );
|
|
hres = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
|
|
if(SUCCEEDED(hres = CHid_InitAttributes(this, &attr)) &&
|
|
SUCCEEDED(hres = CHid_AllocObjectMemory(this)) &&
|
|
SUCCEEDED(hres = CHid_InitObjects(this)) &&
|
|
SUCCEEDED(hres = CHid_InitParse(this)) &&
|
|
SUCCEEDED(hres = CHid_InitParseData(this)))
|
|
{
|
|
|
|
VXDDEVICEFORMAT devf;
|
|
UINT uiCal;
|
|
|
|
/*
|
|
* Load calibration information, and if there were
|
|
* no calibratable items, then wipe out this->pjrcNext
|
|
* to indicate that there is no need to watch for
|
|
* recalibration messages.
|
|
*/
|
|
uiCal = CHid_LoadCalibrations(this);
|
|
if(uiCal == 0)
|
|
{
|
|
this->pjrcNext = NULL;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Remember to do this after we have
|
|
* created the data format.
|
|
*/
|
|
devf.cbData = this->df.dwDataSize;
|
|
devf.cObj = this->df.dwNumObjs;
|
|
devf.rgodf = this->df.rgodf;
|
|
/*
|
|
* Note, dwExtra is 64 bits on 64 bit platforms
|
|
* should update the name one day.
|
|
*/
|
|
devf.dwExtra = (UINT_PTR)this;
|
|
devf.dwEmulation = 0;
|
|
|
|
hres = Hel_HID_CreateInstance(&devf, &this->pvi);
|
|
|
|
/* Polled input devices may not be attached */
|
|
if(this->IsPolledInput)
|
|
{
|
|
HANDLE hdev;
|
|
PBUSDEVICEINFO pbdi;
|
|
|
|
hdev = CHid_OpenDevicePath(this, 0x0);
|
|
|
|
if( hdev != INVALID_HANDLE_VALUE )
|
|
{
|
|
int i;
|
|
BOOL frc;
|
|
DWORD cbRead;
|
|
BOOL bPresent = FALSE;
|
|
|
|
for( i=0x0; i < FAILED_POLL_THRESHOLD; i++ )
|
|
{
|
|
frc = ReadFile(hdev, this->hriIn.pvReport,
|
|
this->hriIn.cbReport, &cbRead, 0x0 );
|
|
|
|
if( frc != 0x0 &&
|
|
cbRead == this->hriIn.cbReport )
|
|
{
|
|
bPresent = TRUE;
|
|
break;
|
|
} else
|
|
{
|
|
Sleep(10);
|
|
|
|
SquirtSqflPtszV(sqflHidParse | sqflVerbose,
|
|
TEXT("CHid_Init: ReadFailed, LastError = 0x%x"),
|
|
GetLastError());
|
|
|
|
}
|
|
}
|
|
|
|
CloseHandle(hdev);
|
|
|
|
if( bPresent == FALSE )
|
|
{
|
|
this->pvi->fl |= VIFL_UNPLUGGED;
|
|
SquirtSqflPtszV(sqflHidParse | sqflBenign,
|
|
TEXT("%hs: ReadFailed, setting to unplugged"), s_szProc );
|
|
}
|
|
|
|
DllEnterCrit();
|
|
|
|
phdi = phdiFindHIDDeviceInterface(this->ptszPath);
|
|
AssertF(phdi != NULL);
|
|
pbdi = pbdiFromphdi(phdi);
|
|
|
|
DllLeaveCrit();
|
|
|
|
|
|
if( pbdi != NULL )
|
|
{
|
|
if( pbdi->fDeleteIfNotConnected == TRUE )
|
|
{
|
|
if( bPresent == FALSE )
|
|
{
|
|
lstrcpy( g_tszIdLastRemoved, pbdi->ptszId );
|
|
g_tmLastRemoved = GetTickCount();
|
|
|
|
DIBusDevice_Remove(pbdi);
|
|
}
|
|
pbdi->fDeleteIfNotConnected = FALSE;
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
// Could not Open the device
|
|
this->pvi->fl |= VIFL_UNPLUGGED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
// Squirt: device mysteriously gone
|
|
hres = DIERR_DEVICENOTREG;
|
|
}
|
|
|
|
SquirtSqflPtszV(sqflHidParse,
|
|
TEXT("CHid_Init: Ending %08x"), rguid->Data1);
|
|
|
|
ExitOleProc();
|
|
return hres;
|
|
}
|