reactos/drivers/usb/usbhub/fdo.c

/*
 * PROJECT:         ReactOS Universal Serial Bus Hub Driver
 * LICENSE:         GPL - See COPYING in the top level directory
 * FILE:            drivers/usb/usbhub/fdo.c
 * PURPOSE:         Handle FDO
 * PROGRAMMERS:
 *                  Michael Martin (michael.martin@reactos.org)
 *                  Johannes Anderwald (johannes.anderwald@reactos.org)
 */

#include "usbhub.h"

#include <stdio.h>

#define NDEBUG
#include <debug.h>

NTSTATUS
QueryStatusChangeEndpoint(
    IN PDEVICE_OBJECT DeviceObject);

NTSTATUS
CreateUsbChildDeviceObject(
    IN PDEVICE_OBJECT UsbHubDeviceObject,
    IN LONG PortId,
    OUT PDEVICE_OBJECT *UsbChildDeviceObject,
    IN ULONG PortStatus);

NTSTATUS
DestroyUsbChildDeviceObject(
    IN PDEVICE_OBJECT UsbHubDeviceObject,
    IN LONG PortId);


NTSTATUS
GetPortStatusAndChange(
    IN PDEVICE_OBJECT RootHubDeviceObject,
    IN ULONG PortId,
    OUT PPORT_STATUS_CHANGE StatusChange)
{
    NTSTATUS Status;
    PURB Urb;

    //
    // Allocate URB
    //
    Urb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB), USB_HUB_TAG);
    if (!Urb)
    {
        DPRINT1("Failed to allocate memory for URB!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Zero it
    //
    RtlZeroMemory(Urb, sizeof(URB));

    //
    // Initialize URB for getting Port Status
    //
    UsbBuildVendorRequest(Urb,
                          URB_FUNCTION_CLASS_OTHER,
                          sizeof(Urb->UrbControlVendorClassRequest),
                          USBD_TRANSFER_DIRECTION_OUT,
                          0,
                          USB_REQUEST_GET_STATUS,
                          0,
                          PortId,
                          StatusChange,
                          0,
                          sizeof(PORT_STATUS_CHANGE),
                          0);

    // FIXME: support usb hubs
    Urb->UrbHeader.UsbdDeviceHandle = NULL;


    //
    // Query the Root Hub
    //
    Status = SubmitRequestToRootHub(RootHubDeviceObject, IOCTL_INTERNAL_USB_SUBMIT_URB, Urb, NULL);

    //
    // Free URB
    //
    ExFreePool(Urb);

    return Status;
}

NTSTATUS
SetPortFeature(
    IN PDEVICE_OBJECT RootHubDeviceObject,
    IN ULONG PortId,
    IN ULONG Feature)
{
    NTSTATUS Status;
    PURB Urb;

    //
    // Allocate URB
    //
    Urb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB), USB_HUB_TAG);
    if (!Urb)
    {
        DPRINT1("Failed to allocate memory for URB!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Zero it
    //
    RtlZeroMemory(Urb, sizeof(URB));

    //
    // Initialize URB for Clearing Port Reset
    //
    UsbBuildVendorRequest(Urb,
                          URB_FUNCTION_CLASS_OTHER,
                          sizeof(Urb->UrbControlVendorClassRequest),
                          USBD_TRANSFER_DIRECTION_IN,
                          0,
                          USB_REQUEST_SET_FEATURE,
                          Feature,
                          PortId,
                          NULL,
                          0,
                          0,
                          0);

    // FIXME support usbhubs
    Urb->UrbHeader.UsbdDeviceHandle = NULL;

    //
    // Query the Root Hub
    //
    Status = SubmitRequestToRootHub(RootHubDeviceObject, IOCTL_INTERNAL_USB_SUBMIT_URB, Urb, NULL);

    //
    // Free URB
    //
    ExFreePool(Urb);

    return Status;
}

NTSTATUS
ClearPortFeature(
    IN PDEVICE_OBJECT RootHubDeviceObject,
    IN ULONG PortId,
    IN ULONG Feature)
{
    NTSTATUS Status;
    PURB Urb;

    //
    // Allocate a URB
    //
    Urb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB), USB_HUB_TAG);
    if (!Urb)
    {
        DPRINT1("Failed to allocate memory for URB!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Zero it
    //
    RtlZeroMemory(Urb, sizeof(URB));

    //
    // Initialize URB for Clearing Port Reset
    //
    UsbBuildVendorRequest(Urb,
                          URB_FUNCTION_CLASS_OTHER,
                          sizeof(Urb->UrbControlVendorClassRequest),
                          USBD_TRANSFER_DIRECTION_IN,
                          0,
                          USB_REQUEST_CLEAR_FEATURE,
                          Feature,
                          PortId,
                          NULL,
                          0,
                          0,
                          0);

    // FIXME: support usb hubs
    Urb->UrbHeader.UsbdDeviceHandle = NULL;

    //
    // Query the Root Hub
    //
    Status = SubmitRequestToRootHub(RootHubDeviceObject, IOCTL_INTERNAL_USB_SUBMIT_URB, Urb, NULL);

    //
    // Free URB
    //
    ExFreePool(Urb);

    return Status;
}

VOID NTAPI
DeviceStatusChangeThread(
    IN PVOID Context)
{
    NTSTATUS Status;
    PDEVICE_OBJECT DeviceObject, RootHubDeviceObject;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PWORK_ITEM_DATA WorkItemData;
    PORT_STATUS_CHANGE PortStatus;
    ULONG PortId;
    BOOLEAN SignalResetComplete = FALSE;

    DPRINT("Entered DeviceStatusChangeThread, Context %x\n", Context);

    WorkItemData = (PWORK_ITEM_DATA)Context;
    DeviceObject = (PDEVICE_OBJECT)WorkItemData->Context;
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;
    //
    // Loop all ports
    //
    for (PortId = 1; PortId <= HubDeviceExtension->UsbExtHubInfo.NumberOfPorts; PortId++)
    {
        //
        // Get Port Status
        //
        Status = GetPortStatusAndChange(RootHubDeviceObject, PortId, &PortStatus);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to get port status for port %d, Status %x\n", PortId, Status);
            // FIXME: Do we really want to halt further SCE requests?
            return;
        }

        DPRINT("Port %d Status %x\n", PortId, PortStatus.Status);
        DPRINT("Port %d Change %x\n", PortId, PortStatus.Change);


        //
        // Check for new device connection
        //
        if (PortStatus.Change & USB_PORT_STATUS_CONNECT)
        {
            //
            // Clear Port Connect
            //
            Status = ClearPortFeature(RootHubDeviceObject, PortId, C_PORT_CONNECTION);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to clear connection change for port %d\n", PortId);
                continue;
            }

            //
            // Is this a connect or disconnect?
            //
            if (!(PortStatus.Status & USB_PORT_STATUS_CONNECT))
            {
                DPRINT1("Device disconnected from port %d\n", PortId);

                Status = DestroyUsbChildDeviceObject(DeviceObject, PortId);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("Failed to delete child device object after disconnect\n");
                    continue;
                }
            }
            else
            {
                DPRINT1("Device connected from port %d\n", PortId);

                // No SCE completion done for clearing C_PORT_CONNECT

                //
                // Reset Port
                //
                Status = SetPortFeature(RootHubDeviceObject, PortId, PORT_RESET);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("Failed to reset port %d\n", PortId);
                    SignalResetComplete = TRUE;
                    continue;
                }
            }
        }
        else if (PortStatus.Change & USB_PORT_STATUS_ENABLE)
        {
            //
            // Clear Enable
            //
            Status = ClearPortFeature(RootHubDeviceObject, PortId, C_PORT_ENABLE);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to clear enable change on port %d\n", PortId);
                continue;
            }
        }
        else if (PortStatus.Change & USB_PORT_STATUS_RESET)
        {
            //
            // Request event signalling later
            //
            SignalResetComplete = TRUE;

            //
            // Clear Reset
            //
            Status = ClearPortFeature(RootHubDeviceObject, PortId, C_PORT_RESET);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to clear reset change on port %d\n", PortId);
                continue;
            }

            //
            // Get Port Status
            //
            Status = GetPortStatusAndChange(RootHubDeviceObject, PortId, &PortStatus);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to get port status for port %d, Status %x\n", PortId, Status);
                // FIXME: Do we really want to halt further SCE requests?
                return;
            }

            DPRINT("Port %d Status %x\n", PortId, PortStatus.Status);
            DPRINT("Port %d Change %x\n", PortId, PortStatus.Change);

            //
            // Check that reset was cleared
            //
            if(PortStatus.Change & USB_PORT_STATUS_RESET)
            {
                DPRINT1("Port did not clear reset! Possible Hardware problem!\n");
                continue;
            }

            //
            // Check if the device is still connected
            //
            if (!(PortStatus.Status & USB_PORT_STATUS_CONNECT))
            {
                DPRINT1("Device has been disconnected\n");
                continue;
            }

            //
            // Make sure its Connected and Enabled
            //
            if (!(PortStatus.Status & (USB_PORT_STATUS_CONNECT | USB_PORT_STATUS_ENABLE)))
            {
                DPRINT1("Usb Device is not connected and enabled!\n");
                //
                // Attempt another reset
                //
                Status = SetPortFeature(RootHubDeviceObject, PortId, PORT_RESET);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("Failed to reset port %d\n", PortId);
                }
                continue;
            }

            //
            // This is a new device
            //
            Status = CreateUsbChildDeviceObject(DeviceObject, PortId, NULL, PortStatus.Status);
        }
    }

    ExFreePool(WorkItemData);

    //
    // Send another SCE Request
    //
    DPRINT("Sending another SCE!\n");
    QueryStatusChangeEndpoint(DeviceObject);

    //
    // Check if a reset event was satisfied
    //
    if (SignalResetComplete)
    {
        //
        // Signal anyone waiting on it
        //
        KeSetEvent(&HubDeviceExtension->ResetComplete, IO_NO_INCREMENT, FALSE);
    }
}

