usbhub.c File Reference

#include "usbhub.h"
#include <debug.h>
#include "dbg_uhub.h"
#include <ntddstor.h>

Include dependency graph for usbhub.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	NDEBUG_USBHUB_SCE
#define	NDEBUG_USBHUB_PNP

Functions
NTSTATUS NTAPI	USBH_Wait (IN ULONG Milliseconds)
NTSTATUS NTAPI	USBH_GetConfigValue (IN PWSTR ValueName, IN ULONG ValueType, IN PVOID ValueData, IN ULONG ValueLength, IN PVOID Context, IN PVOID EntryContext)
VOID NTAPI	USBH_CompleteIrp (IN PIRP Irp, IN NTSTATUS CompleteStatus)
NTSTATUS NTAPI	USBH_PassIrp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	USBH_SyncIrpComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
BOOLEAN NTAPI	IsBitSet (IN PUCHAR BitMapAddress, IN USHORT Bit)
PUSBHUB_PORT_PDO_EXTENSION NTAPI	PdoExt (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	USBH_WriteFailReasonID (IN PDEVICE_OBJECT DeviceObject, IN ULONG FailReason)
VOID NTAPI	USBH_UrbTimeoutDPC (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
NTSTATUS NTAPI	USBH_SetPdoRegistryParameter (IN PDEVICE_OBJECT DeviceObject, IN PCWSTR ValueName, IN PVOID Data, IN ULONG DataSize, IN ULONG Type, IN ULONG DevInstKeyType)
NTSTATUS NTAPI	USBH_SyncSubmitUrb (IN PDEVICE_OBJECT DeviceObject, IN PURB Urb)
NTSTATUS NTAPI	USBH_FdoSyncSubmitUrb (IN PDEVICE_OBJECT FdoDevice, IN PURB Urb)
NTSTATUS NTAPI	USBH_Transact (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID TransferBuffer, IN ULONG BufferLen, IN BOOLEAN IsDeviceToHost, IN USHORT Function, IN BM_REQUEST_TYPE RequestType, IN UCHAR Request, IN USHORT RequestValue, IN USHORT RequestIndex)
NTSTATUS NTAPI	USBH_SyncResetPort (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
NTSTATUS NTAPI	USBH_GetDeviceType (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, OUT USB_DEVICE_TYPE *OutDeviceType)
NTSTATUS NTAPI	USBHUB_GetExtendedHubInfo (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_EXTHUB_INFORMATION_0 HubInfoBuffer)
PUSBHUB_FDO_EXTENSION NTAPI	USBH_GetRootHubExtension (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBH_SyncGetRootHubPdo (IN PDEVICE_OBJECT DeviceObject, IN OUT PDEVICE_OBJECT *OutPdo1, IN OUT PDEVICE_OBJECT *OutPdo2)
NTSTATUS NTAPI	USBH_SyncGetHubCount (IN PDEVICE_OBJECT DeviceObject, IN OUT PULONG OutHubCount)
PUSB_DEVICE_HANDLE NTAPI	USBH_SyncGetDeviceHandle (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	USBH_GetDeviceDescriptor (IN PDEVICE_OBJECT DeviceObject, IN PUSB_DEVICE_DESCRIPTOR HubDeviceDescriptor)
NTSTATUS NTAPI	USBH_SyncGetDeviceConfigurationDescriptor (IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor, IN ULONG NumberOfBytes, IN PULONG OutLength)
NTSTATUS NTAPI	USBH_GetConfigurationDescriptor (IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR *OutDescriptor)
NTSTATUS NTAPI	USBH_SyncGetHubDescriptor (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBH_SyncGetStringDescriptor (IN PDEVICE_OBJECT DeviceObject, IN UCHAR Index, IN USHORT LanguageId, IN PUSB_STRING_DESCRIPTOR Descriptor, IN ULONG NumberOfBytes, IN PULONG OutLength, IN BOOLEAN IsValidateLength)
NTSTATUS NTAPI	USBH_SyncGetStatus (IN PDEVICE_OBJECT DeviceObject, IN PUSHORT OutStatus, IN USHORT Function, IN USHORT RequestIndex)
NTSTATUS NTAPI	USBH_SyncGetHubStatus (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_HUB_STATUS_AND_CHANGE HubStatus, IN ULONG Length)
NTSTATUS NTAPI	USBH_SyncClearHubStatus (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT RequestValue)
NTSTATUS NTAPI	USBH_SyncGetPortStatus (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN PUSB_PORT_STATUS_AND_CHANGE PortStatus, IN ULONG Length)
NTSTATUS NTAPI	USBH_SyncClearPortStatus (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN USHORT RequestValue)
NTSTATUS NTAPI	USBH_SyncPowerOnPort (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN BOOLEAN IsWait)
NTSTATUS NTAPI	USBH_SyncPowerOnPorts (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBH_SyncDisablePort (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port)
BOOLEAN NTAPI	USBH_HubIsBusPowered (IN PDEVICE_OBJECT DeviceObject, IN PUSB_CONFIGURATION_DESCRIPTOR HubConfigDescriptor)
NTSTATUS NTAPI	USBH_ChangeIndicationAckChangeComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	USBH_ChangeIndicationAckChange (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *Urb, IN USHORT Port, IN USHORT RequestValue)
NTSTATUS NTAPI	USBH_ChangeIndicationProcessChange (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	USBH_ChangeIndicationQueryChange (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp, IN struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *Urb, IN USHORT Port)
VOID NTAPI	USBH_ProcessHubStateChange (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_HUB_STATUS_AND_CHANGE HubStatus)
VOID NTAPI	USBH_ProcessPortStateChange (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN PUSB_PORT_STATUS_AND_CHANGE PortStatus)
NTSTATUS NTAPI	USBH_GetPortStatus (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PULONG PortStatus)
NTSTATUS NTAPI	USBH_EnableParentPort (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBH_ResetInterruptPipe (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBH_ResetHub (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_ChangeIndicationWorker (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID Context)
NTSTATUS NTAPI	USBH_ChangeIndication (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	USBH_SubmitStatusChangeTransfer (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBD_CreateDeviceEx (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE *OutDeviceHandle, IN USB_PORT_STATUS UsbPortStatus, IN USHORT Port)
NTSTATUS NTAPI	USBD_RemoveDeviceEx (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, IN ULONG Flags)
NTSTATUS NTAPI	USBD_InitializeDeviceEx (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_DEVICE_HANDLE DeviceHandle, IN PUCHAR DeviceDescriptorBuffer, IN ULONG DeviceDescriptorBufferLength, IN PUCHAR ConfigDescriptorBuffer, IN ULONG ConfigDescriptorBufferLength)
VOID NTAPI	USBHUB_SetDeviceHandleData (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PDEVICE_OBJECT UsbDevicePdo, IN PVOID DeviceHandle)
VOID NTAPI	USBHUB_FlushAllTransfers (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBD_GetDeviceInformationEx (IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSB_NODE_CONNECTION_INFORMATION_EX Info, IN ULONG Length, IN PUSB_DEVICE_HANDLE DeviceHandle)
NTSTATUS NTAPI	USBD_RestoreDeviceEx (IN PUSBHUB_FDO_EXTENSION HubExtension, IN OUT PUSB_DEVICE_HANDLE OldDeviceHandle, IN OUT PUSB_DEVICE_HANDLE NewDeviceHandle)
NTSTATUS NTAPI	USBH_AllocateWorkItem (PUSBHUB_FDO_EXTENSION HubExtension, PUSBHUB_IO_WORK_ITEM *OutHubIoWorkItem, PUSBHUB_WORKER_ROUTINE WorkerRoutine, SIZE_T BufferLength, PVOID *OutHubWorkItemBuffer, WORK_QUEUE_TYPE Type)
VOID NTAPI	USBH_Worker (IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
VOID NTAPI	USBH_QueueWorkItem (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PUSBHUB_IO_WORK_ITEM HubIoWorkItem)
VOID NTAPI	USBH_FreeWorkItem (IN PUSBHUB_IO_WORK_ITEM HubIoWorkItem)
VOID NTAPI	USBHUB_RootHubCallBack (IN PVOID Context)
NTSTATUS NTAPI	USBD_RegisterRootHubCallBack (IN PUSBHUB_FDO_EXTENSION HubExtension)
NTSTATUS NTAPI	USBD_UnRegisterRootHubCallBack (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_HubSetDWakeCompletion (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
VOID NTAPI	USBH_HubQueuePortIdleIrps (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PLIST_ENTRY IdleList)
VOID NTAPI	USBH_HubCompleteQueuedPortIdleIrps (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PLIST_ENTRY IdleList, IN NTSTATUS NtStatus)
VOID NTAPI	USBH_FlushPortPwrList (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_HubCompletePortIdleIrps (IN PUSBHUB_FDO_EXTENSION HubExtension, IN NTSTATUS NtStatus)
VOID NTAPI	USBH_HubCancelIdleIrp (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP IdleIrp)
BOOLEAN NTAPI	USBH_CheckIdleAbort (IN PUSBHUB_FDO_EXTENSION HubExtension, IN BOOLEAN IsWait, IN BOOLEAN IsExtCheck)
VOID NTAPI	USBH_FdoWaitWakeIrpCompletion (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MinorFunction, IN POWER_STATE PowerState, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatus)
NTSTATUS NTAPI	USBH_FdoSubmitWaitWakeIrp (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_FdoIdleNotificationCallback (IN PVOID Context)
VOID NTAPI	USBH_CompletePortIdleIrpsWorker (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID Context)
VOID NTAPI	USBH_IdleCompletePowerHubWorker (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID Context)
NTSTATUS NTAPI	USBH_FdoIdleNotificationRequestComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	USBH_FdoSubmitIdleRequestIrp (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_CheckHubIdle (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_CheckIdleWorker (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PVOID Context)
VOID NTAPI	USBH_CheckIdleDeferred (IN PUSBHUB_FDO_EXTENSION HubExtension)
VOID NTAPI	USBH_PdoSetCapabilities (IN PUSBHUB_PORT_PDO_EXTENSION PortExtension)
NTSTATUS NTAPI	USBH_ProcessDeviceInformation (IN PUSBHUB_PORT_PDO_EXTENSION PortExtension)
BOOLEAN NTAPI	USBH_CheckDeviceIDUnique (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT idVendor, IN USHORT idProduct, IN PVOID SerialNumber, IN USHORT SN_DescriptorLength)
BOOLEAN NTAPI	USBH_ValidateSerialNumberString (IN PUSHORT SerialNumberString)
NTSTATUS NTAPI	USBH_CheckDeviceLanguage (IN PDEVICE_OBJECT DeviceObject, IN USHORT LanguageId)
NTSTATUS NTAPI	USBH_GetSerialNumberString (IN PDEVICE_OBJECT DeviceObject, IN LPWSTR *OutSerialNumber, IN PUSHORT OutDescriptorLength, IN USHORT LanguageId, IN UCHAR Index)
NTSTATUS NTAPI	USBH_CreateDevice (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN USB_PORT_STATUS UsbPortStatus, IN ULONG IsWait)
NTSTATUS NTAPI	USBH_ResetDevice (IN PUSBHUB_FDO_EXTENSION HubExtension, IN USHORT Port, IN BOOLEAN IsKeepDeviceData, IN BOOLEAN IsWait)
NTSTATUS NTAPI	USBH_PdoDispatch (IN PUSBHUB_PORT_PDO_EXTENSION PortExtension, IN PIRP Irp)
NTSTATUS NTAPI	USBH_FdoDispatch (IN PUSBHUB_FDO_EXTENSION HubExtension, IN PIRP Irp)
NTSTATUS NTAPI	USBH_AddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT LowerPDO)
VOID NTAPI	USBH_DriverUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	USBH_HubDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	USBH_RegQueryGenericUSBDeviceString (PVOID USBDeviceString)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

Variables
PWSTR	GenericUSBDeviceString = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 10 of file usbhub.c.

NDEBUG_USBHUB_PNP

#define NDEBUG_USBHUB_PNP

Definition at line 14 of file usbhub.c.

NDEBUG_USBHUB_SCE

#define NDEBUG_USBHUB_SCE

Definition at line 13 of file usbhub.c.

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 5115 of file usbhub.c.

{
    DPRINT("USBHUB: DriverEntry - %wZ\n", RegistryPath);

    DriverObject->DriverExtension->AddDevice = USBH_AddDevice;
    DriverObject->DriverUnload = USBH_DriverUnload;

    DriverObject->MajorFunction[IRP_MJ_CREATE] = USBH_HubDispatch;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = USBH_HubDispatch;

    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = USBH_HubDispatch;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = USBH_HubDispatch;

    DriverObject->MajorFunction[IRP_MJ_PNP] = USBH_HubDispatch;
    DriverObject->MajorFunction[IRP_MJ_POWER] = USBH_HubDispatch;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = USBH_HubDispatch;

    USBH_RegQueryGenericUSBDeviceString(&GenericUSBDeviceString);

    return STATUS_SUCCESS;
}

IsBitSet()

BOOLEAN NTAPI IsBitSet	(	IN PUCHAR	BitMapAddress,
		IN USHORT	Bit
	)

Definition at line 121 of file usbhub.c.

{
    BOOLEAN IsSet;

    IsSet = (BitMapAddress[Bit / 8] & (1 << (Bit & 7))) != 0;
    DPRINT("IsBitSet: Bit - %lX, IsSet - %x\n", Bit, IsSet);
    return IsSet;
}

Referenced by USBH_ChangeIndication(), and USBH_ChangeIndicationWorker().

PdoExt()

PUSBHUB_PORT_PDO_EXTENSION NTAPI PdoExt

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 133 of file usbhub.c.

{
    PVOID PdoExtension;

    DPRINT("PdoExt: DeviceObject - %p\n", DeviceObject);

    if (DeviceObject)
    {
        PdoExtension = DeviceObject->DeviceExtension;
    }
    else
    {
        PdoExtension = NULL;
    }

    return (PUSBHUB_PORT_PDO_EXTENSION)PdoExtension;
}

Referenced by IsaFdoCreateDeviceIDs(), IsaFdoCreateRequirements(), IsaFdoCreateResources(), IsaPdoPnp(), IsaPdoQueryCapabilities(), IsaPdoQueryDeviceRelations(), IsaPdoQueryId(), IsaPdoQueryResourceRequirements(), IsaPdoQueryResources(), IsaPdoRepeatRequest(), IsaPnpCreateReadPortDO(), IsaPnpCreateReadPortDORequirements(), IsaPnpCreateReadPortDOResources(), IsaPnpFillDeviceRelations(), PcmciaPdoPlugPlay(), PcmciaPdoSetPowerState(), USBH_FdoQueryBusRelations(), USBH_FdoSurpriseRemoveDevice(), and USBH_PdoRemoveDevice().

USBD_CreateDeviceEx()

NTSTATUS NTAPI USBD_CreateDeviceEx	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PUSB_DEVICE_HANDLE *	OutDeviceHandle,
		IN USB_PORT_STATUS	UsbPortStatus,
		IN USHORT	Port
	)

Definition at line 2508 of file usbhub.c.

{
    PUSB_DEVICE_HANDLE HubDeviceHandle;
    PUSB_BUSIFFN_CREATE_USB_DEVICE CreateUsbDevice;

    DPRINT("USBD_CreateDeviceEx: Port - %x, UsbPortStatus - 0x%04X\n",
           Port,
           UsbPortStatus.AsUshort16);

    CreateUsbDevice = HubExtension->BusInterface.CreateUsbDevice;

    if (!CreateUsbDevice)
    {
        return STATUS_NOT_IMPLEMENTED;
    }

    HubDeviceHandle = USBH_SyncGetDeviceHandle(HubExtension->LowerDevice);

    return CreateUsbDevice(HubExtension->BusInterface.BusContext,
                           OutDeviceHandle,
                           HubDeviceHandle,
                           UsbPortStatus.AsUshort16,
                           Port);
}

Referenced by USBH_CreateDevice(), and USBH_ResetDevice().

USBD_GetDeviceInformationEx()

NTSTATUS NTAPI USBD_GetDeviceInformationEx	(	IN PUSBHUB_PORT_PDO_EXTENSION	PortExtension,
		IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PUSB_NODE_CONNECTION_INFORMATION_EX	Info,
		IN ULONG	Length,
		IN PUSB_DEVICE_HANDLE	DeviceHandle
	)

Definition at line 2639 of file usbhub.c.

{
    PUSB_BUSIFFN_GET_DEVICE_INFORMATION QueryDeviceInformation;
    PUSB_DEVICE_INFORMATION_0 DeviceInfo;
    SIZE_T DeviceInfoLength;
    PUSB_NODE_CONNECTION_INFORMATION_EX NodeInfo;
    SIZE_T NodeInfoLength;
    ULONG PipeNumber;
    ULONG dummy;
    NTSTATUS Status;

    DPRINT("USBD_GetDeviceInformationEx ... \n");

    QueryDeviceInformation = HubExtension->BusInterface.QueryDeviceInformation;

    if (!QueryDeviceInformation)
    {
        Status = STATUS_NOT_IMPLEMENTED;
        return Status;
    }

    DeviceInfoLength = sizeof(USB_DEVICE_INFORMATION_0);

    while (TRUE)
    {
        DeviceInfo = ExAllocatePoolWithTag(PagedPool,
                                           DeviceInfoLength,
                                           USB_HUB_TAG);

        if (!DeviceInfo)
        {
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlZeroMemory(DeviceInfo, DeviceInfoLength);

        DeviceInfo->InformationLevel = 0;

        Status = QueryDeviceInformation(HubExtension->BusInterface.BusContext,
                                        DeviceHandle,
                                        DeviceInfo,
                                        DeviceInfoLength,
                                        &dummy);

        if (Status != STATUS_BUFFER_TOO_SMALL)
        {
            break;
        }

        DeviceInfoLength = DeviceInfo->ActualLength;

        ExFreePoolWithTag(DeviceInfo, USB_HUB_TAG);
    }

    NodeInfo = NULL;
    NodeInfoLength = 0;

    if (NT_SUCCESS(Status))
    {
        NodeInfoLength = (sizeof(USB_NODE_CONNECTION_INFORMATION_EX) - sizeof(USB_PIPE_INFO)) +
                         DeviceInfo->NumberOfOpenPipes * sizeof(USB_PIPE_INFO);

        NodeInfo = ExAllocatePoolWithTag(PagedPool, NodeInfoLength, USB_HUB_TAG);

        if (!NodeInfo)
        {
            ExFreePoolWithTag(DeviceInfo, USB_HUB_TAG);
            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlZeroMemory(NodeInfo, NodeInfoLength);

        NodeInfo->ConnectionIndex = Info->ConnectionIndex;

        RtlCopyMemory(&NodeInfo->DeviceDescriptor,
                      &DeviceInfo->DeviceDescriptor,
                      sizeof(USB_DEVICE_DESCRIPTOR));

        NodeInfo->CurrentConfigurationValue = DeviceInfo->CurrentConfigurationValue;
        NodeInfo->Speed = DeviceInfo->DeviceSpeed;
        NodeInfo->DeviceIsHub = PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_HUB_DEVICE;
        NodeInfo->DeviceAddress = DeviceInfo->DeviceAddress;
        NodeInfo->NumberOfOpenPipes = DeviceInfo->NumberOfOpenPipes;
        NodeInfo->ConnectionStatus = Info->ConnectionStatus;

        for (PipeNumber = 0;
             PipeNumber < DeviceInfo->NumberOfOpenPipes;
             PipeNumber++)
        {
            RtlCopyMemory(&NodeInfo->PipeList[PipeNumber],
                          &DeviceInfo->PipeList[PipeNumber],
                          sizeof(USB_PIPE_INFO));
        }
    }

    ExFreePoolWithTag(DeviceInfo, USB_HUB_TAG);

    if (NodeInfo)
    {
        if (NodeInfoLength <= Length)
        {
            Length = NodeInfoLength;
        }
        else
        {
            Status = STATUS_BUFFER_TOO_SMALL;
        }

        RtlCopyMemory(Info, NodeInfo, Length);

        ExFreePoolWithTag(NodeInfo, USB_HUB_TAG);
    }

    return Status;
}

Referenced by USBH_IoctlGetNodeConnectionInformation().

USBD_InitializeDeviceEx()

NTSTATUS NTAPI USBD_InitializeDeviceEx	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PUSB_DEVICE_HANDLE	DeviceHandle,
		IN PUCHAR	DeviceDescriptorBuffer,
		IN ULONG	DeviceDescriptorBufferLength,
		IN PUCHAR	ConfigDescriptorBuffer,
		IN ULONG	ConfigDescriptorBufferLength
	)

Definition at line 2562 of file usbhub.c.

{
    NTSTATUS Status;
    PUSB_BUSIFFN_INITIALIZE_USB_DEVICE InitializeUsbDevice;
    PUSB_BUSIFFN_GET_USB_DESCRIPTORS GetUsbDescriptors;

    DPRINT("USBD_InitializeDeviceEx: ... \n");

    InitializeUsbDevice = HubExtension->BusInterface.InitializeUsbDevice;
    GetUsbDescriptors = HubExtension->BusInterface.GetUsbDescriptors;

    if (!InitializeUsbDevice || !GetUsbDescriptors)
    {
        return STATUS_NOT_IMPLEMENTED;
    }

    Status = InitializeUsbDevice(HubExtension->BusInterface.BusContext,
                                 DeviceHandle);

    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    return GetUsbDescriptors(HubExtension->BusInterface.BusContext,
                             DeviceHandle,
                             DeviceDescriptorBuffer,
                             &DeviceDescriptorBufferLength,
                             ConfigDescriptorBuffer,
                             &ConfigDescriptorBufferLength);
}

Referenced by USBH_CreateDevice(), and USBH_ResetDevice().

USBD_RegisterRootHubCallBack()

NTSTATUS NTAPI USBD_RegisterRootHubCallBack

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 2986 of file usbhub.c.

{
    PUSB_BUSIFFN_ROOTHUB_INIT_NOTIFY RootHubInitNotification;

    DPRINT("USBD_RegisterRootHubCallBack: ... \n");

    RootHubInitNotification = HubExtension->BusInterface.RootHubInitNotification;

    if (!RootHubInitNotification)
    {
        return STATUS_NOT_IMPLEMENTED;
    }

    KeClearEvent(&HubExtension->RootHubNotificationEvent);

    return RootHubInitNotification(HubExtension->BusInterface.BusContext,
                                   HubExtension,
                                   USBHUB_RootHubCallBack);
}

Referenced by USBH_StartHubFdoDevice().

USBD_RemoveDeviceEx()

NTSTATUS NTAPI USBD_RemoveDeviceEx	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PUSB_DEVICE_HANDLE	DeviceHandle,
		IN ULONG	Flags
	)

Definition at line 2538 of file usbhub.c.

{
    PUSB_BUSIFFN_REMOVE_USB_DEVICE RemoveUsbDevice;

    DPRINT("USBD_RemoveDeviceEx: DeviceHandle - %p, Flags - %X\n",
           DeviceHandle,
           Flags);

    RemoveUsbDevice = HubExtension->BusInterface.RemoveUsbDevice;

    if (!RemoveUsbDevice)
    {
        return STATUS_NOT_IMPLEMENTED;
    }

    return RemoveUsbDevice(HubExtension->BusInterface.BusContext,
                           DeviceHandle,
                           Flags);
}

Referenced by USBH_CreateDevice(), USBH_FdoCleanup(), USBH_FdoQueryBusRelations(), USBH_PdoRemoveDevice(), USBH_ProcessPortStateChange(), USBH_ResetDevice(), and USBH_ResetPortWorker().

USBD_RestoreDeviceEx()

NTSTATUS NTAPI USBD_RestoreDeviceEx	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN OUT PUSB_DEVICE_HANDLE	OldDeviceHandle,
		IN OUT PUSB_DEVICE_HANDLE	NewDeviceHandle
	)

Definition at line 2761 of file usbhub.c.

{
    PUSB_BUSIFFN_RESTORE_DEVICE RestoreUsbDevice;
    NTSTATUS Status;

    DPRINT("USBD_RestoreDeviceEx: HubExtension - %p, OldDeviceHandle - %p, NewDeviceHandle - %p\n",
           HubExtension,
           OldDeviceHandle,
           NewDeviceHandle);

    RestoreUsbDevice = HubExtension->BusInterface.RestoreUsbDevice;

    if (RestoreUsbDevice)
    {
        Status = RestoreUsbDevice(HubExtension->BusInterface.BusContext,
                                  OldDeviceHandle,
                                  NewDeviceHandle);
    }
    else
    {
        Status = STATUS_NOT_IMPLEMENTED;
    }

    return Status;
}

Referenced by USBH_ResetDevice().

USBD_UnRegisterRootHubCallBack()

NTSTATUS NTAPI USBD_UnRegisterRootHubCallBack

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3008 of file usbhub.c.

{
    PUSB_BUSIFFN_ROOTHUB_INIT_NOTIFY RootHubInitNotification;
    NTSTATUS Status;

    DPRINT("USBD_UnRegisterRootHubCallBack ... \n");

    RootHubInitNotification = HubExtension->BusInterface.RootHubInitNotification;

    if (!RootHubInitNotification)
    {
        return STATUS_NOT_IMPLEMENTED;
    }

    Status = RootHubInitNotification(HubExtension->BusInterface.BusContext,
                                     NULL,
                                     NULL);

    if (!NT_SUCCESS(Status))
    {
        KeWaitForSingleObject(&HubExtension->RootHubNotificationEvent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
    }

    return Status;
}

Referenced by USBH_FdoCleanup().

USBH_AddDevice()

NTSTATUS NTAPI USBH_AddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	LowerPDO
	)

Definition at line 4947 of file usbhub.c.

{
    PDEVICE_OBJECT DeviceObject;
    NTSTATUS Status;
    PUSBHUB_FDO_EXTENSION HubExtension;
    PDEVICE_OBJECT LowerDevice;

    DPRINT("USBH_AddDevice: DriverObject - %p, LowerPDO - %p\n",
           DriverObject,
           LowerPDO);

    DeviceObject = NULL;

    Status = IoCreateDevice(DriverObject,
                            sizeof(USBHUB_FDO_EXTENSION),
                            NULL,
                            0x8600,
                            FILE_AUTOGENERATED_DEVICE_NAME,
                            FALSE,
                            &DeviceObject);

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBH_AddDevice: IoCreateDevice() fail\n");

        if (DeviceObject)
        {
            IoDeleteDevice(DeviceObject);
        }

        return Status;
    }

    DPRINT("USBH_AddDevice: DeviceObject - %p\n", DeviceObject);

    HubExtension = DeviceObject->DeviceExtension;
    RtlZeroMemory(HubExtension, sizeof(USBHUB_FDO_EXTENSION));

    HubExtension->Common.ExtensionType = USBH_EXTENSION_TYPE_HUB;

    LowerDevice = IoAttachDeviceToDeviceStack(DeviceObject, LowerPDO);

    if (!LowerDevice)
    {
        DPRINT1("USBH_AddDevice: IoAttachDeviceToDeviceStack() fail\n");

        if (DeviceObject)
        {
            IoDeleteDevice(DeviceObject);
        }

        return STATUS_UNSUCCESSFUL;
    }

    DPRINT("USBH_AddDevice: LowerDevice  - %p\n", LowerDevice);

    HubExtension->Common.SelfDevice = DeviceObject;

    HubExtension->LowerPDO = LowerPDO;
    HubExtension->LowerDevice = LowerDevice;

    KeInitializeSemaphore(&HubExtension->IdleSemaphore, 1, 1);

    DeviceObject->Flags |= DO_POWER_PAGABLE;
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    DPRINT("USBH_AddDevice: call IoWMIRegistrationControl() UNIMPLEMENTED. FIXME\n");

    return Status;
}

Referenced by DriverEntry().

USBH_AllocateWorkItem()

NTSTATUS NTAPI USBH_AllocateWorkItem	(	PUSBHUB_FDO_EXTENSION	HubExtension,
		PUSBHUB_IO_WORK_ITEM *	OutHubIoWorkItem,
		PUSBHUB_WORKER_ROUTINE	WorkerRoutine,
		SIZE_T	BufferLength,
		PVOID *	OutHubWorkItemBuffer,
		WORK_QUEUE_TYPE	Type
	)

Definition at line 2791 of file usbhub.c.

{
    PUSBHUB_IO_WORK_ITEM HubIoWorkItem;
    PIO_WORKITEM WorkItem;
    PVOID WorkItemBuffer;

    DPRINT("USBH_AllocateWorkItem: ... \n");

    if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_WITEM_INIT))
    {
        return STATUS_INVALID_PARAMETER;
    }

    HubIoWorkItem = ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(USBHUB_IO_WORK_ITEM),
                                          USB_HUB_TAG);

    if (!HubIoWorkItem)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(HubIoWorkItem, sizeof(USBHUB_IO_WORK_ITEM));

    WorkItem = IoAllocateWorkItem(HubExtension->Common.SelfDevice);

    HubIoWorkItem->HubWorkItem = WorkItem;

    if (!WorkItem)
    {
        ExFreePoolWithTag(HubIoWorkItem, USB_HUB_TAG);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    if (BufferLength && OutHubWorkItemBuffer)
    {
        WorkItemBuffer = ExAllocatePoolWithTag(NonPagedPool,
                                               BufferLength,
                                               USB_HUB_TAG);

        HubIoWorkItem->HubWorkItemBuffer = WorkItemBuffer;

        if (!WorkItemBuffer)
        {
            IoFreeWorkItem(HubIoWorkItem->HubWorkItem);
            ExFreePoolWithTag(HubIoWorkItem, USB_HUB_TAG);

            return STATUS_INSUFFICIENT_RESOURCES;
        }

        RtlZeroMemory(WorkItemBuffer, BufferLength);
    }
    else
    {
        HubIoWorkItem->HubWorkItemBuffer = NULL;
    }

    HubIoWorkItem->HubWorkItemType = Type;
    HubIoWorkItem->HubExtension = HubExtension;
    HubIoWorkItem->HubWorkerRoutine = WorkerRoutine;

    if (OutHubIoWorkItem)
    {
        *OutHubIoWorkItem = HubIoWorkItem;
    }

    if (OutHubWorkItemBuffer)
    {
        *OutHubWorkItemBuffer = HubIoWorkItem->HubWorkItemBuffer;
    }

    return STATUS_SUCCESS;
}

Referenced by USBH_ChangeIndication(), USBH_CheckIdleDeferred(), USBH_FdoIdleNotificationRequestComplete(), USBH_PdoIoctlResetPort(), and USBH_PortIdleNotificationCancelRoutine().

USBH_ChangeIndication()

NTSTATUS NTAPI USBH_ChangeIndication	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 2319 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;
    USBD_STATUS UrbStatus;
    BOOLEAN IsErrors = FALSE;
    PUSBHUB_IO_WORK_ITEM HubWorkItem;
    PUSBHUB_STATUS_CHANGE_CONTEXT HubWorkItemBuffer;
    USHORT NumPorts;
    USHORT Port;
    NTSTATUS Status;
    PVOID Bitmap;
    ULONG BufferLength;

    HubExtension = Context;
    UrbStatus = HubExtension->SCEWorkerUrb.Hdr.Status;

    DPRINT_SCE("USBH_ChangeIndication: IrpStatus - %x, UrbStatus - %x, HubFlags - %lX\n",
               Irp->IoStatus.Status,
               UrbStatus,
               HubExtension->HubFlags);

    if (NT_ERROR(Irp->IoStatus.Status) || USBD_ERROR(UrbStatus) ||
       (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED) ||
       (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING))
    {
        HubExtension->RequestErrors++;

        IsErrors = TRUE;

        KeSetEvent(&HubExtension->StatusChangeEvent,
                   EVENT_INCREMENT,
                   FALSE);

        if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING ||
            HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED ||
            HubExtension->RequestErrors > USBHUB_MAX_REQUEST_ERRORS ||
            Irp->IoStatus.Status == STATUS_DELETE_PENDING)
        {
            DPRINT_SCE("USBH_ChangeIndication: HubExtension->RequestErrors - %x\n",
                       HubExtension->RequestErrors);

            return STATUS_MORE_PROCESSING_REQUIRED;
        }

        DPRINT_SCE("USBH_ChangeIndication: HubExtension->RequestErrors - %x\n",
                   HubExtension->RequestErrors);
    }
    else
    {
        HubExtension->RequestErrors = 0;
    }

    BufferLength = sizeof(USBHUB_STATUS_CHANGE_CONTEXT) +
                   HubExtension->SCEBitmapLength;

    Status = USBH_AllocateWorkItem(HubExtension,
                                   &HubWorkItem,
                                   USBH_ChangeIndicationWorker,
                                   BufferLength,
                                   (PVOID *)&HubWorkItemBuffer,
                                   DelayedWorkQueue);

    if (!NT_SUCCESS(Status))
    {
        return STATUS_MORE_PROCESSING_REQUIRED;
    }

    RtlZeroMemory(HubWorkItemBuffer, BufferLength);

    HubWorkItemBuffer->IsRequestErrors = FALSE;

    if (IsErrors)
    {
        HubWorkItemBuffer->IsRequestErrors = TRUE;
    }

    if (InterlockedIncrement(&HubExtension->ResetRequestCount) == 1)
    {
        KeClearEvent(&HubExtension->ResetEvent);
    }

    HubWorkItemBuffer->HubExtension = HubExtension;

    HubExtension->WorkItemToQueue = HubWorkItem;

    Bitmap = HubWorkItemBuffer + 1;

    RtlCopyMemory(Bitmap,
                  HubExtension->SCEBitmap,
                  HubExtension->SCEBitmapLength);

    NumPorts = HubExtension->HubDescriptor->bNumberOfPorts;

    for (Port = 0; Port <= NumPorts; ++Port)
    {
        if (IsBitSet(Bitmap, Port))
        {
            break;
        }
    }

    if (Port > NumPorts)
    {
        Port = 0;
    }

    Status = USBH_ChangeIndicationQueryChange(HubExtension,
                                              HubExtension->ResetPortIrp,
                                              &HubExtension->SCEWorkerUrb,
                                              Port);

    if (NT_ERROR(Status))
    {
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
    }

    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by USBH_SubmitStatusChangeTransfer().

USBH_ChangeIndicationAckChange()

NTSTATUS NTAPI USBH_ChangeIndicationAckChange	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PIRP	Irp,
		IN struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *	Urb,
		IN USHORT	Port,
		IN USHORT	RequestValue
	)

Definition at line 1657 of file usbhub.c.

{
    PIO_STACK_LOCATION IoStack;
    BM_REQUEST_TYPE RequestType;

    DPRINT_SCE("USBH_ChangeIndicationAckChange: ... \n");

    Urb->Hdr.Length = sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST);
    Urb->Hdr.Function = URB_FUNCTION_CLASS_OTHER;
    Urb->Hdr.UsbdDeviceHandle = NULL;

    Urb->TransferFlags = USBD_SHORT_TRANSFER_OK;
    Urb->TransferBufferLength = 0;
    Urb->TransferBuffer = NULL;
    Urb->TransferBufferMDL = NULL;
    Urb->UrbLink = NULL;

    RequestType.B = 0;
    RequestType.Recipient = BMREQUEST_TO_OTHER;
    RequestType.Type = BMREQUEST_CLASS;
    RequestType.Dir = BMREQUEST_HOST_TO_DEVICE;

    Urb->RequestTypeReservedBits = RequestType.B;
    Urb->Request = USB_REQUEST_CLEAR_FEATURE;
    Urb->Index = Port;
    Urb->Value = RequestValue;

    IoInitializeIrp(Irp,
                    IoSizeOfIrp(HubExtension->LowerDevice->StackSize),
                    HubExtension->LowerDevice->StackSize);

    IoStack = IoGetNextIrpStackLocation(Irp);

    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.Others.Argument1 = Urb;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;

    IoSetCompletionRoutine(Irp,
                           USBH_ChangeIndicationAckChangeComplete,
                           HubExtension,
                           TRUE,
                           TRUE,
                           TRUE);

    return IoCallDriver(HubExtension->LowerDevice, Irp);
}

Referenced by USBH_ChangeIndicationProcessChange().

USBH_ChangeIndicationAckChangeComplete()

NTSTATUS NTAPI USBH_ChangeIndicationAckChangeComplete	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 1618 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;
    PVOID Event;
    USHORT Port;

    HubExtension = Context;

    DPRINT_SCE("USBH_ChangeIndicationAckChangeComplete: ... \n");

    ASSERT(HubExtension->Port > 0);
    Port = HubExtension->Port - 1;

    HubExtension->PortData[Port].PortStatus = HubExtension->PortStatus;

    Event = InterlockedExchangePointer((PVOID)&HubExtension->pResetPortEvent,
                                       NULL);

    if (Event)
    {
        KeSetEvent(Event, EVENT_INCREMENT, FALSE);
    }

    USBH_SubmitStatusChangeTransfer(HubExtension);

    if (!InterlockedDecrement(&HubExtension->ResetRequestCount))
    {
        KeSetEvent(&HubExtension->ResetEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }

    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by USBH_ChangeIndicationAckChange().

USBH_ChangeIndicationProcessChange()

NTSTATUS NTAPI USBH_ChangeIndicationProcessChange	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 1710 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;
    PUSBHUB_IO_WORK_ITEM WorkItem;
    USHORT RequestValue;

    HubExtension = Context;

    DPRINT_SCE("USBH_ChangeIndicationProcessChange: PortStatus - %lX\n",
               HubExtension->PortStatus.AsUlong32);

    if ((NT_SUCCESS(Irp->IoStatus.Status) ||
        USBD_SUCCESS(HubExtension->SCEWorkerUrb.Hdr.Status)) &&
        (HubExtension->PortStatus.PortChange.Usb20PortChange.ResetChange ||
         HubExtension->PortStatus.PortChange.Usb20PortChange.PortEnableDisableChange))
    {
        if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
        {
            KeSetEvent(&HubExtension->PendingRequestEvent,
                       EVENT_INCREMENT,
                       FALSE);
        }

        USBH_FreeWorkItem(HubExtension->WorkItemToQueue);

        HubExtension->WorkItemToQueue = NULL;

        if (HubExtension->PortStatus.PortChange.Usb20PortChange.ResetChange)
        {
           RequestValue = USBHUB_FEATURE_C_PORT_RESET;
        }
        else
        {
            RequestValue = USBHUB_FEATURE_C_PORT_ENABLE;
        }

        USBH_ChangeIndicationAckChange(HubExtension,
                                       HubExtension->ResetPortIrp,
                                       &HubExtension->SCEWorkerUrb,
                                       HubExtension->Port,
                                       RequestValue);
    }
    else
    {
        ASSERT(HubExtension->WorkItemToQueue != NULL);

        WorkItem = HubExtension->WorkItemToQueue;
        HubExtension->WorkItemToQueue = NULL;

        USBH_QueueWorkItem(HubExtension, WorkItem);
    }

    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by USBH_ChangeIndicationQueryChange().

USBH_ChangeIndicationQueryChange()

NTSTATUS NTAPI USBH_ChangeIndicationQueryChange	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PIRP	Irp,
		IN struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST *	Urb,
		IN USHORT	Port
	)

Definition at line 1769 of file usbhub.c.

{
    PUSBHUB_IO_WORK_ITEM WorkItem;
    NTSTATUS Status;
    PIO_STACK_LOCATION IoStack;
    BM_REQUEST_TYPE RequestType;

    DPRINT_SCE("USBH_ChangeIndicationQueryChange: Port - %x\n", Port);

    InterlockedIncrement(&HubExtension->PendingRequestCount);

    if (!Port)
    {
        ASSERT(HubExtension->WorkItemToQueue != NULL);

        WorkItem = HubExtension->WorkItemToQueue;
        HubExtension->WorkItemToQueue = NULL;

        USBH_QueueWorkItem(HubExtension, WorkItem);

        return STATUS_SUCCESS;
    }

    Urb->Hdr.Length = sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST);
    Urb->Hdr.UsbdDeviceHandle = NULL;
    Urb->Hdr.Function = URB_FUNCTION_CLASS_OTHER;

    Urb->TransferFlags = USBD_SHORT_TRANSFER_OK | USBD_TRANSFER_DIRECTION_IN;
    Urb->TransferBuffer = &HubExtension->PortStatus;
    Urb->TransferBufferLength = sizeof(HubExtension->PortStatus);
    Urb->TransferBufferMDL = NULL;
    Urb->UrbLink = NULL;

    RequestType.B = 0;
    RequestType.Recipient = BMREQUEST_TO_OTHER;
    RequestType.Type = BMREQUEST_CLASS;
    RequestType.Dir = BMREQUEST_DEVICE_TO_HOST;

    Urb->RequestTypeReservedBits = RequestType.B;
    Urb->Request = USB_REQUEST_GET_STATUS;
    Urb->Value = 0;
    Urb->Index = Port;

    HubExtension->Port = Port;

    IoInitializeIrp(Irp,
                    IoSizeOfIrp(HubExtension->LowerDevice->StackSize),
                    HubExtension->LowerDevice->StackSize);

    IoStack = IoGetNextIrpStackLocation(Irp);

    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
    IoStack->Parameters.Others.Argument1 = Urb;
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;

    IoSetCompletionRoutine(Irp,
                           USBH_ChangeIndicationProcessChange,
                           HubExtension,
                           TRUE,
                           TRUE,
                           TRUE);

    Status = IoCallDriver(HubExtension->LowerDevice, Irp);

    return Status;
}

Referenced by USBH_ChangeIndication().

USBH_ChangeIndicationWorker()

VOID NTAPI USBH_ChangeIndicationWorker	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PVOID	Context
	)

Definition at line 2146 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION LowerHubExtension;
    PUSBHUB_PORT_PDO_EXTENSION LowerPortExtension;
    PUSBHUB_STATUS_CHANGE_CONTEXT WorkItem;
    USB_PORT_STATUS_AND_CHANGE PortStatus;
    USB_HUB_STATUS_AND_CHANGE HubStatus;
    NTSTATUS Status;
    USHORT Port = 0;

    DPRINT_SCE("USBH_ChangeIndicationWorker ... \n");

    WorkItem = Context;

    KeWaitForSingleObject(&HubExtension->HubSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

    if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING)
    {
        KeSetEvent(&HubExtension->StatusChangeEvent,
                   EVENT_INCREMENT,
                   FALSE);

        goto Exit;
    }

    if (!HubExtension->RequestErrors)
    {
        goto Enum;
    }

    DPRINT_SCE("USBH_ChangeIndicationWorker: RequestErrors - %x\n",
               HubExtension->RequestErrors);

    if (HubExtension->LowerPDO == HubExtension->RootHubPdo)
    {
        goto Enum;
    }

    LowerPortExtension = HubExtension->LowerPDO->DeviceExtension;

    if (LowerPortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D1_OR_D2)
    {
        goto Enum;
    }

    LowerHubExtension = LowerPortExtension->HubExtension;

    if (!LowerHubExtension)
    {
        goto Enum;
    }

    Status = USBH_SyncGetPortStatus(LowerHubExtension,
                                    LowerPortExtension->PortNumber,
                                    &PortStatus,
                                    sizeof(USB_PORT_STATUS_AND_CHANGE));

    if (!NT_SUCCESS(Status) ||
        !PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus)
    {
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_REMOVED;

        KeSetEvent(&HubExtension->StatusChangeEvent,
                   EVENT_INCREMENT,
                   FALSE);

        goto Exit;
    }

    if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_ESD_RECOVERING))
    {
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_ESD_RECOVERING;

        DPRINT1("USBH_ChangeIndicationWorker: USBHUB_FDO_FLAG_ESD_RECOVERING FIXME\n");
        DbgBreakPoint();

        goto Exit;
    }

Enum:

    if (WorkItem->IsRequestErrors)
    {
        USBH_ResetHub(HubExtension);
    }
    else
    {
        for (Port = 0;
             Port < HubExtension->HubDescriptor->bNumberOfPorts;
             Port++)
        {
            if (IsBitSet((PUCHAR)(WorkItem + 1), Port))
            {
                break;
            }
        }

        if (Port)
        {
            Status = USBH_SyncGetPortStatus(HubExtension,
                                            Port,
                                            &PortStatus,
                                            sizeof(PortStatus));
        }
        else
        {
            Status = USBH_SyncGetHubStatus(HubExtension,
                                           &HubStatus,
                                           sizeof(HubStatus));
        }

        if (NT_SUCCESS(Status))
        {
            if (Port)
            {
                USBH_ProcessPortStateChange(HubExtension,
                                            Port,
                                            &PortStatus);
            }
            else
            {
                USBH_ProcessHubStateChange(HubExtension,
                                           &HubStatus);
            }
        }
        else
        {
            HubExtension->RequestErrors++;

            if (HubExtension->RequestErrors > USBHUB_MAX_REQUEST_ERRORS)
            {
                HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
                goto Exit;
            }
        }
    }

    USBH_SubmitStatusChangeTransfer(HubExtension);

Exit:

    KeReleaseSemaphore(&HubExtension->HubSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);

    if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }

    if (!InterlockedDecrement((PLONG)&HubExtension->ResetRequestCount))
    {
        KeSetEvent(&HubExtension->ResetEvent,
                   EVENT_INCREMENT,
                   FALSE);

        if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEFER_CHECK_IDLE)
        {
            USBH_CheckHubIdle(HubExtension);
        }
    }
}

Referenced by USBH_ChangeIndication().

USBH_CheckDeviceIDUnique()

BOOLEAN NTAPI USBH_CheckDeviceIDUnique	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN USHORT	idVendor,
		IN USHORT	idProduct,
		IN PVOID	SerialNumber,
		IN USHORT	SN_DescriptorLength
	)

Definition at line 4167 of file usbhub.c.

{
    PDEVICE_OBJECT PortDevice;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    ULONG Port;
    SIZE_T NumberBytes;

    DPRINT("USBH_CheckDeviceIDUnique: idVendor - 0x%04X, idProduct - 0x%04X\n",
           idVendor,
           idProduct);

    if (!HubExtension->HubDescriptor->bNumberOfPorts)
    {
        return TRUE;
    }

    for (Port = 0; Port < HubExtension->HubDescriptor->bNumberOfPorts; Port++)
    {
        PortDevice = HubExtension->PortData[Port].DeviceObject;

        if (PortDevice)
        {
            PortExtension = PortDevice->DeviceExtension;

            if (PortExtension->DeviceDescriptor.idVendor == idVendor &&
                PortExtension->DeviceDescriptor.idProduct == idProduct &&
                PortExtension->SN_DescriptorLength == SN_DescriptorLength)
            {
                if (PortExtension->SerialNumber)
                {
                    NumberBytes = RtlCompareMemory(PortExtension->SerialNumber,
                                                   SerialNumber,
                                                   SN_DescriptorLength);

                    if (NumberBytes == SN_DescriptorLength)
                    {
                        return FALSE;
                    }
                }
            }
        }
    }

    return TRUE;
}

Referenced by USBH_CreateDevice().

USBH_CheckDeviceLanguage()

NTSTATUS NTAPI USBH_CheckDeviceLanguage	(	IN PDEVICE_OBJECT	DeviceObject,
		IN USHORT	LanguageId
	)

Definition at line 4242 of file usbhub.c.

{
    PUSB_STRING_DESCRIPTOR Descriptor;
    NTSTATUS Status;
    ULONG NumSymbols;
    ULONG ix;
    PWCHAR pSymbol;
    ULONG Length;

    DPRINT("USBH_CheckDeviceLanguage: LanguageId - 0x%04X\n", LanguageId);

    Descriptor = ExAllocatePoolWithTag(NonPagedPool,
                                       MAXIMUM_USB_STRING_LENGTH,
                                       USB_HUB_TAG);

    if (!Descriptor)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(Descriptor, MAXIMUM_USB_STRING_LENGTH);

    Status = USBH_SyncGetStringDescriptor(DeviceObject,
                                          0,
                                          0,
                                          Descriptor,
                                          MAXIMUM_USB_STRING_LENGTH,
                                          &Length,
                                          TRUE);

    if (!NT_SUCCESS(Status) ||
        Length < sizeof(USB_COMMON_DESCRIPTOR))
    {
        goto Exit;
    }

    NumSymbols = (Length -
                  FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString)) / sizeof(WCHAR);

    pSymbol = Descriptor->bString;

    for (ix = 1; ix < NumSymbols; ix++)
    {
        if (*pSymbol == (WCHAR)LanguageId)
        {
            Status = STATUS_SUCCESS;
            goto Exit;
        }

        pSymbol++;
    }

    Status = STATUS_NOT_SUPPORTED;

Exit:
    ExFreePoolWithTag(Descriptor, USB_HUB_TAG);
    return Status;
}

Referenced by USBH_GetSerialNumberString(), and USBH_PdoQueryDeviceText().

USBH_CheckHubIdle()

VOID NTAPI USBH_CheckHubIdle

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3808 of file usbhub.c.

{
    PDEVICE_OBJECT PdoDevice;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    PUSBHUB_PORT_DATA PortData;
    ULONG HubFlags;
    ULONG Port;
    KIRQL Irql;
    BOOLEAN IsHubIdle = FALSE;
    BOOLEAN IsAllPortsIdle;
    BOOLEAN IsHubCheck = TRUE;

    DPRINT("USBH_CheckHubIdle: FIXME !!! HubExtension - %p\n", HubExtension);

return; //HACK: delete it line after fixing Power Manager!!!

    KeAcquireSpinLock(&HubExtension->CheckIdleSpinLock, &Irql);

    if (HubExtension->HubFlags & USBHUB_FDO_FLAG_CHECK_IDLE_LOCK)
    {
        KeReleaseSpinLock(&HubExtension->CheckIdleSpinLock, Irql);
        return;
    }

    HubExtension->HubFlags |= USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
    KeReleaseSpinLock(&HubExtension->CheckIdleSpinLock, Irql);

    if (USBH_GetRootHubExtension(HubExtension)->SystemPowerState.SystemState != PowerSystemWorking)
    {
        KeAcquireSpinLock(&HubExtension->CheckIdleSpinLock, &Irql);
        HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
        KeReleaseSpinLock(&HubExtension->CheckIdleSpinLock, Irql);
        return;
    }

    HubFlags = HubExtension->HubFlags;
    DPRINT("USBH_CheckHubIdle: HubFlags - %lX\n", HubFlags);

    if (!(HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED) ||
        !(HubFlags & USBHUB_FDO_FLAG_DO_ENUMERATION))
    {
        goto Exit;
    }

    if (HubFlags & USBHUB_FDO_FLAG_NOT_ENUMERATED ||
        HubFlags & USBHUB_FDO_FLAG_ENUM_POST_RECOVER ||
        HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED ||
        HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING ||
        HubFlags & USBHUB_FDO_FLAG_DEVICE_REMOVED ||
        HubFlags & USBHUB_FDO_FLAG_STATE_CHANGING ||
        HubFlags & USBHUB_FDO_FLAG_WAKEUP_START ||
        HubFlags & USBHUB_FDO_FLAG_ESD_RECOVERING)
    {
        goto Exit;
    }

    if (HubExtension->ResetRequestCount)
    {
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEFER_CHECK_IDLE;
        goto Exit;
    }

    HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DEFER_CHECK_IDLE;

    InterlockedIncrement(&HubExtension->PendingRequestCount);

    KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

    IoAcquireCancelSpinLock(&Irql);

    IsAllPortsIdle = TRUE;

    PortData = HubExtension->PortData;

    for (Port = 0;
         Port < HubExtension->HubDescriptor->bNumberOfPorts;
         Port++)
    {
        PdoDevice = PortData[Port].DeviceObject;

        if (PdoDevice)
        {
            PortExtension = PdoDevice->DeviceExtension;

            if (!PortExtension->IdleNotificationIrp)
            {
                DPRINT("USBH_CheckHubIdle: PortExtension - %p\n",
                       PortExtension);

                IsAllPortsIdle = FALSE;
                IsHubCheck = FALSE;

                break;
            }
        }
    }

    if (IsHubCheck &&
        !(HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST))
    {
        KeClearEvent(&HubExtension->IdleEvent);
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST;
        IsHubIdle = TRUE;
    }

    IoReleaseCancelSpinLock(Irql);

    KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);

    if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }

    DPRINT("USBH_CheckHubIdle: IsAllPortsIdle - %x, IsHubIdle - %x\n",
           IsAllPortsIdle,
           IsHubIdle);

    if (IsAllPortsIdle && IsHubIdle)
    {
        USBH_FdoSubmitIdleRequestIrp(HubExtension);
    }

Exit:
    KeAcquireSpinLock(&HubExtension->CheckIdleSpinLock, &Irql);
    HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_CHECK_IDLE_LOCK;
    KeReleaseSpinLock(&HubExtension->CheckIdleSpinLock, Irql);
}

Referenced by USBH_ChangeIndicationWorker(), USBH_CheckIdleWorker(), and USBH_DeviceControl().

USBH_CheckIdleAbort()

BOOLEAN NTAPI USBH_CheckIdleAbort	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN BOOLEAN	IsWait,
		IN BOOLEAN	IsExtCheck
	)

