drivers/usb/usbport/device.c

   1 /*
   2  * PROJECT:     ReactOS USB Port Driver
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     USBPort device functions
   5  * COPYRIGHT:   Copyright 2017 Vadim Galyant <vgal@rambler.ru>
   6  */
   7
   8 #include "usbport.h"
   9
  10 #define NDEBUG
  11 #include <debug.h>
  12
  13 NTSTATUS
  14 NTAPI
  15 USBPORT_SendSetupPacket(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
  16                         IN PDEVICE_OBJECT FdoDevice,
  17                         IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
  18                         IN PVOID Buffer,
  19                         IN ULONG Length,
  20                         IN OUT PULONG TransferedLen,
  21                         IN OUT PUSBD_STATUS pUSBDStatus)
  22 {
  23     PURB Urb;
  24     PMDL Mdl;
  25     USBD_STATUS USBDStatus;
  26     KEVENT Event;
  27     NTSTATUS Status;
  28
  29     DPRINT("USBPORT_SendSetupPacket: DeviceHandle - %p, FdoDevice - %p, SetupPacket - %p, Buffer - %p, Length - %x, TransferedLen - %x, pUSBDStatus - %x\n",
  30            DeviceHandle,
  31            FdoDevice,
  32            SetupPacket,
  33            Buffer,
  34            Length,
  35            TransferedLen,
  36            pUSBDStatus);
  37
  38     KeInitializeEvent(&Event, NotificationEvent, FALSE);
  39
  40     Urb = ExAllocatePoolWithTag(NonPagedPool,
  41                                 sizeof(struct _URB_CONTROL_TRANSFER),
  42                                 USB_PORT_TAG);
  43
  44     if (Urb)
  45     {
  46         InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
  47
  48         RtlZeroMemory(Urb, sizeof(struct _URB_CONTROL_TRANSFER));
  49
  50         RtlCopyMemory(Urb->UrbControlTransfer.SetupPacket,
  51                       SetupPacket,
  52                       sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
  53
  54         Urb->UrbHeader.Length = sizeof(struct _URB_CONTROL_TRANSFER);
  55         Urb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER;
  56         Urb->UrbHeader.UsbdDeviceHandle = DeviceHandle;
  57         Urb->UrbHeader.UsbdFlags = 0;
  58
  59         Urb->UrbControlTransfer.PipeHandle = &DeviceHandle->PipeHandle;
  60         Urb->UrbControlTransfer.TransferBufferLength = Length;
  61         Urb->UrbControlTransfer.TransferBuffer = Buffer;
  62         Urb->UrbControlTransfer.TransferBufferMDL = NULL;
  63
  64         Urb->UrbControlTransfer.TransferFlags = USBD_SHORT_TRANSFER_OK |
  65                                                 USBD_TRANSFER_DIRECTION;
  66
  67         if (SetupPacket->bmRequestType.Dir != BMREQUEST_DEVICE_TO_HOST)
  68         {
  69             Urb->UrbControlTransfer.TransferFlags &= ~USBD_TRANSFER_DIRECTION_IN;
  70         }
  71
  72         Status = STATUS_SUCCESS;
  73
  74         if (Length)
  75         {
  76             Mdl = IoAllocateMdl(Buffer, Length, FALSE, FALSE, NULL);
  77
  78             Urb->UrbControlTransfer.TransferBufferMDL = Mdl;
  79
  80             if (Mdl)
  81             {
  82                 Urb->UrbHeader.UsbdFlags |= USBD_FLAG_ALLOCATED_MDL;
  83                 MmBuildMdlForNonPagedPool(Mdl);
  84             }
  85             else
  86             {
  87                 Status = USBPORT_USBDStatusToNtStatus(NULL,
  88                                                       USBD_STATUS_INSUFFICIENT_RESOURCES);
  89             }
  90         }
  91
  92         if (NT_SUCCESS(Status))
  93         {
  94             USBDStatus = USBPORT_AllocateTransfer(FdoDevice,
  95                                                   Urb,
  96                                                   NULL,
  97                                                   NULL,
  98                                                   &Event);
  99
 100             if (USBD_SUCCESS(USBDStatus))
 101             {
 102                 InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
 103
 104                 USBPORT_QueueTransferUrb(Urb);
 105
 106                 KeWaitForSingleObject(&Event,
 107                                       Suspended,
 108                                       KernelMode,
 109                                       FALSE,
 110                                       NULL);
 111
 112                 USBDStatus = Urb->UrbHeader.Status;
 113             }
 114
 115             Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
 116
 117             if (TransferedLen)
 118                 *TransferedLen = Urb->UrbControlTransfer.TransferBufferLength;
 119
 120             if (pUSBDStatus)
 121                 *pUSBDStatus = USBDStatus;
 122         }
 123
 124         InterlockedDecrement(&DeviceHandle->DeviceHandleLock);
 125         ExFreePoolWithTag(Urb, USB_PORT_TAG);
 126     }
 127     else
 128     {
 129         if (pUSBDStatus)
 130             *pUSBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
 131
 132         Status = USBPORT_USBDStatusToNtStatus(NULL,
 133                                               USBD_STATUS_INSUFFICIENT_RESOURCES);
 134     }
 135
 136     DPRINT("USBPORT_SendSetupPacket: Status - %x\n", Status);
 137     return Status;
 138 }
 139
 140 ULONG
 141 NTAPI
 142 USBPORT_GetInterfaceLength(IN PUSB_INTERFACE_DESCRIPTOR iDescriptor,
 143                            IN ULONG_PTR EndDescriptors)
 144 {
 145     SIZE_T Length;
 146     PUSB_ENDPOINT_DESCRIPTOR Descriptor;
 147     ULONG ix;
 148
 149     DPRINT("USBPORT_GetInterfaceLength ... \n");
 150
 151     Length = iDescriptor->bLength;
 152     Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)iDescriptor + Length);
 153
 154     if (iDescriptor->bNumEndpoints)
 155     {
 156         for (ix = 0; ix < iDescriptor->bNumEndpoints; ix++)
 157         {
 158             while ((Descriptor->bDescriptorType != USB_ENDPOINT_DESCRIPTOR_TYPE) &&
 159                    (Descriptor->bLength > 0))
 160             {
 161                 Length += Descriptor->bLength;
 162                 Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
 163                                                         Descriptor->bLength);
 164             }
 165
 166             Length += Descriptor->bLength;
 167             Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
 168                                                     Descriptor->bLength);
 169         }
 170     }
 171
 172     while (((ULONG_PTR)Descriptor < EndDescriptors) &&
 173            (Descriptor->bDescriptorType != USB_INTERFACE_DESCRIPTOR_TYPE) &&
 174            (Descriptor->bLength > 0))
 175     {
 176         Length += Descriptor->bLength;
 177         Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
 178                                                 Descriptor->bLength);
 179     }
 180
 181     return Length;
 182 }
 183
 184 PUSB_INTERFACE_DESCRIPTOR
 185 NTAPI
 186 USBPORT_ParseConfigurationDescriptor(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor,
 187                                      IN UCHAR InterfaceNumber,
 188                                      IN UCHAR Alternate,
 189                                      OUT PUCHAR OutAlternate)
 190 {
 191     PUSB_CONFIGURATION_DESCRIPTOR TmpDescriptor;
 192     PUSB_INTERFACE_DESCRIPTOR iDescriptor;
 193     PUSB_INTERFACE_DESCRIPTOR OutDescriptor = NULL;
 194     ULONG_PTR Descriptor = (ULONG_PTR)ConfigDescriptor;
 195     ULONG_PTR EndDescriptors;
 196     ULONG ix;
 197
 198     DPRINT("USBPORT_ParseConfigurationDescriptor ... \n");
 199
 200     if (OutAlternate)
 201         *OutAlternate = 0;
 202
 203     for (TmpDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)((ULONG_PTR)ConfigDescriptor + ConfigDescriptor->bLength);
 204          TmpDescriptor->bDescriptorType == USB_CONFIGURATION_DESCRIPTOR_TYPE && TmpDescriptor->bDescriptorType > 0;
 205          TmpDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)((ULONG_PTR)TmpDescriptor + TmpDescriptor->bLength))
 206     ;
 207
 208     iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)TmpDescriptor;
 209
 210     EndDescriptors = (ULONG_PTR)ConfigDescriptor +
 211                                 ConfigDescriptor->wTotalLength;
 212
 213     while ((Descriptor < EndDescriptors) &&
 214            (iDescriptor->bInterfaceNumber != InterfaceNumber))
 215     {
 216         Descriptor = (ULONG_PTR)iDescriptor +
 217                      USBPORT_GetInterfaceLength(iDescriptor, EndDescriptors);
 218
 219         iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)Descriptor;
 220     }
 221
 222     ix = 0;
 223
 224     while (Descriptor < EndDescriptors &&
 225            iDescriptor->bInterfaceNumber == InterfaceNumber)
 226     {
 227         if (iDescriptor->bAlternateSetting == Alternate)
 228             OutDescriptor = iDescriptor;
 229
 230         Descriptor = (ULONG_PTR)iDescriptor +
 231                      USBPORT_GetInterfaceLength(iDescriptor, EndDescriptors);
 232
 233         iDescriptor = (PUSB_INTERFACE_DESCRIPTOR)Descriptor;
 234
 235         ++ix;
 236     }
 237
 238     if ((ix > 1) && OutAlternate)
 239         *OutAlternate = 1;
 240
 241     return OutDescriptor;
 242 }
 243
 244 USBD_STATUS
 245 NTAPI
 246 USBPORT_OpenInterface(IN PURB Urb,
 247                       IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
 248                       IN PDEVICE_OBJECT FdoDevice,
 249                       IN PUSBPORT_CONFIGURATION_HANDLE ConfigHandle,
 250                       IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
 251                       IN OUT PUSBPORT_INTERFACE_HANDLE *iHandle,
 252                       IN BOOLEAN IsSetInterface)
 253 {
 254     PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
 255     PUSBPORT_INTERFACE_HANDLE InterfaceHandle = NULL;
 256     PUSBPORT_PIPE_HANDLE PipeHandle;
 257     PUSB_ENDPOINT_DESCRIPTOR Descriptor;
 258     PUSBD_PIPE_INFORMATION PipeInfo;
 259     ULONG NumEndpoints;
 260     SIZE_T Length;
 261     SIZE_T HandleLength;
 262     BOOLEAN IsAllocated = FALSE;
 263     USHORT MaxPacketSize;
 264     USHORT wMaxPacketSize;
 265     ULONG ix;
 266     USBD_STATUS USBDStatus = USBD_STATUS_SUCCESS;
 267     NTSTATUS Status;
 268
 269     DPRINT("USBPORT_OpenInterface: ...\n");
 270
 271     InterfaceDescriptor = USBPORT_ParseConfigurationDescriptor(ConfigHandle->ConfigurationDescriptor,
 272                                                                InterfaceInfo->InterfaceNumber,
 273                                                                InterfaceInfo->AlternateSetting,
 274                                                                &InterfaceInfo->AlternateSetting);
 275
 276     NumEndpoints = InterfaceDescriptor->bNumEndpoints;
 277
 278     Length = FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes) +
 279              NumEndpoints * sizeof(USBD_PIPE_INFORMATION);
 280
 281     if (InterfaceInfo->AlternateSetting && IsSetInterface)
 282     {
 283         DPRINT1("USBPORT_OpenInterface: InterfaceInfo->AlternateSetting && IsSetInterface !\n");
 284     }
 285
 286     if (*iHandle)
 287     {
 288         InterfaceHandle = *iHandle;
 289     }
 290     else
 291     {
 292         HandleLength = FIELD_OFFSET(USBPORT_INTERFACE_HANDLE, PipeHandle) +
 293                        NumEndpoints * sizeof(USBPORT_PIPE_HANDLE);
 294
 295         InterfaceHandle = ExAllocatePoolWithTag(NonPagedPool,
 296                                                 HandleLength,
 297                                                 USB_PORT_TAG);
 298
 299         if (!InterfaceHandle)
 300         {
 301             USBDStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
 302             goto Exit;
 303         }
 304
 305         RtlZeroMemory(InterfaceHandle, HandleLength);
 306
 307         for (ix = 0; ix < NumEndpoints; ++ix)
 308         {
 309             PipeHandle = &InterfaceHandle->PipeHandle[ix];
 310
 311             PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
 312             PipeHandle->Endpoint = NULL;
 313         }
 314
 315         IsAllocated = TRUE;
 316     }
 317
 318     InterfaceHandle->AlternateSetting = InterfaceInfo->AlternateSetting;
 319
 320     RtlCopyMemory(&InterfaceHandle->InterfaceDescriptor,
 321                   InterfaceDescriptor,
 322                   sizeof(USB_INTERFACE_DESCRIPTOR));
 323
 324     InterfaceInfo->Class = InterfaceDescriptor->bInterfaceClass;
 325     InterfaceInfo->SubClass = InterfaceDescriptor->bInterfaceSubClass;
 326     InterfaceInfo->Protocol = InterfaceDescriptor->bInterfaceProtocol;
 327     InterfaceInfo->Reserved = 0;
 328     InterfaceInfo->NumberOfPipes = InterfaceDescriptor->bNumEndpoints;
 329
 330     Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor +
 331                                             InterfaceDescriptor->bLength);
 332
 333     for (ix = 0; ix < NumEndpoints; ++ix)
 334     {
 335         PipeHandle = &InterfaceHandle->PipeHandle[ix];
 336
 337         while (Descriptor->bDescriptorType != USB_ENDPOINT_DESCRIPTOR_TYPE)
 338         {
 339             if (Descriptor->bLength == 0)
 340             {
 341                 break;
 342             }
 343             else
 344             {
 345                 Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
 346                                                         Descriptor->bLength);
 347             }
 348         }
 349
 350         if (InterfaceInfo->Pipes[ix].PipeFlags & USBD_PF_CHANGE_MAX_PACKET)
 351         {
 352             Descriptor->wMaxPacketSize = InterfaceInfo->Pipes[ix].MaximumPacketSize;
 353         }
 354
 355         RtlCopyMemory(&PipeHandle->EndpointDescriptor,
 356                       Descriptor,
 357                       sizeof(USB_ENDPOINT_DESCRIPTOR));
 358
 359         PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
 360         PipeHandle->PipeFlags = InterfaceInfo->Pipes[ix].PipeFlags;
 361         PipeHandle->Endpoint = NULL;
 362
 363         wMaxPacketSize = Descriptor->wMaxPacketSize;
 364
 365         /* USB 2.0 Specification, 5.9 High-Speed, High Bandwidth Endpoints */
 366         MaxPacketSize = (wMaxPacketSize & 0x7FF) * (((wMaxPacketSize >> 11) & 3) + 1);
 367
 368         InterfaceInfo->Pipes[ix].EndpointAddress = Descriptor->bEndpointAddress;
 369         InterfaceInfo->Pipes[ix].PipeType = Descriptor->bmAttributes & USB_ENDPOINT_TYPE_MASK;
 370         InterfaceInfo->Pipes[ix].MaximumPacketSize = MaxPacketSize;
 371         InterfaceInfo->Pipes[ix].PipeHandle = (USBD_PIPE_HANDLE)-1;
 372         InterfaceInfo->Pipes[ix].Interval = Descriptor->bInterval;
 373
 374         Descriptor = (PUSB_ENDPOINT_DESCRIPTOR)((ULONG_PTR)Descriptor +
 375                                                 Descriptor->bLength);
 376     }
 377
 378     if (USBD_SUCCESS(USBDStatus))
 379     {
 380         for (ix = 0; ix < NumEndpoints; ++ix)
 381         {
 382             PipeInfo = &InterfaceInfo->Pipes[ix];
 383             PipeHandle = &InterfaceHandle->PipeHandle[ix];
 384
 385             Status = USBPORT_OpenPipe(FdoDevice,
 386                                       DeviceHandle,
 387                                       PipeHandle,
 388                                       &USBDStatus);
 389
 390             if (!NT_SUCCESS(Status))
 391                 break;
 392
 393             PipeInfo->PipeHandle = PipeHandle;
 394         }
 395
 396         if (NumEndpoints)
 397         {
 398             USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
 399         }
 400     }
 401
 402 Exit:
 403
 404     if (USBD_SUCCESS(USBDStatus))
 405     {
 406         InterfaceInfo->InterfaceHandle = InterfaceHandle;
 407         *iHandle = InterfaceHandle;
 408         InterfaceInfo->Length = Length;
 409     }
 410     else
 411     {
 412         if (InterfaceHandle)
 413         {
 414             if (NumEndpoints)
 415             {
 416                 DPRINT1("USBPORT_OpenInterface: USBDStatus - %lx\n", USBDStatus);
 417             }
 418
 419             if (IsAllocated)
 420                 ExFreePoolWithTag(InterfaceHandle, USB_PORT_TAG);
 421         }
 422     }
 423
 424     return USBDStatus;
 425 }
 426
 427 VOID
 428 NTAPI
 429 USBPORT_CloseConfiguration(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
 430                            IN PDEVICE_OBJECT FdoDevice)
 431 {
 432     PUSBPORT_CONFIGURATION_HANDLE ConfigHandle;
 433     PLIST_ENTRY iHandleList;
 434     PUSBPORT_INTERFACE_HANDLE iHandle;
 435     ULONG NumEndpoints;
 436     PUSBPORT_PIPE_HANDLE PipeHandle;
 437
 438     DPRINT("USBPORT_CloseConfiguration: ... \n");
 439
 440     ConfigHandle = DeviceHandle->ConfigHandle;
 441
 442     if (ConfigHandle)
 443     {
 444         iHandleList = &ConfigHandle->InterfaceHandleList;
 445
 446         while (!IsListEmpty(iHandleList))
 447         {
 448             iHandle = CONTAINING_RECORD(iHandleList->Flink,
 449                                         USBPORT_INTERFACE_HANDLE,
 450                                         InterfaceLink);
 451
 452             DPRINT("USBPORT_CloseConfiguration: iHandle - %p\n", iHandle);
 453
 454             RemoveHeadList(iHandleList);
 455
 456             NumEndpoints = iHandle->InterfaceDescriptor.bNumEndpoints;
 457
 458             PipeHandle = &iHandle->PipeHandle[0];
 459
 460             while (NumEndpoints > 0)
 461             {
 462                 USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
 463                 PipeHandle += 1;
 464                 --NumEndpoints;
 465             }
 466
 467             ExFreePoolWithTag(iHandle, USB_PORT_TAG);
 468         }
 469
 470         ExFreePoolWithTag(ConfigHandle, USB_PORT_TAG);
 471         DeviceHandle->ConfigHandle = NULL;
 472     }
 473 }
 474
 475 NTSTATUS
 476 NTAPI
 477 USBPORT_InitInterfaceInfo(IN PUSBD_INTERFACE_INFORMATION InterfaceInfo,
 478                           IN PUSBPORT_CONFIGURATION_HANDLE ConfigHandle)
 479 {
 480     PUSB_INTERFACE_DESCRIPTOR Descriptor;
 481     PUSBD_PIPE_INFORMATION Pipe;
 482     USHORT Length;
 483     ULONG PipeFlags;
 484     ULONG NumberOfPipes;
 485     USBD_STATUS USBDStatus = USBD_STATUS_SUCCESS;
 486
 487     DPRINT("USBPORT_InitInterfaceInfo: InterfaceInfo - %p, ConfigHandle - %p\n",
 488            InterfaceInfo,
 489            ConfigHandle);
 490
 491     Descriptor = USBPORT_ParseConfigurationDescriptor(ConfigHandle->ConfigurationDescriptor,
 492                                                       InterfaceInfo->InterfaceNumber,
 493                                                       InterfaceInfo->AlternateSetting,
 494                                                       &InterfaceInfo->AlternateSetting);
 495
 496     Length = sizeof(USBD_INTERFACE_INFORMATION) +
 497              sizeof(USBD_PIPE_INFORMATION);
 498
 499     if (Descriptor)
 500     {
 501         NumberOfPipes = Descriptor->bNumEndpoints;
 502
 503         Length = FIELD_OFFSET(USBD_INTERFACE_INFORMATION, Pipes) +
 504                  NumberOfPipes * sizeof(USBD_PIPE_INFORMATION);
 505
 506         if (InterfaceInfo->Length >= Length)
 507         {
 508             InterfaceInfo->Class = 0;
 509             InterfaceInfo->SubClass = 0;
 510             InterfaceInfo->Protocol = 0;
 511             InterfaceInfo->Reserved = 0;
 512             InterfaceInfo->InterfaceHandle = 0;
 513             InterfaceInfo->NumberOfPipes = NumberOfPipes;
 514
 515             Pipe = InterfaceInfo->Pipes;
 516
 517             while (NumberOfPipes > 0)
 518             {
 519                 Pipe->EndpointAddress = 0;
 520                 Pipe->Interval = 0;
 521                 Pipe->PipeType = 0;
 522                 Pipe->PipeHandle = 0;
 523
 524                 PipeFlags = Pipe->PipeFlags;
 525
 526                 if (PipeFlags & ~USBD_PF_VALID_MASK)
 527                     USBDStatus = USBD_STATUS_INVALID_PIPE_FLAGS;
 528
 529                 if (!(PipeFlags & USBD_PF_CHANGE_MAX_PACKET))
 530                     Pipe->MaximumPacketSize = 0;
 531
 532                 Pipe += 1;
 533                 --NumberOfPipes;
 534             }
 535         }
 536         else
 537         {
 538             USBDStatus = USBD_STATUS_BUFFER_TOO_SMALL;
 539         }
 540     }
 541     else
 542     {
 543         USBDStatus = USBD_STATUS_INTERFACE_NOT_FOUND;
 544     }
 545
 546     InterfaceInfo->Length = Length;
 547     return USBDStatus;
 548 }
 549
 550 NTSTATUS
 551 NTAPI
 552 USBPORT_HandleSelectConfiguration(IN PDEVICE_OBJECT FdoDevice,
 553                                   IN PIRP Irp,
 554                                   IN PURB Urb)
 555 {
 556     PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptor;
 557     PUSBPORT_DEVICE_HANDLE DeviceHandle;
 558     PUSBPORT_CONFIGURATION_HANDLE ConfigHandle = NULL;
 559     PUSBD_INTERFACE_INFORMATION InterfaceInfo;
 560     PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
 561     ULONG iNumber;
 562     ULONG ix;
 563     USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
 564     NTSTATUS Status;
 565     USBD_STATUS USBDStatus;
 566     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 567
 568     DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor %p\n",
 569            Urb->UrbSelectConfiguration.ConfigurationDescriptor);
 570
 571     FdoExtension = FdoDevice->DeviceExtension;
 572
 573     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
 574                           Executive,
 575                           KernelMode,
 576                           FALSE,
 577                           NULL);
 578
 579     DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
 580     ConfigDescriptor = Urb->UrbSelectConfiguration.ConfigurationDescriptor;
 581
 582     if (!ConfigDescriptor)
 583     {
 584         DPRINT("USBPORT_HandleSelectConfiguration: ConfigDescriptor == NULL\n");
 585
 586         RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 587
 588         SetupPacket.bmRequestType.B = 0;
 589         SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
 590         SetupPacket.wValue.W = 0;
 591         SetupPacket.wIndex.W = 0;
 592         SetupPacket.wLength = 0;
 593
 594         USBPORT_SendSetupPacket(DeviceHandle,
 595                                 FdoDevice,
 596                                 &SetupPacket,
 597                                 NULL,
 598                                 0,
 599                                 NULL,
 600                                 NULL);
 601
 602         Status = USBPORT_USBDStatusToNtStatus(Urb, USBD_STATUS_SUCCESS);
 603         goto Exit;
 604     }
 605
 606     USBPORT_DumpingConfiguration(ConfigDescriptor);
 607
 608     InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
 609
 610     iNumber = 0;
 611
 612     do
 613     {
 614         ++iNumber;
 615         InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
 616                         ((ULONG_PTR)InterfaceInfo +
 617                          InterfaceInfo->Length);
 618     }
 619     while ((ULONG_PTR)InterfaceInfo < (ULONG_PTR)Urb + Urb->UrbHeader.Length);
 620
 621     if ((iNumber <= 0) || (iNumber != ConfigDescriptor->bNumInterfaces))
 622     {
 623         Status = USBPORT_USBDStatusToNtStatus(Urb,
 624                                               USBD_STATUS_INVALID_CONFIGURATION_DESCRIPTOR);
 625         goto Exit;
 626     }
 627
 628     ConfigHandle = ExAllocatePoolWithTag(NonPagedPool,
 629                                          ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE),
 630                                          USB_PORT_TAG);
 631
 632     if (!ConfigHandle)
 633     {
 634         Status = USBPORT_USBDStatusToNtStatus(Urb,
 635                                               USBD_STATUS_INSUFFICIENT_RESOURCES);
 636         goto Exit;
 637     }
 638
 639     RtlZeroMemory(ConfigHandle,
 640                   ConfigDescriptor->wTotalLength + sizeof(USBPORT_CONFIGURATION_HANDLE));
 641
 642     InitializeListHead(&ConfigHandle->InterfaceHandleList);
 643
 644     ConfigHandle->ConfigurationDescriptor = (PUSB_CONFIGURATION_DESCRIPTOR)(ConfigHandle + 1);
 645
 646     RtlCopyMemory(ConfigHandle->ConfigurationDescriptor,
 647                   ConfigDescriptor,
 648                   ConfigDescriptor->wTotalLength);
 649
 650     RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
 651
 652     SetupPacket.bmRequestType.B = 0;
 653     SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
 654     SetupPacket.wValue.W = ConfigDescriptor->bConfigurationValue;
 655     SetupPacket.wIndex.W = 0;
 656     SetupPacket.wLength = 0;
 657
 658     USBPORT_SendSetupPacket(DeviceHandle,
 659                             FdoDevice,
 660                             &SetupPacket,
 661                             NULL,
 662                             0,
 663                             NULL,
 664                             &USBDStatus);
 665
 666     if (USBD_ERROR(USBDStatus))
 667     {
 668         Status = USBPORT_USBDStatusToNtStatus(Urb,
 669                                               USBD_STATUS_SET_CONFIG_FAILED);
 670         goto Exit;
 671     }
 672
 673     if (iNumber <= 0)
 674     {
 675         Status = USBPORT_USBDStatusToNtStatus(Urb,
 676                                               USBD_STATUS_SUCCESS);
 677
 678         goto Exit;
 679     }
 680
 681     InterfaceInfo = &Urb->UrbSelectConfiguration.Interface;
 682
 683     for (ix = 0; ix < iNumber; ++ix)
 684     {
 685         USBDStatus = USBPORT_InitInterfaceInfo(InterfaceInfo,
 686                                                ConfigHandle);
 687
 688         InterfaceHandle = NULL;
 689
 690         if (USBD_SUCCESS(USBDStatus))
 691         {
 692             USBDStatus = USBPORT_OpenInterface(Urb,
 693                                                DeviceHandle,
 694                                                FdoDevice,
 695                                                ConfigHandle,
 696                                                InterfaceInfo,
 697                                                &InterfaceHandle,
 698                                                TRUE);
 699         }
 700
 701         if (InterfaceHandle)
 702         {
 703             InsertTailList(&ConfigHandle->InterfaceHandleList,
 704                            &InterfaceHandle->InterfaceLink);
 705         }
 706
 707         if (USBD_ERROR(USBDStatus))
 708             break;
 709
 710         InterfaceInfo = (PUSBD_INTERFACE_INFORMATION)
 711                          ((ULONG_PTR)InterfaceInfo +
 712                           InterfaceInfo->Length);
 713     }
 714
 715     if (ix >= iNumber)
 716     {
 717         Status = USBPORT_USBDStatusToNtStatus(Urb,
 718                                               USBD_STATUS_SUCCESS);
 719     }
 720     else
 721     {
 722         Status = USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
 723     }
 724
 725 Exit:
 726
 727     if (NT_SUCCESS(Status))
 728     {
 729         Urb->UrbSelectConfiguration.ConfigurationHandle = ConfigHandle;
 730         DeviceHandle->ConfigHandle = ConfigHandle;
 731     }
 732     else
 733     {
 734         DPRINT1("USBPORT_HandleSelectConfiguration: Status %x\n", Status);
 735     }
 736
 737     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
 738                        LOW_REALTIME_PRIORITY,
 739                        1,
 740                        FALSE);
 741
 742     return Status;
 743 }
 744
 745 VOID
 746 NTAPI
 747 USBPORT_AddDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
 748                         IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
 749 {
 750     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 751
 752     DPRINT("USBPORT_AddDeviceHandle: ... \n");
 753
 754     FdoExtension = FdoDevice->DeviceExtension;
 755
 756     InsertTailList(&FdoExtension->DeviceHandleList,
 757                    &DeviceHandle->DeviceHandleLink);
 758 }
 759
 760 VOID
 761 NTAPI
 762 USBPORT_RemoveDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
 763                            IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
 764 {
 765     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 766     KIRQL OldIrql;
 767
 768     DPRINT("USBPORT_RemoveDeviceHandle \n");
 769
 770     FdoExtension = FdoDevice->DeviceExtension;
 771
 772     KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
 773     RemoveEntryList(&DeviceHandle->DeviceHandleLink);
 774     KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
 775 }
 776
 777 BOOLEAN
 778 NTAPI
 779 USBPORT_ValidateDeviceHandle(IN PDEVICE_OBJECT FdoDevice,
 780                              IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
 781 {
 782     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 783     KIRQL OldIrql;
 784     PLIST_ENTRY HandleList;
 785     PUSBPORT_DEVICE_HANDLE CurrentHandle;
 786     BOOLEAN Result = FALSE;
 787
 788     //DPRINT("USBPORT_ValidateDeviceHandle: DeviceHandle - %p\n", DeviceHandle \n");
 789
 790     FdoExtension = FdoDevice->DeviceExtension;
 791
 792     KeAcquireSpinLock(&FdoExtension->DeviceHandleSpinLock, &OldIrql);
 793     if (DeviceHandle)
 794     {
 795         HandleList = FdoExtension->DeviceHandleList.Flink;
 796
 797         while (HandleList != &FdoExtension->DeviceHandleList)
 798         {
 799             CurrentHandle = CONTAINING_RECORD(HandleList,
 800                                               USBPORT_DEVICE_HANDLE,
 801                                               DeviceHandleLink);
 802
 803             if (CurrentHandle == DeviceHandle)
 804             {
 805                 Result = TRUE;
 806                 break;
 807             }
 808
 809             HandleList = HandleList->Flink;
 810         }
 811     }
 812     KeReleaseSpinLock(&FdoExtension->DeviceHandleSpinLock, OldIrql);
 813
 814     return Result;
 815 }
 816
 817 BOOLEAN
 818 NTAPI
 819 USBPORT_DeviceHasTransfers(IN PDEVICE_OBJECT FdoDevice,
 820                            IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
 821 {
 822     PLIST_ENTRY PipeHandleList;
 823     PUSBPORT_PIPE_HANDLE PipeHandle;
 824
 825     DPRINT("USBPORT_DeviceHasTransfers: ... \n");
 826
 827     PipeHandleList = DeviceHandle->PipeHandleList.Flink;
 828
 829     while (PipeHandleList != &DeviceHandle->PipeHandleList)
 830     {
 831         PipeHandle = CONTAINING_RECORD(PipeHandleList,
 832                                        USBPORT_PIPE_HANDLE,
 833                                        PipeLink);
 834
 835         PipeHandleList = PipeHandleList->Flink;
 836
 837         if (!(PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE) &&
 838             USBPORT_EndpointHasQueuedTransfers(FdoDevice, PipeHandle->Endpoint, NULL))
 839         {
 840             return TRUE;
 841         }
 842     }
 843
 844     return FALSE;
 845 }
 846
 847 VOID
 848 NTAPI
 849 USBPORT_AbortTransfers(IN PDEVICE_OBJECT FdoDevice,
 850                        IN PUSBPORT_DEVICE_HANDLE DeviceHandle)
 851 {
 852     PLIST_ENTRY HandleList;
 853     PUSBPORT_PIPE_HANDLE PipeHandle;
 854     BOOLEAN Result;
 855
 856     DPRINT("USBPORT_AbortAllTransfers: ... \n");
 857
 858     HandleList = DeviceHandle->PipeHandleList.Flink;
 859
 860     while (HandleList != &DeviceHandle->PipeHandleList)
 861     {
 862         PipeHandle = CONTAINING_RECORD(HandleList,
 863                                        USBPORT_PIPE_HANDLE,
 864                                        PipeLink);
 865
 866         HandleList = HandleList->Flink;
 867
 868         if (!(PipeHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB))
 869         {
 870             PipeHandle->Endpoint->Flags |= ENDPOINT_FLAG_ABORTING;
 871
 872             USBPORT_AbortEndpoint(FdoDevice, PipeHandle->Endpoint, NULL);
 873             USBPORT_FlushMapTransfers(FdoDevice);
 874         }
 875     }
 876
 877     while (TRUE)
 878     {
 879         Result = USBPORT_DeviceHasTransfers(FdoDevice, DeviceHandle);
 880
 881         if (!Result)
 882             break;
 883
 884         USBPORT_Wait(FdoDevice, 100);
 885     }
 886 }
 887
 888 NTSTATUS
 889 NTAPI
 890 USBPORT_CreateDevice(IN OUT PUSB_DEVICE_HANDLE *pUsbdDeviceHandle,
 891                      IN PDEVICE_OBJECT FdoDevice,
 892                      IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
 893                      IN USHORT PortStatus,
 894                      IN USHORT Port)
 895 {
 896     PUSBPORT_DEVICE_HANDLE DeviceHandle;
 897     PUSBPORT_PIPE_HANDLE PipeHandle;
 898     BOOL IsOpenedPipe;
 899     PVOID DeviceDescriptor;
 900     USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
 901     SIZE_T TransferedLen;
 902     SIZE_T DescriptorMinSize;
 903     UCHAR MaxPacketSize;
 904     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 905
 906     NTSTATUS Status;
 907
 908     DPRINT("USBPORT_CreateDevice: PortStatus - %p, Port - %x\n",
 909            PortStatus,
 910            Port);
 911
 912     FdoExtension = FdoDevice->DeviceExtension;
 913
 914     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
 915                           Executive,
 916                           KernelMode,
 917                           FALSE,
 918                           NULL);
 919
 920     if (!USBPORT_ValidateDeviceHandle(FdoDevice, HubDeviceHandle))
 921     {
 922         KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
 923                            LOW_REALTIME_PRIORITY,
 924                            1,
 925                            FALSE);
 926
 927         DPRINT1("USBPORT_CreateDevice: Not valid hub DeviceHandle\n");
 928         return STATUS_DEVICE_NOT_CONNECTED;
 929     }
 930
 931     if (FdoExtension->MiniPortInterface->Packet.MiniPortFlags & USB_MINIPORT_FLAGS_USB2 &&
 932         !(PortStatus & USB_PORT_STATUS_HIGH_SPEED))
 933     {
 934         DPRINT1("USBPORT_CreateDevice: USB1 device connected to USB2 port. FIXME: Transaction Translator.\n");
 935         DbgBreakPoint();
 936     }
 937
 938     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
 939                        LOW_REALTIME_PRIORITY,
 940                        1,
 941                        FALSE);
 942
 943     DeviceHandle = ExAllocatePoolWithTag(NonPagedPool,
 944                                          sizeof(USBPORT_DEVICE_HANDLE),
 945                                          USB_PORT_TAG);
 946
 947     if (!DeviceHandle)
 948     {
 949         DPRINT1("USBPORT_CreateDevice: Not allocated DeviceHandle\n");
 950         return STATUS_INSUFFICIENT_RESOURCES;
 951     }
 952
 953     RtlZeroMemory(DeviceHandle, sizeof(USBPORT_DEVICE_HANDLE));
 954
 955     *pUsbdDeviceHandle = NULL;
 956
 957     DeviceHandle->PortNumber = Port;
 958     DeviceHandle->HubDeviceHandle = HubDeviceHandle;
 959
 960     if (PortStatus & USB_PORT_STATUS_LOW_SPEED)
 961     {
 962         DeviceHandle->DeviceSpeed = UsbLowSpeed;
 963     }
 964     else if (PortStatus & USB_PORT_STATUS_HIGH_SPEED)
 965     {
 966         DeviceHandle->DeviceSpeed = UsbHighSpeed;
 967     }
 968     else
 969     {
 970         DeviceHandle->DeviceSpeed = UsbFullSpeed;
 971     }
 972
 973     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
 974                           Executive,
 975                           KernelMode,
 976                           FALSE,
 977                           NULL);
 978
 979     PipeHandle = &DeviceHandle->PipeHandle;
 980
 981     PipeHandle->Flags = PIPE_HANDLE_FLAG_CLOSED;
 982
 983     PipeHandle->EndpointDescriptor.bLength = sizeof(PipeHandle->EndpointDescriptor);
 984     PipeHandle->EndpointDescriptor.bDescriptorType = USB_ENDPOINT_DESCRIPTOR_TYPE;
 985
 986     if (DeviceHandle->DeviceSpeed == UsbLowSpeed)
 987     {
 988         PipeHandle->EndpointDescriptor.wMaxPacketSize = 8;
 989     }
 990     else
 991     {
 992         PipeHandle->EndpointDescriptor.wMaxPacketSize = USB_DEFAULT_MAX_PACKET;
 993     }
 994
 995     InitializeListHead(&DeviceHandle->PipeHandleList);
 996
 997     Status = USBPORT_OpenPipe(FdoDevice,
 998                               DeviceHandle,
 999                               PipeHandle,
1000                               NULL);
1001
1002     IsOpenedPipe = NT_SUCCESS(Status);
1003
1004     if (NT_ERROR(Status))
1005     {
1006         DPRINT1("USBPORT_CreateDevice: USBPORT_OpenPipe return - %lx\n", Status);
1007
1008         KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1009                            LOW_REALTIME_PRIORITY,
1010                            1,
1011                            FALSE);
1012
1013         ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
1014
1015         return Status;
1016     }
1017
1018     DeviceDescriptor = ExAllocatePoolWithTag(NonPagedPool,
1019                                              USB_DEFAULT_MAX_PACKET,
1020                                              USB_PORT_TAG);
1021
1022     if (!DeviceDescriptor)
1023     {
1024         DPRINT1("USBPORT_CreateDevice: Not allocated DeviceDescriptor\n");
1025         goto ErrorExit;
1026     }
1027
1028     RtlZeroMemory(DeviceDescriptor, USB_DEFAULT_MAX_PACKET);
1029     RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1030
1031     SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
1032     SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
1033     SetupPacket.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
1034     SetupPacket.wLength = USB_DEFAULT_MAX_PACKET;
1035
1036     TransferedLen = 0;
1037
1038     Status = USBPORT_SendSetupPacket(DeviceHandle,
1039                                      FdoDevice,
1040                                      &SetupPacket,
1041                                      DeviceDescriptor,
1042                                      USB_DEFAULT_MAX_PACKET,
1043                                      &TransferedLen,
1044                                      NULL);
1045
1046     RtlCopyMemory(&DeviceHandle->DeviceDescriptor,
1047                   DeviceDescriptor,
1048                   sizeof(USB_DEVICE_DESCRIPTOR));
1049
1050     ExFreePoolWithTag(DeviceDescriptor, USB_PORT_TAG);
1051
1052     DescriptorMinSize = RTL_SIZEOF_THROUGH_FIELD(USB_DEVICE_DESCRIPTOR,
1053                                                  bMaxPacketSize0);
1054
1055     if ((TransferedLen == DescriptorMinSize) && !NT_SUCCESS(Status))
1056     {
1057         Status = STATUS_SUCCESS;
1058     }
1059
1060     if (NT_SUCCESS(Status) && (TransferedLen >= DescriptorMinSize))
1061     {
1062         if ((DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR)) &&
1063             (DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE))
1064         {
1065             MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
1066
1067             if (MaxPacketSize == 8 ||
1068                 MaxPacketSize == 16 ||
1069                 MaxPacketSize == 32 ||
1070                 MaxPacketSize == 64)
1071             {
1072                 USBPORT_AddDeviceHandle(FdoDevice, DeviceHandle);
1073
1074                 *pUsbdDeviceHandle = DeviceHandle;
1075
1076                 KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1077                                    LOW_REALTIME_PRIORITY,
1078                                    1,
1079                                    FALSE);
1080
1081                 return Status;
1082             }
1083         }
1084     }
1085
1086     DPRINT1("USBPORT_CreateDevice: ERROR!!! TransferedLen - %x, Status - %lx\n",
1087             TransferedLen,
1088             Status);
1089
1090 ErrorExit:
1091
1092     // FIXME: if Transaction Translator
1093
1094     Status = STATUS_DEVICE_DATA_ERROR;
1095
1096     if (IsOpenedPipe)
1097     {
1098         USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
1099     }
1100
1101     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1102                        LOW_REALTIME_PRIORITY,
1103                        1,
1104                        FALSE);
1105
1106     ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
1107
1108     return Status;
1109 }
1110
1111 ULONG
1112 NTAPI
1113 USBPORT_AllocateUsbAddress(IN PDEVICE_OBJECT FdoDevice)
1114 {
1115     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1116     ULONG BitMapIdx;
1117     ULONG BitNumber;
1118     ULONG ix;
1119
1120     DPRINT("USBPORT_AllocateUsbAddress \n");
1121
1122     FdoExtension = FdoDevice->DeviceExtension;
1123
1124     for (ix = 0; ix < 4; ++ix)
1125     {
1126         BitMapIdx = 1;
1127
1128         for (BitNumber = 0; BitNumber < 32; ++BitNumber)
1129         {
1130             if (!(FdoExtension->UsbAddressBitMap[ix] & BitMapIdx))
1131             {
1132                 FdoExtension->UsbAddressBitMap[ix] |= BitMapIdx;
1133                 return 32 * ix + BitNumber;
1134             }
1135
1136             BitMapIdx <<= 2;
1137         }
1138     }
1139
1140     return 0;
1141 }
1142
1143 VOID
1144 NTAPI
1145 USBPORT_FreeUsbAddress(IN PDEVICE_OBJECT FdoDevice,
1146                        IN USHORT DeviceAddress)
1147 {
1148     PUSBPORT_DEVICE_EXTENSION  FdoExtension;
1149     ULONG ix;
1150     ULONG BitMapIdx;
1151     ULONG BitNumber;
1152     USHORT CurrentAddress;
1153
1154     DPRINT("USBPORT_FreeUsbAddress: DeviceAddress - %x\n", DeviceAddress);
1155
1156     FdoExtension = FdoDevice->DeviceExtension;
1157
1158     for (ix = 0; ix < 4; ++ix)
1159     {
1160         BitMapIdx = 1;
1161         CurrentAddress = 32 * ix;
1162
1163         for (BitNumber = 0; BitNumber < 32; ++BitNumber)
1164         {
1165             if (CurrentAddress == DeviceAddress)
1166             {
1167                 FdoExtension->UsbAddressBitMap[ix] &= ~BitMapIdx;
1168                 return;
1169             }
1170
1171             BitMapIdx <<= 2;
1172             CurrentAddress++;
1173         }
1174     }
1175 }
1176
1177 NTSTATUS
1178 NTAPI
1179 USBPORT_InitializeDevice(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
1180                          IN PDEVICE_OBJECT FdoDevice)
1181 {
1182     PUSBPORT_ENDPOINT Endpoint;
1183     USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
1184     ULONG TransferedLen;
1185     USHORT DeviceAddress = 0;
1186     UCHAR MaxPacketSize;
1187     NTSTATUS Status;
1188     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1189
1190     DPRINT("USBPORT_InitializeDevice: ... \n");
1191
1192     ASSERT(DeviceHandle != NULL);
1193
1194     FdoExtension = FdoDevice->DeviceExtension;
1195
1196     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
1197                           Executive,
1198                           KernelMode,
1199                           FALSE,
1200                           NULL);
1201
1202     DeviceAddress = USBPORT_AllocateUsbAddress(FdoDevice);
1203     ASSERT(DeviceHandle->DeviceAddress == USB_DEFAULT_DEVICE_ADDRESS);
1204
1205     RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1206
1207     CtrlSetup.bRequest = USB_REQUEST_SET_ADDRESS;
1208     CtrlSetup.wValue.W = DeviceAddress;
1209
1210     Status = USBPORT_SendSetupPacket(DeviceHandle,
1211                                      FdoDevice,
1212                                      &CtrlSetup,
1213                                      NULL,
1214                                      0,
1215                                      NULL,
1216                                      NULL);
1217
1218     DPRINT("USBPORT_InitializeDevice: DeviceAddress - %x. SendSetupPacket Status - %x\n",
1219            DeviceAddress,
1220            Status);
1221
1222     if (!NT_SUCCESS(Status))
1223         goto ExitError;
1224
1225     DeviceHandle->DeviceAddress = DeviceAddress;
1226     Endpoint = DeviceHandle->PipeHandle.Endpoint;
1227
1228     Endpoint->EndpointProperties.TotalMaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
1229     Endpoint->EndpointProperties.DeviceAddress = DeviceAddress;
1230
1231     Status = USBPORT_ReopenPipe(FdoDevice, Endpoint);
1232
1233     if (!NT_SUCCESS(Status))
1234         goto ExitError;
1235
1236     USBPORT_Wait(FdoDevice, 10);
1237
1238     RtlZeroMemory(&CtrlSetup, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1239
1240     CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
1241     CtrlSetup.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
1242     CtrlSetup.wLength = sizeof(USB_DEVICE_DESCRIPTOR);
1243     CtrlSetup.bmRequestType.B = 0x80;
1244
1245     Status = USBPORT_SendSetupPacket(DeviceHandle,
1246                                      FdoDevice,
1247                                      &CtrlSetup,
1248                                      &DeviceHandle->DeviceDescriptor,
1249                                      sizeof(USB_DEVICE_DESCRIPTOR),
1250                                      &TransferedLen,
1251                                      NULL);
1252
1253     if (NT_SUCCESS(Status))
1254     {
1255         ASSERT(TransferedLen == sizeof(USB_DEVICE_DESCRIPTOR));
1256         ASSERT(DeviceHandle->DeviceDescriptor.bLength >= sizeof(USB_DEVICE_DESCRIPTOR));
1257         ASSERT(DeviceHandle->DeviceDescriptor.bDescriptorType == USB_DEVICE_DESCRIPTOR_TYPE);
1258
1259         MaxPacketSize = DeviceHandle->DeviceDescriptor.bMaxPacketSize0;
1260
1261         ASSERT((MaxPacketSize == 8) ||
1262                (MaxPacketSize == 16) ||
1263                (MaxPacketSize == 32) ||
1264                (MaxPacketSize == 64));
1265     }
1266     else
1267     {
1268 ExitError:
1269         DPRINT1("USBPORT_InitializeDevice: ExitError. Status - %x\n", Status);
1270     }
1271
1272     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1273                        LOW_REALTIME_PRIORITY,
1274                        1,
1275                        FALSE);
1276
1277     return Status;
1278 }
1279
1280 NTSTATUS
1281 NTAPI
1282 USBPORT_GetUsbDescriptor(IN PUSBPORT_DEVICE_HANDLE DeviceHandle,
1283                          IN PDEVICE_OBJECT FdoDevice,
1284                          IN UCHAR Type,
1285                          IN PUCHAR ConfigDesc,
1286                          IN PULONG ConfigDescSize)
1287 {
1288     USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
1289
1290     DPRINT("USBPORT_GetUsbDescriptor: Type - %x\n");
1291
1292     RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1293
1294     SetupPacket.bmRequestType.Dir = BMREQUEST_DEVICE_TO_HOST;
1295     SetupPacket.bRequest = USB_REQUEST_GET_DESCRIPTOR;
1296     SetupPacket.wValue.HiByte = Type;
1297     SetupPacket.wLength = (USHORT)*ConfigDescSize;
1298
1299     return USBPORT_SendSetupPacket(DeviceHandle,
1300                                    FdoDevice,
1301                                    &SetupPacket,
1302                                    ConfigDesc,
1303                                    *ConfigDescSize,
1304                                    ConfigDescSize,
1305                                    NULL);
1306 }
1307
1308 PUSBPORT_INTERFACE_HANDLE
1309 NTAPI
1310 USBPORT_GetInterfaceHandle(IN PUSBPORT_CONFIGURATION_HANDLE ConfigurationHandle,
1311                            IN UCHAR InterfaceNumber)
1312 {
1313     PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
1314     PLIST_ENTRY iHandleList;
1315     UCHAR InterfaceNum;
1316
1317     DPRINT("USBPORT_GetInterfaceHandle: ConfigurationHandle - %p, InterfaceNumber - %p\n",
1318            ConfigurationHandle,
1319            InterfaceNumber);
1320
1321     iHandleList = ConfigurationHandle->InterfaceHandleList.Flink;
1322
1323     while (iHandleList &&
1324            (iHandleList != &ConfigurationHandle->InterfaceHandleList))
1325     {
1326         InterfaceHandle = CONTAINING_RECORD(iHandleList,
1327                                             USBPORT_INTERFACE_HANDLE,
1328                                             InterfaceLink);
1329
1330         InterfaceNum = InterfaceHandle->InterfaceDescriptor.bInterfaceNumber;
1331
1332         if (InterfaceNum == InterfaceNumber)
1333             return InterfaceHandle;
1334
1335         iHandleList = InterfaceHandle->InterfaceLink.Flink;
1336     }
1337
1338     return NULL;
1339 }
1340
1341 NTSTATUS
1342 NTAPI
1343 USBPORT_HandleSelectInterface(IN PDEVICE_OBJECT FdoDevice,
1344                               IN PIRP Irp,
1345                               IN PURB Urb)
1346 {
1347     PUSBPORT_DEVICE_HANDLE DeviceHandle;
1348     PUSBPORT_CONFIGURATION_HANDLE ConfigurationHandle;
1349     PUSBD_INTERFACE_INFORMATION Interface;
1350     PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
1351     PUSBPORT_INTERFACE_HANDLE iHandle;
1352     PUSBPORT_PIPE_HANDLE PipeHandle;
1353     USBD_STATUS USBDStatus;
1354     USHORT Length;
1355     ULONG ix;
1356     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1357
1358     DPRINT("USBPORT_HandleSelectInterface: ... \n");
1359
1360     FdoExtension = FdoDevice->DeviceExtension;
1361
1362     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
1363                           Executive,
1364                           KernelMode,
1365                           FALSE,
1366                           NULL);
1367
1368     ConfigurationHandle = Urb->UrbSelectInterface.ConfigurationHandle;
1369
1370     Interface = &Urb->UrbSelectInterface.Interface;
1371
1372     Length = Interface->Length + sizeof(USBD_PIPE_INFORMATION);
1373     Urb->UrbHeader.Length = Length;
1374
1375     USBDStatus = USBPORT_InitInterfaceInfo(Interface, ConfigurationHandle);
1376
1377     if (USBDStatus)
1378     {
1379         Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
1380         return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
1381     }
1382
1383     DeviceHandle = Urb->UrbHeader.UsbdDeviceHandle;
1384
1385     InterfaceHandle = USBPORT_GetInterfaceHandle(ConfigurationHandle,
1386                                                  Interface->InterfaceNumber);
1387
1388     if (InterfaceHandle)
1389     {
1390         RemoveEntryList(&InterfaceHandle->InterfaceLink);
1391
1392         if (InterfaceHandle->InterfaceDescriptor.bNumEndpoints)
1393         {
1394             PipeHandle = &InterfaceHandle->PipeHandle[0];
1395
1396             for (ix = 0;
1397                  ix < InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
1398                  ix++)
1399             {
1400                 USBPORT_ClosePipe(DeviceHandle, FdoDevice, PipeHandle);
1401                 PipeHandle += 1;
1402             }
1403         }
1404     }
1405
1406     iHandle = 0;
1407
1408     USBDStatus = USBPORT_OpenInterface(Urb,
1409                                        DeviceHandle,
1410                                        FdoDevice,
1411                                        ConfigurationHandle,
1412                                        Interface,
1413                                        &iHandle,
1414                                        1);
1415
1416     if (USBDStatus)
1417     {
1418         Interface->InterfaceHandle = (USBD_INTERFACE_HANDLE)-1;
1419     }
1420     else
1421     {
1422         if (InterfaceHandle)
1423             ExFreePoolWithTag(InterfaceHandle, USB_PORT_TAG);
1424
1425         Interface->InterfaceHandle = iHandle;
1426
1427         InsertTailList(&ConfigurationHandle->InterfaceHandleList,
1428                        &iHandle->InterfaceLink);
1429     }
1430
1431     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1432                        LOW_REALTIME_PRIORITY,
1433                        1,
1434                        FALSE);
1435
1436     return USBPORT_USBDStatusToNtStatus(Urb, USBDStatus);
1437 }
1438
1439 NTSTATUS
1440 NTAPI
1441 USBPORT_RemoveDevice(IN PDEVICE_OBJECT FdoDevice,
1442                      IN OUT PUSBPORT_DEVICE_HANDLE DeviceHandle,
1443                      IN ULONG Flags)
1444 {
1445     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1446
1447     DPRINT("USBPORT_RemoveDevice: DeviceHandle - %p, Flags - %x\n",
1448            DeviceHandle,
1449            Flags);
1450
1451     FdoExtension = FdoDevice->DeviceExtension;
1452
1453     if ((Flags & USBD_KEEP_DEVICE_DATA) ||
1454         (Flags & USBD_MARK_DEVICE_BUSY))
1455     {
1456         return STATUS_SUCCESS;
1457     }
1458
1459     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
1460                           Executive,
1461                           KernelMode,
1462                           FALSE,
1463                           NULL);
1464
1465     if (!USBPORT_ValidateDeviceHandle(FdoDevice, DeviceHandle))
1466     {
1467         KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1468                            LOW_REALTIME_PRIORITY,
1469                            1,
1470                            FALSE);
1471
1472         DPRINT1("USBPORT_RemoveDevice: Not valid device handle\n");
1473         return STATUS_DEVICE_NOT_CONNECTED;
1474     }
1475
1476     USBPORT_RemoveDeviceHandle(FdoDevice, DeviceHandle);
1477
1478     DeviceHandle->Flags |= DEVICE_HANDLE_FLAG_REMOVED;
1479
1480     USBPORT_AbortTransfers(FdoDevice, DeviceHandle);
1481
1482     DPRINT("USBPORT_RemoveDevice: DeviceHandleLock - %x\n",
1483            DeviceHandle->DeviceHandleLock);
1484
1485     while (InterlockedDecrement(&DeviceHandle->DeviceHandleLock) >= 0)
1486     {
1487         InterlockedIncrement(&DeviceHandle->DeviceHandleLock);
1488         USBPORT_Wait(FdoDevice, 100);
1489     }
1490
1491     DPRINT("USBPORT_RemoveDevice: DeviceHandleLock ok\n");
1492
1493     if (DeviceHandle->ConfigHandle)
1494     {
1495         USBPORT_CloseConfiguration(DeviceHandle, FdoDevice);
1496     }
1497
1498     USBPORT_ClosePipe(DeviceHandle, FdoDevice, &DeviceHandle->PipeHandle);
1499
1500     if (DeviceHandle->DeviceAddress)
1501     {
1502         USBPORT_FreeUsbAddress(FdoDevice, DeviceHandle->DeviceAddress);
1503     }
1504
1505     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1506                        LOW_REALTIME_PRIORITY,
1507                        1,
1508                        FALSE);
1509
1510     if (!(DeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB))
1511     {
1512         ExFreePoolWithTag(DeviceHandle, USB_PORT_TAG);
1513     }
1514
1515     return STATUS_SUCCESS;
1516 }
1517
1518 NTSTATUS
1519 NTAPI
1520 USBPORT_RestoreDevice(IN PDEVICE_OBJECT FdoDevice,
1521                       IN OUT PUSBPORT_DEVICE_HANDLE OldDeviceHandle,
1522                       IN OUT PUSBPORT_DEVICE_HANDLE NewDeviceHandle)
1523 {
1524     PUSBPORT_DEVICE_EXTENSION  FdoExtension;
1525     PLIST_ENTRY iHandleList;
1526     PUSBPORT_ENDPOINT Endpoint;
1527     ULONG EndpointRequirements[2] = {0};
1528     USB_DEFAULT_PIPE_SETUP_PACKET SetupPacket;
1529     NTSTATUS Status = STATUS_SUCCESS;
1530     USBD_STATUS USBDStatus;
1531     KIRQL OldIrql;
1532     PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
1533     PUSBPORT_PIPE_HANDLE PipeHandle;
1534     PUSBPORT_REGISTRATION_PACKET Packet;
1535
1536     DPRINT("USBPORT_RestoreDevice: OldDeviceHandle - %p, NewDeviceHandle - %p\n",
1537            OldDeviceHandle,
1538            NewDeviceHandle);
1539
1540     FdoExtension = FdoDevice->DeviceExtension;
1541
1542     KeWaitForSingleObject(&FdoExtension->DeviceSemaphore,
1543                           Executive,
1544                           KernelMode,
1545                           FALSE,
1546                           NULL);
1547
1548     if (!USBPORT_ValidateDeviceHandle(FdoDevice, OldDeviceHandle))
1549     {
1550         KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1551                            LOW_REALTIME_PRIORITY,
1552                            1,
1553                            FALSE);
1554
1555 #ifndef NDEBUG
1556         DPRINT("USBPORT_RestoreDevice: OldDeviceHandle not valid\n");
1557         DbgBreakPoint();
1558 #endif
1559         return STATUS_DEVICE_NOT_CONNECTED;
1560     }
1561
1562     if (!USBPORT_ValidateDeviceHandle(FdoDevice, NewDeviceHandle))
1563     {
1564         KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1565                            LOW_REALTIME_PRIORITY,
1566                            1,
1567                            FALSE);
1568 #ifndef NDEBUG
1569         DPRINT("USBPORT_RestoreDevice: NewDeviceHandle not valid\n");
1570         DbgBreakPoint();
1571 #endif
1572         return STATUS_DEVICE_NOT_CONNECTED;
1573     }
1574
1575     USBPORT_RemoveDeviceHandle(FdoDevice, OldDeviceHandle);
1576     USBPORT_AbortTransfers(FdoDevice, OldDeviceHandle);
1577
1578     while (InterlockedDecrement(&OldDeviceHandle->DeviceHandleLock) >= 0)
1579     {
1580         InterlockedIncrement(&OldDeviceHandle->DeviceHandleLock);
1581         USBPORT_Wait(FdoDevice, 100);
1582     }
1583
1584     if (sizeof(USB_DEVICE_DESCRIPTOR) == RtlCompareMemory(&NewDeviceHandle->DeviceDescriptor,
1585                                                           &OldDeviceHandle->DeviceDescriptor,
1586                                                           sizeof(USB_DEVICE_DESCRIPTOR)))
1587     {
1588         NewDeviceHandle->ConfigHandle = OldDeviceHandle->ConfigHandle;
1589
1590         if (OldDeviceHandle->ConfigHandle)
1591         {
1592             RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1593
1594             SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
1595             SetupPacket.bRequest = USB_REQUEST_SET_CONFIGURATION;
1596             SetupPacket.wValue.W = OldDeviceHandle->ConfigHandle->ConfigurationDescriptor->bConfigurationValue;
1597             SetupPacket.wIndex.W = 0;
1598             SetupPacket.wLength = 0;
1599
1600             USBPORT_SendSetupPacket(NewDeviceHandle,
1601                                     FdoDevice,
1602                                     &SetupPacket,
1603                                     NULL,
1604                                     0,
1605                                     NULL,
1606                                     &USBDStatus);
1607
1608             if (USBD_ERROR(USBDStatus))
1609                 Status = USBPORT_USBDStatusToNtStatus(NULL, USBDStatus);
1610
1611             if (NT_SUCCESS(Status))
1612             {
1613                 iHandleList = NewDeviceHandle->ConfigHandle->InterfaceHandleList.Flink;
1614
1615                 while (iHandleList &&
1616                        iHandleList != &NewDeviceHandle->ConfigHandle->InterfaceHandleList)
1617                 {
1618                     InterfaceHandle = CONTAINING_RECORD(iHandleList,
1619                                                         USBPORT_INTERFACE_HANDLE,
1620                                                         InterfaceLink);
1621
1622                     if (InterfaceHandle->AlternateSetting)
1623                     {
1624                         RtlZeroMemory(&SetupPacket, sizeof(USB_DEFAULT_PIPE_SETUP_PACKET));
1625
1626                         SetupPacket.bmRequestType.Dir = BMREQUEST_HOST_TO_DEVICE;
1627                         SetupPacket.bmRequestType.Type = BMREQUEST_STANDARD;
1628                         SetupPacket.bmRequestType.Recipient = BMREQUEST_TO_INTERFACE;
1629
1630                         SetupPacket.bRequest = USB_REQUEST_SET_INTERFACE;
1631                         SetupPacket.wValue.W = InterfaceHandle->InterfaceDescriptor.bAlternateSetting;
1632                         SetupPacket.wIndex.W = InterfaceHandle->InterfaceDescriptor.bInterfaceNumber;
1633                         SetupPacket.wLength = 0;
1634
1635                         USBPORT_SendSetupPacket(NewDeviceHandle,
1636                                                 FdoDevice,
1637                                                 &SetupPacket,
1638                                                 NULL,
1639                                                 0,
1640                                                 NULL,
1641                                                 &USBDStatus);
1642                     }
1643
1644                     iHandleList = iHandleList->Flink;
1645                 }
1646             }
1647         }
1648
1649         if (NewDeviceHandle->Flags & DEVICE_HANDLE_FLAG_INITIALIZED)
1650         {
1651             DPRINT1("USBPORT_RestoreDevice: FIXME Transaction Translator\n");
1652             NewDeviceHandle->TtCount = OldDeviceHandle->TtCount;
1653         }
1654
1655         while (!IsListEmpty(&OldDeviceHandle->PipeHandleList))
1656         {
1657             PipeHandle = CONTAINING_RECORD(OldDeviceHandle->PipeHandleList.Flink,
1658                                            USBPORT_PIPE_HANDLE,
1659                                            PipeLink);
1660
1661             DPRINT("USBPORT_RestoreDevice: PipeHandle - %p\n", PipeHandle);
1662
1663             USBPORT_RemovePipeHandle(OldDeviceHandle, PipeHandle);
1664
1665             if (PipeHandle != &OldDeviceHandle->PipeHandle)
1666             {
1667                 USBPORT_AddPipeHandle(NewDeviceHandle, PipeHandle);
1668
1669                 if (!(PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE))
1670                 {
1671                     Endpoint = PipeHandle->Endpoint;
1672                     Endpoint->DeviceHandle = NewDeviceHandle;
1673                     Endpoint->EndpointProperties.DeviceAddress = NewDeviceHandle->DeviceAddress;
1674
1675                     Packet = &FdoExtension->MiniPortInterface->Packet;
1676
1677                     if (!(Endpoint->Flags & ENDPOINT_FLAG_NUKE))
1678                     {
1679                         KeAcquireSpinLock(&FdoExtension->MiniportSpinLock,
1680                                           &OldIrql);
1681
1682                         Packet->ReopenEndpoint(FdoExtension->MiniPortExt,
1683                                                &Endpoint->EndpointProperties,
1684                                                Endpoint + 1);
1685
1686                         Packet->SetEndpointDataToggle(FdoExtension->MiniPortExt,
1687                                                       Endpoint + 1,
1688                                                       0);
1689
1690                         Packet->SetEndpointStatus(FdoExtension->MiniPortExt,
1691                                                   Endpoint + 1,
1692                                                   USBPORT_ENDPOINT_RUN);
1693
1694                         KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
1695                                           OldIrql);
1696                     }
1697                     else
1698                     {
1699                         MiniportCloseEndpoint(FdoDevice, Endpoint);
1700
1701                         RtlZeroMemory(Endpoint + 1, Packet->MiniPortEndpointSize);
1702
1703                         RtlZeroMemory((PVOID)Endpoint->EndpointProperties.BufferVA,
1704                                       Endpoint->EndpointProperties.BufferLength);
1705
1706                         KeAcquireSpinLock(&FdoExtension->MiniportSpinLock, &OldIrql);
1707
1708                         Packet->QueryEndpointRequirements(FdoExtension->MiniPortExt,
1709                                                           &Endpoint->EndpointProperties,
1710                                                           EndpointRequirements);
1711
1712                         KeReleaseSpinLock(&FdoExtension->MiniportSpinLock,
1713                                           OldIrql);
1714
1715                         MiniportOpenEndpoint(FdoDevice, Endpoint);
1716
1717                         Endpoint->Flags &= ~(ENDPOINT_FLAG_NUKE |
1718                                              ENDPOINT_FLAG_ABORTING);
1719
1720                         KeAcquireSpinLock(&Endpoint->EndpointSpinLock,
1721                                           &Endpoint->EndpointOldIrql);
1722
1723                         if (Endpoint->StateLast == USBPORT_ENDPOINT_ACTIVE)
1724                         {
1725                             KeAcquireSpinLockAtDpcLevel(&FdoExtension->MiniportSpinLock);
1726
1727                             Packet->SetEndpointState(FdoExtension->MiniPortExt,
1728                                                      Endpoint + 1,
1729                                                      USBPORT_ENDPOINT_ACTIVE);
1730
1731                             KeReleaseSpinLockFromDpcLevel(&FdoExtension->MiniportSpinLock);
1732                         }
1733
1734                         KeReleaseSpinLock(&Endpoint->EndpointSpinLock,
1735                                           Endpoint->EndpointOldIrql);
1736                     }
1737                 }
1738             }
1739         }
1740
1741         USBPORT_AddPipeHandle(OldDeviceHandle, &OldDeviceHandle->PipeHandle);
1742     }
1743     else
1744     {
1745 #ifndef NDEBUG
1746         DPRINT("USBPORT_RestoreDevice: New DeviceDescriptor != Old DeviceDescriptor\n");
1747         DbgBreakPoint();
1748 #endif
1749         Status = STATUS_UNSUCCESSFUL;
1750     }
1751
1752     USBPORT_ClosePipe(OldDeviceHandle, FdoDevice, &OldDeviceHandle->PipeHandle);
1753
1754     if (OldDeviceHandle->DeviceAddress != 0)
1755         USBPORT_FreeUsbAddress(FdoDevice, OldDeviceHandle->DeviceAddress);
1756
1757     KeReleaseSemaphore(&FdoExtension->DeviceSemaphore,
1758                        LOW_REALTIME_PRIORITY,
1759                        1,
1760                        FALSE);
1761
1762     ExFreePoolWithTag(OldDeviceHandle, USB_PORT_TAG);
1763
1764     return Status;
1765 }
1766
1767 NTSTATUS
1768 NTAPI
1769 USBPORT_InitializeTT(IN PDEVICE_OBJECT FdoDevice,
1770                      IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
1771                      IN ULONG TtNumber)
1772 {
1773     DPRINT1("USBPORT_InitializeTT: UNIMPLEMENTED. FIXME. \n");
1774     return STATUS_SUCCESS;
1775 }
1776
1777 NTSTATUS
1778 NTAPI
1779 USBPORT_Initialize20Hub(IN PDEVICE_OBJECT FdoDevice,
1780                         IN PUSBPORT_DEVICE_HANDLE HubDeviceHandle,
1781                         IN ULONG TtCount)
1782 {
1783     NTSTATUS Status;
1784     ULONG ix;
1785
1786     DPRINT("USBPORT_Initialize20Hub \n");
1787
1788     if (!HubDeviceHandle)
1789     {
1790         return STATUS_INVALID_PARAMETER;
1791     }
1792
1793     if (HubDeviceHandle->Flags & DEVICE_HANDLE_FLAG_ROOTHUB)
1794     {
1795         return STATUS_SUCCESS;
1796     }
1797
1798     if (TtCount == 0)
1799     {
1800         HubDeviceHandle->TtCount = 0;
1801         return STATUS_SUCCESS;
1802     }
1803
1804     for (ix = 0; ix < TtCount; ++ix)
1805     {
1806         Status = USBPORT_InitializeTT(FdoDevice, HubDeviceHandle, ix + 1);
1807
1808         if (!NT_SUCCESS(Status))
1809             break;
1810     }
1811
1812     HubDeviceHandle->TtCount = TtCount;
1813
1814     return Status;
1815 }