NTSTATUS
NTAPI
StatusChangeEndpointCompletion(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context)
{
    PDEVICE_OBJECT RealDeviceObject;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PWORK_ITEM_DATA WorkItemData;

    RealDeviceObject = (PDEVICE_OBJECT)Context;
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION)RealDeviceObject->DeviceExtension;

    //
    // NOTE: USBPORT frees this IRP
    //
    DPRINT("Received Irp %x, HubDeviceExtension->PendingSCEIrp %x\n", Irp, HubDeviceExtension->PendingSCEIrp);
    //IoFreeIrp(Irp);

    //
    // Create and initialize work item data
    //
    WorkItemData = ExAllocatePoolWithTag(NonPagedPool, sizeof(WORK_ITEM_DATA), USB_HUB_TAG);
    if (!WorkItemData)
    {
        DPRINT1("Failed to allocate memory!n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    WorkItemData->Context = RealDeviceObject;

    DPRINT("Queuing work item\n");

    //
    // Queue the work item to handle initializing the device
    //
    ExInitializeWorkItem(&WorkItemData->WorkItem, DeviceStatusChangeThread, (PVOID)WorkItemData);
    ExQueueWorkItem(&WorkItemData->WorkItem, DelayedWorkQueue);

    //
    // Return more processing required so the IO Manger doesn’t try to mess with IRP just freed
    //
    return STATUS_MORE_PROCESSING_REQUIRED;
}

NTSTATUS
QueryStatusChangeEndpoint(
    IN PDEVICE_OBJECT DeviceObject)
{
    PDEVICE_OBJECT RootHubDeviceObject;
    PIO_STACK_LOCATION Stack;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PURB PendingSCEUrb;

    HubDeviceExtension = (PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;

    //
    // Allocate a URB
    //
    PendingSCEUrb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB), USB_HUB_TAG);

    //
    // Initialize URB for Status Change Endpoint request
    //
    UsbBuildInterruptOrBulkTransferRequest(PendingSCEUrb,
                                           sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER),
                                           HubDeviceExtension->PipeHandle,
                                           HubDeviceExtension->PortStatusChange,
                                           NULL,
                                           sizeof(USHORT) * 2 * HubDeviceExtension->UsbExtHubInfo.NumberOfPorts,
                                           USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
                                           NULL);

    // Set the device handle
    PendingSCEUrb->UrbHeader.UsbdDeviceHandle = HubDeviceExtension->RootHubHandle;

    //
    // Allocate an Irp
    //
    HubDeviceExtension->PendingSCEIrp = ExAllocatePoolWithTag(NonPagedPool,
                                                              IoSizeOfIrp(RootHubDeviceObject->StackSize),
                                                              USB_HUB_TAG);
/*
    HubDeviceExtension->PendingSCEIrp = IoAllocateIrp(RootHubDeviceObject->StackSize,
                                  FALSE);
*/
    DPRINT("Allocated IRP %x\n", HubDeviceExtension->PendingSCEIrp);

    if (!HubDeviceExtension->PendingSCEIrp)
    {
        DPRINT1("USBHUB: Failed to allocate IRP for SCE request!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Initialize the IRP
    //
    IoInitializeIrp(HubDeviceExtension->PendingSCEIrp,
                    IoSizeOfIrp(RootHubDeviceObject->StackSize),
                    RootHubDeviceObject->StackSize);

    HubDeviceExtension->PendingSCEIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    HubDeviceExtension->PendingSCEIrp->IoStatus.Information = 0;
    HubDeviceExtension->PendingSCEIrp->Flags = 0;
    HubDeviceExtension->PendingSCEIrp->UserBuffer = NULL;

    //
    // Get the Next Stack Location and Initialize it
    //
    Stack = IoGetNextIrpStackLocation(HubDeviceExtension->PendingSCEIrp);
    Stack->DeviceObject = DeviceObject;
    Stack->Parameters.Others.Argument1 = PendingSCEUrb;
    Stack->Parameters.Others.Argument2 = NULL;
    Stack->MajorFunction =  IRP_MJ_INTERNAL_DEVICE_CONTROL;
    Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB;

    //
    // Set the completion routine for when device is connected to root hub
    //
    IoSetCompletionRoutine(HubDeviceExtension->PendingSCEIrp,
                           StatusChangeEndpointCompletion,
                           DeviceObject,
                           TRUE,
                           TRUE,
                           TRUE);

    //
    // Send to RootHub
    //
    DPRINT("DeviceObject is %x\n", DeviceObject);
    DPRINT("Iocalldriver %x with irp %x\n", RootHubDeviceObject, HubDeviceExtension->PendingSCEIrp);
    IoCallDriver(RootHubDeviceObject, HubDeviceExtension->PendingSCEIrp);

    return STATUS_PENDING;
}

NTSTATUS
QueryInterface(
    IN PDEVICE_OBJECT DeviceObject,
    IN CONST GUID InterfaceType,
    IN LONG Size,
    IN LONG Version,
    OUT PVOID Interface)
{
    KEVENT Event;
    PIRP Irp;
    IO_STATUS_BLOCK IoStatus;
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack = NULL;

    //
    // Initialize the Event used to wait for Irp completion
    //
    KeInitializeEvent(&Event, NotificationEvent, FALSE);

    //
    // Build Control Request
    //
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
                                       DeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);

    //
    // Get Next Stack Location and Initialize it.
    //
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MinorFunction = IRP_MN_QUERY_INTERFACE;
    Stack->Parameters.QueryInterface.InterfaceType= &InterfaceType;//USB_BUS_INTERFACE_HUB_GUID;
    Stack->Parameters.QueryInterface.Size = Size;
    Stack->Parameters.QueryInterface.Version = Version;
    Stack->Parameters.QueryInterface.Interface = Interface;
    Stack->Parameters.QueryInterface.InterfaceSpecificData = NULL;

    //
    // Initialize the status block before sending the IRP
    //
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;

    Status = IoCallDriver(DeviceObject, Irp);

    if (Status == STATUS_PENDING)
    {
        DPRINT("Operation pending\n");
        KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }

    return Status;
}

NTSTATUS
GetUsbDeviceDescriptor(
    IN PDEVICE_OBJECT ChildDeviceObject,
    IN UCHAR DescriptorType,
    IN UCHAR Index,
    IN USHORT LangId,
    OUT PVOID TransferBuffer,
    IN ULONG TransferBufferLength)
{
    NTSTATUS Status;
    PDEVICE_OBJECT RootHubDeviceObject;
    PURB Urb;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PHUB_CHILDDEVICE_EXTENSION ChildDeviceExtension;

    //
    // Get the Hubs Device Extension
    //
    ChildDeviceExtension = (PHUB_CHILDDEVICE_EXTENSION)ChildDeviceObject->DeviceExtension;
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) ChildDeviceExtension->ParentDeviceObject->DeviceExtension;
    RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;

    //
    // Allocate a URB
    //
    Urb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB), USB_HUB_TAG);
    if (!Urb)
    {
        DPRINT1("Failed to allocate memory for URB!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Zero it
    //
    RtlZeroMemory(Urb, sizeof(URB));

    //
    // Initialize URB for getting device descriptor
    //
    UsbBuildGetDescriptorRequest(Urb,
                                 sizeof(Urb->UrbControlDescriptorRequest),
                                 DescriptorType,
                                 Index,
                                 LangId,
                                 TransferBuffer,
                                 NULL,
                                 TransferBufferLength,
                                 NULL);

    //
    // Set the device handle
    //
    Urb->UrbHeader.UsbdDeviceHandle = (PVOID)ChildDeviceExtension->UsbDeviceHandle;

    //
    // Query the Root Hub
    //
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    Urb,
                                    NULL);

    return Status;
}