Definition at line 3221 of file usbhub.c.

{
    PDEVICE_OBJECT PdoDevice;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    PUSBHUB_PORT_DATA PortData;
    ULONG Port;
    BOOLEAN Result = FALSE;

    DPRINT("USBH_CheckIdleAbort: ... \n");

    InterlockedIncrement(&HubExtension->PendingRequestCount);

    if (IsWait == TRUE)
    {
        KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
    }

    PortData = HubExtension->PortData;

    for (Port = 0; Port < HubExtension->HubDescriptor->bNumberOfPorts; Port++)
    {
        PdoDevice = PortData[Port].DeviceObject;

        if (PdoDevice)
        {
            PortExtension = PdoDevice->DeviceExtension;

            if (PortExtension->PoRequestCounter)
            {
                Result = TRUE;
                goto Wait;
            }
        }
    }

    if (IsExtCheck == TRUE)
    {
        PortData = HubExtension->PortData;

        for (Port = 0;
             Port < HubExtension->HubDescriptor->bNumberOfPorts;
             Port++)
        {
            PdoDevice = PortData[Port].DeviceObject;

            if (PdoDevice)
            {
                PortExtension = PdoDevice->DeviceExtension;
                InterlockedExchange(&PortExtension->StateBehindD2, 0);
            }
        }
    }

Wait:

    if (IsWait == TRUE)
    {
        KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
                           LOW_REALTIME_PRIORITY,
                           1,
                           FALSE);
    }

    if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }

    return Result;
}

