reactos/drivers/usb/usbport/iface.c

/*
 * PROJECT:     ReactOS USB Port Driver
 * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
 * PURPOSE:     USBPort interface functions
 * COPYRIGHT:   Copyright 2017 Vadim Galyant <vgal@rambler.ru>
 */

#include "usbport.h"

#define NDEBUG
#include <debug.h>

VOID
USB_BUSIFFN
USBI_InterfaceReference(IN PVOID BusContext)
{
    DPRINT("USBI_InterfaceReference\n");
}

VOID
USB_BUSIFFN
USBI_InterfaceDereference(IN PVOID BusContext)
{
    DPRINT("USBI_InterfaceDereference\n");
}

/* USB port driver Interface functions */

NTSTATUS
USB_BUSIFFN
USBHI_CreateUsbDevice(IN PVOID BusContext,
                      IN OUT PUSB_DEVICE_HANDLE *UsbdDeviceHandle,
                      IN PUSB_DEVICE_HANDLE UsbdHubDeviceHandle,
                      IN USHORT PortStatus,
                      IN USHORT PortNumber)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSB_DEVICE_HANDLE deviceHandle = NULL;
    NTSTATUS Status;

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

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    Status = USBPORT_CreateDevice(&deviceHandle,
                                  PdoExtension->FdoDevice,
                                  (PUSBPORT_DEVICE_HANDLE)UsbdHubDeviceHandle,
                                  PortStatus,
                                  PortNumber);

    *UsbdDeviceHandle = deviceHandle;

    return Status;
}

NTSTATUS
USB_BUSIFFN
USBHI_InitializeUsbDevice(IN PVOID BusContext,
                          OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;

    DPRINT("USBHI_InitializeUsbDevice\n");

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    return USBPORT_InitializeDevice((PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle,
                                    PdoExtension->FdoDevice);
}

NTSTATUS
USB_BUSIFFN
USBHI_GetUsbDescriptors(IN PVOID BusContext,
                        IN PUSB_DEVICE_HANDLE UsbdDeviceHandle,
                        IN PUCHAR DeviceDescBuffer,
                        IN PULONG DeviceDescBufferLen,
                        IN PUCHAR ConfigDescBuffer,
                        IN PULONG ConfigDescBufferLen)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;

    NTSTATUS Status;

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

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    DeviceHandle = (PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle;

    if (DeviceDescBuffer && *DeviceDescBufferLen)
    {
        if (*DeviceDescBufferLen > sizeof(USB_DEVICE_DESCRIPTOR))
            *DeviceDescBufferLen = sizeof(USB_DEVICE_DESCRIPTOR);

        RtlCopyMemory(DeviceDescBuffer,
                      &DeviceHandle->DeviceDescriptor,
                      *DeviceDescBufferLen);
    }

    Status = USBPORT_GetUsbDescriptor(DeviceHandle,
                                      PdoExtension->FdoDevice,
                                      USB_CONFIGURATION_DESCRIPTOR_TYPE,
                                      ConfigDescBuffer,
                                      ConfigDescBufferLen);

    USBPORT_DumpingDeviceDescriptor((PUSB_DEVICE_DESCRIPTOR)DeviceDescBuffer);

    return Status;
}

NTSTATUS
USB_BUSIFFN
USBHI_RemoveUsbDevice(IN PVOID BusContext,
                      IN OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle,
                      IN ULONG Flags)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;

    DPRINT("USBHI_RemoveUsbDevice: UsbdDeviceHandle - %p, Flags - %x\n",
           UsbdDeviceHandle,
           Flags);

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    return USBPORT_RemoveDevice(PdoExtension->FdoDevice,
                                (PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle,
                                Flags);
}

NTSTATUS
USB_BUSIFFN
USBHI_RestoreUsbDevice(IN PVOID BusContext,
                       OUT PUSB_DEVICE_HANDLE OldUsbdDeviceHandle,
                       OUT PUSB_DEVICE_HANDLE NewUsbdDeviceHandle)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;

    DPRINT("USBHI_RestoreUsbDevice: OldUsbdDeviceHandle - %p, NewUsbdDeviceHandle - %x\n",
           OldUsbdDeviceHandle,
           NewUsbdDeviceHandle);

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    return USBPORT_RestoreDevice(PdoExtension->FdoDevice,
                                (PUSBPORT_DEVICE_HANDLE)OldUsbdDeviceHandle,
                                (PUSBPORT_DEVICE_HANDLE)NewUsbdDeviceHandle);
}

