|
|
/*****************************************************************************
* * 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;}
|
