usbccgp.h File Reference

#include <wdm.h>
#include <hubbusif.h>
#include <usbbusif.h>
#include <usbdlib.h>
#include <stdio.h>

Include dependency graph for usbccgp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	COMMON_DEVICE_EXTENSION
struct	FDO_DEVICE_EXTENSION
struct	PDO_DEVICE_EXTENSION

Macros
#define	USBCCPG_TAG   'cbsu'

Typedefs
typedef struct COMMON_DEVICE_EXTENSION *	PCOMMON_DEVICE_EXTENSION
typedef struct FDO_DEVICE_EXTENSION *	PFDO_DEVICE_EXTENSION
typedef struct PDO_DEVICE_EXTENSION *	PPDO_DEVICE_EXTENSION

Functions
VOID	DumpConfigurationDescriptor (IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor)
NTSTATUS	USBCCGP_GetDescriptors (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	USBCCGP_SelectConfiguration (IN PDEVICE_OBJECT DeviceObject, IN PFDO_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	USBCCGP_GetDescriptor (IN PDEVICE_OBJECT DeviceObject, IN UCHAR DescriptorType, IN ULONG DescriptorLength, IN UCHAR DescriptorIndex, IN LANGID LanguageId, OUT PVOID *OutDescriptor)
NTSTATUS NTAPI	USBCCGP_GetStringDescriptor (IN PDEVICE_OBJECT DeviceObject, IN ULONG DescriptorLength, IN UCHAR DescriptorIndex, IN LANGID LanguageId, OUT PVOID *OutDescriptor)
ULONG	CountInterfaceDescriptors (IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor)
NTSTATUS	AllocateInterfaceDescriptorsArray (IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, OUT PUSB_INTERFACE_DESCRIPTOR **OutArray)
NTSTATUS	USBCCGP_SyncUrbRequest (IN PDEVICE_OBJECT DeviceObject, OUT PURB UrbRequest)
PVOID	AllocateItem (IN POOL_TYPE PoolType, IN ULONG ItemSize)
VOID	FreeItem (IN PVOID Item)
VOID	DumpFunctionDescriptor (IN PUSBC_FUNCTION_DESCRIPTOR FunctionDescriptor, IN ULONG FunctionDescriptorCount)
NTSTATUS	FDO_Dispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	PDO_Dispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	USBCCGP_QueryInterface (IN PDEVICE_OBJECT DeviceObject, OUT PUSBC_DEVICE_CONFIGURATION_INTERFACE_V1 BusInterface)
NTSTATUS	USBCCGP_EnumerateFunctions (IN PDEVICE_OBJECT DeviceObject)

Macro Definition Documentation

USBCCPG_TAG

#define USBCCPG_TAG   'cbsu'

Definition at line 39 of file usbccgp.h.

Typedef Documentation

PCOMMON_DEVICE_EXTENSION

typedef struct COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION

PFDO_DEVICE_EXTENSION

typedef struct FDO_DEVICE_EXTENSION * PFDO_DEVICE_EXTENSION

PPDO_DEVICE_EXTENSION

typedef struct PDO_DEVICE_EXTENSION * PPDO_DEVICE_EXTENSION

Function Documentation

AllocateInterfaceDescriptorsArray()

NTSTATUS AllocateInterfaceDescriptorsArray	(	IN PUSB_CONFIGURATION_DESCRIPTOR	ConfigurationDescriptor,
		OUT PUSB_INTERFACE_DESCRIPTOR **	OutArray
	)

Definition at line 227 of file descriptor.c.

{
    PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
    ULONG Count = 0;
    PUSB_INTERFACE_DESCRIPTOR *Array;
 
    //
    // allocate array
    //
    Array = AllocateItem(NonPagedPool, sizeof(PUSB_INTERFACE_DESCRIPTOR) * ConfigurationDescriptor->bNumInterfaces);
    if (!Array)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    //
    // enumerate all interfaces
    //
    Count = 0;
    do
    {
        //
        // find next descriptor
        //
        InterfaceDescriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, Count, 0, -1, -1, -1);
        if (!InterfaceDescriptor)
            break;
 
        //
        // store descriptor
        //
        Array[Count] = InterfaceDescriptor;
        Count++;
 
    }while(TRUE);
 
    //
    // store result
    //
    *OutArray = Array;
 
    //
    // done
    //
    return STATUS_SUCCESS;
}

Referenced by USBCCGP_EnumWithAudioLegacy().

AllocateItem()

PVOID AllocateItem	(	IN POOL_TYPE	PoolType,
		IN ULONG	ItemSize
	)

Definition at line 29 of file misc.c.

{
    return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_KS);
}

