tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/QuarkSocPkg/QuarkNorthCluster/S3Support/Dxe/QncS3Support.c

418 lines
11 KiB
C
Raw Blame History

/** @file
This is the driver that implements the QNC S3 Support protocol
Copyright (c) 2013-2016 Intel Corporation.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include "QncS3Support.h"
//
// Global Variables
//
EFI_QNC_S3_SUPPORT_PROTOCOL mQncS3SupportProtocol;
QNC_S3_PARAMETER_HEADER *mS3Parameter;
UINT32 mQncS3ImageEntryPoint;
VOID *mQncS3ImageAddress;
UINTN mQncS3ImageSize;
extern EFI_GUID gQncS3CodeInLockBoxGuid;
extern EFI_GUID gQncS3ContextInLockBoxGuid;
/**
Create a buffer that is used to store context information for use with
dispatch functions.
@retval EFI_SUCCESS - Buffer allocated and initialized.
**/
EFI_STATUS
CreateContextBuffer (
VOID
)
{
EFI_STATUS Status;
EFI_PHYSICAL_ADDRESS Address;
UINT32 ContextStoreSize;
ContextStoreSize = EFI_PAGE_SIZE;
//
// Allcoate <4G EfiReservedMemory
//
Address = 0xFFFFFFFF;
Status = gBS->AllocatePages (AllocateMaxAddress, EfiReservedMemoryType, EFI_SIZE_TO_PAGES (ContextStoreSize), &Address);
if (EFI_ERROR (Status)) {
return Status;
}
mS3Parameter = (QNC_S3_PARAMETER_HEADER *) (UINTN) Address;
//
// Determine the maximum number of context entries that can be stored in this
// table.
//
mS3Parameter->MaxContexts = ((ContextStoreSize - sizeof(QNC_S3_PARAMETER_HEADER)) / sizeof(EFI_DISPATCH_CONTEXT_UNION)) + 1;
mS3Parameter->StorePosition = 0;
return Status;
}
//
// Functions
//
EFI_STATUS
EFIAPI
QncS3SupportEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
QNC S3 support driver entry point
Arguments:
ImageHandle - Handle for the image of this driver
SystemTable - Pointer to the EFI System Table
Returns:
EFI_STATUS
--*/
{
EFI_STATUS Status;
VOID *TmpPtr;
EFI_EVENT Event;
//
// If the protocol is found execution is happening in ACPI NVS memory. If it
// is not found copy the driver into ACPI NVS memory and pass control to it.
//
Status = gBS->LocateProtocol (&gEfiCallerIdGuid, NULL, &TmpPtr);
//
// Load the QNC S3 image
//
if (EFI_ERROR (Status)) {
Status = LoadQncS3Image (SystemTable);
ASSERT_EFI_ERROR (Status);
} else {
DEBUG ((DEBUG_INFO, "QncS3SupportEntryPoint() in reserved memory - Begin\n"));
//
// Allocate and initialize context buffer.
//
Status = CreateContextBuffer ();
if (EFI_ERROR (Status)) {
return Status;
}
//
// Install the QNC S3 Support protocol
//
mQncS3SupportProtocol.SetDispatchItem = QncS3SetDispatchItem;
Status = gBS->InstallMultipleProtocolInterfaces (
&ImageHandle,
&gEfiQncS3SupportProtocolGuid,
&mQncS3SupportProtocol,
NULL
);
mQncS3ImageAddress = (VOID *)(UINTN)PcdGet64(PcdQncS3CodeInLockBoxAddress);
mQncS3ImageSize = (UINTN)PcdGet64(PcdQncS3CodeInLockBoxSize);
DEBUG ((DEBUG_INFO, "QncS3SupportEntry Code = %08x, Size = %08x\n", (UINTN)mQncS3ImageAddress, mQncS3ImageSize));
DEBUG ((DEBUG_INFO, "QncS3SupportEntry Contex = %08x, Size = %08x\n", (UINTN)mS3Parameter, EFI_PAGE_SIZE));
ASSERT (mQncS3ImageAddress != 0);
//
// Register EFI_END_OF_DXE_EVENT_GROUP_GUID event.
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK,
QncS3BootEvent,
NULL,
&gEfiEndOfDxeEventGroupGuid,
&Event
);
ASSERT_EFI_ERROR (Status);
DEBUG ((DEBUG_INFO, "QncS3SupportEntryPoint() in reserved memory - End\n"));
}
return Status;
}
EFI_STATUS
EFIAPI
QncS3SetDispatchItem (
IN EFI_QNC_S3_SUPPORT_PROTOCOL *This,
IN EFI_QNC_S3_DISPATCH_ITEM *DispatchItem,
OUT VOID **S3DispatchEntryPoint,
OUT VOID **Context
)
/*++
Routine Description:
Set an item to be dispatched at S3 resume time. At the same time, the entry point
of the QNC S3 support image is returned to be used in subsequent boot script save
call
Arguments:
This - Pointer to the protocol instance.
DispatchItem - The item to be dispatched.
S3DispatchEntryPoint - The entry point of the QNC S3 support image.
Returns:
EFI_STATUS - Successfully completed.
EFI_OUT_OF_RESOURCES - Out of resources.
--*/
{
DEBUG ((DEBUG_INFO, "QncS3SetDispatchItem() Start\n"));
//
// Set default values.
//
*S3DispatchEntryPoint = NULL;
*Context = NULL;
//
// Determine if this entry will fit.
//
if (mS3Parameter->StorePosition >= mS3Parameter->MaxContexts) {
DEBUG ((DEBUG_INFO, "QncS3SetDispatchItem exceeds max length - 0x%08x\n", (UINTN)mS3Parameter->MaxContexts));
return EFI_OUT_OF_RESOURCES;
}
//
// Calculate the size required;
// ** Always round up to be 8 byte aligned
//
switch (DispatchItem->Type) {
case QncS3ItemTypeInitPcieRootPortDownstream:
*S3DispatchEntryPoint = (VOID*) (UINTN)QncS3InitPcieRootPortDownstream;
*Context = &mS3Parameter->Contexts[mS3Parameter->StorePosition];
CopyMem (&mS3Parameter->Contexts[mS3Parameter->StorePosition], DispatchItem->Parameter, sizeof(UINT32));
DEBUG ((DEBUG_INFO, "QncS3InitPcieRootPortDownstream @ 0x%08x - context 0x%08x\n", (UINTN)*S3DispatchEntryPoint, (UINTN)*Context));
break;
default:
return EFI_UNSUPPORTED;
}
mS3Parameter->StorePosition ++;
DEBUG ((DEBUG_INFO, "QncS3SetDispatchItem() End\n"));
return EFI_SUCCESS;
}
EFI_STATUS
LoadQncS3Image (
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
Load the QNC S3 Image into Efi Reserved Memory below 4G.
Arguments:
ImageEntryPoint the ImageEntryPoint after success loading
Returns:
EFI_STATUS
--*/
{
EFI_STATUS Status;
UINT8 *Buffer;
UINTN BufferSize;
VOID *FfsBuffer;
PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
EFI_HANDLE NewImageHandle;
//
// Install NULL protocol on module file handle to indicate that the entry point
// has been called for the first time.
//
NewImageHandle = NULL;
Status = gBS->InstallProtocolInterface (
&NewImageHandle,
&gEfiCallerIdGuid,
EFI_NATIVE_INTERFACE,
NULL
);
//
// Find this module so it can be loaded again.
//
Status = GetSectionFromAnyFv (
&gEfiCallerIdGuid,
EFI_SECTION_PE32,
0,
(VOID**) &Buffer,
&BufferSize
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get information about the image being loaded.
//
ImageContext.Handle = Buffer;
ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
//
// Get information about the image being loaded
//
Status = PeCoffLoaderGetImageInfo (&ImageContext);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->AllocatePool (
EfiReservedMemoryType,
BufferSize + ImageContext.SectionAlignment,
&FfsBuffer
);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_INFO, "LoadQncS3Image failed for no enough space! \n"));
return EFI_OUT_OF_RESOURCES;
}
mQncS3ImageAddress = FfsBuffer;
mQncS3ImageSize = BufferSize + ImageContext.SectionAlignment;
Status = PcdSet64S (PcdQncS3CodeInLockBoxAddress, (UINT64)(UINTN)mQncS3ImageAddress);
ASSERT_EFI_ERROR (Status);
Status = PcdSet64S (PcdQncS3CodeInLockBoxSize, (UINT64)mQncS3ImageSize);
ASSERT_EFI_ERROR (Status);
//
// Align buffer on section boundary
//
ImageContext.ImageAddress = (PHYSICAL_ADDRESS)(UINTN)FfsBuffer;
if (ImageContext.SectionAlignment != 0) {
ImageContext.ImageAddress += ImageContext.SectionAlignment - 1;
ImageContext.ImageAddress &= ~(ImageContext.SectionAlignment - 1);
}
//
// Load the image to our new buffer
//
Status = PeCoffLoaderLoadImage (&ImageContext);
if (EFI_ERROR (Status)) {
gBS->FreePool (FfsBuffer);
DEBUG ((DEBUG_INFO, "LoadQncS3Image failed for PeCoffLoaderLoadImage failure! \n"));
return Status;
}
//
// Relocate the image in our new buffer
//
Status = PeCoffLoaderRelocateImage (&ImageContext);
if (EFI_ERROR (Status)) {
PeCoffLoaderUnloadImage (&ImageContext);
gBS->FreePool (FfsBuffer);
DEBUG ((DEBUG_INFO, "LoadQncS3Image failed for PeCoffLoaderRelocateImage failure! \n"));
return Status;
}
//
// Invalidate instruction cache and pass control to the image. This will perform
// the initialization of the module and publish the supporting protocols.
//
InvalidateInstructionCacheRange ((VOID *)(UINTN)ImageContext.ImageAddress, (UINTN)ImageContext.ImageSize);
Status = ((EFI_IMAGE_ENTRY_POINT)(UINTN)(ImageContext.EntryPoint)) (NewImageHandle, SystemTable);
if (EFI_ERROR (Status)) {
gBS->FreePool (FfsBuffer);
return Status;
}
return EFI_SUCCESS;
}
EFI_STATUS
QncS3InitPcieRootPortDownstream (
IN EFI_HANDLE ImageHandle,
IN VOID *Context
)
/*++
Routine Description:
Perform Init Root Port Downstream devices on S3 resume
Arguments:
Parameter Parameters passed in from DXE
Returns:
EFI_STATUS
--*/
{
EFI_STATUS Status;
DEBUG ((DEBUG_INFO, "QncS3InitPcieRootPortDownstream() Begin\n"));
//
// Initialize the device behind the root port.
//
Status = PciExpressInit ();
//
// Not checking the error status here - downstream device not present does not
// mean an error of this root port. Our return status of EFI_SUCCESS means this
// port is enabled and outer function depends on this return status to do
// subsequent initializations.
//
if (Status != EFI_SUCCESS){
DEBUG ((DEBUG_INFO, "QncS3InitPcieRootPortDownstream() failed\n"));
}
DEBUG ((DEBUG_INFO, "QncS3InitPcieRootPortDownstream() End\n"));
return Status;
}
VOID
EFIAPI
QncS3BootEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
//
// These 2 boxes will be restored by RestoreAllLockBoxInPlace in S3Resume automatically
//
DEBUG ((DEBUG_INFO, "SaveLockBox QncS3Code = %08x, Size = %08x\n", (UINTN)mQncS3ImageAddress, mQncS3ImageSize));
SaveLockBox(&gQncS3CodeInLockBoxGuid, mQncS3ImageAddress, mQncS3ImageSize);
Status = SetLockBoxAttributes (&gQncS3CodeInLockBoxGuid, LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE);
ASSERT_EFI_ERROR (Status);
DEBUG ((DEBUG_INFO, "SaveLockBox QncS3Context = %08x, Size = %08x\n", (UINTN)mS3Parameter, EFI_PAGE_SIZE));
SaveLockBox(&gQncS3ContextInLockBoxGuid, (VOID *)mS3Parameter, EFI_PAGE_SIZE);
Status = SetLockBoxAttributes (&gQncS3ContextInLockBoxGuid, LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE);
ASSERT_EFI_ERROR (Status);
}
Reference in New Issue View Git Blame Copy Permalink