mirror of
https://github.com/reactos/reactos.git
synced 2024-08-17 08:58:30 +00:00
2825 lines
84 KiB
C
2825 lines
84 KiB
C
/*
|
|
* PROJECT: ReactOS USB Hub Driver
|
|
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
|
|
* PURPOSE: USBHub plug and play functions
|
|
* COPYRIGHT: Copyright 2017 Vadim Galyant <vgal@rambler.ru>
|
|
*/
|
|
|
|
#include "usbhub.h"
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
#define NDEBUG_USBHUB_PNP
|
|
#define NDEBUG_USBHUB_ENUM
|
|
#include "dbg_uhub.h"
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_IrpCompletion(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context)
|
|
{
|
|
PRKEVENT Event;
|
|
|
|
DPRINT("USBH_IrpCompletion: Irp - %p\n", Irp);
|
|
|
|
Event = Context;
|
|
KeSetEvent(Event, EVENT_INCREMENT, FALSE);
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_HubPnPIrpComplete(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context)
|
|
{
|
|
PUSBHUB_FDO_EXTENSION HubExtension;
|
|
|
|
DPRINT("USBH_HubPnPIrpComplete: Irp - %p\n", Irp);
|
|
|
|
HubExtension = Context;
|
|
|
|
if (!NT_SUCCESS(Irp->IoStatus.Status))
|
|
{
|
|
DPRINT1("USBH_HubPnPIrpComplete: Irp failed - %lX\n", Irp->IoStatus.Status);
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
|
|
}
|
|
|
|
Irp->IoStatus.Status = STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
KeSetEvent(&HubExtension->LowerDeviceEvent, EVENT_INCREMENT, FALSE);
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_QueryCapsComplete(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context)
|
|
{
|
|
PIO_STACK_LOCATION IoStack;
|
|
PDEVICE_CAPABILITIES Capabilities;
|
|
|
|
DPRINT("USBH_QueryCapsComplete: ... \n");
|
|
|
|
ASSERT(NT_SUCCESS(Irp->IoStatus.Status));
|
|
|
|
if (Irp->PendingReturned)
|
|
{
|
|
IoMarkIrpPending(Irp);
|
|
}
|
|
|
|
IoStack= IoGetCurrentIrpStackLocation(Irp);
|
|
Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
|
|
|
|
Capabilities->SurpriseRemovalOK = 1;
|
|
|
|
return STATUS_CONTINUE_COMPLETION;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBHUB_GetBusInterface(IN PDEVICE_OBJECT DeviceObject,
|
|
OUT PUSB_BUS_INTERFACE_HUB_V5 BusInterface)
|
|
{
|
|
PIRP Irp;
|
|
NTSTATUS Status;
|
|
PIO_STACK_LOCATION IoStack;
|
|
KEVENT Event;
|
|
|
|
DPRINT("USBHUB_GetBusInterface: ... \n");
|
|
|
|
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
|
|
|
|
if (!Irp)
|
|
{
|
|
DPRINT1("USBHUB_GetBusInterface: IoAllocateIrp() failed\n");
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
|
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
USBH_IrpCompletion,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
IoStack = IoGetNextIrpStackLocation(Irp);
|
|
|
|
IoStack->MajorFunction = IRP_MJ_PNP;
|
|
IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
|
|
|
|
IoStack->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_HUB_GUID;
|
|
IoStack->Parameters.QueryInterface.Size = sizeof(USB_BUS_INTERFACE_HUB_V5);
|
|
IoStack->Parameters.QueryInterface.Version = USB_BUSIF_HUB_VERSION_5;
|
|
IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
|
|
IoStack->Parameters.QueryInterface.InterfaceSpecificData = DeviceObject;
|
|
|
|
Status = IoCallDriver(DeviceObject, Irp);
|
|
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(&Event,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
Status = Irp->IoStatus.Status;
|
|
}
|
|
|
|
IoFreeIrp(Irp);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBHUB_GetBusInterfaceUSBDI(IN PDEVICE_OBJECT DeviceObject,
|
|
OUT PUSB_BUS_INTERFACE_USBDI_V2 BusInterfaceUSBDI)
|
|
{
|
|
PIRP Irp;
|
|
NTSTATUS Status;
|
|
PIO_STACK_LOCATION IoStack;
|
|
KEVENT Event;
|
|
|
|
DPRINT("USBHUB_GetBusInterfaceUSBDI: ... \n");
|
|
|
|
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
|
|
|
|
if (!Irp)
|
|
{
|
|
DPRINT1("USBHUB_GetBusInterfaceUSBDI: IoAllocateIrp() failed\n");
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
|
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
USBH_IrpCompletion,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
IoStack = IoGetNextIrpStackLocation(Irp);
|
|
|
|
IoStack->MajorFunction = IRP_MJ_PNP;
|
|
IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
|
|
|
|
IoStack->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_USBDI_GUID;
|
|
IoStack->Parameters.QueryInterface.Size = sizeof(USB_BUS_INTERFACE_USBDI_V2);
|
|
IoStack->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_2;
|
|
IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterfaceUSBDI;
|
|
IoStack->Parameters.QueryInterface.InterfaceSpecificData = NULL;
|
|
|
|
Status = IoCallDriver(DeviceObject, Irp);
|
|
|
|
if (Status == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(&Event,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
Status = Irp->IoStatus.Status;
|
|
}
|
|
|
|
IoFreeIrp(Irp);
|
|
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
USBH_QueryCapabilities(IN PDEVICE_OBJECT DeviceObject,
|
|
IN PDEVICE_CAPABILITIES DeviceCapabilities)
|
|
{
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IoStack;
|
|
KEVENT Event;
|
|
|
|
DPRINT("USBH_QueryCapabilities: ... \n");
|
|
|
|
RtlZeroMemory(DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
|
|
|
|
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
|
|
|
|
if (!Irp)
|
|
{
|
|
DPRINT1("USBH_QueryCapabilities: IoAllocateIrp() failed\n");
|
|
return;
|
|
}
|
|
|
|
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
|
|
|
|
KeInitializeEvent(&Event, NotificationEvent, FALSE);
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
USBH_IrpCompletion,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
IoStack = IoGetNextIrpStackLocation(Irp);
|
|
|
|
IoStack->MajorFunction = IRP_MJ_PNP;
|
|
IoStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
|
|
|
|
IoStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;
|
|
IoStack->Parameters.DeviceCapabilities.Capabilities->Size = sizeof(DEVICE_CAPABILITIES);
|
|
IoStack->Parameters.DeviceCapabilities.Capabilities->Version = 1;
|
|
IoStack->Parameters.DeviceCapabilities.Capabilities->Address = MAXULONG;
|
|
IoStack->Parameters.DeviceCapabilities.Capabilities->UINumber = MAXULONG;
|
|
|
|
if (IoCallDriver(DeviceObject, Irp) == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(&Event,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
IoFreeIrp(Irp);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_OpenConfiguration(IN PUSBHUB_FDO_EXTENSION HubExtension)
|
|
{
|
|
PUSB_INTERFACE_DESCRIPTOR Pid;
|
|
PURB Urb;
|
|
NTSTATUS Status;
|
|
USBD_INTERFACE_LIST_ENTRY InterfaceList[2] = {{NULL, NULL}, {NULL, NULL}};
|
|
|
|
DPRINT("USBH_OpenConfiguration ... \n");
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB &&
|
|
HubExtension->LowerPDO != HubExtension->RootHubPdo)
|
|
{
|
|
Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
|
|
HubExtension->HubConfigDescriptor,
|
|
-1,
|
|
-1,
|
|
USB_DEVICE_CLASS_HUB,
|
|
-1,
|
|
2);
|
|
|
|
if (Pid)
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_MULTIPLE_TTS;
|
|
}
|
|
else
|
|
{
|
|
Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
|
|
HubExtension->HubConfigDescriptor,
|
|
-1,
|
|
-1,
|
|
USB_DEVICE_CLASS_HUB,
|
|
-1,
|
|
1);
|
|
|
|
if (Pid)
|
|
{
|
|
goto Next;
|
|
}
|
|
|
|
Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
|
|
HubExtension->HubConfigDescriptor,
|
|
-1,
|
|
-1,
|
|
USB_DEVICE_CLASS_HUB,
|
|
-1,
|
|
0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Pid = USBD_ParseConfigurationDescriptorEx(HubExtension->HubConfigDescriptor,
|
|
HubExtension->HubConfigDescriptor,
|
|
-1,
|
|
-1,
|
|
USB_DEVICE_CLASS_HUB,
|
|
-1,
|
|
-1);
|
|
}
|
|
|
|
if (!Pid)
|
|
{
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
Next:
|
|
|
|
if (Pid->bInterfaceClass != USB_DEVICE_CLASS_HUB)
|
|
{
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
InterfaceList[0].InterfaceDescriptor = Pid;
|
|
|
|
Urb = USBD_CreateConfigurationRequestEx(HubExtension->HubConfigDescriptor,
|
|
InterfaceList);
|
|
|
|
if (!Urb)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
Status = USBH_FdoSyncSubmitUrb(HubExtension->Common.SelfDevice, Urb);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
RtlCopyMemory(&HubExtension->PipeInfo,
|
|
InterfaceList[0].Interface->Pipes,
|
|
sizeof(USBD_PIPE_INFORMATION));
|
|
|
|
HubExtension->ConfigHandle = Urb->UrbSelectConfiguration.ConfigurationHandle;
|
|
}
|
|
|
|
ExFreePool(Urb);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBD_Initialize20Hub(IN PUSBHUB_FDO_EXTENSION HubExtension)
|
|
{
|
|
PUSB_BUSIFFN_INITIALIZE_20HUB Initialize20Hub;
|
|
ULONG TtCount;
|
|
PUSB_DEVICE_HANDLE DeviceHandle;
|
|
|
|
DPRINT("USBD_InitUsb2Hub ... \n");
|
|
|
|
Initialize20Hub = HubExtension->BusInterface.Initialize20Hub;
|
|
|
|
if (!Initialize20Hub)
|
|
{
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
TtCount = 1;
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_MULTIPLE_TTS)
|
|
{
|
|
TtCount = HubExtension->HubDescriptor->bNumberOfPorts;
|
|
}
|
|
|
|
DeviceHandle = USBH_SyncGetDeviceHandle(HubExtension->LowerDevice);
|
|
|
|
return Initialize20Hub(HubExtension->BusInterface.BusContext,
|
|
DeviceHandle,
|
|
TtCount);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_AbortInterruptPipe(IN PUSBHUB_FDO_EXTENSION HubExtension)
|
|
{
|
|
struct _URB_PIPE_REQUEST * Urb;
|
|
NTSTATUS Status;
|
|
|
|
DPRINT("USBH_AbortInterruptPipe: HubExtension - %p\n", HubExtension);
|
|
|
|
Urb = ExAllocatePoolWithTag(NonPagedPool,
|
|
sizeof(struct _URB_PIPE_REQUEST),
|
|
USB_HUB_TAG);
|
|
|
|
if (!Urb)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
RtlZeroMemory(Urb, sizeof(struct _URB_PIPE_REQUEST));
|
|
|
|
Urb->Hdr.Length = sizeof(struct _URB_PIPE_REQUEST);
|
|
Urb->Hdr.Function = URB_FUNCTION_ABORT_PIPE;
|
|
Urb->PipeHandle = HubExtension->PipeInfo.PipeHandle;
|
|
|
|
Status = USBH_FdoSyncSubmitUrb(HubExtension->Common.SelfDevice,
|
|
(PURB)Urb);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
ExFreePoolWithTag(Urb, USB_HUB_TAG);
|
|
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
USBH_FdoCleanup(IN PUSBHUB_FDO_EXTENSION HubExtension)
|
|
{
|
|
PIRP IdleIrp = NULL;
|
|
PIRP WakeIrp = NULL;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
PUSBHUB_PORT_PDO_EXTENSION PortExtension;
|
|
PIRP PortIdleIrp = NULL;
|
|
PIRP PortWakeIrp = NULL;
|
|
PVOID DeviceHandle;
|
|
NTSTATUS Status;
|
|
USHORT Port;
|
|
UCHAR NumberPorts;
|
|
KIRQL Irql;
|
|
|
|
DPRINT("USBH_FdoCleanup: HubExtension - %p\n", HubExtension);
|
|
|
|
USBD_UnRegisterRootHubCallBack(HubExtension);
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_STOPPING;
|
|
|
|
if (HubExtension->ResetRequestCount)
|
|
{
|
|
IoCancelIrp(HubExtension->ResetPortIrp);
|
|
|
|
KeWaitForSingleObject(&HubExtension->IdleEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
IoFreeIrp(HubExtension->ResetPortIrp);
|
|
|
|
HubExtension->ResetPortIrp = NULL;
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST)
|
|
{
|
|
KeWaitForSingleObject(&HubExtension->IdleEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
IoAcquireCancelSpinLock(&Irql);
|
|
|
|
if (HubExtension->PendingWakeIrp)
|
|
{
|
|
WakeIrp = HubExtension->PendingWakeIrp;
|
|
HubExtension->PendingWakeIrp = NULL;
|
|
}
|
|
|
|
if (HubExtension->PendingIdleIrp)
|
|
{
|
|
IdleIrp = HubExtension->PendingIdleIrp;
|
|
HubExtension->PendingIdleIrp = NULL;
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(Irql);
|
|
|
|
if (WakeIrp)
|
|
{
|
|
USBH_HubCancelWakeIrp(HubExtension, WakeIrp);
|
|
}
|
|
|
|
USBH_HubCompletePortWakeIrps(HubExtension, STATUS_DELETE_PENDING);
|
|
|
|
if (IdleIrp)
|
|
{
|
|
USBH_HubCancelIdleIrp(HubExtension, IdleIrp);
|
|
}
|
|
|
|
if (InterlockedDecrement(&HubExtension->PendingRequestCount) > 0)
|
|
{
|
|
KeWaitForSingleObject(&HubExtension->PendingRequestEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
if (HubExtension->SCEIrp)
|
|
{
|
|
Status = USBH_AbortInterruptPipe(HubExtension);
|
|
|
|
if (!NT_SUCCESS(Status) && IoCancelIrp(HubExtension->SCEIrp))
|
|
{
|
|
KeWaitForSingleObject(&HubExtension->StatusChangeEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
IoFreeIrp(HubExtension->SCEIrp);
|
|
|
|
HubExtension->SCEIrp = NULL;
|
|
}
|
|
|
|
if (!HubExtension->PortData ||
|
|
!HubExtension->HubDescriptor)
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
PortData = HubExtension->PortData;
|
|
NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
|
|
|
|
for (Port = 0; Port < NumberPorts; Port++)
|
|
{
|
|
if (PortData[Port].DeviceObject)
|
|
{
|
|
PortExtension = PortData[Port].DeviceObject->DeviceExtension;
|
|
|
|
IoAcquireCancelSpinLock(&Irql);
|
|
|
|
PortIdleIrp = PortExtension->IdleNotificationIrp;
|
|
|
|
if (PortIdleIrp)
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_IDLE_NOTIFICATION;
|
|
PortExtension->IdleNotificationIrp = NULL;
|
|
|
|
if (PortIdleIrp->Cancel)
|
|
{
|
|
PortIdleIrp = NULL;
|
|
}
|
|
|
|
if (PortIdleIrp)
|
|
{
|
|
IoSetCancelRoutine(PortIdleIrp, NULL);
|
|
}
|
|
}
|
|
|
|
PortWakeIrp = PortExtension->PdoWaitWakeIrp;
|
|
|
|
if (PortWakeIrp)
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_WAIT_WAKE;
|
|
PortExtension->PdoWaitWakeIrp = NULL;
|
|
|
|
if (PortWakeIrp->Cancel || !IoSetCancelRoutine(PortWakeIrp, NULL))
|
|
{
|
|
PortWakeIrp = NULL;
|
|
|
|
if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
|
|
{
|
|
KeSetEvent(&HubExtension->PendingRequestEvent,
|
|
EVENT_INCREMENT,
|
|
FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(Irql);
|
|
|
|
if (PortIdleIrp)
|
|
{
|
|
PortIdleIrp->IoStatus.Status = STATUS_CANCELLED;
|
|
IoCompleteRequest(PortIdleIrp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
if (PortWakeIrp)
|
|
{
|
|
USBH_CompletePowerIrp(HubExtension,
|
|
PortWakeIrp,
|
|
STATUS_CANCELLED);
|
|
}
|
|
|
|
if (!(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3))
|
|
{
|
|
DeviceHandle = InterlockedExchangePointer(&PortExtension->DeviceHandle,
|
|
NULL);
|
|
|
|
if (DeviceHandle)
|
|
{
|
|
USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
|
|
}
|
|
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_POWER_D3;
|
|
}
|
|
}
|
|
|
|
USBH_SyncDisablePort(HubExtension, Port + 1);
|
|
}
|
|
|
|
Exit:
|
|
|
|
if (HubExtension->SCEBitmap)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->SCEBitmap, USB_HUB_TAG);
|
|
}
|
|
|
|
if (HubExtension->HubDescriptor)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->HubDescriptor, USB_HUB_TAG);
|
|
}
|
|
|
|
if (HubExtension->HubConfigDescriptor)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->HubConfigDescriptor, USB_HUB_TAG);
|
|
}
|
|
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_DEVICE_STARTED;
|
|
|
|
HubExtension->HubDescriptor = NULL;
|
|
HubExtension->HubConfigDescriptor = NULL;
|
|
|
|
HubExtension->SCEIrp = NULL;
|
|
HubExtension->SCEBitmap = NULL;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_StartHubFdoDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG DisableRemoteWakeup = 0;
|
|
ULONG HubCount = 0;
|
|
PUSB_DEVICE_HANDLE DeviceHandle;
|
|
USB_DEVICE_TYPE DeviceType;
|
|
DEVICE_CAPABILITIES DeviceCapabilities;
|
|
BOOLEAN IsBusPowered;
|
|
static WCHAR DisableWakeValueName[] = L"DisableRemoteWakeup";
|
|
|
|
DPRINT("USBH_StartHubFdoDevice: ... \n");
|
|
|
|
KeInitializeEvent(&HubExtension->IdleEvent, NotificationEvent, FALSE);
|
|
KeInitializeEvent(&HubExtension->ResetEvent, NotificationEvent, TRUE);
|
|
KeInitializeEvent(&HubExtension->PendingRequestEvent, NotificationEvent, FALSE);
|
|
KeInitializeEvent(&HubExtension->LowerDeviceEvent, NotificationEvent, FALSE);
|
|
KeInitializeEvent(&HubExtension->StatusChangeEvent, NotificationEvent, TRUE);
|
|
KeInitializeEvent(&HubExtension->RootHubNotificationEvent,
|
|
NotificationEvent,
|
|
TRUE);
|
|
|
|
KeInitializeSpinLock(&HubExtension->RelationsWorkerSpinLock);
|
|
KeInitializeSpinLock(&HubExtension->CheckIdleSpinLock);
|
|
|
|
KeInitializeSemaphore(&HubExtension->ResetDeviceSemaphore, 1, 1);
|
|
KeInitializeSemaphore(&HubExtension->HubPortSemaphore, 1, 1);
|
|
KeInitializeSemaphore(&HubExtension->HubSemaphore, 1, 1);
|
|
|
|
HubExtension->HubFlags = 0;
|
|
HubExtension->HubConfigDescriptor = NULL;
|
|
HubExtension->HubDescriptor = NULL;
|
|
HubExtension->SCEIrp = NULL;
|
|
HubExtension->SCEBitmap = NULL;
|
|
HubExtension->SystemPowerState.SystemState = PowerSystemWorking;
|
|
HubExtension->PendingRequestCount = 1;
|
|
HubExtension->ResetRequestCount = 0;
|
|
HubExtension->PendingIdleIrp = NULL;
|
|
HubExtension->PendingWakeIrp = NULL;
|
|
|
|
InitializeListHead(&HubExtension->PdoList);
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_WITEM_INIT;
|
|
InitializeListHead(&HubExtension->WorkItemList);
|
|
KeInitializeSpinLock(&HubExtension->WorkItemSpinLock);
|
|
|
|
IoCopyCurrentIrpStackLocationToNext(Irp);
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
USBH_HubPnPIrpComplete,
|
|
HubExtension,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
|
|
if (IoCallDriver(HubExtension->LowerDevice, Irp) == STATUS_PENDING)
|
|
{
|
|
KeWaitForSingleObject(&HubExtension->LowerDeviceEvent,
|
|
Suspended,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
}
|
|
|
|
HubExtension->RootHubPdo = NULL;
|
|
|
|
Status = USBH_SyncGetRootHubPdo(HubExtension->LowerDevice,
|
|
&HubExtension->RootHubPdo,
|
|
&HubExtension->RootHubPdo2);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_SyncGetRootHubPdo() failed - %lX\n", Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
USBH_WriteFailReasonID(HubExtension->LowerPDO, USBHUB_FAIL_NO_FAIL);
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBHUB_FDO_FLAG_DEVICE_FAILED - TRUE\n");
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_REMOTE_WAKEUP;
|
|
|
|
Status = USBD_GetPdoRegistryParameter(HubExtension->LowerPDO,
|
|
&DisableRemoteWakeup,
|
|
sizeof(DisableRemoteWakeup),
|
|
DisableWakeValueName,
|
|
sizeof(DisableWakeValueName));
|
|
|
|
if (NT_SUCCESS(Status) && DisableRemoteWakeup)
|
|
{
|
|
DPRINT("USBH_StartHubFdoDevice: DisableRemoteWakeup - TRUE\n");
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_REMOTE_WAKEUP;
|
|
}
|
|
|
|
HubExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
|
|
|
|
USBH_SyncGetHubCount(HubExtension->LowerDevice,
|
|
&HubCount);
|
|
|
|
Status = USBHUB_GetBusInterface(HubExtension->RootHubPdo,
|
|
&HubExtension->BusInterface);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBHUB_GetBusInterface() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
Status = USBHUB_GetBusInterfaceUSBDI(HubExtension->LowerDevice,
|
|
&HubExtension->BusInterfaceUSBDI);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBHUB_GetBusInterfaceUSBDI() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
DeviceHandle = USBH_SyncGetDeviceHandle(HubExtension->LowerDevice);
|
|
|
|
if (DeviceHandle)
|
|
{
|
|
Status = USBH_GetDeviceType(HubExtension, DeviceHandle, &DeviceType);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBH_GetDeviceType() failed - %lX\n",
|
|
Status);
|
|
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if (DeviceType == Usb20Device)
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_USB20_HUB;
|
|
}
|
|
}
|
|
|
|
if (HubCount > USBHUB_MAX_CASCADE_LEVELS)
|
|
{
|
|
PUSBHUB_PORT_PDO_EXTENSION ParentPdoExtension;
|
|
PUSBHUB_FDO_EXTENSION ParentHubExtension;
|
|
USHORT ParentPort;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
|
|
DPRINT1("USBH_StartHubFdoDevice: HubCount > 6 - %x\n", HubCount);
|
|
|
|
USBH_WriteFailReasonID(HubExtension->LowerPDO,
|
|
USBHUB_FAIL_NESTED_TOO_DEEPLY);
|
|
|
|
ParentPdoExtension = HubExtension->LowerPDO->DeviceExtension;
|
|
ParentHubExtension = ParentPdoExtension->HubExtension;
|
|
|
|
ParentPort = ParentPdoExtension->PortNumber - 1;
|
|
PortData = &ParentHubExtension->PortData[ParentPort];
|
|
PortData->ConnectionStatus = DeviceHubNestedTooDeeply;
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
|
|
}
|
|
|
|
USBH_QueryCapabilities(HubExtension->LowerDevice, &DeviceCapabilities);
|
|
|
|
HubExtension->SystemWake = DeviceCapabilities.SystemWake;
|
|
HubExtension->DeviceWake = DeviceCapabilities.DeviceWake;
|
|
|
|
RtlCopyMemory(HubExtension->DeviceState,
|
|
&DeviceCapabilities.DeviceState,
|
|
POWER_SYSTEM_MAXIMUM * sizeof(DEVICE_POWER_STATE));
|
|
|
|
Status = USBH_GetDeviceDescriptor(HubExtension->Common.SelfDevice,
|
|
&HubExtension->HubDeviceDescriptor);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBH_GetDeviceDescriptor() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
Status = USBH_GetConfigurationDescriptor(HubExtension->Common.SelfDevice,
|
|
&HubExtension->HubConfigDescriptor);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBH_GetConfigurationDescriptor() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
Status = USBH_SyncGetHubDescriptor(HubExtension);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBH_SyncGetHubDescriptor() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
IsBusPowered = USBH_HubIsBusPowered(HubExtension->Common.SelfDevice,
|
|
HubExtension->HubConfigDescriptor);
|
|
|
|
if (IsBusPowered)
|
|
{
|
|
/* bus-powered hub is allowed a maximum of 100 mA only for each port */
|
|
HubExtension->MaxPowerPerPort = 100;
|
|
|
|
/* can have 4 ports (4 * 100 mA) and 100 mA remains for itself;
|
|
expressed in 2 mA units (i.e., 250 = 500 mA). */
|
|
HubExtension->HubConfigDescriptor->MaxPower = 250;
|
|
}
|
|
else
|
|
{
|
|
/* self-powered hub is allowed a maximum of 500 mA for each port */
|
|
HubExtension->MaxPowerPerPort = 500;
|
|
}
|
|
|
|
Status = USBH_OpenConfiguration(HubExtension);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("USBH_StartHubFdoDevice: USBH_OpenConfiguration() failed - %lX\n",
|
|
Status);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB)
|
|
{
|
|
Status = USBD_Initialize20Hub(HubExtension);
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
HubExtension->SCEIrp = IoAllocateIrp(HubExtension->Common.SelfDevice->StackSize,
|
|
FALSE);
|
|
|
|
HubExtension->ResetPortIrp = IoAllocateIrp(HubExtension->Common.SelfDevice->StackSize,
|
|
FALSE);
|
|
|
|
if (!HubExtension->SCEIrp || !HubExtension->ResetPortIrp)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
HubExtension->SCEBitmapLength = HubExtension->PipeInfo.MaximumPacketSize;
|
|
|
|
HubExtension->SCEBitmap = ExAllocatePoolWithTag(NonPagedPool,
|
|
HubExtension->SCEBitmapLength,
|
|
USB_HUB_TAG);
|
|
|
|
if (!HubExtension->SCEBitmap)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
RtlZeroMemory(HubExtension->SCEBitmap, HubExtension->SCEBitmapLength);
|
|
|
|
Status = USBH_SyncPowerOnPorts(HubExtension);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
{
|
|
USHORT Port;
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_STARTED;
|
|
|
|
for (Port = 1;
|
|
Port <= HubExtension->HubDescriptor->bNumberOfPorts;
|
|
Port++)
|
|
{
|
|
USBH_SyncClearPortStatus(HubExtension,
|
|
Port,
|
|
USBHUB_FEATURE_C_PORT_CONNECTION);
|
|
}
|
|
}
|
|
|
|
if (HubExtension->LowerPDO == HubExtension->RootHubPdo)
|
|
{
|
|
USBD_RegisterRootHubCallBack(HubExtension);
|
|
}
|
|
else
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DO_ENUMERATION;
|
|
USBH_SubmitStatusChangeTransfer(HubExtension);
|
|
}
|
|
|
|
goto Exit;
|
|
|
|
ErrorExit:
|
|
|
|
if (HubExtension->HubDescriptor)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->HubDescriptor, USB_HUB_TAG);
|
|
HubExtension->HubDescriptor = NULL;
|
|
}
|
|
|
|
if (HubExtension->SCEIrp)
|
|
{
|
|
IoFreeIrp(HubExtension->SCEIrp);
|
|
HubExtension->SCEIrp = NULL;
|
|
}
|
|
|
|
if (HubExtension->ResetPortIrp)
|
|
{
|
|
IoFreeIrp(HubExtension->ResetPortIrp);
|
|
HubExtension->ResetPortIrp = NULL;
|
|
}
|
|
|
|
if (HubExtension->SCEBitmap)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->SCEBitmap, USB_HUB_TAG);
|
|
HubExtension->SCEBitmap = NULL;
|
|
}
|
|
|
|
if (HubExtension->HubConfigDescriptor)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->HubConfigDescriptor, USB_HUB_TAG);
|
|
HubExtension->HubConfigDescriptor = NULL;
|
|
}
|
|
|
|
Exit:
|
|
|
|
USBH_CompleteIrp(Irp, Status);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_FdoStartDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
DPRINT("USBH_FdoStartDevice: HubExtension - %p\n", HubExtension);
|
|
|
|
HubExtension->RootHubPdo = NULL;
|
|
|
|
Status = USBH_SyncGetRootHubPdo(HubExtension->LowerDevice,
|
|
&HubExtension->RootHubPdo,
|
|
&HubExtension->RootHubPdo2);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
if (HubExtension->RootHubPdo)
|
|
{
|
|
Status = USBH_StartHubFdoDevice(HubExtension, Irp);
|
|
}
|
|
else
|
|
{
|
|
DPRINT1("USBH_FdoStartDevice: FIXME. start ParentDevice\n");
|
|
DbgBreakPoint();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DPRINT1("USBH_FdoStartDevice: FIXME. USBH_SyncGetRootHubPdo return - %lX\n",
|
|
Status);
|
|
|
|
DbgBreakPoint();
|
|
USBH_CompleteIrp(Irp, Status);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_FdoQueryBusRelations(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
PDEVICE_RELATIONS DeviceRelations = NULL;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
LIST_ENTRY GhostPdoList;
|
|
KIRQL OldIrql;
|
|
PLIST_ENTRY PdoList;
|
|
UCHAR NumberPorts;
|
|
USHORT Port;
|
|
USHORT GhostPort;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
PDEVICE_OBJECT PdoDevice;
|
|
PUSBHUB_PORT_PDO_EXTENSION PdoExtension;
|
|
PUSBHUB_PORT_PDO_EXTENSION pdoExtension;
|
|
NTSTATUS NtStatus;
|
|
PVOID SerialNumber;
|
|
PVOID DeviceHandle;
|
|
USB_PORT_STATUS UsbPortStatus;
|
|
PLIST_ENTRY Entry;
|
|
ULONG Length;
|
|
|
|
DPRINT_ENUM("USBH_FdoQueryBusRelations: HubFlags - %lX\n",
|
|
HubExtension->HubFlags);
|
|
|
|
if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED))
|
|
{
|
|
Status = STATUS_INVALID_DEVICE_STATE;
|
|
goto RelationsWorker;
|
|
}
|
|
|
|
if (!HubExtension->HubDescriptor)
|
|
{
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
goto RelationsWorker;
|
|
}
|
|
|
|
if (!(HubExtension->HubFlags & USBHUB_FDO_FLAG_DO_ENUMERATION))
|
|
{
|
|
DPRINT_ENUM("USBH_FdoQueryBusRelations: Skip enumeration\n");
|
|
goto RelationsWorker;
|
|
}
|
|
|
|
InterlockedIncrement(&HubExtension->PendingRequestCount);
|
|
|
|
KeWaitForSingleObject(&HubExtension->ResetDeviceSemaphore,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
|
|
DPRINT_ENUM("USBH_FdoQueryBusRelations: NumberPorts - %x\n", NumberPorts);
|
|
|
|
Length = FIELD_OFFSET(DEVICE_RELATIONS, Objects) +
|
|
NumberPorts * sizeof(PDEVICE_OBJECT);
|
|
|
|
if (Irp->IoStatus.Information)
|
|
{
|
|
DPRINT1("FIXME: leaking old bus relations\n");
|
|
}
|
|
|
|
DeviceRelations = ExAllocatePoolWithTag(NonPagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (!DeviceRelations)
|
|
{
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
|
|
|
|
KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
|
|
LOW_REALTIME_PRIORITY,
|
|
1,
|
|
FALSE);
|
|
|
|
if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
|
|
{
|
|
KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
|
|
}
|
|
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto RelationsWorker;
|
|
}
|
|
|
|
RtlZeroMemory(DeviceRelations, Length);
|
|
|
|
DeviceRelations->Count = 0;
|
|
|
|
EnumStart:
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_ESD_RECOVERING)
|
|
{
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
|
|
|
|
KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
|
|
LOW_REALTIME_PRIORITY,
|
|
1,
|
|
FALSE);
|
|
|
|
if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
|
|
{
|
|
KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
|
|
}
|
|
|
|
Status = STATUS_SUCCESS;
|
|
goto RelationsWorker;
|
|
}
|
|
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_ENUM_POST_RECOVER;
|
|
|
|
for (Port = 1; Port <= NumberPorts; Port++)
|
|
{
|
|
PortData = &HubExtension->PortData[Port - 1];
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Status = USBH_SyncGetPortStatus(HubExtension,
|
|
Port,
|
|
&PortData->PortStatus,
|
|
sizeof(USB_PORT_STATUS_AND_CHANGE));
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT_ENUM("USBH_FdoQueryBusRelations: Status - %X\n", Status);
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
|
|
DeviceRelations->Count = 0;
|
|
goto EnumStart;
|
|
}
|
|
|
|
DPRINT_ENUM("USBH_FdoQueryBusRelations: Port - %x, ConnectStatus - %x\n",
|
|
Port,
|
|
PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus);
|
|
|
|
PdoDevice = PortData->DeviceObject;
|
|
|
|
if (PortData->DeviceObject)
|
|
{
|
|
PdoExtension = PdoDevice->DeviceExtension;
|
|
|
|
if (PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_OVERCURRENT_PORT)
|
|
{
|
|
PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus = 1;
|
|
}
|
|
}
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
|
|
{
|
|
DPRINT1("USBH_FdoQueryBusRelations: DbgBreakPoint() \n");
|
|
DbgBreakPoint();
|
|
}
|
|
|
|
if (!PortData->PortStatus.PortStatus.Usb20PortStatus.CurrentConnectStatus)
|
|
{
|
|
if (PdoDevice)
|
|
{
|
|
PdoExtension = PdoDevice->DeviceExtension;
|
|
|
|
PdoExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DELETE_PENDING;
|
|
PdoExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
|
|
|
|
SerialNumber = InterlockedExchangePointer((PVOID)&PdoExtension->SerialNumber,
|
|
NULL);
|
|
|
|
if (SerialNumber)
|
|
{
|
|
ExFreePoolWithTag(SerialNumber, USB_HUB_TAG);
|
|
}
|
|
|
|
DeviceHandle = InterlockedExchangePointer(&PdoExtension->DeviceHandle,
|
|
NULL);
|
|
|
|
if (DeviceHandle)
|
|
{
|
|
USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
|
|
USBH_SyncDisablePort(HubExtension, Port);
|
|
}
|
|
}
|
|
|
|
PortData->DeviceObject = NULL;
|
|
PortData->ConnectionStatus = NoDeviceConnected;
|
|
continue;
|
|
}
|
|
|
|
if (PdoDevice)
|
|
{
|
|
ObReferenceObject(PdoDevice);
|
|
|
|
PdoDevice->Flags |= DO_POWER_PAGABLE;
|
|
PdoDevice->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
DeviceRelations->Objects[DeviceRelations->Count++] = PdoDevice;
|
|
|
|
PdoExtension = PdoDevice->DeviceExtension;
|
|
PdoExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_POWER_D1_OR_D2;
|
|
|
|
continue;
|
|
}
|
|
|
|
USBH_Wait(100);
|
|
|
|
NtStatus = USBH_SyncResetPort(HubExtension, Port);
|
|
|
|
if (!NT_SUCCESS(NtStatus))
|
|
{
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB)
|
|
{
|
|
PortData->DeviceObject = NULL;
|
|
PortData->ConnectionStatus = NoDeviceConnected;
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NtStatus = USBH_SyncGetPortStatus(HubExtension,
|
|
Port,
|
|
&PortData->PortStatus,
|
|
sizeof(USB_PORT_STATUS_AND_CHANGE));
|
|
|
|
UsbPortStatus = PortData->PortStatus.PortStatus;
|
|
|
|
if (NT_SUCCESS(NtStatus))
|
|
{
|
|
ULONG ix = 0;
|
|
|
|
for (NtStatus = USBH_CreateDevice(HubExtension, Port, UsbPortStatus, ix);
|
|
!NT_SUCCESS(NtStatus);
|
|
NtStatus = USBH_CreateDevice(HubExtension, Port, UsbPortStatus, ix))
|
|
{
|
|
USBH_Wait(500);
|
|
|
|
if (ix >= 2)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (PortData->DeviceObject)
|
|
{
|
|
IoDeleteDevice(PortData->DeviceObject);
|
|
PortData->DeviceObject = NULL;
|
|
PortData->ConnectionStatus = NoDeviceConnected;
|
|
}
|
|
|
|
USBH_SyncResetPort(HubExtension, Port);
|
|
|
|
ix++;
|
|
}
|
|
|
|
if (NT_SUCCESS(NtStatus))
|
|
{
|
|
PdoExtension = PortData->DeviceObject->DeviceExtension;
|
|
|
|
if (!(PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_PORT_LOW_SPEED) &&
|
|
!(PdoExtension->PortPdoFlags & USBHUB_PDO_FLAG_PORT_HIGH_SPEED) &&
|
|
!(HubExtension->HubFlags & USBHUB_FDO_FLAG_USB20_HUB))
|
|
{
|
|
DPRINT1("USBH_FdoQueryBusRelations: FIXME USBH_DeviceIs2xDualMode()\n");
|
|
|
|
if (0)//USBH_DeviceIs2xDualMode(PdoExtension))
|
|
{
|
|
PdoExtension->PortPdoFlags |= USBHUB_PDO_FLAG_HS_USB1_DUALMODE;
|
|
}
|
|
}
|
|
|
|
ObReferenceObject(PortData->DeviceObject);
|
|
|
|
DeviceRelations->Objects[DeviceRelations->Count] = PortData->DeviceObject;
|
|
|
|
PortData->DeviceObject->Flags |= DO_POWER_PAGABLE;
|
|
PortData->DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
DeviceRelations->Count++;
|
|
|
|
PortData->ConnectionStatus = DeviceConnected;
|
|
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
PortData->ConnectionStatus = DeviceFailedEnumeration;
|
|
|
|
if (NT_ERROR(USBH_SyncDisablePort(HubExtension, Port)))
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_FAILED;
|
|
}
|
|
|
|
if (PortData->DeviceObject)
|
|
{
|
|
ObReferenceObject(PortData->DeviceObject);
|
|
PortData->DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
DeviceRelations->Objects[DeviceRelations->Count++] = PortData->DeviceObject;
|
|
}
|
|
}
|
|
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_NOT_ENUMERATED;
|
|
|
|
KeReleaseSemaphore(&HubExtension->ResetDeviceSemaphore,
|
|
LOW_REALTIME_PRIORITY,
|
|
1,
|
|
FALSE);
|
|
|
|
if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
|
|
{
|
|
KeSetEvent(&HubExtension->PendingRequestEvent, EVENT_INCREMENT, FALSE);
|
|
}
|
|
|
|
RelationsWorker:
|
|
|
|
Irp->IoStatus.Status = Status;
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
//Irp->IoStatus.Information = 0;
|
|
|
|
if (DeviceRelations)
|
|
{
|
|
ExFreePoolWithTag(DeviceRelations, USB_HUB_TAG);
|
|
}
|
|
|
|
USBH_CompleteIrp(Irp, Status);
|
|
|
|
return Status;
|
|
}
|
|
|
|
KeAcquireSpinLock(&HubExtension->RelationsWorkerSpinLock, &OldIrql);
|
|
|
|
if (DeviceRelations && DeviceRelations->Count)
|
|
{
|
|
for (Port = 0; Port < DeviceRelations->Count; Port++)
|
|
{
|
|
PdoDevice = DeviceRelations->Objects[Port];
|
|
Entry = HubExtension->PdoList.Flink;
|
|
|
|
while (Entry != &HubExtension->PdoList)
|
|
{
|
|
pdoExtension = CONTAINING_RECORD(Entry,
|
|
USBHUB_PORT_PDO_EXTENSION,
|
|
PortLink);
|
|
|
|
if (pdoExtension == PdoDevice->DeviceExtension)
|
|
{
|
|
PdoExt(PdoDevice)->EnumFlags |= USBHUB_ENUM_FLAG_GHOST_DEVICE;
|
|
goto PortNext;
|
|
}
|
|
|
|
Entry = Entry->Flink;
|
|
}
|
|
|
|
PdoExt(PdoDevice)->EnumFlags |= USBHUB_ENUM_FLAG_DEVICE_PRESENT;
|
|
|
|
PortNext:;
|
|
}
|
|
|
|
for (Port = 0; Port < DeviceRelations->Count; Port++)
|
|
{
|
|
PdoDevice = DeviceRelations->Objects[Port];
|
|
|
|
if (PdoExt(PdoDevice)->EnumFlags & USBHUB_ENUM_FLAG_GHOST_DEVICE)
|
|
{
|
|
for (GhostPort = Port;
|
|
GhostPort < DeviceRelations->Count;
|
|
GhostPort++)
|
|
{
|
|
DeviceRelations->Objects[GhostPort] =
|
|
DeviceRelations->Objects[GhostPort + 1];
|
|
}
|
|
|
|
ObDereferenceObject(PdoDevice);
|
|
|
|
DeviceRelations->Count--;
|
|
|
|
if (PdoExt(PdoDevice)->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT)
|
|
{
|
|
PdoExt(PdoDevice)->EnumFlags &= ~USBHUB_ENUM_FLAG_GHOST_DEVICE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
|
|
|
|
InitializeListHead(&GhostPdoList);
|
|
PdoList = &HubExtension->PdoList;
|
|
|
|
while (!IsListEmpty(PdoList))
|
|
{
|
|
Entry = RemoveHeadList(PdoList);
|
|
|
|
PdoExtension = CONTAINING_RECORD(Entry,
|
|
USBHUB_PORT_PDO_EXTENSION,
|
|
PortLink);
|
|
|
|
PdoExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
|
|
|
|
if (PdoExtension->EnumFlags & USBHUB_ENUM_FLAG_GHOST_DEVICE)
|
|
{
|
|
InsertTailList(&GhostPdoList, &PdoExtension->PortLink);
|
|
}
|
|
}
|
|
|
|
KeReleaseSpinLock(&HubExtension->RelationsWorkerSpinLock, OldIrql);
|
|
|
|
while (!IsListEmpty(&GhostPdoList))
|
|
{
|
|
Entry = RemoveHeadList(&GhostPdoList);
|
|
|
|
PdoExtension = CONTAINING_RECORD(Entry,
|
|
USBHUB_PORT_PDO_EXTENSION,
|
|
PortLink);
|
|
|
|
IoDeleteDevice(PdoExtension->Common.SelfDevice);
|
|
}
|
|
|
|
return USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_FdoStopDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
DPRINT1("USBH_FdoStopDevice: UNIMPLEMENTED. FIXME\n");
|
|
DbgBreakPoint();
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_FdoRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
PUSB_HUB_DESCRIPTOR HubDescriptor;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
USHORT NumPorts;
|
|
USHORT ix;
|
|
PDEVICE_OBJECT PortDevice;
|
|
PUSBHUB_PORT_PDO_EXTENSION PortExtension;
|
|
NTSTATUS Status;
|
|
|
|
DPRINT("USBH_FdoRemoveDevice: HubExtension - %p\n", HubExtension);
|
|
|
|
HubDescriptor = HubExtension->HubDescriptor;
|
|
|
|
if (HubDescriptor && HubExtension->PortData)
|
|
{
|
|
NumPorts = HubDescriptor->bNumberOfPorts;
|
|
|
|
for (ix = 0; ix < NumPorts; ++ix)
|
|
{
|
|
PortData = HubExtension->PortData + ix;
|
|
|
|
PortDevice = PortData->DeviceObject;
|
|
|
|
if (PortDevice)
|
|
{
|
|
PortData->PortStatus.AsUlong32 = 0;
|
|
PortData->DeviceObject = NULL;
|
|
|
|
PortExtension = PortDevice->DeviceExtension;
|
|
PortExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
|
|
|
|
USBH_PdoRemoveDevice(PortExtension, HubExtension);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED)
|
|
{
|
|
USBH_FdoCleanup(HubExtension);
|
|
}
|
|
|
|
if (HubExtension->PortData)
|
|
{
|
|
ExFreePoolWithTag(HubExtension->PortData, USB_HUB_TAG);
|
|
HubExtension->PortData = NULL;
|
|
}
|
|
|
|
DPRINT1("USBH_FdoRemoveDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
|
|
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
|
|
IoDetachDevice(HubExtension->LowerDevice);
|
|
IoDeleteDevice(HubExtension->Common.SelfDevice);
|
|
|
|
return Status;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
USBH_FdoSurpriseRemoveDevice(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
PUSBHUB_PORT_PDO_EXTENSION PortExtension;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
ULONG NumberPorts;
|
|
ULONG Port;
|
|
|
|
DPRINT("USBH_FdoSurpriseRemoveDevice: HubExtension - %p, Irp - %p\n",
|
|
HubExtension,
|
|
Irp);
|
|
|
|
if (!HubExtension->PortData ||
|
|
!HubExtension->HubDescriptor)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PortData = HubExtension->PortData;
|
|
NumberPorts = HubExtension->HubDescriptor->bNumberOfPorts;
|
|
|
|
for (Port = 0; Port < NumberPorts; Port++)
|
|
{
|
|
if (PortData[Port].DeviceObject)
|
|
{
|
|
PortExtension = PdoExt(PortData[Port].DeviceObject);
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DELETE_PENDING;
|
|
PortExtension->EnumFlags &= ~USBHUB_ENUM_FLAG_DEVICE_PRESENT;
|
|
|
|
PortData[Port].DeviceObject = NULL;
|
|
PortData[Port].ConnectionStatus = NoDeviceConnected;
|
|
}
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoQueryId(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
ULONG IdType;
|
|
WCHAR Buffer[200];
|
|
PWCHAR EndBuffer;
|
|
size_t Remaining = sizeof(Buffer);
|
|
ULONG Length;
|
|
PWCHAR Id = NULL;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PUSB_DEVICE_DESCRIPTOR DeviceDescriptor;
|
|
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
|
|
|
|
IdType = IoGetCurrentIrpStackLocation(Irp)->Parameters.QueryId.IdType;
|
|
DeviceDescriptor = &PortExtension->DeviceDescriptor;
|
|
InterfaceDescriptor = &PortExtension->InterfaceDescriptor;
|
|
|
|
RtlZeroMemory(Buffer, sizeof(Buffer));
|
|
|
|
switch (IdType)
|
|
{
|
|
case BusQueryDeviceID:
|
|
DPRINT("USBH_PdoQueryId: BusQueryDeviceID\n");
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
|
|
{
|
|
DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Vid_0000&Pid_0000");
|
|
}
|
|
else
|
|
{
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Vid_%04x&Pid_%04x",
|
|
DeviceDescriptor->idVendor,
|
|
DeviceDescriptor->idProduct);
|
|
}
|
|
|
|
Length = sizeof(Buffer) - (Remaining - sizeof(UNICODE_NULL));
|
|
|
|
Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (!Id)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RtlCopyMemory(Id, Buffer, Length);
|
|
DPRINT("USBH_PdoQueryId: BusQueryDeviceID - %S\n", Id);
|
|
break;
|
|
|
|
case BusQueryHardwareIDs:
|
|
DPRINT("USBH_PdoQueryId: BusQueryHardwareIDs\n");
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
|
|
{
|
|
DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
|
|
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\UNKNOWN");
|
|
}
|
|
else
|
|
{
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Vid_%04x&Pid_%04x&Rev_%04x",
|
|
DeviceDescriptor->idVendor,
|
|
DeviceDescriptor->idProduct,
|
|
DeviceDescriptor->bcdDevice);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Vid_%04x&Pid_%04x",
|
|
DeviceDescriptor->idVendor,
|
|
DeviceDescriptor->idProduct);
|
|
}
|
|
|
|
Length = sizeof(Buffer) - (Remaining - sizeof(UNICODE_NULL));
|
|
|
|
Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (!Id)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RtlCopyMemory(Id, Buffer, Length);
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
|
|
{
|
|
DPRINT("USBH_PdoQueryId: BusQueryInstanceID - %S\n", Id);
|
|
}
|
|
else
|
|
{
|
|
USBHUB_DumpingIDs(Id);
|
|
}
|
|
|
|
break;
|
|
|
|
case BusQueryCompatibleIDs:
|
|
DPRINT("USBH_PdoQueryId: BusQueryCompatibleIDs\n");
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
|
|
{
|
|
DPRINT("USBH_PdoQueryId: USBHUB_PDO_FLAG_INIT_PORT_FAILED\n");
|
|
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\UNKNOWN");
|
|
}
|
|
else if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_MULTI_INTERFACE)
|
|
{
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\DevClass_%02x&SubClass_%02x&Prot_%02x",
|
|
InterfaceDescriptor->bInterfaceClass,
|
|
InterfaceDescriptor->bInterfaceSubClass,
|
|
InterfaceDescriptor->bInterfaceProtocol);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\DevClass_%02x&SubClass_%02x",
|
|
InterfaceDescriptor->bInterfaceClass,
|
|
InterfaceDescriptor->bInterfaceSubClass);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\DevClass_%02x",
|
|
InterfaceDescriptor->bInterfaceClass);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\COMPOSITE");
|
|
}
|
|
else
|
|
{
|
|
RtlStringCbPrintfExW(Buffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Class_%02x&SubClass_%02x&Prot_%02x",
|
|
InterfaceDescriptor->bInterfaceClass,
|
|
InterfaceDescriptor->bInterfaceSubClass,
|
|
InterfaceDescriptor->bInterfaceProtocol);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
&EndBuffer,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Class_%02x&SubClass_%02x",
|
|
InterfaceDescriptor->bInterfaceClass,
|
|
InterfaceDescriptor->bInterfaceSubClass);
|
|
|
|
EndBuffer++;
|
|
Remaining -= sizeof(UNICODE_NULL);
|
|
|
|
RtlStringCbPrintfExW(EndBuffer,
|
|
Remaining,
|
|
NULL,
|
|
&Remaining,
|
|
0,
|
|
L"USB\\Class_%02x",
|
|
InterfaceDescriptor->bInterfaceClass);
|
|
}
|
|
|
|
Length = sizeof(Buffer) - (Remaining - sizeof(UNICODE_NULL));
|
|
|
|
Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (!Id)
|
|
{
|
|
break;
|
|
}
|
|
|
|
RtlCopyMemory(Id, Buffer, Length);
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED)
|
|
{
|
|
DPRINT("USBH_PdoQueryId: BusQueryInstanceID - %S\n", Id);
|
|
}
|
|
else
|
|
{
|
|
USBHUB_DumpingIDs(Id);
|
|
}
|
|
|
|
break;
|
|
|
|
case BusQueryInstanceID:
|
|
DPRINT("USBH_PdoQueryId: BusQueryInstanceID\n");
|
|
|
|
if (PortExtension->SerialNumber)
|
|
{
|
|
Id = ExAllocatePoolWithTag(PagedPool,
|
|
PortExtension->SN_DescriptorLength,
|
|
USB_HUB_TAG);
|
|
|
|
if (Id)
|
|
{
|
|
RtlZeroMemory(Id, PortExtension->SN_DescriptorLength);
|
|
|
|
RtlCopyMemory(Id,
|
|
PortExtension->SerialNumber,
|
|
PortExtension->SN_DescriptorLength);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Length = sizeof(PortExtension->InstanceID) +
|
|
sizeof(UNICODE_NULL);
|
|
|
|
Id = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (Id)
|
|
{
|
|
RtlZeroMemory(Id, Length);
|
|
|
|
RtlCopyMemory(Id,
|
|
PortExtension->InstanceID,
|
|
sizeof(PortExtension->InstanceID));
|
|
}
|
|
}
|
|
|
|
DPRINT("USBH_PdoQueryId: BusQueryInstanceID - %S\n", Id);
|
|
break;
|
|
|
|
default:
|
|
DPRINT1("USBH_PdoQueryId: unknown query id type 0x%lx\n", IdType);
|
|
return Irp->IoStatus.Status;
|
|
}
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)Id;
|
|
|
|
if (!Id)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoQueryDeviceText(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
PDEVICE_OBJECT DeviceObject;
|
|
PIO_STACK_LOCATION IoStack;
|
|
DEVICE_TEXT_TYPE DeviceTextType;
|
|
USHORT LanguageId;
|
|
USHORT DefaultId;
|
|
PUSB_STRING_DESCRIPTOR Descriptor;
|
|
PWCHAR DeviceText;
|
|
UCHAR iProduct = 0;
|
|
NTSTATUS Status;
|
|
ULONG NumSymbols;
|
|
ULONG Length;
|
|
|
|
DPRINT("USBH_PdoQueryDeviceText ... \n");
|
|
|
|
DeviceObject = PortExtension->Common.SelfDevice;
|
|
IoStack = IoGetCurrentIrpStackLocation(Irp);
|
|
DeviceTextType = IoStack->Parameters.QueryDeviceText.DeviceTextType;
|
|
|
|
if (DeviceTextType != DeviceTextDescription &&
|
|
DeviceTextType != DeviceTextLocationInformation)
|
|
{
|
|
return Irp->IoStatus.Status;
|
|
}
|
|
|
|
LanguageId = LANGIDFROMLCID(IoStack->Parameters.QueryDeviceText.LocaleId);
|
|
DefaultId = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
|
|
|
|
if (!LanguageId)
|
|
{
|
|
LanguageId = DefaultId;
|
|
}
|
|
|
|
iProduct = PortExtension->DeviceDescriptor.iProduct;
|
|
|
|
if (PortExtension->DeviceHandle && iProduct &&
|
|
!PortExtension->IgnoringHwSerial &&
|
|
!(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_INIT_PORT_FAILED))
|
|
{
|
|
Descriptor = ExAllocatePoolWithTag(NonPagedPool,
|
|
MAXIMUM_USB_STRING_LENGTH,
|
|
USB_HUB_TAG);
|
|
|
|
if (Descriptor)
|
|
{
|
|
RtlZeroMemory(Descriptor, MAXIMUM_USB_STRING_LENGTH);
|
|
|
|
for (Status = USBH_CheckDeviceLanguage(DeviceObject, LanguageId);
|
|
;
|
|
Status = USBH_CheckDeviceLanguage(DeviceObject, DefaultId))
|
|
{
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Status = USBH_SyncGetStringDescriptor(DeviceObject,
|
|
iProduct,
|
|
LanguageId,
|
|
Descriptor,
|
|
MAXIMUM_USB_STRING_LENGTH,
|
|
NULL,
|
|
TRUE);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (LanguageId == DefaultId)
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
LanguageId = DefaultId;
|
|
}
|
|
|
|
if (Descriptor->bLength <= sizeof(USB_COMMON_DESCRIPTOR))
|
|
{
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
Length = Descriptor->bLength -
|
|
FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString);
|
|
|
|
DeviceText = ExAllocatePoolWithTag(PagedPool,
|
|
Length + sizeof(UNICODE_NULL),
|
|
USB_HUB_TAG);
|
|
|
|
if (DeviceText)
|
|
{
|
|
RtlZeroMemory(DeviceText, Length + sizeof(UNICODE_NULL));
|
|
|
|
RtlCopyMemory(DeviceText, Descriptor->bString, Length);
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)DeviceText;
|
|
|
|
DPRINT("USBH_PdoQueryDeviceText: Descriptor->bString - %S\n",
|
|
DeviceText);
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
Exit:
|
|
|
|
ExFreePoolWithTag(Descriptor, USB_HUB_TAG);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
return Status;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
if (!GenericUSBDeviceString)
|
|
{
|
|
return Status;
|
|
}
|
|
|
|
NumSymbols = wcslen(GenericUSBDeviceString);
|
|
Length = (NumSymbols + 1) * sizeof(WCHAR);
|
|
|
|
DeviceText = ExAllocatePoolWithTag(PagedPool, Length, USB_HUB_TAG);
|
|
|
|
if (!DeviceText)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
RtlZeroMemory(DeviceText, Length);
|
|
|
|
RtlCopyMemory(DeviceText,
|
|
GenericUSBDeviceString,
|
|
NumSymbols * sizeof(WCHAR));
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)DeviceText;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_SymbolicLink(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN const GUID * InterfaceClassGuid,
|
|
IN BOOLEAN IsEnable)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PVOID NameBuffer;
|
|
|
|
DPRINT("USBH_SymbolicLink ... \n");
|
|
|
|
if (IsEnable)
|
|
{
|
|
Status = IoRegisterDeviceInterface(PortExtension->Common.SelfDevice,
|
|
InterfaceClassGuid,
|
|
NULL,
|
|
&PortExtension->SymbolicLinkName);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
USBH_SetPdoRegistryParameter(PortExtension->Common.SelfDevice,
|
|
L"SymbolicName",
|
|
PortExtension->SymbolicLinkName.Buffer,
|
|
PortExtension->SymbolicLinkName.Length,
|
|
REG_SZ,
|
|
PLUGPLAY_REGKEY_DEVICE);
|
|
|
|
Status = IoSetDeviceInterfaceState(&PortExtension->SymbolicLinkName,
|
|
TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NameBuffer = PortExtension->SymbolicLinkName.Buffer;
|
|
|
|
if (NameBuffer)
|
|
{
|
|
Status = IoSetDeviceInterfaceState(&PortExtension->SymbolicLinkName,
|
|
FALSE);
|
|
|
|
ExFreePool(PortExtension->SymbolicLinkName.Buffer);
|
|
|
|
PortExtension->SymbolicLinkName.Buffer = NULL;
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_RestoreDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN BOOLEAN IsKeepDeviceData)
|
|
{
|
|
PUSBHUB_FDO_EXTENSION HubExtension;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
NTSTATUS Status;
|
|
ULONG ix;
|
|
|
|
DPRINT("USBH_RestoreDevice ... \n");
|
|
|
|
HubExtension = PortExtension->HubExtension;
|
|
|
|
if (!HubExtension)
|
|
{
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
return Status;
|
|
}
|
|
|
|
ASSERT(PortExtension->PortNumber > 0);
|
|
PortData = &HubExtension->PortData[PortExtension->PortNumber - 1];
|
|
|
|
if (PortExtension->Common.SelfDevice == PortData->DeviceObject)
|
|
{
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
return Status;
|
|
}
|
|
|
|
Status = USBH_SyncGetPortStatus(HubExtension,
|
|
PortExtension->PortNumber,
|
|
&PortData->PortStatus,
|
|
sizeof(USB_PORT_STATUS_AND_CHANGE));
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
for (ix = 0; ix < 3; ix++)
|
|
{
|
|
Status = USBH_ResetDevice((PUSBHUB_FDO_EXTENSION)HubExtension,
|
|
PortExtension->PortNumber,
|
|
IsKeepDeviceData,
|
|
ix == 0);
|
|
|
|
if (NT_SUCCESS(Status) || Status == STATUS_NO_SUCH_DEVICE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
USBH_Wait(1000);
|
|
}
|
|
}
|
|
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_POWER_D3;
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_PORT_RESTORE_FAIL;
|
|
}
|
|
else
|
|
{
|
|
PortExtension->PortPdoFlags |= (USBHUB_PDO_FLAG_INIT_PORT_FAILED |
|
|
USBHUB_PDO_FLAG_PORT_RESTORE_FAIL);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoStartDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
PUSBHUB_FDO_EXTENSION HubExtension;
|
|
const GUID * Guid;
|
|
NTSTATUS Status;
|
|
|
|
DPRINT("USBH_PdoStartDevice: PortExtension - %p\n", PortExtension);
|
|
|
|
if (!PortExtension->HubExtension &&
|
|
PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3)
|
|
{
|
|
PortExtension->HubExtension = PortExtension->RootHubExtension;
|
|
}
|
|
|
|
HubExtension = PortExtension->HubExtension;
|
|
|
|
if (HubExtension)
|
|
{
|
|
USBHUB_SetDeviceHandleData(HubExtension,
|
|
PortExtension->Common.SelfDevice,
|
|
PortExtension->DeviceHandle);
|
|
}
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_HUB_DEVICE)
|
|
{
|
|
Guid = &GUID_DEVINTERFACE_USB_HUB;
|
|
}
|
|
else
|
|
{
|
|
Guid = &GUID_DEVINTERFACE_USB_DEVICE;
|
|
}
|
|
|
|
Status = USBH_SymbolicLink(PortExtension, Guid, TRUE);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
|
|
}
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_POWER_D3)
|
|
{
|
|
Status = USBH_RestoreDevice(PortExtension, 0);
|
|
}
|
|
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_DEVICE_STARTED;
|
|
|
|
PortExtension->CurrentPowerState.DeviceState = PowerDeviceD0;
|
|
|
|
DPRINT1("USBH_PdoStartDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoRemoveDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PUSBHUB_FDO_EXTENSION HubExtension)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
PDEVICE_OBJECT PortDevice;
|
|
PUSBHUB_PORT_PDO_EXTENSION PortExt;
|
|
PUSBHUB_PORT_DATA PortData;
|
|
PIRP IdleNotificationIrp;
|
|
PIRP WakeIrp;
|
|
PVOID DeviceHandle;
|
|
PDEVICE_OBJECT Pdo;
|
|
PVOID SerialNumber;
|
|
USHORT Port;
|
|
KIRQL Irql;
|
|
|
|
DPRINT("USBH_PdoRemoveDevice ... \n");
|
|
|
|
PortDevice = PortExtension->Common.SelfDevice;
|
|
PortExtension->HubExtension = NULL;
|
|
|
|
Port = PortExtension->PortNumber;
|
|
ASSERT(Port > 0);
|
|
|
|
ASSERT(HubExtension);
|
|
|
|
if (HubExtension->CurrentPowerState.DeviceState != PowerDeviceD0 &&
|
|
(HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_STARTED) != 0)
|
|
{
|
|
USBH_HubSetD0(HubExtension);
|
|
}
|
|
|
|
IoAcquireCancelSpinLock(&Irql);
|
|
IdleNotificationIrp = PortExtension->IdleNotificationIrp;
|
|
|
|
if (IdleNotificationIrp)
|
|
{
|
|
PortExtension->IdleNotificationIrp = NULL;
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_IDLE_NOTIFICATION;
|
|
|
|
if (IdleNotificationIrp->Cancel)
|
|
{
|
|
IdleNotificationIrp = NULL;
|
|
}
|
|
|
|
if (IdleNotificationIrp)
|
|
{
|
|
IoSetCancelRoutine(IdleNotificationIrp, NULL);
|
|
}
|
|
}
|
|
|
|
WakeIrp = PortExtension->PdoWaitWakeIrp;
|
|
|
|
if (WakeIrp)
|
|
{
|
|
PortExtension->PdoWaitWakeIrp = NULL;
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_WAIT_WAKE;
|
|
|
|
if (WakeIrp->Cancel || !IoSetCancelRoutine(WakeIrp, NULL))
|
|
{
|
|
WakeIrp = NULL;
|
|
|
|
if (!InterlockedDecrement(&HubExtension->PendingRequestCount))
|
|
{
|
|
KeSetEvent(&HubExtension->PendingRequestEvent,
|
|
EVENT_INCREMENT,
|
|
FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
IoReleaseCancelSpinLock(Irql);
|
|
|
|
if (IdleNotificationIrp)
|
|
{
|
|
IdleNotificationIrp->IoStatus.Status = STATUS_CANCELLED;
|
|
IoCompleteRequest(IdleNotificationIrp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
if (WakeIrp)
|
|
{
|
|
USBH_CompletePowerIrp(HubExtension, WakeIrp, STATUS_CANCELLED);
|
|
}
|
|
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_POWER_D3;
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_REG_DEV_INTERFACE)
|
|
{
|
|
Status = USBH_SymbolicLink(PortExtension, NULL, FALSE);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
|
|
}
|
|
}
|
|
|
|
DeviceHandle = InterlockedExchangePointer(&PortExtension->DeviceHandle,
|
|
NULL);
|
|
|
|
if (DeviceHandle)
|
|
{
|
|
Status = USBD_RemoveDeviceEx(HubExtension, DeviceHandle, 0);
|
|
|
|
if (HubExtension->PortData &&
|
|
HubExtension->PortData[Port - 1].DeviceObject == PortDevice)
|
|
{
|
|
USBH_SyncDisablePort(HubExtension, Port);
|
|
}
|
|
}
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_DEVICE_STARTED;
|
|
|
|
if (HubExtension->PortData)
|
|
{
|
|
PortData = &HubExtension->PortData[Port - 1];
|
|
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_DELETE_PENDING)
|
|
{
|
|
Pdo = PortData->DeviceObject;
|
|
|
|
if (Pdo)
|
|
{
|
|
PortData->DeviceObject = NULL;
|
|
PortData->ConnectionStatus = NoDeviceConnected;
|
|
|
|
if (PdoExt(Pdo)->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT)
|
|
{
|
|
PortExt = PdoExt(Pdo);
|
|
|
|
InsertTailList(&HubExtension->PdoList,
|
|
&PortExt->PortLink);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(PortExtension->EnumFlags & USBHUB_ENUM_FLAG_DEVICE_PRESENT) &&
|
|
!(PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_NOT_CONNECTED))
|
|
{
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_NOT_CONNECTED;
|
|
|
|
SerialNumber = InterlockedExchangePointer((PVOID)&PortExtension->SerialNumber,
|
|
NULL);
|
|
|
|
if (SerialNumber)
|
|
{
|
|
ExFreePoolWithTag(SerialNumber, USB_HUB_TAG);
|
|
}
|
|
|
|
DPRINT1("USBH_PdoRemoveDevice: call IoWMIRegistrationControl UNIMPLEMENTED. FIXME\n");
|
|
|
|
USBHUB_FlushAllTransfers(HubExtension);
|
|
|
|
IoDeleteDevice(PortDevice);
|
|
}
|
|
}
|
|
|
|
DPRINT("USBH_PdoRemoveDevice: call USBH_CheckIdleDeferred()\n");
|
|
USBH_CheckIdleDeferred(HubExtension);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoStopDevice(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PIRP Irp)
|
|
{
|
|
DPRINT1("USBH_PdoStopDevice: UNIMPLEMENTED. FIXME\n");
|
|
DbgBreakPoint();
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_FdoPnP(IN PUSBHUB_FDO_EXTENSION HubExtension,
|
|
IN PIRP Irp,
|
|
IN UCHAR Minor)
|
|
{
|
|
NTSTATUS Status;
|
|
PIO_STACK_LOCATION IoStack;
|
|
DEVICE_RELATION_TYPE RelationsType;
|
|
BOOLEAN IsCheckIdle;
|
|
|
|
DPRINT_PNP("USBH_FdoPnP: HubExtension - %p, Irp - %p, Minor - %X\n",
|
|
HubExtension,
|
|
Irp,
|
|
Minor);
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_WAIT_IDLE_REQUEST &&
|
|
(Minor == IRP_MN_REMOVE_DEVICE || Minor == IRP_MN_STOP_DEVICE))
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
|
|
}
|
|
|
|
KeWaitForSingleObject(&HubExtension->IdleSemaphore,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
DPRINT_PNP("USBH_FdoPnP: HubFlags - %lX\n", HubExtension->HubFlags);
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_GOING_IDLE)
|
|
{
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_SUSPENDED;
|
|
}
|
|
|
|
IoStack = IoGetCurrentIrpStackLocation(Irp);
|
|
RelationsType = IoStack->Parameters.QueryDeviceRelations.Type;
|
|
|
|
if ((HubExtension->CurrentPowerState.DeviceState == PowerDeviceD0) ||
|
|
!(HubExtension->HubFlags & (USBHUB_FDO_FLAG_DEVICE_STOPPED | USBHUB_FDO_FLAG_DEVICE_STARTED)) ||
|
|
(Minor == IRP_MN_QUERY_DEVICE_RELATIONS && RelationsType == TargetDeviceRelation))
|
|
{
|
|
IsCheckIdle = FALSE;
|
|
}
|
|
else
|
|
{
|
|
DPRINT_PNP("USBH_FdoPnP: IsCheckIdle - TRUE\n");
|
|
IsCheckIdle = TRUE;
|
|
USBH_HubSetD0(HubExtension);
|
|
}
|
|
|
|
switch (Minor)
|
|
{
|
|
case IRP_MN_START_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_START_DEVICE\n");
|
|
IsCheckIdle = FALSE;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_FdoStartDevice(HubExtension, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_REMOVE_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_REMOVE_DEVICE\n");
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_REMOVE_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_REMOVE_DEVICE\n");
|
|
IsCheckIdle = FALSE;
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_DEVICE_REMOVED;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_FdoRemoveDevice(HubExtension, Irp);
|
|
break;
|
|
|
|
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_CANCEL_REMOVE_DEVICE\n");
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_STOP_DEVICE\n");
|
|
IsCheckIdle = FALSE;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_FdoStopDevice(HubExtension, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_STOP_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_STOP_DEVICE\n");
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_CANCEL_STOP_DEVICE:
|
|
DPRINT_PNP("FDO IRP_MN_CANCEL_STOP_DEVICE\n");
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_DEVICE_RELATIONS:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_DEVICE_RELATIONS\n");
|
|
|
|
if (RelationsType != BusRelations)
|
|
{
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
}
|
|
|
|
HubExtension->HubFlags |= USBHUB_FDO_FLAG_HUB_BUSY;
|
|
|
|
IsCheckIdle = TRUE;
|
|
DPRINT_PNP("USBH_FdoPnP: IsCheckIdle - TRUE\n");
|
|
|
|
Status = USBH_FdoQueryBusRelations(HubExtension, Irp);
|
|
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_HUB_BUSY;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_INTERFACE:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_INTERFACE\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_CAPABILITIES:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_CAPABILITIES\n");
|
|
IoCopyCurrentIrpStackLocationToNext(Irp);
|
|
|
|
IoSetCompletionRoutine(Irp,
|
|
USBH_QueryCapsComplete,
|
|
HubExtension,
|
|
TRUE,
|
|
FALSE,
|
|
FALSE);
|
|
|
|
Status = IoCallDriver(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCES:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_RESOURCES\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_DEVICE_TEXT:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_DEVICE_TEXT\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
|
|
DPRINT_PNP("FDO IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_READ_CONFIG:
|
|
DPRINT_PNP("FDO IRP_MN_READ_CONFIG\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_WRITE_CONFIG:
|
|
DPRINT_PNP("FDO IRP_MN_WRITE_CONFIG\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_EJECT:
|
|
DPRINT_PNP("FDO IRP_MN_EJECT\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_SET_LOCK:
|
|
DPRINT_PNP("FDO IRP_MN_SET_LOCK\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_ID:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_ID\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_PNP_DEVICE_STATE:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_PNP_DEVICE_STATE\n");
|
|
|
|
if (HubExtension->HubFlags & USBHUB_FDO_FLAG_DEVICE_FAILED)
|
|
{
|
|
Irp->IoStatus.Information |= PNP_DEVICE_FAILED;
|
|
}
|
|
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_BUS_INFORMATION:
|
|
DPRINT_PNP("FDO IRP_MN_QUERY_BUS_INFORMATION\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
|
|
DPRINT_PNP("FDO IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
case IRP_MN_SURPRISE_REMOVAL:
|
|
DPRINT_PNP("FDO IRP_MN_SURPRISE_REMOVAL\n");
|
|
USBH_FdoSurpriseRemoveDevice(HubExtension, Irp);
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
|
|
default:
|
|
DPRINT_PNP("FDO unknown IRP_MN_???\n");
|
|
Status = USBH_PassIrp(HubExtension->LowerDevice, Irp);
|
|
break;
|
|
}
|
|
|
|
KeReleaseSemaphore(&HubExtension->IdleSemaphore,
|
|
LOW_REALTIME_PRIORITY,
|
|
1,
|
|
FALSE);
|
|
|
|
if (IsCheckIdle)
|
|
{
|
|
DPRINT_PNP("USBH_FdoPnP: call USBH_CheckIdleDeferred()\n");
|
|
USBH_CheckIdleDeferred(HubExtension);
|
|
}
|
|
|
|
HubExtension->HubFlags &= ~USBHUB_FDO_FLAG_STATE_CHANGING;
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
USBH_PdoPnP(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
|
|
IN PIRP Irp,
|
|
IN UCHAR Minor,
|
|
OUT BOOLEAN * IsCompleteIrp)
|
|
{
|
|
NTSTATUS Status;
|
|
PIO_STACK_LOCATION IoStack;
|
|
PPNP_BUS_INFORMATION BusInfo;
|
|
PDEVICE_CAPABILITIES DeviceCapabilities;
|
|
USHORT Size;
|
|
USHORT Version;
|
|
PUSBHUB_FDO_EXTENSION HubExtension;
|
|
PDEVICE_RELATIONS DeviceRelation;
|
|
|
|
DPRINT_PNP("USBH_PdoPnP: PortExtension - %p, Irp - %p, Minor - %X\n",
|
|
PortExtension,
|
|
Irp,
|
|
Minor);
|
|
|
|
IoStack = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
*IsCompleteIrp = TRUE;
|
|
|
|
switch (Minor)
|
|
{
|
|
case IRP_MN_START_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_START_DEVICE\n");
|
|
return USBH_PdoStartDevice(PortExtension, Irp);
|
|
|
|
case IRP_MN_QUERY_REMOVE_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_REMOVE_DEVICE\n");
|
|
return STATUS_SUCCESS;
|
|
|
|
case IRP_MN_REMOVE_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_REMOVE_DEVICE\n");
|
|
return USBH_PdoRemoveDevice(PortExtension, PortExtension->HubExtension);
|
|
|
|
case IRP_MN_CANCEL_REMOVE_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_CANCEL_REMOVE_DEVICE\n");
|
|
return STATUS_SUCCESS;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_STOP_DEVICE\n");
|
|
return USBH_PdoStopDevice(PortExtension, Irp);
|
|
|
|
case IRP_MN_QUERY_STOP_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_STOP_DEVICE\n");
|
|
return STATUS_SUCCESS;
|
|
|
|
case IRP_MN_CANCEL_STOP_DEVICE:
|
|
DPRINT_PNP("PDO IRP_MN_CANCEL_STOP_DEVICE\n");
|
|
return STATUS_SUCCESS;
|
|
|
|
case IRP_MN_QUERY_DEVICE_RELATIONS:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_DEVICE_RELATIONS\n");
|
|
|
|
if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
|
|
{
|
|
return Irp->IoStatus.Status;
|
|
}
|
|
|
|
DeviceRelation = ExAllocatePoolWithTag(PagedPool,
|
|
sizeof(DEVICE_RELATIONS),
|
|
USB_HUB_TAG);
|
|
|
|
if (DeviceRelation)
|
|
{
|
|
RtlZeroMemory(DeviceRelation, sizeof(DEVICE_RELATIONS));
|
|
|
|
DeviceRelation->Count = 1;
|
|
DeviceRelation->Objects[0] = PortExtension->Common.SelfDevice;
|
|
|
|
ObReferenceObject(DeviceRelation->Objects[0]);
|
|
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_INTERFACE:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_INTERFACE\n");
|
|
|
|
*IsCompleteIrp = 0;
|
|
|
|
if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
|
|
&USB_BUS_INTERFACE_USBDI_GUID))
|
|
{
|
|
IoStack->Parameters.QueryInterface.InterfaceSpecificData = PortExtension->DeviceHandle;
|
|
}
|
|
|
|
HubExtension = PortExtension->HubExtension;
|
|
|
|
if (!HubExtension)
|
|
{
|
|
HubExtension = PortExtension->RootHubExtension;
|
|
}
|
|
|
|
Status = USBH_PassIrp(HubExtension->RootHubPdo, Irp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_CAPABILITIES:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_CAPABILITIES\n");
|
|
|
|
DeviceCapabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
|
|
|
|
Size = DeviceCapabilities->Size;
|
|
Version = DeviceCapabilities->Version;
|
|
|
|
RtlCopyMemory(DeviceCapabilities,
|
|
&PortExtension->Capabilities,
|
|
sizeof(DEVICE_CAPABILITIES));
|
|
|
|
DeviceCapabilities->Size = Size;
|
|
DeviceCapabilities->Version = Version;
|
|
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCES:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_RESOURCES\n");
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
|
|
PortExtension->PortPdoFlags |= USBHUB_PDO_FLAG_ENUMERATED;
|
|
|
|
/* FIXME HKEY_LOCAL_MACHINE\SYSTEM\ControlSetXXX\Enum\USB\
|
|
Vid_????&Pid_????\????????????\Device Parameters\
|
|
if (ExtPropDescSemaphore)
|
|
*/
|
|
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_DEVICE_TEXT:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_DEVICE_TEXT\n");
|
|
return USBH_PdoQueryDeviceText(PortExtension, Irp);
|
|
|
|
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
|
|
DPRINT_PNP("PDO IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_READ_CONFIG:
|
|
DPRINT_PNP("PDO IRP_MN_READ_CONFIG\n");
|
|
DbgBreakPoint();
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_WRITE_CONFIG:
|
|
DPRINT_PNP("PDO IRP_MN_WRITE_CONFIG\n");
|
|
DbgBreakPoint();
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_EJECT:
|
|
DPRINT_PNP("PDO IRP_MN_EJECT\n");
|
|
DbgBreakPoint();
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_SET_LOCK:
|
|
DPRINT_PNP("PDO IRP_MN_SET_LOCK\n");
|
|
DbgBreakPoint();
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_ID:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_ID\n");
|
|
return USBH_PdoQueryId(PortExtension, Irp);
|
|
|
|
case IRP_MN_QUERY_PNP_DEVICE_STATE:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_PNP_DEVICE_STATE\n");
|
|
if (PortExtension->PortPdoFlags & (USBHUB_PDO_FLAG_INSUFFICIENT_PWR |
|
|
USBHUB_PDO_FLAG_OVERCURRENT_PORT |
|
|
USBHUB_PDO_FLAG_PORT_RESTORE_FAIL |
|
|
USBHUB_PDO_FLAG_INIT_PORT_FAILED))
|
|
{
|
|
Irp->IoStatus.Information |= PNP_DEVICE_FAILED;
|
|
}
|
|
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_BUS_INFORMATION:
|
|
DPRINT_PNP("PDO IRP_MN_QUERY_BUS_INFORMATION\n");
|
|
|
|
BusInfo = ExAllocatePoolWithTag(PagedPool,
|
|
sizeof(PNP_BUS_INFORMATION),
|
|
USB_HUB_TAG);
|
|
|
|
if (!BusInfo)
|
|
{
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
RtlZeroMemory(BusInfo, sizeof(PNP_BUS_INFORMATION));
|
|
|
|
RtlCopyMemory(&BusInfo->BusTypeGuid,
|
|
&GUID_BUS_TYPE_USB,
|
|
sizeof(BusInfo->BusTypeGuid));
|
|
|
|
BusInfo->LegacyBusType = PNPBus;
|
|
BusInfo->BusNumber = 0;
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)BusInfo;
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case IRP_MN_DEVICE_USAGE_NOTIFICATION:
|
|
DPRINT_PNP("PDO IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
|
|
DbgBreakPoint();
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
|
|
case IRP_MN_SURPRISE_REMOVAL:
|
|
DPRINT_PNP("PDO IRP_MN_SURPRISE_REMOVAL\n");
|
|
if (PortExtension->PortPdoFlags & USBHUB_PDO_FLAG_REG_DEV_INTERFACE)
|
|
{
|
|
Status = USBH_SymbolicLink(PortExtension, NULL, FALSE);
|
|
|
|
if (NT_SUCCESS(Status))
|
|
{
|
|
PortExtension->PortPdoFlags &= ~USBHUB_PDO_FLAG_REG_DEV_INTERFACE;
|
|
}
|
|
}
|
|
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
default:
|
|
DPRINT_PNP("PDO unknown IRP_MN_???\n");
|
|
Status = Irp->IoStatus.Status;
|
|
break;
|
|
}
|
|
|
|
return Status;
|
|
}
|