Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-01 04:11:30 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/drivers/usb/usbport/device.c

2048 lines
63 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS USB Port Driver
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
* PURPOSE: USBPort device functions
* COPYRIGHT: Copyright 2017 Vadim Galyant <vgal@rambler.ru>
*/
#include "usbport.h"
#define NDEBUG
#include <debug.h>
NTSTATUS
NTAPI
USBPORT_SendSetupPacket(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN PDEVICE_OBJECT FdoDevice,
IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
IN PVOID Buffer,
IN ULONG Length,
IN OUT PULONG TransferedLen,
IN OUT PUSBD_STATUS pUSBDStatus)
{
PURB Urb;
PMDL Mdl;
USBD_STATUS USBDStatus;
KEVENT Event;
NTSTATUS Status;
DPRINT("USBPORT_SendSetupPacket: DeviceHandle - %p, FdoDevice - %p, SetupPacket - %p, Buffer - %p, Length - %x, TransferedLen - %x, pUSBDStatus - %x\n",
DeviceHandle,
FdoDevice,
SetupPacket,
Buffer,
Length,
TransferedLen,
pUSBDStatus);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Urb = ExAllocatePoolWithTag(NonPagedPool,
sizeof(struct _URB_CONTROL_TRANSFER),
USB_PORT_TAG);
if (Urb)
{
InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
RtlZeroMemory(Urb, sizeof(struct _URB_CONTROL_TRANSFER));
RtlCopyMemory(Urb->UrbControlTransfer.SetupPacket,
SetupPacket,
sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
Urb->UrbHeader.Length = sizeof(struct _URB_CONTROL_TRANSFER);
Urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;
Urb->UrbHeader.UsbdDeviceHandle = DeviceHandle;
Urb->UrbHeader.UsbdFlags = 0;
Urb->UrbControlTransfer.PipeHandle = &DeviceHandle->PipeHandle;
Urb->UrbControlTransfer.TransferBufferLength = Length;
Urb->UrbControlTransfer.TransferBuffer = Buffer;
Urb->UrbControlTransfer.TransferBufferMDL = NULL;
Urb->UrbControlTransfer.TransferFlags = USBD_SHORT_TRANSFER_OK |
USBD_TRANSFER_DIRECTION;
if (SetupPacket->bmRequestType.Dir != BMREQUEST_DEVICE_TO_HOST)
{
Urb->UrbControlTransfer.TransferFlags &= ~USBD_TRANSFER_DIRECTION_IN;
}
Status = STATUS_SUCCESS;
if (Length)
{
Mdl = IoAllocateMdl(Buffer, Length, FALSE, FALSE, NULL);
Urb->UrbControlTransfer.TransferBufferMDL = Mdl;
if (Mdl)
{
Urb->UrbHeader.UsbdFlags |= USBD_FLAG_ALLOCATED_MDL;
MmBuildMdlForNonPagedPool(Mdl);
}
else
{
Status = USBPORT_USBDStatusToNtStatus(NULL,
USBD_STATUS_INSUFFICIENT_RESOURCES);
}
}
if (NT_SUCCESS(Status))
{
USBDStatus = USBPORT_AllocateTransfer(FdoDevice,
Urb,
NULL,
NULL,
&Event);
if (USBD_SUCCESS(USBDStatus))
{
InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
USBPORT_QueueTransferUrb(Urb);
KeWaitForSingleObject(&Event,
Suspended,
KernelMode,
FALSE,
NULL);
USBDStatus = Urb->UrbHeader.Status;
}
Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
if (TransferedLen)
*TransferedLen = Urb->UrbControlTransfer.TransferBufferLength;
if (pUSBDStatus)
*pUSBDStatus = USBDStatus;
}
InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
ExFreePoolWithTag(Urb, USB_PORT_TAG);
}
else
{
if (pUSBDStatus)
*pUSBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
Status = USBPORT_USBDStatusToNtStatus(NULL,
USBD_STATUS_INSUFFICIENT_RESOURCES);
}
DPRINT("USBPORT_SendSetupPacket: Status - %x\n", Status);
return Status;
}
ULONG
NTAPI
USBPORT_GetInterfaceLength(IN PUSB_INTERFACE_DESCRIPTOR iDescriptor,
IN ULONG_PTR EndDescriptors)
{
SIZE_T Length;
PUSB_ENDPOINT_DESCRIPTOR Descriptor;
ULONG ix;
DPRINT("USBPORT_GetInterfaceLength ... \n");
Length = iDescriptor->bLength;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)iDescriptor + Length);
if (iDescriptor->bNumEndpoints)
{
for (ix = 0; ix < iDescriptor->bNumEndpoints; ix++)
{
while ((Descriptor->bDescriptorType != USB_ENDPOINT_DESCRIPTOR_TYPE) &&
(Descriptor->bLength > 0))
{
Length += Descriptor->bLength;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
Descriptor->bLength);
}
Length += Descriptor->bLength;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
Descriptor->bLength);
}
}
while (((ULONG_PTR)Descriptor < EndDescriptors) &&
(Descriptor->bDescriptorType != USB_INTERFACE_DESCRIPTOR_TYPE) &&
(Descriptor->bLength > 0))
{
Length += Descriptor->bLength;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
Descriptor->bLength);
}
return Length;
}
PUSB_INTERFACE_DESCRIPTOR
NTAPI
USBPORT_ParseConfigurationDescriptor(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor,
IN UCHAR InterfaceNumber,
IN UCHAR Alternate,
OUT PBOOLEAN HasAlternates)
{
PUSB_CONFIGURATION_DESCRIPTOR TmpDescriptor;
PUSB_INTERFACE_DESCRIPTOR iDescriptor;
PUSB_INTERFACE_DESCRIPTOR OutDescriptor = NULL;
ULONG_PTR Descriptor = (ULONG_PTR)ConfigDescriptor;
ULONG_PTR EndDescriptors;
ULONG ix;
DPRINT("USBPORT_ParseConfigurationDescriptor ... \n");
if (HasAlternates)
*HasAlternates = FALSE;
for (TmpDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)((ULONG_PTR)ConfigDescriptor + ConfigDescriptor->bLength);
TmpDescriptor->bDescriptorType != USB_INTERFACE_DESCRIPTOR_TYPE && TmpDescriptor->bLength > 0;
TmpDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)((ULONG_PTR)TmpDescriptor + TmpDescriptor->bLength))
;
iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)TmpDescriptor;
EndDescriptors = (ULONG_PTR)ConfigDescriptor +
ConfigDescriptor->wTotalLength;
while ((Descriptor < EndDescriptors) &&
(iDescriptor->bInterfaceNumber != InterfaceNumber))
{
Descriptor = (ULONG_PTR)iDescriptor +
USBPORT_GetInterfaceLength(iDescriptor, EndDescriptors);
iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)Descriptor;
}
ix = 0;
while (Descriptor < EndDescriptors &&
iDescriptor->bInterfaceNumber == InterfaceNumber)
{
if (iDescriptor->bAlternateSetting == Alternate)
OutDescriptor = iDescriptor;
Descriptor = (ULONG_PTR)iDescriptor +
USBPORT_GetInterfaceLength(iDescriptor, EndDescriptors);
iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)Descriptor;
++ix;
}
if ((ix > 1) && HasAlternates)
*HasAlternates = TRUE;
return OutDescriptor;
}
USBD_STATUS
NTAPI
USBPORT_OpenInterface(IN PURB Urb,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_CONFIGURATION_HANDLE ConfigHandle,
IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
IN OUT PUSBPORT_INTERFACE_HANDLE *iHandle,
IN BOOLEAN SendSetInterface)
{
PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
PUSBPORT_INTERFACE_HANDLE InterfaceHandle = NULL;
PUSBPORT_PIPE_HANDLE PipeHandle;
PUSB_ENDPOINT_DESCRIPTOR Descriptor;
PUSBD_PIPE_INFORMATION PipeInfo;
BOOLEAN HasAlternates;
ULONG NumEndpoints;
SIZE_T Length;
USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
SIZE_T HandleLength;
BOOLEAN IsAllocated = FALSE;
USHORT MaxPacketSize;
USHORT wMaxPacketSize;
ULONG ix;
USBD_STATUS USBDStatus = USBD_STATUS_SUCCESS;
NTSTATUS Status;
DPRINT("USBPORT_OpenInterface: ...\n");
InterfaceDescriptor = USBPORT_ParseConfigurationDescriptor(ConfigHandle->ConfigurationDescriptor,
InterfaceInfo->InterfaceNumber,
InterfaceInfo->AlternateSetting,
&HasAlternates);
NumEndpoints = InterfaceDescriptor->bNumEndpoints;
Length = FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes) +
NumEndpoints * sizeof(USBD_PIPE_INFORMATION);
if (HasAlternates && SendSetInterface)
{
RtlZeroMemory(&SetupPacket, sizeof(SetupPacket));
SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
SetupPacket.bmRequestType.Type = BMREQUEST_STANDARD;
SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_INTERFACE;
SetupPacket.bRequest = USB_REQUEST_SET_INTERFACE;
SetupPacket.wValue.W = InterfaceInfo->AlternateSetting;
SetupPacket.wIndex.W = InterfaceInfo->InterfaceNumber;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
&USBDStatus);
if (!USBD_SUCCESS(USBDStatus))
{
goto Exit;
}
}
if (*iHandle)
{
InterfaceHandle = *iHandle;
}
else
{
HandleLength = FIELD_OFFSET(USBPORT_INTERFACE_HANDLE, PipeHandle) +
NumEndpoints * sizeof(USBPORT_PIPE_HANDLE);
InterfaceHandle = ExAllocatePoolWithTag(NonPagedPool,
HandleLength,
USB_PORT_TAG);
if (!InterfaceHandle)
{
USBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
goto Exit;
}
RtlZeroMemory(InterfaceHandle, HandleLength);
for (ix = 0; ix < NumEndpoints; ++ix)
{
PipeHandle = &InterfaceHandle->PipeHandle[ix];
PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
PipeHandle->Endpoint = NULL;
}
IsAllocated = TRUE;
}
InterfaceHandle->AlternateSetting = InterfaceInfo->AlternateSetting;
RtlCopyMemory(&InterfaceHandle->InterfaceDescriptor,
InterfaceDescriptor,
sizeof(USB_INTERFACE_DESCRIPTOR));
InterfaceInfo->Class = InterfaceDescriptor->bInterfaceClass;
InterfaceInfo->SubClass = InterfaceDescriptor->bInterfaceSubClass;
InterfaceInfo->Protocol = InterfaceDescriptor->bInterfaceProtocol;
InterfaceInfo->Reserved = 0;
InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor +
InterfaceDescriptor->bLength);
for (ix = 0; ix < NumEndpoints; ++ix)
{
PipeHandle = &InterfaceHandle->PipeHandle[ix];
while (Descriptor->bDescriptorType != USB_ENDPOINT_DESCRIPTOR_TYPE)
{
if (Descriptor->bLength == 0)
{
break;
}
else
{
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
Descriptor->bLength);
}
}
if (InterfaceInfo->Pipes[ix].PipeFlags & USBD_PF_CHANGE_MAX_PACKET)
{
Descriptor->wMaxPacketSize = InterfaceInfo->Pipes[ix].MaximumPacketSize;
}
RtlCopyMemory(&PipeHandle->EndpointDescriptor,
Descriptor,
sizeof(USB_ENDPOINT_DESCRIPTOR));
PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
PipeHandle->PipeFlags = InterfaceInfo->Pipes[ix].PipeFlags;
PipeHandle->Endpoint = NULL;
wMaxPacketSize = Descriptor->wMaxPacketSize;
/* USB 2.0 Specification, 5.9 High-Speed, High Bandwidth Endpoints */
MaxPacketSize = (wMaxPacketSize & 0x7FF) * (((wMaxPacketSize >> 11) & 3) + 1);
InterfaceInfo->Pipes[ix].EndpointAddress = Descriptor->bEndpointAddress;
InterfaceInfo->Pipes[ix].PipeType = Descriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK;
InterfaceInfo->Pipes[ix].MaximumPacketSize = MaxPacketSize;
InterfaceInfo->Pipes[ix].PipeHandle = (USBD_PIPE_HANDLE)-1;
InterfaceInfo->Pipes[ix].Interval = Descriptor->bInterval;
Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
Descriptor->bLength);
}
if (USBD_SUCCESS(USBDStatus))
{
for (ix = 0; ix < NumEndpoints; ++ix)
{
PipeInfo = &InterfaceInfo->Pipes[ix];
PipeHandle = &InterfaceHandle->PipeHandle[ix];
Status = USBPORT_OpenPipe(FdoDevice,
DeviceHandle,
PipeHandle,
&USBDStatus);
if (!NT_SUCCESS(Status))
break;
PipeInfo->PipeHandle = PipeHandle;
}
if (NumEndpoints)
{
USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
}
}
Exit:
if (USBD_SUCCESS(USBDStatus))
{
InterfaceInfo->InterfaceHandle = InterfaceHandle;
*iHandle = InterfaceHandle;
InterfaceInfo->Length = Length;
}
else
{
if (InterfaceHandle)
{
if (NumEndpoints)
{
DPRINT1("USBPORT_OpenInterface: USBDStatus - %lx\n", USBDStatus);
}
if (IsAllocated)
ExFreePoolWithTag(InterfaceHandle, USB_PORT_TAG);
}
}
return USBDStatus;
}
VOID
NTAPI
USBPORT_CloseConfiguration(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN PDEVICE_OBJECT FdoDevice)
{
PUSBPORT_CONFIGURATION_HANDLE ConfigHandle;
PLIST_ENTRY iHandleList;
PUSBPORT_INTERFACE_HANDLE iHandle;
ULONG NumEndpoints;
PUSBPORT_PIPE_HANDLE PipeHandle;
DPRINT("USBPORT_CloseConfiguration: ... \n");
ConfigHandle = DeviceHandle->ConfigHandle;
if (ConfigHandle)
{
iHandleList = &ConfigHandle->InterfaceHandleList;
while (!IsListEmpty(iHandleList))
{
iHandle = CONTAINING_RECORD(iHandleList->Flink,
USBPORT_INTERFACE_HANDLE,
InterfaceLink);
DPRINT("USBPORT_CloseConfiguration: iHandle - %p\n", iHandle);
RemoveHeadList(iHandleList);
NumEndpoints = iHandle->InterfaceDescriptor.bNumEndpoints;
PipeHandle = &iHandle->PipeHandle[0];
while (NumEndpoints > 0)
{
USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
PipeHandle += 1;
--NumEndpoints;
}
ExFreePoolWithTag(iHandle, USB_PORT_TAG);
}
ExFreePoolWithTag(ConfigHandle, USB_PORT_TAG);
DeviceHandle->ConfigHandle = NULL;
}
}
NTSTATUS
NTAPI
USBPORT_InitInterfaceInfo(IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
IN PUSBPORT_CONFIGURATION_HANDLE ConfigHandle)
{
PUSB_INTERFACE_DESCRIPTOR Descriptor;
PUSBD_PIPE_INFORMATION Pipe;
SIZE_T Length;
ULONG PipeFlags;
ULONG NumberOfPipes;
USBD_STATUS USBDStatus = USBD_STATUS_SUCCESS;
DPRINT("USBPORT_InitInterfaceInfo: InterfaceInfo - %p, ConfigHandle - %p\n",
InterfaceInfo,
ConfigHandle);
Descriptor = USBPORT_ParseConfigurationDescriptor(ConfigHandle->ConfigurationDescriptor,
InterfaceInfo->InterfaceNumber,
InterfaceInfo->AlternateSetting,
NULL);
Length = sizeof(USBD_INTERFACE_INFORMATION) +
sizeof(USBD_PIPE_INFORMATION);
if (Descriptor)
{
NumberOfPipes = Descriptor->bNumEndpoints;
Length = FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes) +
NumberOfPipes * sizeof(USBD_PIPE_INFORMATION);
if (InterfaceInfo->Length >= Length)
{
InterfaceInfo->Class = 0;
InterfaceInfo->SubClass = 0;
InterfaceInfo->Protocol = 0;
InterfaceInfo->Reserved = 0;
InterfaceInfo->InterfaceHandle = 0;
InterfaceInfo->NumberOfPipes = NumberOfPipes;
Pipe = InterfaceInfo->Pipes;
while (NumberOfPipes > 0)
{
Pipe->EndpointAddress = 0;
Pipe->Interval = 0;
Pipe->PipeType = 0;
Pipe->PipeHandle = 0;
PipeFlags = Pipe->PipeFlags;
if (PipeFlags & ~USBD_PF_VALID_MASK)
USBDStatus = USBD_STATUS_INVALID_PIPE_FLAGS;
if (!(PipeFlags & USBD_PF_CHANGE_MAX_PACKET))
Pipe->MaximumPacketSize = 0;
Pipe += 1;
--NumberOfPipes;
}
}
else
{
USBDStatus = USBD_STATUS_BUFFER_TOO_SMALL;
}
}
else
{
USBDStatus = USBD_STATUS_INTERFACE_NOT_FOUND;
}
InterfaceInfo->Length = Length;
return USBDStatus;
}
NTSTATUS
NTAPI
USBPORT_HandleSelectConfiguration(IN PDEVICE_OBJECT FdoDevice,
IN PIRP Irp,
IN PURB Urb)
{
PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor;
PUSBPORT_DEVICE_HANDLE DeviceHandle;
PUSBPORT_CONFIGURATION_HANDLE ConfigHandle = NULL;
PUSBD_INTERFACE_INFORMATION InterfaceInfo;
PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
ULONG iNumber;
ULONG ix;
USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
NTSTATUS Status;
USBD_STATUS USBDStatus;
PUSBPORT_DEVICE_EXTENSION FdoExtension;
DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor %p\n",
Urb->UrbSelectConfiguration.ConfigurationDescriptor);
FdoExtension = FdoDevice->DeviceExtension;
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
ConfigDescriptor = Urb->UrbSelectConfiguration.ConfigurationDescriptor;
if (!ConfigDescriptor)
{
DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor == NULL\n");
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.B = 0;
SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
SetupPacket.wValue.W = 0;
SetupPacket.wIndex.W = 0;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
NULL);
Status = USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_SUCCESS);
goto Exit;
}
USBPORT_DumpingConfiguration(ConfigDescriptor);
InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
iNumber = 0;
do
{
++iNumber;
InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
((ULONG_PTR)InterfaceInfo +
InterfaceInfo->Length);
}
while ((ULONG_PTR)InterfaceInfo < (ULONG_PTR)Urb + Urb->UrbHeader.Length);
if ((iNumber <= 0) || (iNumber != ConfigDescriptor->bNumInterfaces))
{
Status = USBPORT_USBDStatusToNtStatus(Urb,
USBD_STATUS_INVALID_CONFIGURATION_DESCRIPTOR);
goto Exit;
}
ConfigHandle = ExAllocatePoolWithTag(NonPagedPool,
ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE),
USB_PORT_TAG);
if (!ConfigHandle)
{
Status = USBPORT_USBDStatusToNtStatus(Urb,
USBD_STATUS_INSUFFICIENT_RESOURCES);
goto Exit;
}
RtlZeroMemory(ConfigHandle,
ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE));
InitializeListHead(&ConfigHandle->InterfaceHandleList);
ConfigHandle->ConfigurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)(ConfigHandle + 1);
RtlCopyMemory(ConfigHandle->ConfigurationDescriptor,
ConfigDescriptor,
ConfigDescriptor->wTotalLength);
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.B = 0;
SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
SetupPacket.wValue.W = ConfigDescriptor->bConfigurationValue;
SetupPacket.wIndex.W = 0;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
&USBDStatus);
if (USBD_ERROR(USBDStatus))
{
Status = USBPORT_USBDStatusToNtStatus(Urb,
USBD_STATUS_SET_CONFIG_FAILED);
goto Exit;
}
if (iNumber <= 0)
{
Status = USBPORT_USBDStatusToNtStatus(Urb,
USBD_STATUS_SUCCESS);
goto Exit;
}
InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
for (ix = 0; ix < iNumber; ++ix)
{
USBDStatus = USBPORT_InitInterfaceInfo(InterfaceInfo,
ConfigHandle);
InterfaceHandle = NULL;
if (USBD_SUCCESS(USBDStatus))
{
USBDStatus = USBPORT_OpenInterface(Urb,
DeviceHandle,
FdoDevice,
ConfigHandle,
InterfaceInfo,
&InterfaceHandle,
TRUE);
}
if (InterfaceHandle)
{
InsertTailList(&ConfigHandle->InterfaceHandleList,
&InterfaceHandle->InterfaceLink);
}
if (USBD_ERROR(USBDStatus))
break;
InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
((ULONG_PTR)InterfaceInfo +
InterfaceInfo->Length);
}
if (ix >= iNumber)
{
Status = USBPORT_USBDStatusToNtStatus(Urb,
USBD_STATUS_SUCCESS);
}
else
{
Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
}
Exit:
if (NT_SUCCESS(Status))
{
Urb->UrbSelectConfiguration.ConfigurationHandle = ConfigHandle;
DeviceHandle->ConfigHandle = ConfigHandle;
}
else
{
DPRINT1("USBPORT_HandleSelectConfiguration: Status %x\n", Status);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
return Status;
}
VOID
NTAPI
USBPORT_AddDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
DPRINT("USBPORT_AddDeviceHandle: ... \n");
FdoExtension = FdoDevice->DeviceExtension;
InsertTailList(&FdoExtension->DeviceHandleList,
&DeviceHandle->DeviceHandleLink);
}
VOID
NTAPI
USBPORT_RemoveDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
KIRQL OldIrql;
DPRINT("USBPORT_RemoveDeviceHandle \n");
FdoExtension = FdoDevice->DeviceExtension;
KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
RemoveEntryList(&DeviceHandle->DeviceHandleLink);
KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
}
BOOLEAN
NTAPI
USBPORT_ValidateDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
KIRQL OldIrql;
PLIST_ENTRY HandleList;
PUSBPORT_DEVICE_HANDLE CurrentHandle;
BOOLEAN Result = FALSE;
//DPRINT("USBPORT_ValidateDeviceHandle: DeviceHandle - %p\n", DeviceHandle \n");
FdoExtension = FdoDevice->DeviceExtension;
KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
if (DeviceHandle)
{
HandleList = FdoExtension->DeviceHandleList.Flink;
while (HandleList != &FdoExtension->DeviceHandleList)
{
CurrentHandle = CONTAINING_RECORD(HandleList,
USBPORT_DEVICE_HANDLE,
DeviceHandleLink);
if (CurrentHandle == DeviceHandle)
{
Result = TRUE;
break;
}
HandleList = HandleList->Flink;
}
}
KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
return Result;
}
BOOLEAN
NTAPI
USBPORT_DeviceHasTransfers(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
{
PLIST_ENTRY PipeHandleList;
PUSBPORT_PIPE_HANDLE PipeHandle;
DPRINT("USBPORT_DeviceHasTransfers: ... \n");
PipeHandleList = DeviceHandle->PipeHandleList.Flink;
while (PipeHandleList != &DeviceHandle->PipeHandleList)
{
PipeHandle = CONTAINING_RECORD(PipeHandleList,
USBPORT_PIPE_HANDLE,
PipeLink);
PipeHandleList = PipeHandleList->Flink;
if (!(PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE) &&
USBPORT_EndpointHasQueuedTransfers(FdoDevice, PipeHandle->Endpoint, NULL))
{
return TRUE;
}
}
return FALSE;
}
VOID
NTAPI
USBPORT_AbortTransfers(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
{
PLIST_ENTRY HandleList;
PUSBPORT_PIPE_HANDLE PipeHandle;
BOOLEAN Result;
DPRINT("USBPORT_AbortAllTransfers: ... \n");
HandleList = DeviceHandle->PipeHandleList.Flink;
while (HandleList != &DeviceHandle->PipeHandleList)
{
PipeHandle = CONTAINING_RECORD(HandleList,
USBPORT_PIPE_HANDLE,
PipeLink);
HandleList = HandleList->Flink;
if (!(PipeHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB))
{
PipeHandle->Endpoint->Flags |= ENDPOINT_FLAG_ABORTING;
USBPORT_AbortEndpoint(FdoDevice, PipeHandle->Endpoint, NULL);
USBPORT_FlushMapTransfers(FdoDevice);
}
}
while (TRUE)
{
Result = USBPORT_DeviceHasTransfers(FdoDevice, DeviceHandle);
if (!Result)
break;
USBPORT_Wait(FdoDevice, 100);
}
}
PUSB2_TT_EXTENSION
NTAPI
USBPORT_GetTt(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
OUT PUSHORT OutPort,
OUT PUSBPORT_DEVICE_HANDLE * OutHubDeviceHandle)
{
PUSBPORT_DEVICE_HANDLE DeviceHandle = HubDeviceHandle;
ULONG TtCount;
PLIST_ENTRY Entry;
PUSB2_TT_EXTENSION TtExtension = NULL;
DPRINT("USBPORT_GetTt: HubDeviceHandle - %p\n", HubDeviceHandle);
*OutHubDeviceHandle = NULL;
while (DeviceHandle->DeviceSpeed != UsbHighSpeed)
{
DPRINT("USBPORT_GetTt: DeviceHandle - %p, DeviceHandle->PortNumber - %X\n",
DeviceHandle,
DeviceHandle->PortNumber);
*OutPort = DeviceHandle->PortNumber;
DeviceHandle = DeviceHandle->HubDeviceHandle;
if (!DeviceHandle)
return NULL;
}
TtCount = DeviceHandle->TtCount;
if (!TtCount)
return NULL;
if (IsListEmpty(&DeviceHandle->TtList))
return NULL;
Entry = DeviceHandle->TtList.Flink;
if (TtCount > 1)
{
while (Entry != &DeviceHandle->TtList)
{
ASSERT(Entry != NULL);
TtExtension = CONTAINING_RECORD(Entry,
USB2_TT_EXTENSION,
Link);
if (TtExtension->TtNumber == *OutPort)
break;
Entry = Entry->Flink;
TtExtension = NULL;
}
}
else
{
TtExtension = CONTAINING_RECORD(Entry,
USB2_TT_EXTENSION,
Link);
}
*OutHubDeviceHandle = DeviceHandle;
return TtExtension;
}
NTSTATUS
NTAPI
USBPORT_CreateDevice(IN OUT PUSB_DEVICE_HANDLE *pUsbdDeviceHandle,
IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
IN USHORT PortStatus,
IN USHORT Port)
{
PUSBPORT_DEVICE_HANDLE TtDeviceHandle = NULL;
PUSB2_TT_EXTENSION TtExtension = NULL;
USHORT port;
PUSBPORT_DEVICE_HANDLE DeviceHandle;
PUSBPORT_PIPE_HANDLE PipeHandle;
BOOL IsOpenedPipe;
PVOID DeviceDescriptor;
USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
ULONG TransferedLen;
ULONG DescriptorMinSize;
UCHAR MaxPacketSize;
PUSBPORT_DEVICE_EXTENSION FdoExtension;
PUSBPORT_REGISTRATION_PACKET Packet;
NTSTATUS Status;
DPRINT("USBPORT_CreateDevice: PortStatus - %p, Port - %x\n",
PortStatus,
Port);
FdoExtension = FdoDevice->DeviceExtension;
Packet = &FdoExtension->MiniPortInterface->Packet;
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
if (!USBPORT_ValidateDeviceHandle(FdoDevice, HubDeviceHandle))
{
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
DPRINT1("USBPORT_CreateDevice: Not valid hub DeviceHandle\n");
return STATUS_DEVICE_NOT_CONNECTED;
}
port = Port;
if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2 &&
!(PortStatus & USB_PORT_STATUS_HIGH_SPEED))
{
DPRINT1("USBPORT_CreateDevice: USB1 device connected to USB2 port\n");
TtExtension = USBPORT_GetTt(FdoDevice,
HubDeviceHandle,
&port,
&TtDeviceHandle);
DPRINT("USBPORT_CreateDevice: TtDeviceHandle - %p, port - %x\n",
TtDeviceHandle,
port);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
DeviceHandle = ExAllocatePoolWithTag(NonPagedPool,
sizeof(USBPORT_DEVICE_HANDLE),
USB_PORT_TAG);
if (!DeviceHandle)
{
DPRINT1("USBPORT_CreateDevice: Not allocated DeviceHandle\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(DeviceHandle, sizeof(USBPORT_DEVICE_HANDLE));
*pUsbdDeviceHandle = NULL;
DeviceHandle->TtExtension = TtExtension;
DeviceHandle->PortNumber = Port;
DeviceHandle->HubDeviceHandle = HubDeviceHandle;
if (PortStatus & USB_PORT_STATUS_LOW_SPEED)
{
DeviceHandle->DeviceSpeed = UsbLowSpeed;
}
else if (PortStatus & USB_PORT_STATUS_HIGH_SPEED)
{
DeviceHandle->DeviceSpeed = UsbHighSpeed;
}
else
{
DeviceHandle->DeviceSpeed = UsbFullSpeed;
}
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
PipeHandle = &DeviceHandle->PipeHandle;
PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
PipeHandle->EndpointDescriptor.bLength = sizeof(PipeHandle->EndpointDescriptor);
PipeHandle->EndpointDescriptor.bDescriptorType = USB_ENDPOINT_DESCRIPTOR_TYPE;
if (DeviceHandle->DeviceSpeed == UsbLowSpeed)
{
PipeHandle->EndpointDescriptor.wMaxPacketSize = 8;
}
else
{
PipeHandle->EndpointDescriptor.wMaxPacketSize = USB_DEFAULT_MAX_PACKET;
}
InitializeListHead(&DeviceHandle->PipeHandleList);
InitializeListHead(&DeviceHandle->TtList);
Status = USBPORT_OpenPipe(FdoDevice,
DeviceHandle,
PipeHandle,
NULL);
IsOpenedPipe = NT_SUCCESS(Status);
if (NT_ERROR(Status))
{
DPRINT1("USBPORT_CreateDevice: USBPORT_OpenPipe return - %lx\n", Status);
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
return Status;
}
DeviceDescriptor = ExAllocatePoolWithTag(NonPagedPool,
USB_DEFAULT_MAX_PACKET,
USB_PORT_TAG);
if (!DeviceDescriptor)
{
DPRINT1("USBPORT_CreateDevice: Not allocated DeviceDescriptor\n");
goto ErrorExit;
}
RtlZeroMemory(DeviceDescriptor, USB_DEFAULT_MAX_PACKET);
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
SetupPacket.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
SetupPacket.wLength = USB_DEFAULT_MAX_PACKET;
TransferedLen = 0;
Status = USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&SetupPacket,
DeviceDescriptor,
USB_DEFAULT_MAX_PACKET,
&TransferedLen,
NULL);
RtlCopyMemory(&DeviceHandle->DeviceDescriptor,
DeviceDescriptor,
sizeof(USB_DEVICE_DESCRIPTOR));
ExFreePoolWithTag(DeviceDescriptor, USB_PORT_TAG);
DescriptorMinSize = RTL_SIZEOF_THROUGH_FIELD(USB_DEVICE_DESCRIPTOR,
bMaxPacketSize0);
if ((TransferedLen == DescriptorMinSize) && !NT_SUCCESS(Status))
{
Status = STATUS_SUCCESS;
}
if (NT_SUCCESS(Status) && (TransferedLen >= DescriptorMinSize))
{
if ((DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR)) &&
(DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE))
{
MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
if (MaxPacketSize == 8 ||
MaxPacketSize == 16 ||
MaxPacketSize == 32 ||
MaxPacketSize == 64)
{
USBPORT_AddDeviceHandle(FdoDevice, DeviceHandle);
*pUsbdDeviceHandle = DeviceHandle;
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
return Status;
}
}
}
DPRINT1("USBPORT_CreateDevice: ERROR!!! TransferedLen - %x, Status - %lx\n",
TransferedLen,
Status);
ErrorExit:
if (TtExtension && TtDeviceHandle)
{
SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_OTHER;
SetupPacket.bmRequestType.Reserved = 0;
SetupPacket.bmRequestType.Type = BMREQUEST_CLASS;
SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
/* Table 11-15. Hub Class Requests */
if (TtDeviceHandle == HubDeviceHandle)
{
SetupPacket.bRequest = USB_REQUEST_RESET_TT;
}
else
{
SetupPacket.bRequest = USB_REQUEST_CLEAR_TT_BUFFER;
}
SetupPacket.wValue.LowByte = 0;
SetupPacket.wValue.HiByte = 0;
SetupPacket.wIndex.W = port;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(TtDeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
NULL);
}
Status = STATUS_DEVICE_DATA_ERROR;
if (IsOpenedPipe)
{
USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
return Status;
}
ULONG
NTAPI
USBPORT_AllocateUsbAddress(IN PDEVICE_OBJECT FdoDevice)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
ULONG BitMapIdx;
ULONG BitNumber;
ULONG ix;
DPRINT("USBPORT_AllocateUsbAddress \n");
FdoExtension = FdoDevice->DeviceExtension;
for (ix = 0; ix < 4; ++ix)
{
BitMapIdx = 1;
for (BitNumber = 0; BitNumber < 32; ++BitNumber)
{
if (!(FdoExtension->UsbAddressBitMap[ix] & BitMapIdx))
{
FdoExtension->UsbAddressBitMap[ix] |= BitMapIdx;
return 32 * ix + BitNumber;
}
BitMapIdx <<= 2;
}
}
return 0;
}
VOID
NTAPI
USBPORT_FreeUsbAddress(IN PDEVICE_OBJECT FdoDevice,
IN USHORT DeviceAddress)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
ULONG ix;
ULONG BitMapIdx;
ULONG BitNumber;
USHORT CurrentAddress;
DPRINT("USBPORT_FreeUsbAddress: DeviceAddress - %x\n", DeviceAddress);
FdoExtension = FdoDevice->DeviceExtension;
for (ix = 0; ix < 4; ++ix)
{
BitMapIdx = 1;
CurrentAddress = 32 * ix;
for (BitNumber = 0; BitNumber < 32; ++BitNumber)
{
if (CurrentAddress == DeviceAddress)
{
FdoExtension->UsbAddressBitMap[ix] &= ~BitMapIdx;
return;
}
BitMapIdx <<= 2;
CurrentAddress++;
}
}
}
NTSTATUS
NTAPI
USBPORT_InitializeDevice(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN PDEVICE_OBJECT FdoDevice)
{
PUSBPORT_ENDPOINT Endpoint;
USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
ULONG TransferedLen;
USHORT DeviceAddress = 0;
UCHAR MaxPacketSize;
NTSTATUS Status;
PUSBPORT_DEVICE_EXTENSION FdoExtension;
DPRINT("USBPORT_InitializeDevice: ... \n");
ASSERT(DeviceHandle != NULL);
FdoExtension = FdoDevice->DeviceExtension;
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
DeviceAddress = USBPORT_AllocateUsbAddress(FdoDevice);
ASSERT(DeviceHandle->DeviceAddress == USB_DEFAULT_DEVICE_ADDRESS);
RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
CtrlSetup.bRequest = USB_REQUEST_SET_ADDRESS;
CtrlSetup.wValue.W = DeviceAddress;
Status = USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&CtrlSetup,
NULL,
0,
NULL,
NULL);
DPRINT("USBPORT_InitializeDevice: DeviceAddress - %x. SendSetupPacket Status - %x\n",
DeviceAddress,
Status);
if (!NT_SUCCESS(Status))
goto ExitError;
DeviceHandle->DeviceAddress = DeviceAddress;
Endpoint = DeviceHandle->PipeHandle.Endpoint;
Endpoint->EndpointProperties.TotalMaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
Endpoint->EndpointProperties.DeviceAddress = DeviceAddress;
Status = USBPORT_ReopenPipe(FdoDevice, Endpoint);
if (!NT_SUCCESS(Status))
goto ExitError;
USBPORT_Wait(FdoDevice, 10);
RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
CtrlSetup.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
CtrlSetup.wLength = sizeof(USB_DEVICE_DESCRIPTOR);
CtrlSetup.bmRequestType.B = 0x80;
Status = USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&CtrlSetup,
&DeviceHandle->DeviceDescriptor,
sizeof(USB_DEVICE_DESCRIPTOR),
&TransferedLen,
NULL);
if (NT_SUCCESS(Status))
{
ASSERT(TransferedLen == sizeof(USB_DEVICE_DESCRIPTOR));
ASSERT(DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR));
ASSERT(DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE);
MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
ASSERT((MaxPacketSize == 8) ||
(MaxPacketSize == 16) ||
(MaxPacketSize == 32) ||
(MaxPacketSize == 64));
if (DeviceHandle->DeviceSpeed == UsbHighSpeed &&
DeviceHandle->DeviceDescriptor.bDeviceClass == USB_DEVICE_CLASS_HUB)
{
DeviceHandle->Flags |= DEVICE_HANDLE_FLAG_USB2HUB;
}
}
else
{
ExitError:
DPRINT1("USBPORT_InitializeDevice: ExitError. Status - %x\n", Status);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
return Status;
}
NTSTATUS
NTAPI
USBPORT_GetUsbDescriptor(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN PDEVICE_OBJECT FdoDevice,
IN UCHAR Type,
IN PUCHAR ConfigDesc,
IN PULONG ConfigDescSize)
{
USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
DPRINT("USBPORT_GetUsbDescriptor: Type - %x\n");
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
SetupPacket.wValue.HiByte = Type;
SetupPacket.wLength = (USHORT)*ConfigDescSize;
return USBPORT_SendSetupPacket(DeviceHandle,
FdoDevice,
&SetupPacket,
ConfigDesc,
*ConfigDescSize,
ConfigDescSize,
NULL);
}
PUSBPORT_INTERFACE_HANDLE
NTAPI
USBPORT_GetInterfaceHandle(IN PUSBPORT_CONFIGURATION_HANDLE ConfigurationHandle,
IN UCHAR InterfaceNumber)
{
PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
PLIST_ENTRY iHandleList;
UCHAR InterfaceNum;
DPRINT("USBPORT_GetInterfaceHandle: ConfigurationHandle - %p, InterfaceNumber - %p\n",
ConfigurationHandle,
InterfaceNumber);
iHandleList = ConfigurationHandle->InterfaceHandleList.Flink;
while (iHandleList &&
(iHandleList != &ConfigurationHandle->InterfaceHandleList))
{
InterfaceHandle = CONTAINING_RECORD(iHandleList,
USBPORT_INTERFACE_HANDLE,
InterfaceLink);
InterfaceNum = InterfaceHandle->InterfaceDescriptor.bInterfaceNumber;
if (InterfaceNum == InterfaceNumber)
return InterfaceHandle;
iHandleList = InterfaceHandle->InterfaceLink.Flink;
}
return NULL;
}
NTSTATUS
NTAPI
USBPORT_HandleSelectInterface(IN PDEVICE_OBJECT FdoDevice,
IN PIRP Irp,
IN PURB Urb)
{
PUSBPORT_DEVICE_HANDLE DeviceHandle;
PUSBPORT_CONFIGURATION_HANDLE ConfigurationHandle;
PUSBD_INTERFACE_INFORMATION Interface;
PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
PUSBPORT_INTERFACE_HANDLE iHandle;
PUSBPORT_PIPE_HANDLE PipeHandle;
USBD_STATUS USBDStatus;
USHORT Length;
ULONG ix;
PUSBPORT_DEVICE_EXTENSION FdoExtension;
DPRINT("USBPORT_HandleSelectInterface: ... \n");
FdoExtension = FdoDevice->DeviceExtension;
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
ConfigurationHandle = Urb->UrbSelectInterface.ConfigurationHandle;
Interface = &Urb->UrbSelectInterface.Interface;
Length = Interface->Length + sizeof(USBD_PIPE_INFORMATION);
Urb->UrbHeader.Length = Length;
USBDStatus = USBPORT_InitInterfaceInfo(Interface, ConfigurationHandle);
if (USBDStatus)
{
Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
}
DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
InterfaceHandle = USBPORT_GetInterfaceHandle(ConfigurationHandle,
Interface->InterfaceNumber);
if (InterfaceHandle)
{
RemoveEntryList(&InterfaceHandle->InterfaceLink);
if (InterfaceHandle->InterfaceDescriptor.bNumEndpoints)
{
PipeHandle = &InterfaceHandle->PipeHandle[0];
for (ix = 0;
ix < InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
ix++)
{
USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
PipeHandle += 1;
}
}
}
iHandle = 0;
USBDStatus = USBPORT_OpenInterface(Urb,
DeviceHandle,
FdoDevice,
ConfigurationHandle,
Interface,
&iHandle,
TRUE);
if (USBDStatus)
{
Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
}
else
{
if (InterfaceHandle)
ExFreePoolWithTag(InterfaceHandle, USB_PORT_TAG);
Interface->InterfaceHandle = iHandle;
InsertTailList(&ConfigurationHandle->InterfaceHandleList,
&iHandle->InterfaceLink);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
}
NTSTATUS
NTAPI
USBPORT_RemoveDevice(IN PDEVICE_OBJECT FdoDevice,
IN OUT PUSBPORT_DEVICE_HANDLE DeviceHandle,
IN ULONG Flags)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
PUSB2_TT_EXTENSION TtExtension;
ULONG ix;
KIRQL OldIrql;
DPRINT("USBPORT_RemoveDevice: DeviceHandle - %p, Flags - %x\n",
DeviceHandle,
Flags);
FdoExtension = FdoDevice->DeviceExtension;
if ((Flags & USBD_KEEP_DEVICE_DATA) ||
(Flags & USBD_MARK_DEVICE_BUSY))
{
return STATUS_SUCCESS;
}
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
if (!USBPORT_ValidateDeviceHandle(FdoDevice, DeviceHandle))
{
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
DPRINT1("USBPORT_RemoveDevice: Not valid device handle\n");
return STATUS_DEVICE_NOT_CONNECTED;
}
USBPORT_RemoveDeviceHandle(FdoDevice, DeviceHandle);
DeviceHandle->Flags |= DEVICE_HANDLE_FLAG_REMOVED;
USBPORT_AbortTransfers(FdoDevice, DeviceHandle);
DPRINT("USBPORT_RemoveDevice: DeviceHandleLock - %x\n",
DeviceHandle->DeviceHandleLock);
while (InterlockedDecrement(&DeviceHandle->DeviceHandleLock) >= 0)
{
InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
USBPORT_Wait(FdoDevice, 100);
}
DPRINT("USBPORT_RemoveDevice: DeviceHandleLock ok\n");
if (DeviceHandle->ConfigHandle)
{
USBPORT_CloseConfiguration(DeviceHandle, FdoDevice);
}
USBPORT_ClosePipe(DeviceHandle, FdoDevice, &DeviceHandle->PipeHandle);
if (DeviceHandle->DeviceAddress)
{
USBPORT_FreeUsbAddress(FdoDevice, DeviceHandle->DeviceAddress);
}
if (!IsListEmpty(&DeviceHandle->TtList))
{
DPRINT1("USBPORT_RemoveDevice: DeviceHandle->TtList not empty\n");
}
while (!IsListEmpty(&DeviceHandle->TtList))
{
TtExtension = CONTAINING_RECORD(DeviceHandle->TtList.Flink,
USB2_TT_EXTENSION,
Link);
RemoveHeadList(&DeviceHandle->TtList);
DPRINT("USBPORT_RemoveDevice: TtExtension - %p\n", TtExtension);
KeAcquireSpinLock(&FdoExtension->TtSpinLock, &OldIrql);
TtExtension->Flags |= USB2_TT_EXTENSION_FLAG_DELETED;
if (IsListEmpty(&TtExtension->EndpointList))
{
USBPORT_UpdateAllocatedBwTt(TtExtension);
for (ix = 0; ix < USB2_FRAMES; ix++)
{
FdoExtension->Bandwidth[ix] += TtExtension->MaxBandwidth;
}
DPRINT("USBPORT_RemoveDevice: ExFreePoolWithTag TtExtension - %p\n", TtExtension);
ExFreePoolWithTag(TtExtension, USB_PORT_TAG);
}
KeReleaseSpinLock(&FdoExtension->TtSpinLock, OldIrql);
}
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
if (!(DeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB))
{
ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
}
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
USBPORT_RestoreDevice(IN PDEVICE_OBJECT FdoDevice,
IN OUT PUSBPORT_DEVICE_HANDLE OldDeviceHandle,
IN OUT PUSBPORT_DEVICE_HANDLE NewDeviceHandle)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
PLIST_ENTRY iHandleList;
PUSBPORT_ENDPOINT Endpoint;
USBPORT_ENDPOINT_REQUIREMENTS EndpointRequirements = {0};
USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
NTSTATUS Status = STATUS_SUCCESS;
USBD_STATUS USBDStatus;
KIRQL OldIrql;
PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
PUSBPORT_PIPE_HANDLE PipeHandle;
PUSBPORT_REGISTRATION_PACKET Packet;
DPRINT("USBPORT_RestoreDevice: OldDeviceHandle - %p, NewDeviceHandle - %p\n",
OldDeviceHandle,
NewDeviceHandle);
FdoExtension = FdoDevice->DeviceExtension;
KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
Executive,
KernelMode,
FALSE,
NULL);
if (!USBPORT_ValidateDeviceHandle(FdoDevice, OldDeviceHandle))
{
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
#ifndef NDEBUG
DPRINT("USBPORT_RestoreDevice: OldDeviceHandle not valid\n");
DbgBreakPoint();
#endif
return STATUS_DEVICE_NOT_CONNECTED;
}
if (!USBPORT_ValidateDeviceHandle(FdoDevice, NewDeviceHandle))
{
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
#ifndef NDEBUG
DPRINT("USBPORT_RestoreDevice: NewDeviceHandle not valid\n");
DbgBreakPoint();
#endif
return STATUS_DEVICE_NOT_CONNECTED;
}
USBPORT_RemoveDeviceHandle(FdoDevice, OldDeviceHandle);
USBPORT_AbortTransfers(FdoDevice, OldDeviceHandle);
while (InterlockedDecrement(&OldDeviceHandle->DeviceHandleLock) >= 0)
{
InterlockedIncrement(&OldDeviceHandle->DeviceHandleLock);
USBPORT_Wait(FdoDevice, 100);
}
if (sizeof(USB_DEVICE_DESCRIPTOR) == RtlCompareMemory(&NewDeviceHandle->DeviceDescriptor,
&OldDeviceHandle->DeviceDescriptor,
sizeof(USB_DEVICE_DESCRIPTOR)))
{
NewDeviceHandle->ConfigHandle = OldDeviceHandle->ConfigHandle;
if (OldDeviceHandle->ConfigHandle)
{
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
SetupPacket.wValue.W = OldDeviceHandle->ConfigHandle->ConfigurationDescriptor->bConfigurationValue;
SetupPacket.wIndex.W = 0;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(NewDeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
&USBDStatus);
if (USBD_ERROR(USBDStatus))
Status = USBPORT_USBDStatusToNtStatus(NULL, USBDStatus);
if (NT_SUCCESS(Status))
{
iHandleList = NewDeviceHandle->ConfigHandle->InterfaceHandleList.Flink;
while (iHandleList &&
iHandleList != &NewDeviceHandle->ConfigHandle->InterfaceHandleList)
{
InterfaceHandle = CONTAINING_RECORD(iHandleList,
USBPORT_INTERFACE_HANDLE,
InterfaceLink);
if (InterfaceHandle->AlternateSetting)
{
RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
SetupPacket.bmRequestType.Type = BMREQUEST_STANDARD;
SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_INTERFACE;
SetupPacket.bRequest = USB_REQUEST_SET_INTERFACE;
SetupPacket.wValue.W = InterfaceHandle->InterfaceDescriptor.bAlternateSetting;
SetupPacket.wIndex.W = InterfaceHandle->InterfaceDescriptor.bInterfaceNumber;
SetupPacket.wLength = 0;
USBPORT_SendSetupPacket(NewDeviceHandle,
FdoDevice,
&SetupPacket,
NULL,
0,
NULL,
&USBDStatus);
}
iHandleList = iHandleList->Flink;
}
}
}
if (NewDeviceHandle->Flags & DEVICE_HANDLE_FLAG_USB2HUB)
{
DPRINT1("USBPORT_RestoreDevice: FIXME Transaction Translator\n");
NewDeviceHandle->TtCount = OldDeviceHandle->TtCount;
#ifndef NDEBUG
DbgBreakPoint();
#endif
}
while (!IsListEmpty(&OldDeviceHandle->PipeHandleList))
{
PipeHandle = CONTAINING_RECORD(OldDeviceHandle->PipeHandleList.Flink,
USBPORT_PIPE_HANDLE,
PipeLink);
DPRINT("USBPORT_RestoreDevice: PipeHandle - %p\n", PipeHandle);
USBPORT_RemovePipeHandle(OldDeviceHandle, PipeHandle);
if (PipeHandle != &OldDeviceHandle->PipeHandle)
{
USBPORT_AddPipeHandle(NewDeviceHandle, PipeHandle);
if (!(PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE))
{
Endpoint = PipeHandle->Endpoint;
Endpoint->DeviceHandle = NewDeviceHandle;
Endpoint->EndpointProperties.DeviceAddress = NewDeviceHandle->DeviceAddress;
Packet = &FdoExtension->MiniPortInterface->Packet;
if (!(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
{
KeAcquireSpinLock(&FdoExtension->MiniportSpinLock,
&OldIrql);
Packet->ReopenEndpoint(FdoExtension->MiniPortExt,
&Endpoint->EndpointProperties,
Endpoint + 1);
Packet->SetEndpointDataToggle(FdoExtension->MiniPortExt,
Endpoint + 1,
0);
Packet->SetEndpointStatus(FdoExtension->MiniPortExt,
Endpoint + 1,
USBPORT_ENDPOINT_RUN);
KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
OldIrql);
}
else
{
MiniportCloseEndpoint(FdoDevice, Endpoint);
RtlZeroMemory(Endpoint + 1, Packet->MiniPortEndpointSize);
RtlZeroMemory((PVOID)Endpoint->EndpointProperties.BufferVA,
Endpoint->EndpointProperties.BufferLength);
KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
&Endpoint->EndpointProperties,
&EndpointRequirements);
KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
OldIrql);
MiniportOpenEndpoint(FdoDevice, Endpoint);
Endpoint->Flags &= ~(ENDPOINT_FLAG_NUKE |
ENDPOINT_FLAG_ABORTING);
KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
&Endpoint->EndpointOldIrql);
if (Endpoint->StateLast == USBPORT_ENDPOINT_ACTIVE)
{
KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
Packet->SetEndpointState(FdoExtension->MiniPortExt,
Endpoint + 1,
USBPORT_ENDPOINT_ACTIVE);
KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
}
KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
Endpoint->EndpointOldIrql);
}
}
}
}
USBPORT_AddPipeHandle(OldDeviceHandle, &OldDeviceHandle->PipeHandle);
}
else
{
#ifndef NDEBUG
DPRINT("USBPORT_RestoreDevice: New DeviceDescriptor != Old DeviceDescriptor\n");
DbgBreakPoint();
#endif
Status = STATUS_UNSUCCESSFUL;
}
USBPORT_ClosePipe(OldDeviceHandle, FdoDevice, &OldDeviceHandle->PipeHandle);
if (OldDeviceHandle->DeviceAddress != 0)
USBPORT_FreeUsbAddress(FdoDevice, OldDeviceHandle->DeviceAddress);
KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
LOW_REALTIME_PRIORITY,
1,
FALSE);
ExFreePoolWithTag(OldDeviceHandle, USB_PORT_TAG);
return Status;
}
NTSTATUS
NTAPI
USBPORT_InitializeTT(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
IN ULONG TtNumber)
{
PUSBPORT_DEVICE_EXTENSION FdoExtension;
PUSB2_TT_EXTENSION TtExtension;
ULONG ix;
DPRINT("USBPORT_InitializeTT: HubDeviceHandle - %p, TtNumber - %X\n",
HubDeviceHandle,
TtNumber);
FdoExtension = FdoDevice->DeviceExtension;
TtExtension = ExAllocatePoolWithTag(NonPagedPool,
sizeof(USB2_TT_EXTENSION),
USB_PORT_TAG);
if (!TtExtension)
{
DPRINT1("USBPORT_InitializeTT: ExAllocatePoolWithTag return NULL\n");
return STATUS_INSUFFICIENT_RESOURCES;
}
DPRINT("USBPORT_InitializeTT: TtExtension - %p\n", TtExtension);
RtlZeroMemory(TtExtension, sizeof(USB2_TT_EXTENSION));
TtExtension->DeviceAddress = HubDeviceHandle->DeviceAddress;
TtExtension->TtNumber = TtNumber;
TtExtension->RootHubPdo = FdoExtension->RootHubPdo;
TtExtension->BusBandwidth = TOTAL_USB11_BUS_BANDWIDTH;
InitializeListHead(&TtExtension->EndpointList);
/* 90% maximum allowed for periodic endpoints */
for (ix = 0; ix < USB2_FRAMES; ix++)
{
TtExtension->Bandwidth[ix] = TtExtension->BusBandwidth -
TtExtension->BusBandwidth / 10;
}
USBPORT_UpdateAllocatedBwTt(TtExtension);
for (ix = 0; ix < USB2_FRAMES; ix++)
{
FdoExtension->Bandwidth[ix] -= TtExtension->MaxBandwidth;
}
USB2_InitTT(FdoExtension->Usb2Extension, &TtExtension->Tt);
InsertTailList(&HubDeviceHandle->TtList, &TtExtension->Link);
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
USBPORT_Initialize20Hub(IN PDEVICE_OBJECT FdoDevice,
IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
IN ULONG TtCount)
{
NTSTATUS Status;
ULONG ix;
DPRINT("USBPORT_Initialize20Hub: TtCount - %X\n", TtCount);
if (!HubDeviceHandle)
{
return STATUS_INVALID_PARAMETER;
}
if (HubDeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB)
{
return STATUS_SUCCESS;
}
if (TtCount == 0)
{
HubDeviceHandle->TtCount = 0;
return STATUS_SUCCESS;
}
for (ix = 0; ix < TtCount; ++ix)
{
Status = USBPORT_InitializeTT(FdoDevice, HubDeviceHandle, ix + 1);
if (!NT_SUCCESS(Status))
break;
}
HubDeviceHandle->TtCount = TtCount;
return Status;
}
Reference in a new issue View git blame Copy permalink