windows-xp/Source/XPSP1/NT/drivers/wdm/input/client/readhid/readhid.c

#include <stdio.h>
#include <windows.h>
#include <basetyps.h>
#include <stdlib.h>
#include <string.h>
#include <wtypes.h>
#include <wtypes.h>
#include "hidsdi.h"
#include  "hid.h"

#define INSTRUCTIONS "\nCommands:\n" \
"\t?,h Display this message\n" \
"\t<N> 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;uLoop<pDevice->InputDataLength;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;uLoop<pDevice->InputDataLength;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;uiLoop<ulCount;uiLoop++,pWalk++)
        CloseHandle(pWalk->HidDevice);
    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;uiLoop<ulCount;uiLoop++, pWalk++)
    {
        if(pWalk->Caps.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;i<pWalk->Caps.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;i<pWalk->Caps.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;i<pWalk->Caps.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;
}