ecdisp.c

来自「winddk src目录下的WDM源码压缩!」· C语言 代码 · 共 1,674 行 · 第 1/5 页

        pParams -> ReportID = 0;
    }

    return (fStatus);
}

VOID
vInitECControls(
    HWND                hDlg,
    USHORT              InputReportByteLength,
    PBUFFER_DISPLAY     *ppInputDisplay,
    USHORT              OutputReportByteLength,
    PBUFFER_DISPLAY     *ppOutputDisplay,
    USHORT              FeatureReportByteLength,
    PBUFFER_DISPLAY     *ppFeatureDisplay
)
{
    BOOLEAN     fInitStatus;

    /*
    // Begin by initializing the combo box with the calls that can be executed
    */

    vLoadExtCalls(GetDlgItem(hDlg, IDC_EXTCALLS));

    /*
    // Set the radio buttons initially to the input report type
    */
    
    vSetReportType(hDlg, IDC_INPUT);
    
    /*
    // Initialize the edit controls text
    */

    vInitEditText(GetDlgItem(hDlg, IDC_USAGEPAGE), 6, "0x0000");
    vInitEditText(GetDlgItem(hDlg, IDC_USAGE), 6, "0x0000");
    vInitEditText(GetDlgItem(hDlg, IDC_LINKCOLL), 2, "0");
    vInitEditText(GetDlgItem(hDlg, IDC_REPORTID), 3, "0");

    /*
    // Initialize the report buffer boxes
    */

    fInitStatus = BufferDisplay_Init(GetDlgItem(hDlg, IDC_INPUT_SELECT),
                                     GetDlgItem(hDlg, IDC_INPUT_BUFFER),
                                     NUM_INPUT_BUFFERS,
                                     InputReportByteLength,
                                     HidP_Input,
                                     ppInputDisplay);

    if (!fInitStatus) 
    {
        ECDISP_ERROR(hDlg, "Error initializing input buffer display");
    }

    fInitStatus = BufferDisplay_Init(GetDlgItem(hDlg, IDC_OUTPUT_SELECT),
                                     GetDlgItem(hDlg, IDC_OUTPUT_BUFFER),
                                     NUM_OUTPUT_BUFFERS,
                                     OutputReportByteLength,
                                     HidP_Output,
                                     ppOutputDisplay);

    if (!fInitStatus) 
    {
        ECDISP_ERROR(hDlg,  "Error initializing output buffer display");
    }

    fInitStatus = BufferDisplay_Init(GetDlgItem(hDlg, IDC_FEATURE_SELECT),
                                     GetDlgItem(hDlg, IDC_FEATURE_BUFFER),
                                     NUM_FEATURE_BUFFERS,
                                     FeatureReportByteLength,
                                     HidP_Feature,
                                     ppFeatureDisplay);

    if (!fInitStatus) 
    {
        ECDISP_ERROR(hDlg, "Error initializing feature buffer display");
    }

    /*
    // Reset the output box content
    */
    
    SendMessage(GetDlgItem(hDlg, IDC_CALLOUTPUT), LB_RESETCONTENT, 0, 0);
    return;
}
    