NTSTATUS
USB_BUSIFFN
USBHI_QueryDeviceInformation(IN PVOID BusContext,
                             IN PUSB_DEVICE_HANDLE UsbdDeviceHandle,
                             OUT PVOID DeviceInfoBuffer,
                             IN ULONG DeviceInfoBufferLen,
                             OUT PULONG LenDataReturned)
{
    PUSB_DEVICE_INFORMATION_0 DeviceInfo;
    PUSBPORT_CONFIGURATION_HANDLE ConfigHandle;
    PLIST_ENTRY InterfaceEntry;
    PUSBPORT_DEVICE_HANDLE DeviceHandle;
    ULONG NumberOfOpenPipes = 0;
    PUSB_PIPE_INFORMATION_0 PipeInfo;
    PUSBPORT_PIPE_HANDLE PipeHandle;
    PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
    ULONG ActualLength;
    ULONG ix;

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

    *LenDataReturned = 0;

    if (DeviceInfoBufferLen < sizeof(USB_LEVEL_INFORMATION))
    {
        return STATUS_BUFFER_TOO_SMALL;
    }

    DeviceInfo = DeviceInfoBuffer;

    if (DeviceInfo->InformationLevel > 0)
    {
        return STATUS_NOT_SUPPORTED;
    }

    DeviceHandle = UsbdDeviceHandle;
    ConfigHandle = DeviceHandle->ConfigHandle;

    if (ConfigHandle)
    {
        InterfaceEntry = ConfigHandle->InterfaceHandleList.Flink;

        while (InterfaceEntry &&
               InterfaceEntry != &ConfigHandle->InterfaceHandleList)
        {
            InterfaceHandle = CONTAINING_RECORD(InterfaceEntry,
                                                USBPORT_INTERFACE_HANDLE,
                                                InterfaceLink);

            NumberOfOpenPipes += InterfaceHandle->InterfaceDescriptor.bNumEndpoints;

            InterfaceEntry = InterfaceEntry->Flink;
        }
    }

    ActualLength = FIELD_OFFSET(USB_DEVICE_INFORMATION_0, PipeList) +
                   NumberOfOpenPipes * sizeof(USB_PIPE_INFORMATION_0);

    if (DeviceInfoBufferLen < ActualLength)
    {
        DeviceInfo->ActualLength = ActualLength;
        *LenDataReturned = sizeof(USB_LEVEL_INFORMATION);

        return STATUS_BUFFER_TOO_SMALL;
    }

    RtlZeroMemory(DeviceInfo, ActualLength);

    DeviceInfo->InformationLevel = 0;
    DeviceInfo->ActualLength = ActualLength;
    DeviceInfo->DeviceAddress = DeviceHandle->DeviceAddress;
    DeviceInfo->NumberOfOpenPipes = NumberOfOpenPipes;
    DeviceInfo->DeviceSpeed = DeviceHandle->DeviceSpeed;

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

    USBPORT_DumpingDeviceDescriptor(&DeviceInfo->DeviceDescriptor);

    if (DeviceHandle->DeviceSpeed == UsbFullSpeed ||
        DeviceHandle->DeviceSpeed == UsbLowSpeed)
    {
        DeviceInfo->DeviceType = Usb11Device;
    }
    else if (DeviceHandle->DeviceSpeed == UsbHighSpeed)
    {
        DeviceInfo->DeviceType = Usb20Device;
    }

    DeviceInfo->CurrentConfigurationValue = 0;

    if (!ConfigHandle)
    {
        *LenDataReturned = ActualLength;
        return STATUS_SUCCESS;
    }

    DeviceInfo->CurrentConfigurationValue =
        ConfigHandle->ConfigurationDescriptor->bConfigurationValue;

    InterfaceEntry = ConfigHandle->InterfaceHandleList.Flink;

    while (InterfaceEntry &&
           InterfaceEntry != &ConfigHandle->InterfaceHandleList)
    {
        InterfaceHandle = CONTAINING_RECORD(InterfaceEntry,
                                            USBPORT_INTERFACE_HANDLE,
                                            InterfaceLink);

        if (InterfaceHandle->InterfaceDescriptor.bNumEndpoints > 0)
        {
            PipeInfo = &DeviceInfo->PipeList[0];
            PipeHandle = &InterfaceHandle->PipeHandle[0];

            for (ix = 0;
                 ix < InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
                 ix++)
            {
                if (PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE)
                {
                    PipeInfo->ScheduleOffset = 1;
                }
                else
                {
                    PipeInfo->ScheduleOffset =
                        PipeHandle->Endpoint->EndpointProperties.ScheduleOffset;
                }

                RtlCopyMemory(&PipeInfo->EndpointDescriptor,
                              &PipeHandle->EndpointDescriptor,
                              sizeof(USB_ENDPOINT_DESCRIPTOR));

                PipeInfo += 1;
                PipeHandle += 1;
            }
        }

        InterfaceEntry = InterfaceEntry->Flink;
    }

    *LenDataReturned = ActualLength;

    return STATUS_SUCCESS;
}