Referenced by USBH_FdoIdleNotificationCallback(), and USBH_FdoPower().

USBH_CheckIdleDeferred()

VOID NTAPI USBH_CheckIdleDeferred

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3957 of file usbhub.c.

{
    PUSBHUB_IO_WORK_ITEM HubIoWorkItem;
    NTSTATUS Status;

    DPRINT("USBH_CheckIdleDeferred: HubExtension - %p\n", HubExtension);

    Status = USBH_AllocateWorkItem(HubExtension,
                                   &HubIoWorkItem,
                                   USBH_CheckIdleWorker,
                                   0,
                                   NULL,
                                   DelayedWorkQueue);

    DPRINT("USBH_CheckIdleDeferred: HubIoWorkItem - %p\n", HubIoWorkItem);

    if (NT_SUCCESS(Status))
    {
        USBH_QueueWorkItem(HubExtension, HubIoWorkItem);
    }
}

Referenced by USBH_FdoDeferPoRequestCompletion(), USBH_FdoPnP(), USBH_FdoPower(), USBH_PdoRemoveDevice(), and USBH_PortIdleNotificationRequest().

USBH_CheckIdleWorker()

VOID NTAPI USBH_CheckIdleWorker	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PVOID	Context
	)

Definition at line 3948 of file usbhub.c.

