XhciSched.c revision 4fd606d1f5abe38e1f42c38de1d2e895166bd0f4
/** @file
XHCI transfer scheduling routines.
Copyright (c) 2011 - 2012, 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 "Xhci.h"
/**
Create a command transfer TRB to support XHCI command interfaces.
@param Xhc The XHCI Instance.
@param CmdTrb The cmd TRB to be executed.
@return Created URB or NULL.
**/
URB*
)
{
return NULL;
}
return Urb;
}
/**
Execute a XHCI cmd TRB pointed by CmdTrb.
@param Xhc The XHCI Instance.
@param CmdTrb The cmd TRB to be executed.
@param Timeout Indicates the maximum time, in millisecond, which the
transfer is allowed to complete.
@param EvtTrb The event TRB corresponding to the cmd TRB.
@retval EFI_SUCCESS The transfer was completed successfully.
@retval EFI_INVALID_PARAMETER Some parameters are invalid.
@retval EFI_TIMEOUT The transfer failed due to timeout.
@retval EFI_DEVICE_ERROR The transfer failed due to host controller error.
**/
)
{
//
// Validate the parameters
//
return EFI_INVALID_PARAMETER;
}
goto ON_EXIT;
}
//
// Create a new URB, then poll the execution status.
//
goto ON_EXIT;
}
}
return Status;
}
/**
Create a new URB for a new transaction.
@param Xhc The XHCI Instance
@param BusAddr The logical device address assigned by UsbBus driver
@param EpAddr Endpoint addrress
@param DevSpeed The device speed
@param MaxPacket The max packet length of the endpoint
@param Type The transaction type
@param Request The standard USB request for control transfer
@param Data The user data to transfer
@param DataLen The length of data buffer
@param Callback The function to call when data is transferred
@param Context The context to the callback
@return Created URB or NULL
**/
URB*
)
{
return NULL;
}
return Urb;
}
/**
Create a transfer TRB.
@param Xhc The XHCI Instance
@param Urb The urb used to construct the transfer TRB.
@return Created TRB or NULL
**/
)
{
if (SlotId == 0) {
return EFI_DEVICE_ERROR;
}
} else {
}
//
// Construct the TRB
//
switch (EPType) {
case ED_CONTROL_BIDIR:
//
// For control transfer, create SETUP_STAGE_TRB first.
//
} else {
}
//
// Update the cycle bit
//
//
// For control transfer, create DATA_STAGE_TRB.
//
} else {
}
//
// Update the cycle bit
//
}
//
// For control transfer, create STATUS_STAGE_TRB.
// Get the pointer to next TRB for status stage use
//
} else {
}
//
// Update the cycle bit
//
//
// Update the enqueue pointer
//
break;
case ED_BULK_OUT:
case ED_BULK_IN:
TotalLen = 0;
Len = 0;
TrbNum = 0;
} else {
Len = 0x10000;
}
//
// Update the cycle bit
//
TrbNum++;
}
break;
case ED_INTERRUPT_OUT:
case ED_INTERRUPT_IN:
TotalLen = 0;
Len = 0;
TrbNum = 0;
} else {
Len = 0x10000;
}
//
// Update the cycle bit
//
TrbNum++;
}
break;
default:
break;
}
return EFI_SUCCESS;
}
/**
Initialize the XHCI host controller for schedule.
@param Xhc The XHCI Instance to be initialized.
**/
)
{
//
// Program the Max Device Slots Enabled (MaxSlotsEn) field in the CONFIG register (5.4.7)
// to enable the device slots that system software is going to use.
//
//
// The Device Context Base Address Array entry associated with each allocated Device Slot
// shall contain a 64-bit pointer to the base of the associated Device Context.
// The Device Context Base Address Array shall contain MaxSlotsEn + 1 entries.
// Software shall set Device Context Base Address Array entries for unallocated Device Slots to '0'.
//
//
// A Scratchpad Buffer is a PAGESIZE block of system memory located on a PAGESIZE boundary.
// System software shall allocate the Scratchpad Buffer(s) before placing the xHC in to Run
//
MaxScratchpadBufs = ((Xhc->HcSParams2.Data.ScratchBufHi) << 5) | (Xhc->HcSParams2.Data.ScratchBufLo);
if (MaxScratchpadBufs != 0) {
ScratchBuf = AllocateAlignedPages (EFI_SIZE_TO_PAGES (MaxScratchpadBufs * sizeof (UINT64)), Xhc->PageSize);
}
//
// The Scratchpad Buffer Array contains pointers to the Scratchpad Buffers. Entry 0 of the
// Device Context Base Address Array points to the Scratchpad Buffer Array.
//
}
//
// Program the Device Context Base Address Array Pointer (DCBAAP) register (5.4.6) with
// a 64-bit address pointing to where the Device Context Base Address Array is located.
//
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
//
// Define the Command Ring Dequeue Pointer by programming the Command Ring Control Register
// (5.4.5) with a 64-bit address pointing to the starting address of the first TRB of the Command Ring.
// Note: The Command Ring is 64 byte aligned, so the low order 6 bits of the Command Ring Pointer shall
// always be '0'.
//
//
// The xHC uses the Enqueue Pointer to determine when a Transfer Ring is empty. As it fetches TRBs from a
// Transfer Ring it checks for a Cycle bit transition. If a transition detected, the ring is empty.
// So we set RCS as inverted PCS init value to let Command Ring empty
//
CmdRing |= XHC_CRCR_RCS;
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
//
// Disable the 'interrupter enable' bit in USB_CMD
// and clear IE & IP bit in all Interrupter X Management Registers.
//
}
//
// Allocate EventRing for Cmd, Ctrl, Bulk, Interrupt, AsynInterrupt transfer
//
}
/**
System software shall use a Reset Endpoint Command (section 4.11.4.7) to remove the Halted
condition in the xHC. After the successful completion of the Reset Endpoint Command, the Endpoint
Context is transitioned from the Halted to the Stopped state and the Transfer Ring of the endpoint is
reenabled. The next write to the Doorbell of the Endpoint will transition the Endpoint Context from the
Stopped to the Running state.
@param Xhc The XHCI Instance.
@param Urb The urb which makes the endpoint halted.
@retval EFI_SUCCESS The recovery is successful.
@retval Others Failed to recovery halted endpoint.
**/
)
{
if (SlotId == 0) {
return EFI_DEVICE_ERROR;
}
//
// 1) Send Reset endpoint command to transit from halt to stop state
//
Status = XhcCmdTransfer (
Xhc,
);
//
// 2)Set dequeue pointer
//
Status = XhcCmdTransfer (
Xhc,
);
//
// 3)Ring the doorbell to transit from stop to active
//
return Status;
}
/**
Create XHCI event ring.
@param Xhc The XHCI Instance.
@param EventRing The created event ring.
**/
)
{
//
// Software maintains an Event Ring Consumer Cycle State (CCS) bit, initializing it to '1'
// and toggling it every time the Event Ring Dequeue Pointer wraps back to the beginning of the Event Ring.
//
//
// Program the Interrupter Event Ring Segment Table Size (ERSTSZ) register (5.5.2.3.1)
//
Xhc,
);
//
// Program the Interrupter Event Ring Dequeue Pointer (ERDP) register (5.5.2.3.3)
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
Xhc,
);
Xhc,
XHC_ERDP_OFFSET + 4,
);
//
// Program the Interrupter Event Ring Segment Table Base Address (ERSTBA) register(5.5.2.3.2)
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
Xhc,
);
Xhc,
XHC_ERSTBA_OFFSET + 4,
);
//
// Need set IMAN IE bit to enble the ring interrupt
//
}
/**
Create XHCI transfer ring.
@param Xhc The XHCI Instance.
@param TrbNum The number of TRB in the ring.
@param TransferRing The created transfer ring.
**/
)
{
//
// 4.9.2 Transfer Ring Management
// To form a ring (or circular queue) a Link TRB may be inserted at the end of a ring to
// point to the first TRB in the ring.
//
//
// Toggle Cycle (TC). When set to '1', the xHC shall toggle its interpretation of the Cycle bit.
//
//
// Set Cycle bit as other TRB PCS init value
//
}
/**
Free XHCI event ring.
@param Xhc The XHCI Instance.
@param EventRing The event ring to be freed.
**/
)
{
return EFI_SUCCESS;
}
//
// Get the Event Ring Segment Table base address
//
//
// Get all the TRBs Ring and release
//
}
}
return EFI_SUCCESS;
}
/**
Free the resouce allocated at initializing schedule.
@param Xhc The XHCI Instance.
**/
)
{
}
}
}
}
}
/**
Check if the Trb is a transaction of the URBs in XHCI's asynchronous transfer list.
@param Xhc The XHCI Instance.
@param Trb The TRB to be checked.
@param Urb The pointer to the matched Urb.
@retval TRUE The Trb is matched with a transaction of the URBs in the async list.
@retval FALSE The Trb is not matched with any URBs in the async list.
**/
)
{
if (Trb == CheckedTrb) {
*Urb = CheckedUrb;
return TRUE;
}
CheckedTrb++;
if ((UINTN)CheckedTrb >= ((UINTN) CheckedUrb->Ring->RingSeg0 + sizeof (TRB_TEMPLATE) * CheckedUrb->Ring->TrbNumber)) {
}
}
}
return FALSE;
}
/**
Check if the Trb is a transaction of the URB.
@param Trb The TRB to be checked
@param Urb The transfer ring to be checked.
@retval TRUE It is a transaction of the URB.
@retval FALSE It is not any transaction of the URB.
**/
)
{
if (Trb == CheckedTrb) {
return TRUE;
}
CheckedTrb++;
}
return FALSE;
}
/**
Check the URB's execution result and update the URB's
result accordingly.
@param Xhc The XHCI Instance.
@param Urb The URB to check result.
@return Whether the result of URB transfer is finialized.
**/
)
{
goto EXIT;
}
goto EXIT;
}
//
// Traverse the event ring to find out all new events from the previous check.
//
if (Status == EFI_NOT_READY) {
//
// All new events are handled, return directly.
//
goto EXIT;
}
//
// Only handle COMMAND_COMPLETETION_EVENT and TRANSFER_EVENT.
//
continue;
}
//
// Update the status of Urb according to the finished event regardless of whether
// the urb is current checked one or in the XHCI's async transfer list.
// This way is used to avoid that those completed async transfer events don't get
// handled in time and are flushed by newer coming events.
//
CheckedUrb = Urb;
} else {
continue;
}
switch (EvtTrb->Completecode) {
break;
break;
break;
DEBUG ((EFI_D_ERROR, "XhcCheckUrbResult: TRANSACTION_ERROR! Completecode = %x\n",EvtTrb->Completecode));
break;
case TRB_COMPLETION_SUCCESS:
}
if ((TRBType == TRB_TYPE_DATA_STAGE) ||
(TRBType == TRB_TYPE_NORMAL) ||
(TRBType == TRB_TYPE_ISOCH)) {
}
break;
default:
break;
}
//
// Only check first and end Trb event address
//
}
}
}
}
EXIT:
//
// Advance event ring to last available entry
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
//
// Some 3rd party XHCI external cards don't support single 64-bytes width register access,
// So divide it to two 32-bytes width register access.
//
}
return Status;
}
/**
Execute the transfer by polling the URB. This is a synchronous operation.
@param Xhc The XHCI Instance.
@param CmdTransfer The executed URB is for cmd transfer or not.
@param Urb The URB to execute.
@param Timeout The time to wait before abort, in millisecond.
@return EFI_DEVICE_ERROR The transfer failed due to transfer error.
@return EFI_TIMEOUT The transfer failed due to time out.
@return EFI_SUCCESS The transfer finished OK.
**/
)
{
if (CmdTransfer) {
SlotId = 0;
Dci = 0;
} else {
if (SlotId == 0) {
return EFI_DEVICE_ERROR;
}
}
if (Timeout == 0) {
Loop = 0xFFFFFFFF;
}
break;
}
}
}
return Status;
}
/**
Delete a single asynchronous interrupt transfer for
the device and endpoint.
@param Xhc The XHCI Instance.
@param BusAddr The logical device address assigned by UsbBus driver.
@param EpNum The endpoint of the target.
@retval EFI_SUCCESS An asynchronous transfer is removed.
@retval EFI_NOT_FOUND No transfer for the device is found.
**/
)
{
EpNum &= 0x0F;
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}
/**
Remove all the asynchronous interrutp transfers.
@param Xhc The XHCI Instance.
**/
)
{
}
}
/**
Update the queue head for next round of asynchronous transfer
@param Xhc The XHCI Instance.
@param Urb The URB to update
**/
)
{
return;
}
return;
}
}
}
/**
Interrupt transfer periodic check handler.
@param Event Interrupt event.
@param Context Pointer to USB_XHCI_INSTANCE.
**/
)
{
//
// Make sure that the device is available before every check.
//
if (SlotId == 0) {
continue;
}
//
// Check the result of URB execution. If it is still
// active, check the next one.
//
continue;
}
//
// Allocate a buffer then copy the transferred data for user.
// If failed to allocate the buffer, update the URB for next
// round of transfer. Ignore the data of this round.
//
continue;
}
}
//
// Leave error recovery to its related device driver. A
// common case of the error recovery is to re-submit the
// interrupt transfer which is linked to the head of the
// list. This function scans from head to tail. So the
// re-submitted interrupt transfer's callback function
// will not be called again in this round. Don't touch this
// URB after the callback, it may have been removed by the
// callback.
//
//
// Restore the old TPL, USB bus maybe connect device in
// his callback. Some drivers may has a lower TPL restriction.
//
}
}
}
}
/**
@param Xhc The XHCI Instance.
@param ParentRouteChart The route string pointed to the parent device if it exists.
@param Port The port to be polled.
@param PortState The port state.
@retval Others Should not appear.
**/
)
{
if (ParentRouteChart.Dword == 0) {
} else {
if(Port < 14) {
RouteChart.Route.RouteString = ParentRouteChart.Route.RouteString | (Port << (4 * (ParentRouteChart.Route.TierNum - 1)));
} else {
RouteChart.Route.RouteString = ParentRouteChart.Route.RouteString | (15 << (4 * (ParentRouteChart.Route.TierNum - 1)));
}
}
//
// Has a device attached, Identify device speed after port is enabled.
//
}
//
// Execute Enable_Slot cmd for attached device, initialize device context and assign device address.
//
if (SlotId == 0) {
} else {
}
}
//
// Device is detached. Disable the allocated device slot and release resource.
//
if (SlotId != 0) {
} else {
}
}
}
return Status;
}
/**
Calculate the device context index by endpoint address and direction.
@param EpAddr The target endpoint number.
@param Direction The direction of the target endpoint.
@return The device context index of endpoint.
**/
)
{
if (EpAddr == 0) {
return 1;
} else {
if (Direction == EfiUsbDataIn) {
Index += 1;
}
return Index;
}
}
/**
Find out the actual device address according to the requested device address from UsbBus.
@param Xhc The XHCI Instance.
@param BusDevAddr The requested device address by UsbBus upper driver.
@return The actual device address assigned to the device.
**/
)
{
break;
}
}
if (Index == 255) {
return 0;
}
}
/**
Find out the slot id according to the device's route string.
@param Xhc The XHCI Instance.
@param RouteString The route string described the device location.
@return The slot id used by the device.
**/
)
{
break;
}
}
if (Index == 255) {
return 0;
}
}
/**
Synchronize the specified event ring to update the enqueue and dequeue pointer.
@param Xhc The XHCI Instance.
@param EvtRing The event ring to sync.
@retval EFI_SUCCESS The event ring is synchronized successfully.
**/
)
{
//
// Calculate the EventRingEnqueue and EventRingCCS.
// Note: only support single Segment
//
break;
}
EvtTrb1++;
if ((UINTN)EvtTrb1 >= ((UINTN) EvtRing->EventRingSeg0 + sizeof (TRB_TEMPLATE) * EvtRing->TrbNumber)) {
}
}
} else {
}
return EFI_SUCCESS;
}
/**
Synchronize the specified transfer ring to update the enqueue and dequeue pointer.
@param Xhc The XHCI Instance.
@param TrsRing The transfer ring to sync.
@retval EFI_SUCCESS The transfer ring is synchronized successfully.
**/
)
{
//
// Calculate the latest RingEnqueue and RingPCS
//
break;
}
TrsTrb++;
//
// set cycle bit in Link TRB as normal
//
//
// Toggle PCS maintained by software
//
TrsTrb = (TRB_TEMPLATE *)(UINTN)((TrsTrb->Parameter1 | LShiftU64 ((UINT64)TrsTrb->Parameter2, 32)) & ~0x0F);
}
}
}
//
// Clear the Trb context for enqueue, but reserve the PCS bit
//
TrsTrb->Parameter1 = 0;
TrsTrb->Parameter2 = 0;
return EFI_SUCCESS;
}
/**
Check if there is a new generated event.
@param Xhc The XHCI Instance.
@param EvtRing The event ring to check.
@param NewEvtTrb The new event TRB found.
@retval EFI_SUCCESS Found a new event TRB at the event ring.
@retval EFI_NOT_READY The event ring has no new event.
**/
)
{
return EFI_NOT_READY;
}
//
// If the dequeue pointer is beyond the ring, then roll-back it to the begining of the ring.
//
if ((UINTN)EvtRing->EventRingDequeue >= ((UINTN) EvtRing->EventRingSeg0 + sizeof (TRB_TEMPLATE) * EvtRing->TrbNumber)) {
}
return Status;
}
/**
Ring the door bell to notify XHCI there is a transaction to be executed.
@param Xhc The XHCI Instance.
@param SlotId The slot id of the target device.
@param Dci The device context index of the target slot or endpoint.
@retval EFI_SUCCESS Successfully ring the door bell.
**/
)
{
if (SlotId == 0) {
XhcWriteDoorBellReg (Xhc, 0, 0);
} else {
}
return EFI_SUCCESS;
}
/**
Ring the door bell to notify XHCI there is a transaction to be executed through URB.
@param Xhc The XHCI Instance.
@param Urb The URB to be rung.
@retval EFI_SUCCESS Successfully ring the door bell.
**/
)
{
return EFI_SUCCESS;
}
/**
Assign and initialize the device slot for a new device.
@param Xhc The XHCI Instance.
@param ParentRouteChart The route string pointed to the parent device.
@param ParentPort The port at which the device is located.
@param RouteChart The route string pointed to the device.
@param DeviceSpeed The device speed.
@retval EFI_SUCCESS Successfully assign a slot to the device and assign an address to it.
**/
)
{
Status = XhcCmdTransfer (
Xhc,
);
//
// 4.3.3 Device Slot Initialization
// 1) Allocate an Input Context data structure (6.2.5) and initialize all fields to '0'.
//
//
// 2) Initialize the Input Control Context (6.2.5.1) of the Input Context by setting the A0 and A1
// flags to '1'. These flags indicate that the Slot Context and the Endpoint 0 Context of the Input
// Context are affected by the command.
//
//
// 3) Initialize the Input Slot Context data structure
//
//
// The device is behind of hub device.
//
ASSERT (ParentSlotId != 0);
//
//if the Full/Low device attached to a High Speed Hub, Init the TTPortNum and TTHubSlotId field of slot context
//
if ((ParentDeviceContext->Slot.Speed == (EFI_USB_SPEED_HIGH + 1)) && (DeviceSpeed < EFI_USB_SPEED_HIGH)) {
//
//
}
} else {
//
// Inherit the TT parameters from parent device.
//
//
// If the device is a High speed device then down the speed to be the same as its parent Hub
//
if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
}
}
}
//
// 4) Allocate and initialize the Transfer Ring for the Default Control Endpoint.
//
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0]);
//
// 5) Initialize the Input default control Endpoint 0 Context (6.2.3).
//
if (DeviceSpeed == EFI_USB_SPEED_SUPER) {
} else if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
} else {
}
//
// Initial value of Average TRB Length for Control endpoints would be 8B, Interrupt endpoints
// 1KB, and Bulk and Isoch endpoints 3KB.
//
//
// Init the DCS(dequeue cycle state) as the transfer ring's CCS
//
InputContext->EP[0].PtrLo = XHC_LOW_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0])->RingSeg0) | BIT0;
InputContext->EP[0].PtrHi = XHC_HIGH_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0])->RingSeg0);
//
// 6) Allocate the Output Device Context data structure (6.2.1) and initialize it to '0'.
//
//
// 7) Load the appropriate (Device Slot ID) entry in the Device Context Base Address Array (5.4.6) with
// a pointer to the Output Device Context data structure (6.2.1).
//
//
// 8) Issue an Address Device Command for the Device Slot, where the command points to the Input
// Context data structure described above.
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Assign and initialize the device slot for a new device.
@param Xhc The XHCI Instance.
@param ParentRouteChart The route string pointed to the parent device.
@param ParentPort The port at which the device is located.
@param RouteChart The route string pointed to the device.
@param DeviceSpeed The device speed.
@retval EFI_SUCCESS Successfully assign a slot to the device and assign an address to it.
**/
)
{
Status = XhcCmdTransfer (
Xhc,
);
//
// 4.3.3 Device Slot Initialization
// 1) Allocate an Input Context data structure (6.2.5) and initialize all fields to '0'.
//
//
// 2) Initialize the Input Control Context (6.2.5.1) of the Input Context by setting the A0 and A1
// flags to '1'. These flags indicate that the Slot Context and the Endpoint 0 Context of the Input
// Context are affected by the command.
//
//
// 3) Initialize the Input Slot Context data structure
//
//
// The device is behind of hub device.
//
ASSERT (ParentSlotId != 0);
//
//if the Full/Low device attached to a High Speed Hub, Init the TTPortNum and TTHubSlotId field of slot context
//
if ((ParentDeviceContext->Slot.Speed == (EFI_USB_SPEED_HIGH + 1)) && (DeviceSpeed < EFI_USB_SPEED_HIGH)) {
//
//
}
} else {
//
// Inherit the TT parameters from parent device.
//
//
// If the device is a High speed device then down the speed to be the same as its parent Hub
//
if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
}
}
}
//
// 4) Allocate and initialize the Transfer Ring for the Default Control Endpoint.
//
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0]);
//
// 5) Initialize the Input default control Endpoint 0 Context (6.2.3).
//
if (DeviceSpeed == EFI_USB_SPEED_SUPER) {
} else if (DeviceSpeed == EFI_USB_SPEED_HIGH) {
} else {
}
//
// Initial value of Average TRB Length for Control endpoints would be 8B, Interrupt endpoints
// 1KB, and Bulk and Isoch endpoints 3KB.
//
//
// Init the DCS(dequeue cycle state) as the transfer ring's CCS
//
InputContext->EP[0].PtrLo = XHC_LOW_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0])->RingSeg0) | BIT0;
InputContext->EP[0].PtrHi = XHC_HIGH_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[0])->RingSeg0);
//
// 6) Allocate the Output Device Context data structure (6.2.1) and initialize it to '0'.
//
//
// 7) Load the appropriate (Device Slot ID) entry in the Device Context Base Address Array (5.4.6) with
// a pointer to the Output Device Context data structure (6.2.1).
//
//
// 8) Issue an Address Device Command for the Device Slot, where the command points to the Input
// Context data structure described above.
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Disable the specified device slot.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be disabled.
@retval EFI_SUCCESS Successfully disable the device slot.
**/
)
{
//
// Disable the device slots occupied by these devices on its downstream ports.
// Entry 0 is reserved.
//
(Xhc->UsbDevContext[Index + 1].ParentRouteString.Dword != Xhc->UsbDevContext[SlotId].RouteString.Dword)) {
continue;
}
}
}
//
// Construct the disable slot command
//
Status = XhcCmdTransfer (
Xhc,
);
//
// Free the slot's device context entry
//
//
// Free the slot related data structure
//
RingSeg = ((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Index])->RingSeg0;
}
}
}
}
}
}
}
//
// Doesn't zero the entry because XhcAsyncInterruptTransfer() may be invoked to remove the established
// asynchronous interrupt pipe after the device is disabled. It needs the device address mapping info to
// remove urb from XHCI's asynchronous transfer list.
//
return Status;
}
/**
Disable the specified device slot.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be disabled.
@retval EFI_SUCCESS Successfully disable the device slot.
**/
)
{
//
// Disable the device slots occupied by these devices on its downstream ports.
// Entry 0 is reserved.
//
(Xhc->UsbDevContext[Index + 1].ParentRouteString.Dword != Xhc->UsbDevContext[SlotId].RouteString.Dword)) {
continue;
}
}
}
//
// Construct the disable slot command
//
Status = XhcCmdTransfer (
Xhc,
);
//
// Free the slot's device context entry
//
//
// Free the slot related data structure
//
RingSeg = ((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Index])->RingSeg0;
}
}
}
}
}
}
FreePages (Xhc->UsbDevContext[SlotId].OutputContext, EFI_SIZE_TO_PAGES (sizeof (DEVICE_CONTEXT_64)));
}
//
// Doesn't zero the entry because XhcAsyncInterruptTransfer() may be invoked to remove the established
// asynchronous interrupt pipe after the device is disabled. It needs the device address mapping info to
// remove urb from XHCI's asynchronous transfer list.
//
return Status;
}
/**
Configure all the device endpoints through XHCI's Configure_Endpoint cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be configured.
@param DeviceSpeed The device's speed.
@param ConfigDesc The pointer to the usb device configuration descriptor.
@retval EFI_SUCCESS Successfully configure all the device endpoints.
**/
)
{
//
// 4.6.6 Configure Endpoint
//
MaxDci = 0;
}
}
}
if (DeviceSpeed == EFI_USB_SPEED_SUPER) {
//
// 6.2.3.4, shall be set to the value defined in the bMaxBurst field of the SuperSpeed Endpoint Companion Descriptor.
//
} else {
}
case USB_ENDPOINT_BULK:
if (Direction == EfiUsbDataIn) {
} else {
}
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1]);
}
break;
case USB_ENDPOINT_ISO:
if (Direction == EfiUsbDataIn) {
} else {
}
break;
case USB_ENDPOINT_INTERRUPT:
if (Direction == EfiUsbDataIn) {
} else {
}
//
// Get the bInterval from descriptor and init the the interval field of endpoint context
//
//
// Hard code the interval to MAX first, need calculate through the bInterval field of Endpoint descriptor.
//
//
// Refer to XHCI 1.0 spec section 6.2.3.6, table 61
//
}
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1]);
}
break;
case USB_ENDPOINT_CONTROL:
default:
ASSERT (0);
break;
}
PhyAddr = XHC_LOW_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingSeg0);
PhyAddr &= ~(0x0F);
PhyAddr |= ((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingPCS;
InputContext->EP[Dci-1].PtrHi = XHC_HIGH_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingSeg0);
}
}
//
// configure endpoint
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Configure all the device endpoints through XHCI's Configure_Endpoint cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be configured.
@param DeviceSpeed The device's speed.
@param ConfigDesc The pointer to the usb device configuration descriptor.
@retval EFI_SUCCESS Successfully configure all the device endpoints.
**/
)
{
//
// 4.6.6 Configure Endpoint
//
MaxDci = 0;
}
}
}
if (DeviceSpeed == EFI_USB_SPEED_SUPER) {
//
// 6.2.3.4, shall be set to the value defined in the bMaxBurst field of the SuperSpeed Endpoint Companion Descriptor.
//
} else {
}
case USB_ENDPOINT_BULK:
if (Direction == EfiUsbDataIn) {
} else {
}
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1]);
}
break;
case USB_ENDPOINT_ISO:
if (Direction == EfiUsbDataIn) {
} else {
}
break;
case USB_ENDPOINT_INTERRUPT:
if (Direction == EfiUsbDataIn) {
} else {
}
//
// Get the bInterval from descriptor and init the the interval field of endpoint context
//
//
// Hard code the interval to MAX first, need calculate through the bInterval field of Endpoint descriptor.
//
//
// Refer to XHCI 1.0 spec section 6.2.3.6, table 61
//
}
CreateTransferRing(Xhc, TR_RING_TRB_NUMBER, (TRANSFER_RING *)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1]);
}
break;
case USB_ENDPOINT_CONTROL:
default:
ASSERT (0);
break;
}
PhyAddr = XHC_LOW_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingSeg0);
PhyAddr &= ~(0x0F);
PhyAddr |= ((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingPCS;
InputContext->EP[Dci-1].PtrHi = XHC_HIGH_32BIT (((TRANSFER_RING *)(UINTN)Xhc->UsbDevContext[SlotId].EndpointTransferRing[Dci-1])->RingSeg0);
}
}
//
// configure endpoint
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Evaluate the endpoint 0 context through XHCI's Evaluate_Context cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be evaluated.
@param MaxPacketSize The max packet size supported by the device control transfer.
@retval EFI_SUCCESS Successfully evaluate the device endpoint 0.
**/
)
{
//
// 4.6.7 Evaluate Context
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Evaluate the endpoint 0 context through XHCI's Evaluate_Context cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be evaluated.
@param MaxPacketSize The max packet size supported by the device control transfer.
@retval EFI_SUCCESS Successfully evaluate the device endpoint 0.
**/
)
{
//
// 4.6.7 Evaluate Context
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Evaluate the slot context for hub device through XHCI's Configure_Endpoint cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be configured.
@param PortNum The total number of downstream port supported by the hub.
@param TTT The TT think time of the hub device.
@param MTT The multi-TT of the hub device.
@retval EFI_SUCCESS Successfully configure the hub device's slot context.
**/
)
{
//
// 4.6.7 Evaluate Context
//
//
// Copy the slot context from OutputContext to Input context
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}
/**
Evaluate the slot context for hub device through XHCI's Configure_Endpoint cmd.
@param Xhc The XHCI Instance.
@param SlotId The slot id to be configured.
@param PortNum The total number of downstream port supported by the hub.
@param TTT The TT think time of the hub device.
@param MTT The multi-TT of the hub device.
@retval EFI_SUCCESS Successfully configure the hub device's slot context.
**/
)
{
//
// 4.6.7 Evaluate Context
//
//
// Copy the slot context from OutputContext to Input context
//
Status = XhcCmdTransfer (
Xhc,
);
return Status;
}