usbfx2lk_usb.cpp

USBFX2LK WDM drive for OSR s USB FX2 Learning Kit

                          sizeof(BAR_GRAPH_STATE),
                          NULL);

    status = SubmitIrpAndUrbAsync(DevExt, Irp, setBarGraphUrb);

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("SetBarGraphState: Exit\n"));

    //
    // Return whatever status SubmitIrpAndUrbAsync returned
    //
    return status;

}


///////////////////////////////////////////////////////////////////////////////
//
// SubmitGetSevenSegmentState
//
//  This routine gets or sets the state of the 7 segment display  on the board
//
//
//  INPUTS:
//
//      DevExt  -  One of our device extensions
//
//      Irp     -  Pointer to an IOCTL_OSRUSBFX2_GET_7_SEGMENT_DISPLAY
//                  IRP. User's buffer has already been validated
//
//  OUTPUTS:
//
//      None.
//
//  RETURNS:
//
//      An appropriate NTSTATUS value
//
//  IRQL:
//
//      IRQL == PASSIVE_LEVEL
//
//  CONTEXT:
//
//      User context
//
//  NOTES:
//
//      Routine assumes that the output data buffer in the IRP is
//      valid for this request. Must be checked by caller.
//
//      Called relinquishes ownership of the IRP when calling this
//      routine, IRP must NOT be touched by caller after this routine
//      returns
//
/////////////////////////////////////////////////////////////////////////////
NTSTATUS SubmitGetSevenSegmentState(PUSBFX2LK_EXT DevExt, PIRP Irp)
{
    NTSTATUS status;
    PURB getSevenSegmentUrb;

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetSevenSegmentState: Enter\n"));

    //
    // Allocate our get seven segment URB
    //
    getSevenSegmentUrb = 
        (PURB)ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                                    'SGxF');

    if (!getSevenSegmentUrb) {

        OsrTracePrint(TRACE_LEVEL_ERROR,OSRDBG_USB,
                ("GetSevenSegmentState: Failed to allocate memory, Exiting.\n"));

        //
        // We need to complete the IRP ourselves
        //
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_INSUFFICIENT_RESOURCES;

    }

    RtlZeroMemory(getSevenSegmentUrb,
                  sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));


    //
    // Build the vendor request with the appropriate 
    //  flags and command
    //
    //  We're getting data from the device,
    //  to we need to set the USBD_TRANSFER_DIRECTION_IN flag
    // 
    UsbBuildVendorRequest(getSevenSegmentUrb,
                          URB_FUNCTION_VENDOR_DEVICE,
                          sizeof(struct  _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                          USBD_SHORT_TRANSFER_OK | USBD_TRANSFER_DIRECTION_IN,
                          0,
                          USBFX2LK_READ_7SEGMENT_DISPLAY,
                          0,
                          0,
                          Irp->AssociatedIrp.SystemBuffer,
                          NULL,
                          sizeof(UCHAR),
                          NULL);

    status = SubmitIrpAndUrbAsync(DevExt, Irp, getSevenSegmentUrb);

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetSevenSegmentState: Exit\n"));

    //
    // Return whatever status SubmitIrpAndUrbAsync returned
    //
    return status;

}


///////////////////////////////////////////////////////////////////////////////
//
// SubmitSetSevenSegmentState
//
//  This routine sets the state of the 7 segment display  on the board
//
//  INPUTS:
//
//      DevExt  -  One of our device extensions
//
//      Irp     -  Pointer to an IOCTL_OSRUSBFX2_SET_7_SEGMENT_DISPLAY
//                  IRP. User's buffer has already been validated
//
//  OUTPUTS:
//
//      None.
//
//  RETURNS:
//
//      An appropriate NTSTATUS value
//
//  IRQL:
//
//      IRQL == PASSIVE_LEVEL
//
//  CONTEXT:
//
//      User context
//
//  NOTES:
//
//      Routine assumes that the output data buffer in the IRP is
//      valid for this request. Must be checked by caller.
//
//      Called relinquishes ownership of the IRP when calling this
//      routine, IRP must NOT be touched by caller after this routine
//      returns
//
///////////////////////////////////////////////////////////////////////////////
NTSTATUS SubmitSetSevenSegmentState(PUSBFX2LK_EXT DevExt, PIRP Irp)
{
    NTSTATUS status;
    PURB setSevenSegmentUrb;

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("SetSevenSegmentState: Enter\n"));

    //
    // Allocate our set seven segment URB
    //
    setSevenSegmentUrb = 
        (PURB)ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                                    'SSxF');

    if (!setSevenSegmentUrb) {

        OsrTracePrint(TRACE_LEVEL_ERROR,OSRDBG_USB,
                ("SetSevenSegmentState: Failed to allocate memory, Exiting.\n"));

        //
        // We need to complete the IRP ourselves
        //
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_INSUFFICIENT_RESOURCES;

    }

    RtlZeroMemory(setSevenSegmentUrb,
                  sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));


    //
    // Build the vendor request with the appropriate 
    //  flags and command
    //
    //  We're getting data from the device,
    //  to we need to set the USBD_TRANSFER_DIRECTION_IN flag
    // 
    UsbBuildVendorRequest(setSevenSegmentUrb,
                          URB_FUNCTION_VENDOR_DEVICE,
                          sizeof(struct  _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                          USBD_SHORT_TRANSFER_OK,
                          0,
                          USBFX2LK_SET_7SEGMENT_DISPLAY,
                          0,
                          0,
                          Irp->AssociatedIrp.SystemBuffer,
                          NULL,
                          sizeof(UCHAR),
                          NULL);

    status = SubmitIrpAndUrbAsync(DevExt, Irp, setSevenSegmentUrb);

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("SetSevenSegmentState: Exit\n"));

    //
    // Return whatever status SubmitIrpAndUrbAsync returned
    //
    return status;

}