{
    DPRINT("USBH_CheckIdleWorker: ... \n");
    USBH_CheckHubIdle(HubExtension);
}

Referenced by USBH_CheckIdleDeferred().

USBH_CompleteIrp()

VOID NTAPI USBH_CompleteIrp	(	IN PIRP	Irp,
		IN NTSTATUS	CompleteStatus
	)

Definition at line 63 of file usbhub.c.

{
    if (CompleteStatus != STATUS_SUCCESS)
    {
        DPRINT1("USBH_CompleteIrp: Irp - %p, CompleteStatus - %X\n",
                Irp,
                CompleteStatus);
    }

    Irp->IoStatus.Status = CompleteStatus;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by USBH_DeviceControl(), USBH_FdoDispatch(), USBH_FdoQueryBusRelations(), USBH_FdoStartDevice(), USBH_IoctlGetDescriptor(), USBH_IoctlGetHubCapabilities(), USBH_IoctlGetNodeConnectionAttributes(), USBH_IoctlGetNodeConnectionDriverKeyName(), USBH_IoctlGetNodeConnectionInformation(), USBH_IoctlGetNodeInformation(), USBH_IoctlGetNodeName(), USBH_PdoDispatch(), USBH_PdoInternalControl(), USBH_PdoIoctlGetPortStatus(), USBH_PdoIoctlResetPort(), USBH_PdoUrbFilter(), USBH_ResetPortWorker(), and USBH_StartHubFdoDevice().

USBH_CompletePortIdleIrpsWorker()

VOID NTAPI USBH_CompletePortIdleIrpsWorker	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PVOID	Context
	)

