drivers/usb/usbohci/interfaces.h

   1
   2 #ifndef INTERFACES_HPP
   3 #define INTERFACES_HPP
   4
   5 //---------------------------------------------------------------------------
   6 //
   7 //          Object Hierachy
   8 //       --------------------------------------------------------------------
   9 //       |  IRootHCDController                                              |
  10 //       |    IHCDController Intel USB Universal Host Controller - 3A37     |
  11 //       |    IHCDController - Intel USB Universal HostController - 3A38    |
  12 //       |    IHCDController - Intel USB Universal HostController - 3A38    |
  13 //       |------------------------------------------------------------------|
  14 //
  15 //
  16 //       IHCDController Intel USB Universal Host Controller - 3A37
  17 //         IHubController
  18 //         IUSBHardwareDevice
  19 //           IDMAMemoryManager
  20 //           IUSBQueue  <-      interacts with -> IUSBRequest
  21 //
  22 //
  23 //  Each IHCDController creates an IUSBHardwareDevice class upon initialization. The
  24 //  IUSBHardwardeDevice class is used to abstract usb controller specifics. The IHubController
  25 //  manages all attached devices and handles hub control ioctl requests.
  26 //
  27 //  Each IUSBHardwareDevice has one IDMAMemoryManager and one IUSBQueue. The IDMAMemoryManager
  28 //  is used to handle dma memory allocations. The IUSBQueue manages requests which are send to the
  29 //  usb hardware. See IUSBRequest class for details.
  30 //
  31
  32
  33 //=========================================================================================
  34 //
  35 // class IRootHCDController
  36 //
  37 // Description: This class serves as the root host controller. The host controller mantains
  38 // a list of registered controllers and provides support functions for the host controllers
  39
  40 struct IHCDController;
  41
  42 DECLARE_INTERFACE_(IRootHCDController, IUnknown)
  43 {
  44     DEFINE_ABSTRACT_UNKNOWN()
  45
  46 //-----------------------------------------------------------------------------------------
  47 //
  48 // Initialize
  49 //
  50 // Description: This function initializes the root host controller. It allocates the resources
  51 // required to manage the registered controllers
  52
  53     virtual NTSTATUS Initialize() = 0;
  54
  55 //-----------------------------------------------------------------------------------------
  56 //
  57 // RegisterHCD
  58 //
  59 // Description: this function registers a host controller with the root host controller
  60
  61     virtual NTSTATUS RegisterHCD(struct IHCDController * Controller) = 0;
  62
  63 //-----------------------------------------------------------------------------------------
  64 //
  65 // UnregisterHCD
  66 //
  67 // Description: this function unregistes a host controller
  68
  69     virtual NTSTATUS UnregisterHCD(struct IHCDController * Controller) = 0;
  70
  71 //-----------------------------------------------------------------------------------------
  72 //
  73 // GetControllerCount
  74 //
  75 // Description: returns the number of host controllers registered
  76
  77     virtual ULONG GetControllerCount() = 0;
  78
  79 };
  80
  81 typedef IRootHCDController *PROOTHDCCONTROLLER;
  82
  83 //=========================================================================================
  84 //
  85 // class IHCDController
  86 //
  87 // Description: This class is used to manage a single USB host controller
  88 //
  89
  90 DECLARE_INTERFACE_(IHCDController, IUnknown)
  91 {
  92     DEFINE_ABSTRACT_UNKNOWN()
  93
  94 //-----------------------------------------------------------------------------------------
  95 //
  96 // Initialize
  97 //
  98 // Description: This function initializes the IHCDController implementation.
  99 // It creates an IUSBHardwareDevice object and initializes it. It also registeres itself with
 100 // the IRootHCDController
 101 //
 102     virtual NTSTATUS Initialize(IN PROOTHDCCONTROLLER RootHCDController,
 103                                 IN PDRIVER_OBJECT DriverObject,
 104                                 IN PDEVICE_OBJECT PhysicalDeviceObject) = 0;
 105
 106 };
 107
 108 typedef IHCDController *PHCDCONTROLLER;
 109
 110 struct _OHCI_ENDPOINT_DESCRIPTOR;
 111 //=========================================================================================
 112 //
 113 // class IUSBHardwareDevice
 114 //
 115 // Description: This class provides access to the usb hardware controller
 116 //
 117
 118 struct IDMAMemoryManager;
 119 struct IUSBQueue;
 120
 121 DECLARE_INTERFACE_(IUSBHardwareDevice, IUnknown)
 122 {
 123     DEFINE_ABSTRACT_UNKNOWN()
 124
 125 //-----------------------------------------------------------------------------------------
 126 //
 127 // Initialize
 128 //
 129 // Description: Initializes the usb device controller
 130
 131     virtual NTSTATUS Initialize(PDRIVER_OBJECT DriverObject,
 132                                 PDEVICE_OBJECT FunctionalDeviceObject,
 133                                 PDEVICE_OBJECT PhysicalDeviceObject,
 134                                 PDEVICE_OBJECT LowerDeviceObject) = 0;
 135
 136 //-----------------------------------------------------------------------------------------
 137 //
 138 // PnpStart
 139 //
 140 // Description: handles pnp start request from device. It registeres the interrupt,
 141 // sets up the ports and prepares the device. It then starts the controller
 142
 143    virtual NTSTATUS PnpStart(PCM_RESOURCE_LIST RawResources,
 144                              PCM_RESOURCE_LIST TranslatedResources) = 0;
 145
 146 //-----------------------------------------------------------------------------------------
 147 //
 148 // PnpStop
 149 //
 150 // Description: handles pnp stop request from device. It unregisteres the interrupt, releases ports and dma object.
 151
 152     virtual NTSTATUS PnpStop(void) = 0;
 153
 154 //-----------------------------------------------------------------------------------------
 155 //
 156 // GetDeviceDetails
 157 //
 158 // Description: returns the device details such as vendor id, device id, number of ports and speed
 159
 160     virtual NTSTATUS GetDeviceDetails(OUT OPTIONAL PUSHORT VendorId,
 161                                       OUT OPTIONAL PUSHORT DeviceId,
 162                                       OUT OPTIONAL PULONG NumberOfPorts,
 163                                       OUT OPTIONAL PULONG Speed) = 0;
 164
 165 //-----------------------------------------------------------------------------------------
 166 //
 167 // GetUSBQueue
 168 //
 169 // Description: returns interface to internal IUSBQueue
 170 // Interface is reference counted, you need to call release method when you are done with it
 171 // Do not call Initialize on IUSBQueue, the object is already initialized
 172
 173     virtual NTSTATUS GetUSBQueue(OUT struct IUSBQueue **OutUsbQueue) = 0;
 174
 175 //-----------------------------------------------------------------------------------------
 176 //
 177 // GetBulkHeadEndpointDescriptor
 178 //
 179 // Description: returns the bulk head endpoint descriptor
 180
 181     virtual NTSTATUS GetBulkHeadEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
 182
 183 //-----------------------------------------------------------------------------------------
 184 //
 185 // GetControlHeadEndpointDescriptor
 186 //
 187 // Description: returns the control head endpoint descriptor
 188
 189     virtual NTSTATUS GetControlHeadEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
 190
 191 //-----------------------------------------------------------------------------------------
 192 //
 193 // HeadEndpointDescriptorModified
 194 //
 195 // Description: notifies the hardware that an endpoint descriptor was added to head endpoint descriptor
 196
 197     virtual VOID HeadEndpointDescriptorModified(ULONG HeadType) = 0;
 198
 199
 200
 201
 202 //-----------------------------------------------------------------------------------------
 203 //
 204 // GetDMA
 205 //
 206 // Description: returns the DMA object which can be used to allocate memory from the common buffer
 207
 208     virtual NTSTATUS GetDMA(OUT struct IDMAMemoryManager **OutDMAMemoryManager) = 0;
 209
 210
 211 //-----------------------------------------------------------------------------------------
 212 //
 213 // ResetController()
 214 //
 215 // Description: this function resets the controller
 216 // Returns STATUS_SUCCESS when the controller was successfully reset
 217
 218    virtual NTSTATUS ResetController() = 0;
 219
 220 //-----------------------------------------------------------------------------------------
 221 //
 222 // StartController
 223 //
 224 // Description: this functions starts controller allowing interrupts for device connects/removal, and execution of
 225 // Periodic and Asynchronous Schedules.
 226 //
 227
 228     virtual NTSTATUS StartController() = 0;
 229
 230 //-----------------------------------------------------------------------------------------
 231 //
 232 // StopController
 233 //
 234 // Description: this functions stops controller disabling interrupts for device connects/removal, and execution of
 235 // Periodic and Asynchronous Schedules.
 236 //
 237
 238     virtual NTSTATUS StopController() = 0;
 239
 240 //-----------------------------------------------------------------------------------------
 241 //
 242 // ResetPort
 243 //
 244 // Description: this functions resets the port on the controller
 245 //
 246
 247     virtual NTSTATUS ResetPort(ULONG PortNumber) = 0;
 248
 249 //-----------------------------------------------------------------------------------------
 250 //
 251 // GetPortStatus
 252 //
 253 // Description: this functions return status and change state of port
 254 //
 255     virtual NTSTATUS GetPortStatus(ULONG PortId, OUT USHORT *PortStatus, OUT USHORT *PortChange) = 0;
 256
 257 //-----------------------------------------------------------------------------------------
 258 //
 259 // ClearPortStatus
 260 //
 261 // Description: Clears Status of Port, for example Connection, Enable and Reset
 262 //
 263     virtual NTSTATUS ClearPortStatus(ULONG PortId, ULONG Status) = 0;
 264
 265 //-----------------------------------------------------------------------------------------
 266 //
 267 // SetPortFeature
 268 //
 269 // Description: this functions Sets Feature on Port, for example Enable, Power and Reset
 270 //
 271     virtual NTSTATUS SetPortFeature(ULONG PortId, ULONG Feature) = 0;
 272
 273 //-----------------------------------------------------------------------------------------
 274 //
 275 // SetStatusChangeEndpointCallBack
 276 //
 277 // Description: Used to callback to the hub controller when SCE detected
 278 //
 279     virtual VOID SetStatusChangeEndpointCallBack(PVOID CallBack,PVOID Context) = 0;
 280
 281 //-----------------------------------------------------------------------------------------
 282 //
 283 // AcquireDeviceLock
 284 //
 285 // Description: acquires the device lock
 286
 287     virtual KIRQL AcquireDeviceLock(void) = 0;
 288
 289 //-----------------------------------------------------------------------------------------
 290 //
 291 // ReleaseLock
 292 //
 293 // Description: releases the device lock
 294
 295     virtual void ReleaseDeviceLock(KIRQL OldLevel) = 0;
 296 };
 297
 298 typedef IUSBHardwareDevice *PUSBHARDWAREDEVICE;
 299
 300
 301 //=========================================================================================
 302 //
 303 // class IDMAMemoryManager
 304 //
 305 // Description: This class provides access to the dma buffer. It provides methods to
 306 // allocate and free from the dma buffer
 307 //
 308
 309 DECLARE_INTERFACE_(IDMAMemoryManager, IUnknown)
 310 {
 311     DEFINE_ABSTRACT_UNKNOWN()
 312
 313 //-----------------------------------------------------------------------------------------
 314 //
 315 // Initialize
 316 //
 317 // Description: initializes the memory manager
 318
 319     virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Device,
 320                                 IN PKSPIN_LOCK Lock,
 321                                 IN ULONG DmaBufferSize,
 322                                 IN PVOID VirtualBase,
 323                                 IN PHYSICAL_ADDRESS PhysicalAddress,
 324                                 IN ULONG DefaultBlockSize) = 0;
 325
 326 //-----------------------------------------------------------------------------------------
 327 //
 328 // Allocate
 329 //
 330 // Description: allocates block of memory from allocator
 331
 332     virtual NTSTATUS Allocate(IN ULONG Size,
 333                               OUT PVOID *OutVirtualBase,
 334                               OUT PPHYSICAL_ADDRESS OutPhysicalAddress) = 0;
 335
 336
 337 //-----------------------------------------------------------------------------------------
 338 //
 339 // Free
 340 //
 341 // Description: releases memory block
 342
 343     virtual NTSTATUS Release(IN PVOID VirtualBase,
 344                              IN ULONG Size) = 0;
 345
 346 };
 347
 348 typedef IDMAMemoryManager *PDMAMEMORYMANAGER;
 349
 350
 351 //=========================================================================================
 352 //
 353 // class IUSBRequest
 354 //
 355 // Description: This class is used to issue request to usb controller. The class is
 356 // initialized using InitializeXXX methods. You also need to call SetEndpoint to define the endpoint
 357 // In addition you can call SetCompletionDetails if you need to wait for the end of
 358 // the request or want to complete an irp. You call AddUSBRequest to add the request to the queue.
 359 // Once the request is completed the CompletionCallback is invoked. The CompletionCallback
 360 // will take care of any completion details which have been set. If the request is cancelled, the
 361 // CancelCallback routine is invoked.
 362 //
 363
 364 DECLARE_INTERFACE_(IUSBRequest, IUnknown)
 365 {
 366     DEFINE_ABSTRACT_UNKNOWN()
 367
 368 //-----------------------------------------------------------------------------------------
 369 //
 370 // InitializeWithSetupPacket
 371 //
 372 // Description: initializes the request packet with an setup packet
 373 // If there is a TransferBuffer, the TransferBufferLength contains the length of the buffer
 374
 375
 376     virtual NTSTATUS InitializeWithSetupPacket(IN PDMAMEMORYMANAGER DmaManager,
 377                                                IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
 378                                                IN UCHAR DeviceAddress,
 379                                                IN OPTIONAL PUSB_ENDPOINT_DESCRIPTOR EndpointDescriptor,
 380                                                IN OUT ULONG TransferBufferLength,
 381                                                IN OUT PMDL TransferBuffer) = 0;
 382
 383 //-----------------------------------------------------------------------------------------
 384 //
 385 // InitializeWithIrp
 386 //
 387 // Description: initializes the request with an IRP
 388 // The irp contains an URB block which contains all necessary information
 389
 390     virtual NTSTATUS InitializeWithIrp(IN PDMAMEMORYMANAGER DmaManager,
 391                                        IN OUT PIRP Irp) = 0;
 392
 393 //-----------------------------------------------------------------------------------------
 394 //
 395 //  IsRequestComplete
 396 //
 397 // Description: returns true when the request has been completed
 398 // Should be called after the CompletionCallback has been invoked
 399 // This function is called by IUSBQueue after queue head has been completed
 400 // If the function returns true, IUSBQueue will then call ShouldReleaseRequestAfterCompletion
 401 // If that function returns also true, it calls Release() to delete the IUSBRequest
 402
 403     virtual BOOLEAN IsRequestComplete() = 0;
 404
 405 //-----------------------------------------------------------------------------------------
 406 //
 407 // GetTransferType
 408 //
 409 // Description: returns the type of the request: control, bulk, iso, interrupt
 410
 411     virtual ULONG GetTransferType() = 0;
 412
 413 //-----------------------------------------------------------------------------------------
 414 //
 415 // GetEndpointDescriptor
 416 //
 417 // Description: returns the general transfer descriptor
 418
 419     virtual NTSTATUS GetEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR ** OutDescriptor) = 0;
 420
 421 //-----------------------------------------------------------------------------------------
 422 //
 423 // GetResultStatus
 424 //
 425 // Description: returns the status code of the result
 426 // Note: this function will block the caller untill the request has been completed
 427
 428     virtual VOID GetResultStatus(OUT OPTIONAL NTSTATUS * NtStatusCode,
 429                                  OUT OPTIONAL PULONG UrbStatusCode) = 0;
 430
 431 //-----------------------------------------------------------------------------------------
 432 //
 433 // IsRequestInitialized
 434 //
 435 // Description: returns true when the request has been successfully initialized using InitializeXXX methods
 436
 437     virtual BOOLEAN IsRequestInitialized() = 0;
 438
 439 //-----------------------------------------------------------------------------------------
 440 //
 441 // CompletionCallback
 442 //
 443 // Description: notifies request that the endpoint descriptor is complete
 444
 445     virtual VOID CompletionCallback(struct _OHCI_ENDPOINT_DESCRIPTOR * OutDescriptor) = 0;
 446
 447 //-----------------------------------------------------------------------------------------
 448 //
 449 // FreeEndpointDescriptor
 450 //
 451 // Description: frees the associated endpoint descriptor and its general descriptors
 452
 453     virtual VOID FreeEndpointDescriptor(struct _OHCI_ENDPOINT_DESCRIPTOR * OutDescriptor) = 0;
 454 };
 455
 456
 457 typedef IUSBRequest *PUSBREQUEST;
 458
 459 //=========================================================================================
 460 //
 461 // class IUSBQueue
 462 //
 463 // Description: This class manages pending requests
 464 //
 465
 466 DECLARE_INTERFACE_(IUSBQueue, IUnknown)
 467 {
 468     DEFINE_ABSTRACT_UNKNOWN()
 469
 470 //-----------------------------------------------------------------------------------------
 471 //
 472 // Initialize
 473 //
 474 // Description: initializes the object
 475
 476     virtual NTSTATUS Initialize(IN PUSBHARDWAREDEVICE Hardware,
 477                                 IN PDMA_ADAPTER AdapterObject,
 478                                 IN PDMAMEMORYMANAGER MemManager,
 479                                 IN OPTIONAL PKSPIN_LOCK Lock) = 0;
 480
 481 //-----------------------------------------------------------------------------------------
 482 //
 483 // GetPendingRequestCount
 484 //
 485 // Description: returns the number of pending requests true from IsRequestComplete
 486
 487     virtual ULONG GetPendingRequestCount() = 0;
 488
 489 //-----------------------------------------------------------------------------------------
 490 //
 491 // AddUSBRequest
 492 //
 493 // Description: adds an usb request to the queue.
 494 // Returns status success when successful
 495
 496     virtual NTSTATUS AddUSBRequest(IUSBRequest * Request) = 0;
 497
 498 //-----------------------------------------------------------------------------------------
 499 //
 500 // CancelRequests()
 501 //
 502 // Description: cancels all requests
 503
 504     virtual NTSTATUS CancelRequests() = 0;
 505
 506 //-----------------------------------------------------------------------------------------
 507 //
 508 // CreateUSBRequest
 509 //
 510 // Description: creates an usb request
 511
 512     virtual NTSTATUS CreateUSBRequest(IUSBRequest **OutRequest) = 0;
 513
 514 //-----------------------------------------------------------------------------------------
 515 //
 516 // TransferDescriptorCompletionCallback
 517 //
 518 // Description: notifies the queue that a transfer was completed
 519
 520     virtual VOID TransferDescriptorCompletionCallback(ULONG TransferDescriptorLogicalAddress) = 0;
 521
 522 };
 523
 524 typedef IUSBQueue *PUSBQUEUE;
 525
 526 //=========================================================================================
 527 //
 528 // class IHubController
 529 //
 530 // Description: This class implements a hub controller
 531 //
 532
 533 DECLARE_INTERFACE_(IHubController, IUnknown)
 534 {
 535     DEFINE_ABSTRACT_UNKNOWN()
 536
 537 //----------------------------------------------------------------------------------------
 538 //
 539 // Initialize
 540 //
 541 // Description: Initializes the hub controller
 542
 543     virtual NTSTATUS Initialize(IN PDRIVER_OBJECT DriverObject,
 544                                 IN PHCDCONTROLLER Controller,
 545                                 IN PUSBHARDWAREDEVICE Device,
 546                                 IN BOOLEAN IsRootHubDevice,
 547                                 IN ULONG DeviceAddress) = 0;
 548
 549 //----------------------------------------------------------------------------------------
 550 //
 551 // GetHubControllerDeviceObject
 552 //
 553 // Description: Returns the hub controller device object
 554
 555     virtual NTSTATUS GetHubControllerDeviceObject(PDEVICE_OBJECT * HubDeviceObject) = 0;
 556
 557 //----------------------------------------------------------------------------------------
 558 //
 559 // GetHubControllerSymbolicLink
 560 //
 561 // Description: Returns the symbolic link of the root hub
 562
 563     virtual NTSTATUS GetHubControllerSymbolicLink(ULONG BufferLength, PVOID Buffer, PULONG RequiredLength) = 0;
 564
 565
 566 };
 567
 568 typedef IHubController *PHUBCONTROLLER;
 569
 570 //=========================================================================================
 571 //
 572 // class IDispatchIrp
 573 //
 574 // Description: This class is used to handle irp dispatch requests
 575 //
 576
 577 DECLARE_INTERFACE_(IDispatchIrp, IUnknown)
 578 {
 579     DEFINE_ABSTRACT_UNKNOWN()
 580
 581 //-----------------------------------------------------------------------------------------
 582 //
 583 // HandlePnp
 584 //
 585 // Description: This function handles all pnp requests
 586
 587     virtual NTSTATUS HandlePnp(IN PDEVICE_OBJECT DeviceObject,
 588                                IN OUT PIRP Irp) = 0;
 589
 590 //-----------------------------------------------------------------------------------------
 591 //
 592 // HandlePower
 593 //
 594 // Description: This function handles all power pnp requests
 595 //
 596     virtual NTSTATUS HandlePower(IN PDEVICE_OBJECT DeviceObject,
 597                                  IN OUT PIRP Irp) = 0;
 598
 599 //-----------------------------------------------------------------------------------------
 600 //
 601 // HandleDeviceControl
 602 //
 603 // Description: handles device io control requests
 604
 605     virtual NTSTATUS HandleDeviceControl(IN PDEVICE_OBJECT DeviceObject,
 606                                          IN OUT PIRP Irp) = 0;
 607 };
 608
 609 typedef IDispatchIrp *PDISPATCHIRP;
 610
 611 //=========================================================================================
 612 //
 613 // class IUSBDevice
 614 //
 615 // Description: This class is used to abstract details of a usb device
 616 //
 617
 618 DECLARE_INTERFACE_(IUSBDevice, IUnknown)
 619 {
 620     DEFINE_ABSTRACT_UNKNOWN()
 621
 622 //----------------------------------------------------------------------------------------
 623 //
 624 // Initialize
 625 //
 626 // Description: Initializes the usb device
 627
 628     virtual NTSTATUS Initialize(IN PHUBCONTROLLER HubController,
 629                                 IN PUSBHARDWAREDEVICE Device,
 630                                 IN PVOID Parent,
 631                                 IN ULONG Port,
 632                                 IN ULONG PortStatus) = 0;
 633
 634 //-----------------------------------------------------------------------------------------
 635 //
 636 // IsHub
 637 //
 638 // Description: returns true when device is a hub
 639
 640     virtual BOOLEAN IsHub() = 0;
 641
 642 //-----------------------------------------------------------------------------------------
 643 //
 644 // GetParent
 645 //
 646 // Description: gets the parent device of the this device
 647
 648     virtual NTSTATUS GetParent(PVOID * Parent) = 0;
 649
 650 //-----------------------------------------------------------------------------------------
 651 //
 652 // GetDeviceAddress
 653 //
 654 // Description: gets the device address of the this device
 655
 656     virtual UCHAR GetDeviceAddress() = 0;
 657
 658
 659 //-----------------------------------------------------------------------------------------
 660 //
 661 // GetPort
 662 //
 663 // Description: gets the port to which this device is connected
 664
 665     virtual ULONG GetPort() = 0;
 666
 667 //-----------------------------------------------------------------------------------------
 668 //
 669 // GetSpeed
 670 //
 671 // Description: gets the speed of the device
 672
 673     virtual USB_DEVICE_SPEED GetSpeed() = 0;
 674
 675 //-----------------------------------------------------------------------------------------
 676 //
 677 // GetType
 678 //
 679 // Description: gets the type of the device, either 1.1 or 2.0 device
 680
 681     virtual USB_DEVICE_TYPE GetType() = 0;
 682
 683 //-----------------------------------------------------------------------------------------
 684 //
 685 // GetState
 686 //
 687 // Description: gets the device state
 688
 689     virtual ULONG GetState() = 0;
 690
 691 //-----------------------------------------------------------------------------------------
 692 //
 693 // SetDeviceHandleData
 694 //
 695 // Description: sets device handle data
 696
 697     virtual void SetDeviceHandleData(PVOID Data) = 0;
 698
 699 //-----------------------------------------------------------------------------------------
 700 //
 701 // SetDeviceAddress
 702 //
 703 // Description: sets device handle data
 704
 705     virtual NTSTATUS SetDeviceAddress(UCHAR DeviceAddress) = 0;
 706
 707 //-----------------------------------------------------------------------------------------
 708 //
 709 // GetDeviceDescriptor
 710 //
 711 // Description: sets device handle data
 712
 713     virtual void GetDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR DeviceDescriptor) = 0;
 714
 715 //-----------------------------------------------------------------------------------------
 716 //
 717 // GetConfigurationValue
 718 //
 719 // Description: gets current selected configuration index
 720
 721    virtual UCHAR GetConfigurationValue() = 0;
 722
 723 //-----------------------------------------------------------------------------------------
 724 //
 725 // SubmitIrp
 726 //
 727 // Description: submits an irp containing an urb
 728
 729     virtual NTSTATUS SubmitIrp(PIRP Irp) = 0;
 730
 731 //-----------------------------------------------------------------------------------------
 732 //
 733 // GetConfigurationDescriptors
 734 //
 735 // Description: returns one or more configuration descriptors
 736
 737     virtual VOID GetConfigurationDescriptors(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigDescriptorBuffer,
 738                                              IN ULONG BufferLength,
 739                                              OUT PULONG OutBufferLength) = 0;
 740
 741 //-----------------------------------------------------------------------------------------
 742 //
 743 // Description: returns length of configuration descriptors
 744 //
 745      virtual ULONG GetConfigurationDescriptorsLength() = 0;
 746
 747 //-----------------------------------------------------------------------------------------
 748 //
 749 // SubmitSetupPacket
 750 //
 751 // Description: submits an setup packet. The usb device will then create an usb request from it and submit it to the queue
 752
 753      virtual NTSTATUS SubmitSetupPacket(IN PUSB_DEFAULT_PIPE_SETUP_PACKET SetupPacket,
 754                                         IN OUT ULONG BufferLength,
 755                                         OUT PVOID Buffer) = 0;
 756
 757 //-----------------------------------------------------------------------------------------
 758 //
 759 // SelectConfiguration
 760 //
 761 // Description: selects a configuration
 762
 763     virtual NTSTATUS SelectConfiguration(IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
 764                                          IN PUSBD_INTERFACE_INFORMATION Interface,
 765                                          OUT USBD_CONFIGURATION_HANDLE *ConfigurationHandle) = 0;
 766
 767 //-----------------------------------------------------------------------------------------
 768 //
 769 // SelectConfiguration
 770 //
 771 // Description: selects a interface of an configuration
 772
 773     virtual NTSTATUS SelectInterface(IN USBD_CONFIGURATION_HANDLE ConfigurationHandle,
 774                                      IN OUT PUSBD_INTERFACE_INFORMATION Interface) = 0;
 775 };
 776
 777 typedef IUSBDevice *PUSBDEVICE;
 778
 779 #endif