NTSTATUS
GetUsbStringDescriptor(
    IN PDEVICE_OBJECT ChildDeviceObject,
    IN UCHAR Index,
    IN USHORT LangId,
    OUT PVOID *TransferBuffer,
    OUT USHORT *Size)
{
    NTSTATUS Status;
    PUSB_STRING_DESCRIPTOR StringDesc = NULL;
    ULONG SizeNeeded;
    LPWSTR Buffer;

    StringDesc = ExAllocatePoolWithTag(NonPagedPool,
                                       sizeof(USB_STRING_DESCRIPTOR),
                                       USB_HUB_TAG);
    if (!StringDesc)
    {
        DPRINT1("Failed to allocate buffer for string!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Get the index string descriptor length
    // FIXME: Implement LangIds
    //
    Status = GetUsbDeviceDescriptor(ChildDeviceObject,
                                    USB_STRING_DESCRIPTOR_TYPE,
                                    Index,
                                    0x0409,
                                    StringDesc,
                                    sizeof(USB_STRING_DESCRIPTOR));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("GetUsbDeviceDescriptor failed with status %x\n", Status);
        ExFreePool(StringDesc);
        return Status;
    }
    DPRINT1("StringDesc->bLength %d\n", StringDesc->bLength);

    //
    // Did we get something more than the length of the first two fields of structure?
    //
    if (StringDesc->bLength == 2)
    {
        DPRINT1("USB Device Error!\n");
        ExFreePool(StringDesc);
        return STATUS_DEVICE_DATA_ERROR;
    }
    SizeNeeded = StringDesc->bLength + sizeof(WCHAR);

    //
    // Free String
    //
    ExFreePool(StringDesc);

    //
    // Recreate with appropriate size
    //
    StringDesc = ExAllocatePoolWithTag(NonPagedPool,
                                       SizeNeeded,
                                       USB_HUB_TAG);
    if (!StringDesc)
    {
        DPRINT1("Failed to allocate buffer for string!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(StringDesc, SizeNeeded);

    //
    // Get the string
    //
    Status = GetUsbDeviceDescriptor(ChildDeviceObject,
                                    USB_STRING_DESCRIPTOR_TYPE,
                                    Index,
                                    0x0409,
                                    StringDesc,
                                    SizeNeeded);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("GetUsbDeviceDescriptor failed with status %x\n", Status);
        ExFreePool(StringDesc);
        return Status;
    }

    //
    // Allocate Buffer to return
    //
    Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                   SizeNeeded,
                                   USB_HUB_TAG);
    if (!Buffer)
    {
        DPRINT1("Failed to allocate buffer for string!\n");
        ExFreePool(StringDesc);
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(Buffer, SizeNeeded);

    //
    // Copy the string to destination
    //
    RtlCopyMemory(Buffer, StringDesc->bString, SizeNeeded - FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString));
    *Size = SizeNeeded;
    *TransferBuffer = Buffer;

    ExFreePool(StringDesc);

    return STATUS_SUCCESS;
}

ULONG
IsCompositeDevice(
    IN PUSB_DEVICE_DESCRIPTOR DeviceDescriptor,
    IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor)
{
    if (DeviceDescriptor->bNumConfigurations != 1)
    {
         //
         // composite device must have only one configuration
         //
         DPRINT1("IsCompositeDevice bNumConfigurations %x\n", DeviceDescriptor->bNumConfigurations);
         return FALSE;
    }

    if (ConfigurationDescriptor->bNumInterfaces < 2)
    {
        //
        // composite device must have multiple interfaces
        //
        DPRINT1("IsCompositeDevice bNumInterfaces %x\n", ConfigurationDescriptor->bNumInterfaces);
        return FALSE;
    }

    if (DeviceDescriptor->bDeviceClass == 0)
    {
        //
        // composite device
        //
        ASSERT(DeviceDescriptor->bDeviceSubClass == 0);
        ASSERT(DeviceDescriptor->bDeviceProtocol == 0);
        DPRINT1("IsCompositeDevice: TRUE\n");
        return TRUE;
    }

    if (DeviceDescriptor->bDeviceClass == 0xEF &&
        DeviceDescriptor->bDeviceSubClass == 0x02 &&
        DeviceDescriptor->bDeviceProtocol == 0x01)
    {
        //
        // USB-IF association descriptor
        //
        DPRINT1("IsCompositeDevice: TRUE\n");
        return TRUE;
    }

    DPRINT1("DeviceDescriptor bDeviceClass %x bDeviceSubClass %x bDeviceProtocol %x\n", DeviceDescriptor->bDeviceClass, DeviceDescriptor->bDeviceSubClass, DeviceDescriptor->bDeviceProtocol);

    //
    // not a composite device
    //
    return FALSE;
}

NTSTATUS
CreateDeviceIds(
    PDEVICE_OBJECT UsbChildDeviceObject)
{
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG Index = 0;
    LPWSTR DeviceString;
    WCHAR Buffer[200];
    PHUB_CHILDDEVICE_EXTENSION UsbChildExtension;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PUSB_DEVICE_DESCRIPTOR DeviceDescriptor;
    PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
    PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;

    //
    // get child device extension
    //
    UsbChildExtension = (PHUB_CHILDDEVICE_EXTENSION)UsbChildDeviceObject->DeviceExtension;

    // get hub device extension
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) UsbChildExtension->ParentDeviceObject->DeviceExtension;

    //
    // get device descriptor
    //
    DeviceDescriptor = &UsbChildExtension->DeviceDesc;

    //
    // get configuration descriptor
    //
    ConfigurationDescriptor = UsbChildExtension->FullConfigDesc;

    //
    // use first interface descriptor available
    //
    InterfaceDescriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, 0, -1, -1, -1, -1);
    if (InterfaceDescriptor == NULL)
    {
         DPRINT1("Error USBD_ParseConfigurationDescriptorEx failed to parse interface descriptor\n");
         return STATUS_INVALID_PARAMETER;
    }

    ASSERT(InterfaceDescriptor);

    //
    // Construct the CompatibleIds
    //
    if (IsCompositeDevice(DeviceDescriptor, ConfigurationDescriptor))
    {
        //
        // sanity checks
        //
        ASSERT(DeviceDescriptor->bNumConfigurations == 1);
        ASSERT(ConfigurationDescriptor->bNumInterfaces > 1);
        Index += swprintf(&Buffer[Index],
                          L"USB\\DevClass_%02x&SubClass_%02x&Prot_%02x",
                          DeviceDescriptor->bDeviceClass, DeviceDescriptor->bDeviceSubClass, DeviceDescriptor->bDeviceProtocol) + 1;
        Index += swprintf(&Buffer[Index],
                          L"USB\\DevClass_%02x&SubClass_%02x",
                          DeviceDescriptor->bDeviceClass, DeviceDescriptor->bDeviceSubClass) + 1;
        Index += swprintf(&Buffer[Index],
                          L"USB\\DevClass_%02x",
                          DeviceDescriptor->bDeviceClass) + 1;
        Index += swprintf(&Buffer[Index],
                          L"USB\\COMPOSITE") + 1;
    }
    else
    {
        //
        // FIXME: support multiple configurations
        //
        ASSERT(DeviceDescriptor->bNumConfigurations == 1);

        if (DeviceDescriptor->bDeviceClass == 0)
        {
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x&SubClass_%02x&Prot_%02x",
                          InterfaceDescriptor->bInterfaceClass, InterfaceDescriptor->bInterfaceSubClass, InterfaceDescriptor->bInterfaceProtocol) + 1;
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x&SubClass_%02x",
                          InterfaceDescriptor->bInterfaceClass, InterfaceDescriptor->bInterfaceSubClass) + 1;
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x",
                          InterfaceDescriptor->bInterfaceClass) + 1;
        }
        else
        {
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x&SubClass_%02x&Prot_%02x",
                          DeviceDescriptor->bDeviceClass, DeviceDescriptor->bDeviceSubClass, DeviceDescriptor->bDeviceProtocol) + 1;
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x&SubClass_%02x",
                          DeviceDescriptor->bDeviceClass, DeviceDescriptor->bDeviceSubClass) + 1;
            Index += swprintf(&Buffer[Index],
                          L"USB\\Class_%02x",
                          DeviceDescriptor->bDeviceClass) + 1;
        }
    }

    //
    // now allocate the buffer
    //
    DeviceString = ExAllocatePool(NonPagedPool, (Index + 1) * sizeof(WCHAR));
    if (!DeviceString)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // copy buffer
    //
    RtlCopyMemory(DeviceString, Buffer, Index * sizeof(WCHAR));
    DeviceString[Index] = UNICODE_NULL;
    UsbChildExtension->usCompatibleIds.Buffer = DeviceString;
    UsbChildExtension->usCompatibleIds.Length = Index * sizeof(WCHAR);
    UsbChildExtension->usCompatibleIds.MaximumLength = (Index + 1) * sizeof(WCHAR);
    DPRINT("usCompatibleIds %wZ\n", &UsbChildExtension->usCompatibleIds);

    //
    // Construct DeviceId string
    //
    Index = swprintf(Buffer, L"USB\\Vid_%04x&Pid_%04x", UsbChildExtension->DeviceDesc.idVendor, UsbChildExtension->DeviceDesc.idProduct) + 1;

    //
    // now allocate the buffer
    //
    DeviceString = ExAllocatePool(NonPagedPool, Index * sizeof(WCHAR));
    if (!DeviceString)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // copy buffer
    //
    RtlCopyMemory(DeviceString, Buffer, Index * sizeof(WCHAR));
    UsbChildExtension->usDeviceId.Buffer = DeviceString;
    UsbChildExtension->usDeviceId.Length = (Index-1) * sizeof(WCHAR);
    UsbChildExtension->usDeviceId.MaximumLength = Index * sizeof(WCHAR);
    DPRINT("usDeviceId %wZ\n", &UsbChildExtension->usDeviceId);

    //
    // Construct HardwareIds
    //
    Index = 0;
    Index += swprintf(&Buffer[Index],
                      L"USB\\Vid_%04x&Pid_%04x&Rev_%04x",
                      UsbChildExtension->DeviceDesc.idVendor, UsbChildExtension->DeviceDesc.idProduct, UsbChildExtension->DeviceDesc.bcdDevice) + 1;
    Index += swprintf(&Buffer[Index],
                      L"USB\\Vid_%04x&Pid_%04x",
                      UsbChildExtension->DeviceDesc.idVendor, UsbChildExtension->DeviceDesc.idProduct) + 1;

    //
    // now allocate the buffer
    //
    DeviceString = ExAllocatePool(NonPagedPool, (Index + 1) * sizeof(WCHAR));
    if (!DeviceString)
    {
        //
        // no memory
        //
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // copy buffer
    //
    RtlCopyMemory(DeviceString, Buffer, Index * sizeof(WCHAR));
    DeviceString[Index] = UNICODE_NULL;
    UsbChildExtension->usHardwareIds.Buffer = DeviceString;
    UsbChildExtension->usHardwareIds.Length = (Index + 1) * sizeof(WCHAR);
    UsbChildExtension->usHardwareIds.MaximumLength = (Index + 1) * sizeof(WCHAR);
    DPRINT("usHardWareIds %wZ\n", &UsbChildExtension->usHardwareIds);

    //
    // FIXME: Handle Lang ids
    //

    //
    // Get the product string if obe provided
    //
    if (UsbChildExtension->DeviceDesc.iProduct)
    {
        Status = GetUsbStringDescriptor(UsbChildDeviceObject,
                                        UsbChildExtension->DeviceDesc.iProduct,
                                        0,
                                        (PVOID*)&UsbChildExtension->usTextDescription.Buffer,
                                        &UsbChildExtension->usTextDescription.Length);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("USBHUB: GetUsbStringDescriptor failed with status %x\n", Status);
            RtlInitUnicodeString(&UsbChildExtension->usTextDescription, L"USB Device"); // FIXME NON-NLS
        }
        else
        {
            UsbChildExtension->usTextDescription.MaximumLength = UsbChildExtension->usTextDescription.Length;
            DPRINT("Usb TextDescription %wZ\n", &UsbChildExtension->usTextDescription);
        }
    }

    //
    // Get the Serial Number string if obe provided
    //
    if (UsbChildExtension->DeviceDesc.iSerialNumber)
    {
       LPWSTR SerialBuffer = NULL;

        Status = GetUsbStringDescriptor(UsbChildDeviceObject,
                                        UsbChildExtension->DeviceDesc.iSerialNumber,
                                        0,
                                        (PVOID*)&SerialBuffer,
                                        &UsbChildExtension->usInstanceId.Length);
        if (NT_SUCCESS(Status))
        {
            // construct instance id buffer
            Index = swprintf(Buffer, L"%04d&%s", HubDeviceExtension->InstanceCount, SerialBuffer) + 1;

            ExFreePool(SerialBuffer);

            UsbChildExtension->usInstanceId.Buffer = (LPWSTR)ExAllocatePool(NonPagedPool, Index * sizeof(WCHAR));
            if (UsbChildExtension->usInstanceId.Buffer == NULL)
            {
                DPRINT1("Error: failed to allocate %lu bytes\n", Index * sizeof(WCHAR));
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            //
            // copy instance id
            //
            RtlCopyMemory(UsbChildExtension->usInstanceId.Buffer, Buffer, Index * sizeof(WCHAR));
            UsbChildExtension->usInstanceId.Length = UsbChildExtension->usInstanceId.MaximumLength = Index * sizeof(WCHAR);

            DPRINT("Usb InstanceId %wZ InstanceCount %x\n", &UsbChildExtension->usInstanceId, HubDeviceExtension->InstanceCount);
            return Status;
        }
    }

    //
    // the device did not provide a serial number, or failed to retrieve the serial number
    // lets create a pseudo instance id
    //
    Index = swprintf(Buffer, L"%04d&%04d", HubDeviceExtension->InstanceCount, UsbChildExtension->PortNumber) + 1;
    UsbChildExtension->usInstanceId.Buffer = (LPWSTR)ExAllocatePool(NonPagedPool, Index * sizeof(WCHAR));
    if (UsbChildExtension->usInstanceId.Buffer == NULL)
    {
       DPRINT1("Error: failed to allocate %lu bytes\n", Index * sizeof(WCHAR));
       Status = STATUS_INSUFFICIENT_RESOURCES;
       return Status;
    }

    //
    // copy instance id
    //
    RtlCopyMemory(UsbChildExtension->usInstanceId.Buffer, Buffer, Index * sizeof(WCHAR));
    UsbChildExtension->usInstanceId.Length = UsbChildExtension->usInstanceId.MaximumLength = Index * sizeof(WCHAR);

    DPRINT("usDeviceId %wZ\n", &UsbChildExtension->usInstanceId);
    return STATUS_SUCCESS;
}