Definition at line 3576 of file usbhub.c.

{
    PUSBHUB_IDLE_PORT_CONTEXT IdlePortContext;
    NTSTATUS NtStatus;
    NTSTATUS Status;
    BOOLEAN IsFlush = FALSE;

    DPRINT("USBH_CompletePortIdleIrpsWorker ... \n");

    IdlePortContext = Context;
    NtStatus = IdlePortContext->Status;

    USBH_HubCompleteQueuedPortIdleIrps(HubExtension,
                                       &IdlePortContext->PwrList,
                                       NtStatus);

    DPRINT1("USBH_CompletePortIdleIrpsWorker: USBH_RegQueryFlushPortPowerIrpsFlag() UNIMPLEMENTED. FIXME\n");
    Status = STATUS_NOT_IMPLEMENTED;// USBH_RegQueryFlushPortPowerIrpsFlag(&IsFlush);

    if (NT_SUCCESS(Status))
    {
        if (IsFlush)
        {
            USBH_FlushPortPwrList(HubExtension);
        }
    }
}

Referenced by USBH_FdoIdleNotificationRequestComplete().

USBH_CreateDevice()

NTSTATUS NTAPI USBH_CreateDevice	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN USHORT	Port,
		IN USB_PORT_STATUS	UsbPortStatus,
		IN ULONG	IsWait
	)

Definition at line 4379 of file usbhub.c.

