xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Intel/AlderLake/AlderLakeChipsetPkg/XhciSmiDispatcher/XhciSmiDispatcher.c

477 lines
15 KiB
C
Raw Permalink Blame History

/** @file
;******************************************************************************
;* Copyright (c) 2014, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "XhciSmiDispatcher.h"
//
// The device path used for SMI registration.
// This example sets the XHCI device plugged behind bridge BRIDGE_DEV_FOR_XHCI/BRIDGE_FUN_FOR_XHCI
// Please based on platform setting to change the device path for XHCI device
//
struct {
ACPI_HID_DEVICE_PATH Acpi;
PCI_DEVICE_PATH RootBridge;
PCI_DEVICE_PATH Pci;
EFI_DEVICE_PATH_PROTOCOL End;
} mXhciDevicePath = {
{ ACPI_DEVICE_PATH, ACPI_DP, (UINT8)(sizeof(ACPI_HID_DEVICE_PATH)), (UINT8)((sizeof(ACPI_HID_DEVICE_PATH)) >> 8), EISA_PNP_ID(0x0A03), 0 },
{ HARDWARE_DEVICE_PATH, HW_PCI_DP, (UINT8)(sizeof(PCI_DEVICE_PATH)), (UINT8)((sizeof(PCI_DEVICE_PATH)) >> 8), 0, 0 },
{ HARDWARE_DEVICE_PATH, HW_PCI_DP, (UINT8)(sizeof(PCI_DEVICE_PATH)), (UINT8)((sizeof(PCI_DEVICE_PATH)) >> 8), XHCI_FUN, XHCI_DEV },
{ END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, END_DEVICE_PATH_LENGTH, 0 }
};
//#545659 SKL-U/SKL-Y PCH EDS
//Below are the PCH GPIOs that can be routed to generate SMI# or NMI:
//!E GPP_B14, GPP_B20, GPP_B23
//!E GPP_C[23:22]
//!E GPP_D[4:0]
//!E GPP_E[8:0], GPP_E[16:13]
UINT32 mPchGpioSmiPad[] = {
GPIO_SKL_LP_GPP_B14,
GPIO_SKL_LP_GPP_B20,
GPIO_SKL_LP_GPP_B23,
GPIO_SKL_LP_GPP_C22,
GPIO_SKL_LP_GPP_C23,
GPIO_SKL_LP_GPP_D0,
GPIO_SKL_LP_GPP_D1,
GPIO_SKL_LP_GPP_D2,
GPIO_SKL_LP_GPP_D3,
GPIO_SKL_LP_GPP_D4,
GPIO_SKL_LP_GPP_E0,
GPIO_SKL_LP_GPP_E1,
GPIO_SKL_LP_GPP_E2,
GPIO_SKL_LP_GPP_E3,
GPIO_SKL_LP_GPP_E4,
GPIO_SKL_LP_GPP_E5,
GPIO_SKL_LP_GPP_E6,
GPIO_SKL_LP_GPP_E7,
GPIO_SKL_LP_GPP_E8,
GPIO_SKL_LP_GPP_E13,
GPIO_SKL_LP_GPP_E14,
GPIO_SKL_LP_GPP_E15,
GPIO_SKL_LP_GPP_E16
};
EFI_SMM_USB_DISPATCH2_PROTOCOL mStockUsbDispatch;
DATABASE_RECORD *mRecord;
UINT32 mXhciCmd;
UINT32 mXhciPwr;
UINT32 mXhciXecp;
UINT32 mXhciPcdSetting;
/**
Entry point for EFI drivers.
@param ImageHandle EFI_HANDLE
@param SystemTable EFI_SYSTEM_TABLE
@retval EFI_SUCCESS Success
@retval EFI_DEVICE_ERROR Fail
**/
EFI_STATUS
EFIAPI
XhciSmiDispatcherDriverEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_SMM_USB_DISPATCH2_PROTOCOL *UsbDispatch;
//
// Checking the PCD to
//
mXhciPcdSetting = PcdGet32 (PcdXhciAddonCardSetting);
if (mXhciPcdSetting == 0) {
//
// Quit if no PCD specify
//
return EFI_UNSUPPORTED;
}
//
// Get the stock SmmUsbDispatcher protocol
//
Status = gSmst->SmmLocateProtocol (
&gEfiSmmUsbDispatch2ProtocolGuid,
NULL,
(VOID **)&UsbDispatch
);
if (EFI_ERROR(Status)) {
return EFI_UNSUPPORTED;
}
//
// Patch the SmmUsbDispatcher protocol
//
CopyMem (&mStockUsbDispatch, UsbDispatch, sizeof (EFI_SMM_USB_DISPATCH2_PROTOCOL));
UsbDispatch->Register = XhciSmiRegister;
UsbDispatch->UnRegister = XhciSmiUnregister;
//
// Setup internal variables
//
mRecord = NULL;
mXhciDevicePath.RootBridge.Function = (UINT8)BRIDGE_FUN_FOR_XHCI;
mXhciDevicePath.RootBridge.Device = (UINT8)BRIDGE_DEV_FOR_XHCI;
return EFI_SUCCESS;
}
/**
Provides the parent dispatch service for the USB SMI source generator.
This service registers a function (DispatchFunction) which will be called when the USB-
related SMI specified by RegisterContext has occurred. On return, DispatchHandle
contains a unique handle which may be used later to unregister the function using UnRegister().
The DispatchFunction will be called with Context set to the same value as was passed into
this function in RegisterContext and with CommBuffer containing NULL and
CommBufferSize containing zero.
@param[in] This Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
@param[in] DispatchFunction Function to register for handler when a USB-related SMI occurs.
@param[in] RegisterContext Pointer to the dispatch function's context.
The caller fills this context in before calling
the register function to indicate to the register
function the USB SMI types for which the dispatch
function should be invoked.
@param[out] DispatchHandle Handle generated by the dispatcher to track the function instance.
@retval EFI_SUCCESS The dispatch function has been successfully
registered and the SMI source has been enabled.
@retval EFI_DEVICE_ERROR The driver was unable to enable the SMI source.
@retval EFI_INVALID_PARAMETER RegisterContext is invalid. The USB SMI type
is not within valid range.
@retval EFI_OUT_OF_RESOURCES There is not enough memory (system or SMM) to manage this child.
**/
EFI_STATUS
XhciSmiRegister (
IN CONST EFI_SMM_USB_DISPATCH2_PROTOCOL *This,
IN EFI_SMM_HANDLER_ENTRY_POINT2 DispatchFunction,
IN CONST EFI_SMM_USB_REGISTER_CONTEXT *RegisterContext,
OUT EFI_HANDLE *DispatchHandle
)
{
EFI_STATUS Status;
DATABASE_RECORD *Record;
EFI_HANDLE Handle;
UINT32 Index;
UINT32 Data;
UINT32 Bus;
UINT32 Bar;
//
// Check the owner
//
if (RegisterContext->Type == UsbLegacy && CompareMem(RegisterContext->Device, &mXhciDevicePath, sizeof(mXhciDevicePath)) == 0) {
//
// Create a XHCI SMI registration
//
Status = gSmst->SmmAllocatePool (
EfiRuntimeServicesData,
sizeof (DATABASE_RECORD),
(VOID **)&Record
);
if (EFI_ERROR (Status)) {
return EFI_OUT_OF_RESOURCES;
}
Record->Signature = DATABASE_RECORD_SIGNATURE;
Record->Next = mRecord;
Record->DispatchFunction = DispatchFunction;
Record->RegisterContext = *RegisterContext;
if (!mRecord) {
//
// Setup the related registers and SMI root callback on first time setting
//
gSmst->SmiHandlerRegister (
XhciSmmCoreDispatcher,
NULL,
&Handle
);
//
// Setup GPIO INV for invert signal GPIO registers for XHCI SMIB pin
//
Status = GpioSetInputInversion (GPIO_PIN_FOR_XHCI_SMIB, INVERSE_GPIO_SIGNAL);
ASSERT_EFI_ERROR (Status);
//
// Make sure the GPIO_ROUT for XHCI SMIB pin is inactive before set the ALT_GP_SMI
//
Status = GpioClearGpiSmiSts(GPIO_PIN_FOR_XHCI_SMIB);
ASSERT_EFI_ERROR (Status);
//
// Setup ALT_GP_SMI for XHCI SMIB pin
//
Status = GpioEnableGpiSmi (GPIO_PIN_FOR_XHCI_SMIB ,TRUE);
ASSERT_EFI_ERROR (Status);
//
// Setting the record;
//
mRecord = Record;
if (SKIP_HAND_OFF_TO_BIOS_EVENT) {
Bus = (PciRead32 (PCI_LIB_ADDRESS (0, BRIDGE_DEV_FOR_XHCI, BRIDGE_FUN_FOR_XHCI, 0x18)) >> 8) & 0xff;
Bar = PciRead32 (PCI_LIB_ADDRESS (Bus, XHCI_DEV, XHCI_FUN, 0x10)) & ~0x0f;
mXhciCmd = PCI_LIB_ADDRESS (Bus, XHCI_DEV, XHCI_FUN, 0x04);
//
// Searching for USB Legacy Support Capability
//
mXhciXecp = 0;
Index = ((*(UINT32*)(UINTN)(Bar + 0x10) & 0xffff0000) >> 14);
while (((Data = *(UINT32*)(UINTN)(Bar + Index)) & 0xff) != 0x01 && (Data & 0xff00) != 0) {
Index += ((Data & 0xff00) >> (8 - 2));
}
if ((Data & 0xff) == 0x01) {
mXhciXecp = Bar + Index;
}
//
// Get the offset of Power Control Status Register
//
for (Index = 0x34, Data = 0; Index < 0x100;) {
Data = PciRead16 (PCI_LIB_ADDRESS (Bus, XHCI_DEV, XHCI_FUN, Index));
if (Index != 0x34) {
if ((Data & 0xff) == 0x01) {
mXhciPwr = PCI_LIB_ADDRESS (Bus, XHCI_DEV, XHCI_FUN, Index + 4);
break;
} else {
//
// The position of next ptr will be next of ID
//
Index = (Data & 0xff00) >> 8;
}
} else {
Index = Data & 0xff;
}
}
}
}
*DispatchHandle = (EFI_HANDLE)Record;
Status = EFI_SUCCESS;
} else {
//
// Transfer to stock function
//
Status = mStockUsbDispatch.Register (
This,
DispatchFunction,
RegisterContext,
DispatchHandle
);
}
return Status;
}
/**
Unregisters a USB service.
This service removes the handler associated with DispatchHandle so that it will no longer be
called when the USB event occurs.
@param[in] This Pointer to the EFI_SMM_USB_DISPATCH2_PROTOCOL instance.
@param[in] DispatchHandle Handle of the service to remove.
@retval EFI_SUCCESS The dispatch function has been successfully
unregistered and the SMI source has been disabled
if there are no other registered child dispatch
functions for this SMI source.
@retval EFI_INVALID_PARAMETER The DispatchHandle was not valid.
**/
EFI_STATUS
XhciSmiUnregister (
IN CONST EFI_SMM_USB_DISPATCH2_PROTOCOL *This,
IN EFI_HANDLE DispatchHandle
)
{
DATABASE_RECORD *Record;
DATABASE_RECORD *Prev;
EFI_STATUS Status;
if (DispatchHandle == NULL) {
return EFI_INVALID_PARAMETER;
}
Record = mRecord;
Prev = NULL;
while (Record != NULL) {
if (Record == DispatchHandle) {
//
// Don't free the record due to SmmBase is DXE driver and can't accessed during runtime
//
if (Prev) {
Prev->Next = Record->Next;
}
if (mRecord == DispatchHandle) {
//
// Turn off ALT_GP_SMI for XHCI SMIB pin
//
Status = GpioEnableGpiSmi (GPIO_PIN_FOR_XHCI_SMIB ,FALSE);
ASSERT_EFI_ERROR (Status);
//
// Remove the record;
//
mRecord = NULL;
}
return EFI_SUCCESS;
}
Prev = Record;
Record = Record->Next;
}
//
// Transfer to stock function
//
return mStockUsbDispatch.UnRegister (
This,
DispatchHandle
);
}
/**
Stall in microsecond.
@param[in] MicroSecond Microsecond for stall
**/
STATIC
VOID
Stall (
IN UINTN MicroSecond
)
{
MicroSecondDelay(MicroSecond);
}
/**
Main entry point for an SMM handler dispatch or communicate-based callback.
@param[in] DispatchHandle The unique handle assigned to this handler by SmiHandlerRegister().
@param[in] Context Points to an optional handler context which was specified when the
handler was registered.
@param[in,out] CommBuffer A pointer to a collection of data in memory that will
be conveyed from a non-SMM environment into an SMM environment.
@param[in,out] CommBufferSize The size of the CommBuffer.
@retval EFI_SUCCESS The interrupt was handled and quiesced. No other handlers
should still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED The interrupt has been quiesced but other handlers should
still be called.
@retval EFI_WARN_INTERRUPT_SOURCE_PENDING The interrupt is still pending and other handlers should still
be called.
@retval EFI_INTERRUPT_PENDING The interrupt could not be quiesced.
**/
EFI_STATUS
EFIAPI
XhciSmmCoreDispatcher (
IN EFI_HANDLE DispatchHandle,
IN CONST VOID *Context OPTIONAL,
IN OUT VOID *CommBuffer OPTIONAL,
IN OUT UINTN *CommBufferSize OPTIONAL
)
{
DATABASE_RECORD *Record;
GPIO_CONFIG GpioPadConfig;
UINT32 Data32;
EFI_STATUS Status;
//
// Check GPIO SMI for XHCI SMIB pin
//
Status = GpioGetPadConfig (GPIO_PIN_FOR_XHCI_SMIB, &GpioPadConfig);
ASSERT_EFI_ERROR (Status);
Status = GpioGetGpiSmiSts (GPIO_PIN_FOR_XHCI_SMIB, &Data32);
ASSERT_EFI_ERROR (Status);
if (((GpioPadConfig.InterruptConfig & GpioIntSmi) == GpioIntSmi) && Data32) {
Record = mRecord;
while (Record != NULL) {
if (SKIP_HAND_OFF_TO_BIOS_EVENT) {
UINT16 CmdState = 0x06;
UINT16 PwrState = 0x00;
BOOLEAN QuitFlag = FALSE;
if (*(UINT32*)(UINTN)(mXhciXecp + 0) == 0xffffffff) {
//
// Setup and backup cmd and power state
//
CmdState = PciRead16 (mXhciCmd);
if ((CmdState & 0x06) != 0x06) {
PciWrite16 (mXhciCmd, CmdState | 0x06);
}
PwrState = PciRead16 (mXhciPwr);
if (PwrState & 0x03) {
PciWrite16 (mXhciPwr, PwrState & ~0x03);
}
//
// Stall 10ms to waiting for signal stable
//
Stall(10 * 1000);
}
if (*(UINT32*)(UINTN)(mXhciXecp + 4) & 0x20000000) {
//
// Xhci owner changed
//
if (!(*(UINT32*)(UINTN)(mXhciXecp + 0) & 0x01000000)) {
//
// OS to BIOS, just to setup the Xecp register and leave
//
*(volatile UINT32*)(UINTN)(mXhciXecp + 0) = *(volatile UINT32*)(UINTN)(mXhciXecp + 0) | 0x00010000;
*(volatile UINT32*)(UINTN)(mXhciXecp + 4) = *(volatile UINT32*)(UINTN)(mXhciXecp + 4) | 0x20000000;
//
// Stall 1ms to waiting for signal stable
//
Stall(1000);
QuitFlag = TRUE;
}
}
if ((CmdState & 0x06) != 0x06) {
//
// Restore the cmd
//
PciWrite16 (mXhciCmd, CmdState);
//
// Stall 10ms to waiting for signal stable
//
Stall(10 * 1000);
}
if (PwrState & 0x03) {
//
// Restore the power state
//
PciWrite16 (mXhciPwr, PwrState);
//
// Stall 10ms to waiting for signal stable
//
Stall(10 * 1000);
}
if (QuitFlag) {
Record = Record->Next;
continue;
}
}
Record->DispatchFunction (
(EFI_HANDLE)Record,
&Record->RegisterContext,
NULL,
NULL
);
Record = Record->Next;
}
//
// Clear source
//
Status = GpioClearGpiSmiSts(GPIO_PIN_FOR_XHCI_SMIB);
ASSERT_EFI_ERROR (Status);
}
//
// Return EFI_WARN_INTERRUPT_SOURCE_QUIESCED to make subsequent root SMM handler get called
//
return EFI_WARN_INTERRUPT_SOURCE_QUIESCED;
}
Reference in New Issue View Git Blame Copy Permalink