CountInterfaceDescriptors()

ULONG CountInterfaceDescriptors

(

IN PUSB_CONFIGURATION_DESCRIPTOR

ConfigurationDescriptor

)

DumpConfigurationDescriptor()

VOID DumpConfigurationDescriptor

(

IN PUSB_CONFIGURATION_DESCRIPTOR

ConfigurationDescriptor

)

DumpFunctionDescriptor()

VOID DumpFunctionDescriptor	(	IN PUSBC_FUNCTION_DESCRIPTOR	FunctionDescriptor,
		IN ULONG	FunctionDescriptorCount
	)

Definition at line 111 of file misc.c.

{
    ULONG Index, SubIndex;
 
    DPRINT("FunctionCount %lu\n", FunctionDescriptorCount);
    for (Index = 0; Index < FunctionDescriptorCount; Index++)
    {
        DPRINT("Function %lu\n", Index);
        DPRINT("FunctionNumber %lu\n", FunctionDescriptor[Index].FunctionNumber);
        DPRINT("HardwareId %S\n", FunctionDescriptor[Index].HardwareId.Buffer);
        DPRINT("CompatibleId %S\n", FunctionDescriptor[Index].CompatibleId.Buffer);
        DPRINT("FunctionDescription %wZ\n", &FunctionDescriptor[Index].FunctionDescription);
        DPRINT("NumInterfaces %lu\n", FunctionDescriptor[Index].NumberOfInterfaces);
 
        for(SubIndex = 0; SubIndex < FunctionDescriptor[Index].NumberOfInterfaces; SubIndex++)
        {
            DPRINT(" Index %lu Interface %p\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]);
            DPRINT(" Index %lu Interface InterfaceNumber %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bInterfaceNumber);
            DPRINT(" Index %lu Interface Alternate %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bAlternateSetting );
            DPRINT(" Index %lu bLength %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bLength);
            DPRINT(" Index %lu bDescriptorType %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bDescriptorType);
            DPRINT(" Index %lu bInterfaceNumber %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bInterfaceNumber);
            DPRINT(" Index %lu bAlternateSetting %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bAlternateSetting);
            DPRINT(" Index %lu bNumEndpoints %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bNumEndpoints);
            DPRINT(" Index %lu bInterfaceClass %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bInterfaceClass);
            DPRINT(" Index %lu bInterfaceSubClass %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bInterfaceSubClass);
            DPRINT(" Index %lu bInterfaceProtocol %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->bInterfaceProtocol);
            DPRINT(" Index %lu iInterface %x\n", SubIndex, FunctionDescriptor[Index].InterfaceDescriptorList[SubIndex]->iInterface);
        }
    }
}

Referenced by FDO_StartDevice().

FDO_Dispatch()

NTSTATUS FDO_Dispatch	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 633 of file fdo.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    /* Get device extension */
    FDODeviceExtension = DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    /* Get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch(IoStack->MajorFunction)
    {
        case IRP_MJ_PNP:
            return FDO_HandlePnp(DeviceObject, Irp);
        case IRP_MJ_INTERNAL_DEVICE_CONTROL:
            return FDO_HandleInternalDeviceControl(DeviceObject, Irp);
        case IRP_MJ_POWER:
            PoStartNextPowerIrp(Irp);
            IoSkipCurrentIrpStackLocation(Irp);
            return PoCallDriver(FDODeviceExtension->NextDeviceObject, Irp);
        case IRP_MJ_SYSTEM_CONTROL:
            return FDO_HandleSystemControl(DeviceObject, Irp);
        default:
            DPRINT1("FDO_Dispatch Function %x not implemented\n", IoStack->MajorFunction);
            ASSERT(FALSE);
            Status = Irp->IoStatus.Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
    }
 
}

Referenced by USBCCGP_Dispatch().

FreeItem()

VOID FreeItem

(

IN PVOID

Item

)

Definition at line 37 of file misc.c.

{
    ExFreePoolWithTag(Item, TAG_KS);
}

PDO_Dispatch()

NTSTATUS PDO_Dispatch	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 1125 of file pdo.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    switch(IoStack->MajorFunction)
    {
        case IRP_MJ_PNP:
            return PDO_HandlePnp(DeviceObject, Irp);
        case IRP_MJ_INTERNAL_DEVICE_CONTROL:
            return PDO_HandleInternalDeviceControl(DeviceObject, Irp);
        case IRP_MJ_POWER:
            return PDO_HandlePower(DeviceObject, Irp);
        default:
            DPRINT1("PDO_Dispatch Function %x not implemented\n", IoStack->MajorFunction);
            Status = Irp->IoStatus.Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return Status;
    }
}

Referenced by USBCCGP_Dispatch().

USBCCGP_EnumerateFunctions()

NTSTATUS USBCCGP_EnumerateFunctions

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 829 of file function.c.

{
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION FDODeviceExtension;
 
    //
    // get device extension
    //
    FDODeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ASSERT(FDODeviceExtension->Common.IsFDO);
 
    //
    // first try with filter driver
    //
    Status = USBCCGP_CustomEnumWithInterface(DeviceObject);
    if (NT_SUCCESS(Status))
    {
        //
        // succeeded
        //
        return Status;
    }
 
    //
    // enumerate functions with interface association descriptor
    //
    Status = USBCCGP_EnumWithAssociationDescriptor(DeviceObject);
    if (NT_SUCCESS(Status))
    {
        //
        // succeeded
        //
        return Status;
    }
 
#if 0
    //
    // try with union function descriptors
    //
    Status = USBCCGP_EnumWithUnionFunctionDescriptors(DeviceObject);
    if (NT_SUCCESS(Status))
    {
        //
        // succeeded
        //
        return Status;
    }
#endif
 
    //
    // try with legacy audio methods
    //
    Status = USBCCGP_EnumWithAudioLegacy(DeviceObject);
    if (NT_SUCCESS(Status))
    {
        //
        // succeeded
        //
        return Status;
    }
 
    //
    // try with legacy enumeration
    //
    return USBCCGP_LegacyEnum(DeviceObject);
}

Referenced by FDO_StartDevice().

USBCCGP_GetDescriptor()

NTSTATUS NTAPI USBCCGP_GetDescriptor	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	DescriptorType,
		IN ULONG	DescriptorLength,
		IN UCHAR	DescriptorIndex,
		IN LANGID	LanguageId,
		OUT PVOID *	OutDescriptor
	)

Definition at line 19 of file descriptor.c.

{
    PURB Urb;
    NTSTATUS Status;
    PVOID Descriptor;
 
    //
    // sanity checks
    //
    ASSERT(DeviceObject);
    ASSERT(OutDescriptor);
    ASSERT(DescriptorLength);
 
    //
    // first allocate descriptor buffer
    //
    Descriptor = AllocateItem(NonPagedPool, DescriptorLength);
    if (!Descriptor)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // allocate urb
    //
    Urb = (PURB) AllocateItem(NonPagedPool, sizeof(URB));
    if (!Urb)
    {
        //
        // no memory
        //
        FreeItem(Descriptor);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // initialize urb
    //
    UsbBuildGetDescriptorRequest(Urb,
                                 sizeof(Urb->UrbControlDescriptorRequest),
                                 DescriptorType,
                                 DescriptorIndex,
                                 LanguageId,
                                 Descriptor,
                                 NULL,
                                 DescriptorLength,
                                 NULL);
 
    //
    // submit urb
    //
    Status = USBCCGP_SyncUrbRequest(DeviceObject, Urb);
 
    //
    // free urb
    //
    FreeItem(Urb);
 
    if (NT_SUCCESS(Status))
    {
        //
        // store result
        //
        *OutDescriptor = Descriptor;
    }
 
    //
    // done
    //
    return Status;
}

Referenced by PDO_HandleInternalDeviceControl(), USBCCGP_GetDescriptors(), and USBCCGP_GetStringDescriptor().

USBCCGP_GetDescriptors()

NTSTATUS USBCCGP_GetDescriptors

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 160 of file descriptor.c.

{
    NTSTATUS Status;
    PFDO_DEVICE_EXTENSION DeviceExtension;
    USHORT DescriptorLength;
 
    //
    // get device extension
    //
    DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
     //
     // first get device descriptor
     //
     Status = USBCCGP_GetDescriptor(DeviceExtension->NextDeviceObject, USB_DEVICE_DESCRIPTOR_TYPE, sizeof(USB_DEVICE_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->DeviceDescriptor);
     if (!NT_SUCCESS(Status))
     {
         //
         // failed to get device descriptor
         //
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     //
     // now get basic configuration descriptor
     //
     Status = USBCCGP_GetDescriptor(DeviceExtension->NextDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, sizeof(USB_CONFIGURATION_DESCRIPTOR), 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         //
         // failed to get configuration descriptor
         //
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
 
     //
     // backup length
     //
     DescriptorLength = DeviceExtension->ConfigurationDescriptor->wTotalLength;
 
     //
     // release basic descriptor
     //
     FreeItem(DeviceExtension->ConfigurationDescriptor);
     DeviceExtension->ConfigurationDescriptor = NULL;
 
     //
     // allocate full descriptor
     //
     Status = USBCCGP_GetDescriptor(DeviceExtension->NextDeviceObject, USB_CONFIGURATION_DESCRIPTOR_TYPE, DescriptorLength, 0, 0, (PVOID*)&DeviceExtension->ConfigurationDescriptor);
     if (!NT_SUCCESS(Status))
     {
         //
         // failed to get configuration descriptor
         //
         FreeItem(DeviceExtension->DeviceDescriptor);
         DeviceExtension->DeviceDescriptor = NULL;
         return Status;
     }
     return Status;
}

Referenced by FDO_StartDevice().

USBCCGP_GetStringDescriptor()

NTSTATUS NTAPI USBCCGP_GetStringDescriptor	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	DescriptorLength,
		IN UCHAR	DescriptorIndex,
		IN LANGID	LanguageId,
		OUT PVOID *	OutDescriptor
	)

Definition at line 102 of file descriptor.c.

{
    NTSTATUS Status;
    PUSB_STRING_DESCRIPTOR StringDescriptor;
    ULONG Size;
    PVOID Buffer;
 
    // retrieve descriptor
    Status = USBCCGP_GetDescriptor(DeviceObject, USB_STRING_DESCRIPTOR_TYPE, DescriptorLength, DescriptorIndex, LanguageId, OutDescriptor);
    if (!NT_SUCCESS(Status))
    {
        // failed
        return Status;
    }
 
    // get descriptor structure
    StringDescriptor = (PUSB_STRING_DESCRIPTOR)*OutDescriptor;
 
    // sanity check
    ASSERT(StringDescriptor->bLength < DescriptorLength - 2);
 
    if (StringDescriptor->bLength == 2)
    {
        // invalid descriptor
        FreeItem(StringDescriptor);
        return STATUS_DEVICE_DATA_ERROR;
    }
 
    // calculate size
    Size = StringDescriptor->bLength + sizeof(WCHAR);
 
    // allocate buffer
    Buffer = AllocateItem(NonPagedPool, Size);
    if (!Buffer)
    {
        // no memory
        FreeItem(StringDescriptor);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // copy result
    RtlCopyMemory(Buffer, StringDescriptor->bString, Size - FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString));
 
    // free buffer
    FreeItem(StringDescriptor);
 
    // store result
    *OutDescriptor = (PVOID)Buffer;
    return STATUS_SUCCESS;
}

Referenced by USBCCG_InitIdsWithInterfaceDescriptor(), and USBCCGP_InitFunctionDescriptor().

USBCCGP_QueryInterface()

NTSTATUS USBCCGP_QueryInterface	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PUSBC_DEVICE_CONFIGURATION_INTERFACE_V1	BusInterface
	)

Definition at line 18 of file function.c.

{
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    PIO_STACK_LOCATION Stack;
 
    /* Sanity checks */
    ASSERT(DeviceObject);
 
    /* Initialize event */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Init interface */
    RtlZeroMemory(BusInterface, sizeof(USBC_DEVICE_CONFIGURATION_INTERFACE_V1));
    BusInterface->Version = USBC_DEVICE_CONFIGURATION_INTERFACE_VERSION_1;
    BusInterface->Size = sizeof(USBC_DEVICE_CONFIGURATION_INTERFACE_V1);
 
    /* Create irp */
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
 
    //
    // was irp built
    //
    if (Irp == NULL)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // initialize request
    //
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
    Stack->Parameters.QueryInterface.InterfaceType = (LPGUID)&USB_BUS_INTERFACE_USBC_CONFIGURATION_GUID;
    Stack->Parameters.QueryInterface.Version = 2;
    Stack->Parameters.QueryInterface.Interface = (PINTERFACE)&BusInterface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 
    //
    // call driver
    //
    Status = IoCallDriver(DeviceObject, Irp);
 
    //
    // did operation complete
    //
    if (Status == STATUS_PENDING)
    {
        //
        // wait for completion
        //
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 
        //
        // collect status
        //
        Status = IoStatus.Status;
    }
 
    return Status;
}

Referenced by FDO_StartDevice().

USBCCGP_SelectConfiguration()

NTSTATUS USBCCGP_SelectConfiguration	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PFDO_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 467 of file descriptor.c.

{
    PUSBD_INTERFACE_INFORMATION InterfaceInformation;
    NTSTATUS Status;
    PURB Urb;
    ULONG Index;
 
    //
    // now scan configuration descriptors
    //
    Status = USBCCGP_ScanConfigurationDescriptor(DeviceExtension, DeviceExtension->ConfigurationDescriptor);
    if (!NT_SUCCESS(Status))
    {
        //
        // failed to scan
        //
        return Status;
    }
 
    //
    // now allocate the urb
    //
    Urb = USBD_CreateConfigurationRequestEx(DeviceExtension->ConfigurationDescriptor, DeviceExtension->InterfaceList);
    if (!Urb)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // submit urb
    //
    Status = USBCCGP_SyncUrbRequest(DeviceExtension->NextDeviceObject, Urb);
    if (!NT_SUCCESS(Status))
    {
        //
        // failed to set configuration
        //
        DPRINT1("USBCCGP_SyncUrbRequest failed to set interface %x\n", Status);
        ExFreePool(Urb);
        return Status;
    }
 
    //
    // get interface information
    //
    InterfaceInformation = &Urb->UrbSelectConfiguration.Interface;
    for(Index = 0; Index < DeviceExtension->InterfaceListCount; Index++)
    {
        //
        // allocate buffer to store interface information
        //
        DeviceExtension->InterfaceList[Index].Interface = AllocateItem(NonPagedPool, InterfaceInformation->Length);
        if (!DeviceExtension->InterfaceList[Index].Interface)
        {
            //
            // no memory
            //
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        //
        // copy interface information
        //
        RtlCopyMemory(DeviceExtension->InterfaceList[Index].Interface, InterfaceInformation, InterfaceInformation->Length);
 
        //
        // move to next interface
        //
        InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)((ULONG_PTR)InterfaceInformation + InterfaceInformation->Length);
    }
 
 
    //
    // store pipe handle
    //
    DeviceExtension->ConfigurationHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
 
    //
    // free interface list & urb
    //
    ExFreePool(Urb);
 
    //
    // done
    //
    return Status;
}

Referenced by FDO_StartDevice().

USBCCGP_SyncUrbRequest()

NTSTATUS USBCCGP_SyncUrbRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PURB	UrbRequest
	)

Definition at line 35 of file misc.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    KEVENT Event;
    NTSTATUS Status;
 
    /* Allocate irp */
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (!Irp)
    {
        /* No memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Initialize event */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Get next stack location */
    IoStack = IoGetNextIrpStackLocation(Irp);
 
    /* Initialize stack location */
    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;
    IoStack->Parameters.Others.Argument1 = (PVOID)UrbRequest;
    IoStack->Parameters.DeviceIoControl.InputBufferLength = UrbRequest->UrbHeader.Length;
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    /* Setup completion routine */
    IoSetCompletionRoutine(Irp,
                           USBSTOR_SyncForwardIrpCompletionRoutine,
                           &Event,
                           TRUE,
                           TRUE,
                           TRUE);
 
    /* Call driver */
    Status = IoCallDriver(DeviceObject, Irp);
 
    /* Check if request is pending */
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 
        /* Update status */
        Status = Irp->IoStatus.Status;
    }
 
    /* Free irp */
    IoFreeIrp(Irp);
 
    /* Done */
    return Status;
}

Referenced by FDO_CloseConfiguration(), USBCCGP_GetDescriptor(), USBCCGP_PDOSelectConfiguration(), USBCCGP_SelectConfiguration(), and USBCCGP_SelectInterface().