reactos/drivers/usb/usbehci/usbiffn.c

   1 /*
   2  * PROJECT:     ReactOS Universal Serial Bus Bulk Enhanced Host Controller Interface
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        drivers/usb/usbehci/usbiffn.c
   5  * PURPOSE:     Direct Call Interface Functions.
   6  * PROGRAMMERS:
   7  *              Michael Martin
   8  */
   9
  10 #include "usbehci.h"
  11 #include <hubbusif.h>
  12 #include <usbbusif.h>
  13
  14 PVOID InternalCreateUsbDevice(UCHAR DeviceNumber, ULONG Port, PUSB_DEVICE Parent, BOOLEAN Hub)
  15 {
  16     PUSB_DEVICE UsbDevicePointer = NULL;
  17     UsbDevicePointer = ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_DEVICE), USB_POOL_TAG);
  18
  19     if (!UsbDevicePointer)
  20     {
  21         DPRINT1("Out of memory\n");
  22         return NULL;
  23     }
  24
  25     RtlZeroMemory(UsbDevicePointer, sizeof(USB_DEVICE));
  26
  27     if ((Hub) && (!Parent))
  28     {
  29         DPRINT1("This is the root hub\n");
  30     }
  31
  32     UsbDevicePointer->Address = DeviceNumber;
  33     UsbDevicePointer->Port = Port;
  34     UsbDevicePointer->ParentDevice = Parent;
  35
  36     UsbDevicePointer->IsHub = Hub;
  37
  38     return UsbDevicePointer;
  39 }
  40
  41 BOOLEAN
  42 IsHandleValid(PVOID BusContext,
  43               PUSB_DEVICE_HANDLE DeviceHandle)
  44 {
  45     PPDO_DEVICE_EXTENSION PdoDeviceExtension;
  46     LONG i;
  47
  48     PdoDeviceExtension = (PPDO_DEVICE_EXTENSION) BusContext;
  49
  50     if (!DeviceHandle)
  51         return FALSE;
  52
  53     for (i = 0; i < 128; i++)
  54     {
  55         if (PdoDeviceExtension->UsbDevices[i] == DeviceHandle)
  56             return TRUE;
  57     }
  58
  59     return FALSE;
  60 }
  61
  62 VOID
  63 USB_BUSIFFN
  64 InterfaceReference(PVOID BusContext)
  65 {
  66     DPRINT1("InterfaceReference called\n");
  67 }
  68
  69 VOID
  70 USB_BUSIFFN
  71 InterfaceDereference(PVOID BusContext)
  72 {
  73     DPRINT1("InterfaceDereference called\n");
  74 }
  75
  76 /* Bus Interface Hub V5 Functions */
  77
  78 NTSTATUS
  79 USB_BUSIFFN
  80 CreateUsbDevice(PVOID BusContext,
  81                 PUSB_DEVICE_HANDLE *NewDevice,
  82                 PUSB_DEVICE_HANDLE HubDeviceHandle,
  83                 USHORT PortStatus, USHORT PortNumber)
  84 {
  85     PPDO_DEVICE_EXTENSION PdoDeviceExtension;
  86     PUSB_DEVICE UsbDevice;
  87     LONG i = 0;
  88     PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)BusContext)->DeviceExtension;
  89     DPRINT1("CreateUsbDevice: HubDeviceHandle %x, PortStatus %x, PortNumber %x\n", HubDeviceHandle, PortStatus, PortNumber);
  90
  91     UsbDevice = InternalCreateUsbDevice(PdoDeviceExtension->ChildDeviceCount, PortNumber, HubDeviceHandle, FALSE);
  92
  93     /* Add it to the list */
  94     while (TRUE)
  95     {
  96         if (PdoDeviceExtension->UsbDevices[i] == NULL)
  97         {
  98             PdoDeviceExtension->UsbDevices[i] = (PUSB_DEVICE)UsbDevice;
  99             PdoDeviceExtension->UsbDevices[i]->Address = i + 1;
 100             PdoDeviceExtension->UsbDevices[i]->Port = PortNumber;
 101             break;
 102         }
 103         i++;
 104     }
 105
 106     /* Return it */
 107     *NewDevice = UsbDevice;
 108     return STATUS_SUCCESS;
 109 }
 110
 111 /* Called when SCE reports a change */
 112 /* FIXME: Do something better for memory */
 113 NTSTATUS
 114 USB_BUSIFFN
 115 InitializeUsbDevice(PVOID BusContext, PUSB_DEVICE_HANDLE DeviceHandle)
 116 {
 117     PPDO_DEVICE_EXTENSION PdoDeviceExtension;
 118     PFDO_DEVICE_EXTENSION FdoDeviceExtension;
 119     USB_DEFAULT_PIPE_SETUP_PACKET CtrlSetup;
 120     PUSB_CONFIGURATION_DESCRIPTOR ConfigDesc;
 121     PUSB_INTERFACE_DESCRIPTOR InterfaceDesc;
 122     PUSB_ENDPOINT_DESCRIPTOR EndpointDesc;
 123     PUSB_DEVICE UsbDevice;
 124     BOOLEAN ResultOk;
 125     PVOID Buffer;
 126     PUCHAR Ptr;
 127     LONG i, j, k;
 128
 129     DPRINT1("InitializeUsbDevice called, device %x\n", DeviceHandle);
 130     PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)BusContext)->DeviceExtension;
 131     FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)PdoDeviceExtension->ControllerFdo->DeviceExtension;
 132     UsbDevice = (PUSB_DEVICE) DeviceHandle;
 133
 134     Buffer = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, USB_POOL_TAG);
 135
 136     if (!Buffer)
 137     {
 138         DPRINT1("Out of memory\n");
 139         return STATUS_NO_MEMORY;
 140     }
 141
 142     Ptr = Buffer;
 143     /* Set the device address */
 144     CtrlSetup.bmRequestType._BM.Recipient = BMREQUEST_TO_DEVICE;
 145     CtrlSetup.bmRequestType._BM.Type = BMREQUEST_STANDARD;
 146     CtrlSetup.bmRequestType._BM.Dir = BMREQUEST_HOST_TO_DEVICE;
 147     CtrlSetup.bRequest = USB_REQUEST_SET_ADDRESS;
 148     CtrlSetup.wValue.W = UsbDevice->Address;
 149     CtrlSetup.wIndex.W = 0;
 150     CtrlSetup.wLength = 0;
 151
 152     ResultOk = ExecuteControlRequest(FdoDeviceExtension, &CtrlSetup, 0, 0, NULL, 0);
 153
 154     /* Get the Device Descriptor */
 155     CtrlSetup.bmRequestType._BM.Recipient = BMREQUEST_TO_DEVICE;
 156     CtrlSetup.bmRequestType._BM.Type = BMREQUEST_STANDARD;
 157     CtrlSetup.bmRequestType._BM.Dir = BMREQUEST_DEVICE_TO_HOST;
 158     CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
 159     CtrlSetup.wValue.LowByte = 0;
 160     CtrlSetup.wValue.HiByte = USB_DEVICE_DESCRIPTOR_TYPE;
 161     CtrlSetup.wIndex.W = 0;
 162     CtrlSetup.wLength = sizeof(USB_DEVICE_DESCRIPTOR);
 163
 164     ResultOk = ExecuteControlRequest(FdoDeviceExtension, &CtrlSetup, UsbDevice->Address, UsbDevice->Port,
 165                                      &UsbDevice->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
 166
 167     DPRINT1("bLength %x\n", UsbDevice->DeviceDescriptor.bLength);
 168     DPRINT1("bDescriptorType %x\n", UsbDevice->DeviceDescriptor.bDescriptorType);
 169     DPRINT1("bNumDescriptors %x\n", UsbDevice->DeviceDescriptor.bNumConfigurations);
 170
 171     if (UsbDevice->DeviceDescriptor.bNumConfigurations == 0)
 172         return STATUS_DEVICE_DATA_ERROR;
 173
 174     UsbDevice->Configs = ExAllocatePoolWithTag(NonPagedPool,
 175                                                sizeof(PVOID) * UsbDevice->DeviceDescriptor.bNumConfigurations,
 176                                                USB_POOL_TAG);
 177
 178     if (!UsbDevice->Configs)
 179     {
 180         DPRINT1("Out of memory\n");
 181         return STATUS_NO_MEMORY;
 182     }
 183
 184     for (i = 0; i < UsbDevice->DeviceDescriptor.bNumConfigurations; i++)
 185     {
 186         /* Get the Device Configuration Descriptor */
 187         CtrlSetup.bmRequestType._BM.Recipient = BMREQUEST_TO_DEVICE;
 188         CtrlSetup.bmRequestType._BM.Type = BMREQUEST_STANDARD;
 189         CtrlSetup.bmRequestType._BM.Dir = BMREQUEST_DEVICE_TO_HOST;
 190         CtrlSetup.bRequest = USB_REQUEST_GET_DESCRIPTOR;
 191         CtrlSetup.wValue.LowByte = 0;
 192         CtrlSetup.wValue.HiByte = USB_CONFIGURATION_DESCRIPTOR_TYPE;
 193         CtrlSetup.wIndex.W = 0;
 194         CtrlSetup.wLength = PAGE_SIZE;
 195
 196         ResultOk = ExecuteControlRequest(FdoDeviceExtension, &CtrlSetup, UsbDevice->Address, UsbDevice->Port, Buffer, PAGE_SIZE);
 197
 198         ConfigDesc = (PUSB_CONFIGURATION_DESCRIPTOR)Ptr;
 199
 200         ASSERT(ConfigDesc->wTotalLength <= PAGE_SIZE);
 201
 202         UsbDevice->Configs[i] = ExAllocatePoolWithTag(NonPagedPool,
 203                                                       sizeof(USB_CONFIGURATION) + sizeof(PVOID) * ConfigDesc->bNumInterfaces,
 204                                                       USB_POOL_TAG);
 205         UsbDevice->Configs[i]->Device = UsbDevice;
 206         RtlCopyMemory(&UsbDevice->Configs[0]->ConfigurationDescriptor,
 207                       ConfigDesc, sizeof(USB_CONFIGURATION_DESCRIPTOR));
 208         Ptr += ConfigDesc->bLength;
 209
 210         for (j = 0; j < ConfigDesc->bNumInterfaces; j++)
 211         {
 212             InterfaceDesc = (PUSB_INTERFACE_DESCRIPTOR) Ptr;
 213             UsbDevice->Configs[i]->Interfaces[j] = ExAllocatePoolWithTag(NonPagedPool,
 214                                                                          sizeof(USB_INTERFACE) + sizeof(PVOID) * InterfaceDesc->bNumEndpoints,
 215                                                                          USB_POOL_TAG);
 216             RtlCopyMemory(&UsbDevice->Configs[i]->Interfaces[j]->InterfaceDescriptor,
 217                           InterfaceDesc,
 218                           sizeof(USB_INTERFACE_DESCRIPTOR));
 219
 220             Ptr += InterfaceDesc->bLength;
 221
 222             for (k = 0; k < InterfaceDesc->bNumEndpoints; k++)
 223             {
 224                 EndpointDesc = (PUSB_ENDPOINT_DESCRIPTOR)Ptr;
 225                 UsbDevice->Configs[i]->Interfaces[j]->EndPoints[k] = ExAllocatePoolWithTag(NonPagedPool, sizeof(USB_ENDPOINT), USB_POOL_TAG);
 226                 RtlCopyMemory(&UsbDevice->Configs[i]->Interfaces[j]->EndPoints[k]->EndPointDescriptor,
 227                               EndpointDesc, sizeof(USB_ENDPOINT_DESCRIPTOR));
 228             }
 229
 230         }
 231     }
 232
 233     UsbDevice->ActiveConfig = UsbDevice->Configs[0];
 234     UsbDevice->ActiveInterface = UsbDevice->Configs[0]->Interfaces[0];
 235
 236     return STATUS_SUCCESS;
 237 }
 238
 239 NTSTATUS
 240 USB_BUSIFFN
 241 GetUsbDescriptors(PVOID BusContext,
 242                   PUSB_DEVICE_HANDLE DeviceHandle,
 243                   PUCHAR DeviceDescriptorBuffer,
 244                   PULONG DeviceDescriptorBufferLength,
 245                   PUCHAR ConfigDescriptorBuffer,
 246                   PULONG ConfigDescriptorBufferLength)
 247 {
 248     PUSB_DEVICE UsbDevice;
 249     DPRINT1("GetUsbDescriptor %x, %d, %x, %d\n", DeviceDescriptorBuffer, DeviceDescriptorBufferLength, ConfigDescriptorBuffer, ConfigDescriptorBufferLength);
 250
 251     UsbDevice = (PUSB_DEVICE) DeviceHandle;
 252
 253     if ((DeviceDescriptorBuffer) && (DeviceDescriptorBufferLength))
 254     {
 255         RtlCopyMemory(DeviceDescriptorBuffer, &UsbDevice->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
 256         *DeviceDescriptorBufferLength = sizeof(USB_DEVICE_DESCRIPTOR);
 257     }
 258     if ((ConfigDescriptorBuffer) && (ConfigDescriptorBufferLength))
 259     {
 260         RtlCopyMemory(ConfigDescriptorBuffer, &UsbDevice->ActiveConfig->ConfigurationDescriptor, sizeof(USB_CONFIGURATION_DESCRIPTOR));
 261         *ConfigDescriptorBufferLength = sizeof(USB_CONFIGURATION_DESCRIPTOR);
 262     }
 263
 264     return STATUS_SUCCESS;
 265 }
 266
 267 NTSTATUS
 268 USB_BUSIFFN
 269 RemoveUsbDevice(PVOID BusContext, PUSB_DEVICE_HANDLE DeviceHandle, ULONG Flags)
 270 {
 271     DPRINT1("RemoveUsbDevice called\n");
 272     return STATUS_SUCCESS;
 273 }
 274
 275 NTSTATUS
 276 USB_BUSIFFN
 277 RestoreUsbDevice(PVOID BusContext, PUSB_DEVICE_HANDLE OldDeviceHandle, PUSB_DEVICE_HANDLE NewDeviceHandle)
 278 {
 279     DPRINT1("RestoreUsbDevice called\n");
 280     return STATUS_NOT_SUPPORTED;
 281 }
 282
 283 NTSTATUS
 284 USB_BUSIFFN
 285 GetPortHackFlags(PVOID BusContext, PULONG Flags)
 286 {
 287     DPRINT1("GetPortHackFlags called\n");
 288     return STATUS_NOT_SUPPORTED;
 289 }
 290
 291 NTSTATUS
 292 USB_BUSIFFN
 293 QueryDeviceInformation(PVOID BusContext,
 294                        PUSB_DEVICE_HANDLE DeviceHandle,
 295                        PVOID DeviceInformationBuffer,
 296                        ULONG DeviceInformationBufferLength,
 297                        PULONG LengthReturned)
 298 {
 299     PUSB_DEVICE_INFORMATION_0 DeviceInfo = DeviceInformationBuffer;
 300     PUSB_DEVICE UsbDevice = (PUSB_DEVICE) DeviceHandle;
 301     ULONG SizeNeeded;
 302     LONG i;
 303
 304     DPRINT1("QueryDeviceInformation (%x, %x, %x, %d, %x\n", BusContext, DeviceHandle, DeviceInformationBuffer, DeviceInformationBufferLength, LengthReturned);
 305
 306     /* Search for a valid usb device in this BusContext */
 307     if (!IsHandleValid(BusContext, DeviceHandle))
 308     {
 309         DPRINT1("Not a valid DeviceHandle\n");
 310         return STATUS_INVALID_PARAMETER;
 311     }
 312
 313     SizeNeeded = FIELD_OFFSET(USB_DEVICE_INFORMATION_0, PipeList[UsbDevice->ActiveInterface->InterfaceDescriptor.bNumEndpoints]);
 314     *LengthReturned = SizeNeeded;
 315
 316     DeviceInfo->ActualLength = SizeNeeded;
 317
 318     if (DeviceInformationBufferLength < SizeNeeded)
 319     {
 320         DPRINT1("Buffer to small\n");
 321         return STATUS_BUFFER_TOO_SMALL;
 322     }
 323
 324     if (DeviceInfo->InformationLevel != 0)
 325     {
 326         DPRINT1("Invalid Param\n");
 327         return STATUS_INVALID_PARAMETER;
 328     }
 329
 330     DeviceInfo->PortNumber = UsbDevice->Port;
 331     DeviceInfo->HubAddress = 1;
 332     DeviceInfo->DeviceAddress = UsbDevice->Address;
 333     DeviceInfo->DeviceSpeed = UsbDevice->DeviceSpeed;
 334     DeviceInfo->DeviceType = UsbDevice->DeviceType;
 335     DeviceInfo->CurrentConfigurationValue = UsbDevice->ActiveConfig->ConfigurationDescriptor.bConfigurationValue;
 336     DeviceInfo->NumberOfOpenPipes = UsbDevice->ActiveInterface->InterfaceDescriptor.bNumEndpoints;
 337
 338     RtlCopyMemory(&DeviceInfo->DeviceDescriptor, &UsbDevice->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
 339
 340     for (i = 0; i < UsbDevice->ActiveInterface->InterfaceDescriptor.bNumEndpoints; i++)
 341     {
 342         RtlCopyMemory(&DeviceInfo->PipeList[i].EndpointDescriptor, &UsbDevice->ActiveInterface->EndPoints[i]->EndPointDescriptor, sizeof(USB_ENDPOINT_DESCRIPTOR));
 343     }
 344     return STATUS_SUCCESS;
 345 }
 346
 347 NTSTATUS
 348 USB_BUSIFFN
 349 GetControllerInformation(PVOID BusContext,
 350                          PVOID ControllerInformationBuffer,
 351                          ULONG ControllerInformationBufferLength,
 352                          PULONG LengthReturned)
 353 {
 354     PUSB_CONTROLLER_INFORMATION_0 ControllerInfo;
 355
 356     DPRINT1("GetControllerInformation called\n");
 357
 358     ControllerInfo = ControllerInformationBuffer;
 359
 360     if (ControllerInformationBufferLength < sizeof(USB_CONTROLLER_INFORMATION_0))
 361     {
 362         DPRINT1("Buffer to small\n");
 363         return STATUS_BUFFER_TOO_SMALL;
 364     }
 365
 366     if (ControllerInfo->InformationLevel != 0)
 367     {
 368         DPRINT1("InformationLevel other than 0 not supported\n");
 369         return STATUS_NOT_SUPPORTED;
 370     }
 371
 372     ControllerInfo->ActualLength = sizeof(USB_CONTROLLER_INFORMATION_0);
 373     ControllerInfo->SelectiveSuspendEnabled = FALSE;
 374     ControllerInfo->IsHighSpeedController = TRUE;
 375
 376     *LengthReturned = ControllerInfo->ActualLength;
 377
 378     return STATUS_SUCCESS;
 379 }
 380
 381 NTSTATUS
 382 USB_BUSIFFN
 383 ControllerSelectiveSuspend(PVOID BusContext, BOOLEAN Enable)
 384 {
 385     DPRINT1("ControllerSelectiveSuspend called\n");
 386     return STATUS_NOT_SUPPORTED;
 387 }
 388
 389 NTSTATUS
 390 USB_BUSIFFN
 391 GetExtendedHubInformation(PVOID BusContext,
 392                           PDEVICE_OBJECT HubPhysicalDeviceObject,
 393                           PVOID HubInformationBuffer,
 394                           ULONG HubInformationBufferLength,
 395                           PULONG LengthReturned)
 396 {
 397
 398     PUSB_EXTHUB_INFORMATION_0 UsbExtHubInfo = HubInformationBuffer;
 399     PPDO_DEVICE_EXTENSION PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)BusContext)->DeviceExtension;
 400     PFDO_DEVICE_EXTENSION FdoDeviceExntension = (PFDO_DEVICE_EXTENSION)PdoDeviceExtension->ControllerFdo->DeviceExtension;
 401     LONG i;
 402     DPRINT1("GetExtendedHubInformation\n");
 403     /* Set the default return value */
 404     *LengthReturned = 0;
 405     /* Caller must have set InformationLevel to 0 */
 406     if (UsbExtHubInfo->InformationLevel != 0)
 407     {
 408         return STATUS_NOT_SUPPORTED;
 409     }
 410
 411     UsbExtHubInfo->NumberOfPorts = 8;
 412
 413     for (i=0; i < UsbExtHubInfo->NumberOfPorts; i++)
 414     {
 415         UsbExtHubInfo->Port[i].PhysicalPortNumber = i + 1;
 416         UsbExtHubInfo->Port[i].PortLabelNumber = FdoDeviceExntension->ECHICaps.HCSParams.PortCount;
 417         UsbExtHubInfo->Port[i].VidOverride = 0;
 418         UsbExtHubInfo->Port[i].PidOverride = 0;
 419         UsbExtHubInfo->Port[i].PortAttributes = USB_PORTATTR_SHARED_USB2;
 420     }
 421
 422     *LengthReturned = FIELD_OFFSET(USB_EXTHUB_INFORMATION_0, Port[8]);
 423
 424     return STATUS_SUCCESS;
 425 }
 426
 427 NTSTATUS
 428 USB_BUSIFFN
 429 GetRootHubSymbolicName(PVOID BusContext,
 430                        PVOID HubSymNameBuffer,
 431                        ULONG HubSymNameBufferLength,
 432                        PULONG HubSymNameActualLength)
 433 {
 434     DPRINT1("GetRootHubSymbolicName called\n");
 435
 436     if (HubSymNameBufferLength < 16)
 437         return STATUS_UNSUCCESSFUL;
 438     RtlCopyMemory(HubSymNameBuffer, L"ROOT_HUB", HubSymNameBufferLength);
 439     *HubSymNameActualLength = 16;
 440
 441     return STATUS_SUCCESS;
 442 }
 443
 444 PVOID
 445 USB_BUSIFFN
 446 GetDeviceBusContext(PVOID HubBusContext, PVOID DeviceHandle)
 447 {
 448     DPRINT1("GetDeviceBusContext called\n");
 449     return NULL;
 450 }
 451
 452 NTSTATUS
 453 USB_BUSIFFN
 454 Initialize20Hub(PVOID BusContext, PUSB_DEVICE_HANDLE HubDeviceHandle, ULONG TtCount)
 455 {
 456     DPRINT1("Initialize20Hub called, HubDeviceHandle: %x\n", HubDeviceHandle);
 457
 458     /* FIXME: */
 459     /* Create the Irp Queue for SCE */
 460     /* Should queue be created for each device or each enpoint??? */
 461     return STATUS_SUCCESS;
 462 }
 463
 464 NTSTATUS
 465 USB_BUSIFFN
 466 RootHubInitNotification(PVOID BusContext, PVOID CallbackContext, PRH_INIT_CALLBACK CallbackRoutine)
 467 {
 468     PPDO_DEVICE_EXTENSION PdoDeviceExtension;
 469     DPRINT1("RootHubInitNotification %x, %x, %x\n", BusContext, CallbackContext, CallbackRoutine);
 470
 471     PdoDeviceExtension = (PPDO_DEVICE_EXTENSION)((PDEVICE_OBJECT)BusContext)->DeviceExtension;
 472     PdoDeviceExtension->CallbackContext = CallbackContext;
 473     PdoDeviceExtension->CallbackRoutine = CallbackRoutine;
 474     if (PdoDeviceExtension->CallbackRoutine)
 475     {
 476         DPRINT1("Called Callbackrountine\n");
 477         PdoDeviceExtension->CallbackRoutine(PdoDeviceExtension->CallbackContext);
 478         DPRINT1("Done Callbackrountine\n");
 479     }
 480     else
 481     {
 482         DPRINT1("PdoDeviceExtension->CallbackRoutine is NULL!\n");
 483     }
 484
 485     return STATUS_SUCCESS;
 486 }
 487
 488 VOID
 489 USB_BUSIFFN
 490 FlushTransfers(PVOID BusContext, PVOID DeviceHandle)
 491 {
 492     DPRINT1("FlushTransfers\n");
 493 }
 494
 495 VOID
 496 USB_BUSIFFN
 497 SetDeviceHandleData(PVOID BusContext, PVOID DeviceHandle, PDEVICE_OBJECT UsbDevicePdo)
 498 {
 499     DPRINT1("SetDeviceHandleData called\n");
 500 }
 501
 502
 503 /* USB_BUS_INTERFACE_USBDI_V2 Functions */
 504
 505 VOID
 506 USB_BUSIFFN
 507 GetUSBDIVersion(PVOID BusContext, PUSBD_VERSION_INFORMATION VersionInformation, PULONG HcdCapabilites)
 508 {
 509     DPRINT1("GetUSBDIVersion called\n");
 510     return;
 511 }
 512
 513 NTSTATUS
 514 USB_BUSIFFN
 515 QueryBusTime(PVOID BusContext, PULONG CurrentFrame)
 516 {
 517     DPRINT1("QueryBusTime called\n");
 518     return STATUS_NOT_SUPPORTED;
 519 }
 520
 521 NTSTATUS
 522 USB_BUSIFFN
 523 SubmitIsoOutUrb(PVOID BusContext, PURB Urb)
 524 {
 525     DPRINT1("SubmitIsoOutUrb called\n");
 526     return STATUS_NOT_SUPPORTED;
 527 }
 528
 529 NTSTATUS
 530 USB_BUSIFFN
 531 QueryBusInformation(PVOID BusContext,
 532                     ULONG Level,
 533                     PVOID BusInformationBuffer,
 534                     PULONG BusInformationBufferLength,
 535                     PULONG BusInformationActualLength)
 536 {
 537     DPRINT1("QueryBusInformation called\n");
 538     return STATUS_NOT_SUPPORTED;
 539 }
 540
 541 BOOLEAN
 542 USB_BUSIFFN
 543 IsDeviceHighSpeed(PVOID BusContext)
 544 {
 545     DPRINT1("IsDeviceHighSpeed called\n");
 546     return TRUE;
 547 }
 548
 549 NTSTATUS
 550 USB_BUSIFFN
 551 EnumLogEntry(PVOID BusContext, ULONG DriverTag, ULONG EnumTag, ULONG P1, ULONG P2)
 552 {
 553     DPRINT1("EnumLogEntry called\n");
 554     return STATUS_NOT_SUPPORTED;
 555 }