tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/MdeModulePkg/Bus/Pci/UhciDxe/Uhci.c

1842 lines
49 KiB
C
Raw Blame History

/** @file
Copyright (c) 2004 - 2007, Intel Corporation
All rights reserved. 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.
Module Name:
Uhci.c
Abstract:
The UHCI driver model and HC protocol routines.
Revision History
**/
#include "Uhci.h"
/**
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
**/
STATIC
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);
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 errors2006
**/
STATIC
EFI_STATUS
EFIAPI
Uhci2GetState (
IN CONST 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) {
*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
**/
STATIC
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
**/
STATIC
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)) {
(*PortNumber)++;
}
}
Uhc->RootPorts = *PortNumber;
DEBUG ((EFI_D_INFO, "Uhci2GetCapability: %d ports\n", 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
**/
STATIC
EFI_STATUS
EFIAPI
Uhci2GetRootHubPortStatus (
IN CONST EFI_USB2_HC_PROTOCOL *This,
IN CONST 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) {
PortStatus->PortStatus |= USB_PORT_STAT_CONNECTION;
}
if (PortSC & USBPORTSC_PED) {
PortStatus->PortStatus |= USB_PORT_STAT_ENABLE;
}
if (PortSC & USBPORTSC_SUSP) {
DEBUG ((EFI_D_INFO, "Uhci2GetRootHubPortStatus: port %d is suspended\n", PortNumber));
PortStatus->PortStatus |= USB_PORT_STAT_SUSPEND;
}
if (PortSC & USBPORTSC_PR) {
PortStatus->PortStatus |= USB_PORT_STAT_RESET;
}
if (PortSC & USBPORTSC_LSDA) {
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) {
PortStatus->PortChangeStatus |= USB_PORT_STAT_C_CONNECTION;
}
if (PortSC & USBPORTSC_PEDC) {
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
**/
STATIC
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)) {
//
// 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
**/
STATIC
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 accroding to UEFI 2.0 spec..
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
Request : USB device request to send
TransferDirection : Data direction of the Data stage in control transfer
Data : Data to transmit/receive in data stage
DataLength : Length of the data
TimeOut : Maximum time, in microseconds, for transfer to complete.
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.
**/
STATIC
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;
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) && (DataLength == NULL)) {
return EFI_INVALID_PARAMETER;
}
*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,
RequestPhy,
DataPhy,
*DataLength,
(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->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
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
EndPointAddress : Endpoint number and direction
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
DataBuffersNumber : Number of data buffers prepared for the transfer.
Data : Array of pointers to the buffers of data
DataLength : On input, size of the data buffer, On output,
actually transferred data size.
DataToggle : On input, data toggle to use; On output, next data toggle
Translator : A pointr to the transaction translator data.
TimeOut : Maximum time out, in microseconds
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.
**/
STATIC
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) || (Data == NULL) || (TransferResult == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (*DataLength == 0) {
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) {
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,
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 (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.
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
EndPointAddress : Endpoint number and direction
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
IsNewTransfer : If TRUE, submit a new transfer, if FALSE cancel old transfer
DataToggle : On input, data toggle to use; On output, next data toggle
PollingInterval : Interrupt poll rate in milliseconds
DataLength : On input, size of the data buffer, On output,
actually transferred data size.
Translator : A pointr to the transaction translator data.
CallBackFunction : Function to call periodically
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
**/
STATIC
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;
VOID *DataMap;
UINT8 PktId;
Uhc = UHC_FROM_USB2_HC_PROTO (This);
Qh = NULL;
IntTds = NULL;
DataPtr = NULL;
DataPhy = NULL;
DataMap = 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;
}
//
// Allocate and map source data buffer for bus master access.
//
DataPtr = AllocatePool (DataLength);
if (DataPtr == NULL) {
return EFI_OUT_OF_RESOURCES;
}
OldTpl = gBS->RaiseTPL (UHCI_TPL);
//
// Map the user data then create a queue head and
// list of TD for it.
//
Status = UhciMapUserData (
Uhc,
EfiUsbDataIn,
DataPtr,
&DataLength,
&PktId,
&DataPhy,
&DataMap
);
if (EFI_ERROR (Status)) {
goto FREE_DATA;
}
Qh = UhciCreateQh (Uhc, PollingInterval);
if (Qh == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto UNMAP_DATA;
}
IntTds = UhciCreateBulkOrIntTds (
Uhc,
DeviceAddress,
EndPointAddress,
PktId,
DataPhy,
DataLength,
DataToggle,
(UINT8) MaximumPacketLength,
IsSlowDevice
);
if (IntTds == NULL) {
Status = EFI_OUT_OF_RESOURCES;
goto DESTORY_QH;
}
UhciLinkTdToQh (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,
DataMap,
DataPtr,
CallBackFunction,
Context,
IsSlowDevice
);
if (EFI_ERROR (Status)) {
goto DESTORY_QH;
}
UhciLinkQhToFrameList (Uhc->FrameBase, Qh);
gBS->RestoreTPL (OldTpl);
return EFI_SUCCESS;
DESTORY_QH:
UsbHcFreeMem (Uhc->MemPool, Qh, sizeof (UHCI_QH_SW));
UNMAP_DATA:
Uhc->PciIo->Unmap (Uhc->PciIo, DataMap);
FREE_DATA:
gBS->FreePool (DataPtr);
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.
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
EndPointAddress : Endpoint number and direction
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
DataBuffersNumber : Number of data buffers prepared for the transfer.
Data : Array of pointers to the buffers of data
DataLength : On input, size of the data buffer, On output,
actually transferred data size.
DataToggle : On input, data toggle to use; On output, next data toggle
TimeOut : Maximum time out, in microseconds
Translator : A pointr to the transaction translator data.
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.
**/
STATIC
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 ((EndPointAddress & 0x80) == 0) {
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,
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->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.
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
EndPointAddress : Endpoint number and direction
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
DataBuffersNumber : Number of data buffers prepared for the transfer.
Data : Array of pointers to the buffers of data
DataLength : On input, size of the data buffer, On output,
actually transferred data size.
Translator : A pointr to the transaction translator data.
TransferResult : Variable to receive transfer result
@return EFI_UNSUPPORTED
**/
STATIC
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.
This : A pointer to the EFI_USB2_HC_PROTOCOL instance.
DeviceAddress : Target device address
EndPointAddress : Endpoint number and direction
DeviceSpeed : Device speed
MaximumPacketLength : Maximum packet size of the target endpoint
DataBuffersNumber : Number of data buffers prepared for the transfer.
Data : Array of pointers to the buffers of data
Translator : A pointr to the transaction translator data.
IsochronousCallBack : Function to call when the transfer complete
Context : Pass to the call back function as parameter
@return EFI_UNSUPPORTED
**/
STATIC
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;
}
EFI_STATUS
EFIAPI
UhciDriverEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Entry point for EFI drivers.
Arguments:
ImageHandle - EFI_HANDLE
SystemTable - EFI_SYSTEM_TABLE
Returns:
EFI_SUCCESS : Driver is successfully loaded
Others : Failed
--*/
{
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,
CLASSC_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.PI != PCI_CLASSC_PI_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
@return Allocated UHCI device
**/
STATIC
USB_HC_DEV *
UhciAllocateDev (
IN EFI_PCI_IO_PROTOCOL *PciIo,
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->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_CALLBACK,
UhciMonitorAsyncReqList,
Uhc,
&Uhc->AsyncIntMonitor
);
if (EFI_ERROR (Status)) {
UsbHcFreeMemPool (Uhc->MemPool);
goto ON_ERROR;
}
return Uhc;
ON_ERROR:
gBS->FreePool (Uhc);
return NULL;
}
/**
Free the UHCI device and release its associated resources
@param Uhc The UHCI device to release
@return None
**/
STATIC
VOID
UhciFreeDev (
IN USB_HC_DEV *Uhc
)
{
if (Uhc->AsyncIntMonitor != NULL) {
gBS->CloseEvent (Uhc->AsyncIntMonitor);
}
if (Uhc->MemPool != NULL) {
UsbHcFreeMemPool (Uhc->MemPool);
}
if (Uhc->CtrlNameTable) {
FreeUnicodeStringTable (Uhc->CtrlNameTable);
}
gBS->FreePool (Uhc);
}
/**
Uninstall all Uhci Interface
@param Controller Controller handle
@param This Protocol instance pointer.
@return VOID
**/
STATIC
VOID
UhciCleanDevUp (
IN EFI_HANDLE Controller,
IN EFI_USB2_HC_PROTOCOL *This
)
{
USB_HC_DEV *Uhc;
//
// Uninstall the USB_HC and USB_HC2 protocol, then disable the controller
//
Uhc = UHC_FROM_USB2_HC_PROTO (This);
UhciStopHc (Uhc, UHC_GENERIC_TIMEOUT);
gBS->UninstallProtocolInterface (
Controller,
&gEfiUsb2HcProtocolGuid,
&Uhc->Usb2Hc
);
UhciFreeAllAsyncReq (Uhc);
UhciDestoryFrameList (Uhc);
//
// Restore original PCI attributes
//
Uhc->PciIo->Attributes (
Uhc->PciIo,
EfiPciIoAttributeOperationSet,
Uhc->OriginalPciAttributes,
NULL
);
UhciFreeDev (Uhc);
}
/**
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;
//
// 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;
}
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.
//
// UhciTurnOffUsbEmulation (PciIo);
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSupported,
0,
&Supports
);
if (!EFI_ERROR (Status)) {
Supports &= EFI_PCI_DEVICE_ENABLE;
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationEnable,
Supports,
NULL
);
}
if (EFI_ERROR (Status)) {
goto CLOSE_PCIIO;
}
Uhc = UhciAllocateDev (PciIo, 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;
}
//
// 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;
FREE_UHC:
UhciFreeDev (Uhc);
CLOSE_PCIIO:
if (PciAttributesSaved == TRUE) {
//
// 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 stoping 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;
}
EFI_DRIVER_BINDING_PROTOCOL gUhciDriverBinding = {
UhciDriverBindingSupported,
UhciDriverBindingStart,
UhciDriverBindingStop,
0x20,
NULL,
NULL
};
Reference in New Issue View Git Blame Copy Permalink