BOOL
ECDisp_Execute(
    IN     INT             FuncCall,
    IN OUT PEXTCALL_PARAMS CallParams,
    OUT    PEXTCALL_STATUS CallStatus
)
/*++
RoutineDescription:
    This routine is a complex routine for executing all of the functions.  The
    routine was originally developed with consideration for future use that 
    never materialized.  

    It makes use of the calls in extcalls.c which basically execute the given
    function and does some verification on the buffers that are passed down to 
    HID.DLL.  

    The input parameters are specify the function call to execute, the 
    call parameters structures and the call status structure.

    If any further buffers are needed for the specific calls, they will be
    allocated here.  

    The CallStatus parameters is a structure set by the ExtCalls_ routines

    Future versions of the HClient sample may remove this routine and/or the
    ExtCalls_ routines to simply the code.
--*/
{
    BOOL                ExecuteStatus;
    HIDP_VALUE_CAPS     ValueCaps;
    USHORT              ValueCapsLength;
    PULONG              ValueList;

    NTSTATUS            status;
    DWORD               numBytes;
    ULONG               size;

    /*
    // Initially assume everything will go correctly and will set otherwise
    //    depending on the function call.
    */

    CallStatus -> IsHidError = FALSE;

    switch (FuncCall) 
    {
    case HID_READ_REPORT:
        CallStatus -> IsHidError = !ReadFile(CallParams -> DeviceHandle,
                                             CallParams -> ReportBuffer,
                                             CallParams -> ReportLength,
                                             &numBytes,
                                             NULL);
        return (TRUE);
        break;

    case HID_WRITE_REPORT:
        CallStatus -> IsHidError = !WriteFile(CallParams -> DeviceHandle,
                                              CallParams -> ReportBuffer,
                                              CallParams -> ReportLength,
                                              &numBytes,
                                              NULL);
        return (TRUE);
        break;

    case HIDD_FLUSH_QUEUE:
        CallStatus -> IsHidError = !HidD_FlushQueue(CallParams -> DeviceHandle);
        return (TRUE);
        break;

    case HIDD_GET_HID_GUID:
        CallParams -> List = malloc(sizeof(GUID));

        if (NULL != CallParams -> List) 
        {
            HidD_GetHidGuid((GUID *) CallParams -> List);
        }
        return (NULL != CallParams -> List);
        break;

    case HIDD_GET_PREPARSED_DATA:
        CallStatus -> IsHidError = !HidD_GetPreparsedData(CallParams -> DeviceHandle,
                                                          CallParams -> ppPd);
        return (TRUE);

    case HIDD_FREE_PREPARSED_DATA:
        CallStatus -> IsHidError = !HidD_FreePreparsedData(CallParams -> Ppd);
        return (TRUE);

    case HIDD_GET_ATTRIBUTES:
        CallParams -> List = malloc(sizeof(HIDD_ATTRIBUTES));

        if (NULL != CallParams -> List) 
        {
            CallStatus -> IsHidError = !HidD_GetAttributes(CallParams -> DeviceHandle,
                                                           CallParams -> List);
        }
        return (NULL != CallParams -> List);
        
    case HIDD_GET_FEATURE:
        *(CallParams -> ReportBuffer) = CallParams -> ReportID;

        CallStatus -> IsHidError = !HidD_GetFeature(CallParams -> DeviceHandle,
                                                    CallParams -> ReportBuffer,
                                                    CallParams -> ReportLength);
        return (TRUE);

    case HIDD_SET_FEATURE:
        CallStatus -> IsHidError = !HidD_SetFeature(CallParams -> DeviceHandle,
                                                    CallParams -> ReportBuffer,
                                                    CallParams -> ReportLength);
        return (TRUE);

    case HIDD_GET_INPUT_REPORT:
        *(CallParams -> ReportBuffer) = CallParams -> ReportID;

        CallStatus -> IsHidError = !HidD_GetInputReport(CallParams -> DeviceHandle,
                                                        CallParams -> ReportBuffer,
                                                        CallParams -> ReportLength);
        return (TRUE);

    case HIDD_SET_OUTPUT_REPORT:
        CallStatus -> IsHidError = !HidD_SetOutputReport(CallParams -> DeviceHandle,
                                                         CallParams -> ReportBuffer,
                                                         CallParams -> ReportLength);
        return (TRUE);

    case HIDD_GET_NUM_INPUT_BUFFERS:
        CallStatus -> IsHidError = !HidD_GetNumInputBuffers(CallParams -> DeviceHandle,
                                                            &CallParams -> Value);
        return (TRUE);

    case HIDD_SET_NUM_INPUT_BUFFERS:
        CallStatus -> IsHidError = !HidD_SetNumInputBuffers(CallParams -> DeviceHandle,
                                                            CallParams -> Value);

        return (TRUE);

    case HIDD_GET_PHYSICAL_DESCRIPTOR:
        CallParams -> List = (PCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetPhysicalDescriptor(CallParams -> DeviceHandle,
                                                                   CallParams -> List,
                                                                   CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);

    case HIDD_GET_MANUFACTURER_STRING:
        
        CallParams -> List = (PWCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetManufacturerString(CallParams -> DeviceHandle,
                                                                   CallParams -> List,
                                                                   CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);

    case HIDD_GET_PRODUCT_STRING:
        CallParams -> List = (PWCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetProductString(CallParams -> DeviceHandle,
                                                             CallParams -> List,
                                                             CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);

    case HIDP_GET_EXTENDED_ATTRIBUTES:
        CallParams -> List = (PWCHAR) malloc (CallParams -> ListLength);
        if (NULL != CallParams -> List )
        {
            status = pfnHidP_GetExtendedAttributes(CallParams -> ReportType,
                                                  (USHORT) CallParams -> Index,
                                                   CallParams -> Ppd,
                                                   CallParams -> List,
                                                   &CallParams -> ListLength);

            CallStatus -> IsHidError = (HIDP_STATUS_SUCCESS != status);
            CallStatus -> HidErrorCode = status;
        }
        return (NULL != CallParams -> List);
        
    case HIDD_GET_INDEXED_STRING:
        CallParams -> List = (PWCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetIndexedString(CallParams -> DeviceHandle,
                                                              CallParams -> Index,
                                                              CallParams -> List,
                                                              CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);
        
    case HIDD_GET_SERIAL_NUMBER_STRING:
        CallParams -> List = (PWCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetSerialNumberString(CallParams -> DeviceHandle,
                                                                   CallParams -> List,
                                                                   CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);

    case HIDD_GET_MS_GENRE_DESCRIPTOR:
        CallParams -> List = (PCHAR) malloc (CallParams -> ListLength);

        if (NULL != CallParams -> List ) 
        {
            CallStatus -> IsHidError = !HidD_GetMsGenreDescriptor(CallParams -> DeviceHandle,
                                                                  CallParams -> List,
                                                                  CallParams -> ListLength);
        }
        return (NULL != CallParams -> List);

    case HIDP_GET_BUTTON_CAPS:
        size = CallParams -> ListLength * sizeof(HIDP_BUTTON_CAPS);

        CallParams -> List = malloc(size);

        if (NULL != CallParams -> List) 
        {
            status = HidP_GetButtonCaps(CallParams -> ReportType,
                                        CallParams -> List,
                                        (PUSHORT) &CallParams -> ListLength,
                                        CallParams -> Ppd);

            CallStatus -> IsHidError = (HIDP_STATUS_SUCCESS != status);
            CallStatus -> HidErrorCode = status;
        }
        return (NULL != CallParams -> List);

    case HIDP_GET_BUTTONS:

        CallParams -> ListLength = HidP_MaxUsageListLength(CallParams -> ReportType,
                                                           CallParams -> UsagePage,
                                                           CallParams -> Ppd);

        CallParams -> List = malloc(CallParams -> ListLength * sizeof(USAGE));

        if (NULL != CallParams -> List) 
        {