NTSTATUS
DestroyUsbChildDeviceObject(
    IN PDEVICE_OBJECT UsbHubDeviceObject,
    IN LONG PortId)
{
    PHUB_DEVICE_EXTENSION HubDeviceExtension = (PHUB_DEVICE_EXTENSION)UsbHubDeviceObject->DeviceExtension;
    PHUB_CHILDDEVICE_EXTENSION UsbChildExtension = NULL;
    PDEVICE_OBJECT ChildDeviceObject = NULL;
    ULONG Index = 0;

    KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);
    for (Index = 0; Index < USB_MAXCHILDREN; Index++)
    {
        if (HubDeviceExtension->ChildDeviceObject[Index])
        {
            UsbChildExtension = (PHUB_CHILDDEVICE_EXTENSION)HubDeviceExtension->ChildDeviceObject[Index]->DeviceExtension;

            /* Check if it matches the port ID */
            if (UsbChildExtension->PortNumber == PortId)
            {
                /* We found it */
                ChildDeviceObject = HubDeviceExtension->ChildDeviceObject[Index];
                break;
            }
        }
    }

    /* Fail the request if the device doesn't exist */
    if (!ChildDeviceObject)
    {
        DPRINT1("Removal request for non-existant device!\n");
        KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
        return STATUS_UNSUCCESSFUL;
    }

    DPRINT("Removing device on port %d (Child index: %d)\n", PortId, Index);

    /* Remove the device from the table */
    HubDeviceExtension->ChildDeviceObject[Index] = NULL;

    KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);

    /* Invalidate device relations for the root hub */
    IoInvalidateDeviceRelations(HubDeviceExtension->RootHubPhysicalDeviceObject, BusRelations);

    /* The rest of the removal process takes place in IRP_MN_REMOVE_DEVICE handling for the PDO */
    return STATUS_SUCCESS;
}

NTSTATUS
CreateUsbChildDeviceObject(
    IN PDEVICE_OBJECT UsbHubDeviceObject,
    IN LONG PortId,
    OUT PDEVICE_OBJECT *UsbChildDeviceObject,
    IN ULONG PortStatus)
{
    NTSTATUS Status;
    PDEVICE_OBJECT RootHubDeviceObject, NewChildDeviceObject;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PHUB_CHILDDEVICE_EXTENSION UsbChildExtension;
    PUSB_BUS_INTERFACE_HUB_V5 HubInterface;
    ULONG ChildDeviceCount, UsbDeviceNumber = 0;
    WCHAR CharDeviceName[64];
    UNICODE_STRING DeviceName;
    ULONG ConfigDescSize, DeviceDescSize, DeviceInfoSize;
    PVOID HubInterfaceBusContext;
    USB_CONFIGURATION_DESCRIPTOR ConfigDesc;

    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) UsbHubDeviceObject->DeviceExtension;
    HubInterface = &HubDeviceExtension->HubInterface;
    RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;
    HubInterfaceBusContext = HubDeviceExtension->UsbDInterface.BusContext;

    while (TRUE)
    {
        //
        // Create a Device Name
        //
        swprintf(CharDeviceName, L"\\Device\\USBPDO-%d", UsbDeviceNumber);

        //
        // Initialize UnicodeString
        //
        RtlInitUnicodeString(&DeviceName, CharDeviceName);

        //
        // Create a DeviceObject
        //
        Status = IoCreateDevice(UsbHubDeviceObject->DriverObject,
                                sizeof(HUB_CHILDDEVICE_EXTENSION),
                                NULL,
                                FILE_DEVICE_CONTROLLER,
                                FILE_AUTOGENERATED_DEVICE_NAME,
                                FALSE,
                                &NewChildDeviceObject);

        //
        // Check if the name is already in use
        //
        if ((Status == STATUS_OBJECT_NAME_EXISTS) || (Status == STATUS_OBJECT_NAME_COLLISION))
        {
            //
            // Try next name
            //
            UsbDeviceNumber++;
            continue;
        }

        //
        // Check for other errors
        //
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("USBHUB: IoCreateDevice failed with status %x\n", Status);
            return Status;
        }

        DPRINT("USBHUB: Created Device %x\n", NewChildDeviceObject);
        break;
    }

    NewChildDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;

    //
    // Assign the device extensions
    //
    UsbChildExtension = (PHUB_CHILDDEVICE_EXTENSION)NewChildDeviceObject->DeviceExtension;
    RtlZeroMemory(UsbChildExtension, sizeof(HUB_CHILDDEVICE_EXTENSION));
    UsbChildExtension->ParentDeviceObject = UsbHubDeviceObject;
    UsbChildExtension->PortNumber = PortId;

    //
    // Create the UsbDeviceObject
    //
    Status = HubInterface->CreateUsbDevice(HubInterfaceBusContext,
                                           (PVOID)&UsbChildExtension->UsbDeviceHandle,
                                           HubDeviceExtension->RootHubHandle,
                                           PortStatus,
                                           PortId);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBHUB: CreateUsbDevice failed with status %x\n", Status);
        goto Cleanup;
    }

    //
    // Initialize UsbDevice
    //
    Status = HubInterface->InitializeUsbDevice(HubInterfaceBusContext, UsbChildExtension->UsbDeviceHandle);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBHUB: InitializeUsbDevice failed with status %x\n", Status);
        goto Cleanup;
    }

    DPRINT("Usb Device Handle %x\n", UsbChildExtension->UsbDeviceHandle);

    ConfigDescSize = sizeof(USB_CONFIGURATION_DESCRIPTOR);
    DeviceDescSize = sizeof(USB_DEVICE_DESCRIPTOR);

    //
    // Get the descriptors
    //
    Status = HubInterface->GetUsbDescriptors(HubInterfaceBusContext,
                                             UsbChildExtension->UsbDeviceHandle,
                                             (PUCHAR)&UsbChildExtension->DeviceDesc,
                                             &DeviceDescSize,
                                             (PUCHAR)&ConfigDesc,
                                             &ConfigDescSize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBHUB: GetUsbDescriptors failed with status %x\n", Status);
        goto Cleanup;
    }

    //DumpDeviceDescriptor(&UsbChildExtension->DeviceDesc);
    //DumpConfigurationDescriptor(&ConfigDesc);

    //
    // FIXME: Support more than one configuration and one interface?
    //
    if (UsbChildExtension->DeviceDesc.bNumConfigurations > 1)
    {
        DPRINT1("Warning: Device has more than one configuration. Only one configuration (the first) is supported!\n");
    }

    if (ConfigDesc.bNumInterfaces > 1)
    {
        DPRINT1("Warning: Device has more than one interface. Only one interface (the first) is currently supported\n");
    }

    ConfigDescSize = ConfigDesc.wTotalLength;

    //
    // Allocate memory for the first full descriptor, including interfaces and endpoints.
    //
    UsbChildExtension->FullConfigDesc = ExAllocatePoolWithTag(PagedPool, ConfigDescSize, USB_HUB_TAG);

    //
    // Retrieve the full configuration descriptor
    //
    Status = GetUsbDeviceDescriptor(NewChildDeviceObject,
                                    USB_CONFIGURATION_DESCRIPTOR_TYPE,
                                    0,
                                    0,
                                    UsbChildExtension->FullConfigDesc,
                                    ConfigDescSize);

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("USBHUB: GetUsbDeviceDescriptor failed with status %x\n", Status);
        goto Cleanup;
    }

    // query device details
    Status = HubInterface->QueryDeviceInformation(HubInterfaceBusContext,
                                         UsbChildExtension->UsbDeviceHandle,
                                         &UsbChildExtension->DeviceInformation,
                                         sizeof(USB_DEVICE_INFORMATION_0),
                                         &DeviceInfoSize);


    //DumpFullConfigurationDescriptor(UsbChildExtension->FullConfigDesc);

    //
    // Construct all the strings that will describe the device to PNP
    //
    Status = CreateDeviceIds(NewChildDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create strings needed to describe device to PNP.\n");
        goto Cleanup;
    }

    // copy device interface
    RtlCopyMemory(&UsbChildExtension->DeviceInterface, &HubDeviceExtension->UsbDInterface, sizeof(USB_BUS_INTERFACE_USBDI_V2));
    UsbChildExtension->DeviceInterface.InterfaceReference(UsbChildExtension->DeviceInterface.BusContext);

    INITIALIZE_PNP_STATE(UsbChildExtension->Common);

    IoInitializeRemoveLock(&UsbChildExtension->Common.RemoveLock, 'pbuH', 0, 0);

    KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);

    //
    // Find an empty slot in the child device array
    //
    for (ChildDeviceCount = 0; ChildDeviceCount < USB_MAXCHILDREN; ChildDeviceCount++)
    {
        if (HubDeviceExtension->ChildDeviceObject[ChildDeviceCount] == NULL)
        {
            DPRINT("Found unused entry at %d\n", ChildDeviceCount);
            break;
        }
    }

    //
    // Check if the limit has been reached for maximum usb devices
    //
    if (ChildDeviceCount == USB_MAXCHILDREN)
    {
        DPRINT1("USBHUB: Too many child devices!\n");
        Status = STATUS_UNSUCCESSFUL;
        KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
        UsbChildExtension->DeviceInterface.InterfaceDereference(UsbChildExtension->DeviceInterface.BusContext);
        goto Cleanup;
    }

    HubDeviceExtension->ChildDeviceObject[ChildDeviceCount] = NewChildDeviceObject;
    HubDeviceExtension->InstanceCount++;
    KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);

    IoInvalidateDeviceRelations(RootHubDeviceObject, BusRelations);
    return STATUS_SUCCESS;

