AGESA_STATUS agesawrapper_amdinitreset(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_RESET_PARAMS AmdResetParams;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
memset(&AmdResetParams, 0, sizeof(AMD_RESET_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_RESET;
AmdParamStruct.AllocationMethod = ByHost;
AmdParamStruct.NewStructSize = sizeof(AMD_RESET_PARAMS);
AmdParamStruct.NewStructPtr = &AmdResetParams;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
AmdResetParams.HtConfig.Depth = 0;
status = AmdInitReset((AMD_RESET_PARAMS *) AmdParamStruct.NewStructPtr);
AGESA_EVENTLOG(status, &AmdParamStruct.StdHeader);
AmdReleaseStruct(&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitearly(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_EARLY_PARAMS *AmdEarlyParamsPtr;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_EARLY;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct (&AmdParamStruct);
AmdEarlyParamsPtr = (AMD_EARLY_PARAMS *)AmdParamStruct.NewStructPtr;
OemCustomizeInitEarly (AmdEarlyParamsPtr);
AmdEarlyParamsPtr->GnbConfig.PsppPolicy = PsppDisabled;
status = AmdInitEarly ((AMD_EARLY_PARAMS *)AmdParamStruct.NewStructPtr);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
AmdReleaseStruct (&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitearly(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_EARLY_PARAMS *AmdEarlyParamsPtr;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_EARLY;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
/* OEM Should Customize the defaults through this hook. */
AmdEarlyParamsPtr = (AMD_EARLY_PARAMS *) AmdParamStruct.NewStructPtr;
if (OemHook->InitEarly)
OemHook->InitEarly(AmdEarlyParamsPtr);
status = AmdInitEarly(AmdEarlyParamsPtr);
AGESA_EVENTLOG(status, &AmdParamStruct.StdHeader);
AmdReleaseStruct(&AmdParamStruct);
return status;
}
/**
* AgesaLaunchApForGivenTask
*
* Description
* Call the host environment interface to provide a user hook opportunity.
*
* @return The AGESA Status returned from the callout.
*
*/
AGESA_STATUS
AgesaLaunchApForGivenTask (
VOID
)
{
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AGESA_STATUS AgesaStatus;
AP_EXE_PARAMS *ApExeParams;
//
// Invoke AmdAmdCpuLateInit
//
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_LATE_RUN_AP_TASK;
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
ApExeParams = (AP_EXE_PARAMS *)AmdInterfaceParams.NewStructPtr;
ApExeParams->RelatedBlockLength = RelatedBlockLength;
ApExeParams->RelatedDataBlock = RelatedDataBlock;
ApExeParams->FunctionNumber = FunctionNumber;
AgesaStatus = AmdLateRunApTask (ApExeParams);
AmdReleaseStruct (&AmdInterfaceParams);
return AgesaStatus;
}
AGESA_STATUS agesawrapper_amdinitlate(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_LATE;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
#if IS_ENABLED(CONFIG_CPU_AMD_AGESA_FAMILY15_TN) || IS_ENABLED(CONFIG_CPU_AMD_AGESA_FAMILY15_RL) || \
IS_ENABLED(CONFIG_CPU_AMD_AGESA_FAMILY16_KB)
AmdParamStruct.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
#endif
AmdCreateStruct(&AmdParamStruct);
AmdLateParams = (AMD_LATE_PARAMS *) AmdParamStruct.NewStructPtr;
status = AmdInitLate(AmdLateParams);
AGESA_EVENTLOG(status, &AmdLateParams->StdHeader);
ASSERT(status == AGESA_SUCCESS);
/* No AmdReleaseStruct(&AmdParamStruct), we need AmdLateParams later. */
return status;
}
AGESA_STATUS agesawrapper_amdinitenv(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_ENV_PARAMS *EnvParam;
/* Initialize heap space */
EmptyHeap();
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_ENV;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
EnvParam = (AMD_ENV_PARAMS *) AmdParamStruct.NewStructPtr;
status = AmdInitEnv(EnvParam);
AGESA_EVENTLOG(status, &EnvParam->StdHeader);
AmdReleaseStruct(&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitmid(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_MID_PARAMS *MidParam;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_MID;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
/* OEM Should Customize the defaults through this hook. */
MidParam = (AMD_MID_PARAMS *) AmdParamStruct.NewStructPtr;
if (OemHook->InitMid)
OemHook->InitMid(MidParam);
status = AmdInitMid(MidParam);
AGESA_EVENTLOG(status, &MidParam->StdHeader);
AmdReleaseStruct(&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdS3Save(void)
{
AGESA_STATUS status;
AMD_S3SAVE_PARAMS *AmdS3SaveParamsPtr;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
memset(&AmdInterfaceParams, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.StdHeader.CalloutPtr = &GetBiosCallout;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_S3_SAVE;
AmdInterfaceParams.StdHeader.AltImageBasePtr = 0;
AmdInterfaceParams.StdHeader.Func = 0;
AmdCreateStruct(&AmdInterfaceParams);
AmdS3SaveParamsPtr = (AMD_S3SAVE_PARAMS *) AmdInterfaceParams.NewStructPtr;
AmdS3SaveParamsPtr->StdHeader = AmdInterfaceParams.StdHeader;
status = AmdS3Save(AmdS3SaveParamsPtr);
AGESA_EVENTLOG(status, &AmdInterfaceParams.StdHeader);
ASSERT(status == AGESA_SUCCESS);
OemS3Save(AmdS3SaveParamsPtr);
AmdReleaseStruct(&AmdInterfaceParams);
return status;
}
AGESA_STATUS agesawrapper_amds3laterestore(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AMD_S3LATE_PARAMS AmdS3LateParams;
AMD_S3LATE_PARAMS *AmdS3LateParamsPtr;
memset(&AmdS3LateParams, 0, sizeof(AMD_S3LATE_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.AllocationMethod = ByHost;
AmdInterfaceParams.AgesaFunctionName = AMD_S3LATE_RESTORE;
AmdInterfaceParams.NewStructPtr = &AmdS3LateParams;
AmdInterfaceParams.StdHeader.CalloutPtr = &GetBiosCallout;
AmdS3LateParamsPtr = &AmdS3LateParams;
AmdInterfaceParams.NewStructSize = sizeof(AMD_S3LATE_PARAMS);
AmdCreateStruct(&AmdInterfaceParams);
#if 0
/* TODO: What to do with NvStorage here? */
AmdS3LateParamsPtr->S3DataBlock.NvStorageSize = 0;
#endif
AmdS3LateParamsPtr->S3DataBlock.VolatileStorageSize = 0;
OemS3LateRestore(AmdS3LateParamsPtr);
status = AmdS3LateRestore(AmdS3LateParamsPtr);
AGESA_EVENTLOG(status, &AmdInterfaceParams.StdHeader);
ASSERT(status == AGESA_SUCCESS);
return status;
}
AGESA_STATUS agesawrapper_amdinitresume(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_RESUME_PARAMS *AmdResumeParamsPtr;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_RESUME;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
AmdResumeParamsPtr = (AMD_RESUME_PARAMS *) AmdParamStruct.NewStructPtr;
AmdResumeParamsPtr->S3DataBlock.NvStorageSize = 0;
AmdResumeParamsPtr->S3DataBlock.VolatileStorageSize = 0;
OemInitResume(AmdResumeParamsPtr);
status = AmdInitResume(AmdResumeParamsPtr);
AGESA_EVENTLOG(status, &AmdParamStruct.StdHeader);
AmdReleaseStruct(&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitpost(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_POST_PARAMS *PostParams;
memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
AmdParamStruct.AgesaFunctionName = AMD_INIT_POST;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct(&AmdParamStruct);
/* OEM Should Customize the defaults through this hook. */
PostParams = (AMD_POST_PARAMS *) AmdParamStruct.NewStructPtr;
if (OemHook->InitPost)
OemHook->InitPost(PostParams);
status = AmdInitPost(PostParams);
AGESA_EVENTLOG(status, &PostParams->StdHeader);
AmdReleaseStruct(&AmdParamStruct);
/* Initialize heap space */
EmptyHeap();
return status;
}
AGESA_STATUS agesawrapper_amdS3Save(void)
{
AGESA_STATUS Status;
AMD_S3SAVE_PARAMS *AmdS3SaveParamsPtr;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
S3_DATA_TYPE S3DataType;
LibAmdMemFill (&AmdInterfaceParams,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdInterfaceParams.StdHeader));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.StdHeader.CalloutPtr = &GetBiosCallout;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_S3_SAVE;
AmdInterfaceParams.StdHeader.AltImageBasePtr = 0;
AmdInterfaceParams.StdHeader.Func = 0;
AmdCreateStruct(&AmdInterfaceParams);
AmdS3SaveParamsPtr = (AMD_S3SAVE_PARAMS *)AmdInterfaceParams.NewStructPtr;
AmdS3SaveParamsPtr->StdHeader = AmdInterfaceParams.StdHeader;
Status = AmdS3Save(AmdS3SaveParamsPtr);
if (Status != AGESA_SUCCESS) {
agesawrapper_amdreadeventlog(AmdInterfaceParams.StdHeader.HeapStatus);
ASSERT(Status == AGESA_SUCCESS);
}
S3DataType = S3DataTypeNonVolatile;
printk(BIOS_DEBUG, "NvStorageSize=%x, NvStorage=%x\n",
(unsigned int)AmdS3SaveParamsPtr->S3DataBlock.NvStorageSize,
(unsigned int)AmdS3SaveParamsPtr->S3DataBlock.NvStorage);
Status = OemAgesaSaveS3Info (
S3DataType,
AmdS3SaveParamsPtr->S3DataBlock.NvStorageSize,
AmdS3SaveParamsPtr->S3DataBlock.NvStorage);
printk(BIOS_DEBUG, "VolatileStorageSize=%x, VolatileStorage=%x\n",
(unsigned int)AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize,
(unsigned int)AmdS3SaveParamsPtr->S3DataBlock.VolatileStorage);
if (AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize != 0) {
S3DataType = S3DataTypeVolatile;
Status = OemAgesaSaveS3Info (
S3DataType,
AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize,
AmdS3SaveParamsPtr->S3DataBlock.VolatileStorage);
}
OemAgesaSaveMtrr();
AmdReleaseStruct (&AmdInterfaceParams);
return Status;
}
AGESA_STATUS agesawrapper_amdinitpost(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_POST_PARAMS *PostParams;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_POST;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = NULL;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct (&AmdParamStruct);
PostParams = (AMD_POST_PARAMS *)AmdParamStruct.NewStructPtr;
OemPostParams(PostParams);
// Do not use IS_ENABLED here. CONFIG_GFXUMA should always have a value. Allow
// the compiler to flag the error if CONFIG_GFXUMA is not set.
PostParams->MemConfig.UmaMode = CONFIG_GFXUMA ? UMA_AUTO : UMA_NONE;
PostParams->MemConfig.UmaSize = 0;
PostParams->MemConfig.BottomIo = (UINT16)(0xD0000000 >> 24);
status = AmdInitPost (PostParams);
printk(
BIOS_SPEW,
"setup_uma_memory: umamode %s\n",
(PostParams->MemConfig.UmaMode == UMA_AUTO) ? "UMA_AUTO" :
(PostParams->MemConfig.UmaMode == UMA_SPECIFIED) ? "UMA_SPECIFIED" :
(PostParams->MemConfig.UmaMode == UMA_NONE) ? "UMA_NONE" :
"unknown"
);
printk(
BIOS_SPEW,
"setup_uma_memory: syslimit 0x%08llX, bottomio 0x%08lx\n",
(unsigned long long)(PostParams->MemConfig.SysLimit) << 16,
(unsigned long)(PostParams->MemConfig.BottomIo) << 16
);
printk(
BIOS_SPEW,
"setup_uma_memory: uma size %luMB, uma start 0x%08lx\n",
(unsigned long)(PostParams->MemConfig.UmaSize) >> (20 - 16),
(unsigned long)(PostParams->MemConfig.UmaBase) << 16
);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
AmdReleaseStruct (&AmdParamStruct);
/* Initialize heap space */
EmptyHeap();
return status;
}
VOID
EFIAPI
InvokeAmdInitMid (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Installs the AmdInitMid This function gets called
each time the EFI_EVENT_SIGNAL_READY_TO_BOOT gets signaled
Arguments & Return Values: Standard event handling function prototype
--*/
{
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AGESA_STATUS AgesaStatus;
AMD_DXE_INIT_MID_PROTOCOL AmdInitMidProtocol;
EFI_HANDLE Handle;
STATIC BOOLEAN InitMidInvoked = FALSE;
//
// Prepare for AmdInitMid
//
if (!InitMidInvoked) {
ZeroMem (&AmdInterfaceParams, sizeof (AMD_INTERFACE_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_INIT_MID;
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
((AMD_MID_PARAMS *)AmdInterfaceParams.NewStructPtr)->StdHeader = AmdInterfaceParams.StdHeader;
OemCustomizeInitMid (gBS, (AMD_MID_PARAMS *)AmdInterfaceParams.NewStructPtr);
AgesaStatus = AmdInitMid ((AMD_MID_PARAMS *)AmdInterfaceParams.NewStructPtr);
OemHookAfterInitMid (gBS, (AMD_MID_PARAMS *)AmdInterfaceParams.NewStructPtr);
if ((AgesaStatus == AGESA_CRITICAL) || (AgesaStatus == AGESA_FATAL)) {
return;
}
AmdInitMidProtocol.Revision = AGESA_DXE_INIT_MID_REV;
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdDxeInitMidProtocolGuid,
EFI_NATIVE_INTERFACE,
&AmdInitMidProtocol
);
}
InitMidInvoked = TRUE;
}
AGESA_STATUS agesawrapper_amdinitlate(void)
{
AGESA_STATUS Status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_LATE_PARAMS *AmdLateParams;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_LATE;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
/* NOTE: if not call amdcreatestruct, the initializer(AmdInitLateInitializer) would not be called */
AmdCreateStruct(&AmdParamStruct);
AmdLateParams = (AMD_LATE_PARAMS *)AmdParamStruct.NewStructPtr;
Status = AmdInitLate(AmdLateParams);
if (Status != AGESA_SUCCESS) {
agesawrapper_amdreadeventlog(AmdLateParams->StdHeader.HeapStatus);
ASSERT(Status == AGESA_SUCCESS);
}
DmiTable = AmdLateParams->DmiTable;
AcpiPstate = AmdLateParams->AcpiPState;
#if IS_ENABLED(CONFIG_NORTHBRIDGE_AMD_PI_00630F01) || IS_ENABLED(CONFIG_NORTHBRIDGE_AMD_PI_00730F01)
AcpiSrat = AmdLateParams->AcpiSrat;
AcpiSlit = AmdLateParams->AcpiSlit;
#endif
AcpiWheaMce = AmdLateParams->AcpiWheaMce;
AcpiWheaCmc = AmdLateParams->AcpiWheaCmc;
AcpiAlib = AmdLateParams->AcpiAlib;
AcpiIvrs = AmdLateParams->AcpiIvrs;
AcpiCrat = AmdLateParams->AcpiCrat;
printk(BIOS_DEBUG, "DmiTable:%x, AcpiPstatein: %x, AcpiSrat:%x,"
"AcpiSlit:%x, Mce:%x, Cmc:%x,"
"Alib:%x, AcpiIvrs:%x in %s\n",
(unsigned int)DmiTable, (unsigned int)AcpiPstate, (unsigned int)AcpiSrat,
(unsigned int)AcpiSlit, (unsigned int)AcpiWheaMce, (unsigned int)AcpiWheaCmc,
(unsigned int)AcpiAlib, (unsigned int)AcpiIvrs, __func__);
/* AmdReleaseStruct (&AmdParamStruct); */
return Status;
}
AGESA_STATUS agesawrapper_amdinitmid(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_MID_PARAMS *MidParam;
/* Enable MMIO on AMD CPU Address Map Controller */
amd_initcpuio ();
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_MID;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct (&AmdParamStruct);
MidParam = (AMD_MID_PARAMS *)AmdParamStruct.NewStructPtr;
MidParam->GnbMidConfiguration.iGpuVgaMode = 0;/* 0 iGpuVgaAdapter, 1 iGpuVgaNonAdapter; */
MidParam->GnbMidConfiguration.GnbIoapicAddress = 0xFEC20000;
MidParam->FchInterface.AzaliaController = AzEnable;
MidParam->FchInterface.SataClass = CONFIG_HUDSON_SATA_MODE;
MidParam->FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
MidParam->FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
MidParam->FchInterface.SataIdeMode = (CONFIG_HUDSON_SATA_MODE == 3);
status = AmdInitMid ((AMD_MID_PARAMS *)AmdParamStruct.NewStructPtr);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
AmdReleaseStruct (&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitreset(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_RESET_PARAMS AmdResetParams;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
LibAmdMemFill (&AmdResetParams,
0,
sizeof (AMD_RESET_PARAMS),
&(AmdResetParams.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_RESET;
AmdParamStruct.AllocationMethod = ByHost;
AmdParamStruct.NewStructSize = sizeof(AMD_RESET_PARAMS);
AmdParamStruct.NewStructPtr = &AmdResetParams;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct (&AmdParamStruct);
AmdResetParams.FchInterface.Xhci0Enable = IS_ENABLED(CONFIG_HUDSON_XHCI_ENABLE);
if (IS_ENABLED(CONFIG_SOUTHBRIDGE_AMD_PI_BOLTON))
AmdResetParams.FchInterface.Xhci1Enable = TRUE;
AmdResetParams.FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
AmdResetParams.FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
status = AmdInitReset(&AmdResetParams);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
AmdReleaseStruct (&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amds3laterestore(void)
{
AGESA_STATUS Status;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AMD_S3LATE_PARAMS AmdS3LateParams;
AMD_S3LATE_PARAMS *AmdS3LateParamsPtr;
S3_DATA_TYPE S3DataType;
agesawrapper_amdinitcpuio();
LibAmdMemFill (&AmdS3LateParams,
0,
sizeof (AMD_S3LATE_PARAMS),
&(AmdS3LateParams.StdHeader));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.AllocationMethod = ByHost;
AmdInterfaceParams.AgesaFunctionName = AMD_S3LATE_RESTORE;
AmdInterfaceParams.NewStructPtr = &AmdS3LateParams;
AmdInterfaceParams.StdHeader.CalloutPtr = &GetBiosCallout;
AmdS3LateParamsPtr = &AmdS3LateParams;
AmdInterfaceParams.NewStructSize = sizeof (AMD_S3LATE_PARAMS);
AmdCreateStruct (&AmdInterfaceParams);
AmdS3LateParamsPtr->S3DataBlock.VolatileStorageSize = 0;
S3DataType = S3DataTypeVolatile;
OemAgesaGetS3Info (S3DataType,
(u32 *) &AmdS3LateParamsPtr->S3DataBlock.VolatileStorageSize,
(void **) &AmdS3LateParamsPtr->S3DataBlock.VolatileStorage);
Status = AmdS3LateRestore (AmdS3LateParamsPtr);
if (Status != AGESA_SUCCESS) {
agesawrapper_amdreadeventlog(AmdInterfaceParams.StdHeader.HeapStatus);
ASSERT(Status == AGESA_SUCCESS);
}
return Status;
}
AGESA_STATUS agesawrapper_amdinitresume(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_RESUME_PARAMS *AmdResumeParamsPtr;
S3_DATA_TYPE S3DataType;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_RESUME;
AmdParamStruct.AllocationMethod = PreMemHeap;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
AmdCreateStruct (&AmdParamStruct);
AmdResumeParamsPtr = (AMD_RESUME_PARAMS *)AmdParamStruct.NewStructPtr;
AmdResumeParamsPtr->S3DataBlock.NvStorageSize = 0;
AmdResumeParamsPtr->S3DataBlock.VolatileStorageSize = 0;
S3DataType = S3DataTypeNonVolatile;
OemAgesaGetS3Info (S3DataType,
(u32 *) &AmdResumeParamsPtr->S3DataBlock.NvStorageSize,
(void **) &AmdResumeParamsPtr->S3DataBlock.NvStorage);
status = AmdInitResume ((AMD_RESUME_PARAMS *)AmdParamStruct.NewStructPtr);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
AmdReleaseStruct (&AmdParamStruct);
return status;
}
AGESA_STATUS agesawrapper_amdinitenv(void)
{
AGESA_STATUS status;
AMD_INTERFACE_PARAMS AmdParamStruct;
AMD_ENV_PARAMS *EnvParam;
LibAmdMemFill (&AmdParamStruct,
0,
sizeof (AMD_INTERFACE_PARAMS),
&(AmdParamStruct.StdHeader));
AmdParamStruct.AgesaFunctionName = AMD_INIT_ENV;
AmdParamStruct.AllocationMethod = PostMemDram;
AmdParamStruct.StdHeader.AltImageBasePtr = 0;
AmdParamStruct.StdHeader.CalloutPtr = &GetBiosCallout;
AmdParamStruct.StdHeader.Func = 0;
AmdParamStruct.StdHeader.ImageBasePtr = 0;
status = AmdCreateStruct (&AmdParamStruct);
EnvParam = (AMD_ENV_PARAMS *)AmdParamStruct.NewStructPtr;
EnvParam->FchInterface.AzaliaController = AzEnable;
EnvParam->FchInterface.SataClass = CONFIG_HUDSON_SATA_MODE;
EnvParam->FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
EnvParam->FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
EnvParam->FchInterface.SataIdeMode = (CONFIG_HUDSON_SATA_MODE == 3);
EnvParam->GnbEnvConfiguration.IommuSupport = FALSE;
status = AmdInitEnv (EnvParam);
if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(EnvParam->StdHeader.HeapStatus);
/* Initialize Subordinate Bus Number and Secondary Bus Number
* In platform BIOS this address is allocated by PCI enumeration code
Modify D1F0x18
*/
return status;
}
VOID
EFIAPI
AgesaInitRtb (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Do last minute configuration and preparation for system suspend-to-RAM mode.
This function gets called each time the EFI_EVENT_SIGNAL_READY_TO_BOOT gets signaled
Arguments & Return Values: Standard event handling function prototype
--*/
{
EFI_STATUS Status;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AMD_RTB_PARAMS *AmdInitRtbParamsPtr;
AGESA_STATUS AgesaStatus;
S3_DATA_TYPE S3DataType;
//
// Prepare for S3Save
//
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_INIT_RTB;
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
AmdInitRtbParamsPtr = (AMD_RTB_PARAMS *) AmdInterfaceParams.NewStructPtr;
//
// OEM hook to customize any S3 Info required
//
OemCustomizeInitRtb (gBS, AmdInitRtbParamsPtr);
AgesaStatus = AmdInitRtb (AmdInitRtbParamsPtr);
if (AgesaStatus != AGESA_SUCCESS) {
return;
}
if (AmdInitRtbParamsPtr->S3DataBlock.NvStorageSize != 0) {
S3DataType = S3DataTypeNonVolatile;
Status = OemAgesaSaveS3Info (
S3DataType,
AmdInitRtbParamsPtr->S3DataBlock.NvStorageSize,
AmdInitRtbParamsPtr->S3DataBlock.NvStorage
);
}
if (AmdInitRtbParamsPtr->S3DataBlock.VolatileStorageSize != 0) {
S3DataType = S3DataTypeVolatile;
Status = OemAgesaSaveS3Info (
S3DataType,
AmdInitRtbParamsPtr->S3DataBlock.VolatileStorageSize,
AmdInitRtbParamsPtr->S3DataBlock.VolatileStorage
);
}
//
// Close this event to avoid any alternate run
//
gBS->CloseEvent (Event);
}
VOID
EFIAPI
InvokeAmdInitLate (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Invoke AmdinitLate entry point. This function gets called
each time the EFI_EVENT_SIGNAL_READY_TO_BOOT gets signaled
Arguments & Return Values: Standard event handling function prototype
--*/
{
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AGESA_STATUS AgesaStatus;
AMD_DXE_INIT_LATE_PROTOCOL AmdInitLateProtocol;
AMD_AGESA_DXE_PROTOCOL *AmdAgesaDxe;
EFI_HANDLE Handle;
UINTN TableBufferLength;
UINT8 *TableBufferPtr;
EFI_ACPI_TABLE_PROTOCOL *AcpiTable;
UINTN TableKey;
EFI_STATUS Status;
//
// Prepare for AmdInitLate
//
ZeroMem (&AmdInterfaceParams, sizeof (AMD_INTERFACE_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_INIT_LATE;
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
((AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr)->StdHeader = AmdInterfaceParams.StdHeader;
OemCustomizeInitLate (gBS, (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
AgesaStatus = AmdInitLate ((AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
OemHookAfterInitLate (gBS, (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
if ((AgesaStatus == AGESA_CRITICAL) || (AgesaStatus == AGESA_FATAL)) {
return;
}
mAgesaDxePrivate->LateParamsPtr = (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr;
//
// Now Install the AmdDxeInitLateProtocol which helps notify any consumer
// which is depending upon it.
//
AmdInitLateProtocol.Revision = AGESA_DXE_INIT_LATE_REV;
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdDxeInitLateProtocolGuid,
EFI_NATIVE_INTERFACE,
&AmdInitLateProtocol
);
//
// Install the AMD_AGESA_DXE_PROTOCOL to notify OEM to override default value
//
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdAgesaDxeProtocolGuid,
EFI_NATIVE_INTERFACE,
&mAgesaDxePrivate->CpuInterface
);
//Publish ACPI TABLES.
(UINT8*)TableBufferPtr = NULL;
TableKey = NULL;
AcpiTable = NULL;
AmdAgesaDxe = NULL;
//By default PCD is set to FALSE. Before Enabling PCD make sure to disable publishing of ACPI Tables by IBVs to avoid conflict.
if (PcdGetBool (PcdPublishAgesaAcpiTable)) {
Status = gBS->LocateProtocol (
&gAcpiTableProtocolGuid,
NULL,
&AcpiTable
);
ASSERT_EFI_ERROR (Status);
//-PSTATE
TableBufferLength = 0;
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiPstateType, &TableBufferLength, &TableBufferPtr); //First get the buffer size needed for the table.
if (TableBufferLength != 0 ) {
TableBufferPtr = AllocateZeroPool (TableBufferLength);
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiPstateType, &TableBufferLength, &TableBufferPtr);
Status = AcpiTable->InstallAcpiTable (AcpiTable, TableBufferPtr, TableBufferLength, &TableKey);
FreePool (TableBufferPtr);
}
//-Crat
TableBufferLength = 0;
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiCratType, &TableBufferLength, &TableBufferPtr); //First get the buffer size needed for the table.
if (TableBufferLength != 0 ) {
TableBufferPtr = AllocateZeroPool (TableBufferLength);
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiCratType, &TableBufferLength, &TableBufferPtr);
Status = AcpiTable->InstallAcpiTable (AcpiTable, TableBufferPtr, TableBufferLength, &TableKey);
FreePool (TableBufferPtr);
}
//-Cdit
TableBufferLength = 0;
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiCditType, &TableBufferLength, &TableBufferPtr); //First get the buffer size needed for the table.
if (TableBufferLength != 0 ) {
TableBufferPtr = AllocateZeroPool (TableBufferLength);
mAgesaDxePrivate->CpuInterface.CreateProcessorTables (AmdAgesaDxe, AcpiCditType, &TableBufferLength, &TableBufferPtr);
Status = AcpiTable->InstallAcpiTable (AcpiTable, TableBufferPtr, TableBufferLength, &TableKey);
FreePool (TableBufferPtr);
}
}
return;
}
VOID
EFIAPI
InvokeAmdInitLate (
IN EFI_EVENT Event,
IN VOID *Context
)
/*++
Routine Description:
Invoke AmdinitLate entry point. This function gets called
each time the EFI_EVENT_SIGNAL_READY_TO_BOOT gets signaled
Arguments & Return Values: Standard event handling function prototype
--*/
{
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AGESA_STATUS AgesaStatus;
AMD_DXE_INIT_LATE_PROTOCOL AmdInitLateProtocol;
EFI_HANDLE Handle;
//
// Prepare for AmdInitLate
//
EfiZeroMem (&AmdInterfaceParams, sizeof (AMD_INTERFACE_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.AllocationMethod = PostMemDram;
AmdInterfaceParams.AgesaFunctionName = AMD_INIT_LATE;
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
((AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr)->StdHeader = AmdInterfaceParams.StdHeader;
OemCustomizeInitLate (gBS, (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
AgesaStatus = AmdInitLate ((AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
OemHookAfterInitLate (gBS, (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr);
if ((AgesaStatus == AGESA_CRITICAL) || (AgesaStatus == AGESA_FATAL)) {
return;
}
mAgesaDxePrivate->LateParamsPtr = (AMD_LATE_PARAMS *)AmdInterfaceParams.NewStructPtr;
//
// Now Install the AmdDxeInitLateProtocol which helps notify any consumer
// which is depending upon it.
//
AmdInitLateProtocol.Revision = AGESA_DXE_INIT_LATE_REV;
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdDxeInitLateProtocolGuid,
EFI_NATIVE_INTERFACE,
&AmdInitLateProtocol
);
//
// Install the AMD_AGESA_DXE_PROTOCOL to notify OEM to override default value
//
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdAgesaDxeProtocolGuid,
EFI_NATIVE_INTERFACE,
&mAgesaDxePrivate->CpuInterface
);
//
// Install AgesaDxeMiscellaneous Protocol
//
Handle = NULL;
gBS->CopyMem (
&mAgesaDxePrivate->AgesaMiscServices.StdHeader,
&AmdInterfaceParams.StdHeader,
sizeof (AMD_CONFIG_PARAMS)
);
mAgesaDxePrivate->AgesaMiscServices.GetDimmInfo = AgesaGetDimmInfo;
gBS->InstallProtocolInterface (
&Handle,
&gAmdAgesaDxeMiscServicesProtocolGuid,
EFI_NATIVE_INTERFACE,
&mAgesaDxePrivate->AgesaMiscServices
);
return;
}
EFI_STATUS
EFIAPI
AgesaDxeDriverEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
AMD_INTERFACE_PARAMS AmdInterfaceParams;
AGESA_STATUS AgesaStatus;
AMD_ENV_PARAMS AmdInitEnvParams;
EFI_EVENT ReadyToBootEvent;
EFI_HANDLE Handle;
AMD_BUFFER_MANAGER_PROTOCOL *BufferMgr;
//
// Initialize Global Variable
//
//
// Initialize the configuration structure and private data area
//
// Allocate memory for the private data
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (AGESA_DXE_PRIVATE_DATA),
&mAgesaDxePrivate);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Install the AMD_AGESA_MMIO_PROTOCOL
//
mAgesaDxePrivate->MmioMapManager.AmdMmioMapManager = AmdMmioMapManager;
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdAgesaMmioProtocolGuid,
EFI_NATIVE_INTERFACE,
&mAgesaDxePrivate->MmioMapManager
);
//
// Initialize the private data structure
//
mAgesaDxePrivate->Signature = AGESA_DXE_PRIVATE_DATA_SIGNATURE;
//
// Create the first buffer for AGESA_ALLOCATE_BUFFER Manager
//
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (AGESA_DXE_BUFFER_MANAGER),
&mAgesaDxePrivate->BufferManagerPtr
);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR (Status)) {
return Status;
}
ZeroMem (mAgesaDxePrivate->BufferManagerPtr, sizeof (AGESA_DXE_BUFFER_MANAGER));
mAgesaDxePrivate->BufferManagerPtr->NextAgesaBufferManagerPtr = NULL;
AgesaBufferManager = mAgesaDxePrivate->BufferManagerPtr;
//
// Rebuild persist heap from HOB.
//
Status = RebuildHeap (&mAgesaDxePrivate->HeapManagerPtr);
if (EFI_ERROR (Status)) {
return EFI_OUT_OF_RESOURCES;
}
//
// Invoke AmdInitEnv
//
ZeroMem (&AmdInterfaceParams, sizeof (AMD_INTERFACE_PARAMS));
ZeroMem (&AmdInitEnvParams, sizeof (AMD_ENV_PARAMS));
AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
AmdInterfaceParams.AllocationMethod = ByHost;
AmdInterfaceParams.AgesaFunctionName = AMD_INIT_ENV;
AmdInterfaceParams.NewStructPtr = &AmdInitEnvParams;
AmdInterfaceParams.NewStructSize = sizeof (AMD_ENV_PARAMS);
AgesaStatus = AmdCreateStruct (&AmdInterfaceParams);
AmdInitEnvParams.StdHeader = AmdInterfaceParams.StdHeader;
OemCustomizeInitEnv (gBS, &AmdInitEnvParams);
AgesaStatus = AmdInitEnv (&AmdInitEnvParams);
OemHookAfterInitEnv (gBS, &AmdInitEnvParams);
if ((AgesaStatus == AGESA_CRITICAL) || (AgesaStatus == AGESA_FATAL)) {
return EFI_DEVICE_ERROR;
}
//
// Install AmdBufferManagerProtocol which notifies other dependent drivers
//
Status = gBS->AllocatePool (
EfiBootServicesData,
sizeof (AMD_BUFFER_MANAGER_PROTOCOL),
&BufferMgr
);
ASSERT_EFI_ERROR (Status);
BufferMgr->StdHeader = AmdInitEnvParams.StdHeader;
BufferMgr->DxeBufferManager = mAgesaDxePrivate->BufferManagerPtr;
BufferMgr->AmdBufferCallout = AgesaDxeCallout;
Handle = NULL;
gBS->InstallProtocolInterface (
&Handle,
&gAmdBufferManagerProtocolGuid,
EFI_NATIVE_INTERFACE,
BufferMgr
);
//
// Register the event handling function for AmdInitMid to be launched after
// PciIo protocol
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
InvokeAmdInitMid,
NULL,
&PciIoProtocolInstallEventGuid,
&PciIoEvent
);
Status = gBS->RegisterProtocolNotify (
&gEfiPciIoProtocolGuid,
PciIoEvent,
&mRegistrationForPciIo
);
//
// Set up call back for AmdInitLate after AmdInitMid has been launched.
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
InvokeAmdInitLate,
NULL,
&AmdInitMidProtocolInstallEventGuid,
&AmdInitMidEvent
);
Status = gBS->RegisterProtocolNotify (
&gAmdDxeInitMidProtocolGuid,
AmdInitMidEvent,
&(mRegistrationForAmdInitMid)
);
//
// Initialize AMD CPU Interface protocol
//
mAgesaDxePrivate->CpuInterface.CreateProcessorTables = AmdCpuCreateProcessorTables;
// S3 Interface
// Register the event handling function to produce
// resulting Smbios image.
//
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
AgesaInitRtb,
NULL,
&gEfiEventReadyToBootGuid,
&ReadyToBootEvent
);
return EFI_SUCCESS;
}
