reactos/drivers/usb/usbport/iface.c

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