#include #include #include #include #include #include #include #include "hidsdi.h" #include "hid.h" #define INSTRUCTIONS "\nCommands:\n" \ "\t?,h Display this message\n" \ "\t Enter device number \n" \ "\tL LOOP read \n" \ "\tx exit\n" #define PROMPT "Command!>" void PrintDeviceinfo(PHID_DEVICE HidDevices, LONG ulCount); int __cdecl main(int argc, char **argv) { PHID_DEVICE HidDevices, pWalk; LONG ulCount; BOOL bReturn, bDone, bOK; int uiLoop; PHID_DEVICE pDevice; PHID_DATA pData; unsigned uLoop; char sz[256], cCode; int i; DWORD dwDelay=100; bDone = FALSE; bReturn=FindKnownHidDevices(&HidDevices,&ulCount); printf("\n"); if(argc > 1) dwDelay = atoi(argv[1]); if(!bReturn) { printf("Error FindKnownHidDevices returned FALSE\n"); exit(0); } pDevice = HidDevices; if(!pDevice){ printf("Hid Devices are not availabel\n"); exit(0); } PrintDeviceinfo(HidDevices, ulCount); printf (INSTRUCTIONS); while (!bDone) { printf (PROMPT); if (gets (sz) == NULL) { sz[0] = 'x'; sz[1] = '\0'; } cCode = sz[0]; // if user types a blank before the command, too bad switch (cCode) { case 'h': case '?': printf (INSTRUCTIONS); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6' : case '7': case '8': case '9':{ if( cCode - '0' >= ulCount ) { printf("Error invalid input try again\n"); continue; } pDevice = HidDevices + cCode - '0' ; Read(pDevice); pData=pDevice->InputData; for(uLoop=0;uLoopInputDataLength;uLoop++) { ReportToString(pData); pData++; } /*end for*/ break; } case 'L': // loop read printf ("Loop read device %d\n", pDevice->HidDevice); Sleep(1000); for (i = 0; i < 1000; i++) { if(!Read(pDevice)) // printf("Read returned false\n"); pData=pDevice->InputData; printf("-------------------------------------------\n"); for(uLoop=0;uLoopInputDataLength;uLoop++) { ReportToString(pData); pData++; } /*end for*/ Sleep(dwDelay); } break; case 'x': // done bDone = TRUE; break; default: printf ("Huh? >%s<\n", sz); printf (INSTRUCTIONS); break; } } // end of while pWalk= HidDevices; for(uiLoop=0;uiLoopHidDevice); return 0; } void PrintDeviceinfo( PHID_DEVICE HidDevices, LONG ulCount ) { PHID_DEVICE pWalk; LONG uiLoop, i, num; PHIDP_VALUE_CAPS pValue; PHIDP_BUTTON_CAPS pButton; pWalk=HidDevices; for(uiLoop=0;uiLoopCaps.UsagePage == HID_USAGE_PAGE_GENERIC) { switch(pWalk->Caps.Usage){ case HID_USAGE_GENERIC_POINTER: printf("Device (%d) Pointer", uiLoop);break; case HID_USAGE_GENERIC_MOUSE: printf("Device (%d) Mouse", uiLoop);break; case HID_USAGE_GENERIC_PEN: printf("Device (%d) PEN", uiLoop);break; case HID_USAGE_GENERIC_JOYSTICK: printf("Device (%d) Joystick", uiLoop);break; case HID_USAGE_GENERIC_GAMEPAD: printf("Device (%d) GamePad", uiLoop);break; case HID_USAGE_GENERIC_KEYBOARD : printf("Device (%d) Keyboard", uiLoop);break; case HID_USAGE_GENERIC_KEYPAD : printf("Device (%d) Keypad", uiLoop);break; case HID_USAGE_GENERIC_STYLUS2: printf("Device (%d) Stylus2", uiLoop);break; case HID_USAGE_GENERIC_PUCK : printf("Device (%d) Pointer", uiLoop);break; case HID_USAGE_GENERIC_SYSTEM_CTL : printf("Device (%d) System Control", uiLoop);break; default: goto PRN; }// end of switch } else { PRN: printf("Device (%d) UsagePage:0%x Usage:0%x", uiLoop,pWalk->Caps.UsagePage,pWalk->Caps.Usage); } //pValue = pWalk->InputValueCaps; if(pWalk->Caps.NumberInputButtonCaps){ pButton = pWalk->InputButtonCaps; for(num=0,i=0;iCaps.NumberInputButtonCaps;i++,pButton++) { num += (pButton->Range.UsageMax - pButton->Range.UsageMin + 1); } printf("\tNumInpBut(%d):%d",pWalk->Caps.NumberInputButtonCaps, num); } if(pWalk->Caps.NumberInputValueCaps){ printf("\tInpValCaps:%d",pWalk->Caps.NumberInputValueCaps); } if(pWalk->Caps.NumberOutputButtonCaps){ pButton = pWalk->OutputButtonCaps; for(num=0,i=0;iCaps.NumberOutputButtonCaps;i++,pButton++) { num += (pButton->Range.UsageMax - pButton->Range.UsageMin + 1); } printf("\tNumOutBut(%d):%d",pWalk->Caps.NumberOutputButtonCaps, num); } if(pWalk->Caps.NumberOutputValueCaps){ printf("\tOutButCaps:%d\n",pWalk->Caps.NumberOutputValueCaps); } if(pWalk->Caps.NumberFeatureButtonCaps){ pButton = pWalk->FeatureButtonCaps; for(num=0,i=0;iCaps.NumberFeatureButtonCaps;i++,pButton++) { num += (pButton->Range.UsageMax - pButton->Range.UsageMin + 1); } printf("\tNumFeatBut(%d):%d",pWalk->Caps.NumberFeatureButtonCaps, num); } if(pWalk->Caps.NumberFeatureValueCaps){ printf("\tFeatButCaps:%d\n",pWalk->Caps.NumberFeatureValueCaps); } printf("\n"); } /*end for*/ } BOOLEAN FindKnownHidDevices ( OUT PHID_DEVICE * HidDevices, // A array of struct _HID_DEVICE OUT PULONG NumberDevices // the length of this array. ) /*++ Routine Description: Do the required PnP things in order to find, the all the HID devices in the system at this time. --*/ { HDEVINFO hardwareDeviceInfo; SP_DEVICE_INTERFACE_DATA deviceInfoData; ULONG i; BOOL done; PHID_DEVICE hidDeviceInst; GUID hidGuid; HidD_GetHidGuid (&hidGuid); *HidDevices = NULL; *NumberDevices = 0; // // Open a handle to the plug and play dev node. // hardwareDeviceInfo = SetupDiGetClassDevs ( &hidGuid, NULL, // Define no enumerator (global) NULL, // Define no (DIGCF_PRESENT | // Only Devices present DIGCF_DEVICEINTERFACE)); // Function class devices. // // Take a wild guess to start // *NumberDevices = 4; done = FALSE; deviceInfoData.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA); i=0; while (!done) { *NumberDevices *= 2; if (*HidDevices) { *HidDevices = realloc (*HidDevices, (*NumberDevices * sizeof (HID_DEVICE))); } else { *HidDevices = calloc (*NumberDevices, sizeof (HID_DEVICE)); } if (NULL == *HidDevices) { SetupDiDestroyDeviceInfoList (hardwareDeviceInfo); return FALSE; } hidDeviceInst = *HidDevices + i; for (; i < *NumberDevices; i++, hidDeviceInst++) { if (SetupDiEnumDeviceInterfaces (hardwareDeviceInfo, 0, // No care about specific PDOs &hidGuid, i, &deviceInfoData)) { OpenHidDevice (hardwareDeviceInfo, &deviceInfoData, hidDeviceInst); } else { if (ERROR_NO_MORE_ITEMS == GetLastError()) { done = TRUE; break; } } } } *NumberDevices = i; SetupDiDestroyDeviceInfoList (hardwareDeviceInfo); return TRUE; } VOID ReportToString( PHID_DATA pData ) { PUSAGE pUsage; ULONG i; if (pData->IsButtonData && pData->UsagePage == HID_USAGE_PAGE_BUTTON ) { printf (" Buttons :"); for (i=0, pUsage = pData->ButtonData.Usages; i < pData->ButtonData.MaxUsageLength; i++, pUsage++) { if (0 == *pUsage) { break; // A usage of zero is a non button. } printf (" 0x%x", *pUsage); } printf("\n"); } else { switch(pData->UsagePage) { case HID_USAGE_PAGE_GENERIC : case HID_USAGE_PAGE_VEHICLE : switch(pData->ValueData.Usage) { case HID_USAGE_VEHICLE_THROTTLE: printf(" THROTTLE(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_VEHICLE_RUDDER: printf(" RUDDER(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_X: printf(" X(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_Y: printf(" Y(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_Z: printf(" Z(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_RX: printf(" RX(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_RY: printf(" RY(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_RZ: printf(" RZ(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_SLIDER: printf(" SLIDDER(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_DIAL: printf(" DIAL(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_WHEEL: printf(" WHEEL(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_HATSWITCH: printf(" HATSWITCH(%4d):%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; default: goto END; break; }// end of switch break; case HID_USAGE_PAGE_KEYBOARD: switch(pData->ValueData.Usage) { case HID_USAGE_GENERIC_KEYBOARD: printf(" KEYBOARD(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; case HID_USAGE_GENERIC_KEYPAD: printf(" KEYPAD(%4d) :%4d\n", pData->ValueData.ScaledValue, pData->ValueData.Value); break; default: goto END; break; }// end of switch default: END: printf ("Usage Page: 0x%x, Usage: 0x%x, Scaled: %d Value:%d\n", pData->UsagePage, pData->ValueData.Usage, pData->ValueData.ScaledValue, pData->ValueData.Value); }//end of switch } } BOOLEAN Read ( PHID_DEVICE HidDevice ) /*++ RoutineDescription: Given a struct _HID_DEVICE, obtain a read report and unpack the values into to InputData array. --*/ { DWORD bytesRead; if (!ReadFile (HidDevice->HidDevice, HidDevice->InputReportBuffer, HidDevice->Caps.InputReportByteLength, &bytesRead, NULL)) { // No overlapped structure. HidClass buffers for us. return FALSE; } ASSERT (bytesRead == hidDevice->Caps.InputReportByteLength); return UnpackReport (HidDevice->InputReportBuffer, HidDevice->Caps.InputReportByteLength, HidP_Input, HidDevice->InputData, HidDevice->InputDataLength, HidDevice->Ppd); } BOOL UnpackReport ( IN PCHAR ReportBuffer, IN USHORT ReportBufferLength, IN HIDP_REPORT_TYPE ReportType, IN OUT PHID_DATA Data, IN ULONG DataLength, IN PHIDP_PREPARSED_DATA Ppd ) /*++ Routine Description: --*/ { ULONG numUsages; // Number of usages returned from GetUsages. ULONG i; for (i = 0; i < DataLength; i++, Data++) { if (Data->IsButtonData) { numUsages = Data->ButtonData.MaxUsageLength; Data->Status = HidP_GetUsages ( ReportType, Data->UsagePage, 0, // All collections Data->ButtonData.Usages, &numUsages, Ppd, ReportBuffer, ReportBufferLength); // // Get usages writes the list of usages into the buffer // Data->ButtonData.Usages newUsage is set to the number of usages // written into this array. // We assume that there will not be a usage of zero. // (None have been defined to date.) // So lets assume that a zero indicates an end of the list of usages. // if (numUsages < Data->ButtonData.MaxUsageLength) { Data->ButtonData.Usages[numUsages] = 0; } } else { Data->Status = HidP_GetUsageValue ( ReportType, Data->UsagePage, 0, // All Collections. Data->ValueData.Usage, &Data->ValueData.Value, Ppd, ReportBuffer, ReportBufferLength); Data->Status = HidP_GetScaledUsageValue ( ReportType, Data->UsagePage, 0, // All Collections. Data->ValueData.Usage, &Data->ValueData.ScaledValue, Ppd, ReportBuffer, ReportBufferLength); } } return (HIDP_STATUS_SUCCESS == Data->Status); } BOOLEAN OpenHidDevice ( IN HDEVINFO HardwareDeviceInfo, IN PSP_DEVICE_INTERFACE_DATA DeviceInfoData, IN OUT PHID_DEVICE HidDevice ) /*++ RoutineDescription: Given the HardwareDeviceInfo, representing a handle to the plug and play information, and deviceInfoData, representing a specific hid device, open that device and fill in all the relivant information in the given HID_DEVICE structure. return if the open and initialization was successfull or not. --*/ { PSP_DEVICE_INTERFACE_DETAIL_DATA functionClassDeviceData = NULL; ULONG predictedLength = 0; ULONG requiredLength = 0; ULONG i; ULONG numValues; USHORT numCaps; PHIDP_BUTTON_CAPS buttonCaps; PHIDP_VALUE_CAPS valueCaps; PHID_DATA data; USAGE usage; static ULONG NumberDevices = 0; // // allocate a function class device data structure to receive the // goods about this particular device. // SetupDiGetDeviceInterfaceDetail ( HardwareDeviceInfo, DeviceInfoData, NULL, // probing so no output buffer yet 0, // probing so output buffer length of zero &requiredLength, NULL); // not interested in the specific dev-node predictedLength = requiredLength; functionClassDeviceData = malloc (predictedLength); functionClassDeviceData->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA); // // Retrieve the information from Plug and Play. // if (! SetupDiGetDeviceInterfaceDetail ( HardwareDeviceInfo, DeviceInfoData, functionClassDeviceData, predictedLength, &requiredLength, NULL)) { return FALSE; } //printf("\nDevicePath of %d HID device: %s\n", NumberDevices, // functionClassDeviceData->DevicePath); HidDevice->HidDevice = CreateFile ( functionClassDeviceData->DevicePath, GENERIC_READ | GENERIC_WRITE, 0, // FILE_SHARE_READ | FILE_SHARE_WRITE NULL, // no SECURITY_ATTRIBUTES structure OPEN_EXISTING, // No special create flags 0, // No special attributes NULL); // No template file if (INVALID_HANDLE_VALUE == HidDevice->HidDevice) { return FALSE; } if (!HidD_GetPreparsedData (HidDevice->HidDevice, &HidDevice->Ppd)) { return FALSE; } if (!HidP_GetCaps (HidDevice->Ppd, &HidDevice->Caps)) { HidD_FreePreparsedData (HidDevice->Ppd); return FALSE; } NumberDevices++; // // At this point the client has a choise. It may chose to look at the // Usage and Page of the top level collection found in the HIDP_CAPS // structure. In this way it could just use the usages it knows about. // If either HidP_GetUsages or HidP_GetUsageValue return an error then // that particular usage does not exist in the report. // This is most likely the preferred method as the application can only // use usages of which it already knows. // In this case the app need not even call GetButtonCaps or GetValueCaps. // // In this example, however, we look for all of the usages in the device. // // // setup Input Data buffers. // // // Allocate memory to hold on input report // HidDevice->InputReportBuffer = (PCHAR) calloc (HidDevice->Caps.InputReportByteLength, sizeof (CHAR)); // // Allocate memory to hold the button and value capabilities. // NumberXXCaps is in terms of array elements. // HidDevice->InputButtonCaps = buttonCaps = (PHIDP_BUTTON_CAPS) calloc (HidDevice->Caps.NumberInputButtonCaps, sizeof (HIDP_BUTTON_CAPS)); HidDevice->InputValueCaps = valueCaps = (PHIDP_VALUE_CAPS) calloc (HidDevice->Caps.NumberInputValueCaps, sizeof (HIDP_VALUE_CAPS)); // // Have the HidP_X functions fill in the capability structure arrays. // numCaps = HidDevice->Caps.NumberInputButtonCaps; HidP_GetButtonCaps (HidP_Input, buttonCaps, &numCaps, HidDevice->Ppd); numCaps = HidDevice->Caps.NumberInputValueCaps; HidP_GetValueCaps (HidP_Input, valueCaps, &numCaps, HidDevice->Ppd); // // Depending on the device, some value caps structures may represent more // than one value. (A range). In the interest of being verbose, over // efficient we will expand these so that we have one and only one // struct _HID_DATA for each value. // // To do this we need to count up the total number of values are listed // in the value caps structure. For each element in the array we test // for range if it is a range then UsageMax and UsageMin describe the // usages for this range INCLUSIVE. // numValues = 0; for (i = 0; i < HidDevice->Caps.NumberInputValueCaps; i++, valueCaps++) { if (valueCaps->IsRange) { numValues += valueCaps->Range.UsageMax - valueCaps->Range.UsageMin + 1; } else { numValues++; } } valueCaps = HidDevice->InputValueCaps; // // Allocate a buffer to hold the struct _HID_DATA structures. // One element for each set of buttons, and one element for each value // found. // HidDevice->InputDataLength = HidDevice->Caps.NumberInputButtonCaps + numValues; HidDevice->InputData = data = (PHID_DATA) calloc (HidDevice->InputDataLength, sizeof (HID_DATA)); // // Fill in the button data // for (i = 0; i < HidDevice->Caps.NumberInputButtonCaps; i++, data++, buttonCaps++) { data->IsButtonData = TRUE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = buttonCaps->UsagePage; data->ButtonData.MaxUsageLength = HidP_MaxUsageListLength ( HidP_Input, buttonCaps->UsagePage, HidDevice->Ppd); data->ButtonData.Usages = (PUSAGE) calloc (data->ButtonData.MaxUsageLength, sizeof (USAGE)); } // // Fill in the value data // for (i = 0; i < numValues; i++, valueCaps++) { if (valueCaps->IsRange) { for (usage = valueCaps->Range.UsageMin; usage <= valueCaps->Range.UsageMax; usage++) { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = usage; data++; } } else { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = valueCaps->NotRange.Usage; data++; } } //return TRUE; // no need to get other info // // setup Output Data buffers. // HidDevice->OutputReportBuffer = (PCHAR) calloc (HidDevice->Caps.OutputReportByteLength, sizeof (CHAR)); HidDevice->OutputButtonCaps = buttonCaps = (PHIDP_BUTTON_CAPS) calloc (HidDevice->Caps.NumberOutputButtonCaps, sizeof (HIDP_BUTTON_CAPS)); HidDevice->OutputValueCaps = valueCaps = (PHIDP_VALUE_CAPS) calloc (HidDevice->Caps.NumberOutputValueCaps, sizeof (HIDP_VALUE_CAPS)); numCaps = HidDevice->Caps.NumberOutputButtonCaps; HidP_GetButtonCaps (HidP_Output, buttonCaps, &numCaps, HidDevice->Ppd); numCaps = HidDevice->Caps.NumberOutputValueCaps; HidP_GetValueCaps (HidP_Output, valueCaps, &numCaps, HidDevice->Ppd); numValues = 0; for (i = 0; i < HidDevice->Caps.NumberOutputValueCaps; i++, valueCaps++) { if (valueCaps->IsRange) { numValues += valueCaps->Range.UsageMax - valueCaps->Range.UsageMin + 1; } else { numValues++; } } valueCaps = HidDevice->OutputValueCaps; HidDevice->OutputDataLength = HidDevice->Caps.NumberOutputButtonCaps + numValues; HidDevice->OutputData = data = (PHID_DATA) calloc (HidDevice->OutputDataLength, sizeof (HID_DATA)); for (i = 0; i < HidDevice->Caps.NumberOutputButtonCaps; i++, data++, buttonCaps++) { data->IsButtonData = TRUE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = buttonCaps->UsagePage; data->ButtonData.MaxUsageLength = HidP_MaxUsageListLength ( HidP_Output, buttonCaps->UsagePage, HidDevice->Ppd); data->ButtonData.Usages = (PUSAGE) calloc (data->ButtonData.MaxUsageLength, sizeof (USAGE)); } for (i = 0; i < numValues; i++, valueCaps++) { if (valueCaps->IsRange) { for (usage = valueCaps->Range.UsageMin; usage <= valueCaps->Range.UsageMax; usage++) { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = usage; data++; } } else { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = valueCaps->NotRange.Usage; data++; } } // // setup Feature Data buffers. // HidDevice->FeatureReportBuffer = (PCHAR) calloc (HidDevice->Caps.FeatureReportByteLength, sizeof (CHAR)); HidDevice->FeatureButtonCaps = buttonCaps = (PHIDP_BUTTON_CAPS) calloc (HidDevice->Caps.NumberFeatureButtonCaps, sizeof (HIDP_BUTTON_CAPS)); HidDevice->FeatureValueCaps = valueCaps = (PHIDP_VALUE_CAPS) calloc (HidDevice->Caps.NumberFeatureValueCaps, sizeof (HIDP_VALUE_CAPS)); numCaps = HidDevice->Caps.NumberFeatureButtonCaps; HidP_GetButtonCaps (HidP_Feature, buttonCaps, &numCaps, HidDevice->Ppd); numCaps = HidDevice->Caps.NumberFeatureValueCaps; HidP_GetValueCaps (HidP_Feature, valueCaps, &numCaps, HidDevice->Ppd); numValues = 0; for (i = 0; i < HidDevice->Caps.NumberFeatureValueCaps; i++, valueCaps++) { if (valueCaps->IsRange) { numValues += valueCaps->Range.UsageMax - valueCaps->Range.UsageMin + 1; } else { numValues++; } } valueCaps = HidDevice->FeatureValueCaps; HidDevice->FeatureDataLength = HidDevice->Caps.NumberFeatureButtonCaps + numValues; HidDevice->FeatureData = data = (PHID_DATA) calloc (HidDevice->FeatureDataLength, sizeof (HID_DATA)); for (i = 0; i < HidDevice->Caps.NumberFeatureButtonCaps; i++, data++, buttonCaps++) { data->IsButtonData = TRUE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = buttonCaps->UsagePage; data->ButtonData.MaxUsageLength = HidP_MaxUsageListLength ( HidP_Feature, buttonCaps->UsagePage, HidDevice->Ppd); data->ButtonData.Usages = (PUSAGE) calloc (data->ButtonData.MaxUsageLength, sizeof (USAGE)); } for (i = 0; i < numValues; i++, valueCaps++) { if (valueCaps->IsRange) { for (usage = valueCaps->Range.UsageMin; usage <= valueCaps->Range.UsageMax; usage++) { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = usage; data++; } } else { data->IsButtonData = FALSE; data->Status = HIDP_STATUS_SUCCESS; data->UsagePage = valueCaps->UsagePage; data->ValueData.Usage = valueCaps->NotRange.Usage; data++; } } return TRUE; }