drivers/usb/usbport/iface.c

   1 /*
   2  * PROJECT:     ReactOS USB Port Driver
   3  * LICENSE:     GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
   4  * PURPOSE:     USBPort interface 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 VOID
  14 USB_BUSIFFN
  15 USBI_InterfaceReference(IN PVOID BusContext)
  16 {
  17     DPRINT("USBI_InterfaceReference \n");
  18 }
  19
  20 VOID
  21 USB_BUSIFFN
  22 USBI_InterfaceDereference(IN PVOID BusContext)
  23 {
  24     DPRINT("USBI_InterfaceDereference \n");
  25 }
  26
  27 /* USB port driver Interface functions */
  28
  29 NTSTATUS
  30 USB_BUSIFFN
  31 USBHI_CreateUsbDevice(IN PVOID BusContext,
  32                       IN OUT PUSB_DEVICE_HANDLE *UsbdDeviceHandle,
  33                       IN PUSB_DEVICE_HANDLE UsbdHubDeviceHandle,
  34                       IN USHORT PortStatus,
  35                       IN USHORT PortNumber)
  36 {
  37     PDEVICE_OBJECT PdoDevice;
  38     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
  39     PUSB_DEVICE_HANDLE deviceHandle = NULL;
  40     NTSTATUS Status;
  41
  42     DPRINT("USBHI_CreateUsbDevice: ... \n");
  43
  44     PdoDevice = BusContext;
  45     PdoExtension = PdoDevice->DeviceExtension;
  46
  47     Status = USBPORT_CreateDevice(&deviceHandle,
  48                                   PdoExtension->FdoDevice,
  49                                   (PUSBPORT_DEVICE_HANDLE)UsbdHubDeviceHandle,
  50                                   PortStatus,
  51                                   PortNumber);
  52
  53     *UsbdDeviceHandle = deviceHandle;
  54
  55     return Status;
  56 }
  57
  58 NTSTATUS
  59 USB_BUSIFFN
  60 USBHI_InitializeUsbDevice(IN PVOID BusContext,
  61                           OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle)
  62 {
  63     PDEVICE_OBJECT PdoDevice;
  64     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
  65
  66     DPRINT("USBHI_InitializeUsbDevice \n");
  67
  68     PdoDevice = BusContext;
  69     PdoExtension = PdoDevice->DeviceExtension;
  70
  71     return USBPORT_InitializeDevice((PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle,
  72                                     PdoExtension->FdoDevice);
  73 }
  74
  75 NTSTATUS
  76 USB_BUSIFFN
  77 USBHI_GetUsbDescriptors(IN PVOID BusContext,
  78                         IN PUSB_DEVICE_HANDLE UsbdDeviceHandle,
  79                         IN PUCHAR DeviceDescBuffer,
  80                         IN PULONG DeviceDescBufferLen,
  81                         IN PUCHAR ConfigDescBuffer,
  82                         IN PULONG ConfigDescBufferLen)
  83 {
  84     PDEVICE_OBJECT PdoDevice;
  85     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
  86     PUSBPORT_DEVICE_HANDLE DeviceHandle;
  87
  88     NTSTATUS Status;
  89
  90     DPRINT("USBHI_GetUsbDescriptors ...\n");
  91
  92     PdoDevice = BusContext;
  93     PdoExtension = PdoDevice->DeviceExtension;
  94     DeviceHandle = (PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle;
  95
  96     if (DeviceDescBuffer && *DeviceDescBufferLen)
  97     {
  98         if (*DeviceDescBufferLen > sizeof(USB_DEVICE_DESCRIPTOR))
  99             *DeviceDescBufferLen = sizeof(USB_DEVICE_DESCRIPTOR);
 100
 101         RtlCopyMemory(DeviceDescBuffer,
 102                       &DeviceHandle->DeviceDescriptor,
 103                       *DeviceDescBufferLen);
 104     }
 105
 106     Status = USBPORT_GetUsbDescriptor(DeviceHandle,
 107                                       PdoExtension->FdoDevice,
 108                                       USB_CONFIGURATION_DESCRIPTOR_TYPE,
 109                                       ConfigDescBuffer,
 110                                       ConfigDescBufferLen);
 111
 112     USBPORT_DumpingDeviceDescriptor((PUSB_DEVICE_DESCRIPTOR)DeviceDescBuffer);
 113
 114     return Status;
 115 }
 116
 117 NTSTATUS
 118 USB_BUSIFFN
 119 USBHI_RemoveUsbDevice(IN PVOID BusContext,
 120                       IN OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle,
 121                       IN ULONG Flags)
 122 {
 123     PDEVICE_OBJECT PdoDevice;
 124     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 125
 126     DPRINT("USBHI_RemoveUsbDevice: UsbdDeviceHandle - %p, Flags - %x\n",
 127            UsbdDeviceHandle,
 128            Flags);
 129
 130     PdoDevice = BusContext;
 131     PdoExtension = PdoDevice->DeviceExtension;
 132
 133     return USBPORT_RemoveDevice(PdoExtension->FdoDevice,
 134                                 (PUSBPORT_DEVICE_HANDLE)UsbdDeviceHandle,
 135                                 Flags);
 136 }
 137
 138 NTSTATUS
 139 USB_BUSIFFN
 140 USBHI_RestoreUsbDevice(IN PVOID BusContext,
 141                        OUT PUSB_DEVICE_HANDLE OldUsbdDeviceHandle,
 142                        OUT PUSB_DEVICE_HANDLE NewUsbdDeviceHandle)
 143 {
 144     PDEVICE_OBJECT PdoDevice;
 145     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 146
 147     DPRINT("USBHI_RestoreUsbDevice: OldUsbdDeviceHandle - %p, NewUsbdDeviceHandle - %x\n",
 148            OldUsbdDeviceHandle,
 149            NewUsbdDeviceHandle);
 150
 151     PdoDevice = BusContext;
 152     PdoExtension = PdoDevice->DeviceExtension;
 153
 154     return USBPORT_RestoreDevice(PdoExtension->FdoDevice,
 155                                 (PUSBPORT_DEVICE_HANDLE)OldUsbdDeviceHandle,
 156                                 (PUSBPORT_DEVICE_HANDLE)NewUsbdDeviceHandle);
 157 }
 158
 159 NTSTATUS
 160 USB_BUSIFFN
 161 USBHI_QueryDeviceInformation(IN PVOID BusContext,
 162                              IN PUSB_DEVICE_HANDLE UsbdDeviceHandle,
 163                              OUT PVOID DeviceInfoBuffer,
 164                              IN ULONG DeviceInfoBufferLen,
 165                              OUT PULONG LenDataReturned)
 166 {
 167     PUSB_DEVICE_INFORMATION_0 DeviceInfo;
 168     PUSBPORT_CONFIGURATION_HANDLE ConfigHandle;
 169     PLIST_ENTRY InterfaceEntry;
 170     PUSBPORT_DEVICE_HANDLE DeviceHandle;
 171     ULONG NumberOfOpenPipes = 0;
 172     PUSB_PIPE_INFORMATION_0 PipeInfo;
 173     PUSBPORT_PIPE_HANDLE PipeHandle;
 174     PUSBPORT_INTERFACE_HANDLE InterfaceHandle;
 175     ULONG ActualLength;
 176     ULONG ix;
 177
 178     DPRINT("USBHI_QueryDeviceInformation: ... \n");
 179
 180     *LenDataReturned = 0;
 181
 182     if (DeviceInfoBufferLen < sizeof(USB_LEVEL_INFORMATION))
 183     {
 184         return STATUS_BUFFER_TOO_SMALL;
 185     }
 186
 187     DeviceInfo = DeviceInfoBuffer;
 188
 189     if (DeviceInfo->InformationLevel > 0)
 190     {
 191         return STATUS_NOT_SUPPORTED;
 192     }
 193
 194     DeviceHandle = UsbdDeviceHandle;
 195     ConfigHandle = DeviceHandle->ConfigHandle;
 196
 197     if (ConfigHandle)
 198     {
 199         InterfaceEntry = ConfigHandle->InterfaceHandleList.Flink;
 200
 201         while (InterfaceEntry &&
 202                InterfaceEntry != &ConfigHandle->InterfaceHandleList)
 203         {
 204             InterfaceHandle = CONTAINING_RECORD(InterfaceEntry,
 205                                                 USBPORT_INTERFACE_HANDLE,
 206                                                 InterfaceLink);
 207
 208             NumberOfOpenPipes += InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
 209
 210             InterfaceEntry = InterfaceEntry->Flink;
 211         }
 212     }
 213
 214     ActualLength = FIELD_OFFSET(USB_DEVICE_INFORMATION_0, PipeList) +
 215                    NumberOfOpenPipes * sizeof(USB_PIPE_INFORMATION_0);
 216
 217     if (DeviceInfoBufferLen < ActualLength)
 218     {
 219         DeviceInfo->ActualLength = ActualLength;
 220         *LenDataReturned = sizeof(USB_LEVEL_INFORMATION);
 221
 222         return STATUS_BUFFER_TOO_SMALL;
 223     }
 224
 225     RtlZeroMemory(DeviceInfo, ActualLength);
 226
 227     DeviceInfo->InformationLevel = 0;
 228     DeviceInfo->ActualLength = ActualLength;
 229     DeviceInfo->DeviceAddress = DeviceHandle->DeviceAddress;
 230     DeviceInfo->NumberOfOpenPipes = NumberOfOpenPipes;
 231     DeviceInfo->DeviceSpeed = DeviceHandle->DeviceSpeed;
 232
 233     RtlCopyMemory(&DeviceInfo->DeviceDescriptor,
 234                   &DeviceHandle->DeviceDescriptor,
 235                   sizeof(USB_DEVICE_DESCRIPTOR));
 236
 237     USBPORT_DumpingDeviceDescriptor(&DeviceInfo->DeviceDescriptor);
 238
 239     if (DeviceHandle->DeviceSpeed == UsbFullSpeed ||
 240         DeviceHandle->DeviceSpeed == UsbLowSpeed)
 241     {
 242         DeviceInfo->DeviceType = Usb11Device;
 243     }
 244     else if (DeviceHandle->DeviceSpeed == UsbHighSpeed)
 245     {
 246         DeviceInfo->DeviceType = Usb20Device;
 247     }
 248
 249     DeviceInfo->CurrentConfigurationValue = 0;
 250
 251     if (!ConfigHandle)
 252     {
 253         *LenDataReturned = ActualLength;
 254         return STATUS_SUCCESS;
 255     }
 256
 257     DeviceInfo->CurrentConfigurationValue =
 258         ConfigHandle->ConfigurationDescriptor->bConfigurationValue;
 259
 260     InterfaceEntry = ConfigHandle->InterfaceHandleList.Flink;
 261
 262     while (InterfaceEntry &&
 263            InterfaceEntry != &ConfigHandle->InterfaceHandleList)
 264     {
 265         InterfaceHandle = CONTAINING_RECORD(InterfaceEntry,
 266                                             USBPORT_INTERFACE_HANDLE,
 267                                             InterfaceLink);
 268
 269         if (InterfaceHandle->InterfaceDescriptor.bNumEndpoints > 0)
 270         {
 271             PipeInfo = &DeviceInfo->PipeList[0];
 272             PipeHandle = &InterfaceHandle->PipeHandle[0];
 273
 274             for (ix = 0;
 275                  ix < InterfaceHandle->InterfaceDescriptor.bNumEndpoints;
 276                  ix++)
 277             {
 278                 if (PipeHandle->Flags & PIPE_HANDLE_FLAG_NULL_PACKET_SIZE)
 279                 {
 280                     PipeInfo->ScheduleOffset = 1;
 281                 }
 282                 else
 283                 {
 284                     PipeInfo->ScheduleOffset =
 285                         PipeHandle->Endpoint->EndpointProperties.ScheduleOffset;
 286                 }
 287
 288                 RtlCopyMemory(&PipeInfo->EndpointDescriptor,
 289                               &PipeHandle->EndpointDescriptor,
 290                               sizeof(USB_ENDPOINT_DESCRIPTOR));
 291
 292                 PipeInfo += 1;
 293                 PipeHandle += 1;
 294             }
 295         }
 296
 297         InterfaceEntry = InterfaceEntry->Flink;
 298     }
 299
 300     *LenDataReturned = ActualLength;
 301
 302     return STATUS_SUCCESS;
 303 }
 304
 305 NTSTATUS
 306 USB_BUSIFFN
 307 USBHI_GetControllerInformation(IN PVOID BusContext,
 308                                OUT PVOID ControllerInfoBuffer,
 309                                IN ULONG ControllerInfoBufferLen,
 310                                OUT PULONG LenDataReturned)
 311 {
 312     PDEVICE_OBJECT PdoDevice;
 313     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 314     PDEVICE_OBJECT FdoDevice;
 315     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 316     PUSB_CONTROLLER_INFORMATION_0 InfoBuffer;
 317     NTSTATUS Status;
 318
 319     DPRINT("USBHI_GetControllerInformation: ControllerInfoBufferLen - %x\n",
 320            ControllerInfoBufferLen);
 321
 322     PdoDevice = BusContext;
 323     PdoExtension = PdoDevice->DeviceExtension;
 324     FdoDevice = PdoExtension->FdoDevice;
 325     FdoExtension = FdoDevice->DeviceExtension;
 326
 327     InfoBuffer = ControllerInfoBuffer;
 328
 329     *LenDataReturned = 0;
 330
 331     if (ControllerInfoBufferLen < sizeof(USB_LEVEL_INFORMATION))
 332     {
 333         Status = STATUS_BUFFER_TOO_SMALL;
 334         return Status;
 335     }
 336
 337     *LenDataReturned = sizeof(USB_LEVEL_INFORMATION);
 338
 339     if (InfoBuffer->InformationLevel > 0)
 340     {
 341         Status = STATUS_NOT_SUPPORTED;
 342         return Status;
 343     }
 344
 345     InfoBuffer->ActualLength = sizeof(USB_CONTROLLER_INFORMATION_0);
 346
 347     if (ControllerInfoBufferLen >= sizeof(USB_CONTROLLER_INFORMATION_0))
 348     {
 349         InfoBuffer->SelectiveSuspendEnabled =
 350             (FdoExtension->Flags & USBPORT_FLAG_SELECTIVE_SUSPEND) ==
 351             USBPORT_FLAG_SELECTIVE_SUSPEND;
 352     }
 353
 354     *LenDataReturned = sizeof(USB_CONTROLLER_INFORMATION_0);
 355
 356     return STATUS_SUCCESS;
 357 }
 358
 359 NTSTATUS
 360 USB_BUSIFFN
 361 USBHI_ControllerSelectiveSuspend(IN PVOID BusContext,
 362                                  IN BOOLEAN Enable)
 363 {
 364     PDEVICE_OBJECT PdoDevice;
 365     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 366     PDEVICE_OBJECT FdoDevice;
 367     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 368     ULONG Flags;
 369     ULONG HcDisable;
 370     NTSTATUS Status;
 371
 372     DPRINT("USBHI_ControllerSelectiveSuspend: Enable - %x\n", Enable);
 373
 374     PdoDevice = BusContext;
 375     PdoExtension = PdoDevice->DeviceExtension;
 376     FdoDevice = PdoExtension->FdoDevice;
 377     FdoExtension = FdoDevice->DeviceExtension;
 378
 379     Flags = FdoExtension->Flags;
 380
 381     if (Flags & USBPORT_FLAG_BIOS_DISABLE_SS)
 382     {
 383         return STATUS_SUCCESS;
 384     }
 385
 386     if (Enable)
 387     {
 388         FdoExtension->Flags |= USBPORT_FLAG_SELECTIVE_SUSPEND;
 389         HcDisable = 0;
 390     }
 391     else
 392     {
 393         FdoExtension->Flags &= ~USBPORT_FLAG_SELECTIVE_SUSPEND;
 394         HcDisable = 1;
 395     }
 396
 397     Status = USBPORT_SetRegistryKeyValue(FdoExtension->CommonExtension.LowerPdoDevice,
 398                                          TRUE,
 399                                          REG_DWORD,
 400                                          L"HcDisableSelectiveSuspend",
 401                                          &HcDisable,
 402                                          sizeof(HcDisable));
 403
 404     if (NT_SUCCESS(Status))
 405     {
 406         if (Enable)
 407             FdoExtension->Flags |= USBPORT_FLAG_SELECTIVE_SUSPEND;
 408         else
 409             FdoExtension->Flags &= ~USBPORT_FLAG_SELECTIVE_SUSPEND;
 410     }
 411
 412     return Status;
 413 }
 414
 415 NTSTATUS
 416 USB_BUSIFFN
 417 USBHI_GetExtendedHubInformation(IN PVOID BusContext,
 418                                 IN PDEVICE_OBJECT HubPhysicalDeviceObject,
 419                                 IN OUT PVOID HubInformationBuffer,
 420                                 IN ULONG HubInfoLen,
 421                                 IN OUT PULONG LenDataReturned)
 422 {
 423     PDEVICE_OBJECT PdoDevice;
 424     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 425     PDEVICE_OBJECT FdoDevice;
 426     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 427     PUSBPORT_REGISTRATION_PACKET Packet;
 428     ULONG NumPorts;
 429     ULONG ix;
 430     PUSB_EXTHUB_INFORMATION_0 HubInfoBuffer;
 431     USB_PORT_STATUS_AND_CHANGE PortStatus;
 432     ULONG PortAttrX;
 433
 434     DPRINT("USBHI_GetExtendedHubInformation: ... \n");
 435
 436     PdoDevice = BusContext;
 437     PdoExtension = PdoDevice->DeviceExtension;
 438     FdoDevice = PdoExtension->FdoDevice;
 439     FdoExtension = FdoDevice->DeviceExtension;
 440     Packet = &FdoExtension->MiniPortInterface->Packet;
 441
 442     HubInfoBuffer = HubInformationBuffer;
 443     PortStatus.AsUlong32 = 0;
 444
 445     if (HubPhysicalDeviceObject != PdoDevice)
 446     {
 447         *LenDataReturned = 0;
 448         return STATUS_NOT_SUPPORTED;
 449     }
 450
 451     if (HubInfoLen < sizeof(USB_EXTHUB_INFORMATION_0))
 452     {
 453         *LenDataReturned = 0;
 454         return STATUS_BUFFER_TOO_SMALL;
 455     }
 456
 457     NumPorts = PdoExtension->RootHubDescriptors->Descriptor.bNumberOfPorts;
 458     HubInfoBuffer->NumberOfPorts = NumPorts;
 459
 460     if (NumPorts == 0)
 461     {
 462         *LenDataReturned = sizeof(USB_EXTHUB_INFORMATION_0);
 463         return STATUS_SUCCESS;
 464     }
 465
 466     for (ix = 0; ix < HubInfoBuffer->NumberOfPorts; ++ix)
 467     {
 468         HubInfoBuffer->Port[ix].PhysicalPortNumber = ix + 1;
 469         HubInfoBuffer->Port[ix].PortLabelNumber = ix;
 470         HubInfoBuffer->Port[ix].VidOverride = 0;
 471         HubInfoBuffer->Port[ix].PidOverride = 0;
 472         HubInfoBuffer->Port[ix].PortAttributes = 0;
 473
 474         if (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2)
 475         {
 476             HubInfoBuffer->Port[ix].PortAttributes = USB_PORTATTR_SHARED_USB2;
 477
 478             Packet->RH_GetPortStatus(FdoExtension->MiniPortExt,
 479                                      ix + 1,
 480                                      &PortStatus);
 481
 482             if (PortStatus.PortStatus.Usb20PortStatus.AsUshort16 & 0x8000)
 483             {
 484                 HubInfoBuffer->Port[ix].PortAttributes |= USB_PORTATTR_OWNED_BY_CC;
 485             }
 486         }
 487         else
 488         {
 489             if (!(FdoExtension->Flags & USBPORT_FLAG_COMPANION_HC))
 490             {
 491                 continue;
 492             }
 493
 494             if (USBPORT_FindUSB2Controller(FdoDevice))
 495             {
 496                 HubInfoBuffer->Port[ix].PortAttributes |= USB_PORTATTR_NO_OVERCURRENT_UI;
 497             }
 498         }
 499     }
 500
 501     for (ix = 0; ix < HubInfoBuffer->NumberOfPorts; ++ix)
 502     {
 503         PortAttrX = 0;
 504
 505         USBPORT_GetRegistryKeyValueFullInfo(FdoDevice,
 506                                             FdoExtension->CommonExtension.LowerPdoDevice,
 507                                             FALSE,
 508                                             L"PortAttrX",
 509                                             sizeof(L"PortAttrX"),
 510                                             &PortAttrX,
 511                                             sizeof(PortAttrX));
 512
 513         HubInfoBuffer->Port[ix].PortAttributes |= PortAttrX;
 514     }
 515
 516     *LenDataReturned = sizeof(USB_EXTHUB_INFORMATION_0);
 517
 518     return STATUS_SUCCESS;
 519 }
 520
 521 NTSTATUS
 522 USB_BUSIFFN
 523 USBHI_GetRootHubSymbolicName(IN PVOID BusContext,
 524                              IN OUT PVOID HubInfoBuffer,
 525                              IN ULONG HubInfoBufferLen,
 526                              OUT PULONG HubNameActualLen)
 527 {
 528     PDEVICE_OBJECT PdoDevice;
 529     UNICODE_STRING HubName;
 530     PUNICODE_STRING InfoBuffer;
 531     NTSTATUS Status;
 532
 533     DPRINT("USBHI_GetRootHubSymbolicName: ... \n");
 534
 535     PdoDevice = BusContext;
 536
 537     Status = USBPORT_GetSymbolicName(PdoDevice, &HubName);
 538
 539     if (HubInfoBufferLen < HubName.Length)
 540     {
 541         InfoBuffer = HubInfoBuffer;
 542         InfoBuffer->Length = 0;
 543     }
 544     else
 545     {
 546         RtlCopyMemory(HubInfoBuffer, HubName.Buffer, HubName.Length);
 547     }
 548
 549     *HubNameActualLen = HubName.Length;
 550
 551     if (NT_SUCCESS(Status))
 552         RtlFreeUnicodeString(&HubName);
 553
 554     return Status;
 555 }
 556
 557 PVOID
 558 USB_BUSIFFN
 559 USBHI_GetDeviceBusContext(IN PVOID BusContext,
 560                           IN PVOID DeviceHandle)
 561 {
 562     DPRINT1("USBHI_GetDeviceBusContext: UNIMPLEMENTED. FIXME. \n");
 563     return NULL;
 564 }
 565
 566 NTSTATUS
 567 USB_BUSIFFN
 568 USBHI_Initialize20Hub(IN PVOID BusContext,
 569                       IN PUSB_DEVICE_HANDLE UsbdHubDeviceHandle,
 570                       IN ULONG TtCount)
 571 {
 572     PDEVICE_OBJECT PdoDevice;
 573     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 574
 575     DPRINT("USBHI_Initialize20Hub: UsbdHubDeviceHandle - %p, TtCount - %x\n",
 576            UsbdHubDeviceHandle,
 577            TtCount);
 578
 579     PdoDevice = BusContext;
 580     PdoExtension = PdoDevice->DeviceExtension;
 581
 582     return USBPORT_Initialize20Hub(PdoExtension->FdoDevice,
 583                                    (PUSBPORT_DEVICE_HANDLE)UsbdHubDeviceHandle,
 584                                    TtCount);
 585 }
 586
 587 NTSTATUS
 588 USB_BUSIFFN
 589 USBHI_RootHubInitNotification(IN PVOID BusContext,
 590                               IN PVOID CallbackContext,
 591                               IN PRH_INIT_CALLBACK CallbackFunction)
 592 {
 593     PDEVICE_OBJECT PdoDevice;
 594     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 595     PDEVICE_OBJECT FdoDevice;
 596     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 597     KIRQL OldIrql;
 598
 599     DPRINT("USBHI_RootHubInitNotification \n");
 600
 601     PdoDevice = BusContext;
 602     PdoExtension = PdoDevice->DeviceExtension;
 603     FdoDevice = PdoExtension->FdoDevice;
 604     FdoExtension = FdoDevice->DeviceExtension;
 605
 606     KeAcquireSpinLock(&FdoExtension->RootHubCallbackSpinLock, &OldIrql);
 607     PdoExtension->RootHubInitContext = CallbackContext;
 608     PdoExtension->RootHubInitCallback = CallbackFunction;
 609     KeReleaseSpinLock(&FdoExtension->RootHubCallbackSpinLock, OldIrql);
 610
 611     return STATUS_SUCCESS;
 612 }
 613
 614 VOID
 615 USB_BUSIFFN
 616 USBHI_FlushTransfers(IN PVOID BusContext,
 617                      OUT PUSB_DEVICE_HANDLE UsbdDeviceHandle)
 618 {
 619     PDEVICE_OBJECT PdoDevice;
 620     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 621
 622     DPRINT("USBHI_FlushTransfers: ... \n");
 623
 624     PdoDevice = BusContext;
 625     PdoExtension = PdoDevice->DeviceExtension;
 626
 627     USBPORT_BadRequestFlush(PdoExtension->FdoDevice);
 628 }
 629
 630 VOID
 631 USB_BUSIFFN
 632 USBHI_SetDeviceHandleData(IN PVOID BusContext,
 633                           IN PVOID DeviceHandle,
 634                           IN PDEVICE_OBJECT UsbDevicePdo)
 635 {
 636     DPRINT1("USBHI_SetDeviceHandleData: UNIMPLEMENTED. FIXME. \n");
 637 }
 638
 639 /* USB bus driver Interface functions */
 640
 641 VOID
 642 USB_BUSIFFN
 643 USBDI_GetUSBDIVersion(IN PVOID BusContext,
 644                       OUT PUSBD_VERSION_INFORMATION VersionInfo,
 645                       OUT PULONG HcdCapabilities)
 646 {
 647     DPRINT1("USBDI_GetUSBDIVersion: UNIMPLEMENTED. FIXME. \n");
 648 }
 649
 650 NTSTATUS
 651 USB_BUSIFFN
 652 USBDI_QueryBusTime(IN PVOID BusContext,
 653                    OUT PULONG CurrentFrame)
 654 {
 655     DPRINT1("USBDI_QueryBusTime: UNIMPLEMENTED. FIXME. \n");
 656     return STATUS_SUCCESS;
 657 }
 658
 659 NTSTATUS
 660 USB_BUSIFFN
 661 USBDI_SubmitIsoOutUrb(IN PVOID BusContext,
 662                       IN PURB Urb)
 663 {
 664     DPRINT1("USBDI_SubmitIsoOutUrb: UNIMPLEMENTED. FIXME. \n");
 665     return STATUS_SUCCESS;
 666 }
 667
 668 NTSTATUS
 669 USB_BUSIFFN
 670 USBDI_QueryBusInformation(IN PVOID BusContext,
 671                           IN ULONG Level,
 672                           OUT PVOID BusInfoBuffer,
 673                           OUT PULONG BusInfoBufferLen,
 674                           OUT PULONG BusInfoActualLen)
 675 {
 676     PDEVICE_OBJECT PdoDevice;
 677     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 678     PDEVICE_OBJECT FdoDevice;
 679     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 680     SIZE_T Length;
 681     PUSB_BUS_INFORMATION_LEVEL_1 Buffer1;
 682
 683     DPRINT("USBDI_QueryBusInformation: Level - %p\n", Level);
 684
 685     if ((Level != 0) && (Level != 1))
 686     {
 687         DPRINT1("USBDI_QueryBusInformation: Level should be 0 or 1\n");
 688         return STATUS_NOT_SUPPORTED;
 689     }
 690
 691     PdoDevice = BusContext;
 692     PdoExtension = PdoDevice->DeviceExtension;
 693     FdoDevice = PdoExtension->FdoDevice;
 694     FdoExtension = FdoDevice->DeviceExtension;
 695
 696     if (Level == 0)
 697     {
 698         if (BusInfoActualLen)
 699             *BusInfoActualLen = sizeof(USB_BUS_INFORMATION_LEVEL_0);
 700
 701         if (*BusInfoBufferLen < sizeof(USB_BUS_INFORMATION_LEVEL_0))
 702         {
 703             return STATUS_BUFFER_TOO_SMALL;
 704         }
 705
 706         *BusInfoBufferLen = sizeof(USB_BUS_INFORMATION_LEVEL_0);
 707
 708         //Buffer0 = BusInfoBuffer;
 709         DPRINT1("USBDI_QueryBusInformation: LEVEL_0 UNIMPLEMENTED. FIXME\n");
 710         //Buffer0->TotalBandwidth = USBPORT_GetTotalBandwidth();
 711         //Buffer0->ConsumedBandwidth = USBPORT_GetAllocatedBandwidth();
 712
 713         return STATUS_SUCCESS;
 714     }
 715
 716     if (Level == 1)
 717     {
 718         Length = sizeof(USB_BUS_INFORMATION_LEVEL_1) +
 719                  FdoExtension->CommonExtension.SymbolicLinkName.Length;
 720
 721         if (BusInfoActualLen)
 722             *BusInfoActualLen = Length;
 723
 724         if (*BusInfoBufferLen < Length)
 725         {
 726             return STATUS_BUFFER_TOO_SMALL;
 727         }
 728
 729         *BusInfoBufferLen = Length;
 730
 731         Buffer1 = BusInfoBuffer;
 732         DPRINT1("USBDI_QueryBusInformation: LEVEL_1 UNIMPLEMENTED. FIXME\n");
 733         //Buffer1->TotalBandwidth = USBPORT_GetTotalBandwidth();
 734         //Buffer1->ConsumedBandwidth = USBPORT_GetAllocatedBandwidth();
 735         Buffer1->ControllerNameLength = FdoExtension->CommonExtension.SymbolicLinkName.Length;
 736
 737         RtlCopyMemory(&Buffer1->ControllerNameUnicodeString,
 738                       FdoExtension->CommonExtension.SymbolicLinkName.Buffer,
 739                       FdoExtension->CommonExtension.SymbolicLinkName.Length);
 740
 741         return STATUS_SUCCESS;
 742     }
 743
 744     return STATUS_SUCCESS;
 745 }
 746
 747 BOOLEAN
 748 USB_BUSIFFN
 749 USBDI_IsDeviceHighSpeed(IN PVOID BusContext)
 750 {
 751     PDEVICE_OBJECT PdoDevice;
 752     PUSBPORT_RHDEVICE_EXTENSION PdoExtension;
 753     PDEVICE_OBJECT FdoDevice;
 754     PUSBPORT_DEVICE_EXTENSION FdoExtension;
 755     PUSBPORT_REGISTRATION_PACKET Packet;
 756
 757     DPRINT("USBDI_IsDeviceHighSpeed: ... \n");
 758
 759     PdoDevice = BusContext;
 760     PdoExtension = PdoDevice->DeviceExtension;
 761     FdoDevice = PdoExtension->FdoDevice;
 762     FdoExtension = FdoDevice->DeviceExtension;
 763     Packet = &FdoExtension->MiniPortInterface->Packet;
 764
 765     return (Packet->MiniPortFlags & USB_MINIPORT_FLAGS_USB2) != 0;
 766 }
 767
 768 NTSTATUS
 769 USB_BUSIFFN
 770 USBDI_EnumLogEntry(IN PVOID BusContext,
 771                    IN ULONG DriverTag,
 772                    IN ULONG EnumTag,
 773                    IN ULONG P1,
 774                    IN ULONG P2)
 775 {
 776     DPRINT1("USBDI_EnumLogEntry: UNIMPLEMENTED. FIXME. \n");
 777     return STATUS_SUCCESS;
 778 }
 779
 780 NTSTATUS
 781 NTAPI
 782 USBPORT_PdoQueryInterface(IN PDEVICE_OBJECT FdoDevice,
 783                           IN PDEVICE_OBJECT PdoDevice,
 784                           IN PIRP Irp)
 785 {
 786     PIO_STACK_LOCATION IoStack = IoGetCurrentIrpStackLocation(Irp);
 787     PUSB_BUS_INTERFACE_HUB_V5 InterfaceHub;
 788     PUSB_BUS_INTERFACE_USBDI_V2 InterfaceDI;
 789     UNICODE_STRING GuidBuffer;
 790     NTSTATUS Status;
 791
 792     DPRINT("USBPORT_PdoQueryInterface: ... \n");
 793
 794     if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
 795                            &USB_BUS_INTERFACE_HUB_GUID))
 796     {
 797         /* Get request parameters */
 798         InterfaceHub = (PUSB_BUS_INTERFACE_HUB_V5)IoStack->Parameters.QueryInterface.Interface;
 799         InterfaceHub->Version = IoStack->Parameters.QueryInterface.Version;
 800
 801         /* Check version */
 802         if (IoStack->Parameters.QueryInterface.Version >= 6)
 803         {
 804             DPRINT1("USB_BUS_INTERFACE_HUB_GUID version %x not supported!\n",
 805                     IoStack->Parameters.QueryInterface.Version);
 806
 807             return Irp->IoStatus.Status; // Version not supported
 808         }
 809
 810         /* Interface version 0 */
 811         InterfaceHub->Size = IoStack->Parameters.QueryInterface.Size;
 812         InterfaceHub->BusContext = PdoDevice;
 813
 814         InterfaceHub->InterfaceReference = USBI_InterfaceReference;
 815         InterfaceHub->InterfaceDereference = USBI_InterfaceDereference;
 816
 817         /* Interface version 1 */
 818         if (IoStack->Parameters.QueryInterface.Version >= 1)
 819         {
 820             InterfaceHub->CreateUsbDevice = USBHI_CreateUsbDevice;
 821             InterfaceHub->InitializeUsbDevice = USBHI_InitializeUsbDevice;
 822             InterfaceHub->GetUsbDescriptors = USBHI_GetUsbDescriptors;
 823             InterfaceHub->RemoveUsbDevice = USBHI_RemoveUsbDevice;
 824             InterfaceHub->RestoreUsbDevice = USBHI_RestoreUsbDevice;
 825             InterfaceHub->QueryDeviceInformation = USBHI_QueryDeviceInformation;
 826         }
 827
 828         /* Interface version 2 */
 829         if (IoStack->Parameters.QueryInterface.Version >= 2)
 830         {
 831             InterfaceHub->GetControllerInformation = USBHI_GetControllerInformation;
 832             InterfaceHub->ControllerSelectiveSuspend = USBHI_ControllerSelectiveSuspend;
 833             InterfaceHub->GetExtendedHubInformation = USBHI_GetExtendedHubInformation;
 834             InterfaceHub->GetRootHubSymbolicName = USBHI_GetRootHubSymbolicName;
 835             InterfaceHub->GetDeviceBusContext = USBHI_GetDeviceBusContext;
 836             InterfaceHub->Initialize20Hub = USBHI_Initialize20Hub;
 837         }
 838
 839         /* Interface version 3 */
 840         if (IoStack->Parameters.QueryInterface.Version >= 3)
 841             InterfaceHub->RootHubInitNotification = USBHI_RootHubInitNotification;
 842
 843         /* Interface version 4 */
 844         if (IoStack->Parameters.QueryInterface.Version >= 4)
 845             InterfaceHub->FlushTransfers = USBHI_FlushTransfers;
 846
 847         /* Interface version 5 */
 848         if (IoStack->Parameters.QueryInterface.Version >= 5)
 849             InterfaceHub->SetDeviceHandleData = USBHI_SetDeviceHandleData;
 850
 851         /* Request completed */
 852         return STATUS_SUCCESS;
 853     }
 854     else if (IsEqualGUIDAligned(IoStack->Parameters.QueryInterface.InterfaceType,
 855                                 &USB_BUS_INTERFACE_USBDI_GUID))
 856     {
 857         /* Get request parameters */
 858         InterfaceDI = (PUSB_BUS_INTERFACE_USBDI_V2)IoStack->Parameters.QueryInterface.Interface;
 859         InterfaceDI->Version = IoStack->Parameters.QueryInterface.Version;
 860
 861         /* Check version */
 862         if (IoStack->Parameters.QueryInterface.Version >= 3)
 863         {
 864             DPRINT1("USB_BUS_INTERFACE_USBDI_GUID version %x not supported!\n",
 865                     IoStack->Parameters.QueryInterface.Version);
 866
 867             return Irp->IoStatus.Status; // Version not supported
 868         }
 869
 870         /* Interface version 0 */
 871         InterfaceDI->Size = IoStack->Parameters.QueryInterface.Size;
 872         InterfaceDI->BusContext = PdoDevice;
 873         InterfaceDI->InterfaceReference = USBI_InterfaceReference;
 874         InterfaceDI->InterfaceDereference = USBI_InterfaceDereference;
 875         InterfaceDI->GetUSBDIVersion = USBDI_GetUSBDIVersion;
 876         InterfaceDI->QueryBusTime = USBDI_QueryBusTime;
 877         InterfaceDI->SubmitIsoOutUrb = USBDI_SubmitIsoOutUrb;
 878         InterfaceDI->QueryBusInformation = USBDI_QueryBusInformation;
 879
 880         /* Interface version 1 */
 881         if (IoStack->Parameters.QueryInterface.Version >= 1)
 882             InterfaceDI->IsDeviceHighSpeed = USBDI_IsDeviceHighSpeed;
 883
 884         /* Interface version 2 */
 885         if (IoStack->Parameters.QueryInterface.Version >= 2)
 886             InterfaceDI->EnumLogEntry = USBDI_EnumLogEntry;
 887
 888         return STATUS_SUCCESS;
 889     }
 890     else
 891     {
 892         /* Convert GUID to string */
 893         Status = RtlStringFromGUID(IoStack->Parameters.QueryInterface.InterfaceType,
 894                                    &GuidBuffer);
 895
 896         if (NT_SUCCESS(Status))
 897         {
 898             /* Print interface */
 899             DPRINT1("HandleQueryInterface UNKNOWN INTERFACE GUID: %wZ Version %x\n",
 900                     &GuidBuffer,
 901                     IoStack->Parameters.QueryInterface.Version);
 902
 903             RtlFreeUnicodeString(&GuidBuffer); // Free GUID buffer
 904         }
 905     }
 906
 907     return Irp->IoStatus.Status;
 908 }