Cleanup:

    //
    // Remove the usb device if it was created
    //
    if (UsbChildExtension->UsbDeviceHandle)
        HubInterface->RemoveUsbDevice(HubInterfaceBusContext, UsbChildExtension->UsbDeviceHandle, 0);

    //
    // Free full configuration descriptor if one was allocated
    //
    if (UsbChildExtension->FullConfigDesc)
        ExFreePool(UsbChildExtension->FullConfigDesc);

    //
    // Free ID buffers if they were allocated in CreateDeviceIds()
    //
    if (UsbChildExtension->usCompatibleIds.Buffer)
        ExFreePool(UsbChildExtension->usCompatibleIds.Buffer);

    if (UsbChildExtension->usDeviceId.Buffer)
        ExFreePool(UsbChildExtension->usDeviceId.Buffer);

    if (UsbChildExtension->usHardwareIds.Buffer)
        ExFreePool(UsbChildExtension->usHardwareIds.Buffer);

    if (UsbChildExtension->usInstanceId.Buffer)
        ExFreePool(UsbChildExtension->usInstanceId.Buffer);

    //
    // Delete the device object
    //
    IoDeleteDevice(NewChildDeviceObject);
    return Status;
}

NTSTATUS
USBHUB_FdoQueryBusRelations(
    IN PDEVICE_OBJECT DeviceObject,
    IN PDEVICE_RELATIONS RelationsFromTop,
    OUT PDEVICE_RELATIONS* pDeviceRelations)
{
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PDEVICE_RELATIONS DeviceRelations;
    ULONG i;
    ULONG ChildrenFromTop = 0;
    ULONG Children = 0;
    ULONG NeededSize;

    HubDeviceExtension = (PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

    KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);

    //
    // Count the number of children
    //
    for (i = 0; i < USB_MAXCHILDREN; i++)
    {

        if (HubDeviceExtension->ChildDeviceObject[i] == NULL)
        {
            continue;
        }
        Children++;
    }

    if (RelationsFromTop)
    {
        ChildrenFromTop = RelationsFromTop->Count;
        if (!Children)
        {
            // We have nothing to add
            *pDeviceRelations = RelationsFromTop;
            KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
            return STATUS_SUCCESS;
        }
    }

    NeededSize = sizeof(DEVICE_RELATIONS) + (Children + ChildrenFromTop - 1) * sizeof(PDEVICE_OBJECT);

    //
    // Allocate DeviceRelations
    //
    DeviceRelations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool,
                                                        NeededSize);

    if (!DeviceRelations)
    {
        KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
        if (!RelationsFromTop)
            return STATUS_INSUFFICIENT_RESOURCES;
        else
            return STATUS_NOT_SUPPORTED;
    }
    // Copy the objects coming from top
    if (ChildrenFromTop)
    {
        RtlCopyMemory(DeviceRelations->Objects, RelationsFromTop->Objects,
                      ChildrenFromTop * sizeof(PDEVICE_OBJECT));
    }

    DeviceRelations->Count = Children + ChildrenFromTop;
    Children = ChildrenFromTop;

    //
    // Fill in return structure
    //
    for (i = 0; i < USB_MAXCHILDREN; i++)
    {
        if (HubDeviceExtension->ChildDeviceObject[i])
        {
            // The PnP Manager removes the reference when appropriate.
            ObReferenceObject(HubDeviceExtension->ChildDeviceObject[i]);
            HubDeviceExtension->ChildDeviceObject[i]->Flags &= ~DO_DEVICE_INITIALIZING;
            DeviceRelations->Objects[Children++] = HubDeviceExtension->ChildDeviceObject[i];
        }
    }

    KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);

    // We should do this, because replaced this with our's one
    if (RelationsFromTop)
        ExFreePool(RelationsFromTop);

    ASSERT(Children == DeviceRelations->Count);
    *pDeviceRelations = DeviceRelations;

    return STATUS_SUCCESS;
}

VOID
NTAPI
RootHubInitCallbackFunction(
    PVOID Context)
{
    PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)Context;
    NTSTATUS Status;
    ULONG PortId;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PORT_STATUS_CHANGE StatusChange;

    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;

    DPRINT("RootHubInitCallbackFunction Sending the initial SCE Request %x\n", DeviceObject);

    //
    // Send the first SCE Request
    //
    QueryStatusChangeEndpoint(DeviceObject);

    for (PortId = 1; PortId <= HubDeviceExtension->HubDescriptor.bNumberOfPorts; PortId++)
    {
        //
        // get port status
        //
        Status = GetPortStatusAndChange(HubDeviceExtension->RootHubPhysicalDeviceObject, PortId, &StatusChange);
        if (NT_SUCCESS(Status))
        {
            //
            // is there a device connected
            //
            if (StatusChange.Status & USB_PORT_STATUS_CONNECT)
            {
                //
                // reset port
                //
                Status = SetPortFeature(HubDeviceExtension->RootHubPhysicalDeviceObject, PortId, PORT_RESET);
                if (!NT_SUCCESS(Status))
                {
                    DPRINT1("Failed to reset on port %d\n", PortId);
                }
                else
                {
                    //
                    // wait for the reset to be handled since we want to enumerate synchronously
                    //
                    KeWaitForSingleObject(&HubDeviceExtension->ResetComplete,
                                          Executive,
                                          KernelMode,
                                          FALSE,
                                          NULL);
                    KeClearEvent(&HubDeviceExtension->ResetComplete);
                }
            }
        }
    }
}

BOOLEAN
USBHUB_IsRootHubFDO(
   IN PDEVICE_OBJECT DeviceObject)
{
    NTSTATUS Status;
    PDEVICE_OBJECT RootHubPhysicalDeviceObject = NULL;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;

    // get hub device extension
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;

    // Get the Root Hub Pdo
    Status = SubmitRequestToRootHub(HubDeviceExtension->LowerDeviceObject,
                                    IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO,
                                    &RootHubPhysicalDeviceObject,
                                    NULL);

    // FIXME handle error
    ASSERT(NT_SUCCESS(Status));

    // physical device object is only obtained for root hubs
    return (RootHubPhysicalDeviceObject != NULL);
}