{
    ULONG PdoNumber = 0;
    WCHAR CharDeviceName[64];
    UNICODE_STRING DeviceName;
    PDEVICE_OBJECT DeviceObject = NULL;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    PUSB_DEVICE_HANDLE DeviceHandle;
    LPWSTR SerialNumberBuffer;
    BOOLEAN IsHsDevice;
    BOOLEAN IsLsDevice;
    BOOLEAN IgnoringHwSerial = FALSE;
    NTSTATUS Status;
    UNICODE_STRING DestinationString;

    DPRINT("USBH_CreateDevice: Port - %x, UsbPortStatus - %lX\n",
           Port,
           UsbPortStatus.AsUshort16);

    do
    {
        RtlStringCbPrintfW(CharDeviceName,
                           sizeof(CharDeviceName),
                           L"\\Device\\USBPDO-%d",
                           PdoNumber);

        RtlInitUnicodeString(&DeviceName, CharDeviceName);

        Status = IoCreateDevice(HubExtension->Common.SelfDevice->DriverObject,
                                sizeof(USBHUB_PORT_PDO_EXTENSION),
                                &DeviceName,
                                FILE_DEVICE_USB,
                                0,
                                FALSE,
                                &DeviceObject);

        ++PdoNumber;
    }
    while (Status == STATUS_OBJECT_NAME_COLLISION);

    if (!NT_SUCCESS(Status))
    {
        ASSERT(Port > 0);
        HubExtension->PortData[Port-1].DeviceObject = DeviceObject;
        return Status;
    }

    DeviceObject->StackSize = HubExtension->RootHubPdo2->StackSize;

    PortExtension = DeviceObject->DeviceExtension;

    DPRINT("USBH_CreateDevice: PortDevice - %p, <%wZ>\n", DeviceObject, &DeviceName);
    DPRINT("USBH_CreateDevice: PortExtension - %p\n", PortExtension);

    RtlZeroMemory(PortExtension, sizeof(USBHUB_PORT_PDO_EXTENSION));

    PortExtension->Common.ExtensionType = USBH_EXTENSION_TYPE_PORT;
    PortExtension->Common.SelfDevice = DeviceObject;

    PortExtension->HubExtension = HubExtension;
    PortExtension->RootHubExtension = HubExtension;

    PortExtension->PortNumber = Port;
    PortExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
    PortExtension->IgnoringHwSerial = FALSE;

    KeInitializeSpinLock(&PortExtension->PortTimeoutSpinLock);

    InitializeListHead(&PortExtension->PortPowerList);
    KeInitializeSpinLock(&PortExtension->PortPowerListSpinLock);

    PortExtension->PoRequestCounter = 0;
    PortExtension->PendingSystemPoRequest = 0;
    PortExtension->PendingDevicePoRequest = 0;
    PortExtension->StateBehindD2 = 0;

    SerialNumberBuffer = NULL;

    IsHsDevice = UsbPortStatus.Usb20PortStatus.HighSpeedDeviceAttached;
    IsLsDevice = UsbPortStatus.Usb20PortStatus.LowSpeedDeviceAttached;

    if (IsLsDevice == 0)
    {
        if (IsHsDevice)
        {
            PortExtension->PortPdoFlags = USBHUB_PDO_FLAG_PORT_HIGH_SPEED;
        }
    }
    else
    {
        PortExtension->PortPdoFlags = USBHUB_PDO_FLAG_PORT_LOW_SPEED;
    }

    /* Initialize PortExtension->InstanceID */
    RtlInitUnicodeString(&DestinationString, (PCWSTR)&PortExtension->InstanceID);
    DestinationString.MaximumLength = 4 * sizeof(WCHAR);
    Status = RtlIntegerToUnicodeString(Port, 10, &DestinationString);

    DeviceObject->Flags |= DO_POWER_PAGABLE;
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBH_CreateDevice: IoCreateDevice() failed - %lX\n", Status);
        goto ErrorExit;
    }

    Status = USBD_CreateDeviceEx(HubExtension,
                                 &PortExtension->DeviceHandle,
                                 UsbPortStatus,
                                 Port);

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBH_CreateDevice: USBD_CreateDeviceEx() failed - %lX\n", Status);
        goto ErrorExit;
    }

    Status = USBH_SyncResetPort(HubExtension, Port);

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBH_CreateDevice: USBH_SyncResetPort() failed - %lX\n", Status);
        goto ErrorExit;
    }

    if (IsWait)
    {
        USBH_Wait(50);
    }

    Status = USBD_InitializeDeviceEx(HubExtension,
                                     PortExtension->DeviceHandle,
                                     (PUCHAR)&PortExtension->DeviceDescriptor,
                                     sizeof(USB_DEVICE_DESCRIPTOR),
                                     (PUCHAR)&PortExtension->ConfigDescriptor,
                                     sizeof(USB_CONFIGURATION_DESCRIPTOR));

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBH_CreateDevice: USBD_InitializeDeviceEx() failed - %lX\n", Status);
        PortExtension->DeviceHandle = NULL;
        goto ErrorExit;
    }

    DPRINT1("USBH_RegQueryDeviceIgnoreHWSerNumFlag UNIMPLEMENTED. FIXME\n");
    //Status = USBH_RegQueryDeviceIgnoreHWSerNumFlag(PortExtension->DeviceDescriptor.idVendor,
    //                                               PortExtension->DeviceDescriptor.idProduct,
    //                                               &IgnoringHwSerial);

    if (TRUE)//Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        IgnoringHwSerial = FALSE;
    }

    if (IgnoringHwSerial)
    {
        PortExtension->IgnoringHwSerial = TRUE;
    }

    if (PortExtension->DeviceDescriptor.iSerialNumber &&
       !PortExtension->IgnoringHwSerial)
    {
        InterlockedExchangePointer((PVOID)&PortExtension->SerialNumber, NULL);

        USBH_GetSerialNumberString(PortExtension->Common.SelfDevice,
                                   &SerialNumberBuffer,
                                   &PortExtension->SN_DescriptorLength,
                                   MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
                                   PortExtension->DeviceDescriptor.iSerialNumber);

        if (SerialNumberBuffer)
        {
            if (!USBH_ValidateSerialNumberString((PUSHORT)SerialNumberBuffer))
            {
                ExFreePoolWithTag(SerialNumberBuffer, USB_HUB_TAG);
                SerialNumberBuffer = NULL;
            }

            if (SerialNumberBuffer &&
                !USBH_CheckDeviceIDUnique(HubExtension,
                                          PortExtension->DeviceDescriptor.idVendor,
                                          PortExtension->DeviceDescriptor.idProduct,
                                          SerialNumberBuffer,
                                          PortExtension->SN_DescriptorLength))
            {
                ExFreePoolWithTag(SerialNumberBuffer, USB_HUB_TAG);
                SerialNumberBuffer = NULL;
            }
        }

        InterlockedExchangePointer((PVOID)&PortExtension->SerialNumber,
                                   SerialNumberBuffer);
    }

    Status = USBH_ProcessDeviceInformation(PortExtension);

    USBH_PdoSetCapabilities(PortExtension);

    if (NT_SUCCESS(Status))
    {
        goto Exit;
    }

ErrorExit:

    PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_INIT_PORT_FAILED;

    DeviceHandle = InterlockedExchangePointer(&PortExtension->DeviceHandle,
                                              NULL);

    if (DeviceHandle)
    {
        USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
    }

    SerialNumberBuffer = InterlockedExchangePointer((PVOID)&PortExtension->SerialNumber,
                                                     NULL);

    if (SerialNumberBuffer)
    {
        ExFreePoolWithTag(SerialNumberBuffer, USB_HUB_TAG);
    }

Exit:

    ASSERT(Port > 0);
    HubExtension->PortData[Port-1].DeviceObject = DeviceObject;
    return Status;
}

Referenced by USBH_FdoQueryBusRelations().

USBH_DriverUnload()

VOID NTAPI USBH_DriverUnload

(

IN PDRIVER_OBJECT

DriverObject

)

Definition at line 5021 of file usbhub.c.

{
    DPRINT("USBH_DriverUnload: UNIMPLEMENTED\n");

    if (GenericUSBDeviceString)
    {
        ExFreePool(GenericUSBDeviceString);
        GenericUSBDeviceString = NULL;
    }
}

Referenced by DriverEntry().

USBH_EnableParentPort()

NTSTATUS NTAPI USBH_EnableParentPort

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 2032 of file usbhub.c.

{
    PIRP Irp;
    NTSTATUS Status;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;

    DPRINT("USBH_EnableParentPort ... \n");

    KeInitializeEvent(&Event, NotificationEvent, FALSE);

    Irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_USB_ENABLE_PORT,
                                        HubExtension->LowerDevice,
                                        NULL,
                                        0,
                                        NULL,
                                        0,
                                        TRUE,
                                        &Event,
                                        &IoStatusBlock);

    if (!Irp)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    Status = IoCallDriver(HubExtension->LowerDevice, Irp);

    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Suspended,
                              KernelMode,
                              FALSE,
                              NULL);
    }
    else
    {
        IoStatusBlock.Status = Status;
    }

    return IoStatusBlock.Status;
}

Referenced by USBH_ResetHub().

USBH_FdoDispatch()

NTSTATUS NTAPI USBH_FdoDispatch	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PIRP	Irp
	)

Definition at line 4896 of file usbhub.c.

{
    PIO_STACK_LOCATION IoStack;
    UCHAR MajorFunction;
    NTSTATUS Status;

    IoStack = IoGetCurrentIrpStackLocation(Irp);

    DPRINT("USBH_FdoDispatch: HubExtension - %p, Irp - %p, MajorFunction - %X\n",
           HubExtension,
           Irp,
           IoStack->MajorFunction);

    MajorFunction = IoStack->MajorFunction;

    switch (MajorFunction)
    {
        case IRP_MJ_CREATE:
        case IRP_MJ_CLOSE:
            Status = STATUS_SUCCESS;
            USBH_CompleteIrp(Irp, Status);
            break;

        case IRP_MJ_DEVICE_CONTROL:
            Status = USBH_DeviceControl(HubExtension, Irp);
            break;

        case IRP_MJ_PNP:
            Status = USBH_FdoPnP(HubExtension, Irp, IoStack->MinorFunction);
            break;

        case IRP_MJ_POWER:
            Status = USBH_FdoPower(HubExtension, Irp, IoStack->MinorFunction);
            break;

        case IRP_MJ_SYSTEM_CONTROL:
            DPRINT1("USBH_FdoDispatch: USBH_SystemControl() UNIMPLEMENTED. FIXME\n");
            /* fall through */

        case IRP_MJ_INTERNAL_DEVICE_CONTROL:
        default:
            Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
            break;
    }

    return Status;
}

Referenced by USBH_HubDispatch().

USBH_FdoIdleNotificationCallback()

VOID NTAPI USBH_FdoIdleNotificationCallback

(

IN PVOID

Context

)