NTSTATUS
USB_BUSIFFN
USBHI_GetControllerInformation(IN PVOID BusContext,
                               OUT PVOID ControllerInfoBuffer,
                               IN ULONG ControllerInfoBufferLen,
                               OUT PULONG LenDataReturned)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSB_CONTROLLER_INFORMATION_0 InfoBuffer;
    NTSTATUS Status;

    DPRINT("USBHI_GetControllerInformation: ControllerInfoBufferLen - %x\n",
           ControllerInfoBufferLen);

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;

    InfoBuffer = ControllerInfoBuffer;

    *LenDataReturned = 0;

    if (ControllerInfoBufferLen < sizeof(USB_LEVEL_INFORMATION))
    {
        Status = STATUS_BUFFER_TOO_SMALL;
        return Status;
    }

    *LenDataReturned = sizeof(USB_LEVEL_INFORMATION);

    if (InfoBuffer->InformationLevel > 0)
    {
        Status = STATUS_NOT_SUPPORTED;
        return Status;
    }

    InfoBuffer->ActualLength = sizeof(USB_CONTROLLER_INFORMATION_0);

    if (ControllerInfoBufferLen >= sizeof(USB_CONTROLLER_INFORMATION_0))
    {
        InfoBuffer->SelectiveSuspendEnabled =
            (FdoExtension->Flags & USBPORT_FLAG_SELECTIVE_SUSPEND) ==
            USBPORT_FLAG_SELECTIVE_SUSPEND;
    }

    *LenDataReturned = sizeof(USB_CONTROLLER_INFORMATION_0);

    return STATUS_SUCCESS;
}

NTSTATUS
USB_BUSIFFN
USBHI_ControllerSelectiveSuspend(IN PVOID BusContext,
                                 IN BOOLEAN Enable)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    ULONG Flags;
    ULONG HcDisable;
    NTSTATUS Status;

    DPRINT("USBHI_ControllerSelectiveSuspend: Enable - %x\n", Enable);

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;

    Flags = FdoExtension->Flags;

    if (Flags & USBPORT_FLAG_BIOS_DISABLE_SS)
    {
        return STATUS_SUCCESS;
    }

    if (Enable)
    {
        FdoExtension->Flags |= USBPORT_FLAG_SELECTIVE_SUSPEND;
        HcDisable = 0;
    }
    else
    {
        FdoExtension->Flags &= ~USBPORT_FLAG_SELECTIVE_SUSPEND;
        HcDisable = 1;
    }

    Status = USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
                                         TRUE,
                                         REG_DWORD,
                                         L"HcDisableSelectiveSuspend",
                                         &HcDisable,
                                         sizeof(HcDisable));

    if (NT_SUCCESS(Status))
    {
        if (Enable)
            FdoExtension->Flags |= USBPORT_FLAG_SELECTIVE_SUSPEND;
        else
            FdoExtension->Flags &= ~USBPORT_FLAG_SELECTIVE_SUSPEND;
    }

    return Status;
}

