381 lines
12 KiB
C
381 lines
12 KiB
C
/** @file
|
|
This driver implements Global Pcd definition block in ACPI table and
|
|
registers SMI callback functions for ReadPcd
|
|
|
|
;******************************************************************************
|
|
;* Copyright (c) 2018 - 2019, 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 "PcdAcpiSupport.h"
|
|
|
|
H2O_ACPI_GET_PCD_VALUE *mGlobalPcdArea = NULL;
|
|
extern EFI_GET_PCD_INFO_PROTOCOL mEfiGetPcdInfoInstance;
|
|
extern EFI_PCD_PROTOCOL mEfiPcdInstance;
|
|
|
|
#define LibPcdGetExPtr(X, Y) mEfiPcdInstance.GetPtr (X, Y)
|
|
|
|
/**
|
|
Software SMI callback for Read PCD which is called from ACPI method.
|
|
|
|
Caution: This function may receive untrusted input.
|
|
ACPINvs are external input, so this function will validate
|
|
its data structure to be valid value.
|
|
|
|
@retval H2O_PCD_ACPI_STATUS_SUCCESS Success
|
|
@retval H2O_PCD_ACPI_STATUS_INVALID_PCD Invalid PCD
|
|
@retval H2O_PCD_ACPI_STATUS_INVALID_ACTION Invalid PCD Action
|
|
|
|
**/
|
|
H2O_PCD_STATUS
|
|
ParamterCheck (
|
|
UINTN *Size
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PCD_INFO EfiPcdInfo;
|
|
|
|
Status = EFI_SUCCESS;
|
|
|
|
if (mGlobalPcdArea->PcdAction != READ_PCD_COMMAND) {
|
|
return H2O_PCD_ACPI_STATUS_INVALID_ACTION;
|
|
}
|
|
if (CompareGuid (&mGlobalPcdArea->PcdGuid, &gZeroGuid)) {
|
|
return H2O_PCD_ACPI_STATUS_INVALID_PCD;
|
|
}
|
|
|
|
Status = mEfiGetPcdInfoInstance.GetInfo (&mGlobalPcdArea->PcdGuid, mGlobalPcdArea->PcdTokenNumber, &EfiPcdInfo);
|
|
if (EFI_ERROR(Status)) {
|
|
return H2O_PCD_ACPI_STATUS_INVALID_PCD;
|
|
}
|
|
|
|
*Size = EfiPcdInfo.PcdSize;
|
|
mGlobalPcdArea->PcdDataSize = (UINT32) EfiPcdInfo.PcdSize;
|
|
mGlobalPcdArea->PcdType = EfiPcdInfo.PcdType;
|
|
return H2O_PCD_ACPI_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
/**
|
|
Software SMI callback for Read PCD which is called from ACPI method.
|
|
|
|
Caution: This function may receive untrusted input.
|
|
ACPINvs are external input, so this function will validate
|
|
its data structure to be valid value.
|
|
|
|
@retval EFI_SUCCESS The interrupt was handled successfully.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
SmmGetPcdCommon (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
H2O_PCD_STATUS PcdStatus;
|
|
UINTN Size;
|
|
EFI_PCD_PROTOCOL *Pcd;
|
|
VOID *Buffer;
|
|
|
|
Size = 0;
|
|
PcdStatus = H2O_PCD_ACPI_STATUS_SUCCESS;
|
|
Status = EFI_UNSUPPORTED;
|
|
Pcd = &mEfiPcdInstance;
|
|
|
|
PcdStatus = ParamterCheck(&Size);
|
|
if (PcdStatus != H2O_PCD_ACPI_STATUS_SUCCESS) {
|
|
return Status;
|
|
}
|
|
|
|
switch(mGlobalPcdArea->PcdType) {
|
|
|
|
case EFI_PCD_TYPE_8:
|
|
*(UINT8 *) mGlobalPcdArea->PcdData = Pcd->Get8(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
break;
|
|
|
|
case EFI_PCD_TYPE_16:
|
|
*(UINT16 *) mGlobalPcdArea->PcdData = Pcd->Get16(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
break;
|
|
|
|
case EFI_PCD_TYPE_32:
|
|
*(UINT32 *) mGlobalPcdArea->PcdData = Pcd->Get32(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
break;
|
|
|
|
case EFI_PCD_TYPE_64:
|
|
*(UINT64 *) mGlobalPcdArea->PcdData = Pcd->Get64(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
break;
|
|
|
|
case EFI_PCD_TYPE_BOOL:
|
|
*(BOOLEAN *) mGlobalPcdArea->PcdData = Pcd->GetBool(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
break;
|
|
|
|
case EFI_PCD_TYPE_PTR:
|
|
if (Size > MAX_PCD_DATA_SIZE) {
|
|
PcdStatus = H2O_PCD_ACPI_STATUS_DATA_TOO_SMALL; // PcdDataSize was too small to hold the PCD's data
|
|
break;
|
|
}
|
|
Buffer = Pcd->GetPtr(&mGlobalPcdArea->PcdGuid,mGlobalPcdArea->PcdTokenNumber);
|
|
CopyMem(mGlobalPcdArea->PcdData, Buffer, Size);
|
|
break;
|
|
default:
|
|
PcdStatus = H2O_PCD_ACPI_STATUS_INVALID_PCD; // wrong PCD Type specified
|
|
Status = EFI_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
mGlobalPcdArea->PcdStatus = PcdStatus;
|
|
if (PcdStatus == H2O_PCD_ACPI_STATUS_SUCCESS) {
|
|
Status = EFI_SUCCESS;
|
|
}
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
Software SMI callback for Read PCD which is called from ACPI method.
|
|
|
|
Caution: This function may receive untrusted input.
|
|
ACPINvs are external input, so this function will validate
|
|
its data structure to be valid value.
|
|
|
|
@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 successfully.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
AcpiReadPcdCallback (
|
|
IN EFI_HANDLE DispatchHandle,
|
|
IN CONST VOID *Context,
|
|
IN OUT VOID *CommBuffer,
|
|
IN OUT UINTN *CommBufferSize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
H2O_ACPI_GET_PCD_VALUE *OrgGlobalPcdArea;
|
|
|
|
//
|
|
// Copy H2O_ACPI_GET_PCD_VALUE to SMRAM to prevent from TOCTOU attack.
|
|
//
|
|
OrgGlobalPcdArea = mGlobalPcdArea;
|
|
mGlobalPcdArea = AllocateCopyPool (sizeof (H2O_ACPI_GET_PCD_VALUE), OrgGlobalPcdArea);
|
|
if (mGlobalPcdArea == NULL) {
|
|
mGlobalPcdArea = OrgGlobalPcdArea;
|
|
return EFI_SUCCESS;
|
|
}
|
|
mGlobalPcdArea->PcdAction = READ_PCD_COMMAND;
|
|
Status = SmmGetPcdCommon();
|
|
//
|
|
// Restore data from SMRAM to H2O_ACPI_GET_PCD_VALUE buffer.
|
|
//
|
|
CopyMem (OrgGlobalPcdArea, mGlobalPcdArea, sizeof (H2O_ACPI_GET_PCD_VALUE));
|
|
FreePool (mGlobalPcdArea);
|
|
mGlobalPcdArea = OrgGlobalPcdArea;
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Find the operation region in Pcd ACPI table by given Name and Size,
|
|
and initialize it if the region is found.
|
|
|
|
@param[in, out] Table The Pcd item in ACPI table.
|
|
@param[in] Name The name string to find in Pcd table.
|
|
@param[in] Size The size of the region to find.
|
|
@param[in, out] Address The allocated address for the found region.
|
|
|
|
@retval EFI_SUCCESS The function completed successfully.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
AssignOpRegion (
|
|
IN OUT EFI_ACPI_DESCRIPTION_HEADER *Table,
|
|
IN UINT32 Name,
|
|
IN UINT16 Size,
|
|
IN OUT VOID** Address OPTIONAL
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
AML_OP_REGION_32_16 *OpRegion;
|
|
EFI_PHYSICAL_ADDRESS MemoryAddress;
|
|
UINTN SizeA;
|
|
|
|
SizeA = sizeof (AML_OP_REGION_32_16);
|
|
|
|
Status = EFI_NOT_FOUND;
|
|
MemoryAddress = (EFI_PHYSICAL_ADDRESS) (UINTN) *Address;
|
|
//
|
|
// Patch some pointers for the ASL code before loading the SSDT.
|
|
//
|
|
for (OpRegion = (AML_OP_REGION_32_16 *) (Table + 1);
|
|
OpRegion <= (AML_OP_REGION_32_16 *) ((UINT8 *) Table + Table->Length);
|
|
OpRegion = (AML_OP_REGION_32_16 *) ((UINT8 *) OpRegion + 1)) {
|
|
if ((OpRegion->OpRegionOp == AML_EXT_REGION_OP) &&
|
|
(OpRegion->NameString == Name) &&
|
|
(OpRegion->DWordPrefix == AML_DWORD_PREFIX) &&
|
|
(OpRegion->WordPrefix == AML_WORD_PREFIX)) {
|
|
|
|
if (MemoryAddress == 0) {
|
|
MemoryAddress = SIZE_4GB - 1;
|
|
Status = gBS->AllocatePages (AllocateMaxAddress, EfiACPIMemoryNVS, EFI_SIZE_TO_PAGES (Size), &MemoryAddress);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "AllocatePages Status = %r\n",Status));
|
|
goto Done;
|
|
}
|
|
ZeroMem ((VOID *)(UINTN) MemoryAddress, Size);
|
|
}
|
|
OpRegion->RegionOffset = (UINT32) (UINTN) MemoryAddress;
|
|
OpRegion->RegionLen = Size;
|
|
Status = EFI_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
*Address = (VOID *) (UINTN) MemoryAddress;
|
|
|
|
Done:
|
|
return Status;
|
|
}
|
|
|
|
/**
|
|
Initialize and publish Pcd items in ACPI table.
|
|
|
|
@retval EFI_SUCCESS The Pcd ACPI table is published successfully.
|
|
@retval Others The Pcd ACPI table is not published.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
PublishAcpiTable (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN TableKey;
|
|
UINTN TableSize;
|
|
EFI_ACPI_TABLE_PROTOCOL *AcpiTable;
|
|
EFI_ACPI_DESCRIPTION_HEADER *Table;
|
|
|
|
//
|
|
// Use instance 1 to get ACPI table, Instance 0 is DXEPcdDataBaseSec.raw
|
|
//
|
|
Status = GetSectionFromFv (
|
|
&gEfiCallerIdGuid,
|
|
EFI_SECTION_RAW,
|
|
1,
|
|
(VOID **) &Table,
|
|
&TableSize
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "GetSectionFromFv Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
CopyMem (Table->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (Table->OemId) );
|
|
Status = AssignOpRegion (Table, SIGNATURE_32 ('G', 'P', 'C', 'D'), (UINT16) sizeof (H2O_ACPI_GET_PCD_VALUE), (VOID **)&mGlobalPcdArea);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "AssignOpRegion Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Publish the PCD ACPI table
|
|
//
|
|
Status = gBS->LocateProtocol (&gEfiAcpiTableProtocolGuid, NULL, (VOID **) &AcpiTable);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "Locate gEfiAcpiTableProtocolGuid Protocol Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
TableKey = 0;
|
|
Status = AcpiTable->InstallAcpiTable (
|
|
AcpiTable,
|
|
Table,
|
|
TableSize,
|
|
&TableKey
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "InstallAcpiTable Status = %r\n",Status));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
|
|
InitializePcdAcpiSupport allocate space for pcd.asl and publish it's acpi table
|
|
|
|
@retval EFI_SUCCESS The PCD ACPI table is published successfully.
|
|
@retval Others The PCD ACPI table is not published.
|
|
|
|
|
|
**/
|
|
EFI_STATUS
|
|
InitializePcdAcpiSupport (
|
|
VOID
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_PHYSICAL_ADDRESS Address;
|
|
UINTN Pages;
|
|
EFI_SMM_SW_DISPATCH2_PROTOCOL *SwDispatch;
|
|
EFI_SMM_SW_REGISTER_CONTEXT SwContext;
|
|
EFI_HANDLE SwHandle;
|
|
|
|
//
|
|
// Allocate and initialize the PCD area for SMM and ASL communication.
|
|
//
|
|
Pages = EFI_SIZE_TO_PAGES (sizeof (H2O_ACPI_GET_PCD_VALUE));
|
|
Address = 0xFFFFFFFF;
|
|
Status = gBS->AllocatePages (
|
|
AllocateMaxAddress,
|
|
EfiACPIMemoryNVS,
|
|
Pages,
|
|
&Address
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "AllocatePages Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
mGlobalPcdArea = (H2O_ACPI_GET_PCD_VALUE*) (UINTN)Address;
|
|
SetMem (mGlobalPcdArea, sizeof (H2O_ACPI_GET_PCD_VALUE), 0);
|
|
DEBUG ((EFI_D_INFO, "mGlobalPcdArea is at 0x%X\n", mGlobalPcdArea));
|
|
|
|
Status = PublishAcpiTable ();
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "PublishAcpiTable Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Get the Sw dispatch protocol and register SMI callback functions.
|
|
//
|
|
Status = gSmst->SmmLocateProtocol (&gEfiSmmSwDispatch2ProtocolGuid, NULL, (VOID**)&SwDispatch);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "Locate gEfiSmmSwDispatch2ProtocolGuid Protocol Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
SwContext.SwSmiInputValue = (UINTN) SMM_READ_PCD;
|
|
Status = SwDispatch->Register (SwDispatch, AcpiReadPcdCallback, &SwContext, &SwHandle);
|
|
if (EFI_ERROR (Status)) {
|
|
DEBUG ((EFI_D_ERROR, "Register ReadPcdCallback Status = %r\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|