Definition at line 3365 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;
    PUSBHUB_PORT_DATA PortData;
    PDEVICE_OBJECT PortDevice;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    PIRP Irp = NULL;
    PIRP IdleIrp;
    POWER_STATE PowerState;
    KEVENT Event;
    ULONG Port;
    PIO_STACK_LOCATION IoStack;
    PUSB_IDLE_CALLBACK_INFO CallbackInfo;
    BOOLEAN IsReady;
    KIRQL OldIrql;
    NTSTATUS Status;

    HubExtension = Context;

    DPRINT("USBH_FdoIdleNotificationCallback: HubExtension - %p, HubFlags - %lX\n",
           HubExtension,
           HubExtension->HubFlags);

    if (HubExtension->HubFlags & (USBHUB_FDO_FLAG_ENUM_POST_RECOVER |
                                  USBHUB_FDO_FLAG_WAKEUP_START |
                                  USBHUB_FDO_FLAG_DEVICE_REMOVED |
                                  USBHUB_FDO_FLAG_STATE_CHANGING |
                                  USBHUB_FDO_FLAG_ESD_RECOVERING |
                                  USBHUB_FDO_FLAG_DEVICE_FAILED |
                                  USBHUB_FDO_FLAG_DEVICE_STOPPING))
    {
        DbgBreakPoint();
        return;
    }

    HubExtension->HubFlags |= USBHUB_FDO_FLAG_GOING_IDLE;

    if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_PENDING_WAKE_IRP))
    {
        Status = USBH_FdoSubmitWaitWakeIrp(HubExtension);

        if (Status != STATUS_PENDING)
        {
            DPRINT("Status != STATUS_PENDING. DbgBreakPoint()\n");
            DbgBreakPoint();
            HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_GOING_IDLE;
            return;
        }
    }

    InterlockedIncrement(&HubExtension->PendingRequestCount);

    KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

    PortData = HubExtension->PortData;
    IsReady = TRUE;

    for (Port = 0;
         Port < HubExtension->HubDescriptor->bNumberOfPorts;
         Port++)
    {
        PortDevice = PortData[Port].DeviceObject;

        if (PortDevice)
        {
            PortExtension = PortDevice->DeviceExtension;

            IdleIrp = PortExtension->IdleNotificationIrp;

            if (!IdleIrp)
            {
                IsReady = FALSE;
                goto IdleHub;
            }

            IoStack = IoGetCurrentIrpStackLocation(IdleIrp);

            CallbackInfo = IoStack->Parameters.DeviceIoControl.Type3InputBuffer;

            if (!CallbackInfo)
            {
                IsReady = FALSE;
                goto IdleHub;
            }

            if (!CallbackInfo->IdleCallback)
            {
                IsReady = FALSE;
                goto IdleHub;
            }

            if (PortExtension->PendingSystemPoRequest)
            {
                IsReady = FALSE;
                goto IdleHub;
            }

            if (InterlockedCompareExchange(&PortExtension->StateBehindD2,
                                           1,
                                           0))
            {
                IsReady = FALSE;
                goto IdleHub;
            }

            DPRINT("USBH_FdoIdleNotificationCallback: IdleContext - %p\n",
                   CallbackInfo->IdleContext);

            CallbackInfo->IdleCallback(CallbackInfo->IdleContext);

            if (PortExtension->CurrentPowerState.DeviceState == PowerDeviceD0)
            {
                IsReady = FALSE;
                goto IdleHub;
            }
        }
    }

    if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING) &&
        (USBH_CheckIdleAbort(HubExtension, FALSE, FALSE) == TRUE))
    {
        IsReady = FALSE;
    }

IdleHub:

    KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);

    if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }

    if (!IsReady ||
        (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_SUSPENDED))
    {
        DPRINT1("USBH_FdoIdleNotificationCallback: HubFlags - %lX\n",
                HubExtension->HubFlags);

        HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_DEVICE_SUSPENDED |
                                    USBHUB_FDO_FLAG_GOING_IDLE);

        /* Aborting Idle for Hub */
        IoAcquireCancelSpinLock(&OldIrql);

        if (HubExtension->PendingIdleIrp)
        {
            Irp = HubExtension->PendingIdleIrp;
            HubExtension->PendingIdleIrp = NULL;
        }

        IoReleaseCancelSpinLock(OldIrql);

        if (Irp)
        {
            USBH_HubCancelIdleIrp(HubExtension, Irp);
        }

        DbgBreakPoint();
        USBH_HubCompletePortIdleIrps(HubExtension, STATUS_CANCELLED);
    }
    else
    {
        PowerState.DeviceState = HubExtension->DeviceWake;

        KeWaitForSingleObject(&HubExtension->IdleSemaphore,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);

        HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_GOING_IDLE;
        HubExtension->HubFlags |= USBHUB_FDO_FLAG_DO_SUSPENSE;

        KeInitializeEvent(&Event, NotificationEvent, FALSE);

        DPRINT("USBH_FdoIdleNotificationCallback: LowerPdo - %p\n",
                HubExtension->LowerPDO);

        DPRINT("USBH_FdoIdleNotificationCallback: PowerState.DeviceState - %x\n",
               PowerState.DeviceState);

        Status = PoRequestPowerIrp(HubExtension->LowerPDO,
                                   IRP_MN_SET_POWER,
                                   PowerState,
                                   USBH_HubSetDWakeCompletion,
                                   &Event,
                                   NULL);

        if (Status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
        }
    }
}

Referenced by USBH_FdoSubmitIdleRequestIrp().

USBH_FdoIdleNotificationRequestComplete()

NTSTATUS NTAPI USBH_FdoIdleNotificationRequestComplete	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 3629 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;
    NTSTATUS NtStatus;
    PVOID IdleIrp;
    KIRQL Irql;
    NTSTATUS Status;
    PUSBHUB_IO_WORK_ITEM HubIoWorkItem;

    IoAcquireCancelSpinLock(&Irql);

    HubExtension = Context;
    HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST;

    IdleIrp = InterlockedExchangePointer((PVOID)&HubExtension->PendingIdleIrp,
                                         NULL);

    DPRINT("USBH_FdoIdleNotificationRequestComplete: IdleIrp - %p\n", IdleIrp);

    if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
    }

    IoReleaseCancelSpinLock(Irql);

    NtStatus = Irp->IoStatus.Status;

    DPRINT("USBH_FdoIdleNotificationRequestComplete: NtStatus - %lX\n",
           NtStatus);

    if (!NT_SUCCESS(NtStatus) &&
        NtStatus != STATUS_POWER_STATE_INVALID &&
        !(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_REMOVED) &&
        !(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPED))
    {
        DPRINT("USBH_FdoIdleNotificationRequestComplete: DeviceState - %x\n",
               HubExtension->CurrentPowerState.DeviceState);

        if (HubExtension->CurrentPowerState.DeviceState == PowerDeviceD0)
        {
            PUSBHUB_IDLE_PORT_CONTEXT HubWorkItemBuffer;

            Status = USBH_AllocateWorkItem(HubExtension,
                                           &HubIoWorkItem,
                                           USBH_CompletePortIdleIrpsWorker,
                                           sizeof(USBHUB_IDLE_PORT_CONTEXT),
                                           (PVOID *)&HubWorkItemBuffer,
                                           DelayedWorkQueue);

            if (NT_SUCCESS(Status))
            {
                HubWorkItemBuffer->Status = NtStatus;

                USBH_HubQueuePortIdleIrps(HubExtension,
                                          &HubWorkItemBuffer->PwrList);

                USBH_QueueWorkItem(HubExtension, HubIoWorkItem);
            }
        }
        else
        {
            PUSBHUB_IDLE_HUB_CONTEXT HubWorkItemBuffer;

            Status = USBH_AllocateWorkItem(HubExtension,
                                           &HubIoWorkItem,
                                           USBH_IdleCompletePowerHubWorker,
                                           sizeof(USBHUB_IDLE_HUB_CONTEXT),
                                           (PVOID *)&HubWorkItemBuffer,
                                           DelayedWorkQueue);

            if (NT_SUCCESS(Status))
            {
                HubWorkItemBuffer->Status = NtStatus;
                USBH_QueueWorkItem(HubExtension, HubIoWorkItem);
            }
        }
    }

    if (IdleIrp ||
        InterlockedExchange((PLONG)&HubExtension->IdleRequestLock, 1))
    {
        DPRINT("USBH_FdoIdleNotificationRequestComplete: Irp - %p\n", Irp);
        IoFreeIrp(Irp);
    }

    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by USBH_FdoSubmitIdleRequestIrp().

USBH_FdoSubmitIdleRequestIrp()

NTSTATUS NTAPI USBH_FdoSubmitIdleRequestIrp

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3722 of file usbhub.c.

{
    NTSTATUS Status;
    ULONG HubFlags;
    PDEVICE_OBJECT LowerPDO;
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    KIRQL Irql;

    DPRINT("USBH_FdoSubmitIdleRequestIrp: HubExtension - %p, PendingIdleIrp - %p\n",
           HubExtension,
           HubExtension->PendingIdleIrp);

    if (HubExtension->PendingIdleIrp)
    {
        Status = STATUS_DEVICE_BUSY;
        KeSetEvent(&HubExtension->IdleEvent, EVENT_INCREMENT, FALSE);
        return Status;
    }

    HubFlags = HubExtension->HubFlags;

    if (HubFlags & USBHUB_FDO_FLAG_DEVICE_STOPPING ||
        HubFlags & USBHUB_FDO_FLAG_DEVICE_REMOVED)
    {
        HubExtension->HubFlags = HubFlags & ~USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST;
        KeSetEvent(&HubExtension->IdleEvent, EVENT_INCREMENT, FALSE);
        return STATUS_DEVICE_REMOVED;
    }

    LowerPDO = HubExtension->LowerPDO;

    HubExtension->IdleCallbackInfo.IdleCallback = USBH_FdoIdleNotificationCallback;
    HubExtension->IdleCallbackInfo.IdleContext = HubExtension;

    Irp = IoAllocateIrp(LowerPDO->StackSize, FALSE);

    if (!Irp)
    {
        HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST;
        Status = STATUS_INSUFFICIENT_RESOURCES;

        KeSetEvent(&HubExtension->IdleEvent, EVENT_INCREMENT, FALSE);
        return Status;
    }

    IoStack = IoGetNextIrpStackLocation(Irp);

    IoStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;

    IoStack->Parameters.DeviceIoControl.InputBufferLength = sizeof(USB_IDLE_CALLBACK_INFO);
    IoStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION;
    IoStack->Parameters.DeviceIoControl.Type3InputBuffer = &HubExtension->IdleCallbackInfo;

    IoSetCompletionRoutine(Irp,
                           USBH_FdoIdleNotificationRequestComplete,
                           HubExtension,
                           TRUE,
                           TRUE,
                           TRUE);

    InterlockedIncrement(&HubExtension->PendingRequestCount);
    InterlockedExchange(&HubExtension->IdleRequestLock, 0);

    HubExtension->HubFlags &= ~(USBHUB_FDO_FLAG_DEVICE_SUSPENDED |
                                USBHUB_FDO_FLAG_GOING_IDLE);

    Status = IoCallDriver(HubExtension->LowerPDO, Irp);

    IoAcquireCancelSpinLock(&Irql);

    if (Status == STATUS_PENDING &&
        HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST)
    {
        HubExtension->PendingIdleIrp = Irp;
    }

    IoReleaseCancelSpinLock(Irql);

    KeSetEvent(&HubExtension->IdleEvent, EVENT_INCREMENT, FALSE);

    return Status;
}

Referenced by USBH_CheckHubIdle().

USBH_FdoSubmitWaitWakeIrp()

NTSTATUS NTAPI USBH_FdoSubmitWaitWakeIrp

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3313 of file usbhub.c.

{
    POWER_STATE PowerState;
    NTSTATUS Status;
    PIRP Irp = NULL;
    KIRQL Irql;

    DPRINT("USBH_FdoSubmitWaitWakeIrp: ... \n");

    PowerState.SystemState = HubExtension->SystemWake;
    HubExtension->HubFlags |= USBHUB_FDO_FLAG_PENDING_WAKE_IRP;

    InterlockedIncrement(&HubExtension->PendingRequestCount);
    InterlockedExchange(&HubExtension->FdoWaitWakeLock, 0);

    Status = PoRequestPowerIrp(HubExtension->LowerPDO,
                               IRP_MN_WAIT_WAKE,
                               PowerState,
                               USBH_FdoWaitWakeIrpCompletion,
                               HubExtension,
                               &Irp);

    IoAcquireCancelSpinLock(&Irql);

    if (Status == STATUS_PENDING)
    {
        if (HubExtension->HubFlags & USBHUB_FDO_FLAG_PENDING_WAKE_IRP)
        {
            HubExtension->PendingWakeIrp = Irp;
            DPRINT("USBH_FdoSubmitWaitWakeIrp: PendingWakeIrp - %p\n",
                   HubExtension->PendingWakeIrp);
        }
    }
    else
    {
        HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_PENDING_WAKE_IRP;

        if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
        {
            KeSetEvent(&HubExtension->PendingRequestEvent,
                       EVENT_INCREMENT,
                       FALSE);
        }
    }

    IoReleaseCancelSpinLock(Irql);

    return Status;
}

