drivers/usb/usbport/pnp.c

   1 /*
   2  * PROJECT:     ReactOS USB Port Driver
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     USBPort plug and play 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 #define NDEBUG_USBPORT_CORE
  14 #include "usbdebug.h"
  15
  16 IO_COMPLETION_ROUTINE USBPORT_FdoStartCompletion;
  17
  18 NTSTATUS
  19 NTAPI
  20 USBPORT_FdoStartCompletion(IN PDEVICE_OBJECT DeviceObject,
  21                            IN PIRP Irp,
  22                            IN PVOID Context)
  23 {
  24     KeSetEvent((PKEVENT)Context, EVENT_INCREMENT, FALSE);
  25     return STATUS_MORE_PROCESSING_REQUIRED;
  26 }
  27
  28 NTSTATUS
  29 NTAPI
  30 USBPORT_RegisterDeviceInterface(IN PDEVICE_OBJECT PdoDevice,
  31                                 IN PDEVICE_OBJECT DeviceObject,
  32                                 IN CONST GUID *InterfaceClassGuid,
  33                                 IN BOOLEAN Enable)
  34 {
  35     PUSBPORT_RHDEVICE_EXTENSION DeviceExtension;
  36     PUNICODE_STRING SymbolicLinkName;
  37     NTSTATUS Status;
  38
  39     DPRINT("USBPORT_RegisterDeviceInterface: Enable - %x\n", Enable);
  40
  41     DeviceExtension = DeviceObject->DeviceExtension;
  42     SymbolicLinkName = &DeviceExtension->CommonExtension.SymbolicLinkName;
  43
  44     if (Enable)
  45     {
  46         Status = IoRegisterDeviceInterface(PdoDevice,
  47                                            InterfaceClassGuid,
  48                                            NULL,
  49                                            SymbolicLinkName);
  50
  51         if (NT_SUCCESS(Status))
  52         {
  53             DeviceExtension->CommonExtension.IsInterfaceEnabled = 1;
  54
  55             Status = USBPORT_SetRegistryKeyValue(PdoDevice,
  56                                                  FALSE,
  57                                                  REG_SZ,
  58                                                  L"SymbolicName",
  59                                                  SymbolicLinkName->Buffer,
  60                                                  SymbolicLinkName->Length);
  61
  62             if (NT_SUCCESS(Status))
  63             {
  64                 DPRINT("USBPORT_RegisterDeviceInterface: LinkName  - %wZ\n",
  65                        &DeviceExtension->CommonExtension.SymbolicLinkName);
  66
  67                 Status = IoSetDeviceInterfaceState(SymbolicLinkName, TRUE);
  68             }
  69         }
  70     }
  71     else
  72     {
  73         /* Disable device interface */
  74         Status = IoSetDeviceInterfaceState(SymbolicLinkName, FALSE);
  75
  76         if (NT_SUCCESS(Status))
  77         {
  78             RtlFreeUnicodeString(SymbolicLinkName);
  79             DeviceExtension->CommonExtension.IsInterfaceEnabled = 0; // Disabled interface
  80         }
  81     }
  82
  83     return Status;
  84 }
  85
  86 BOOLEAN
  87 NTAPI
  88 USBPORT_IsSelectiveSuspendEnabled(IN PDEVICE_OBJECT FdoDevice)
  89 {
  90     PUSBPORT_DEVICE_EXTENSION FdoExtension;
  91     ULONG Disabled = 0;
  92
  93     DPRINT("USBPORT_IsSelectiveSuspendEnabled: ... \n");
  94
  95     FdoExtension = FdoDevice->DeviceExtension;
  96
  97     USBPORT_GetRegistryKeyValueFullInfo(FdoDevice,
  98                                         FdoExtension->CommonExtension.LowerPdoDevice,
  99                                         TRUE,
 100                                         L"HcDisableSelectiveSuspend",
 101                                         sizeof(L"HcDisableSelectiveSuspend"),
 102                                         &Disabled,
 103                                         sizeof(Disabled));
 104
 105     return (Disabled == 0);
 106 }
 107
 108 NTSTATUS
 109 NTAPI
 110 USBPORT_GetConfigValue(IN PWSTR ValueName,
 111                        IN ULONG ValueType,
 112                        IN PVOID ValueData,
 113                        IN ULONG ValueLength,
 114                        IN PVOID Context,
 115                        IN PVOID EntryContext)
 116 {
 117     NTSTATUS Status = STATUS_SUCCESS;
 118
 119     DPRINT("USBPORT_GetConfigValue \n");
 120
 121     if (ValueType == REG_DWORD)
 122     {
 123         *(PULONG)EntryContext = *(PULONG)ValueData;
 124     }
 125     else
 126     {
 127         Status = STATUS_INVALID_PARAMETER;
 128     }
 129
 130     return Status;
 131 }
 132
 133 NTSTATUS
 134 NTAPI
 135 USBPORT_GetDefaultBIOSx(IN PDEVICE_OBJECT FdoDevice,
 136                          IN PULONG UsbBIOSx,
 137                          IN PULONG DisableSelectiveSuspend,
 138                          IN PULONG DisableCcDetect,
 139                          IN PULONG IdleEpSupport,
 140                          IN PULONG IdleEpSupportEx,
 141                          IN PULONG SoftRetry)
 142 {
 143     RTL_QUERY_REGISTRY_TABLE QueryTable[7];
 144
 145     DPRINT("USBPORT_GetDefaultBIOS_X: ... \n");
 146
 147     RtlZeroMemory(QueryTable, sizeof(QueryTable));
 148
 149     *UsbBIOSx = 2;
 150
 151     QueryTable[0].QueryRoutine = USBPORT_GetConfigValue;
 152     QueryTable[0].Flags = 0;
 153     QueryTable[0].Name = L"UsbBIOSx";
 154     QueryTable[0].EntryContext = UsbBIOSx;
 155     QueryTable[0].DefaultType = REG_DWORD;
 156     QueryTable[0].DefaultData = UsbBIOSx;
 157     QueryTable[0].DefaultLength = sizeof(ULONG);
 158
 159     QueryTable[1].QueryRoutine = USBPORT_GetConfigValue;
 160     QueryTable[1].Flags = 0;
 161     QueryTable[1].Name = L"DisableSelectiveSuspend";
 162     QueryTable[1].EntryContext = DisableSelectiveSuspend;
 163     QueryTable[1].DefaultType = REG_DWORD;
 164     QueryTable[1].DefaultData = DisableSelectiveSuspend;
 165     QueryTable[1].DefaultLength = sizeof(ULONG);
 166
 167     QueryTable[2].QueryRoutine = USBPORT_GetConfigValue;
 168     QueryTable[2].Flags = 0;
 169     QueryTable[2].Name = L"DisableCcDetect";
 170     QueryTable[2].EntryContext = DisableCcDetect;
 171     QueryTable[2].DefaultType = REG_DWORD;
 172     QueryTable[2].DefaultData = DisableCcDetect;
 173     QueryTable[2].DefaultLength = sizeof(ULONG);
 174
 175     QueryTable[3].QueryRoutine = USBPORT_GetConfigValue;
 176     QueryTable[3].Flags = 0;
 177     QueryTable[3].Name = L"EnIdleEndpointSupport";
 178     QueryTable[3].EntryContext = IdleEpSupport;
 179     QueryTable[3].DefaultType = REG_DWORD;
 180     QueryTable[3].DefaultData = IdleEpSupport;
 181     QueryTable[3].DefaultLength = sizeof(ULONG);
 182
 183     QueryTable[4].QueryRoutine = USBPORT_GetConfigValue;
 184     QueryTable[4].Flags = 0;
 185     QueryTable[4].Name = L"EnIdleEndpointSupportEx";
 186     QueryTable[4].EntryContext = IdleEpSupportEx;
 187     QueryTable[4].DefaultType = REG_DWORD;
 188     QueryTable[4].DefaultData = IdleEpSupportEx;
 189     QueryTable[4].DefaultLength = sizeof(ULONG);
 190
 191     QueryTable[5].QueryRoutine = USBPORT_GetConfigValue;
 192     QueryTable[5].Flags = 0;
 193     QueryTable[5].Name = L"EnSoftRetry";
 194     QueryTable[5].EntryContext = SoftRetry;
 195     QueryTable[5].DefaultType = REG_DWORD;
 196     QueryTable[5].DefaultData = SoftRetry;
 197     QueryTable[5].DefaultLength = sizeof(ULONG);
 198
 199     return RtlQueryRegistryValues(RTL_REGISTRY_SERVICES,
 200                                   L"usb",
 201                                   QueryTable,
 202                                   NULL,
 203                                   NULL);
 204 }
 205
 206 NTSTATUS
 207 NTAPI
 208 USBPORT_IsCompanionController(IN PDEVICE_OBJECT DeviceObject,
 209                               IN BOOLEAN *IsCompanion)
 210 {
 211     PDEVICE_OBJECT HighestDevice;
 212     PIRP Irp;
 213     KEVENT Event;
 214     PIO_STACK_LOCATION IoStack;
 215     PCI_DEVICE_PRESENT_INTERFACE PciInterface = {0};
 216     PCI_DEVICE_PRESENCE_PARAMETERS Parameters   = {0};
 217     IO_STATUS_BLOCK IoStatusBlock;
 218     NTSTATUS Status;
 219     BOOLEAN IsPresent;
 220
 221     DPRINT("USBPORT_IsCompanionController: ... \n");
 222
 223     *IsCompanion = FALSE;
 224
 225     KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 226
 227     HighestDevice = IoGetAttachedDeviceReference(DeviceObject);
 228
 229     Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
 230                                        HighestDevice,
 231                                        NULL,
 232                                        0,
 233                                        NULL,
 234                                        &Event,
 235                                        &IoStatusBlock);
 236
 237     if (!Irp)
 238     {
 239         Status = STATUS_INSUFFICIENT_RESOURCES;
 240         ObDereferenceObject(HighestDevice);
 241         return Status;
 242     }
 243
 244     IoStack = IoGetNextIrpStackLocation(Irp);
 245
 246     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 247     Irp->IoStatus.Information = 0;
 248
 249     IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
 250
 251     IoStack->Parameters.QueryInterface.InterfaceType = &GUID_PCI_DEVICE_PRESENT_INTERFACE;
 252     IoStack->Parameters.QueryInterface.Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
 253     IoStack->Parameters.QueryInterface.Version = 1;
 254     IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)&PciInterface;
 255     IoStack->Parameters.QueryInterface.InterfaceSpecificData = 0;
 256
 257     Status = IoCallDriver(HighestDevice, Irp);
 258
 259     if (Status == STATUS_PENDING)
 260     {
 261         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 262         Status = IoStatusBlock.Status;
 263     }
 264
 265     if (!NT_SUCCESS(Status))
 266     {
 267         DPRINT1("USBPORT_IsCompanionController: query interface failed\\n");
 268         ObDereferenceObject(HighestDevice);
 269         return Status;
 270     }
 271
 272     DPRINT("USBPORT_IsCompanionController: query interface succeeded\n");
 273
 274     if (PciInterface.Size < sizeof(PCI_DEVICE_PRESENT_INTERFACE))
 275     {
 276         DPRINT1("USBPORT_IsCompanionController: old version\n");
 277         ObDereferenceObject(HighestDevice);
 278         return Status;
 279     }
 280
 281     Parameters.Size = sizeof(PCI_DEVICE_PRESENT_INTERFACE);
 282
 283     Parameters.BaseClass = PCI_CLASS_SERIAL_BUS_CTLR;
 284     Parameters.SubClass = PCI_SUBCLASS_SB_USB;
 285     Parameters.ProgIf = PCI_INTERFACE_USB_ID_EHCI;
 286
 287     Parameters.Flags = PCI_USE_LOCAL_BUS |
 288                        PCI_USE_LOCAL_DEVICE |
 289                        PCI_USE_CLASS_SUBCLASS |
 290                        PCI_USE_PROGIF;
 291
 292     IsPresent = (PciInterface.IsDevicePresentEx)(PciInterface.Context,
 293                                                  &Parameters);
 294
 295     if (IsPresent)
 296     {
 297         DPRINT("USBPORT_IsCompanionController: Present EHCI controller for FDO - %p\n",
 298                DeviceObject);
 299     }
 300     else
 301     {
 302         DPRINT("USBPORT_IsCompanionController: No EHCI controller for FDO - %p\n",
 303                DeviceObject);
 304     }
 305
 306     *IsCompanion = IsPresent;
 307
 308     (PciInterface.InterfaceDereference)(PciInterface.Context);
 309
 310     ObDereferenceObject(HighestDevice);
 311
 312     return Status;
 313 }
 314
 315 NTSTATUS
 316 NTAPI
 317 USBPORT_QueryPciBusInterface(IN PDEVICE_OBJECT FdoDevice)
 318 {
 319     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 320     PBUS_INTERFACE_STANDARD BusInterface;
 321     PIO_STACK_LOCATION IoStack;
 322     IO_STATUS_BLOCK IoStatusBlock;
 323     PDEVICE_OBJECT HighestDevice;
 324     KEVENT Event;
 325     PIRP Irp;
 326     NTSTATUS Status;
 327
 328     DPRINT("USBPORT_QueryPciBusInterface: ...  \n");
 329
 330     FdoExtension = FdoDevice->DeviceExtension;
 331     BusInterface = &FdoExtension->BusInterface;
 332
 333     RtlZeroMemory(BusInterface, sizeof(BUS_INTERFACE_STANDARD));
 334     KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 335     HighestDevice = IoGetAttachedDeviceReference(FdoDevice);
 336
 337     Irp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP,
 338                                        HighestDevice,
 339                                        NULL,
 340                                        0,
 341                                        NULL,
 342                                        &Event,
 343                                        &IoStatusBlock);
 344
 345     if (Irp)
 346     {
 347         IoStack = IoGetNextIrpStackLocation(Irp);
 348
 349         Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 350         Irp->IoStatus.Information = 0;
 351
 352         IoStack->MinorFunction = IRP_MN_QUERY_INTERFACE;
 353
 354         IoStack->Parameters.QueryInterface.InterfaceType = &GUID_BUS_INTERFACE_STANDARD;
 355         IoStack->Parameters.QueryInterface.Size = sizeof(BUS_INTERFACE_STANDARD);
 356         IoStack->Parameters.QueryInterface.Version = 1;
 357         IoStack->Parameters.QueryInterface.Interface = (PINTERFACE)BusInterface;
 358         IoStack->Parameters.QueryInterface.InterfaceSpecificData = 0;
 359
 360         Status = IoCallDriver(HighestDevice, Irp);
 361
 362         if (Status == STATUS_PENDING)
 363         {
 364             KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 365             Status = IoStatusBlock.Status;
 366         }
 367     }
 368     else
 369     {
 370         Status = STATUS_INSUFFICIENT_RESOURCES;
 371     }
 372
 373     ObDereferenceObject(HighestDevice);
 374
 375     DPRINT("USBPORT_QueryPciBusInterface: return Status - %x\n", Status);
 376
 377     return Status;
 378 }
 379
 380 NTSTATUS
 381 NTAPI
 382 USBPORT_QueryCapabilities(IN PDEVICE_OBJECT FdoDevice,
 383                           IN PDEVICE_CAPABILITIES Capabilities)
 384 {
 385     PUSBPORT_DEVICE_EXTENSION FdoExtention;
 386     PIRP Irp;
 387     NTSTATUS Status;
 388     PIO_STACK_LOCATION IoStack;
 389     KEVENT Event;
 390
 391     DPRINT("USBPORT_QueryCapabilities: ... \n");
 392
 393     FdoExtention = FdoDevice->DeviceExtension;
 394
 395     RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
 396
 397     Capabilities->Size     = sizeof(DEVICE_CAPABILITIES);
 398     Capabilities->Version  = 1;
 399     Capabilities->Address  = MAXULONG;
 400     Capabilities->UINumber = MAXULONG;
 401
 402     Irp = IoAllocateIrp(FdoExtention->CommonExtension.LowerDevice->StackSize,
 403                         FALSE);
 404
 405     if (!Irp)
 406     {
 407         DPRINT1("USBPORT_QueryCapabilities: No resources - IoAllocateIrp!\n");
 408         return STATUS_INSUFFICIENT_RESOURCES;
 409     }
 410
 411     IoStack = IoGetCurrentIrpStackLocation(Irp);
 412     Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
 413
 414     IoStack = IoGetNextIrpStackLocation(Irp);
 415     IoStack->MajorFunction = IRP_MJ_PNP;
 416     IoStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
 417
 418     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 419
 420     IoSetCompletionRoutine(Irp,
 421                           USBPORT_FdoStartCompletion,
 422                           &Event,
 423                           TRUE,
 424                           TRUE,
 425                           TRUE);
 426
 427     IoStack->Parameters.DeviceCapabilities.Capabilities = Capabilities;
 428
 429     Status = IoCallDriver(FdoExtention->CommonExtension.LowerDevice, Irp);
 430
 431     if (Status == STATUS_PENDING)
 432     {
 433         KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
 434         Status = Irp->IoStatus.Status;
 435     }
 436
 437     if (NT_SUCCESS(Status) && Capabilities)
 438     {
 439         USBPORT_DumpingCapabilities(Capabilities);
 440     }
 441
 442     IoFreeIrp(Irp);
 443
 444     return Status;
 445 }
 446
 447 NTSTATUS
 448 NTAPI
 449 USBPORT_CreateLegacySymbolicLink(IN PDEVICE_OBJECT FdoDevice)
 450 {
 451     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 452     WCHAR CharName[255] = {0};
 453     WCHAR CharDosName[255] = {0};
 454     UNICODE_STRING DeviceName;
 455     NTSTATUS Status;
 456
 457     FdoExtension = FdoDevice->DeviceExtension;
 458
 459     RtlStringCbPrintfW(CharName,
 460                        sizeof(CharName),
 461                        L"\\Device\\USBFDO-%d",
 462                        FdoExtension->FdoNameNumber);
 463
 464     RtlInitUnicodeString(&DeviceName, CharName);
 465
 466     RtlStringCbPrintfW(CharDosName,
 467                        sizeof(CharDosName),
 468                        L"\\DosDevices\\HCD%d",
 469                        FdoExtension->FdoNameNumber);
 470
 471     RtlInitUnicodeString(&FdoExtension->DosDeviceSymbolicName, CharDosName);
 472
 473     DPRINT("USBPORT_CreateLegacySymbolicLink: DeviceName - %wZ, DosSymbolicName - %wZ\n",
 474            &DeviceName,
 475            &FdoExtension->DosDeviceSymbolicName);
 476
 477     Status = IoCreateSymbolicLink(&FdoExtension->DosDeviceSymbolicName,
 478                                   &DeviceName);
 479
 480     if (NT_SUCCESS(Status))
 481     {
 482         FdoExtension->Flags |= USBPORT_FLAG_DOS_SYMBOLIC_NAME;
 483     }
 484
 485     return Status;
 486 }
 487
 488 NTSTATUS
 489 NTAPI
 490 USBPORT_StopDevice(IN PDEVICE_OBJECT FdoDevice)
 491 {
 492     DPRINT1("USBPORT_StopDevice: UNIMPLEMENTED. FIXME\n");
 493     DbgBreakPoint();
 494     return STATUS_SUCCESS;
 495 }
 496
 497 NTSTATUS
 498 NTAPI
 499 USBPORT_StartDevice(IN PDEVICE_OBJECT FdoDevice,
 500                     IN PUSBPORT_RESOURCES UsbPortResources)
 501 {
 502     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 503     PUSBPORT_REGISTRATION_PACKET Packet;
 504     NTSTATUS Status;
 505     PCI_COMMON_CONFIG PciConfig;
 506     ULONG BytesRead;
 507     DEVICE_DESCRIPTION DeviceDescription;
 508     PDMA_ADAPTER DmaAdapter = NULL;
 509     ULONG MiniPortStatus;
 510     PUSBPORT_COMMON_BUFFER_HEADER HeaderBuffer;
 511     ULONG ResultLength;
 512     ULONG DisableSelectiveSuspend = 0;
 513     ULONG DisableCcDetect = 0;
 514     ULONG IdleEpSupport = 0;
 515     ULONG IdleEpSupportEx = 0;
 516     ULONG SoftRetry = 0;
 517     ULONG Limit2GB = 0;
 518     ULONG TotalBusBandwidth = 0;
 519     BOOLEAN IsCompanion = FALSE;
 520     ULONG LegacyBIOS;
 521     ULONG MiniportFlags;
 522     ULONG ix;
 523
 524     DPRINT("USBPORT_StartDevice: FdoDevice - %p, UsbPortResources - %p\n",
 525            FdoDevice,
 526            UsbPortResources);
 527
 528     FdoExtension = FdoDevice->DeviceExtension;
 529     Packet = &FdoExtension->MiniPortInterface->Packet;
 530
 531     Status = USBPORT_QueryPciBusInterface(FdoDevice);
 532     if (!NT_SUCCESS(Status))
 533         goto ExitWithError;
 534
 535     BytesRead = (*FdoExtension->BusInterface.GetBusData)(FdoExtension->BusInterface.Context,
 536                                                          PCI_WHICHSPACE_CONFIG,
 537                                                          &PciConfig,
 538                                                          0,
 539                                                          PCI_COMMON_HDR_LENGTH);
 540
 541     if (BytesRead != PCI_COMMON_HDR_LENGTH)
 542     {
 543         DPRINT1("USBPORT_StartDevice: Failed to get pci config information!\n");
 544         goto ExitWithError;
 545     }
 546
 547     FdoExtension->VendorID = PciConfig.VendorID;
 548     FdoExtension->DeviceID = PciConfig.DeviceID;
 549     FdoExtension->RevisionID = PciConfig.RevisionID;
 550     FdoExtension->ProgIf = PciConfig.ProgIf;
 551     FdoExtension->SubClass = PciConfig.SubClass;
 552     FdoExtension->BaseClass = PciConfig.BaseClass;
 553
 554     RtlZeroMemory(&DeviceDescription, sizeof(DeviceDescription));
 555
 556     DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
 557     DeviceDescription.Master = TRUE;
 558     DeviceDescription.ScatterGather = TRUE;
 559     DeviceDescription.Dma32BitAddresses = TRUE;
 560     DeviceDescription.InterfaceType = PCIBus;
 561     DeviceDescription.DmaWidth = Width32Bits;
 562     DeviceDescription.DmaSpeed = Compatible;
 563     DeviceDescription.MaximumLength = MAXULONG;
 564
 565     DmaAdapter = IoGetDmaAdapter(FdoExtension->CommonExtension.LowerPdoDevice,
 566                                  &DeviceDescription,
 567                                  &FdoExtension->NumberMapRegs);
 568
 569     FdoExtension->DmaAdapter = DmaAdapter;
 570
 571     if (!DmaAdapter)
 572     {
 573         DPRINT1("USBPORT_StartDevice: Failed to get DmaAdapter!\n");
 574         Status = STATUS_INSUFFICIENT_RESOURCES;
 575         goto ExitWithError;
 576     }
 577
 578     Status = USBPORT_CreateWorkerThread(FdoDevice);
 579     if (!NT_SUCCESS(Status))
 580         goto ExitWithError;
 581
 582     Status = USBPORT_QueryCapabilities(FdoDevice, &FdoExtension->Capabilities);
 583     if (!NT_SUCCESS(Status))
 584         goto ExitWithError;
 585
 586     FdoExtension->PciDeviceNumber = FdoExtension->Capabilities.Address >> 16;
 587     FdoExtension->PciFunctionNumber = FdoExtension->Capabilities.Address & 0xFFFF;
 588
 589     Status = IoGetDeviceProperty(FdoExtension->CommonExtension.LowerPdoDevice,
 590                                  DevicePropertyBusNumber,
 591                                  sizeof(ULONG),
 592                                  &FdoExtension->BusNumber,
 593                                  &ResultLength);
 594
 595     if (!NT_SUCCESS(Status))
 596         goto ExitWithError;
 597
 598     KeInitializeSpinLock(&FdoExtension->EndpointListSpinLock);
 599     KeInitializeSpinLock(&FdoExtension->EpStateChangeSpinLock);
 600     KeInitializeSpinLock(&FdoExtension->EndpointClosedSpinLock);
 601     KeInitializeSpinLock(&FdoExtension->DeviceHandleSpinLock);
 602     KeInitializeSpinLock(&FdoExtension->IdleIoCsqSpinLock);
 603     KeInitializeSpinLock(&FdoExtension->BadRequestIoCsqSpinLock);
 604     KeInitializeSpinLock(&FdoExtension->MapTransferSpinLock);
 605     KeInitializeSpinLock(&FdoExtension->FlushTransferSpinLock);
 606     KeInitializeSpinLock(&FdoExtension->FlushPendingTransferSpinLock);
 607     KeInitializeSpinLock(&FdoExtension->DoneTransferSpinLock);
 608     KeInitializeSpinLock(&FdoExtension->WorkerThreadEventSpinLock);
 609     KeInitializeSpinLock(&FdoExtension->MiniportSpinLock);
 610     KeInitializeSpinLock(&FdoExtension->TimerFlagsSpinLock);
 611     KeInitializeSpinLock(&FdoExtension->PowerWakeSpinLock);
 612     KeInitializeSpinLock(&FdoExtension->SetPowerD0SpinLock);
 613     KeInitializeSpinLock(&FdoExtension->RootHubCallbackSpinLock);
 614     KeInitializeSpinLock(&FdoExtension->TtSpinLock);
 615
 616     KeInitializeDpc(&FdoExtension->IsrDpc, USBPORT_IsrDpc, FdoDevice);
 617
 618     KeInitializeDpc(&FdoExtension->TransferFlushDpc,
 619                     USBPORT_TransferFlushDpc,
 620                     FdoDevice);
 621
 622     KeInitializeDpc(&FdoExtension->WorkerRequestDpc,
 623                     USBPORT_WorkerRequestDpc,
 624                     FdoDevice);
 625
 626     KeInitializeDpc(&FdoExtension->HcWakeDpc,
 627                     USBPORT_HcWakeDpc,
 628                     FdoDevice);
 629
 630     IoCsqInitialize(&FdoExtension->IdleIoCsq,
 631                     USBPORT_InsertIdleIrp,
 632                     USBPORT_RemoveIdleIrp,
 633                     USBPORT_PeekNextIdleIrp,
 634                     USBPORT_AcquireIdleLock,
 635                     USBPORT_ReleaseIdleLock,
 636                     USBPORT_CompleteCanceledIdleIrp);
 637
 638     IoCsqInitialize(&FdoExtension->BadRequestIoCsq,
 639                     USBPORT_InsertBadRequest,
 640                     USBPORT_RemoveBadRequest,
 641                     USBPORT_PeekNextBadRequest,
 642                     USBPORT_AcquireBadRequestLock,
 643                     USBPORT_ReleaseBadRequestLock,
 644                     USBPORT_CompleteCanceledBadRequest);
 645
 646     FdoExtension->IsrDpcCounter = -1;
 647     FdoExtension->IsrDpcHandlerCounter = -1;
 648     FdoExtension->IdleLockCounter = -1;
 649     FdoExtension->BadRequestLockCounter = -1;
 650     FdoExtension->ChirpRootPortLock = -1;
 651
 652     FdoExtension->RHInitCallBackLock = 0;
 653
 654     FdoExtension->UsbAddressBitMap[0] = 1;
 655     FdoExtension->UsbAddressBitMap[1] = 0;
 656     FdoExtension->UsbAddressBitMap[2] = 0;
 657     FdoExtension->UsbAddressBitMap[3] = 0;
 658
 659     USBPORT_GetDefaultBIOSx(FdoDevice,
 660                             &FdoExtension->UsbBIOSx,
 661                             &DisableSelectiveSuspend,
 662                             &DisableCcDetect,
 663                             &IdleEpSupport,
 664                             &IdleEpSupportEx,
 665                             &SoftRetry);
 666
 667     if (DisableSelectiveSuspend)
 668         FdoExtension->Flags |= USBPORT_FLAG_BIOS_DISABLE_SS;
 669
 670     if (!DisableSelectiveSuspend &&
 671         USBPORT_IsSelectiveSuspendEnabled(FdoDevice))
 672     {
 673         FdoExtension->Flags |= USBPORT_FLAG_SELECTIVE_SUSPEND;
 674     }
 675
 676     MiniportFlags = Packet->MiniPortFlags;
 677
 678     if (MiniportFlags & USB_MINIPORT_FLAGS_POLLING)
 679         FdoExtension->Flags |= USBPORT_FLAG_HC_POLLING;
 680
 681     if (MiniportFlags & USB_MINIPORT_FLAGS_WAKE_SUPPORT)
 682         FdoExtension->Flags |= USBPORT_FLAG_HC_WAKE_SUPPORT;
 683
 684     if (MiniportFlags & USB_MINIPORT_FLAGS_DISABLE_SS)
 685         FdoExtension->Flags = (FdoExtension->Flags & ~USBPORT_FLAG_SELECTIVE_SUSPEND) |
 686                               USBPORT_FLAG_BIOS_DISABLE_SS;
 687
 688     USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
 689                                 TRUE,
 690                                 REG_DWORD,
 691                                 L"EnIdleEndpointSupport",
 692                                 &IdleEpSupport,
 693                                 sizeof(IdleEpSupport));
 694
 695     USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
 696                                 TRUE,
 697                                 REG_DWORD,
 698                                 L"EnIdleEndpointSupportEx",
 699                                 &IdleEpSupportEx,
 700                                 sizeof(IdleEpSupportEx));
 701
 702     USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
 703                                 TRUE,
 704                                 REG_DWORD,
 705                                 L"EnSoftRetry",
 706                                 &SoftRetry,
 707                                 sizeof(SoftRetry));
 708
 709     USBPORT_GetRegistryKeyValueFullInfo(FdoDevice,
 710                                         FdoExtension->CommonExtension.LowerPdoDevice,
 711                                         TRUE,
 712                                         L"CommonBuffer2GBLimit",
 713                                         sizeof(L"CommonBuffer2GBLimit"),
 714                                         &Limit2GB,
 715                                         sizeof(Limit2GB));
 716
 717     FdoExtension->CommonBufferLimit = (Limit2GB != 0);
 718
 719     if (FdoExtension->BaseClass == PCI_CLASS_SERIAL_BUS_CTLR &&
 720         FdoExtension->SubClass == PCI_SUBCLASS_SB_USB  &&
 721         FdoExtension->ProgIf < PCI_INTERFACE_USB_ID_EHCI)
 722     {
 723         Status = USBPORT_IsCompanionController(FdoDevice, &IsCompanion);
 724
 725         if (!NT_SUCCESS(Status))
 726         {
 727             if (IsCompanion)
 728             {
 729                 FdoExtension->Flags |= USBPORT_FLAG_COMPANION_HC;
 730             }
 731             else
 732             {
 733                 FdoExtension->Flags &= ~USBPORT_FLAG_COMPANION_HC;
 734             }
 735         }
 736     }
 737
 738     if (DisableCcDetect)
 739     {
 740         FdoExtension->Flags &= ~USBPORT_FLAG_COMPANION_HC;
 741     }
 742
 743     TotalBusBandwidth = Packet->MiniPortBusBandwidth;
 744     FdoExtension->TotalBusBandwidth = TotalBusBandwidth;
 745
 746     USBPORT_GetRegistryKeyValueFullInfo(FdoDevice,
 747                                         FdoExtension->CommonExtension.LowerPdoDevice,
 748                                         TRUE,
 749                                         L"TotalBusBandwidth",
 750                                         sizeof(L"TotalBusBandwidth"),
 751                                         &TotalBusBandwidth,
 752                                         sizeof(TotalBusBandwidth));
 753
 754     if (TotalBusBandwidth != FdoExtension->TotalBusBandwidth)
 755     {
 756         FdoExtension->TotalBusBandwidth = TotalBusBandwidth;
 757     }
 758
 759     for (ix = 0; ix < USB2_FRAMES; ix++)
 760     {
 761         FdoExtension->Bandwidth[ix] = FdoExtension->TotalBusBandwidth -
 762                                       FdoExtension->TotalBusBandwidth / 10;
 763     }
 764
 765     FdoExtension->ActiveIrpTable = ExAllocatePoolWithTag(NonPagedPool,
 766                                                          sizeof(USBPORT_IRP_TABLE),
 767                                                          USB_PORT_TAG);
 768
 769     if (!FdoExtension->ActiveIrpTable)
 770     {
 771         DPRINT1("USBPORT_StartDevice: Allocate ActiveIrpTable failed!\n");
 772         goto ExitWithError;
 773     }
 774
 775     RtlZeroMemory(FdoExtension->ActiveIrpTable, sizeof(USBPORT_IRP_TABLE));
 776
 777     FdoExtension->PendingIrpTable = ExAllocatePoolWithTag(NonPagedPool,
 778                                                           sizeof(USBPORT_IRP_TABLE),
 779                                                           USB_PORT_TAG);
 780
 781     if (!FdoExtension->PendingIrpTable)
 782     {
 783         DPRINT1("USBPORT_StartDevice: Allocate PendingIrpTable failed!\n");
 784         goto ExitWithError;
 785     }
 786
 787     RtlZeroMemory(FdoExtension->PendingIrpTable, sizeof(USBPORT_IRP_TABLE));
 788
 789     Status = IoConnectInterrupt(&FdoExtension->InterruptObject,
 790                                 USBPORT_InterruptService,
 791                                 (PVOID)FdoDevice,
 792                                 0,
 793                                 UsbPortResources->InterruptVector,
 794                                 UsbPortResources->InterruptLevel,
 795                                 UsbPortResources->InterruptLevel,
 796                                 UsbPortResources->InterruptMode,
 797                                 UsbPortResources->ShareVector,
 798                                 UsbPortResources->InterruptAffinity,
 799                                 0);
 800
 801
 802     if (!NT_SUCCESS(Status))
 803     {
 804         DPRINT1("USBPORT_StartDevice: IoConnectInterrupt failed!\n");
 805         goto ExitWithError;
 806     }
 807
 808     FdoExtension->Flags &= ~USBPORT_FLAG_INT_CONNECTED;
 809
 810     if (Packet->MiniPortExtensionSize)
 811     {
 812         RtlZeroMemory(FdoExtension->MiniPortExt, Packet->MiniPortExtensionSize);
 813     }
 814
 815     if (Packet->MiniPortResourcesSize)
 816     {
 817         HeaderBuffer = USBPORT_AllocateCommonBuffer(FdoDevice,
 818                                                     Packet->MiniPortResourcesSize);
 819
 820         if (!HeaderBuffer)
 821         {
 822             DPRINT1("USBPORT_StartDevice: Failed to AllocateCommonBuffer!\n");
 823             Status = STATUS_INSUFFICIENT_RESOURCES;
 824             goto ExitWithError;
 825         }
 826
 827         UsbPortResources->StartVA = HeaderBuffer->VirtualAddress;
 828         UsbPortResources->StartPA = HeaderBuffer->PhysicalAddress;
 829
 830         FdoExtension->MiniPortCommonBuffer = HeaderBuffer;
 831     }
 832     else
 833     {
 834         FdoExtension->MiniPortCommonBuffer = NULL;
 835     }
 836
 837     MiniPortStatus = Packet->StartController(FdoExtension->MiniPortExt,
 838                                              UsbPortResources);
 839
 840     if (UsbPortResources->LegacySupport)
 841     {
 842         FdoExtension->Flags |= USBPORT_FLAG_LEGACY_SUPPORT;
 843         LegacyBIOS = 1;
 844     }
 845     else
 846     {
 847         LegacyBIOS = 0;
 848     }
 849
 850     USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
 851                                 FALSE,
 852                                 REG_DWORD,
 853                                 L"DetectedLegacyBIOS",
 854                                 &LegacyBIOS,
 855                                 sizeof(LegacyBIOS));
 856
 857     if (MiniPortStatus)
 858     {
 859         DPRINT1("USBPORT_StartDevice: Failed to Start MiniPort. MiniPortStatus - %x\n",
 860                 MiniPortStatus);
 861
 862         if (FdoExtension->Flags & USBPORT_FLAG_INT_CONNECTED)
 863         {
 864             IoDisconnectInterrupt(FdoExtension->InterruptObject);
 865             FdoExtension->Flags &= ~USBPORT_FLAG_INT_CONNECTED;
 866         }
 867
 868         if (FdoExtension->MiniPortCommonBuffer)
 869         {
 870             USBPORT_FreeCommonBuffer(FdoDevice, FdoExtension->MiniPortCommonBuffer);
 871             FdoExtension->MiniPortCommonBuffer = NULL;
 872         }
 873
 874         goto ExitWithError;
 875     }
 876     else
 877     {
 878         FdoExtension->MiniPortFlags |= USBPORT_MPFLAG_INTERRUPTS_ENABLED;
 879         USBPORT_MiniportInterrupts(FdoDevice, TRUE);
 880     }
 881
 882     FdoExtension->TimerValue = 500;
 883     USBPORT_StartTimer((PVOID)FdoDevice, 500);
 884
 885     Status = USBPORT_RegisterDeviceInterface(FdoExtension->CommonExtension.LowerPdoDevice,
 886                                              FdoDevice,
 887                                              &GUID_DEVINTERFACE_USB_HOST_CONTROLLER,
 888                                              TRUE);
 889
 890     if (!NT_SUCCESS(Status))
 891     {
 892         DPRINT1("USBPORT_StartDevice: RegisterDeviceInterface failed!\n");
 893         goto ExitWithError;
 894     }
 895
 896     USBPORT_CreateLegacySymbolicLink(FdoDevice);
 897
 898     FdoExtension->Flags |= USBPORT_FLAG_HC_STARTED;
 899
 900     DPRINT("USBPORT_StartDevice: Exit Status - %p\n", Status);
 901     return Status;
 902
 903 ExitWithError:
 904     USBPORT_StopDevice(FdoDevice);
 905
 906     DPRINT1("USBPORT_StartDevice: ExitWithError Status - %lx\n", Status);
 907     return Status;
 908 }
 909
 910 NTSTATUS
 911 NTAPI
 912 USBPORT_ParseResources(IN PDEVICE_OBJECT FdoDevice,
 913                        IN PIRP Irp,
 914                        IN PUSBPORT_RESOURCES UsbPortResources)
 915 {
 916     PCM_RESOURCE_LIST AllocatedResourcesTranslated;
 917     PCM_PARTIAL_RESOURCE_LIST ResourceList;
 918     PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
 919     PCM_PARTIAL_RESOURCE_DESCRIPTOR PortDescriptor = NULL;
 920     PCM_PARTIAL_RESOURCE_DESCRIPTOR MemoryDescriptor = NULL;
 921     PCM_PARTIAL_RESOURCE_DESCRIPTOR InterruptDescriptor = NULL;
 922     PIO_STACK_LOCATION IoStack;
 923     ULONG ix;
 924     NTSTATUS Status = STATUS_SUCCESS;
 925
 926     DPRINT("USBPORT_ParseResources: ... \n");
 927
 928     IoStack = IoGetCurrentIrpStackLocation(Irp);
 929     AllocatedResourcesTranslated = IoStack->Parameters.StartDevice.AllocatedResourcesTranslated;
 930
 931     if (AllocatedResourcesTranslated)
 932     {
 933         RtlZeroMemory(UsbPortResources, sizeof(USBPORT_RESOURCES));
 934
 935         ResourceList = &AllocatedResourcesTranslated->List[0].PartialResourceList;
 936
 937         PartialDescriptor = &ResourceList->PartialDescriptors[0];
 938
 939         for (ix = 0; ix < ResourceList->Count; ++ix)
 940         {
 941             if (PartialDescriptor->Type == CmResourceTypePort)
 942             {
 943                 if (!PortDescriptor)
 944                     PortDescriptor = PartialDescriptor;
 945             }
 946             else if (PartialDescriptor->Type == CmResourceTypeInterrupt)
 947             {
 948                 if (!InterruptDescriptor)
 949                     InterruptDescriptor = PartialDescriptor;
 950             }
 951             else if (PartialDescriptor->Type == CmResourceTypeMemory)
 952             {
 953                 if (!MemoryDescriptor)
 954                     MemoryDescriptor = PartialDescriptor;
 955             }
 956
 957             PartialDescriptor += 1;
 958         }
 959
 960         if (PortDescriptor)
 961         {
 962             if (PortDescriptor->Flags & CM_RESOURCE_PORT_IO)
 963             {
 964                 UsbPortResources->ResourceBase = (PVOID)(ULONG_PTR)PortDescriptor->u.Port.Start.QuadPart;
 965             }
 966             else
 967             {
 968                 UsbPortResources->ResourceBase = MmMapIoSpace(PortDescriptor->u.Port.Start,
 969                                                               PortDescriptor->u.Port.Length,
 970                                                               0);
 971             }
 972
 973             UsbPortResources->IoSpaceLength = PortDescriptor->u.Port.Length;
 974
 975             if (UsbPortResources->ResourceBase)
 976             {
 977                 UsbPortResources->ResourcesTypes |= USBPORT_RESOURCES_PORT;
 978             }
 979             else
 980             {
 981                 Status = STATUS_NONE_MAPPED;
 982             }
 983         }
 984
 985         if (MemoryDescriptor && NT_SUCCESS(Status))
 986         {
 987             UsbPortResources->IoSpaceLength = MemoryDescriptor->u.Memory.Length;
 988
 989             UsbPortResources->ResourceBase = MmMapIoSpace(MemoryDescriptor->u.Memory.Start,
 990                                                           MemoryDescriptor->u.Memory.Length,
 991                                                           0);
 992
 993             if (UsbPortResources->ResourceBase)
 994             {
 995                 UsbPortResources->ResourcesTypes |= USBPORT_RESOURCES_MEMORY;
 996             }
 997             else
 998             {
 999                 Status = STATUS_NONE_MAPPED;
1000             }
1001         }
1002
1003         if (InterruptDescriptor && NT_SUCCESS(Status))
1004         {
1005             UsbPortResources->ResourcesTypes |= USBPORT_RESOURCES_INTERRUPT;
1006
1007             UsbPortResources->InterruptVector = InterruptDescriptor->u.Interrupt.Vector;
1008             UsbPortResources->InterruptLevel = InterruptDescriptor->u.Interrupt.Level;
1009             UsbPortResources->InterruptAffinity = InterruptDescriptor->u.Interrupt.Affinity;
1010
1011             UsbPortResources->ShareVector = InterruptDescriptor->ShareDisposition ==
1012                                             CmResourceShareShared;
1013
1014             UsbPortResources->InterruptMode = InterruptDescriptor->Flags ==
1015                                               CM_RESOURCE_INTERRUPT_LATCHED;
1016         }
1017     }
1018     else
1019     {
1020         Status = STATUS_NONE_MAPPED;
1021     }
1022
1023     return Status;
1024 }
1025
1026 NTSTATUS
1027 NTAPI
1028 USBPORT_CreatePdo(IN PDEVICE_OBJECT FdoDevice,
1029                   OUT PDEVICE_OBJECT *RootHubPdo)
1030 {
1031     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1032     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
1033     UNICODE_STRING DeviceName;
1034     ULONG DeviceNumber = 0;
1035     PDEVICE_OBJECT DeviceObject = NULL;
1036     WCHAR CharDeviceName[64];
1037     NTSTATUS Status = STATUS_SUCCESS;
1038
1039     DPRINT("USBPORT_CreatePdo: FdoDevice - %p, RootHubPdo - %p\n",
1040            FdoDevice,
1041            RootHubPdo);
1042
1043     FdoExtension = FdoDevice->DeviceExtension;
1044
1045     do
1046     {
1047         RtlStringCbPrintfW(CharDeviceName,
1048                            sizeof(CharDeviceName),
1049                            L"\\Device\\USBPDO-%d",
1050                            DeviceNumber);
1051
1052         RtlInitUnicodeString(&DeviceName, CharDeviceName);
1053
1054         DPRINT("USBPORT_CreatePdo: DeviceName - %wZ\n", &DeviceName);
1055
1056         Status = IoCreateDevice(FdoExtension->MiniPortInterface->DriverObject,
1057                                 sizeof(USBPORT_RHDEVICE_EXTENSION),
1058                                 &DeviceName,
1059                                 FILE_DEVICE_BUS_EXTENDER,
1060                                 0,
1061                                 FALSE,
1062                                 &DeviceObject);
1063
1064         ++DeviceNumber;
1065     }
1066     while (Status == STATUS_OBJECT_NAME_COLLISION);
1067
1068     if (!NT_SUCCESS(Status))
1069     {
1070         *RootHubPdo = NULL;
1071         DPRINT1("USBPORT_CreatePdo: Filed create HubPdo!\n");
1072         return Status;
1073     }
1074
1075     if (DeviceObject)
1076     {
1077         PdoExtension = DeviceObject->DeviceExtension;
1078
1079         RtlZeroMemory(PdoExtension, sizeof(USBPORT_RHDEVICE_EXTENSION));
1080
1081         PdoExtension->CommonExtension.SelfDevice = DeviceObject;
1082         PdoExtension->CommonExtension.IsPDO = TRUE;
1083
1084         PdoExtension->FdoDevice = FdoDevice;
1085         PdoExtension->PdoNameNumber = DeviceNumber;
1086
1087         USBPORT_AdjustDeviceCapabilities(FdoDevice, DeviceObject);
1088
1089         DeviceObject->StackSize = FdoDevice->StackSize;
1090
1091         DeviceObject->Flags |= DO_POWER_PAGABLE;
1092         DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
1093     }
1094     else
1095     {
1096         Status = STATUS_UNSUCCESSFUL;
1097     }
1098
1099     if (!NT_SUCCESS(Status))
1100         *RootHubPdo = NULL;
1101     else
1102         *RootHubPdo = DeviceObject;
1103
1104     DPRINT("USBPORT_CreatePdo: HubPdo - %p\n", DeviceObject);
1105     return Status;
1106 }
1107
1108 NTSTATUS
1109 NTAPI
1110 USBPORT_FdoPnP(IN PDEVICE_OBJECT FdoDevice,
1111                IN PIRP Irp)
1112 {
1113     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1114     PUSBPORT_COMMON_DEVICE_EXTENSION FdoCommonExtension;
1115     PUSBPORT_REGISTRATION_PACKET Packet;
1116     PUSBPORT_RESOURCES UsbPortResources;
1117     PIO_STACK_LOCATION IoStack;
1118     UCHAR Minor;
1119     KEVENT Event;
1120     NTSTATUS Status;
1121     DEVICE_RELATION_TYPE RelationType;
1122     PDEVICE_RELATIONS DeviceRelations;
1123     PDEVICE_OBJECT RootHubPdo;
1124
1125     FdoExtension = FdoDevice->DeviceExtension;
1126     FdoCommonExtension = &FdoExtension->CommonExtension;
1127     UsbPortResources = &FdoExtension->UsbPortResources;
1128     Packet = &FdoExtension->MiniPortInterface->Packet;
1129
1130     IoStack = IoGetCurrentIrpStackLocation(Irp);
1131     Minor = IoStack->MinorFunction;
1132
1133     DPRINT("USBPORT_FdoPnP: FdoDevice - %p, Minor - %x\n", FdoDevice, Minor);
1134
1135     RelationType = IoStack->Parameters.QueryDeviceRelations.Type;
1136
1137     switch (Minor)
1138     {
1139         case IRP_MN_START_DEVICE:
1140             DPRINT("IRP_MN_START_DEVICE\n");
1141
1142             KeInitializeEvent(&Event, NotificationEvent, FALSE);
1143
1144             IoCopyCurrentIrpStackLocationToNext(Irp);
1145
1146             IoSetCompletionRoutine(Irp,
1147                                    USBPORT_FdoStartCompletion,
1148                                    &Event,
1149                                    TRUE,
1150                                    TRUE,
1151                                    TRUE);
1152
1153             Status = IoCallDriver(FdoCommonExtension->LowerDevice,
1154                                   Irp);
1155
1156             if (Status == STATUS_PENDING)
1157             {
1158                 KeWaitForSingleObject(&Event,
1159                                       Suspended,
1160                                       KernelMode,
1161                                       FALSE,
1162                                       NULL);
1163
1164                 Status = Irp->IoStatus.Status;
1165             }
1166
1167             if (!NT_SUCCESS(Status))
1168             {
1169                 goto Exit;
1170             }
1171
1172             Status = USBPORT_ParseResources(FdoDevice,
1173                                             Irp,
1174                                             UsbPortResources);
1175
1176             if (!NT_SUCCESS(Status))
1177             {
1178                 FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STOPPED;
1179                 goto Exit;
1180             }
1181
1182             Status = USBPORT_StartDevice(FdoDevice, UsbPortResources);
1183
1184             if (!NT_SUCCESS(Status))
1185             {
1186                 FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STOPPED;
1187                 goto Exit;
1188             }
1189
1190             FdoCommonExtension->PnpStateFlags &= ~USBPORT_PNP_STATE_NOT_INIT;
1191             FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_STARTED;
1192
1193             FdoCommonExtension->DevicePowerState = PowerDeviceD0;
1194
1195             if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
1196             {
1197                 USBPORT_AddUSB2Fdo(FdoDevice);
1198             }
1199             else
1200             {
1201                 USBPORT_AddUSB1Fdo(FdoDevice);
1202             }
1203
1204 Exit:
1205             Irp->IoStatus.Status = Status;
1206             IoCompleteRequest(Irp, IO_NO_INCREMENT);
1207             return Status;
1208
1209         case IRP_MN_QUERY_REMOVE_DEVICE:
1210             DPRINT("IRP_MN_QUERY_REMOVE_DEVICE\n");
1211             if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
1212             {
1213                 DPRINT1("USBPORT_FdoPnP: Haction registry write FIXME\n");
1214             }
1215
1216             Irp->IoStatus.Status = STATUS_SUCCESS;
1217             goto ForwardIrp;
1218
1219         case IRP_MN_REMOVE_DEVICE:
1220             DPRINT("USBPORT_FdoPnP: IRP_MN_REMOVE_DEVICE\n");
1221             FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_FAILED;
1222
1223             if (FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_STARTED &&
1224                !(FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_NOT_INIT))
1225             {
1226                 DPRINT1("USBPORT_FdoPnP: stop fdo FIXME\n");
1227                 FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_NOT_INIT;
1228             }
1229
1230             Irp->IoStatus.Status = STATUS_SUCCESS;
1231             IoSkipCurrentIrpStackLocation(Irp);
1232             Status = IoCallDriver(FdoCommonExtension->LowerDevice, Irp);
1233
1234             IoDetachDevice(FdoCommonExtension->LowerDevice);
1235
1236             RootHubPdo = FdoExtension->RootHubPdo;
1237
1238             IoDeleteDevice(FdoDevice);
1239
1240             if (RootHubPdo)
1241             {
1242                 IoDeleteDevice(RootHubPdo);
1243             }
1244
1245             return Status;
1246
1247         case IRP_MN_CANCEL_REMOVE_DEVICE:
1248             DPRINT("IRP_MN_CANCEL_REMOVE_DEVICE\n");
1249             Irp->IoStatus.Status = STATUS_SUCCESS;
1250             goto ForwardIrp;
1251
1252         case IRP_MN_STOP_DEVICE:
1253             DPRINT("IRP_MN_STOP_DEVICE\n");
1254             if (FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_STARTED)
1255             {
1256                 DPRINT1("USBPORT_FdoPnP: stop fdo FIXME\n");
1257
1258                 FdoCommonExtension->PnpStateFlags &= ~USBPORT_PNP_STATE_STARTED;
1259                 FdoCommonExtension->PnpStateFlags |= USBPORT_PNP_STATE_NOT_INIT;
1260             }
1261
1262             Irp->IoStatus.Status = STATUS_SUCCESS;
1263             goto ForwardIrp;
1264
1265         case IRP_MN_QUERY_STOP_DEVICE:
1266             DPRINT("IRP_MN_QUERY_STOP_DEVICE\n");
1267             Irp->IoStatus.Status = STATUS_SUCCESS;
1268             goto ForwardIrp;
1269
1270         case IRP_MN_CANCEL_STOP_DEVICE:
1271             DPRINT("IRP_MN_CANCEL_STOP_DEVICE\n");
1272             Irp->IoStatus.Status = STATUS_SUCCESS;
1273             goto ForwardIrp;
1274
1275         case IRP_MN_QUERY_DEVICE_RELATIONS:
1276             DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS\n");
1277             if (RelationType == BusRelations)
1278             {
1279                 DeviceRelations = ExAllocatePoolWithTag(PagedPool,
1280                                                         sizeof(DEVICE_RELATIONS),
1281                                                         USB_PORT_TAG);
1282
1283                 if (!DeviceRelations)
1284                 {
1285                     Status = STATUS_INSUFFICIENT_RESOURCES;
1286                     Irp->IoStatus.Status = Status;
1287                     IoCompleteRequest(Irp, IO_NO_INCREMENT);
1288                     return Status;
1289                 }
1290
1291                 DeviceRelations->Count = 0;
1292                 DeviceRelations->Objects[0] = NULL;
1293
1294                 if (!FdoExtension->RootHubPdo)
1295                 {
1296                     Status = USBPORT_CreatePdo(FdoDevice,
1297                                                &FdoExtension->RootHubPdo);
1298
1299                     if (!NT_SUCCESS(Status))
1300                     {
1301                         ExFreePoolWithTag(DeviceRelations, USB_PORT_TAG);
1302                         goto ForwardIrp;
1303                     }
1304                 }
1305                 else
1306                 {
1307                     Status = STATUS_SUCCESS;
1308                 }
1309
1310                 DeviceRelations->Count = 1;
1311                 DeviceRelations->Objects[0] = FdoExtension->RootHubPdo;
1312
1313                 ObReferenceObject(FdoExtension->RootHubPdo);
1314                 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1315             }
1316             else
1317             {
1318                 if (RelationType == RemovalRelations)
1319                 {
1320                     DPRINT1("USBPORT_FdoPnP: FIXME IRP_MN_QUERY_DEVICE_RELATIONS/RemovalRelations\n");
1321                 }
1322
1323                 goto ForwardIrp;
1324             }
1325
1326             Irp->IoStatus.Status = Status;
1327             goto ForwardIrp;
1328
1329         case IRP_MN_QUERY_INTERFACE:
1330             DPRINT("IRP_MN_QUERY_INTERFACE\n");
1331             goto ForwardIrp;
1332
1333         case IRP_MN_QUERY_CAPABILITIES:
1334             DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
1335             goto ForwardIrp;
1336
1337         case IRP_MN_QUERY_RESOURCES:
1338             DPRINT("IRP_MN_QUERY_RESOURCES\n");
1339             goto ForwardIrp;
1340
1341         case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
1342             DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
1343             goto ForwardIrp;
1344
1345         case IRP_MN_QUERY_DEVICE_TEXT:
1346             DPRINT("IRP_MN_QUERY_DEVICE_TEXT\n");
1347             goto ForwardIrp;
1348
1349         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
1350             DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
1351             goto ForwardIrp;
1352
1353         case IRP_MN_READ_CONFIG:
1354             DPRINT("IRP_MN_READ_CONFIG\n");
1355             goto ForwardIrp;
1356
1357         case IRP_MN_WRITE_CONFIG:
1358             DPRINT("IRP_MN_WRITE_CONFIG\n");
1359             goto ForwardIrp;
1360
1361         case IRP_MN_EJECT:
1362             DPRINT("IRP_MN_EJECT\n");
1363             goto ForwardIrp;
1364
1365         case IRP_MN_SET_LOCK:
1366             DPRINT("IRP_MN_SET_LOCK\n");
1367             goto ForwardIrp;
1368
1369         case IRP_MN_QUERY_ID:
1370             DPRINT("IRP_MN_QUERY_ID\n");
1371             goto ForwardIrp;
1372
1373         case IRP_MN_QUERY_PNP_DEVICE_STATE:
1374             DPRINT("IRP_MN_QUERY_PNP_DEVICE_STATE\n");
1375             goto ForwardIrp;
1376
1377         case IRP_MN_QUERY_BUS_INFORMATION:
1378             DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
1379             goto ForwardIrp;
1380
1381         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
1382             DPRINT("IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
1383             goto ForwardIrp;
1384
1385         case IRP_MN_SURPRISE_REMOVAL:
1386             DPRINT1("IRP_MN_SURPRISE_REMOVAL\n");
1387             if (!(FdoCommonExtension->PnpStateFlags & USBPORT_PNP_STATE_FAILED))
1388             {
1389                 USBPORT_InvalidateControllerHandler(FdoDevice,
1390                                                     USBPORT_INVALIDATE_CONTROLLER_SURPRISE_REMOVE);
1391             }
1392             goto ForwardIrp;
1393
1394         default:
1395             DPRINT("unknown IRP_MN_???\n");
1396 ForwardIrp:
1397             /* forward irp to next device object */
1398             IoSkipCurrentIrpStackLocation(Irp);
1399             break;
1400     }
1401
1402     return IoCallDriver(FdoCommonExtension->LowerDevice, Irp);
1403 }
1404
1405 PVOID
1406 NTAPI
1407 USBPORT_GetDeviceHwIds(IN PDEVICE_OBJECT FdoDevice,
1408                        IN USHORT VendorID,
1409                        IN USHORT DeviceID,
1410                        IN USHORT RevisionID)
1411 {
1412     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1413     PUSBPORT_REGISTRATION_PACKET Packet;
1414     PVOID Id;
1415     WCHAR Buffer[300] = {0};
1416     SIZE_T Length = 0;
1417     size_t Remaining = sizeof(Buffer);
1418     PWCHAR EndBuffer;
1419
1420     FdoExtension = FdoDevice->DeviceExtension;
1421     Packet = &FdoExtension->MiniPortInterface->Packet;
1422
1423     DPRINT("USBPORT_GetDeviceHwIds: FdoDevice - %p, Packet->MiniPortFlags - %p\n",
1424            FdoDevice,
1425            Packet->MiniPortFlags);
1426
1427     if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
1428     {
1429         RtlStringCbPrintfExW(Buffer,
1430                              Remaining,
1431                              &EndBuffer,
1432                              &Remaining,
1433                              0,
1434                              L"USB\\ROOT_HUB20&VID%04x&PID%04x&REV%04x",
1435                              VendorID,
1436                              DeviceID,
1437                              RevisionID);
1438
1439         EndBuffer++;
1440         Remaining -= sizeof(UNICODE_NULL);
1441
1442         RtlStringCbPrintfExW(EndBuffer,
1443                              Remaining,
1444                              &EndBuffer,
1445                              &Remaining,
1446                              0,
1447                              L"USB\\ROOT_HUB20&VID%04x&PID%04x",
1448                              VendorID,
1449                              DeviceID);
1450
1451         EndBuffer++;
1452         Remaining -= sizeof(UNICODE_NULL);
1453
1454         RtlStringCbPrintfExW(EndBuffer,
1455                              Remaining,
1456                              NULL,
1457                              &Remaining,
1458                              0,
1459                              L"USB\\ROOT_HUB20");
1460     }
1461     else
1462     {
1463         RtlStringCbPrintfExW(Buffer,
1464                              Remaining,
1465                              &EndBuffer,
1466                              &Remaining,
1467                              0,
1468                              L"USB\\ROOT_HUB&VID%04x&PID%04x&REV%04x",
1469                              VendorID,
1470                              DeviceID,
1471                              RevisionID);
1472
1473         EndBuffer++;
1474         Remaining -= sizeof(UNICODE_NULL);
1475
1476         RtlStringCbPrintfExW(EndBuffer,
1477                              Remaining,
1478                              &EndBuffer,
1479                              &Remaining,
1480                              0,
1481                              L"USB\\ROOT_HUB&VID%04x&PID%04x",
1482                              VendorID,
1483                              DeviceID);
1484
1485         EndBuffer++;
1486         Remaining -= sizeof(UNICODE_NULL);
1487
1488         RtlStringCbPrintfExW(EndBuffer,
1489                              Remaining,
1490                              NULL,
1491                              &Remaining,
1492                              0,
1493                              L"USB\\ROOT_HUB");
1494     }
1495
1496     Length = (sizeof(Buffer) - Remaining + 2 * sizeof(UNICODE_NULL));
1497
1498      /* for debug only */
1499     if (FALSE)
1500     {
1501         DPRINT("Hardware IDs:\n");
1502         USBPORT_DumpingIDs(Buffer);
1503     }
1504
1505     Id = ExAllocatePoolWithTag(PagedPool, Length, USB_PORT_TAG);
1506
1507     if (!Id)
1508         return NULL;
1509
1510     RtlMoveMemory(Id, Buffer, Length);
1511
1512     return Id;
1513 }
1514
1515 NTSTATUS
1516 NTAPI
1517 USBPORT_PdoPnP(IN PDEVICE_OBJECT PdoDevice,
1518                IN PIRP Irp)
1519 {
1520     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
1521     PUSBPORT_COMMON_DEVICE_EXTENSION PdoCommonExtension;
1522     PDEVICE_OBJECT FdoDevice;
1523     PUSBPORT_DEVICE_EXTENSION FdoExtension;
1524     PIO_STACK_LOCATION IoStack;
1525     UCHAR Minor;
1526     NTSTATUS Status;
1527     PPNP_BUS_INFORMATION BusInformation;
1528     PDEVICE_CAPABILITIES DeviceCapabilities;
1529
1530     PdoExtension = PdoDevice->DeviceExtension;
1531     PdoCommonExtension = &PdoExtension->CommonExtension;
1532
1533     FdoDevice = PdoExtension->FdoDevice;
1534     FdoExtension = FdoDevice->DeviceExtension;
1535
1536     IoStack = IoGetCurrentIrpStackLocation(Irp);
1537     Minor = IoStack->MinorFunction;
1538
1539     Status = Irp->IoStatus.Status;
1540
1541     DPRINT("USBPORT_PdoPnP: PdoDevice - %p, Minor - %x\n", PdoDevice, Minor);
1542
1543     switch (Minor)
1544     {
1545         case IRP_MN_START_DEVICE:
1546             DPRINT("IRP_MN_START_DEVICE\n");
1547
1548             Status = USBPORT_RootHubCreateDevice(FdoDevice, PdoDevice);
1549
1550             if (NT_SUCCESS(Status))
1551             {
1552                 Status = USBPORT_RegisterDeviceInterface(PdoDevice,
1553                                                          PdoDevice,
1554                                                          &GUID_DEVINTERFACE_USB_HUB,
1555                                                          TRUE);
1556
1557                 if (NT_SUCCESS(Status))
1558                 {
1559                     PdoCommonExtension->DevicePowerState = PowerDeviceD0;
1560                     PdoCommonExtension->PnpStateFlags = USBPORT_PNP_STATE_STARTED;
1561                 }
1562             }
1563
1564             break;
1565
1566         case IRP_MN_QUERY_REMOVE_DEVICE:
1567             DPRINT("USBPORT_PdoPnP: IRP_MN_QUERY_REMOVE_DEVICE\n");
1568             Status = STATUS_SUCCESS;
1569             break;
1570
1571         case IRP_MN_REMOVE_DEVICE:
1572             DPRINT1("USBPORT_PdoPnP: IRP_MN_REMOVE_DEVICE UNIMPLEMENTED. FIXME. \n");
1573             //USBPORT_StopRootHub();
1574             Status = STATUS_SUCCESS;
1575             break;
1576
1577         case IRP_MN_CANCEL_REMOVE_DEVICE:
1578             DPRINT("IRP_MN_CANCEL_REMOVE_DEVICE\n");
1579             Status = STATUS_SUCCESS;
1580             break;
1581
1582         case IRP_MN_STOP_DEVICE:
1583             DPRINT1("USBPORT_PdoPnP: IRP_MN_STOP_DEVICE UNIMPLEMENTED. FIXME. \n");
1584             //USBPORT_StopRootHub();
1585             Status = STATUS_SUCCESS;
1586             break;
1587
1588         case IRP_MN_QUERY_STOP_DEVICE:
1589             DPRINT("IRP_MN_QUERY_STOP_DEVICE\n");
1590             Status = STATUS_SUCCESS;
1591             break;
1592
1593         case IRP_MN_CANCEL_STOP_DEVICE:
1594             DPRINT("IRP_MN_CANCEL_STOP_DEVICE\n");
1595             Status = STATUS_SUCCESS;
1596             break;
1597
1598         case IRP_MN_QUERY_DEVICE_RELATIONS:
1599         {
1600             PDEVICE_RELATIONS DeviceRelations;
1601
1602             DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS\n");
1603             if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
1604             {
1605                 break;
1606             }
1607
1608             DeviceRelations = ExAllocatePoolWithTag(PagedPool,
1609                                                     sizeof(DEVICE_RELATIONS),
1610                                                     USB_PORT_TAG);
1611
1612             if (!DeviceRelations)
1613             {
1614                 Status = STATUS_INSUFFICIENT_RESOURCES;
1615                 Irp->IoStatus.Information = 0;
1616                 break;
1617             }
1618
1619             DeviceRelations->Count = 1;
1620             DeviceRelations->Objects[0] = PdoDevice;
1621
1622             ObReferenceObject(PdoDevice);
1623
1624             Status = STATUS_SUCCESS;
1625             Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1626             break;
1627         }
1628
1629         case IRP_MN_QUERY_INTERFACE:
1630             DPRINT("IRP_MN_QUERY_INTERFACE\n");
1631             Status = USBPORT_PdoQueryInterface(FdoDevice, PdoDevice, Irp);
1632             break;
1633
1634         case IRP_MN_QUERY_CAPABILITIES:
1635             DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
1636
1637             DeviceCapabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
1638
1639             RtlCopyMemory(DeviceCapabilities,
1640                           &PdoExtension->Capabilities,
1641                           sizeof(DEVICE_CAPABILITIES));
1642
1643             Status = STATUS_SUCCESS;
1644             break;
1645
1646         case IRP_MN_QUERY_RESOURCES:
1647             DPRINT("USBPORT_PdoPnP: IRP_MN_QUERY_RESOURCES\n");
1648             break;
1649
1650         case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
1651             DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
1652             break;
1653
1654         case IRP_MN_QUERY_DEVICE_TEXT:
1655             DPRINT("IRP_MN_QUERY_DEVICE_TEXT\n");
1656             break;
1657
1658         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
1659             DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
1660             break;
1661
1662         case IRP_MN_READ_CONFIG:
1663             DPRINT("IRP_MN_READ_CONFIG\n");
1664             ASSERT(FALSE);
1665             break;
1666
1667         case IRP_MN_WRITE_CONFIG:
1668             DPRINT("IRP_MN_WRITE_CONFIG\n");
1669             ASSERT(FALSE);
1670             break;
1671
1672         case IRP_MN_EJECT:
1673             DPRINT("IRP_MN_EJECT\n");
1674             ASSERT(FALSE);
1675             break;
1676
1677         case IRP_MN_SET_LOCK:
1678             DPRINT("IRP_MN_SET_LOCK\n");
1679             ASSERT(FALSE);
1680             break;
1681
1682         case IRP_MN_QUERY_ID:
1683         {
1684             ULONG IdType;
1685             LONG Length;
1686             WCHAR Buffer[64] = {0};
1687             PVOID Id;
1688
1689             Status = STATUS_SUCCESS;
1690             IdType = IoStack->Parameters.QueryId.IdType;
1691
1692             DPRINT("IRP_MN_QUERY_ID/Type %x\n", IdType);
1693
1694             if (IdType == BusQueryDeviceID)
1695             {
1696                 PUSBPORT_REGISTRATION_PACKET Packet;
1697                 Packet = &FdoExtension->MiniPortInterface->Packet;
1698
1699                 if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
1700                 {
1701                     RtlStringCbPrintfW(Buffer,
1702                                        sizeof(Buffer),
1703                                        L"USB\\ROOT_HUB20");
1704                 }
1705                 else
1706                 {
1707                     RtlStringCbPrintfW(Buffer,
1708                                        sizeof(Buffer),
1709                                        L"USB\\ROOT_HUB");
1710                 }
1711
1712                 Length = (LONG)(wcslen(Buffer) + 1);
1713
1714                 Id = ExAllocatePoolWithTag(PagedPool,
1715                                            Length * sizeof(WCHAR),
1716                                            USB_PORT_TAG);
1717
1718                 if (Id)
1719                 {
1720                     RtlZeroMemory(Id, Length * sizeof(WCHAR));
1721                     RtlStringCbCopyW(Id, Length * sizeof(WCHAR), Buffer);
1722
1723                     DPRINT("BusQueryDeviceID - %S, TotalLength - %hu\n",
1724                            Id,
1725                            Length);
1726                 }
1727
1728                 Irp->IoStatus.Information = (ULONG_PTR)Id;
1729                 break;
1730             }
1731
1732             if (IdType == BusQueryHardwareIDs)
1733             {
1734                 Id = USBPORT_GetDeviceHwIds(FdoDevice,
1735                                             FdoExtension->VendorID,
1736                                             FdoExtension->DeviceID,
1737                                             FdoExtension->RevisionID);
1738
1739                 Irp->IoStatus.Information = (ULONG_PTR)Id;
1740                 break;
1741             }
1742
1743             if (IdType == BusQueryCompatibleIDs ||
1744                 IdType == BusQueryInstanceID)
1745             {
1746                 Irp->IoStatus.Information = 0;
1747                 break;
1748             }
1749
1750             /* IdType == BusQueryDeviceSerialNumber */
1751             Status = Irp->IoStatus.Status;
1752             break;
1753         }
1754
1755         case IRP_MN_QUERY_PNP_DEVICE_STATE:
1756             DPRINT("IRP_MN_QUERY_PNP_DEVICE_STATE\n");
1757             Status = STATUS_SUCCESS;
1758             break;
1759
1760         case IRP_MN_QUERY_BUS_INFORMATION:
1761             DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
1762
1763             /* Allocate buffer for bus information */
1764             BusInformation = ExAllocatePoolWithTag(PagedPool,
1765                                                    sizeof(PNP_BUS_INFORMATION),
1766                                                    USB_PORT_TAG);
1767
1768             if (!BusInformation)
1769             {
1770                 /* No memory */
1771                 Status = STATUS_INSUFFICIENT_RESOURCES;
1772                 break;
1773             }
1774
1775             RtlZeroMemory(BusInformation, sizeof(PNP_BUS_INFORMATION));
1776
1777             /* Copy BUS GUID */
1778             RtlMoveMemory(&BusInformation->BusTypeGuid,
1779                           &GUID_BUS_TYPE_USB,
1780                           sizeof(GUID));
1781
1782             /* Set bus type */
1783             BusInformation->LegacyBusType = PNPBus;
1784             BusInformation->BusNumber = 0;
1785
1786             Status = STATUS_SUCCESS;
1787             Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
1788             break;
1789
1790         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
1791             DPRINT("IRP_MN_DEVICE_USAGE_NOTIFICATION\n");
1792             break;
1793
1794         case IRP_MN_SURPRISE_REMOVAL:
1795             DPRINT("USBPORT_PdoPnP: IRP_MN_SURPRISE_REMOVAL\n");
1796             Status = STATUS_SUCCESS;
1797             break;
1798
1799         default:
1800             DPRINT("unknown IRP_MN_???\n");
1801             break;
1802     }
1803
1804     Irp->IoStatus.Status = Status;
1805     IoCompleteRequest(Irp, IO_NO_INCREMENT);
1806     return Status;
1807 }