NTSTATUS
USB_BUSIFFN
USBHI_GetExtendedHubInformation(IN PVOID BusContext,
                                IN PDEVICE_OBJECT HubPhysicalDeviceObject,
                                IN OUT PVOID HubInformationBuffer,
                                IN ULONG HubInfoLen,
                                IN OUT PULONG LenDataReturned)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;
    ULONG NumPorts;
    ULONG ix;
    PUSB_EXTHUB_INFORMATION_0 HubInfoBuffer;
    USB_PORT_STATUS_AND_CHANGE PortStatus;
    ULONG PortAttrX;

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

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;

    HubInfoBuffer = HubInformationBuffer;
    PortStatus.AsUlong32 = 0;

    if (HubPhysicalDeviceObject != PdoDevice)
    {
        *LenDataReturned = 0;
        return STATUS_NOT_SUPPORTED;
    }

    if (HubInfoLen < sizeof(USB_EXTHUB_INFORMATION_0))
    {
        *LenDataReturned = 0;
        return STATUS_BUFFER_TOO_SMALL;
    }

    NumPorts = PdoExtension->RootHubDescriptors->Descriptor.bNumberOfPorts;
    HubInfoBuffer->NumberOfPorts = NumPorts;

    if (NumPorts == 0)
    {
        *LenDataReturned = sizeof(USB_EXTHUB_INFORMATION_0);
        return STATUS_SUCCESS;
    }

    for (ix = 0; ix < HubInfoBuffer->NumberOfPorts; ++ix)
    {
        HubInfoBuffer->Port[ix].PhysicalPortNumber = ix + 1;
        HubInfoBuffer->Port[ix].PortLabelNumber = ix;
        HubInfoBuffer->Port[ix].VidOverride = 0;
        HubInfoBuffer->Port[ix].PidOverride = 0;
        HubInfoBuffer->Port[ix].PortAttributes = 0;

        if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
        {
            HubInfoBuffer->Port[ix].PortAttributes = USB_PORTATTR_SHARED_USB2;

            Packet->RH_GetPortStatus(FdoExtension->MiniPortExt,
                                     ix + 1,
                                     &PortStatus);

            if (PortStatus.PortStatus.Usb20PortStatus.AsUshort16 & 0x8000)
            {
                HubInfoBuffer->Port[ix].PortAttributes |= USB_PORTATTR_OWNED_BY_CC;
            }
        }
        else
        {
            if (!(FdoExtension->Flags & USBPORT_FLAG_COMPANION_HC))
            {
                continue;
            }

            if (USBPORT_FindUSB2Controller(FdoDevice))
            {
                HubInfoBuffer->Port[ix].PortAttributes |= USB_PORTATTR_NO_OVERCURRENT_UI;
            }
        }
    }

    for (ix = 0; ix < HubInfoBuffer->NumberOfPorts; ++ix)
    {
        PortAttrX = 0;

        USBPORT_GetRegistryKeyValueFullInfo(FdoDevice,
                                            FdoExtension->CommonExtension.LowerPdoDevice,
                                            FALSE,
                                            L"PortAttrX",
                                            sizeof(L"PortAttrX"),
                                            &PortAttrX,
                                            sizeof(PortAttrX));

        HubInfoBuffer->Port[ix].PortAttributes |= PortAttrX;
    }

    *LenDataReturned = sizeof(USB_EXTHUB_INFORMATION_0);

    return STATUS_SUCCESS;
}

NTSTATUS
USB_BUSIFFN
USBHI_GetRootHubSymbolicName(IN PVOID BusContext,
                             IN OUT PVOID HubInfoBuffer,
                             IN ULONG HubInfoBufferLen,
                             OUT PULONG HubNameActualLen)
{
    PDEVICE_OBJECT PdoDevice;
    UNICODE_STRING HubName;
    PUNICODE_STRING InfoBuffer;
    NTSTATUS Status;

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

    PdoDevice = BusContext;

    Status = USBPORT_GetSymbolicName(PdoDevice, &HubName);

    if (HubInfoBufferLen < HubName.Length)
    {
        InfoBuffer = HubInfoBuffer;
        InfoBuffer->Length = 0;
    }
    else
    {
        RtlCopyMemory(HubInfoBuffer, HubName.Buffer, HubName.Length);
    }

    *HubNameActualLen = HubName.Length;

    if (NT_SUCCESS(Status))
        RtlFreeUnicodeString(&HubName);

    return Status;
}

