[efi] Add USB headers and GUID definitions

Signed-off-by: Michael Brown <mcb30@ipxe.org>

3 files changed, 1627 insertions, 0 deletions

diff --git a/src/include/ipxe/efi/Protocol/Usb2HostController.h b/src/include/ipxe/efi/Protocol/Usb2HostController.h
new file mode 100644
index 0000000..01f6170
--- /dev/null
+++ b/src/include/ipxe/efi/Protocol/Usb2HostController.h
@@ -0,0 +1,603 @@
+/** @file
+  EFI_USB2_HC_PROTOCOL as defined in UEFI 2.0.
+  The USB Host Controller Protocol is used by code, typically USB bus drivers,
+  running in the EFI boot services environment, to perform data transactions over
+  a USB bus. In addition, it provides an abstraction for the root hub of the USB bus.
+
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _USB2_HOSTCONTROLLER_H_
+#define _USB2_HOSTCONTROLLER_H_
+
+FILE_LICENCE ( BSD3 );
+
+#include <ipxe/efi/Protocol/UsbIo.h>
+
+#define EFI_USB2_HC_PROTOCOL_GUID \
+  { \
+    0x3e745226, 0x9818, 0x45b6, {0xa2, 0xac, 0xd7, 0xcd, 0xe, 0x8b, 0xa2, 0xbc } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_USB2_HC_PROTOCOL EFI_USB2_HC_PROTOCOL;
+
+
+typedef struct {
+  UINT16          PortStatus;        ///< Contains current port status bitmap.
+  UINT16          PortChangeStatus;  ///< Contains current port status change bitmap.
+} EFI_USB_PORT_STATUS;
+
+///
+/// EFI_USB_PORT_STATUS.PortStatus bit definition
+///
+#define USB_PORT_STAT_CONNECTION    0x0001
+#define USB_PORT_STAT_ENABLE        0x0002
+#define USB_PORT_STAT_SUSPEND       0x0004
+#define USB_PORT_STAT_OVERCURRENT   0x0008
+#define USB_PORT_STAT_RESET         0x0010
+#define USB_PORT_STAT_POWER         0x0100
+#define USB_PORT_STAT_LOW_SPEED     0x0200
+#define USB_PORT_STAT_HIGH_SPEED    0x0400
+#define USB_PORT_STAT_SUPER_SPEED   0x0800
+#define USB_PORT_STAT_OWNER         0x2000
+
+///
+/// EFI_USB_PORT_STATUS.PortChangeStatus bit definition
+///
+#define USB_PORT_STAT_C_CONNECTION  0x0001
+#define USB_PORT_STAT_C_ENABLE      0x0002
+#define USB_PORT_STAT_C_SUSPEND     0x0004
+#define USB_PORT_STAT_C_OVERCURRENT 0x0008
+#define USB_PORT_STAT_C_RESET       0x0010
+
+
+///
+/// Usb port features value
+/// Each value indicates its bit index in the port status and status change bitmaps,
+/// if combines these two bitmaps into a 32-bit bitmap.
+///
+typedef enum {
+  EfiUsbPortEnable            = 1,
+  EfiUsbPortSuspend           = 2,
+  EfiUsbPortReset             = 4,
+  EfiUsbPortPower             = 8,
+  EfiUsbPortOwner             = 13,
+  EfiUsbPortConnectChange     = 16,
+  EfiUsbPortEnableChange      = 17,
+  EfiUsbPortSuspendChange     = 18,
+  EfiUsbPortOverCurrentChange = 19,
+  EfiUsbPortResetChange       = 20
+} EFI_USB_PORT_FEATURE;
+
+#define EFI_USB_SPEED_FULL      0x0000  ///< 12 Mb/s, USB 1.1 OHCI and UHCI HC.
+#define EFI_USB_SPEED_LOW       0x0001  ///< 1 Mb/s, USB 1.1 OHCI and UHCI HC.
+#define EFI_USB_SPEED_HIGH      0x0002  ///< 480 Mb/s, USB 2.0 EHCI HC.
+#define EFI_USB_SPEED_SUPER     0x0003  ///< 4.8 Gb/s, USB 3.0 XHCI HC.
+
+typedef struct {
+  UINT8      TranslatorHubAddress; ///< device address
+  UINT8      TranslatorPortNumber; ///< the port number of the hub that device is connected to.
+} EFI_USB2_HC_TRANSACTION_TRANSLATOR;
+
+//
+// Protocol definitions
+//
+
+/**
+  Retrieves the Host Controller capabilities.
+
+  @param  This           A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  MaxSpeed       Host controller data transfer speed.
+  @param  PortNumber     Number of the root hub ports.
+  @param  Is64BitCapable TRUE if controller supports 64-bit memory addressing,
+                         FALSE otherwise.
+
+  @retval EFI_SUCCESS           The host controller capabilities were retrieved successfully.
+  @retval EFI_INVALID_PARAMETER One of the input args was NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to
+                                retrieve the capabilities.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_CAPABILITY)(
+  IN  EFI_USB2_HC_PROTOCOL  *This,
+  OUT UINT8                 *MaxSpeed,
+  OUT UINT8                 *PortNumber,
+  OUT UINT8                 *Is64BitCapable
+  );
+
+#define EFI_USB_HC_RESET_GLOBAL             0x0001
+#define EFI_USB_HC_RESET_HOST_CONTROLLER    0x0002
+#define EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG  0x0004
+#define EFI_USB_HC_RESET_HOST_WITH_DEBUG    0x0008
+/**
+  Provides software reset for the USB host controller.
+
+  @param  This       A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  Attributes A bit mask of the reset operation to perform.
+
+  @retval EFI_SUCCESS           The reset operation succeeded.
+  @retval EFI_INVALID_PARAMETER Attributes is not valid.
+  @retval EFI_UNSUPPORTED       The type of reset specified by Attributes is not currently
+                                supported by the host controller hardware.
+  @retval EFI_ACCESS_DENIED     Reset operation is rejected due to the debug port being configured
+                                and active; only EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG or
+                                EFI_USB_HC_RESET_HOST_WITH_DEBUG reset Attributes can be used to
+                                perform reset operation for this host controller.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to
+                                retrieve the capabilities.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_RESET)(
+  IN EFI_USB2_HC_PROTOCOL   *This,
+  IN UINT16                 Attributes
+  );
+
+/**
+  Enumration value for status of USB HC.
+**/
+typedef enum {
+  EfiUsbHcStateHalt,                ///< The host controller is in halt
+                                    ///< state. No USB transactions can occur
+                                    ///< while in this state. The host
+                                    ///< controller can enter this state for
+                                    ///< three reasons: 1) After host
+                                    ///< controller hardware reset. 2)
+                                    ///< Explicitly set by software. 3)
+                                    ///< Triggered by a fatal error such as
+                                    ///< consistency check failure.
+
+  EfiUsbHcStateOperational,         ///< The host controller is in an
+                                    ///< operational state. When in
+                                    ///< this state, the host
+                                    ///< controller can execute bus
+                                    ///< traffic. This state must be
+                                    ///< explicitly set to enable the
+                                    ///< USB bus traffic.
+
+  EfiUsbHcStateSuspend,             ///< The host controller is in the
+                                    ///< suspend state. No USB
+                                    ///< transactions can occur while in
+                                    ///< this state. The host controller
+                                    ///< enters this state for the
+                                    ///< following reasons: 1) Explicitly
+                                    ///< set by software. 2) Triggered
+                                    ///< when there is no bus traffic for
+                                    ///< 3 microseconds.
+
+  EfiUsbHcStateMaximum              ///< Maximum value for enumration value of HC status.
+} EFI_USB_HC_STATE;
+
+/**
+  Retrieves current state of the USB host controller.
+
+  @param  This  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  State A pointer to the EFI_USB_HC_STATE data structure that
+                indicates current state of the USB host controller.
+
+  @retval EFI_SUCCESS           The state information of the host controller was returned in State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the
+                                host controller's current state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_STATE)(
+  IN        EFI_USB2_HC_PROTOCOL    *This,
+  OUT       EFI_USB_HC_STATE        *State
+);
+
+/**
+  Sets the USB host controller to a specific state.
+
+  @param  This  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  State Indicates the state of the host controller that will be set.
+
+  @retval EFI_SUCCESS           The USB host controller was successfully placed in the state
+                                specified by State.
+  @retval EFI_INVALID_PARAMETER State is not valid.
+  @retval EFI_DEVICE_ERROR      Failed to set the state specified by State due to device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SET_STATE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN EFI_USB_HC_STATE        State
+  );
+
+/**
+  Submits control transfer to a target USB device.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size that the default control transfer
+                              endpoint is capable of sending or receiving.
+  @param  Request             A pointer to the USB device request that will be sent to the USB device.
+  @param  TransferDirection   Specifies the data direction for the transfer. There are three values
+                              available, EfiUsbDataIn, EfiUsbDataOut and EfiUsbNoData.
+  @param  Data                A pointer to the buffer of data that will be transmitted to USB device or
+                              received from USB device.
+  @param  DataLength          On input, indicates the size, in bytes, of the data buffer specified by Data.
+                              On output, indicates the amount of data actually transferred.
+  @param  TimeOut             Indicates the maximum time, in milliseconds, which the transfer is
+                              allowed to complete.
+  @param  Translator          A pointer to the transaction translator data.
+  @param  TransferResult      A pointer to the detailed result information generated by this control
+                              transfer.
+
+  @retval EFI_SUCCESS           The control transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The control transfer could not be completed due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The control transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_CONTROL_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     EFI_USB_DEVICE_REQUEST             *Request,
+  IN     EFI_USB_DATA_DIRECTION             TransferDirection,
+  IN OUT VOID                               *Data       OPTIONAL,
+  IN OUT UINTN                              *DataLength OPTIONAL,
+  IN     UINTN                              TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+#define EFI_USB_MAX_BULK_BUFFER_NUM 10
+
+/**
+  Submits bulk transfer to a bulk endpoint of a USB device.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  EndPointAddress     The combination of an endpoint number and an endpoint direction of the
+                              target USB device.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size the target endpoint is capable of
+                              sending or receiving.
+  @param  DataBuffersNumber   Number of data buffers prepared for the transfer.
+  @param  Data                Array of pointers to the buffers of data that will be transmitted to USB
+                              device or received from USB device.
+  @param  DataLength          When input, indicates the size, in bytes, of the data buffers specified by
+                              Data. When output, indicates the actually transferred data size.
+  @param  DataToggle          A pointer to the data toggle value.
+  @param  TimeOut             Indicates the maximum time, in milliseconds, which the transfer is
+                              allowed to complete.
+  @param  Translator          A pointer to the transaction translator data.
+  @param  TransferResult      A pointer to the detailed result information of the bulk transfer.
+
+  @retval EFI_SUCCESS           The bulk transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The bulk transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_BULK_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_BULK_BUFFER_NUM],
+  IN OUT UINTN                              *DataLength,
+  IN OUT UINT8                              *DataToggle,
+  IN     UINTN                              TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+/**
+  Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
+  Translator parameter doesn't exist in UEFI2.0 spec, but it will be updated in the following specification version.
+
+  @param  This                A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress       Represents the address of the target device on the USB.
+  @param  EndPointAddress     The combination of an endpoint number and an endpoint direction of the
+                              target USB device.
+  @param  DeviceSpeed         Indicates device speed.
+  @param  MaximumPacketLength Indicates the maximum packet size the target endpoint is capable of
+                              sending or receiving.
+  @param  IsNewTransfer       If TRUE, an asynchronous interrupt pipe is built between the host and the
+                              target interrupt endpoint. If FALSE, the specified asynchronous interrupt
+                              pipe is canceled. If TRUE, and an interrupt transfer exists for the target
+                              end point, then EFI_INVALID_PARAMETER is returned.
+  @param  DataToggle          A pointer to the data toggle value.
+  @param  PollingInterval     Indicates the interval, in milliseconds, that the asynchronous interrupt
+                              transfer is polled.
+  @param  DataLength          Indicates the length of data to be received at the rate specified by
+                              PollingInterval from the target asynchronous interrupt endpoint.
+  @param  Translator          A pointr to the transaction translator data.
+  @param  CallBackFunction    The Callback function. This function is called at the rate specified by
+                              PollingInterval.
+  @param  Context             The context that is passed to the CallBackFunction. This is an
+                              optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous interrupt transfer request has been successfully
+                                submitted or canceled.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL                                *This,
+  IN     UINT8                                               DeviceAddress,
+  IN     UINT8                                               EndPointAddress,
+  IN     UINT8                                               DeviceSpeed,
+  IN     UINTN                                               MaxiumPacketLength,
+  IN     BOOLEAN                                             IsNewTransfer,
+  IN OUT UINT8                                               *DataToggle,
+  IN     UINTN                                               PollingInterval  OPTIONAL,
+  IN     UINTN                                               DataLength       OPTIONAL,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR                  *Translator      OPTIONAL,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK                     CallBackFunction OPTIONAL,
+  IN     VOID                                                *Context         OPTIONAL
+  );
+
+/**
+  Submits synchronous interrupt transfer to an interrupt endpoint of a USB device.
+  Translator parameter doesn't exist in UEFI2.0 spec, but it will be updated in the following specification version.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB device or
+                                received from USB device.
+  @param  DataLength            On input, the size, in bytes, of the data buffer specified by Data. On
+                                output, the number of bytes transferred.
+  @param  DataToggle            A pointer to the data toggle value.
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer is
+                                allowed to complete.
+  @param  Translator            A pointr to the transaction translator data.
+  @param  TransferResult        A pointer to the detailed result information from the synchronous
+                                interrupt transfer.
+
+  @retval EFI_SUCCESS           The synchronous interrupt transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The synchronous interrupt transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The synchronous interrupt transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The synchronous interrupt transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL                        *This,
+  IN     UINT8                                       DeviceAddress,
+  IN     UINT8                                       EndPointAddress,
+  IN     UINT8                                       DeviceSpeed,
+  IN     UINTN                                       MaximumPacketLength,
+  IN OUT VOID                                        *Data,
+  IN OUT UINTN                                       *DataLength,
+  IN OUT UINT8                                       *DataToggle,
+  IN     UINTN                                       TimeOut,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR          *Translator,
+  OUT    UINT32                                      *TransferResult
+  );
+
+#define EFI_USB_MAX_ISO_BUFFER_NUM  7
+#define EFI_USB_MAX_ISO_BUFFER_NUM1 2
+
+/**
+  Submits isochronous transfer to an isochronous endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  DataBuffersNumber     Number of data buffers prepared for the transfer.
+  @param  Data                  Array of pointers to the buffers of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received from
+                                the USB device.
+  @param  Translator            A pointer to the transaction translator data.
+  @param  TransferResult        A pointer to the detailed result information of the isochronous transfer.
+
+  @retval EFI_SUCCESS           The isochronous transfer was completed successfully.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The isochronous transfer could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The isochronous transfer cannot be completed within the one USB frame time.
+  @retval EFI_DEVICE_ERROR      The isochronous transfer failed due to host controller or device error.
+                                Caller should check TransferResult for detailed error information.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
+  IN     UINTN                              DataLength,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  OUT    UINT32                             *TransferResult
+  );
+
+/**
+  Submits nonblocking isochronous transfer to an isochronous endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint direction of the
+                                target USB device.
+  @param  DeviceSpeed           Indicates device speed.
+  @param  MaximumPacketLength   Indicates the maximum packet size the target endpoint is capable of
+                                sending or receiving.
+  @param  DataBuffersNumber     Number of data buffers prepared for the transfer.
+  @param  Data                  Array of pointers to the buffers of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received from
+                                the USB device.
+  @param  Translator            A pointer to the transaction translator data.
+  @param  IsochronousCallback   The Callback function. This function is called if the requested
+                                isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback function. This is an
+                                optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer request has been successfully
+                                submitted or canceled.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The asynchronous isochronous transfer could not be submitted due to
+                                a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB2_HC_PROTOCOL               *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              DeviceSpeed,
+  IN     UINTN                              MaximumPacketLength,
+  IN     UINT8                              DataBuffersNumber,
+  IN OUT VOID                               *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
+  IN     UINTN                              DataLength,
+  IN     EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK    IsochronousCallBack,
+  IN     VOID                               *Context OPTIONAL
+  );
+
+/**
+  Retrieves the current status of a USB root hub port.
+
+  @param  This       A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber Specifies the root hub port from which the status is to be retrieved.
+                     This value is zero based.
+  @param  PortStatus A pointer to the current port status bits and port status change bits.
+
+  @retval EFI_SUCCESS           The status of the USB root hub port specified by PortNumber
+                                was returned in PortStatus.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS)(
+  IN        EFI_USB2_HC_PROTOCOL    *This,
+  IN        UINT8                   PortNumber,
+  OUT       EFI_USB_PORT_STATUS     *PortStatus
+  );
+
+/**
+  Sets a feature for the specified root hub port.
+
+  @param  This        A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber  Specifies the root hub port whose feature is requested to be set. This
+                      value is zero based.
+  @param  PortFeature Indicates the feature selector associated with the feature set request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was set for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+/**
+  Clears a feature for the specified root hub port.
+
+  @param  This        A pointer to the EFI_USB2_HC_PROTOCOL instance.
+  @param  PortNumber  Specifies the root hub port whose feature is requested to be cleared. This
+                      value is zero based.
+  @param  PortFeature Indicates the feature selector associated with the feature clear request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was cleared for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB2_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB2_HC_PROTOCOL    *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+///
+/// The EFI_USB2_HC_PROTOCOL provides USB host controller management, basic
+/// data transactions over a USB bus, and USB root hub access. A device driver
+/// that wishes to manage a USB bus in a system retrieves the EFI_USB2_HC_PROTOCOL
+/// instance that is associated with the USB bus to be managed. A device handle
+/// for a USB host controller will minimally contain an EFI_DEVICE_PATH_PROTOCOL
+/// instance, and an EFI_USB2_HC_PROTOCOL instance.
+///
+struct _EFI_USB2_HC_PROTOCOL {
+  EFI_USB2_HC_PROTOCOL_GET_CAPABILITY              GetCapability;
+  EFI_USB2_HC_PROTOCOL_RESET                       Reset;
+  EFI_USB2_HC_PROTOCOL_GET_STATE                   GetState;
+  EFI_USB2_HC_PROTOCOL_SET_STATE                   SetState;
+  EFI_USB2_HC_PROTOCOL_CONTROL_TRANSFER            ControlTransfer;
+  EFI_USB2_HC_PROTOCOL_BULK_TRANSFER               BulkTransfer;
+  EFI_USB2_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER    AsyncInterruptTransfer;
+  EFI_USB2_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER     SyncInterruptTransfer;
+  EFI_USB2_HC_PROTOCOL_ISOCHRONOUS_TRANSFER        IsochronousTransfer;
+  EFI_USB2_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER  AsyncIsochronousTransfer;
+  EFI_USB2_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS     GetRootHubPortStatus;
+  EFI_USB2_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE    SetRootHubPortFeature;
+  EFI_USB2_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE  ClearRootHubPortFeature;
+
+  ///
+  /// The major revision number of the USB host controller. The revision information
+  /// indicates the release of the Universal Serial Bus Specification with which the
+  /// host controller is compliant.
+  ///
+  UINT16                                           MajorRevision;
+
+  ///
+  /// The minor revision number of the USB host controller. The revision information
+  /// indicates the release of the Universal Serial Bus Specification with which the
+  /// host controller is compliant.
+  ///
+  UINT16                                           MinorRevision;
+};
+
+extern EFI_GUID gEfiUsb2HcProtocolGuid;
+
+#endif
diff --git a/src/include/ipxe/efi/Protocol/UsbHostController.h b/src/include/ipxe/efi/Protocol/UsbHostController.h
new file mode 100644
index 0000000..a29088c
--- /dev/null
+++ b/src/include/ipxe/efi/Protocol/UsbHostController.h
@@ -0,0 +1,510 @@
+/** @file
+  EFI_USB_HC_PROTOCOL as defined in EFI 1.10.
+
+  The USB Host Controller Protocol is used by code, typically USB bus drivers,
+  running in the EFI boot services environment, to perform data transactions
+  over a USB bus. In addition, it provides an abstraction for the root hub of the USB bus.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _USB_HOSTCONTROLLER_H_
+#define _USB_HOSTCONTROLLER_H_
+
+FILE_LICENCE ( BSD3 );
+
+#include <ipxe/efi/Protocol/Usb2HostController.h>
+
+#define EFI_USB_HC_PROTOCOL_GUID \
+  { \
+    0xf5089266, 0x1aa0, 0x4953, {0x97, 0xd8, 0x56, 0x2f, 0x8a, 0x73, 0xb5, 0x19 } \
+  }
+
+///
+/// Forward reference for pure ANSI compatability
+///
+typedef struct _EFI_USB_HC_PROTOCOL EFI_USB_HC_PROTOCOL;
+
+//
+// Protocol definitions
+//
+
+/**
+  Provides software reset for the USB host controller.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  Attributes            A bit mask of the reset operation to perform.
+
+  @retval EFI_SUCCESS           The reset operation succeeded.
+  @retval EFI_UNSUPPORTED       The type of reset specified by Attributes is not currently supported
+                                by the host controller hardware.
+  @retval EFI_INVALID_PARAMETER Attributes is not valid.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to perform the reset operation.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_RESET)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT16                  Attributes
+  );
+
+/**
+  Retrieves current state of the USB host controller.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  State                 A pointer to the EFI_USB_HC_STATE data structure that
+                                indicates current state of the USB host controller.
+
+  @retval EFI_SUCCESS           The state information of the host controller was returned in State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the host controller's
+                                current state.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_STATE)(
+  IN  EFI_USB_HC_PROTOCOL    *This,
+  OUT EFI_USB_HC_STATE       *State
+  );
+
+/**
+  Sets the USB host controller to a specific state.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  State                 Indicates the state of the host controller that will be set.
+
+  @retval EFI_SUCCESS           The USB host controller was successfully placed in the state specified by
+                                State.
+  @retval EFI_INVALID_PARAMETER State is NULL.
+  @retval EFI_DEVICE_ERROR      Failed to set the state specified by State due to device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SET_STATE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN EFI_USB_HC_STATE        State
+  );
+
+/**
+  Submits control transfer to a target USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving.
+  @param  Request               A pointer to the USB device request that will be sent to the USB
+                                device.
+  @param  TransferDirection     Specifies the data direction for the transfer. There are three
+                                values available, EfiUsbDataIn, EfiUsbDataOut and EfiUsbNoData.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            On input, indicates the size, in bytes, of the data buffer specified
+                                by Data. On output, indicates the amount of data actually
+                                transferred.
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer
+                                is allowed to complete.
+  @param  TransferResult        A pointer to the detailed result information generated by this
+                                control transfer.
+
+  @retval EFI_SUCCESS           The control transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The control transfer could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The control transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The control transfer failed due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_CONTROL_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL       *This,
+  IN     UINT8                     DeviceAddress,
+  IN     BOOLEAN                   IsSlowDevice,
+  IN     UINT8                     MaximumPacketLength,
+  IN     EFI_USB_DEVICE_REQUEST    *Request,
+  IN     EFI_USB_DATA_DIRECTION    TransferDirection,
+  IN OUT VOID                      *Data       OPTIONAL,
+  IN OUT UINTN                     *DataLength OPTIONAL,
+  IN     UINTN                     TimeOut,
+  OUT    UINT32                    *TransferResult
+  );
+
+/**
+  Submits bulk transfer to a bulk endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is 0). It is the
+                                caller's responsibility to make sure that the EndPointAddress
+                                represents a bulk endpoint.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            On input, indicates the size, in bytes, of the data buffer specified
+                                by Data. On output, indicates the amount of data actually
+                                transferred.
+  @param  DataToggle            A pointer to the data toggle value.
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer
+                                is allowed to complete.
+  @param  TransferResult        A pointer to the detailed result information of the bulk transfer.
+
+  @retval EFI_SUCCESS           The bulk transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The bulk transfer could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_BULK_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN OUT UINTN                  *DataLength,
+  IN OUT UINT8                  *DataToggle,
+  IN     UINTN                  TimeOut,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**
+  Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an interrupt endpoint.
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving.
+  @param  IsNewTransfer         If TRUE, an asynchronous interrupt pipe is built between the host
+                                and the target interrupt endpoint. If FALSE, the specified asynchronous
+                                interrupt pipe is canceled. If TRUE, and an interrupt transfer exists
+                                for the target end point, then EFI_INVALID_PARAMETER is returned.
+  @param  DataToggle            A pointer to the data toggle value. On input, it is valid when
+                                IsNewTransfer is TRUE, and it indicates the initial data toggle
+                                value the asynchronous interrupt transfer should adopt. On output,
+                                it is valid when IsNewTransfer is FALSE, and it is updated to indicate
+                                the data toggle value of the subsequent asynchronous interrupt transfer.
+  @param  PollingInterval       Indicates the interval, in milliseconds, that the asynchronous
+                                interrupt transfer is polled.
+  @param  DataLength            Indicates the length of data to be received at the rate specified by
+                                PollingInterval from the target asynchronous interrupt
+                                endpoint. This parameter is only required when IsNewTransfer is TRUE.
+  @param  CallBackFunction      The Callback function. This function is called at the rate specified by
+                                PollingInterval. This parameter is only required when IsNewTransfer is TRUE.
+  @param  Context               The context that is passed to the CallBackFunction.
+
+  @retval EFI_SUCCESS           The asynchronous interrupt transfer request has been successfully
+                                submitted or canceled.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The bulk transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The bulk transfer failed due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL                                 *This,
+  IN     UINT8                                               DeviceAddress,
+  IN     UINT8                                               EndPointAddress,
+  IN     BOOLEAN                                             IsSlowDevice,
+  IN     UINT8                                               MaxiumPacketLength,
+  IN     BOOLEAN                                             IsNewTransfer,
+  IN OUT UINT8                                               *DataToggle,
+  IN     UINTN                                               PollingInterval  OPTIONAL,
+  IN     UINTN                                               DataLength       OPTIONAL,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK                     CallBackFunction OPTIONAL,
+  IN     VOID                                                *Context         OPTIONAL
+  );
+
+/**
+  Submits synchronous interrupt transfer to an interrupt endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an interrupt endpoint.
+  @param  IsSlowDevice          Indicates whether the target device is slow device or full-speed
+                                device.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.
+  @param  DataLength            On input, the size, in bytes, of the data buffer specified by Data.
+                                On output, the number of bytes transferred.
+  @param  DataToggle            A pointer to the data toggle value. On input, it indicates the initial
+                                data toggle value the synchronous interrupt transfer should adopt;
+                                on output, it is updated to indicate the data toggle value of the
+                                subsequent synchronous interrupt transfer.
+  @param  TimeOut               Indicates the maximum time, in milliseconds, which the transfer
+                                is allowed to complete.
+  @param  TransferResult        A pointer to the detailed result information from the synchronous
+                                interrupt transfer.
+
+  @retval EFI_SUCCESS           The synchronous interrupt transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The synchronous interrupt transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The synchronous interrupt transfer failed due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     BOOLEAN                IsSlowDevice,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN OUT UINTN                  *DataLength,
+  IN OUT UINT8                  *DataToggle,
+  IN     UINTN                  TimeOut,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**
+  Submits isochronous transfer to an isochronous endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is 0). It is the caller's
+                                responsibility to make sure that the EndPointAddress
+                                represents an isochronous endpoint.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received
+                                from the USB device.
+  @param  TransferResult        A pointer to the detailed result information from the isochronous
+                                transfer.
+
+  @retval EFI_SUCCESS           The isochronous transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The isochronous could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+  @retval EFI_TIMEOUT           The isochronous transfer failed due to timeout.
+  @retval EFI_DEVICE_ERROR      The isochronous transfer failed due to host controller or device error.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL    *This,
+  IN     UINT8                  DeviceAddress,
+  IN     UINT8                  EndPointAddress,
+  IN     UINT8                  MaximumPacketLength,
+  IN OUT VOID                   *Data,
+  IN     UINTN                  DataLength,
+  OUT    UINT32                 *TransferResult
+  );
+
+/**
+  Submits nonblocking isochronous transfer to an isochronous endpoint of a USB device.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  DeviceAddress         Represents the address of the target device on the USB, which is
+                                assigned during USB enumeration.
+  @param  EndPointAddress       The combination of an endpoint number and an endpoint
+                                direction of the target USB device. Each endpoint address
+                                supports data transfer in one direction except the control
+                                endpoint (whose default endpoint address is zero). It is the
+                                caller's responsibility to make sure that the
+                                EndPointAddress represents an isochronous endpoint.
+  @param  MaximumPacketLength   Indicates the maximum packet size that the default control
+                                transfer endpoint is capable of sending or receiving. For isochronous
+                                endpoints, this value is used to reserve the bus time in the schedule,
+                                required for the perframe data payloads. The pipe may, on an ongoing basis,
+                                actually use less bandwidth than that reserved.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.                                                                                            asynchronous interrupt pipe is canceled.
+  @param  DataLength            Specifies the length, in bytes, of the data to be sent to or received
+                                from the USB device.
+  @param  IsochronousCallback   The Callback function.This function is called if the requested
+                                isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback function. This is
+                                an optional parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer was completed successfully.
+  @retval EFI_OUT_OF_RESOURCES  The asynchronous isochronous could not be completed due to a lack of resources.
+  @retval EFI_INVALID_PARAMETER Some parameters are invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN     EFI_USB_HC_PROTOCOL                *This,
+  IN     UINT8                              DeviceAddress,
+  IN     UINT8                              EndPointAddress,
+  IN     UINT8                              MaximumPacketLength,
+  IN OUT VOID                               *Data,
+  IN     UINTN                              DataLength,
+  IN     EFI_ASYNC_USB_TRANSFER_CALLBACK    IsochronousCallBack,
+  IN     VOID                               *Context OPTIONAL
+  );
+
+/**
+  Retrieves the number of root hub ports.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            A pointer to the number of the root hub ports.
+
+  @retval EFI_SUCCESS           The port number was retrieved successfully.
+  @retval EFI_DEVICE_ERROR      An error was encountered while attempting to retrieve the port number.
+  @retval EFI_INVALID_PARAMETER PortNumber is NULL.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_NUMBER)(
+  IN EFI_USB_HC_PROTOCOL    *This,
+  OUT UINT8                 *PortNumber
+  );
+
+/**
+  Retrieves the current status of a USB root hub port.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortStatus            A pointer to the current port status bits and port status change bits.
+
+  @retval EFI_SUCCESS           The status of the USB root hub port specified by PortNumber
+                                was returned in PortStatus.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN  UINT8                  PortNumber,
+  OUT EFI_USB_PORT_STATUS    *PortStatus
+  );
+
+/**
+  Sets a feature for the specified root hub port.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortFeature           Indicates the feature selector associated with the feature set
+                                request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was set for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+/**
+  Clears a feature for the specified root hub port.
+
+  @param  This                  A pointer to the EFI_USB_HC_PROTOCOL instance.
+  @param  PortNumber            Specifies the root hub port from which the status is to be retrieved.
+                                This value is zero based. For example, if a root hub has two ports,
+                                then the first port is numbered 0, and the second port is
+                                numbered 1.
+  @param  PortFeature           Indicates the feature selector associated with the feature clear
+                                request.
+
+  @retval EFI_SUCCESS           The feature specified by PortFeature was cleared for the USB
+                                root hub port specified by PortNumber.
+  @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid for this function.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE)(
+  IN EFI_USB_HC_PROTOCOL     *This,
+  IN UINT8                   PortNumber,
+  IN EFI_USB_PORT_FEATURE    PortFeature
+  );
+
+
+///
+/// The EFI_USB_HC_PROTOCOL provides USB host controller management, basic data transactions
+/// over a USB bus, and USB root hub access. A device driver that wishes to manage a USB bus in a
+/// system retrieves the EFI_USB_HC_PROTOCOL instance that is associated with the USB bus to be
+/// managed. A device handle for a USB host controller will minimally contain an
+/// EFI_DEVICE_PATH_PROTOCOL instance, and an EFI_USB_HC_PROTOCOL instance.
+///
+struct _EFI_USB_HC_PROTOCOL {
+  EFI_USB_HC_PROTOCOL_RESET                       Reset;
+  EFI_USB_HC_PROTOCOL_GET_STATE                   GetState;
+  EFI_USB_HC_PROTOCOL_SET_STATE                   SetState;
+  EFI_USB_HC_PROTOCOL_CONTROL_TRANSFER            ControlTransfer;
+  EFI_USB_HC_PROTOCOL_BULK_TRANSFER               BulkTransfer;
+  EFI_USB_HC_PROTOCOL_ASYNC_INTERRUPT_TRANSFER    AsyncInterruptTransfer;
+  EFI_USB_HC_PROTOCOL_SYNC_INTERRUPT_TRANSFER     SyncInterruptTransfer;
+  EFI_USB_HC_PROTOCOL_ISOCHRONOUS_TRANSFER        IsochronousTransfer;
+  EFI_USB_HC_PROTOCOL_ASYNC_ISOCHRONOUS_TRANSFER  AsyncIsochronousTransfer;
+  EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_NUMBER     GetRootHubPortNumber;
+  EFI_USB_HC_PROTOCOL_GET_ROOTHUB_PORT_STATUS     GetRootHubPortStatus;
+  EFI_USB_HC_PROTOCOL_SET_ROOTHUB_PORT_FEATURE    SetRootHubPortFeature;
+  EFI_USB_HC_PROTOCOL_CLEAR_ROOTHUB_PORT_FEATURE  ClearRootHubPortFeature;
+  ///
+  /// The major revision number of the USB host controller. The revision information
+  /// indicates the release of the Universal Serial Bus Specification with which the
+  /// host controller is compliant.
+  ///
+  UINT16                                          MajorRevision;
+  ///
+  /// The minor revision number of the USB host controller. The revision information
+  /// indicates the release of the Universal Serial Bus Specification with which the
+  /// host controller is compliant.
+  ///
+  UINT16                                          MinorRevision;
+};
+
+extern EFI_GUID gEfiUsbHcProtocolGuid;
+
+#endif
diff --git a/src/include/ipxe/efi/Protocol/UsbIo.h b/src/include/ipxe/efi/Protocol/UsbIo.h
new file mode 100644
index 0000000..b8d33ee
--- /dev/null
+++ b/src/include/ipxe/efi/Protocol/UsbIo.h
@@ -0,0 +1,514 @@
+/** @file
+  EFI Usb I/O Protocol as defined in UEFI specification.
+  This protocol is used by code, typically drivers, running in the EFI
+  boot services environment to access USB devices like USB keyboards,
+  mice and mass storage devices. In particular, functions for managing devices
+  on USB buses are defined here.
+
+  Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef __USB_IO_H__
+#define __USB_IO_H__
+
+FILE_LICENCE ( BSD3 );
+
+#include <ipxe/efi/IndustryStandard/Usb.h>
+
+//
+// Global ID for the USB I/O Protocol
+//
+#define EFI_USB_IO_PROTOCOL_GUID \
+  { \
+    0x2B2F68D6, 0x0CD2, 0x44cf, {0x8E, 0x8B, 0xBB, 0xA2, 0x0B, 0x1B, 0x5B, 0x75 } \
+  }
+
+typedef struct _EFI_USB_IO_PROTOCOL   EFI_USB_IO_PROTOCOL;
+
+//
+// Related Definition for EFI USB I/O protocol
+//
+
+//
+// USB standard descriptors and reqeust
+//
+typedef USB_DEVICE_REQUEST        EFI_USB_DEVICE_REQUEST;
+typedef USB_DEVICE_DESCRIPTOR     EFI_USB_DEVICE_DESCRIPTOR;
+typedef USB_CONFIG_DESCRIPTOR     EFI_USB_CONFIG_DESCRIPTOR;
+typedef USB_INTERFACE_DESCRIPTOR  EFI_USB_INTERFACE_DESCRIPTOR;
+typedef USB_ENDPOINT_DESCRIPTOR   EFI_USB_ENDPOINT_DESCRIPTOR;
+
+///
+/// USB data transfer direction
+///
+typedef enum {
+  EfiUsbDataIn,
+  EfiUsbDataOut,
+  EfiUsbNoData
+} EFI_USB_DATA_DIRECTION;
+
+//
+// USB Transfer Results
+//
+#define EFI_USB_NOERROR             0x00
+#define EFI_USB_ERR_NOTEXECUTE      0x01
+#define EFI_USB_ERR_STALL           0x02
+#define EFI_USB_ERR_BUFFER          0x04
+#define EFI_USB_ERR_BABBLE          0x08
+#define EFI_USB_ERR_NAK             0x10
+#define EFI_USB_ERR_CRC             0x20
+#define EFI_USB_ERR_TIMEOUT         0x40
+#define EFI_USB_ERR_BITSTUFF        0x80
+#define EFI_USB_ERR_SYSTEM          0x100
+
+/**
+  Async USB transfer callback routine.
+
+  @param  Data                  Data received or sent via the USB Asynchronous Transfer, if the
+                                transfer completed successfully.
+  @param  DataLength            The length of Data received or sent via the Asynchronous
+                                Transfer, if transfer successfully completes.
+  @param  Context               Data passed from UsbAsyncInterruptTransfer() request.
+  @param  Status                Indicates the result of the asynchronous transfer.
+
+  @retval EFI_SUCCESS           The asynchronous USB transfer request has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The asynchronous USB transfer request failed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ASYNC_USB_TRANSFER_CALLBACK)(
+  IN VOID         *Data,
+  IN UINTN        DataLength,
+  IN VOID         *Context,
+  IN UINT32       Status
+  );
+
+//
+// Prototype for EFI USB I/O protocol
+//
+
+
+/**
+  This function is used to manage a USB device with a control transfer pipe. A control transfer is
+  typically used to perform device initialization and configuration.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  Request               A pointer to the USB device request that will be sent to the USB
+                                device.
+  @param  Direction             Indicates the data direction.
+  @param  Timeout               Indicating the transfer should be completed within this time frame.
+                                The units are in milliseconds.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+  @param  Status                A pointer to the result of the USB transfer.
+
+  @retval EFI_SUCCESS           The control transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The transfer failed. The transfer status is returned in Status.
+  @retval EFI_INVALID_PARAMETE  One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer fails due to timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_CONTROL_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL                        *This,
+  IN EFI_USB_DEVICE_REQUEST                     *Request,
+  IN EFI_USB_DATA_DIRECTION                     Direction,
+  IN UINT32                                     Timeout,
+  IN OUT VOID                                   *Data OPTIONAL,
+  IN UINTN                                      DataLength  OPTIONAL,
+  OUT UINT32                                    *Status
+  );
+
+/**
+  This function is used to manage a USB device with the bulk transfer pipe. Bulk Transfers are
+  typically used to transfer large amounts of data to/from USB devices.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the
+                                device request is being sent. DeviceEndpoint must
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F,
+                                otherwise EFI_INVALID_PARAMETER is returned. If
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER
+                                is returned. The MSB of this parameter indicates
+                                the endpoint direction. The number "1" stands for
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+                                On input, the size, in bytes, of the data buffer specified by Data.
+                                On output, the number of bytes that were actually transferred.
+  @param  Timeout               Indicating the transfer should be completed within this time frame.
+                                The units are in milliseconds. If Timeout is 0, then the
+                                caller must wait for the function to be completed until
+                                EFI_SUCCESS or EFI_DEVICE_ERROR is returned.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The bulk transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The transfer failed. The transfer status is returned in Status.
+  @retval EFI_INVALID_PARAMETE  One or more parameters are invalid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The control transfer fails due to timeout.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_BULK_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN UINT8                          DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN OUT UINTN                      *DataLength,
+  IN UINTN                          Timeout,
+  OUT UINT32                        *Status
+  );
+
+/**
+  This function is used to manage a USB device with an interrupt transfer pipe. An Asynchronous
+  Interrupt Transfer is typically used to query a device's status at a fixed rate. For example,
+  keyboard, mouse, and hub devices use this type of transfer to query their interrupt endpoints at
+  a fixed rate.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the
+                                device request is being sent. DeviceEndpoint must
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F,
+                                otherwise EFI_INVALID_PARAMETER is returned. If
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER
+                                is returned. The MSB of this parameter indicates
+                                the endpoint direction. The number "1" stands for
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  IsNewTransfer         If TRUE, a new transfer will be submitted to USB controller. If
+                                FALSE, the interrupt transfer is deleted from the device's interrupt
+                                transfer queue.
+  @param  PollingInterval       Indicates the periodic rate, in milliseconds, that the transfer is to be
+                                executed.This parameter is required when IsNewTransfer is TRUE. The
+                                value must be between 1 to 255, otherwise EFI_INVALID_PARAMETER is returned.
+                                The units are in milliseconds.
+  @param  DataLength            Specifies the length, in bytes, of the data to be received from the
+                                USB device. This parameter is only required when IsNewTransfer is TRUE.
+  @param  InterruptCallback     The Callback function. This function is called if the asynchronous
+                                interrupt transfer is completed. This parameter is required
+                                when IsNewTransfer is TRUE.
+  @param  Context               Data passed to the InterruptCallback function. This is an optional
+                                parameter and may be NULL.
+
+  @retval EFI_SUCCESS           The asynchronous USB transfer request transfer has been successfully executed.
+  @retval EFI_DEVICE_ERROR      The asynchronous USB transfer request failed.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ASYNC_INTERRUPT_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL                                 *This,
+  IN UINT8                                               DeviceEndpoint,
+  IN BOOLEAN                                             IsNewTransfer,
+  IN UINTN                                               PollingInterval    OPTIONAL,
+  IN UINTN                                               DataLength         OPTIONAL,
+  IN EFI_ASYNC_USB_TRANSFER_CALLBACK                     InterruptCallBack  OPTIONAL,
+  IN VOID                                                *Context OPTIONAL
+  );
+
+/**
+  This function is used to manage a USB device with an interrupt transfer pipe.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the
+                                device request is being sent. DeviceEndpoint must
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F,
+                                otherwise EFI_INVALID_PARAMETER is returned. If
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER
+                                is returned. The MSB of this parameter indicates
+                                the endpoint direction. The number "1" stands for
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            On input, then size, in bytes, of the buffer Data. On output, the
+                                amount of data actually transferred.
+  @param  Timeout               The time out, in seconds, for this transfer. If Timeout is 0,
+                                then the caller must wait for the function to be completed
+                                until EFI_SUCCESS or EFI_DEVICE_ERROR is returned. If the
+                                transfer is not completed in this time frame, then EFI_TIMEOUT is returned.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The sync interrupt transfer has been successfully executed.
+  @retval EFI_INVALID_PARAMETER One or more parameters are invalid.
+  @retval EFI_DEVICE_ERROR      The sync interrupt transfer request failed.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The transfer fails due to timeout.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_SYNC_INTERRUPT_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN     UINT8                      DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN OUT UINTN                      *DataLength,
+  IN     UINTN                      Timeout,
+  OUT    UINT32                     *Status
+  );
+
+/**
+  This function is used to manage a USB device with an isochronous transfer pipe. An Isochronous
+  transfer is typically used to transfer streaming data.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the
+                                device request is being sent. DeviceEndpoint must
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F,
+                                otherwise EFI_INVALID_PARAMETER is returned. If
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER
+                                is returned. The MSB of this parameter indicates
+                                the endpoint direction. The number "1" stands for
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+  @param  Status                This parameter indicates the USB transfer status.
+
+  @retval EFI_SUCCESS           The isochronous transfer has been successfully executed.
+  @retval EFI_INVALID_PARAMETER The parameter DeviceEndpoint is not valid.
+  @retval EFI_DEVICE_ERROR      The transfer failed due to the reason other than timeout, The error status
+                                is returned in Status.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+  @retval EFI_TIMEOUT           The transfer fails due to timeout.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ISOCHRONOUS_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN     UINT8                      DeviceEndpoint,
+  IN OUT VOID                       *Data,
+  IN     UINTN                      DataLength,
+  OUT    UINT32                     *Status
+  );
+
+/**
+  This function is used to manage a USB device with an isochronous transfer pipe. An Isochronous
+  transfer is typically used to transfer streaming data.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceEndpoint        The destination USB device endpoint to which the
+                                device request is being sent. DeviceEndpoint must
+                                be between 0x01 and 0x0F or between 0x81 and 0x8F,
+                                otherwise EFI_INVALID_PARAMETER is returned. If
+                                the endpoint is not a BULK endpoint, EFI_INVALID_PARAMETER
+                                is returned. The MSB of this parameter indicates
+                                the endpoint direction. The number "1" stands for
+                                an IN endpoint, and "0" stands for an OUT endpoint.
+  @param  Data                  A pointer to the buffer of data that will be transmitted to USB
+                                device or received from USB device.
+  @param  DataLength            The size, in bytes, of the data buffer specified by Data.
+                                This is an optional parameter and may be NULL.
+  @param  IsochronousCallback   The IsochronousCallback() function.This function is
+                                called if the requested isochronous transfer is completed.
+  @param  Context               Data passed to the IsochronousCallback() function.
+
+  @retval EFI_SUCCESS           The asynchronous isochronous transfer has been successfully submitted
+                                to the system.
+  @retval EFI_INVALID_PARAMETER The parameter DeviceEndpoint is not valid.
+  @retval EFI_OUT_OF_RESOURCES  The request could not be submitted due to a lack of resources.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_ASYNC_ISOCHRONOUS_TRANSFER)(
+  IN EFI_USB_IO_PROTOCOL              *This,
+  IN UINT8                            DeviceEndpoint,
+  IN OUT VOID                         *Data,
+  IN     UINTN                        DataLength,
+  IN EFI_ASYNC_USB_TRANSFER_CALLBACK  IsochronousCallBack,
+  IN VOID                             *Context OPTIONAL
+  );
+
+/**
+  Resets and reconfigures the USB controller. This function will work for all USB devices except
+  USB Hub Controllers.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+
+  @retval EFI_SUCCESS           The USB controller was reset.
+  @retval EFI_INVALID_PARAMETER If the controller specified by This is a USB hub.
+  @retval EFI_DEVICE_ERROR      An error occurred during the reconfiguration process.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_PORT_RESET)(
+  IN EFI_USB_IO_PROTOCOL    *This
+  );
+
+/**
+  Retrieves the USB Device Descriptor.
+
+  @param  This                  A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  DeviceDescriptor      A pointer to the caller allocated USB Device Descriptor.
+
+  @retval EFI_SUCCESS           The device descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER DeviceDescriptor is NULL.
+  @retval EFI_NOT_FOUND         The device descriptor was not found. The device may not be configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_DEVICE_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_DEVICE_DESCRIPTOR     *DeviceDescriptor
+  );
+
+/**
+  Retrieves the USB Device Descriptor.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  ConfigurationDescriptor A pointer to the caller allocated USB Active Configuration
+                                  Descriptor.
+  @retval EFI_SUCCESS             The active configuration descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   ConfigurationDescriptor is NULL.
+  @retval EFI_NOT_FOUND           An active configuration descriptor cannot be found. The device may not
+                                  be configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_CONFIG_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_CONFIG_DESCRIPTOR     *ConfigurationDescriptor
+  );
+
+/**
+  Retrieves the Interface Descriptor for a USB Device Controller. As stated earlier, an interface
+  within a USB device is equivalently to a USB Controller within the current configuration.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  InterfaceDescriptor     A pointer to the caller allocated USB Interface Descriptor within
+                                  the configuration setting.
+  @retval EFI_SUCCESS             The interface descriptor retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   InterfaceDescriptor is NULL.
+  @retval EFI_NOT_FOUND           The interface descriptor cannot be found. The device may not be
+                                  correctly configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_INTERFACE_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT EFI_USB_INTERFACE_DESCRIPTOR  *InterfaceDescriptor
+  );
+
+/**
+  Retrieves an Endpoint Descriptor within a USB Controller.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  EndpointIndex           Indicates which endpoint descriptor to retrieve.
+  @param  EndpointDescriptor      A pointer to the caller allocated USB Endpoint Descriptor of
+                                  a USB controller.
+
+  @retval EFI_SUCCESS             The endpoint descriptor was retrieved successfully.
+  @retval EFI_INVALID_PARAMETER   One or more parameters are invalid.
+  @retval EFI_NOT_FOUND           The endpoint descriptor cannot be found. The device may not be
+                                  correctly configured.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_ENDPOINT_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN  UINT8                         EndpointIndex,
+  OUT EFI_USB_ENDPOINT_DESCRIPTOR   *EndpointDescriptor
+  );
+
+/**
+  Retrieves a string stored in a USB Device.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  LangID                  The Language ID for the string being retrieved.
+  @param  StringID                The ID of the string being retrieved.
+  @param  String                  A pointer to a buffer allocated by this function with
+                                  AllocatePool() to store the string.If this function
+                                  returns EFI_SUCCESS, it stores the string the caller
+                                  wants to get. The caller should release the string
+                                  buffer with FreePool() after the string is not used any more.
+
+  @retval EFI_SUCCESS             The string was retrieved successfully.
+  @retval EFI_NOT_FOUND           The string specified by LangID and StringID was not found.
+  @retval EFI_OUT_OF_RESOURCES    There are not enough resources to allocate the return buffer String.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_STRING_DESCRIPTOR)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  IN  UINT16                        LangID,
+  IN  UINT8                         StringID,
+  OUT CHAR16                        **String
+  );
+
+/**
+  Retrieves all the language ID codes that the USB device supports.
+
+  @param  This                    A pointer to the EFI_USB_IO_PROTOCOL instance.
+  @param  LangIDTable             Language ID for the string the caller wants to get.
+                                  This is a 16-bit ID defined by Microsoft. This
+                                  buffer pointer is allocated and maintained by
+                                  the USB Bus Driver, the caller should not modify
+                                  its contents.
+  @param  TableSize               The size, in bytes, of the table LangIDTable.
+
+  @retval EFI_SUCCESS             The support languages were retrieved successfully.
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_USB_IO_GET_SUPPORTED_LANGUAGE)(
+  IN EFI_USB_IO_PROTOCOL            *This,
+  OUT UINT16                        **LangIDTable,
+  OUT UINT16                        *TableSize
+  );
+
+///
+/// The EFI_USB_IO_PROTOCOL provides four basic transfers types described
+/// in the USB 1.1 Specification. These include control transfer, interrupt
+/// transfer, bulk transfer and isochronous transfer. The EFI_USB_IO_PROTOCOL
+/// also provides some basic USB device/controller management and configuration
+/// interfaces. A USB device driver uses the services of this protocol to manage USB devices.
+///
+struct _EFI_USB_IO_PROTOCOL {
+  //
+  // IO transfer
+  //
+  EFI_USB_IO_CONTROL_TRANSFER           UsbControlTransfer;
+  EFI_USB_IO_BULK_TRANSFER              UsbBulkTransfer;
+  EFI_USB_IO_ASYNC_INTERRUPT_TRANSFER   UsbAsyncInterruptTransfer;
+  EFI_USB_IO_SYNC_INTERRUPT_TRANSFER    UsbSyncInterruptTransfer;
+  EFI_USB_IO_ISOCHRONOUS_TRANSFER       UsbIsochronousTransfer;
+  EFI_USB_IO_ASYNC_ISOCHRONOUS_TRANSFER UsbAsyncIsochronousTransfer;
+
+  //
+  // Common device request
+  //
+  EFI_USB_IO_GET_DEVICE_DESCRIPTOR      UsbGetDeviceDescriptor;
+  EFI_USB_IO_GET_CONFIG_DESCRIPTOR      UsbGetConfigDescriptor;
+  EFI_USB_IO_GET_INTERFACE_DESCRIPTOR   UsbGetInterfaceDescriptor;
+  EFI_USB_IO_GET_ENDPOINT_DESCRIPTOR    UsbGetEndpointDescriptor;
+  EFI_USB_IO_GET_STRING_DESCRIPTOR      UsbGetStringDescriptor;
+  EFI_USB_IO_GET_SUPPORTED_LANGUAGE     UsbGetSupportedLanguages;
+
+  //
+  // Reset controller's parent port
+  //
+  EFI_USB_IO_PORT_RESET                 UsbPortReset;
+};
+
+extern EFI_GUID gEfiUsbIoProtocolGuid;
+
+#endif