Uhci.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
The UHCI driver model and HC protocol routines.
Copyright (c) 2004 - 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
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "Uhci.h"
0x20,
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.
**/
)
{
if ((Attributes == EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG) ||
return EFI_UNSUPPORTED;
}
switch (Attributes) {
case EFI_USB_HC_RESET_GLOBAL:
//
// Stop schedule and set the Global Reset bit in the command register
//
//
// Clear the Global Reset bit to zero.
//
break;
//
// Stop schedule and set Host Controller Reset bit to 1
//
break;
default:
goto ON_INVAILD_PARAMETER;
}
//
// Delete all old transactions on the USB bus, then
// reinitialize the frame list
//
return EFI_SUCCESS;
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.
**/
)
{
return EFI_INVALID_PARAMETER;
}
if ((UsbCmd & USBCMD_EGSM) !=0 ) {
} else if ((UsbSts & USBSTS_HCH) != 0) {
} else {
}
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.
**/
)
{
return EFI_DEVICE_ERROR;
}
return EFI_SUCCESS;
}
switch (State) {
case EfiUsbHcStateHalt:
break;
case EfiUsbHcStateOperational:
if (CurState == EfiUsbHcStateHalt) {
//
// point to 64 bytes
//
} else if (CurState == EfiUsbHcStateSuspend) {
//
// If FGR(Force Global Resume) bit is 0, set it
//
if ((UsbCmd & USBCMD_FGR) == 0) {
UsbCmd |= USBCMD_FGR;
}
//
// wait 20ms to let resume complete (20ms is specified by UHCI spec)
//
//
// Write FGR bit to 0 and EGSM(Enter Global Suspend Mode) bit to 0
//
UsbCmd &= ~USBCMD_FGR;
UsbCmd &= ~USBCMD_EGSM;
}
break;
case EfiUsbHcStateSuspend:
goto ON_EXIT;
}
//
// Set Enter Global Suspend Mode bit to 1.
//
UsbCmd |= USBCMD_EGSM;
break;
default:
break;
}
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.
**/
)
{
return EFI_INVALID_PARAMETER;
}
*PortNumber = 0;
//
// 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.
//
break;
}
(*PortNumber)++;
}
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.
**/
)
{
if (PortStatus == NULL) {
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
PortStatus->PortStatus = 0;
PortStatus->PortChangeStatus = 0;
if ((PortSC & USBPORTSC_CCS) != 0) {
}
if ((PortSC & USBPORTSC_PED) != 0) {
}
if ((PortSC & USBPORTSC_SUSP) != 0) {
}
if ((PortSC & USBPORTSC_PR) != 0) {
}
if ((PortSC & USBPORTSC_LSDA) != 0) {
}
//
// CHC will always return one in port owner bit
//
if ((PortSC & USBPORTSC_CSC) != 0) {
}
if ((PortSC & USBPORTSC_PEDC) != 0) {
}
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.
**/
)
{
return EFI_INVALID_PARAMETER;
}
switch (PortFeature) {
case EfiUsbPortSuspend:
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:
return EFI_INVALID_PARAMETER;
}
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.
**/
)
{
return EFI_INVALID_PARAMETER;
}
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;
//
// Root hub does not support this
//
break;
case EfiUsbPortResetChange:
//
// Root hub does not support this
//
break;
default:
return EFI_INVALID_PARAMETER;
}
return EFI_SUCCESS;
}
/**
Submits control transfer to a target USB device accroding 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 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.
**/
)
{
RequestPhy = NULL;
RequestMap = NULL;
//
// Parameters Checking
//
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
if (TransferDirection == EfiUsbNoData) {
TransferDataLength = 0;
} else {
}
//
// If errors exist that cause host controller halt,
// clear status then return EFI_DEVICE_ERROR.
//
return EFI_DEVICE_ERROR;
}
//
// Map the Request and data for bus master access,
// then create a list of TD for this transfer
//
goto ON_EXIT;
}
goto ON_EXIT;
}
TDs = UhciCreateCtrlTds (
Uhc,
);
goto UNMAP_DATA;
}
//
// According to the speed of the end point, link
// the TD to corrosponding queue head, then check
// the execution result
//
if (DataLength != NULL) {
}
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.
**/
)
{
if (DeviceSpeed == EFI_USB_SPEED_LOW) {
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
//
// If has errors that cause host controller halt,
// then return EFI_DEVICE_ERROR directly.
//
return EFI_DEVICE_ERROR;
}
//
// Map the source data buffer for bus master access,
// then create a list of TDs
//
if ((EndPointAddress & 0x80) != 0) {
} else {
}
goto ON_EXIT;
}
Uhc,
);
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.
//
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.
**/
)
{
UHCI_QH_SW *Qh;
if ((EndPointAddress & 0x80) == 0) {
return EFI_INVALID_PARAMETER;
}
//
// Delete Async interrupt transfer request
//
if (!IsNewTransfer) {
return Status;
}
return EFI_INVALID_PARAMETER;
}
if (DataLength == 0) {
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
//
// If has errors that cause host controller halt,
// then return EFI_DEVICE_ERROR directly.
//
return EFI_DEVICE_ERROR;
}
if ((EndPointAddress & 0x80) == 0) {
} else {
}
//
// Allocate and map source data buffer for bus master access.
//
return EFI_OUT_OF_RESOURCES;
}
goto FREE_DATA;
}
Uhc,
);
goto DESTORY_QH;
}
//
// Save QH-TD structures to async Interrupt transfer list,
// for monitor interrupt transfer execution routine use.
//
Uhc,
Qh,
);
goto DESTORY_QH;
}
return EFI_SUCCESS;
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.
**/
)
{
if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
if ((EndPointAddress & 0x80) == 0) {
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return EFI_INVALID_PARAMETER;
}
return Status;
}
//
// Map the source data buffer for bus master access.
// Create Tds list, then link it to the UHC's interrupt list
//
Uhc,
Data,
&PktId,
&DataPhy,
);
goto ON_EXIT;
}
Uhc,
);
goto ON_EXIT;
}
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
**/
)
{
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
**/
)
{
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.
**/
)
{
);
}
/**
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.
**/
)
{
//
// Test whether there is PCI IO Protocol attached on the controller handle.
//
);
if (EFI_ERROR (OpenStatus)) {
return OpenStatus;
}
sizeof (USB_CLASSC) / sizeof (UINT8),
);
goto ON_EXIT;
}
//
// Test whether the controller belongs to UHCI type
//
) {
}
gBS->CloseProtocol (
);
return Status;
}
/**
Allocate and initialize the empty UHCI device.
@param PciIo The PCIIO to use.
@param OriginalPciAttributes The original PCI attributes.
@return Allocated UHCI device. If err, return NULL.
**/
)
{
return NULL;
}
//
// This driver supports both USB_HC_PROTOCOL and USB2_HC_PROTOCOL.
// USB_HC_PROTOCOL is for EFI 1.1 backward compability.
//
goto ON_ERROR;
}
Uhc,
);
goto ON_ERROR;
}
return Uhc;
return NULL;
}
/**
Free the UHCI device and release its associated resources.
@param Uhc The UHCI device to release.
**/
)
{
}
}
}
}
}
/**
Uninstall all Uhci Interface.
@param Controller Controller handle.
@param This Protocol instance pointer.
**/
)
{
//
// Uninstall the USB_HC and USB_HC2 protocol, then disable the controller
//
);
//
// Restore original PCI attributes
//
);
UhciFreeDev (Uhc);
}
/**
One notified function to stop the Host Controller when gBS->ExitBootServices() called.
@param Event Pointer to this event
@param Context Event hanlder private data
**/
)
{
//
// Stop the Host Controller
//
//
// Reset the Host Controller
//
}
/**
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.
**/
)
{
//
// Open PCIIO, then enable the EHC device and turn off emulation
//
);
return Status;
}
//
// Save original PCI attributes
//
0,
);
goto CLOSE_PCIIO;
}
//
// Robustnesss improvement such as for UoL
// Default is not required.
//
if (FeaturePcdGet (PcdTurnOffUsbLegacySupport)) {
}
0,
);
);
}
goto CLOSE_PCIIO;
}
goto CLOSE_PCIIO;
}
//
// Allocate and Init Host Controller's Frame List Entry
//
goto FREE_UHC;
}
);
goto FREE_UHC;
}
//
// Install USB2_HC_PROTOCOL
//
);
goto FREE_UHC;
}
//
// Create event to stop the HC when exit boot service.
//
Uhc,
);
goto UNINSTALL_USBHC;
}
//
// Install the component name protocol
//
"eng",
&Uhc->CtrlNameTable,
L"Usb Universal Host Controller",
);
"en",
&Uhc->CtrlNameTable,
L"Usb Universal Host Controller",
);
//
// Start the UHCI hardware, also set its reclamation point to 64 bytes
//
return EFI_SUCCESS;
);
UhciFreeDev (Uhc);
if (PciAttributesSaved) {
//
// Restore original PCI attributes
//
PciIo->Attributes (
);
}
gBS->CloseProtocol (
);
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
**/
)
{
);
//
// Test whether the Controller handler passed in is a valid
// Usb controller handle that should be supported, if not,
// return the error status directly
//
return Status;
}
gBS->CloseProtocol (
);
return EFI_SUCCESS;
}