PVOID
USB_BUSIFFN
USBHI_GetDeviceBusContext(IN PVOID BusContext,
                          IN PVOID DeviceHandle)
{
    DPRINT1("USBHI_GetDeviceBusContext: UNIMPLEMENTED. FIXME.\n");
    return NULL;
}

NTSTATUS
USB_BUSIFFN
USBHI_Initialize20Hub(IN PVOID BusContext,
                      IN PUSB_DEVICE_HANDLE UsbdHubDeviceHandle,
                      IN ULONG TtCount)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;

    DPRINT("USBHI_Initialize20Hub: UsbdHubDeviceHandle - %p, TtCount - %x\n",
           UsbdHubDeviceHandle,
           TtCount);

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    return USBPORT_Initialize20Hub(PdoExtension->FdoDevice,
                                   (PUSBPORT_DEVICE_HANDLE)UsbdHubDeviceHandle,
                                   TtCount);
}

NTSTATUS
USB_BUSIFFN
USBHI_RootHubInitNotification(IN PVOID BusContext,
                              IN PVOID CallbackContext,
                              IN PRH_INIT_CALLBACK CallbackFunction)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    KIRQL OldIrql;

    DPRINT("USBHI_RootHubInitNotification\n");

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;

    KeAcquireSpinLock(&FdoExtension->RootHubCallbackSpinLock, &OldIrql);
    PdoExtension->RootHubInitContext = CallbackContext;
    PdoExtension->RootHubInitCallback = CallbackFunction;
    KeReleaseSpinLock(&FdoExtension->RootHubCallbackSpinLock, OldIrql);

    return STATUS_SUCCESS;
}

VOID
USB_BUSIFFN
USBHI_FlushTransfers(IN PVOID BusContext,
                     OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;

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

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;

    USBPORT_BadRequestFlush(PdoExtension->FdoDevice);
}

VOID
USB_BUSIFFN
USBHI_SetDeviceHandleData(IN PVOID BusContext,
                          IN PVOID DeviceHandle,
                          IN PDEVICE_OBJECT UsbDevicePdo)
{
    DPRINT1("USBHI_SetDeviceHandleData: UNIMPLEMENTED. FIXME.\n");
}

/* USB bus driver Interface functions */

VOID
USB_BUSIFFN
USBDI_GetUSBDIVersion(IN PVOID BusContext,
                      OUT PUSBD_VERSION_INFORMATION VersionInfo,
                      OUT PULONG HcdCapabilities)
{
    DPRINT1("USBDI_GetUSBDIVersion: UNIMPLEMENTED. FIXME.\n");
}

NTSTATUS
USB_BUSIFFN
USBDI_QueryBusTime(IN PVOID BusContext,
                   OUT PULONG CurrentFrame)
{
    DPRINT1("USBDI_QueryBusTime: UNIMPLEMENTED. FIXME.\n");
    return STATUS_SUCCESS;
}

NTSTATUS
USB_BUSIFFN
USBDI_SubmitIsoOutUrb(IN PVOID BusContext,
                      IN PURB Urb)
{
    DPRINT1("USBDI_SubmitIsoOutUrb: UNIMPLEMENTED. FIXME.\n");
    return STATUS_SUCCESS;
}

