mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-11 14:28:08 +01:00
d7c710f9e3
Signed-off-by: SergeySlice <sergey.slice@gmail.com>
1884 lines
52 KiB
C
1884 lines
52 KiB
C
/** @file
|
|
|
|
The UHCI driver model and HC protocol routines.
|
|
|
|
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include "Uhci.h"
|
|
|
|
|
|
EFI_DRIVER_BINDING_PROTOCOL gUhciDriverBinding = {
|
|
UhciDriverBindingSupported,
|
|
UhciDriverBindingStart,
|
|
UhciDriverBindingStop,
|
|
0x20,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
/**
|
|
Provides software reset for the USB host controller according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param Attributes A bit mask of the reset operation to perform. See
|
|
below for a list of the supported bit mask values.
|
|
|
|
@return EFI_SUCCESS The reset operation succeeded.
|
|
@return EFI_INVALID_PARAMETER Attributes is not valid.
|
|
@return EFI_UNSUPPORTED This type of reset is not currently supported.
|
|
@return EFI_DEVICE_ERROR Other errors.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2Reset (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN UINT16 Attributes
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
EFI_TPL OldTpl;
|
|
|
|
if ((Attributes == EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG) ||
|
|
(Attributes == EFI_USB_HC_RESET_HOST_WITH_DEBUG)) {
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
if (Uhc->DevicePath != NULL) {
|
|
//
|
|
// Report Status Code to indicate reset happens
|
|
//
|
|
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
|
|
EFI_PROGRESS_CODE,
|
|
(EFI_IO_BUS_USB | EFI_IOB_PC_RESET),
|
|
Uhc->DevicePath
|
|
);
|
|
}
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
switch (Attributes) {
|
|
case EFI_USB_HC_RESET_GLOBAL:
|
|
//
|
|
// Stop schedule and set the Global Reset bit in the command register
|
|
//
|
|
UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
|
|
UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_GRESET);
|
|
|
|
gBS->Stall (UHC_ROOT_PORT_RESET_STALL);
|
|
|
|
//
|
|
// Clear the Global Reset bit to zero.
|
|
//
|
|
UhciClearRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_GRESET);
|
|
|
|
gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
|
|
break;
|
|
|
|
case EFI_USB_HC_RESET_HOST_CONTROLLER:
|
|
//
|
|
// Stop schedule and set Host Controller Reset bit to 1
|
|
//
|
|
UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
|
|
UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_HCRESET);
|
|
|
|
gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
|
|
break;
|
|
|
|
default:
|
|
goto ON_INVAILD_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Delete all old transactions on the USB bus, then
|
|
// reinitialize the frame list
|
|
//
|
|
UhciFreeAllAsyncReq (Uhc);
|
|
UhciDestoryFrameList (Uhc);
|
|
UhciInitFrameList (Uhc);
|
|
|
|
gBS->RestoreTPL (OldTpl);
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
ON_INVAILD_PARAMETER:
|
|
|
|
gBS->RestoreTPL (OldTpl);
|
|
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
|
|
/**
|
|
Retrieves current state of the USB host controller according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param State Variable to receive current device state.
|
|
|
|
@return EFI_SUCCESS The state is returned.
|
|
@return EFI_INVALID_PARAMETER State is not valid.
|
|
@return EFI_DEVICE_ERROR Other errors.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2GetState (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
OUT EFI_USB_HC_STATE *State
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
UINT16 UsbSts;
|
|
UINT16 UsbCmd;
|
|
|
|
if (State == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
UsbCmd = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
|
|
UsbSts = UhciReadReg (Uhc->PciIo, USBSTS_OFFSET);
|
|
|
|
if ((UsbCmd & USBCMD_EGSM) !=0 ) {
|
|
*State = EfiUsbHcStateSuspend;
|
|
|
|
} else if ((UsbSts & USBSTS_HCH) != 0) {
|
|
*State = EfiUsbHcStateHalt;
|
|
|
|
} else {
|
|
*State = EfiUsbHcStateOperational;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Sets the USB host controller to a specific state according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param State Indicates the state of the host controller that will
|
|
be set.
|
|
|
|
@return EFI_SUCCESS Host controller was successfully placed in the state.
|
|
@return EFI_INVALID_PARAMETER State is invalid.
|
|
@return EFI_DEVICE_ERROR Failed to set the state.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2SetState (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN EFI_USB_HC_STATE State
|
|
)
|
|
{
|
|
EFI_USB_HC_STATE CurState;
|
|
USB_HC_DEV *Uhc;
|
|
EFI_TPL OldTpl;
|
|
EFI_STATUS Status;
|
|
UINT16 UsbCmd;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
Status = Uhci2GetState (This, &CurState);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
if (CurState == State) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
Status = EFI_SUCCESS;
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
switch (State) {
|
|
case EfiUsbHcStateHalt:
|
|
Status = UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
|
|
break;
|
|
|
|
case EfiUsbHcStateOperational:
|
|
UsbCmd = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
|
|
|
|
if (CurState == EfiUsbHcStateHalt) {
|
|
//
|
|
// Set Run/Stop bit to 1, also set the bandwidht reclamation
|
|
// point to 64 bytes
|
|
//
|
|
UsbCmd |= USBCMD_RS | USBCMD_MAXP;
|
|
UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
|
|
|
|
} else if (CurState == EfiUsbHcStateSuspend) {
|
|
//
|
|
// If FGR(Force Global Resume) bit is 0, set it
|
|
//
|
|
if ((UsbCmd & USBCMD_FGR) == 0) {
|
|
UsbCmd |= USBCMD_FGR;
|
|
UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
|
|
}
|
|
|
|
//
|
|
// wait 20ms to let resume complete (20ms is specified by UHCI spec)
|
|
//
|
|
gBS->Stall (UHC_FORCE_GLOBAL_RESUME_STALL);
|
|
|
|
//
|
|
// Write FGR bit to 0 and EGSM(Enter Global Suspend Mode) bit to 0
|
|
//
|
|
UsbCmd &= ~USBCMD_FGR;
|
|
UsbCmd &= ~USBCMD_EGSM;
|
|
UsbCmd |= USBCMD_RS;
|
|
UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
|
|
}
|
|
|
|
break;
|
|
|
|
case EfiUsbHcStateSuspend:
|
|
Status = Uhci2SetState (This, EfiUsbHcStateHalt);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Status = EFI_DEVICE_ERROR;
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
//
|
|
// Set Enter Global Suspend Mode bit to 1.
|
|
//
|
|
UsbCmd = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
|
|
UsbCmd |= USBCMD_EGSM;
|
|
UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, UsbCmd);
|
|
break;
|
|
|
|
default:
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
ON_EXIT:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Retrieves capabilities of USB host controller according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param MaxSpeed A pointer to the max speed USB host controller
|
|
supports.
|
|
@param PortNumber A pointer to the number of root hub ports.
|
|
@param Is64BitCapable A pointer to an integer to show whether USB host
|
|
controller supports 64-bit memory addressing.
|
|
|
|
@return EFI_SUCCESS capabilities were retrieved successfully.
|
|
@return EFI_INVALID_PARAMETER MaxSpeed or PortNumber or Is64BitCapable is NULL.
|
|
@return EFI_DEVICE_ERROR An error was encountered.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2GetCapability (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
OUT UINT8 *MaxSpeed,
|
|
OUT UINT8 *PortNumber,
|
|
OUT UINT8 *Is64BitCapable
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
UINT32 Offset;
|
|
UINT16 PortSC;
|
|
UINT32 Index;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
if ((NULL == MaxSpeed) || (NULL == PortNumber) || (NULL == Is64BitCapable)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*MaxSpeed = EFI_USB_SPEED_FULL;
|
|
*Is64BitCapable = (UINT8) FALSE;
|
|
|
|
*PortNumber = 0;
|
|
|
|
for (Index = 0; Index < USB_MAX_ROOTHUB_PORT; Index++) {
|
|
Offset = USBPORTSC_OFFSET + Index * 2;
|
|
PortSC = UhciReadReg (Uhc->PciIo, Offset);
|
|
|
|
//
|
|
// Port status's bit 7 is reserved and always returns 1 if
|
|
// the port number is valid. Intel's UHCI (in EHCI controller)
|
|
// returns 0 in this bit if port number is invalid. Also, if
|
|
// PciIo IoRead returns error, 0xFFFF is returned to caller.
|
|
//
|
|
if (((PortSC & 0x80) == 0) || (PortSC == 0xFFFF)) {
|
|
break;
|
|
}
|
|
(*PortNumber)++;
|
|
}
|
|
|
|
Uhc->RootPorts = *PortNumber;
|
|
|
|
DEBUG ((EFI_D_INFO, "Uhci2GetCapability: %d ports\n", (UINT32)Uhc->RootPorts));
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Retrieves the current status of a USB root hub port according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL.
|
|
@param PortNumber The port to get status.
|
|
@param PortStatus A pointer to the current port status bits and port
|
|
status change bits.
|
|
|
|
@return EFI_SUCCESS status of the USB root hub port was returned in PortStatus.
|
|
@return EFI_INVALID_PARAMETER PortNumber is invalid.
|
|
@return EFI_DEVICE_ERROR Can't read register.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2GetRootHubPortStatus (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN UINT8 PortNumber,
|
|
OUT EFI_USB_PORT_STATUS *PortStatus
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
UINT32 Offset;
|
|
UINT16 PortSC;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
if (PortStatus == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (PortNumber >= Uhc->RootPorts) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
Offset = USBPORTSC_OFFSET + PortNumber * 2;
|
|
PortStatus->PortStatus = 0;
|
|
PortStatus->PortChangeStatus = 0;
|
|
|
|
PortSC = UhciReadReg (Uhc->PciIo, Offset);
|
|
|
|
if ((PortSC & USBPORTSC_CCS) != 0) {
|
|
PortStatus->PortStatus |= USB_PORT_STAT_CONNECTION;
|
|
}
|
|
|
|
if ((PortSC & USBPORTSC_PED) != 0) {
|
|
PortStatus->PortStatus |= USB_PORT_STAT_ENABLE;
|
|
}
|
|
|
|
if ((PortSC & USBPORTSC_SUSP) != 0) {
|
|
DEBUG ((EFI_D_INFO, "Uhci2GetRootHubPortStatus: port %d is suspended\n", PortNumber));
|
|
PortStatus->PortStatus |= USB_PORT_STAT_SUSPEND;
|
|
}
|
|
|
|
if ((PortSC & USBPORTSC_PR) != 0) {
|
|
PortStatus->PortStatus |= USB_PORT_STAT_RESET;
|
|
}
|
|
|
|
if ((PortSC & USBPORTSC_LSDA) != 0) {
|
|
PortStatus->PortStatus |= USB_PORT_STAT_LOW_SPEED;
|
|
}
|
|
|
|
//
|
|
// CHC will always return one in port owner bit
|
|
//
|
|
PortStatus->PortStatus |= USB_PORT_STAT_OWNER;
|
|
|
|
if ((PortSC & USBPORTSC_CSC) != 0) {
|
|
PortStatus->PortChangeStatus |= USB_PORT_STAT_C_CONNECTION;
|
|
}
|
|
|
|
if ((PortSC & USBPORTSC_PEDC) != 0) {
|
|
PortStatus->PortChangeStatus |= USB_PORT_STAT_C_ENABLE;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Sets a feature for the specified root hub port according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL.
|
|
@param PortNumber Specifies the root hub port whose feature is
|
|
requested to be set.
|
|
@param PortFeature Indicates the feature selector associated with the
|
|
feature set request.
|
|
|
|
@return EFI_SUCCESS PortFeature was set for the root port.
|
|
@return EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
|
|
@return EFI_DEVICE_ERROR Can't read register.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2SetRootHubPortFeature (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN UINT8 PortNumber,
|
|
IN EFI_USB_PORT_FEATURE PortFeature
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
EFI_TPL OldTpl;
|
|
UINT32 Offset;
|
|
UINT16 PortSC;
|
|
UINT16 Command;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
if (PortNumber >= Uhc->RootPorts) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
Offset = USBPORTSC_OFFSET + PortNumber * 2;
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
PortSC = UhciReadReg (Uhc->PciIo, Offset);
|
|
|
|
switch (PortFeature) {
|
|
case EfiUsbPortSuspend:
|
|
Command = UhciReadReg (Uhc->PciIo, USBCMD_OFFSET);
|
|
if ((Command & USBCMD_EGSM) == 0) {
|
|
//
|
|
// if global suspend is not active, can set port suspend
|
|
//
|
|
PortSC &= 0xfff5;
|
|
PortSC |= USBPORTSC_SUSP;
|
|
}
|
|
break;
|
|
|
|
case EfiUsbPortReset:
|
|
PortSC &= 0xfff5;
|
|
PortSC |= USBPORTSC_PR;
|
|
break;
|
|
|
|
case EfiUsbPortPower:
|
|
//
|
|
// No action
|
|
//
|
|
break;
|
|
|
|
case EfiUsbPortEnable:
|
|
PortSC &= 0xfff5;
|
|
PortSC |= USBPORTSC_PED;
|
|
break;
|
|
|
|
default:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
UhciWriteReg (Uhc->PciIo, Offset, PortSC);
|
|
gBS->RestoreTPL (OldTpl);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Clears a feature for the specified root hub port according to Uefi 2.0 spec.
|
|
|
|
@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.
|
|
@param PortFeature Indicates the feature selector associated with the
|
|
feature clear request.
|
|
|
|
@return EFI_SUCCESS PortFeature was cleared for the USB root hub port.
|
|
@return EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
|
|
@return EFI_DEVICE_ERROR Can't read register.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2ClearRootHubPortFeature (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN UINT8 PortNumber,
|
|
IN EFI_USB_PORT_FEATURE PortFeature
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
EFI_TPL OldTpl;
|
|
UINT32 Offset;
|
|
UINT16 PortSC;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
if (PortNumber >= Uhc->RootPorts) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
Offset = USBPORTSC_OFFSET + PortNumber * 2;
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
PortSC = UhciReadReg (Uhc->PciIo, Offset);
|
|
|
|
switch (PortFeature) {
|
|
case EfiUsbPortEnable:
|
|
PortSC &= 0xfff5;
|
|
PortSC &= ~USBPORTSC_PED;
|
|
break;
|
|
|
|
case EfiUsbPortSuspend:
|
|
//
|
|
// Cause a resume on the specified port if in suspend mode.
|
|
//
|
|
PortSC &= 0xfff5;
|
|
PortSC &= ~USBPORTSC_SUSP;
|
|
break;
|
|
|
|
case EfiUsbPortPower:
|
|
//
|
|
// No action
|
|
//
|
|
break;
|
|
|
|
case EfiUsbPortReset:
|
|
PortSC &= 0xfff5;
|
|
PortSC &= ~USBPORTSC_PR;
|
|
break;
|
|
|
|
case EfiUsbPortConnectChange:
|
|
PortSC &= 0xfff5;
|
|
PortSC |= USBPORTSC_CSC;
|
|
break;
|
|
|
|
case EfiUsbPortEnableChange:
|
|
PortSC &= 0xfff5;
|
|
PortSC |= USBPORTSC_PEDC;
|
|
break;
|
|
|
|
case EfiUsbPortSuspendChange:
|
|
//
|
|
// Root hub does not support this
|
|
//
|
|
break;
|
|
|
|
case EfiUsbPortOverCurrentChange:
|
|
//
|
|
// Root hub does not support this
|
|
//
|
|
break;
|
|
|
|
case EfiUsbPortResetChange:
|
|
//
|
|
// Root hub does not support this
|
|
//
|
|
break;
|
|
|
|
default:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
UhciWriteReg (Uhc->PciIo, Offset, PortSC);
|
|
gBS->RestoreTPL (OldTpl);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Submits control transfer to a target USB device according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param Request USB device request to send.
|
|
@param TransferDirection Data direction of the Data stage in control transfer.
|
|
@param Data Data to transmit/receive in data stage.
|
|
@param DataLength Length of the data.
|
|
@param TimeOut Maximum time, in microseconds, for transfer to complete.
|
|
@param Translator Transaction translator to be used by this device.
|
|
@param TransferResult Variable to receive the transfer result.
|
|
|
|
@return EFI_SUCCESS The control transfer was completed successfully.
|
|
@return EFI_OUT_OF_RESOURCES Failed due to lack of resource.
|
|
@return EFI_INVALID_PARAMETER Some parameters are invalid.
|
|
@return EFI_TIMEOUT Failed due to timeout.
|
|
@return EFI_DEVICE_ERROR Failed due to host controller or device error.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2ControlTransfer (
|
|
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,
|
|
IN OUT UINTN *DataLength,
|
|
IN UINTN TimeOut,
|
|
IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
|
|
OUT UINT32 *TransferResult
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
UHCI_TD_SW *TDs;
|
|
EFI_TPL OldTpl;
|
|
EFI_STATUS Status;
|
|
UHCI_QH_RESULT QhResult;
|
|
UINT8 PktId;
|
|
UINT8 *RequestPhy;
|
|
VOID *RequestMap;
|
|
UINT8 *DataPhy;
|
|
VOID *DataMap;
|
|
BOOLEAN IsSlowDevice;
|
|
UINTN TransferDataLength;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
TDs = NULL;
|
|
DataPhy = NULL;
|
|
DataMap = NULL;
|
|
RequestPhy = NULL;
|
|
RequestMap = NULL;
|
|
|
|
IsSlowDevice = (BOOLEAN) ((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
|
|
|
|
//
|
|
// Parameters Checking
|
|
//
|
|
if (Request == NULL || TransferResult == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (IsSlowDevice && (MaximumPacketLength != 8)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((MaximumPacketLength != 8) && (MaximumPacketLength != 16) &&
|
|
(MaximumPacketLength != 32) && (MaximumPacketLength != 64)) {
|
|
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((TransferDirection != EfiUsbNoData) && (Data == NULL || DataLength == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (TransferDirection == EfiUsbNoData) {
|
|
TransferDataLength = 0;
|
|
} else {
|
|
TransferDataLength = *DataLength;
|
|
}
|
|
|
|
*TransferResult = EFI_USB_ERR_SYSTEM;
|
|
Status = EFI_DEVICE_ERROR;
|
|
|
|
//
|
|
// If errors exist that cause host controller halt,
|
|
// clear status then return EFI_DEVICE_ERROR.
|
|
//
|
|
UhciAckAllInterrupt (Uhc);
|
|
|
|
if (!UhciIsHcWorking (Uhc->PciIo)) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
//
|
|
// Map the Request and data for bus master access,
|
|
// then create a list of TD for this transfer
|
|
//
|
|
Status = UhciMapUserRequest (Uhc, Request, &RequestPhy, &RequestMap);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
Status = UhciMapUserData (Uhc, TransferDirection, Data, DataLength, &PktId, &DataPhy, &DataMap);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, RequestMap);
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
TDs = UhciCreateCtrlTds (
|
|
Uhc,
|
|
DeviceAddress,
|
|
PktId,
|
|
(UINT8*)Request,
|
|
RequestPhy,
|
|
(UINT8*)Data,
|
|
DataPhy,
|
|
TransferDataLength,
|
|
(UINT8) MaximumPacketLength,
|
|
IsSlowDevice
|
|
);
|
|
|
|
if (TDs == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto UNMAP_DATA;
|
|
}
|
|
|
|
//
|
|
// According to the speed of the end point, link
|
|
// the TD to corrosponding queue head, then check
|
|
// the execution result
|
|
//
|
|
UhciLinkTdToQh (Uhc, Uhc->CtrlQh, TDs);
|
|
Status = UhciExecuteTransfer (Uhc, Uhc->CtrlQh, TDs, TimeOut, IsSlowDevice, &QhResult);
|
|
UhciUnlinkTdFromQh (Uhc->CtrlQh, TDs);
|
|
|
|
Uhc->PciIo->Flush (Uhc->PciIo);
|
|
|
|
*TransferResult = QhResult.Result;
|
|
|
|
if (DataLength != NULL) {
|
|
*DataLength = QhResult.Complete;
|
|
}
|
|
|
|
UhciDestoryTds (Uhc, TDs);
|
|
|
|
UNMAP_DATA:
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, RequestMap);
|
|
|
|
ON_EXIT:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Submits bulk transfer to a bulk endpoint of a USB device.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param EndPointAddress Endpoint number and direction.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param DataBuffersNumber Number of data buffers prepared for the transfer.
|
|
@param Data Array of pointers to the buffers of data.
|
|
@param DataLength On input, size of the data buffer, On output,
|
|
actually transferred data size.
|
|
@param DataToggle On input, data toggle to use; On output, next data toggle.
|
|
@param TimeOut Maximum time out, in microseconds.
|
|
@param Translator A pointr to the transaction translator data.
|
|
@param TransferResult Variable to receive transfer result.
|
|
|
|
@return EFI_SUCCESS The bulk transfer was completed successfully.
|
|
@return EFI_OUT_OF_RESOURCES Failed due to lack of resource.
|
|
@return EFI_INVALID_PARAMETER Some parameters are invalid.
|
|
@return EFI_TIMEOUT Failed due to timeout.
|
|
@return EFI_DEVICE_ERROR Failed due to host controller or device error.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2BulkTransfer (
|
|
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
|
|
)
|
|
{
|
|
EFI_USB_DATA_DIRECTION Direction;
|
|
EFI_TPL OldTpl;
|
|
USB_HC_DEV *Uhc;
|
|
UHCI_TD_SW *TDs;
|
|
UHCI_QH_SW *BulkQh;
|
|
UHCI_QH_RESULT QhResult;
|
|
EFI_STATUS Status;
|
|
UINT8 PktId;
|
|
UINT8 *DataPhy;
|
|
VOID *DataMap;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
DataPhy = NULL;
|
|
DataMap = NULL;
|
|
|
|
if (DeviceSpeed == EFI_USB_SPEED_LOW) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((DataLength == NULL) || (*DataLength == 0) || (Data == NULL) || (TransferResult == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((*DataToggle != 1) && (*DataToggle != 0)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((MaximumPacketLength != 8) && (MaximumPacketLength != 16) &&
|
|
(MaximumPacketLength != 32) && (MaximumPacketLength != 64)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*TransferResult = EFI_USB_ERR_SYSTEM;
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
|
|
//
|
|
// If has errors that cause host controller halt,
|
|
// then return EFI_DEVICE_ERROR directly.
|
|
//
|
|
UhciAckAllInterrupt (Uhc);
|
|
|
|
if (!UhciIsHcWorking (Uhc->PciIo)) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
//
|
|
// Map the source data buffer for bus master access,
|
|
// then create a list of TDs
|
|
//
|
|
if ((EndPointAddress & 0x80) != 0) {
|
|
Direction = EfiUsbDataIn;
|
|
} else {
|
|
Direction = EfiUsbDataOut;
|
|
}
|
|
|
|
Status = UhciMapUserData (Uhc, Direction, *Data, DataLength, &PktId, &DataPhy, &DataMap);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
TDs = UhciCreateBulkOrIntTds (
|
|
Uhc,
|
|
DeviceAddress,
|
|
EndPointAddress,
|
|
PktId,
|
|
(UINT8 *)*Data,
|
|
DataPhy,
|
|
*DataLength,
|
|
DataToggle,
|
|
(UINT8) MaximumPacketLength,
|
|
FALSE
|
|
);
|
|
|
|
if (TDs == NULL) {
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
|
|
//
|
|
// Link the TDs to bulk queue head. According to the platfore
|
|
// defintion of UHCI_NO_BW_RECLAMATION, BulkQh is either configured
|
|
// to do full speed bandwidth reclamation or not.
|
|
//
|
|
BulkQh = Uhc->BulkQh;
|
|
|
|
UhciLinkTdToQh (Uhc, BulkQh, TDs);
|
|
Status = UhciExecuteTransfer (Uhc, BulkQh, TDs, TimeOut, FALSE, &QhResult);
|
|
UhciUnlinkTdFromQh (BulkQh, TDs);
|
|
|
|
Uhc->PciIo->Flush (Uhc->PciIo);
|
|
|
|
*TransferResult = QhResult.Result;
|
|
*DataToggle = QhResult.NextToggle;
|
|
*DataLength = QhResult.Complete;
|
|
|
|
UhciDestoryTds (Uhc, TDs);
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
|
|
|
|
ON_EXIT:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Submits an asynchronous interrupt transfer to an
|
|
interrupt endpoint of a USB device according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param EndPointAddress Endpoint number and direction.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param IsNewTransfer If TRUE, submit a new transfer, if FALSE cancel old transfer.
|
|
@param DataToggle On input, data toggle to use; On output, next data toggle.
|
|
@param PollingInterval Interrupt poll rate in milliseconds.
|
|
@param DataLength On input, size of the data buffer, On output,
|
|
actually transferred data size.
|
|
@param Translator A pointr to the transaction translator data.
|
|
@param CallBackFunction Function to call periodically.
|
|
@param Context User context.
|
|
|
|
@return EFI_SUCCESS Transfer was submitted.
|
|
@return EFI_INVALID_PARAMETER Some parameters are invalid.
|
|
@return EFI_OUT_OF_RESOURCES Failed due to a lack of resources.
|
|
@return EFI_DEVICE_ERROR Can't read register.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2AsyncInterruptTransfer (
|
|
IN EFI_USB2_HC_PROTOCOL *This,
|
|
IN UINT8 DeviceAddress,
|
|
IN UINT8 EndPointAddress,
|
|
IN UINT8 DeviceSpeed,
|
|
IN UINTN MaximumPacketLength,
|
|
IN BOOLEAN IsNewTransfer,
|
|
IN OUT UINT8 *DataToggle,
|
|
IN UINTN PollingInterval,
|
|
IN UINTN DataLength,
|
|
IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
|
|
IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
BOOLEAN IsSlowDevice;
|
|
UHCI_QH_SW *Qh;
|
|
UHCI_TD_SW *IntTds;
|
|
EFI_TPL OldTpl;
|
|
EFI_STATUS Status;
|
|
UINT8 *DataPtr;
|
|
UINT8 *DataPhy;
|
|
UINT8 PktId;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
Qh = NULL;
|
|
IntTds = NULL;
|
|
DataPtr = NULL;
|
|
DataPhy = NULL;
|
|
|
|
IsSlowDevice = (BOOLEAN) ((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
|
|
|
|
if ((EndPointAddress & 0x80) == 0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Delete Async interrupt transfer request
|
|
//
|
|
if (!IsNewTransfer) {
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
Status = UhciRemoveAsyncReq (Uhc, DeviceAddress, EndPointAddress, DataToggle);
|
|
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
if (PollingInterval < 1 || PollingInterval > 255) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (DataLength == 0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((*DataToggle != 1) && (*DataToggle != 0)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// If has errors that cause host controller halt,
|
|
// then return EFI_DEVICE_ERROR directly.
|
|
//
|
|
UhciAckAllInterrupt (Uhc);
|
|
|
|
if (!UhciIsHcWorking (Uhc->PciIo)) {
|
|
return EFI_DEVICE_ERROR;
|
|
}
|
|
|
|
if ((EndPointAddress & 0x80) == 0) {
|
|
PktId = OUTPUT_PACKET_ID;
|
|
} else {
|
|
PktId = INPUT_PACKET_ID;
|
|
}
|
|
|
|
//
|
|
// Allocate and map source data buffer for bus master access.
|
|
//
|
|
DataPtr = UsbHcAllocateMem (Uhc->MemPool, DataLength);
|
|
|
|
if (DataPtr == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
DataPhy = (UINT8 *) (UINTN) UsbHcGetPciAddressForHostMem (Uhc->MemPool, DataPtr, DataLength);
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
Qh = UhciCreateQh (Uhc, PollingInterval);
|
|
|
|
if (Qh == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto FREE_DATA;
|
|
}
|
|
|
|
IntTds = UhciCreateBulkOrIntTds (
|
|
Uhc,
|
|
DeviceAddress,
|
|
EndPointAddress,
|
|
PktId,
|
|
DataPtr,
|
|
DataPhy,
|
|
DataLength,
|
|
DataToggle,
|
|
(UINT8) MaximumPacketLength,
|
|
IsSlowDevice
|
|
);
|
|
|
|
if (IntTds == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto DESTORY_QH;
|
|
}
|
|
|
|
UhciLinkTdToQh (Uhc, Qh, IntTds);
|
|
|
|
//
|
|
// Save QH-TD structures to async Interrupt transfer list,
|
|
// for monitor interrupt transfer execution routine use.
|
|
//
|
|
Status = UhciCreateAsyncReq (
|
|
Uhc,
|
|
Qh,
|
|
IntTds,
|
|
DeviceAddress,
|
|
EndPointAddress,
|
|
DataLength,
|
|
PollingInterval,
|
|
DataPtr,
|
|
CallBackFunction,
|
|
Context,
|
|
IsSlowDevice
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto DESTORY_QH;
|
|
}
|
|
|
|
UhciLinkQhToFrameList (Uhc, Qh);
|
|
|
|
gBS->RestoreTPL (OldTpl);
|
|
return EFI_SUCCESS;
|
|
|
|
DESTORY_QH:
|
|
UsbHcFreeMem (Uhc->MemPool, Qh, sizeof (UHCI_QH_SW));
|
|
|
|
FREE_DATA:
|
|
UsbHcFreeMem (Uhc->MemPool, DataPtr, DataLength);
|
|
Uhc->PciIo->Flush (Uhc->PciIo);
|
|
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Submits synchronous interrupt transfer to an interrupt endpoint
|
|
of a USB device according to UEFI 2.0 spec.
|
|
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param EndPointAddress Endpoint number and direction.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param Data Array of pointers to the buffers of data.
|
|
@param DataLength On input, size of the data buffer, On output,
|
|
actually transferred data size.
|
|
@param DataToggle On input, data toggle to use; On output, next data toggle.
|
|
@param TimeOut Maximum time out, in microseconds.
|
|
@param Translator A pointr to the transaction translator data.
|
|
@param TransferResult Variable to receive transfer result.
|
|
|
|
@return EFI_SUCCESS The transfer was completed successfully.
|
|
@return EFI_OUT_OF_RESOURCES Failed due to lack of resource.
|
|
@return EFI_INVALID_PARAMETER Some parameters are invalid.
|
|
@return EFI_TIMEOUT Failed due to timeout.
|
|
@return EFI_DEVICE_ERROR Failed due to host controller or device error.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2SyncInterruptTransfer (
|
|
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
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
USB_HC_DEV *Uhc;
|
|
UHCI_TD_SW *TDs;
|
|
UHCI_QH_RESULT QhResult;
|
|
EFI_TPL OldTpl;
|
|
UINT8 *DataPhy;
|
|
VOID *DataMap;
|
|
UINT8 PktId;
|
|
BOOLEAN IsSlowDevice;
|
|
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
DataPhy = NULL;
|
|
DataMap = NULL;
|
|
TDs = NULL;
|
|
|
|
if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
IsSlowDevice = (BOOLEAN) ((EFI_USB_SPEED_LOW == DeviceSpeed) ? TRUE : FALSE);
|
|
|
|
if ((DataLength == NULL) || (Data == NULL) || (TransferResult == NULL)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((*DataToggle != 1) && (*DataToggle != 0)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ((*DataLength == 0) || (MaximumPacketLength > 64)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (IsSlowDevice && (MaximumPacketLength > 8)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
*TransferResult = EFI_USB_ERR_SYSTEM;
|
|
Status = EFI_DEVICE_ERROR;
|
|
|
|
|
|
UhciAckAllInterrupt (Uhc);
|
|
|
|
if (!UhciIsHcWorking (Uhc->PciIo)) {
|
|
return Status;
|
|
}
|
|
|
|
OldTpl = gBS->RaiseTPL (UHCI_TPL);
|
|
|
|
//
|
|
// Map the source data buffer for bus master access.
|
|
// Create Tds list, then link it to the UHC's interrupt list
|
|
//
|
|
Status = UhciMapUserData (
|
|
Uhc,
|
|
EfiUsbDataIn,
|
|
Data,
|
|
DataLength,
|
|
&PktId,
|
|
&DataPhy,
|
|
&DataMap
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
TDs = UhciCreateBulkOrIntTds (
|
|
Uhc,
|
|
DeviceAddress,
|
|
EndPointAddress,
|
|
PktId,
|
|
(UINT8 *)Data,
|
|
DataPhy,
|
|
*DataLength,
|
|
DataToggle,
|
|
(UINT8) MaximumPacketLength,
|
|
IsSlowDevice
|
|
);
|
|
|
|
if (TDs == NULL) {
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
|
|
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
|
|
UhciLinkTdToQh (Uhc, Uhc->SyncIntQh, TDs);
|
|
|
|
Status = UhciExecuteTransfer (Uhc, Uhc->SyncIntQh, TDs, TimeOut, IsSlowDevice, &QhResult);
|
|
|
|
UhciUnlinkTdFromQh (Uhc->SyncIntQh, TDs);
|
|
Uhc->PciIo->Flush (Uhc->PciIo);
|
|
|
|
*TransferResult = QhResult.Result;
|
|
*DataToggle = QhResult.NextToggle;
|
|
*DataLength = QhResult.Complete;
|
|
|
|
UhciDestoryTds (Uhc, TDs);
|
|
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
|
|
|
|
ON_EXIT:
|
|
gBS->RestoreTPL (OldTpl);
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Submits isochronous transfer to a target USB device according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param EndPointAddress Endpoint number and direction.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param DataBuffersNumber Number of data buffers prepared for the transfer.
|
|
@param Data Array of pointers to the buffers of data.
|
|
@param DataLength On input, size of the data buffer, On output,
|
|
actually transferred data size.
|
|
@param Translator A pointr to the transaction translator data.
|
|
@param TransferResult Variable to receive transfer result.
|
|
|
|
@return EFI_UNSUPPORTED
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2IsochronousTransfer (
|
|
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
|
|
)
|
|
{
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
|
|
/**
|
|
Submits Async isochronous transfer to a target USB device according to UEFI 2.0 spec.
|
|
|
|
@param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
|
|
@param DeviceAddress Target device address.
|
|
@param EndPointAddress Endpoint number and direction.
|
|
@param DeviceSpeed Device speed.
|
|
@param MaximumPacketLength Maximum packet size of the target endpoint.
|
|
@param DataBuffersNumber Number of data buffers prepared for the transfer.
|
|
@param Data Array of pointers to the buffers of data.
|
|
@param DataLength On input, size of the data buffer, On output,
|
|
actually transferred data size.
|
|
@param Translator A pointr to the transaction translator data.
|
|
@param IsochronousCallBack Function to call when the transfer complete.
|
|
@param Context Pass to the call back function as parameter.
|
|
|
|
@return EFI_UNSUPPORTED
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
Uhci2AsyncIsochronousTransfer (
|
|
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
|
|
)
|
|
{
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
/**
|
|
Entry point for EFI drivers.
|
|
|
|
@param ImageHandle EFI_HANDLE.
|
|
@param SystemTable EFI_SYSTEM_TABLE.
|
|
|
|
@retval EFI_SUCCESS Driver is successfully loaded.
|
|
@return Others Failed.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UhciDriverEntryPoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
return EfiLibInstallDriverBindingComponentName2 (
|
|
ImageHandle,
|
|
SystemTable,
|
|
&gUhciDriverBinding,
|
|
ImageHandle,
|
|
&gUhciComponentName,
|
|
&gUhciComponentName2
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
Test to see if this driver supports ControllerHandle. Any
|
|
ControllerHandle that has UsbHcProtocol installed will be supported.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to test.
|
|
@param RemainingDevicePath Not used.
|
|
|
|
@return EFI_SUCCESS This driver supports this device.
|
|
@return EFI_UNSUPPORTED This driver does not support this device.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UhciDriverBindingSupported (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS OpenStatus;
|
|
EFI_STATUS Status;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
USB_CLASSC UsbClassCReg;
|
|
|
|
//
|
|
// Test whether there is PCI IO Protocol attached on the controller handle.
|
|
//
|
|
OpenStatus = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiPciIoProtocolGuid,
|
|
(VOID **) &PciIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
|
|
if (EFI_ERROR(OpenStatus)) {
|
|
return OpenStatus;
|
|
}
|
|
|
|
Status = PciIo->Pci.Read (
|
|
PciIo,
|
|
EfiPciIoWidthUint8,
|
|
PCI_CLASSCODE_OFFSET,
|
|
sizeof (USB_CLASSC) / sizeof (UINT8),
|
|
&UsbClassCReg
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Status = EFI_UNSUPPORTED;
|
|
goto ON_EXIT;
|
|
}
|
|
|
|
//
|
|
// Test whether the controller belongs to UHCI type
|
|
//
|
|
if ((UsbClassCReg.BaseCode != PCI_CLASS_SERIAL) ||
|
|
(UsbClassCReg.SubClassCode != PCI_CLASS_SERIAL_USB) ||
|
|
(UsbClassCReg.ProgInterface != PCI_IF_UHCI)
|
|
) {
|
|
|
|
Status = EFI_UNSUPPORTED;
|
|
}
|
|
|
|
ON_EXIT:
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
Allocate and initialize the empty UHCI device.
|
|
|
|
@param PciIo The PCIIO to use.
|
|
@param DevicePath The device path of host controller.
|
|
@param OriginalPciAttributes The original PCI attributes.
|
|
|
|
@return Allocated UHCI device. If err, return NULL.
|
|
|
|
**/
|
|
USB_HC_DEV *
|
|
UhciAllocateDev (
|
|
IN EFI_PCI_IO_PROTOCOL *PciIo,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
|
|
IN UINT64 OriginalPciAttributes
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
EFI_STATUS Status;
|
|
|
|
Uhc = AllocateZeroPool(sizeof (USB_HC_DEV));
|
|
|
|
if (Uhc == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// This driver supports both USB_HC_PROTOCOL and USB2_HC_PROTOCOL.
|
|
// USB_HC_PROTOCOL is for EFI 1.1 backward compability.
|
|
//
|
|
Uhc->Signature = USB_HC_DEV_SIGNATURE;
|
|
Uhc->Usb2Hc.GetCapability = Uhci2GetCapability;
|
|
Uhc->Usb2Hc.Reset = Uhci2Reset;
|
|
Uhc->Usb2Hc.GetState = Uhci2GetState;
|
|
Uhc->Usb2Hc.SetState = Uhci2SetState;
|
|
Uhc->Usb2Hc.ControlTransfer = Uhci2ControlTransfer;
|
|
Uhc->Usb2Hc.BulkTransfer = Uhci2BulkTransfer;
|
|
Uhc->Usb2Hc.AsyncInterruptTransfer = Uhci2AsyncInterruptTransfer;
|
|
Uhc->Usb2Hc.SyncInterruptTransfer = Uhci2SyncInterruptTransfer;
|
|
Uhc->Usb2Hc.IsochronousTransfer = Uhci2IsochronousTransfer;
|
|
Uhc->Usb2Hc.AsyncIsochronousTransfer = Uhci2AsyncIsochronousTransfer;
|
|
Uhc->Usb2Hc.GetRootHubPortStatus = Uhci2GetRootHubPortStatus;
|
|
Uhc->Usb2Hc.SetRootHubPortFeature = Uhci2SetRootHubPortFeature;
|
|
Uhc->Usb2Hc.ClearRootHubPortFeature = Uhci2ClearRootHubPortFeature;
|
|
Uhc->Usb2Hc.MajorRevision = 0x1;
|
|
Uhc->Usb2Hc.MinorRevision = 0x1;
|
|
|
|
Uhc->PciIo = PciIo;
|
|
Uhc->DevicePath = DevicePath;
|
|
Uhc->OriginalPciAttributes = OriginalPciAttributes;
|
|
Uhc->MemPool = UsbHcInitMemPool (PciIo, TRUE, 0);
|
|
|
|
if (Uhc->MemPool == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto ON_ERROR;
|
|
}
|
|
|
|
InitializeListHead (&Uhc->AsyncIntList);
|
|
|
|
Status = gBS->CreateEvent (
|
|
EVT_TIMER | EVT_NOTIFY_SIGNAL,
|
|
TPL_NOTIFY,
|
|
UhciMonitorAsyncReqList,
|
|
Uhc,
|
|
&Uhc->AsyncIntMonitor
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
UsbHcFreeMemPool (Uhc->MemPool);
|
|
goto ON_ERROR;
|
|
}
|
|
|
|
return Uhc;
|
|
|
|
ON_ERROR:
|
|
FreePool(Uhc);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/**
|
|
Free the UHCI device and release its associated resources.
|
|
|
|
@param Uhc The UHCI device to release.
|
|
|
|
**/
|
|
VOID
|
|
UhciFreeDev (
|
|
IN USB_HC_DEV *Uhc
|
|
)
|
|
{
|
|
if (Uhc->AsyncIntMonitor != NULL) {
|
|
gBS->CloseEvent (Uhc->AsyncIntMonitor);
|
|
}
|
|
|
|
if (Uhc->ExitBootServiceEvent != NULL) {
|
|
gBS->CloseEvent (Uhc->ExitBootServiceEvent);
|
|
}
|
|
|
|
if (Uhc->MemPool != NULL) {
|
|
UsbHcFreeMemPool (Uhc->MemPool);
|
|
}
|
|
|
|
if (Uhc->CtrlNameTable != NULL) {
|
|
FreeUnicodeStringTable (Uhc->CtrlNameTable);
|
|
}
|
|
|
|
FreePool(Uhc);
|
|
}
|
|
|
|
|
|
/**
|
|
Uninstall all Uhci Interface.
|
|
|
|
@param Controller Controller handle.
|
|
@param This Protocol instance pointer.
|
|
|
|
**/
|
|
VOID
|
|
UhciCleanDevUp (
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_USB2_HC_PROTOCOL *This
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Uninstall the USB_HC and USB_HC2 protocol, then disable the controller
|
|
//
|
|
Uhc = UHC_FROM_USB2_HC_PROTO (This);
|
|
|
|
|
|
Status = gBS->UninstallProtocolInterface (
|
|
Controller,
|
|
&gEfiUsb2HcProtocolGuid,
|
|
&Uhc->Usb2Hc
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return ;
|
|
}
|
|
|
|
UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
|
|
UhciFreeAllAsyncReq (Uhc);
|
|
UhciDestoryFrameList (Uhc);
|
|
|
|
//
|
|
// Restore original PCI attributes
|
|
//
|
|
Uhc->PciIo->Attributes (
|
|
Uhc->PciIo,
|
|
EfiPciIoAttributeOperationSet,
|
|
Uhc->OriginalPciAttributes,
|
|
NULL
|
|
);
|
|
|
|
UhciFreeDev (Uhc);
|
|
}
|
|
|
|
/**
|
|
One notified function to stop the Host Controller when gBS->ExitBootServices() called.
|
|
|
|
@param Event Pointer to this event
|
|
@param Context Event handler private data
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
UhcExitBootService (
|
|
EFI_EVENT Event,
|
|
VOID *Context
|
|
)
|
|
{
|
|
USB_HC_DEV *Uhc;
|
|
|
|
Uhc = (USB_HC_DEV *) Context;
|
|
|
|
//
|
|
// Stop the Host Controller
|
|
//
|
|
UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
|
|
|
|
//
|
|
// Reset the Host Controller
|
|
//
|
|
UhciSetRegBit (Uhc->PciIo, USBCMD_OFFSET, USBCMD_HCRESET);
|
|
gBS->Stall (UHC_ROOT_PORT_RECOVERY_STALL);
|
|
}
|
|
|
|
/**
|
|
Starting the Usb UHCI Driver.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to test.
|
|
@param RemainingDevicePath Not used.
|
|
|
|
@retval EFI_SUCCESS This driver supports this device.
|
|
@retval EFI_UNSUPPORTED This driver does not support this device.
|
|
@retval EFI_DEVICE_ERROR This driver cannot be started due to device Error.
|
|
EFI_OUT_OF_RESOURCES- Failed due to resource shortage.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UhciDriverBindingStart (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PCI_IO_PROTOCOL *PciIo;
|
|
USB_HC_DEV *Uhc;
|
|
UINT64 Supports;
|
|
UINT64 OriginalPciAttributes;
|
|
BOOLEAN PciAttributesSaved;
|
|
EFI_DEVICE_PATH_PROTOCOL *HcDevicePath;
|
|
|
|
//
|
|
// Open PCIIO, then enable the EHC device and turn off emulation
|
|
//
|
|
Uhc = NULL;
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiPciIoProtocolGuid,
|
|
(VOID **) &PciIo,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_BY_DRIVER
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Open Device Path Protocol for on USB host controller
|
|
//
|
|
HcDevicePath = NULL;
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID **) &HcDevicePath,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
|
|
PciAttributesSaved = FALSE;
|
|
//
|
|
// Save original PCI attributes
|
|
//
|
|
Status = PciIo->Attributes (
|
|
PciIo,
|
|
EfiPciIoAttributeOperationGet,
|
|
0,
|
|
&OriginalPciAttributes
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto CLOSE_PCIIO;
|
|
}
|
|
PciAttributesSaved = TRUE;
|
|
|
|
//
|
|
// Robustnesss improvement such as for UoL
|
|
// Default is not required.
|
|
//
|
|
if (FeaturePcdGet (PcdTurnOffUsbLegacySupport)) {
|
|
UhciTurnOffUsbEmulation (PciIo);
|
|
}
|
|
|
|
Status = PciIo->Attributes (
|
|
PciIo,
|
|
EfiPciIoAttributeOperationSupported,
|
|
0,
|
|
&Supports
|
|
);
|
|
if (!EFI_ERROR(Status)) {
|
|
Supports &= (UINT64)EFI_PCI_DEVICE_ENABLE;
|
|
Status = PciIo->Attributes (
|
|
PciIo,
|
|
EfiPciIoAttributeOperationEnable,
|
|
Supports,
|
|
NULL
|
|
);
|
|
}
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto CLOSE_PCIIO;
|
|
}
|
|
|
|
Uhc = UhciAllocateDev (PciIo, HcDevicePath, OriginalPciAttributes);
|
|
|
|
if (Uhc == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto CLOSE_PCIIO;
|
|
}
|
|
|
|
//
|
|
// Allocate and Init Host Controller's Frame List Entry
|
|
//
|
|
Status = UhciInitFrameList (Uhc);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto FREE_UHC;
|
|
}
|
|
|
|
Status = gBS->SetTimer (
|
|
Uhc->AsyncIntMonitor,
|
|
TimerPeriodic,
|
|
UHC_ASYNC_POLL_INTERVAL
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto FREE_UHC;
|
|
}
|
|
|
|
//
|
|
// Install USB2_HC_PROTOCOL
|
|
//
|
|
Status = gBS->InstallMultipleProtocolInterfaces (
|
|
&Controller,
|
|
&gEfiUsb2HcProtocolGuid,
|
|
&Uhc->Usb2Hc,
|
|
NULL
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
goto FREE_UHC;
|
|
}
|
|
|
|
//
|
|
// Create event to stop the HC when exit boot service.
|
|
//
|
|
Status = gBS->CreateEventEx (
|
|
EVT_NOTIFY_SIGNAL,
|
|
TPL_NOTIFY,
|
|
UhcExitBootService,
|
|
Uhc,
|
|
&gEfiEventExitBootServicesGuid,
|
|
&Uhc->ExitBootServiceEvent
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
goto UNINSTALL_USBHC;
|
|
}
|
|
|
|
//
|
|
// Install the component name protocol
|
|
//
|
|
Uhc->CtrlNameTable = NULL;
|
|
|
|
AddUnicodeString2 (
|
|
"eng",
|
|
gUhciComponentName.SupportedLanguages,
|
|
&Uhc->CtrlNameTable,
|
|
L"Usb Universal Host Controller",
|
|
TRUE
|
|
);
|
|
AddUnicodeString2 (
|
|
"en",
|
|
gUhciComponentName2.SupportedLanguages,
|
|
&Uhc->CtrlNameTable,
|
|
L"Usb Universal Host Controller",
|
|
FALSE
|
|
);
|
|
|
|
|
|
//
|
|
// Start the UHCI hardware, also set its reclamation point to 64 bytes
|
|
//
|
|
UhciWriteReg (Uhc->PciIo, USBCMD_OFFSET, USBCMD_RS | USBCMD_MAXP);
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
UNINSTALL_USBHC:
|
|
gBS->UninstallMultipleProtocolInterfaces (
|
|
Controller,
|
|
&gEfiUsb2HcProtocolGuid,
|
|
&Uhc->Usb2Hc,
|
|
NULL
|
|
);
|
|
|
|
FREE_UHC:
|
|
UhciFreeDev (Uhc);
|
|
|
|
CLOSE_PCIIO:
|
|
if (PciAttributesSaved) {
|
|
//
|
|
// Restore original PCI attributes
|
|
//
|
|
PciIo->Attributes (
|
|
PciIo,
|
|
EfiPciIoAttributeOperationSet,
|
|
OriginalPciAttributes,
|
|
NULL
|
|
);
|
|
}
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
Stop this driver on ControllerHandle. Support stopping any child handles
|
|
created by this driver.
|
|
|
|
@param This Protocol instance pointer.
|
|
@param Controller Handle of device to stop driver on.
|
|
@param NumberOfChildren Number of Children in the ChildHandleBuffer.
|
|
@param ChildHandleBuffer List of handles for the children we need to stop.
|
|
|
|
@return EFI_SUCCESS
|
|
@return others
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
UhciDriverBindingStop (
|
|
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
|
IN EFI_HANDLE Controller,
|
|
IN UINTN NumberOfChildren,
|
|
IN EFI_HANDLE *ChildHandleBuffer
|
|
)
|
|
{
|
|
EFI_USB2_HC_PROTOCOL *Usb2Hc;
|
|
EFI_STATUS Status;
|
|
|
|
Status = gBS->OpenProtocol (
|
|
Controller,
|
|
&gEfiUsb2HcProtocolGuid,
|
|
(VOID **) &Usb2Hc,
|
|
This->DriverBindingHandle,
|
|
Controller,
|
|
EFI_OPEN_PROTOCOL_GET_PROTOCOL
|
|
);
|
|
|
|
//
|
|
// Test whether the Controller handler passed in is a valid
|
|
// Usb controller handle that should be supported, if not,
|
|
// return the error status directly
|
|
//
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
UhciCleanDevUp (Controller, Usb2Hc);
|
|
|
|
gBS->CloseProtocol (
|
|
Controller,
|
|
&gEfiPciIoProtocolGuid,
|
|
This->DriverBindingHandle,
|
|
Controller
|
|
);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|