Referenced by USBH_FdoIdleNotificationCallback().

USBH_FdoSyncSubmitUrb()

NTSTATUS NTAPI USBH_FdoSyncSubmitUrb	(	IN PDEVICE_OBJECT	FdoDevice,
		IN PURB	Urb
	)

Definition at line 355 of file usbhub.c.

{
    PUSBHUB_FDO_EXTENSION HubExtension;

    DPRINT("USBH_FdoSyncSubmitUrb: FdoDevice - %p, Urb - %p\n",
           FdoDevice,
           Urb);

    HubExtension = FdoDevice->DeviceExtension;
    return USBH_SyncSubmitUrb(HubExtension->LowerDevice, Urb);
}

Referenced by USBH_AbortInterruptPipe(), USBH_GetDeviceDescriptor(), USBH_OpenConfiguration(), USBH_ResetInterruptPipe(), USBH_SyncGetDeviceConfigurationDescriptor(), USBH_SyncGetStatus(), and USBH_Transact().

USBH_FdoWaitWakeIrpCompletion()

VOID NTAPI USBH_FdoWaitWakeIrpCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MinorFunction,
		IN POWER_STATE	PowerState,
		IN PVOID	Context,
		IN PIO_STATUS_BLOCK	IoStatus
	)

Definition at line 3302 of file usbhub.c.

{
    DPRINT("USBH_FdoWaitWakeIrpCompletion ... \n");
}

Referenced by USBH_FdoSubmitWaitWakeIrp().

USBH_FlushPortPwrList()

VOID NTAPI USBH_FlushPortPwrList

(

IN PUSBHUB_FDO_EXTENSION

HubExtension

)

Definition at line 3125 of file usbhub.c.

{
    PDEVICE_OBJECT PortDevice;
    PUSBHUB_PORT_PDO_EXTENSION PortExtension;
    PLIST_ENTRY Entry;
    ULONG Port;

    DPRINT("USBH_FlushPortPwrList ... \n");

    InterlockedIncrement((PLONG)&HubExtension->PendingRequestCount);

    KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
                          Executive,
                          KernelMode,
                          FALSE,
                          NULL);

    for (Port = 0; Port < HubExtension->HubDescriptor->bNumberOfPorts; ++Port)
    {
        PortDevice = HubExtension->PortData[Port].DeviceObject;

        if (!PortDevice)
        {
            continue;
        }

        PortExtension = PortDevice->DeviceExtension;

        InterlockedExchange((PLONG)&PortExtension->StateBehindD2, 0);

        while (TRUE)
        {
            Entry = ExInterlockedRemoveHeadList(&PortExtension->PortPowerList,
                                                &PortExtension->PortPowerListSpinLock);

            if (!Entry)
            {
                break;
            }

            DPRINT1("USBH_FlushPortPwrList: PortPowerList FIXME\n");
            DbgBreakPoint();
        }
    }

    KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
                       LOW_REALTIME_PRIORITY,
                       1,
                       FALSE);

    if (!InterlockedDecrement((PLONG)&HubExtension->PendingRequestCount))
    {
        KeSetEvent(&HubExtension->PendingRequestEvent,
                   EVENT_INCREMENT,
                   FALSE);
    }
}

Referenced by USBH_CompletePortIdleIrpsWorker(), and USBH_HubCompletePortIdleIrps().

USBH_FreeWorkItem()

VOID NTAPI USBH_FreeWorkItem

(

IN PUSBHUB_IO_WORK_ITEM

HubIoWorkItem

)

Definition at line 2937 of file usbhub.c.

{
    PIO_WORKITEM WorkItem;

    DPRINT("USBH_FreeWorkItem: ... \n");

    WorkItem = HubIoWorkItem->HubWorkItem;

    if (HubIoWorkItem->HubWorkItemBuffer)
    {
        ExFreePoolWithTag(HubIoWorkItem->HubWorkItemBuffer, USB_HUB_TAG);
    }

    ExFreePoolWithTag(HubIoWorkItem, USB_HUB_TAG);

    IoFreeWorkItem(WorkItem);
}

Referenced by USBH_ChangeIndicationProcessChange().

USBH_GetConfigurationDescriptor()

NTSTATUS NTAPI USBH_GetConfigurationDescriptor	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PUSB_CONFIGURATION_DESCRIPTOR *	OutDescriptor
	)

Definition at line 974 of file usbhub.c.

{
    PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor;
    ULONG ReturnedLen;
    SIZE_T DescriptorLen;
    NTSTATUS Status;

    DPRINT("USBH_GetConfigurationDescriptor: ... \n");

    DescriptorLen = MAXUCHAR;

    while (TRUE)
    {
        ConfigDescriptor = ExAllocatePoolWithTag(NonPagedPool,
                                                 DescriptorLen,
                                                 USB_HUB_TAG);

        if (!ConfigDescriptor)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }

        Status = USBH_SyncGetDeviceConfigurationDescriptor(DeviceObject,
                                                           ConfigDescriptor,
                                                           DescriptorLen,
                                                           &ReturnedLen);

        if (ReturnedLen < sizeof(USB_CONFIGURATION_DESCRIPTOR))
        {
            Status = STATUS_DEVICE_DATA_ERROR;
        }

        if (!NT_SUCCESS(Status))
        {
            break;
        }

        *OutDescriptor = ConfigDescriptor;

        if (ConfigDescriptor->wTotalLength <= DescriptorLen)
        {
            break;
        }

        DescriptorLen = ConfigDescriptor->wTotalLength;

        ExFreePool(ConfigDescriptor);
        *OutDescriptor = NULL;
    }

    if (NT_SUCCESS(Status))
    {
        if (ReturnedLen < ConfigDescriptor->wTotalLength)
        {
            Status = STATUS_DEVICE_DATA_ERROR;
        }
    }
    else
    {
        if (ConfigDescriptor)
        {
            ExFreePool(ConfigDescriptor);
        }

        *OutDescriptor = NULL;
    }

    return Status;
}

Referenced by USBH_ProcessDeviceInformation(), and USBH_StartHubFdoDevice().

USBH_GetConfigValue()

NTSTATUS NTAPI USBH_GetConfigValue	(	IN PWSTR	ValueName,
		IN ULONG	ValueType,
		IN PVOID	ValueData,
		IN ULONG	ValueLength,
		IN PVOID	Context,
		IN PVOID	EntryContext
	)

Definition at line 34 of file usbhub.c.

{
    NTSTATUS Status = STATUS_SUCCESS;

    DPRINT("USBHUB_GetConfigValue: ... \n");

    if (ValueType == REG_BINARY)
    {
        *(PUCHAR)EntryContext = *(PUCHAR)ValueData;
    }
    else if (ValueType == REG_DWORD)
    {
        *(PULONG)EntryContext = *(PULONG)ValueData;
    }
    else
    {
        Status = STATUS_INVALID_PARAMETER;
    }

    return Status;
}

Referenced by USBH_RegQueryGenericUSBDeviceString().

USBH_GetDeviceDescriptor()

NTSTATUS NTAPI USBH_GetDeviceDescriptor	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PUSB_DEVICE_DESCRIPTOR	HubDeviceDescriptor
	)

Definition at line 877 of file usbhub.c.

{
    struct _URB_CONTROL_DESCRIPTOR_REQUEST * Urb;
    NTSTATUS Status;

    DPRINT("USBH_GetDeviceDescriptor: ... \n");

    Urb = ExAllocatePoolWithTag(NonPagedPool,
                                sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST),
                                USB_HUB_TAG);

    if (!Urb)
    {
        DPRINT1("USBH_SyncGetDeviceHandle: Urb - NULL!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(Urb, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));

    Urb->Hdr.Function = URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE;
    Urb->Hdr.Length = sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST);

    Urb->TransferBufferLength = sizeof(USB_DEVICE_DESCRIPTOR);
    Urb->TransferBuffer = HubDeviceDescriptor;
    Urb->DescriptorType = USB_DEVICE_DESCRIPTOR_TYPE;

    Status = USBH_FdoSyncSubmitUrb(DeviceObject, (PURB)Urb);

    ExFreePoolWithTag(Urb, USB_HUB_TAG);

    return Status;
}

Referenced by USBH_StartHubFdoDevice().

USBH_GetDeviceType()

NTSTATUS NTAPI USBH_GetDeviceType	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PUSB_DEVICE_HANDLE	DeviceHandle,
		OUT USB_DEVICE_TYPE *	OutDeviceType
	)

Definition at line 608 of file usbhub.c.

{
    PUSB_BUSIFFN_GET_DEVICE_INFORMATION QueryDeviceInformation;
    PUSB_DEVICE_INFORMATION_0 DeviceInfo;
    SIZE_T DeviceInformationBufferLength;
    USB_DEVICE_TYPE DeviceType = Usb11Device;
    ULONG dummy;
    NTSTATUS Status;

    DPRINT("USBH_GetDeviceType: ... \n");

    QueryDeviceInformation = HubExtension->BusInterface.QueryDeviceInformation;

    if (!QueryDeviceInformation)
    {
        DPRINT1("USBH_GetDeviceType: no QueryDeviceInformation()\n");
        return STATUS_NOT_IMPLEMENTED;
    }

    DeviceInformationBufferLength = sizeof(USB_DEVICE_INFORMATION_0);

    while (TRUE)
    {
        DeviceInfo = ExAllocatePoolWithTag(PagedPool,
                                           DeviceInformationBufferLength,
                                           USB_HUB_TAG);

        if (!DeviceInfo)
        {
            DPRINT1("USBH_GetDeviceType: ExAllocatePoolWithTag() failed\n");
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }

        RtlZeroMemory(DeviceInfo, DeviceInformationBufferLength);

        DeviceInfo->InformationLevel = 0;

        Status = QueryDeviceInformation(HubExtension->BusInterface.BusContext,
                                        DeviceHandle,
                                        DeviceInfo,
                                        DeviceInformationBufferLength,
                                        &dummy);

        if (Status != STATUS_BUFFER_TOO_SMALL)
        {
            if (NT_SUCCESS(Status))
            {
                DeviceType = DeviceInfo->DeviceType;
            }

            ExFreePoolWithTag(DeviceInfo, USB_HUB_TAG);
            break;
        }

        DeviceInformationBufferLength = DeviceInfo->ActualLength;
        ExFreePoolWithTag(DeviceInfo, USB_HUB_TAG);
    }

    if (OutDeviceType)
    {
        *OutDeviceType = DeviceType;
        DPRINT("USBH_GetDeviceType: DeviceType - %x\n", DeviceType);
    }

    return Status;
}

Referenced by USBH_StartHubFdoDevice().

USBH_GetPortStatus()

NTSTATUS NTAPI USBH_GetPortStatus	(	IN PUSBHUB_FDO_EXTENSION	HubExtension,
		IN PULONG	PortStatus
	)

Definition at line 1979 of file usbhub.c.

{
    PIRP Irp;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    KEVENT Event;
    IO_STATUS_BLOCK IoStatusBlock;

    DPRINT("USBH_GetPortStatus ... \n");

    *PortStatus = 0;

    KeInitializeEvent(&Event, NotificationEvent, FALSE);

    Irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_USB_GET_PORT_STATUS,
                                        HubExtension->LowerDevice,
                                        NULL,
                                        0,
                                        NULL,
                                        0,
                                        TRUE,
                                        &Event,
                                        &IoStatusBlock);

    if (!Irp)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    IoStack = IoGetNextIrpStackLocation(Irp);
    IoStack->Parameters.Others.Argument1 = PortStatus;

    Status = IoCallDriver(HubExtension->LowerDevice, Irp);

    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,