Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/multimedia/directx/dinput/dx8/dll/dihidini.c

4651 lines
165 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*****************************************************************************
*
* 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;
}
Reference in New Issue Copy Permalink