NTSTATUS
USB_BUSIFFN
USBDI_QueryBusInformation(IN PVOID BusContext,
                          IN ULONG Level,
                          OUT PVOID BusInfoBuffer,
                          OUT PULONG BusInfoBufferLen,
                          OUT PULONG BusInfoActualLen)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    SIZE_T Length;
    PUSB_BUS_INFORMATION_LEVEL_1 Buffer1;

    DPRINT("USBDI_QueryBusInformation: Level - %p\n", Level);

    if ((Level != 0) && (Level != 1))
    {
        DPRINT1("USBDI_QueryBusInformation: Level should be 0 or 1\n");
        return STATUS_NOT_SUPPORTED;
    }

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;

    if (Level == 0)
    {
        if (BusInfoActualLen)
            *BusInfoActualLen = sizeof(USB_BUS_INFORMATION_LEVEL_0);

        if (*BusInfoBufferLen < sizeof(USB_BUS_INFORMATION_LEVEL_0))
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        *BusInfoBufferLen = sizeof(USB_BUS_INFORMATION_LEVEL_0);

        //Buffer0 = BusInfoBuffer;
        DPRINT1("USBDI_QueryBusInformation: LEVEL_0 UNIMPLEMENTED. FIXME\n");
        //Buffer0->TotalBandwidth = USBPORT_GetTotalBandwidth();
        //Buffer0->ConsumedBandwidth = USBPORT_GetAllocatedBandwidth();

        return STATUS_SUCCESS;
    }

    if (Level == 1)
    {
        Length = sizeof(USB_BUS_INFORMATION_LEVEL_1) +
                 FdoExtension->CommonExtension.SymbolicLinkName.Length;

        if (BusInfoActualLen)
            *BusInfoActualLen = Length;

        if (*BusInfoBufferLen < Length)
        {
            return STATUS_BUFFER_TOO_SMALL;
        }

        *BusInfoBufferLen = Length;

        Buffer1 = BusInfoBuffer;
        DPRINT1("USBDI_QueryBusInformation: LEVEL_1 UNIMPLEMENTED. FIXME\n");
        //Buffer1->TotalBandwidth = USBPORT_GetTotalBandwidth();
        //Buffer1->ConsumedBandwidth = USBPORT_GetAllocatedBandwidth();
        Buffer1->ControllerNameLength = FdoExtension->CommonExtension.SymbolicLinkName.Length;

        RtlCopyMemory(&Buffer1->ControllerNameUnicodeString,
                      FdoExtension->CommonExtension.SymbolicLinkName.Buffer,
                      FdoExtension->CommonExtension.SymbolicLinkName.Length);

        return STATUS_SUCCESS;
    }

    return STATUS_SUCCESS;
}

BOOLEAN
USB_BUSIFFN
USBDI_IsDeviceHighSpeed(IN PVOID BusContext)
{
    PDEVICE_OBJECT PdoDevice;
    PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
    PDEVICE_OBJECT FdoDevice;
    PUSBPORT_DEVICE_EXTENSION FdoExtension;
    PUSBPORT_REGISTRATION_PACKET Packet;

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

    PdoDevice = BusContext;
    PdoExtension = PdoDevice->DeviceExtension;
    FdoDevice = PdoExtension->FdoDevice;
    FdoExtension = FdoDevice->DeviceExtension;
    Packet = &FdoExtension->MiniPortInterface->Packet;

    return (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2) != 0;
}

NTSTATUS
USB_BUSIFFN
USBDI_EnumLogEntry(IN PVOID BusContext,
                   IN ULONG DriverTag,
                   IN ULONG EnumTag,
                   IN ULONG P1,
                   IN ULONG P2)
{
    DPRINT1("USBDI_EnumLogEntry: UNIMPLEMENTED. FIXME.\n");
    return STATUS_SUCCESS;
}