NTSTATUS
USBHUB_FdoStartDevice(
   IN PDEVICE_OBJECT DeviceObject,
   IN PIRP Irp)
{
    PURB Urb;
    PUSB_INTERFACE_DESCRIPTOR Pid;
    ULONG Result = 0, PortId;
    USBD_INTERFACE_LIST_ENTRY InterfaceList[2] = {{NULL, NULL}, {NULL, NULL}};
    PURB ConfigUrb = NULL;
    ULONG HubStatus;
    NTSTATUS Status = STATUS_SUCCESS;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PDEVICE_OBJECT RootHubDeviceObject;
    PVOID HubInterfaceBusContext;
    PORT_STATUS_CHANGE StatusChange;

    // get hub device extension
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;

    DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");

    // Allocated size including the sizeof USBD_INTERFACE_LIST_ENTRY
    Urb = ExAllocatePoolWithTag(NonPagedPool, sizeof(URB) + sizeof(USBD_INTERFACE_LIST_ENTRY), USB_HUB_TAG);
    if (!Urb)
    {
         // no memory
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }

    // zero urb
    RtlZeroMemory(Urb, sizeof(URB) + sizeof(USBD_INTERFACE_LIST_ENTRY));

    // Get the Root Hub Pdo
    Status = SubmitRequestToRootHub(HubDeviceExtension->LowerDeviceObject,
                                    IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO,
                                    &HubDeviceExtension->RootHubPhysicalDeviceObject,
                                    &HubDeviceExtension->RootHubFunctionalDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        // failed to obtain hub pdo
        DPRINT1("IOCTL_INTERNAL_USB_GET_ROOTHUB_PDO failed with %x\n", Status);
        goto cleanup;
    }

    // sanity checks
    ASSERT(HubDeviceExtension->RootHubPhysicalDeviceObject);
    ASSERT(HubDeviceExtension->RootHubFunctionalDeviceObject);

    // get roothub
    RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;

    // Send the StartDevice to RootHub
    Status = ForwardIrpAndWait(HubDeviceExtension->LowerDeviceObject, Irp);

    if (!NT_SUCCESS(Status))
    {
        // failed to start pdo
        DPRINT1("Failed to start the RootHub PDO\n");
        goto cleanup;
    }

    // Get the current number of hubs
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_GET_HUB_COUNT,
                                    &HubDeviceExtension->NumberOfHubs, NULL);
    if (!NT_SUCCESS(Status))
    {
        // failed to get number of hubs
        DPRINT1("IOCTL_INTERNAL_USB_GET_HUB_COUNT failed with %x\n", Status);
        goto cleanup;
    }

    // Get the Hub Interface
    Status = QueryInterface(RootHubDeviceObject,
                            USB_BUS_INTERFACE_HUB_GUID,
                            sizeof(USB_BUS_INTERFACE_HUB_V5),
                            USB_BUSIF_HUB_VERSION_5,
                            (PVOID)&HubDeviceExtension->HubInterface);

    if (!NT_SUCCESS(Status))
    {
        // failed to get root hub interface
        DPRINT1("Failed to get HUB_GUID interface with status 0x%08lx\n", Status);
        goto cleanup;
    }

    HubInterfaceBusContext = HubDeviceExtension->HubInterface.BusContext;

    // Get the USBDI Interface
    Status = QueryInterface(RootHubDeviceObject,
                            USB_BUS_INTERFACE_USBDI_GUID,
                            sizeof(USB_BUS_INTERFACE_USBDI_V2),
                            USB_BUSIF_USBDI_VERSION_2,
                            (PVOID)&HubDeviceExtension->UsbDInterface);

    if (!NT_SUCCESS(Status))
    {
        // failed to get usbdi interface
        DPRINT1("Failed to get USBDI_GUID interface with status 0x%08lx\n", Status);
        goto cleanup;
    }

    // Get Root Hub Device Handle
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE,
                                    &HubDeviceExtension->RootHubHandle,
                                    NULL);

    if (!NT_SUCCESS(Status))
    {
        // failed
        DPRINT1("IOCTL_INTERNAL_USB_GET_DEVICE_HANDLE failed with status 0x%08lx\n", Status);
        goto cleanup;
    }

    //
    // Get Hub Device Information
    //
    Status = HubDeviceExtension->HubInterface.QueryDeviceInformation(HubInterfaceBusContext,
                                                                        HubDeviceExtension->RootHubHandle,
                                                                        &HubDeviceExtension->DeviceInformation,
                                                                        sizeof(USB_DEVICE_INFORMATION_0),
                                                                        &Result);

    DPRINT("Status %x, Result 0x%08lx\n", Status, Result);
    DPRINT("InformationLevel %x\n", HubDeviceExtension->DeviceInformation.InformationLevel);
    DPRINT("ActualLength %x\n", HubDeviceExtension->DeviceInformation.ActualLength);
    DPRINT("PortNumber %x\n", HubDeviceExtension->DeviceInformation.PortNumber);
    DPRINT("DeviceDescriptor %x\n", HubDeviceExtension->DeviceInformation.DeviceDescriptor);
    DPRINT("HubAddress %x\n", HubDeviceExtension->DeviceInformation.HubAddress);
    DPRINT("NumberofPipes %x\n", HubDeviceExtension->DeviceInformation.NumberOfOpenPipes);

    // Get Root Hubs Device Descriptor
    UsbBuildGetDescriptorRequest(Urb,
                                    sizeof(Urb->UrbControlDescriptorRequest),
                                    USB_DEVICE_DESCRIPTOR_TYPE,
                                    0,
                                    0,
                                    &HubDeviceExtension->HubDeviceDescriptor,
                                    NULL,
                                    sizeof(USB_DEVICE_DESCRIPTOR),
                                    NULL);

    // set device handle
    Urb->UrbHeader.UsbdDeviceHandle = HubDeviceExtension->RootHubHandle;

    // get hub device descriptor
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    Urb,
                                    NULL);

    if (!NT_SUCCESS(Status))
    {
        // failed to get device descriptor of hub
        DPRINT1("Failed to get HubDeviceDescriptor!\n");
        goto cleanup;
    }

    // build configuration request
    UsbBuildGetDescriptorRequest(Urb,
                                    sizeof(Urb->UrbControlDescriptorRequest),
                                    USB_CONFIGURATION_DESCRIPTOR_TYPE,
                                    0,
                                    0,
                                    &HubDeviceExtension->HubConfigDescriptor,
                                    NULL,
                                    sizeof(USB_CONFIGURATION_DESCRIPTOR) + sizeof(USB_INTERFACE_DESCRIPTOR) + sizeof(USB_ENDPOINT_DESCRIPTOR),
                                    NULL);

    // set device handle
    Urb->UrbHeader.UsbdDeviceHandle = HubDeviceExtension->RootHubHandle;

    // request configuration descriptor
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    Urb,
                                    NULL);

    if (!NT_SUCCESS(Status))
    {
        // failed to get configuration descriptor
        DPRINT1("Failed to get RootHub Configuration with status %x\n", Status);
        goto cleanup;
    }

    // sanity checks
    ASSERT(HubDeviceExtension->HubConfigDescriptor.wTotalLength == sizeof(USB_CONFIGURATION_DESCRIPTOR) + sizeof(USB_INTERFACE_DESCRIPTOR) + sizeof(USB_ENDPOINT_DESCRIPTOR));
    ASSERT(HubDeviceExtension->HubConfigDescriptor.bDescriptorType == USB_CONFIGURATION_DESCRIPTOR_TYPE);
    ASSERT(HubDeviceExtension->HubConfigDescriptor.bLength == sizeof(USB_CONFIGURATION_DESCRIPTOR));
    ASSERT(HubDeviceExtension->HubConfigDescriptor.bNumInterfaces == 1);
    ASSERT(HubDeviceExtension->HubInterfaceDescriptor.bLength == sizeof(USB_INTERFACE_DESCRIPTOR));
    ASSERT(HubDeviceExtension->HubInterfaceDescriptor.bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE);
    ASSERT(HubDeviceExtension->HubInterfaceDescriptor.bNumEndpoints == 1);
    ASSERT(HubDeviceExtension->HubEndPointDescriptor.bDescriptorType == USB_ENDPOINT_DESCRIPTOR_TYPE);
    ASSERT(HubDeviceExtension->HubEndPointDescriptor.bLength == sizeof(USB_ENDPOINT_DESCRIPTOR));
    ASSERT(HubDeviceExtension->HubEndPointDescriptor.bmAttributes == USB_ENDPOINT_TYPE_INTERRUPT);
    ASSERT(HubDeviceExtension->HubEndPointDescriptor.bEndpointAddress == 0x81); // interrupt in

    // get hub information
    Status = HubDeviceExtension->HubInterface.GetExtendedHubInformation(HubInterfaceBusContext,
                                                                        RootHubDeviceObject,
                                                                        &HubDeviceExtension->UsbExtHubInfo,
                                                                        sizeof(USB_EXTHUB_INFORMATION_0),
                                                                        &Result);
    if (!NT_SUCCESS(Status))
    {
        // failed to get hub information
        DPRINT1("Failed to extended hub information. Unable to determine the number of ports!\n");
        goto cleanup;
    }

    if (!HubDeviceExtension->UsbExtHubInfo.NumberOfPorts)
    {
        // bogus port driver
        DPRINT1("Failed to retrieve the number of ports\n");
        Status = STATUS_UNSUCCESSFUL;
        goto cleanup;
    }

    DPRINT("HubDeviceExtension->UsbExtHubInfo.NumberOfPorts %x\n", HubDeviceExtension->UsbExtHubInfo.NumberOfPorts);

    // Build hub descriptor request
    UsbBuildVendorRequest(Urb,
                            URB_FUNCTION_CLASS_DEVICE,
                            sizeof(Urb->UrbControlVendorClassRequest),
                            USBD_TRANSFER_DIRECTION_IN | USBD_SHORT_TRANSFER_OK,
                            0,
                            USB_REQUEST_GET_DESCRIPTOR,
                            USB_DEVICE_CLASS_RESERVED,
                            0,
                            &HubDeviceExtension->HubDescriptor,
                            NULL,
                            sizeof(USB_HUB_DESCRIPTOR),
                            NULL);

    // set device handle
    Urb->UrbHeader.UsbdDeviceHandle = HubDeviceExtension->RootHubHandle;

    // send request
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    Urb,
                                    NULL);

    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to get Hub Descriptor!\n");
        Status = STATUS_UNSUCCESSFUL;
        goto cleanup;
    }

    // sanity checks
    ASSERT(HubDeviceExtension->HubDescriptor.bDescriptorLength == sizeof(USB_HUB_DESCRIPTOR));
    ASSERT(HubDeviceExtension->HubDescriptor.bNumberOfPorts == HubDeviceExtension->UsbExtHubInfo.NumberOfPorts);
    ASSERT(HubDeviceExtension->HubDescriptor.bDescriptorType == 0x29);

    // build get status request
    HubStatus = 0;
    UsbBuildGetStatusRequest(Urb,
                                URB_FUNCTION_GET_STATUS_FROM_DEVICE,
                                0,
                                &HubStatus,
                                0,
                                NULL);
    // set device handle
    Urb->UrbHeader.UsbdDeviceHandle = HubDeviceExtension->RootHubHandle;

    // send request
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    Urb,
                                    NULL);
    if (!NT_SUCCESS(Status))
    {
        // failed to get hub status
        DPRINT1("Failed to get Hub Status!\n");
        Status = STATUS_UNSUCCESSFUL;
        goto cleanup;
    }

    // Allocate memory for PortStatusChange to hold 2 USHORTs for each port on hub
    HubDeviceExtension->PortStatusChange = ExAllocatePoolWithTag(NonPagedPool,
                                                                    sizeof(ULONG) * HubDeviceExtension->UsbExtHubInfo.NumberOfPorts,
                                                                    USB_HUB_TAG);

    if (!HubDeviceExtension->PortStatusChange)
    {
        DPRINT1("Failed to allocate pool for PortStatusChange!\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }

    // Get the first Configuration Descriptor
    Pid = USBD_ParseConfigurationDescriptorEx(&HubDeviceExtension->HubConfigDescriptor,
                                                &HubDeviceExtension->HubConfigDescriptor,
                                                -1, -1, -1, -1, -1);
    if (Pid == NULL)
    {
        // failed parse hub descriptor
        DPRINT1("Failed to parse configuration descriptor\n");
        Status = STATUS_UNSUCCESSFUL;
        goto cleanup;
    }

    // create configuration request
    InterfaceList[0].InterfaceDescriptor = Pid;
    ConfigUrb = USBD_CreateConfigurationRequestEx(&HubDeviceExtension->HubConfigDescriptor,
                                                    (PUSBD_INTERFACE_LIST_ENTRY)&InterfaceList);
    if (ConfigUrb == NULL)
    {
        // failed to build urb
        DPRINT1("Failed to allocate urb\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }

    // send request
    Status = SubmitRequestToRootHub(RootHubDeviceObject,
                                    IOCTL_INTERNAL_USB_SUBMIT_URB,
                                    ConfigUrb,
                                    NULL);
    if (!NT_SUCCESS(Status))
    {
        // failed to select configuration
        DPRINT1("Failed to select configuration with %x\n", Status);
        goto cleanup;
    }

    // store configuration & pipe handle
    HubDeviceExtension->ConfigurationHandle = ConfigUrb->UrbSelectConfiguration.ConfigurationHandle;
    HubDeviceExtension->PipeHandle = ConfigUrb->UrbSelectConfiguration.Interface.Pipes[0].PipeHandle;
    DPRINT("Configuration Handle %x\n", HubDeviceExtension->ConfigurationHandle);

    // check if function is available
    if (HubDeviceExtension->UsbDInterface.IsDeviceHighSpeed)
    {
        // is it high speed bus
        if (HubDeviceExtension->UsbDInterface.IsDeviceHighSpeed(HubInterfaceBusContext))
        {
            // initialize usb 2.0 hub
            Status = HubDeviceExtension->HubInterface.Initialize20Hub(HubInterfaceBusContext,
                                                                        HubDeviceExtension->RootHubHandle, 1);
            DPRINT("Status %x\n", Status);

            // FIXME handle error
            ASSERT(Status == STATUS_SUCCESS);
        }
    }


    // Enable power on all ports
    DPRINT("Enabling PortPower on all ports!\n");
    for (PortId = 1; PortId <= HubDeviceExtension->HubDescriptor.bNumberOfPorts; PortId++)
    {
        Status = SetPortFeature(RootHubDeviceObject, PortId, PORT_POWER);
        if (!NT_SUCCESS(Status))
            DPRINT1("Failed to power on port %d\n", PortId);

        Status = ClearPortFeature(RootHubDeviceObject, PortId, C_PORT_CONNECTION);
        if (!NT_SUCCESS(Status))
            DPRINT1("Failed to power on port %d\n", PortId);
    }

    // init root hub notification
    if (HubDeviceExtension->HubInterface.RootHubInitNotification)
    {
        Status = HubDeviceExtension->HubInterface.RootHubInitNotification(HubInterfaceBusContext,
                                                                            DeviceObject,
                                                                            RootHubInitCallbackFunction);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to set callback\n");
            goto cleanup;
        }
    }
    else
    {
        // Send the first SCE Request
        QueryStatusChangeEndpoint(DeviceObject);

        //
        // reset ports
        //
        for (PortId = 1; PortId <= HubDeviceExtension->HubDescriptor.bNumberOfPorts; PortId++)
        {
            //
            // get port status
            //
            Status = GetPortStatusAndChange(HubDeviceExtension->RootHubPhysicalDeviceObject, PortId, &StatusChange);
            if (NT_SUCCESS(Status))
            {
                //
                // is there a device connected
                //
                if (StatusChange.Status & USB_PORT_STATUS_CONNECT)
                {
                    //
                    // reset port
                    //
                    Status = SetPortFeature(HubDeviceExtension->RootHubPhysicalDeviceObject, PortId, PORT_RESET);
                    if (!NT_SUCCESS(Status))
                    {
                        DPRINT1("Failed to reset on port %d\n", PortId);
                    }
                    else
                    {
                        //
                        // wait for the reset to be handled since we want to enumerate synchronously
                        //
                        KeWaitForSingleObject(&HubDeviceExtension->ResetComplete,
                                                Executive,
                                                KernelMode,
                                                FALSE,
                                                NULL);
                        KeClearEvent(&HubDeviceExtension->ResetComplete);
                    }
                }
            }
        }
    }

    // free urb
    ExFreePool(Urb);

    // free ConfigUrb
    ExFreePool(ConfigUrb);

    // done
    return Status;

cleanup:
    if (Urb)
        ExFreePool(Urb);

    // Dereference interfaces
    if (HubDeviceExtension->HubInterface.Size)
        HubDeviceExtension->HubInterface.InterfaceDereference(HubDeviceExtension->HubInterface.BusContext);

    if (HubDeviceExtension->UsbDInterface.Size)
        HubDeviceExtension->UsbDInterface.InterfaceDereference(HubDeviceExtension->UsbDInterface.BusContext);

    if (HubDeviceExtension->PortStatusChange)
        ExFreePool(HubDeviceExtension->PortStatusChange);

    if (ConfigUrb)
        ExFreePool(ConfigUrb);

    return Status;
}

NTSTATUS
USBHUB_FdoHandlePnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    PIO_STACK_LOCATION Stack;
    NTSTATUS Status = STATUS_SUCCESS;
    PDEVICE_OBJECT ChildDeviceObject;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PUSB_BUS_INTERFACE_HUB_V5 HubInterface;
    PHUB_CHILDDEVICE_EXTENSION ChildDeviceExtension;

    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;

    HubInterface = &HubDeviceExtension->HubInterface;
    Stack = IoGetCurrentIrpStackLocation(Irp);

    Status = IoAcquireRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
    if (!NT_SUCCESS(Status))
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }

    switch (Stack->MinorFunction)
    {
        int i;

        case IRP_MN_START_DEVICE:
        {
            DPRINT("IRP_MN_START_DEVICE\n");
            if (USBHUB_IsRootHubFDO(DeviceObject))
            {
                // start root hub fdo
                Status = USBHUB_FdoStartDevice(DeviceObject, Irp);
            }
            else
            {
                Status = USBHUB_ParentFDOStartDevice(DeviceObject, Irp);
            }

            SET_NEW_PNP_STATE(HubDeviceExtension->Common, Started);

            Irp->IoStatus.Status = Status;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            IoReleaseRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
            return Status;
        }

        case IRP_MN_QUERY_DEVICE_RELATIONS:
        {
            switch (Stack->Parameters.QueryDeviceRelations.Type)
            {
                case BusRelations:
                {
                    PDEVICE_RELATIONS DeviceRelations = NULL;
                    PDEVICE_RELATIONS RelationsFromTop = (PDEVICE_RELATIONS)Irp->IoStatus.Information;
                    DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");

                    Status = USBHUB_FdoQueryBusRelations(DeviceObject, RelationsFromTop, &DeviceRelations);

                    if (!NT_SUCCESS(Status))
                    {
                        if (Status == STATUS_NOT_SUPPORTED)
                        {
                            // We should process this to not lose relations from top.
                            Irp->IoStatus.Status = STATUS_SUCCESS;
                            break;
                        }
                        // We should fail an IRP
                        Irp->IoStatus.Status = Status;
                        IoCompleteRequest(Irp, IO_NO_INCREMENT);
                        IoReleaseRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
                        return Status;
                    }

                    Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
                    Irp->IoStatus.Status = Status;
                    break;
                }
                case RemovalRelations:
                {
                    DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
                    break;
                }
                default:
                    DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
                            Stack->Parameters.QueryDeviceRelations.Type);
                    break;
            }
            break;
        }
        case IRP_MN_QUERY_STOP_DEVICE:
        {
            //
            // We should fail this request, because we're not handling
            // IRP_MN_STOP_DEVICE for now.We'll receive this IRP ONLY when
            // PnP manager rebalances resources.
            //
            Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
            IoCompleteRequest(Irp, IO_NO_INCREMENT);
            return STATUS_NOT_SUPPORTED;
        }
        case IRP_MN_QUERY_REMOVE_DEVICE:
        {
            // No action is required from FDO because it have nothing to free.
            DPRINT("IRP_MN_QUERY_REMOVE_DEVICE\n");

            SET_NEW_PNP_STATE(HubDeviceExtension->Common, RemovePending);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_CANCEL_REMOVE_DEVICE:
        {
            DPRINT("IRP_MN_CANCEL_REMOVE_DEVICE\n");

            if (HubDeviceExtension->Common.PnPState == RemovePending)
                RESTORE_PREVIOUS_PNP_STATE(HubDeviceExtension->Common);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_SURPRISE_REMOVAL:
        {
            //
            // We'll receive this IRP on HUB unexpected removal, or on USB
            // controller removal from PCI port. Here we should "let know" all
            // our children that their parent is removed and on next removal
            // they also can be removed.
            //
            SET_NEW_PNP_STATE(HubDeviceExtension->Common, SurpriseRemovePending);

            KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);

            for (i = 0; i < USB_MAXCHILDREN; i++)
            {
                ChildDeviceObject = HubDeviceExtension->ChildDeviceObject[i];
                if (ChildDeviceObject)
                {
                    ChildDeviceExtension = (PHUB_CHILDDEVICE_EXTENSION)ChildDeviceObject->DeviceObjectExtension;
                    ChildDeviceExtension->ParentDeviceObject = NULL;
                }
            }

            KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);

            // This IRP can't be failed
            Irp->IoStatus.Status = STATUS_SUCCESS;
            break;
        }
        case IRP_MN_REMOVE_DEVICE:
        {
            DPRINT("IRP_MN_REMOVE_DEVICE\n");

            SET_NEW_PNP_STATE(HubDeviceExtension->Common, Deleted);

            IoReleaseRemoveLockAndWait(&HubDeviceExtension->Common.RemoveLock, Irp);

            //
            // Here we should remove all child PDOs. At this point all children
            // received and returned from IRP_MN_REMOVE so remove synchronization
            // isn't needed here
            //

            KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);

            for (i = 0; i < USB_MAXCHILDREN; i++)
            {
                ChildDeviceObject = HubDeviceExtension->ChildDeviceObject[i];
                if (ChildDeviceObject)
                {
                    PHUB_CHILDDEVICE_EXTENSION UsbChildExtension = (PHUB_CHILDDEVICE_EXTENSION)ChildDeviceObject->DeviceExtension;

                    SET_NEW_PNP_STATE(UsbChildExtension->Common, Deleted);

                    // Remove the usb device
                    if (UsbChildExtension->UsbDeviceHandle)
                    {
                        Status = HubInterface->RemoveUsbDevice(HubInterface->BusContext, UsbChildExtension->UsbDeviceHandle, 0);
                        ASSERT(Status == STATUS_SUCCESS);
                    }

                    // Free full configuration descriptor
                    if (UsbChildExtension->FullConfigDesc)
                        ExFreePool(UsbChildExtension->FullConfigDesc);

                    // Free ID buffers
                    if (UsbChildExtension->usCompatibleIds.Buffer)
                        ExFreePool(UsbChildExtension->usCompatibleIds.Buffer);

                    if (UsbChildExtension->usDeviceId.Buffer)
                        ExFreePool(UsbChildExtension->usDeviceId.Buffer);

                    if (UsbChildExtension->usHardwareIds.Buffer)
                        ExFreePool(UsbChildExtension->usHardwareIds.Buffer);

                    if (UsbChildExtension->usInstanceId.Buffer)
                        ExFreePool(UsbChildExtension->usInstanceId.Buffer);

                    DPRINT("Deleting child PDO\n");
                    IoDeleteDevice(DeviceObject);
                    ChildDeviceObject = NULL;
                }
            }

            KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);

            Irp->IoStatus.Status = STATUS_SUCCESS;
            Status = ForwardIrpAndForget(DeviceObject, Irp);

            IoDetachDevice(HubDeviceExtension->LowerDeviceObject);
            DPRINT("Deleting FDO 0x%p\n", DeviceObject);
            IoDeleteDevice(DeviceObject);

            return Status;
        }
        case IRP_MN_QUERY_BUS_INFORMATION:
        {
            // Function drivers and filter drivers do not handle this IRP.
            DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
            break;
        }
        case IRP_MN_QUERY_ID:
        {
            DPRINT("IRP_MN_QUERY_ID\n");
            // Function drivers and filter drivers do not handle this IRP.
            break;
        }
        case IRP_MN_QUERY_CAPABILITIES:
        {
            //
            // If a function or filter driver does not handle this IRP, it
            // should pass that down.
            //
            DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
            break;
        }
        default:
        {
            DPRINT(" IRP_MJ_PNP / unknown minor function 0x%lx\n", Stack->MinorFunction);
            break;
        }
    }

    Status = ForwardIrpAndForget(DeviceObject, Irp);
    IoReleaseRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
    return Status;
}