///////////////////////////////////////////////////////////////////////////////
//
// SubmitGetSwitchState
//
//  This routine gets the state of the switches on the board
//
//  INPUTS:
//
//      DevExt  -  One of our device extensions
//
//      Irp     -  Pointer to an IOCTL_OSRUSBFX2_READ_SWITCHES
//                  IRP. User's buffer has already been validated
//
//  OUTPUTS:
//
//      None.
//
//  RETURNS:
//
//      An appropriate NTSTATUS value
//
//  IRQL:
//
//      IRQL == PASSIVE_LEVEL
//
//  CONTEXT:
//
//      User context
//
//  NOTES:
//
//      Routine assumes that the output data buffer in the IRP is
//      valid for this request. Must be checked by caller.
//
//      Called relinquishes ownership of the IRP when calling this
//      routine, IRP must NOT be touched by caller after this routine
//      returns
//
///////////////////////////////////////////////////////////////////////////////
NTSTATUS SubmitGetSwitchState(PUSBFX2LK_EXT DevExt, PIRP Irp)
{

    NTSTATUS status;
    PURB getSwitchUrb;

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetSwitchState: Enter\n"));

    //
    // Allocate our get seven segment URB
    //
    getSwitchUrb = 
        (PURB)ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                                    'WGxF');

    if (!getSwitchUrb) {

        OsrTracePrint(TRACE_LEVEL_ERROR,OSRDBG_USB,
                ("GetSwitchState: Failed to allocate memory, Exiting.\n"));

        //
        // We need to complete the IRP ourselves
        //
        Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return STATUS_INSUFFICIENT_RESOURCES;

    }

    RtlZeroMemory(getSwitchUrb,
                  sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));


    //
    // Build the vendor request with the appropriate 
    //  flags and command
    //
    //  We're getting data from the device,
    //  to we need to set the USBD_TRANSFER_DIRECTION_IN flag
    // 
    UsbBuildVendorRequest(getSwitchUrb,
                          URB_FUNCTION_VENDOR_DEVICE,
                          sizeof(struct  _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
                          USBD_SHORT_TRANSFER_OK | USBD_TRANSFER_DIRECTION_IN,
                          0,
                          USBFX2LK_READ_SWITCHES,
                          0,
                          0,
                          Irp->AssociatedIrp.SystemBuffer,
                          NULL,
                          sizeof(SWITCH_STATE),
                          NULL);

    status = SubmitIrpAndUrbAsync(DevExt, Irp, getSwitchUrb);

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetSwitchState: Exit\n"));

    //
    // Return whatever status SubmitIrpAndUrbAsync returned
    //
    return status;
}


///////////////////////////////////////////////////////////////////////////////
//
// GetDeviceDescriptor
//
//      Returns the USB device descriptor for the device
//
//  INPUTS:
//
//      DevExt  -  One of our device extensions
//
//  OUTPUTS:
//
//      DeviceDescriptor - If successful, contains the USB device descriptor
//                         for the device
//
//      BytesTransferred - The actual amount of data transferred by this 
//                         operation
//
//  RETURNS:
//
//      An appropriate NTSTATUS value
//
//  IRQL:
//
//      IRQL == PASSIVE_LEVEL
//
//  CONTEXT:
//
//      User context
//
//  NOTES:
//
///////////////////////////////////////////////////////////////////////////////
NTSTATUS GetDeviceDescriptor(PUSBFX2LK_EXT DevExt, PUSB_DEVICE_DESCRIPTOR DeviceDescriptor,
                             PULONG BytesTransferred)
{
    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetDeviceDescriptor: Enter\n"));

    //
    // We've already saved the device descriptor away 
    //  so we just need to copy it out of the device 
    //  extension
    //
    RtlCopyMemory(DeviceDescriptor, DevExt->UsbDeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));

    //
    // Indicate the amount of data that was actually 
    //  transferred
    //
    *BytesTransferred = sizeof(USB_DEVICE_DESCRIPTOR);

    OsrTracePrint(TRACE_LEVEL_VERBOSE,OSRDBG_USB,("GetDeviceDescriptor: Exit\n"));

    return STATUS_SUCCESS;

}

///////////////////////////////////////////////////////////////////////////////
//
// GetConfigurationDescriptor
//
//      Returns the USB configuration descriptor for the device
//
//  INPUTS:
//
//      DevExt  -  One of our device extensions
//
//  OUTPUTS:
//
//      ConfigDescriptor - If successful, contains the USB configuration descriptor
//                         for the device
//
//      BytesTransferred - The actual amount of data transferred by this 
//                         operation
//
//  RETURNS:
//
//      An appropriate NTSTATUS value
//
//  IRQL:
//
//      IRQL == PASSIVE_LEVEL
//
//  CONTEXT:
//
//      User context
//
//  NOTES:
//
//////////////////////////////////////