NTSTATUS
NTAPI
USBPORT_PdoQueryInterface(IN PDEVICE_OBJECT FdoDevice,
                          IN PDEVICE_OBJECT PdoDevice,
                          IN PIRP Irp)
{
    PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
    PUSB_BUS_INTERFACE_HUB_V5 InterfaceHub;
    PUSB_BUS_INTERFACE_USBDI_V2 InterfaceDI;
    UNICODE_STRING GuidBuffer;
    NTSTATUS Status;

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

    if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
                           &USB_BUS_INTERFACE_HUB_GUID))
    {
        /* Get request parameters */
        InterfaceHub = (PUSB_BUS_INTERFACE_HUB_V5)IoStack->Parameters.QueryInterface.Interface;
        InterfaceHub->Version = IoStack->Parameters.QueryInterface.Version;

        /* Check version */
        if (IoStack->Parameters.QueryInterface.Version >= 6)
        {
            DPRINT1("USB_BUS_INTERFACE_HUB_GUID version %x not supported!\n",
                    IoStack->Parameters.QueryInterface.Version);

            return Irp->IoStatus.Status; // Version not supported
        }

        /* Interface version 0 */
        InterfaceHub->Size = IoStack->Parameters.QueryInterface.Size;
        InterfaceHub->BusContext = PdoDevice;

        InterfaceHub->InterfaceReference = USBI_InterfaceReference;
        InterfaceHub->InterfaceDereference = USBI_InterfaceDereference;

        /* Interface version 1 */
        if (IoStack->Parameters.QueryInterface.Version >= 1)
        {
            InterfaceHub->CreateUsbDevice = USBHI_CreateUsbDevice;
            InterfaceHub->InitializeUsbDevice = USBHI_InitializeUsbDevice;
            InterfaceHub->GetUsbDescriptors = USBHI_GetUsbDescriptors;
            InterfaceHub->RemoveUsbDevice = USBHI_RemoveUsbDevice;
            InterfaceHub->RestoreUsbDevice = USBHI_RestoreUsbDevice;
            InterfaceHub->QueryDeviceInformation = USBHI_QueryDeviceInformation;
        }

        /* Interface version 2 */
        if (IoStack->Parameters.QueryInterface.Version >= 2)
        {
            InterfaceHub->GetControllerInformation = USBHI_GetControllerInformation;
            InterfaceHub->ControllerSelectiveSuspend = USBHI_ControllerSelectiveSuspend;
            InterfaceHub->GetExtendedHubInformation = USBHI_GetExtendedHubInformation;
            InterfaceHub->GetRootHubSymbolicName = USBHI_GetRootHubSymbolicName;
            InterfaceHub->GetDeviceBusContext = USBHI_GetDeviceBusContext;
            InterfaceHub->Initialize20Hub = USBHI_Initialize20Hub;
        }

        /* Interface version 3 */
        if (IoStack->Parameters.QueryInterface.Version >= 3)
            InterfaceHub->RootHubInitNotification = USBHI_RootHubInitNotification;

        /* Interface version 4 */
        if (IoStack->Parameters.QueryInterface.Version >= 4)
            InterfaceHub->FlushTransfers = USBHI_FlushTransfers;

        /* Interface version 5 */
        if (IoStack->Parameters.QueryInterface.Version >= 5)
            InterfaceHub->SetDeviceHandleData = USBHI_SetDeviceHandleData;

        /* Request completed */
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
                                &USB_BUS_INTERFACE_USBDI_GUID))
    {
        /* Get request parameters */
        InterfaceDI = (PUSB_BUS_INTERFACE_USBDI_V2)IoStack->Parameters.QueryInterface.Interface;
        InterfaceDI->Version = IoStack->Parameters.QueryInterface.Version;

        /* Check version */
        if (IoStack->Parameters.QueryInterface.Version >= 3)
        {
            DPRINT1("USB_BUS_INTERFACE_USBDI_GUID version %x not supported!\n",
                    IoStack->Parameters.QueryInterface.Version);

            return Irp->IoStatus.Status; // Version not supported
        }

        /* Interface version 0 */
        InterfaceDI->Size = IoStack->Parameters.QueryInterface.Size;
        InterfaceDI->BusContext = PdoDevice;
        InterfaceDI->InterfaceReference = USBI_InterfaceReference;
        InterfaceDI->InterfaceDereference = USBI_InterfaceDereference;
        InterfaceDI->GetUSBDIVersion = USBDI_GetUSBDIVersion;
        InterfaceDI->QueryBusTime = USBDI_QueryBusTime;
        InterfaceDI->SubmitIsoOutUrb = USBDI_SubmitIsoOutUrb;
        InterfaceDI->QueryBusInformation = USBDI_QueryBusInformation;

        /* Interface version 1 */
        if (IoStack->Parameters.QueryInterface.Version >= 1)
            InterfaceDI->IsDeviceHighSpeed = USBDI_IsDeviceHighSpeed;

        /* Interface version 2 */
        if (IoStack->Parameters.QueryInterface.Version >= 2)
            InterfaceDI->EnumLogEntry = USBDI_EnumLogEntry;

        return STATUS_SUCCESS;
    }
    else
    {
        /* Convert GUID to string */
        Status = RtlStringFromGUID(IoStack->Parameters.QueryInterface.InterfaceType,
                                   &GuidBuffer);

        if (NT_SUCCESS(Status))
        {
            /* Print interface */
            DPRINT1("HandleQueryInterface UNKNOWN INTERFACE GUID: %wZ Version %x\n",
                    &GuidBuffer,
                    IoStack->Parameters.QueryInterface.Version);

            RtlFreeUnicodeString(&GuidBuffer); // Free GUID buffer
        }
    }

    return Irp->IoStatus.Status;
}