NTSTATUS
USBHUB_FdoHandleDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp)
{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
    PUSB_NODE_INFORMATION NodeInformation;
    PHUB_DEVICE_EXTENSION HubDeviceExtension;
    PUSB_NODE_CONNECTION_INFORMATION NodeConnectionInfo;
    PHUB_CHILDDEVICE_EXTENSION ChildDeviceExtension;
    PUSB_NODE_CONNECTION_DRIVERKEY_NAME NodeKey;
    PUSB_NODE_CONNECTION_NAME ConnectionName;
    ULONG Index, Length;

    // get stack location
    IoStack = IoGetCurrentIrpStackLocation(Irp);

    // get device extension
    HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;

    Status = IoAcquireRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
    if (!NT_SUCCESS(Status))
    {
        Irp->IoStatus.Status = Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }

    // Prevent handling of control requests in remove pending state
    if (HubDeviceExtension->Common.PnPState == RemovePending)
    {
        DPRINT1("[USBHUB] Request for removed device object %p\n", DeviceObject);
        Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        IoReleaseRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
        return STATUS_DEVICE_NOT_CONNECTED;
    }

    if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_USB_GET_NODE_INFORMATION)
    {
        // is the buffer big enough
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(USB_NODE_INFORMATION))
        {
            // buffer too small
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            // get buffer
            NodeInformation = (PUSB_NODE_INFORMATION)Irp->AssociatedIrp.SystemBuffer;

            // sanity check
            ASSERT(NodeInformation);

            // init buffer
            NodeInformation->NodeType = UsbHub;
            RtlCopyMemory(&NodeInformation->u.HubInformation.HubDescriptor, &HubDeviceExtension->HubDescriptor, sizeof(USB_HUB_DESCRIPTOR));

            // FIXME is hub powered
            NodeInformation->u.HubInformation.HubIsBusPowered = TRUE;

            // done
            Irp->IoStatus.Information = sizeof(USB_NODE_INFORMATION);
            Status = STATUS_SUCCESS;
        }


    }
    else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_USB_GET_NODE_CONNECTION_INFORMATION)
    {
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(USB_NODE_CONNECTION_INFORMATION))
        {
            // buffer too small
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            // get node connection info
            NodeConnectionInfo = (PUSB_NODE_CONNECTION_INFORMATION)Irp->AssociatedIrp.SystemBuffer;

            // sanity checks
            ASSERT(NodeConnectionInfo);

            KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);
            for(Index = 0; Index < USB_MAXCHILDREN; Index++)
            {
                if (HubDeviceExtension->ChildDeviceObject[Index] == NULL)
                    continue;

                // get child device extension
                ChildDeviceExtension = (PHUB_CHILDDEVICE_EXTENSION)HubDeviceExtension->ChildDeviceObject[Index]->DeviceExtension;

                if (ChildDeviceExtension->PortNumber != NodeConnectionInfo->ConnectionIndex)
                   continue;

                // init node connection info
                RtlCopyMemory(&NodeConnectionInfo->DeviceDescriptor, &ChildDeviceExtension->DeviceDesc, sizeof(USB_DEVICE_DESCRIPTOR));
                NodeConnectionInfo->CurrentConfigurationValue = ChildDeviceExtension->FullConfigDesc->bConfigurationValue;
                NodeConnectionInfo->DeviceIsHub = FALSE; //FIXME support hubs
                NodeConnectionInfo->LowSpeed = ChildDeviceExtension->DeviceInformation.DeviceSpeed == UsbLowSpeed;
                NodeConnectionInfo->DeviceAddress = ChildDeviceExtension->DeviceInformation.DeviceAddress;
                NodeConnectionInfo->NumberOfOpenPipes = ChildDeviceExtension->DeviceInformation.NumberOfOpenPipes;
                NodeConnectionInfo->ConnectionStatus = DeviceConnected; //FIXME

                if (NodeConnectionInfo->NumberOfOpenPipes)
                {
                    DPRINT1("Need to copy pipe information\n");
                }
                break;
            }
            KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
            // done
            Irp->IoStatus.Information = sizeof(USB_NODE_INFORMATION);
            Status = STATUS_SUCCESS;
        }
    }
    else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME)
    {
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(USB_NODE_CONNECTION_INFORMATION))
        {
            // buffer too small
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            // get node connection info
            NodeKey = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)Irp->AssociatedIrp.SystemBuffer;

            // sanity checks
            ASSERT(NodeKey);

            KeAcquireGuardedMutex(&HubDeviceExtension->HubMutexLock);
            for(Index = 0; Index < USB_MAXCHILDREN; Index++)
            {
                if (HubDeviceExtension->ChildDeviceObject[Index] == NULL)
                    continue;

                // get child device extension
                ChildDeviceExtension = (PHUB_CHILDDEVICE_EXTENSION)HubDeviceExtension->ChildDeviceObject[Index]->DeviceExtension;

                if (ChildDeviceExtension->PortNumber != NodeKey->ConnectionIndex)
                   continue;

                // get driver key
                Status = IoGetDeviceProperty(HubDeviceExtension->ChildDeviceObject[Index], DevicePropertyDriverKeyName,
                                             IoStack->Parameters.DeviceIoControl.OutputBufferLength - sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME),
                                             NodeKey->DriverKeyName,
                                             &Length);

                if (Status == STATUS_BUFFER_TOO_SMALL)
                {
                    // normalize status
                    Status = STATUS_SUCCESS;
                }

                if (Length + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
                {
                    // terminate node key name
                    NodeKey->DriverKeyName[0] = UNICODE_NULL;
                    Irp->IoStatus.Information = sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
                }
                else
                {
                    // result size
                    Irp->IoStatus.Information = Length + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
                }

                // length of driver name
                NodeKey->ActualLength = Length + sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
                break;
            }
            KeReleaseGuardedMutex(&HubDeviceExtension->HubMutexLock);
        }
    }
    else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_USB_GET_NODE_CONNECTION_NAME)
    {
        if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(USB_NODE_CONNECTION_NAME))
        {
            // buffer too small
            Status = STATUS_BUFFER_TOO_SMALL;
        }
        else
        {
            // FIXME support hubs
            ConnectionName = (PUSB_NODE_CONNECTION_NAME)Irp->AssociatedIrp.SystemBuffer;
            ConnectionName->ActualLength = 0;
            ConnectionName->NodeName[0] = UNICODE_NULL;

            // done
            Irp->IoStatus.Information = sizeof(USB_NODE_CONNECTION_NAME);
            Status = STATUS_SUCCESS;
        }
    }
    else
    {
        DPRINT1("UNIMPLEMENTED FdoHandleDeviceControl IoCtl %x InputBufferLength %x OutputBufferLength %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode,
           IoStack->Parameters.DeviceIoControl.InputBufferLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
    }

    // finish irp
    Irp->IoStatus.Status = Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    IoReleaseRemoveLock(&HubDeviceExtension->Common.RemoveLock, Irp);
    return Status;
}