本文整理汇总了C++中LibAmdMemFill函数的典型用法代码示例。如果您正苦于以下问题:C++ LibAmdMemFill函数的具体用法?C++ LibAmdMemFill怎么用?C++ LibAmdMemFill使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了LibAmdMemFill函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: OemCustomizeInitEarly
/*---------------------------------------------------------------------------------------*/
VOID
OemCustomizeInitEarly (
IN OUT AMD_EARLY_PARAMS *InitEarly
)
{
AGESA_STATUS Status;
VOID *TrinityPcieComplexListPtr;
VOID *TrinityPciePortPtr;
VOID *TrinityPcieDdiPtr;
ALLOCATE_HEAP_PARAMS AllocHeapParams;
// GNB PCIe topology Porting
//
// Allocate buffer for PCIe_COMPLEX_DESCRIPTOR , PCIe_PORT_DESCRIPTOR and PCIe_DDI_DESCRIPTOR
//
AllocHeapParams.RequestedBufferSize = sizeof(Trinity) + sizeof(PortList) + sizeof(DdiList);
AllocHeapParams.BufferHandle = AMD_MEM_MISC_HANDLES_START;
AllocHeapParams.Persist = HEAP_LOCAL_CACHE;
Status = HeapAllocateBuffer (&AllocHeapParams, &InitEarly->StdHeader);
if ( Status!= AGESA_SUCCESS) {
// Could not allocate buffer for PCIe_COMPLEX_DESCRIPTOR , PCIe_PORT_DESCRIPTOR and PCIe_DDI_DESCRIPTOR
ASSERT(FALSE);
return;
}
TrinityPcieComplexListPtr = (PCIe_COMPLEX_DESCRIPTOR *) AllocHeapParams.BufferPtr;
AllocHeapParams.BufferPtr += sizeof(Trinity);
TrinityPciePortPtr = (PCIe_PORT_DESCRIPTOR *)AllocHeapParams.BufferPtr;
AllocHeapParams.BufferPtr += sizeof(PortList);
TrinityPcieDdiPtr = (PCIe_DDI_DESCRIPTOR *) AllocHeapParams.BufferPtr;
LibAmdMemFill (TrinityPcieComplexListPtr,
0,
sizeof(Trinity),
&InitEarly->StdHeader);
LibAmdMemFill (TrinityPciePortPtr,
0,
sizeof(PortList),
&InitEarly->StdHeader);
LibAmdMemFill (TrinityPcieDdiPtr,
0,
sizeof(DdiList),
&InitEarly->StdHeader);
LibAmdMemCopy (TrinityPcieComplexListPtr, &Trinity, sizeof(Trinity), &InitEarly->StdHeader);
LibAmdMemCopy (TrinityPciePortPtr, &PortList[0], sizeof(PortList), &InitEarly->StdHeader);
LibAmdMemCopy (TrinityPcieDdiPtr, &DdiList[0], sizeof(DdiList), &InitEarly->StdHeader);
((PCIe_COMPLEX_DESCRIPTOR*)TrinityPcieComplexListPtr)->PciePortList = (PCIe_PORT_DESCRIPTOR*)TrinityPciePortPtr;
((PCIe_COMPLEX_DESCRIPTOR*)TrinityPcieComplexListPtr)->DdiLinkList = (PCIe_DDI_DESCRIPTOR*)TrinityPcieDdiPtr;
InitEarly->GnbConfig.PcieComplexList = TrinityPcieComplexListPtr;
}
示例2: OemInitEarly
static AGESA_STATUS OemInitEarly(AMD_EARLY_PARAMS * InitEarly)
{
AGESA_STATUS Status;
VOID *LlanoPcieComplexListPtr;
VOID *LlanoPciePortPtr;
VOID *LlanoPcieDdiPtr;
ALLOCATE_HEAP_PARAMS AllocHeapParams;
// GNB PCIe topology Porting
//
// Allocate buffer for PCIe_COMPLEX_DESCRIPTOR , PCIe_PORT_DESCRIPTOR and PCIe_DDI_DESCRIPTOR
//
AllocHeapParams.RequestedBufferSize = sizeof(Llano) + sizeof(PortList) + sizeof(DdiList);
AllocHeapParams.BufferHandle = AMD_MEM_MISC_HANDLES_START;
AllocHeapParams.Persist = HEAP_LOCAL_CACHE;
Status = HeapAllocateBuffer (&AllocHeapParams, &InitEarly->StdHeader);
ASSERT(Status == AGESA_SUCCESS);
LlanoPcieComplexListPtr = (PCIe_COMPLEX_DESCRIPTOR *) AllocHeapParams.BufferPtr;
AllocHeapParams.BufferPtr += sizeof(Llano);
LlanoPciePortPtr = (PCIe_PORT_DESCRIPTOR *)AllocHeapParams.BufferPtr;
AllocHeapParams.BufferPtr += sizeof(PortList);
LlanoPcieDdiPtr = (PCIe_DDI_DESCRIPTOR *) AllocHeapParams.BufferPtr;
LibAmdMemFill (LlanoPcieComplexListPtr,
0,
sizeof(Llano),
&InitEarly->StdHeader);
LibAmdMemFill (LlanoPciePortPtr,
0,
sizeof(PortList),
&InitEarly->StdHeader);
LibAmdMemFill (LlanoPcieDdiPtr,
0,
sizeof(DdiList),
&InitEarly->StdHeader);
LibAmdMemCopy (LlanoPcieComplexListPtr, &Llano, sizeof(Llano), &InitEarly->StdHeader);
LibAmdMemCopy (LlanoPciePortPtr, &PortList[0], sizeof(PortList), &InitEarly->StdHeader);
LibAmdMemCopy (LlanoPcieDdiPtr, &DdiList[0], sizeof(DdiList), &InitEarly->StdHeader);
((PCIe_COMPLEX_DESCRIPTOR*)LlanoPcieComplexListPtr)->PciePortList = (PCIe_PORT_DESCRIPTOR*)LlanoPciePortPtr;
((PCIe_COMPLEX_DESCRIPTOR*)LlanoPcieComplexListPtr)->DdiLinkList = (PCIe_DDI_DESCRIPTOR*)LlanoPcieDdiPtr;
InitEarly->GnbConfig.PcieComplexList = LlanoPcieComplexListPtr;
InitEarly->GnbConfig.PsppPolicy = 0;
return AGESA_SUCCESS;
}
示例3: GfxInitAtPost
AGESA_STATUS
GfxInitAtPost (
IN AMD_CONFIG_PARAMS *StdHeader
)
{
AMD_POST_PARAMS *PostParamsPtr;
GFX_CARD_CARD_INFO GfxDiscreteCardInfo;
AGESA_STATUS Status;
GFX_PLATFORM_CONFIG *Gfx;
PostParamsPtr = (AMD_POST_PARAMS *)StdHeader;
IDS_HDT_CONSOLE (GNB_TRACE, "GfxInitAtPost Enter\n");
Status = GfxLocateConfigData (StdHeader, &Gfx);
ASSERT (Status == AGESA_SUCCESS);
if (Status == AGESA_SUCCESS) {
if (GfxLibIsControllerPresent (StdHeader)) {
if (PostParamsPtr->MemConfig.UmaMode != UMA_NONE) {
LibAmdMemFill (&GfxDiscreteCardInfo, 0x0, sizeof (GfxDiscreteCardInfo), StdHeader);
GfxGetDiscreteCardInfo (&GfxDiscreteCardInfo, StdHeader);
if (GfxDiscreteCardInfo.PciGfxCardBitmap != 0 ||
(GfxDiscreteCardInfo.AmdPcieGfxCardBitmap & GfxDiscreteCardInfo.PcieGfxCardBitmap) !=
GfxDiscreteCardInfo.AmdPcieGfxCardBitmap) {
PostParamsPtr->MemConfig.UmaMode = UMA_NONE;
IDS_HDT_CONSOLE (GFX_MISC, " GfxDisabled due dGPU policy\n");
}
}
} else {
PostParamsPtr->MemConfig.UmaMode = UMA_NONE;
Gfx->GfxFusedOff = TRUE;
}
} else {
PostParamsPtr->MemConfig.UmaMode = UMA_NONE;
}
IDS_HDT_CONSOLE (GNB_TRACE, "GfxInitAtPost Exit [0x%x]\n", Status);
return Status;
}
示例4: NotifyFatalCohMpCapMismatch
/**
* For event HT_EVENT_COH_MPCAP_MISMATCH
*
* @param[in] Node The node from which a new node was discovered
* @param[in] Link The link from that node
* @param[in] Cap The aggregate system MP Capability
* @param[in] Nodes The total number of nodes found so far
* @param[in] State our State
*
*/
VOID
NotifyFatalCohMpCapMismatch (
IN UINT8 Node,
IN UINT8 Link,
IN UINT8 Cap,
IN UINT8 Nodes,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_COH_MP_CAP_MISMATCH Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.Node = Node;
Evt.Link = Link;
Evt.SysMpCap = Cap;
Evt.TotalNodes = Nodes;
setEventNotify (AGESA_CRITICAL,
HT_EVENT_COH_MPCAP_MISMATCH,
(UINT8 *)&Evt, State);
}
示例5: NotifyInfoCohNodeDiscovered
/**
* For event HT_EVENT_COH_NODE_DISCOVERED
*
* @param[in] Node Node from which a new node was discovered
* @param[in] Link The link to that new node
* @param[in] NewNode The new node's id
* @param[in] TempRoute Temporarily, during discovery, the new node is accessed at this id.
* @param[in] State our State
*
*/
VOID
NotifyInfoCohNodeDiscovered (
IN UINT8 Node,
IN UINT8 Link,
IN UINT8 NewNode,
IN UINT8 TempRoute,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_COH_NODE_DISCOVERED Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.Node = Node;
Evt.Link = Link;
Evt.NewNode = NewNode;
Evt.TempRoute = TempRoute;
setEventNotify (AGESA_SUCCESS,
HT_EVENT_COH_NODE_DISCOVERED,
(UINT8 *)&Evt, State);
}
示例6: NotifyWarningOptLinkPairExceed
/**
* For event HT_EVENT_OPT_LINK_PAIR_EXCEED
*
* @param[in] NodeA One of the nodes connected
* @param[in] NodeB The other connected node
* @param[in] MasterLink its unusable Masterlink
* @param[in] AltLink its unusable Alternate link
* @param[in] State our State
*
*/
VOID
NotifyWarningOptLinkPairExceed (
IN UINT32 NodeA,
IN UINT32 NodeB,
IN UINT32 MasterLink,
IN UINT32 AltLink,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_OPT_LINK_PAIR_EXCEED Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.NodeA = NodeA;
Evt.MasterLink = MasterLink;
Evt.NodeB = NodeB;
Evt.AltLink = AltLink;
setEventNotify (AGESA_WARNING,
HT_EVENT_OPT_LINK_PAIR_EXCEED,
(UINT8 *)&Evt, State);
}
示例7: NotifyWarningOptUnusedLinks
/**
* For event HT_EVENT_OPT_UNUSED_LINKS
*
* @param[in] NodeA One of the nodes connected
* @param[in] NodeB The other connected node
* @param[in] LinkA its unusable link
* @param[in] LinkB its unusable link
* @param[in] State our State
*
*/
VOID
NotifyWarningOptUnusedLinks (
IN UINT32 NodeA,
IN UINT32 LinkA,
IN UINT32 NodeB,
IN UINT32 LinkB,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_OPT_UNUSED_LINKS Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.NodeA = NodeA;
Evt.LinkA = LinkA;
Evt.NodeB = NodeB;
Evt.LinkB = LinkB;
setEventNotify (AGESA_WARNING,
HT_EVENT_OPT_UNUSED_LINKS,
(UINT8 *)&Evt, State);
}
示例8: NotifyErrorNcohDeviceFailed
/**
* For event HT_EVENT_NCOH_DEVICE_FAILED
*
* @param[in] Node The node on which the chain is located
* @param[in] Link The link from that node
* @param[in] Depth Position on chain
* @param[in] Id The Id which was attempted to assigned
* @param[in] State our State
*
*/
VOID
NotifyErrorNcohDeviceFailed (
IN UINT8 Node,
IN UINT8 Link,
IN UINT8 Depth,
IN UINT8 Id,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_NCOH_DEVICE_FAILED Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.Node = Node;
Evt.Link = Link;
Evt.Depth = Depth;
Evt.AttemptedBuid = Id;
setEventNotify (AGESA_ERROR,
HT_EVENT_NCOH_DEVICE_FAILED,
(UINT8 *)&Evt, State);
}
示例9: NotifyErrorNcohBuidExceed
/**
* For event HT_EVENT_NCOH_BUID_EXCEED
*
* @param[in] Node The node on which the chain is located
* @param[in] Link The link from that node
* @param[in] Depth Position on chain
* @param[in] Id The Id which was attempted to assigned
* @param[in] Units The number of units in this device
* @param[in] State our State
*
*/
VOID
NotifyErrorNcohBuidExceed (
IN UINT8 Node,
IN UINT8 Link,
IN UINT8 Depth,
IN UINT8 Id,
IN UINT8 Units,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_NCOH_BUID_EXCEED Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
Evt.Node = Node;
Evt.Link = Link;
Evt.Depth = Depth;
Evt.CurrentBuid = Id;
Evt.UnitCount = Units;
setEventNotify (AGESA_ERROR,
HT_EVENT_NCOH_BUID_EXCEED,
(UINT8 *)&Evt, State);
}
示例10: OemInitEarly
static AGESA_STATUS OemInitEarly(AMD_EARLY_PARAMS * InitEarly)
{
AGESA_STATUS Status;
PCIe_COMPLEX_DESCRIPTOR *PcieComplexListPtr;
ALLOCATE_HEAP_PARAMS AllocHeapParams;
/* GNB PCIe topology Porting */
/* */
/* Allocate buffer for PCIe_COMPLEX_DESCRIPTOR , PCIe_PORT_DESCRIPTOR and PCIe_DDI_DESCRIPTOR */
/* */
AllocHeapParams.RequestedBufferSize = sizeof(PCIe_COMPLEX_DESCRIPTOR);
AllocHeapParams.BufferHandle = AMD_MEM_MISC_HANDLES_START;
AllocHeapParams.Persist = HEAP_LOCAL_CACHE;
Status = HeapAllocateBuffer (&AllocHeapParams, &InitEarly->StdHeader);
ASSERT(Status == AGESA_SUCCESS);
PcieComplexListPtr = (PCIe_COMPLEX_DESCRIPTOR *) AllocHeapParams.BufferPtr;
LibAmdMemFill (PcieComplexListPtr,
0,
sizeof(PCIe_COMPLEX_DESCRIPTOR),
&InitEarly->StdHeader);
PcieComplexListPtr->Flags = DESCRIPTOR_TERMINATE_LIST;
PcieComplexListPtr->SocketId = 0;
PcieComplexListPtr->PciePortList = PortList;
PcieComplexListPtr->DdiLinkList = DdiList;
InitEarly->GnbConfig.PcieComplexList = PcieComplexListPtr;
return AGESA_SUCCESS;
}
示例11: NotifyFatalCohProcessorTypeMix
/**
* For event HT_EVENT_COH_PROCESSOR_TYPE_MIX
*
* @param[in] Node The node from which a new node was discovered
* @param[in] Link The link from that node
* @param[in] Nodes The total number of nodes found so far
* @param[in] State our State
*
*/
VOID
NotifyFatalCohProcessorTypeMix (
IN UINT8 Node,
IN UINT8 Link,
IN UINT8 Nodes,
IN STATE_DATA *State
)
{
HT_EVENT_DATA_COH_PROCESSOR_TYPE_MIX Evt;
// Zero out the event data
LibAmdMemFill (
&Evt,
0,
(sizeof(UINT32) * NUMBER_OF_EVENT_DATA_PARAMS),
State->ConfigHandle
);
IDS_HDT_CONSOLE (HT_TRACE, "Illegal Processor Type Mix.\n");
Evt.Node = Node;
Evt.Link = Link;
Evt.TotalNodes = Nodes;
setEventNotify (AGESA_CRITICAL,
HT_EVENT_COH_PROCESSOR_TYPE_MIX,
(UINT8 *)&Evt, State);
}
示例12: FeatureLeveling
/**
*
* FeatureLeveling
*
* CPU feature leveling. Set least common features set of all CPUs
*
* @param[in,out] StdHeader - Pointer to AMD_CONFIG_PARAMS struct.
*
*/
VOID
FeatureLeveling (
IN OUT AMD_CONFIG_PARAMS *StdHeader
)
{
UINT32 BscSocket;
UINT32 Ignored;
UINT32 BscCoreNum;
UINT32 Socket;
UINT32 Core;
UINT32 NumberOfSockets;
UINT32 NumberOfCores;
BOOLEAN *FirstTime;
BOOLEAN *NeedLeveling;
AGESA_STATUS IgnoredSts;
CPU_FEATURES_LIST *globalCpuFeatureList;
AP_TASK TaskPtr;
ASSERT (IsBsp (StdHeader, &IgnoredSts));
GetGlobalCpuFeatureListAddress ((UINT64 **) &globalCpuFeatureList, StdHeader);
FirstTime = (BOOLEAN *) ((UINT8 *) globalCpuFeatureList + sizeof (CPU_FEATURES_LIST));
NeedLeveling = (BOOLEAN *) ((UINT8 *) globalCpuFeatureList + sizeof (CPU_FEATURES_LIST) + sizeof (BOOLEAN));
*FirstTime = TRUE;
*NeedLeveling = FALSE;
LibAmdMemFill (globalCpuFeatureList, 0xFF, sizeof (CPU_FEATURES_LIST), StdHeader);
IdentifyCore (StdHeader, &BscSocket, &Ignored, &BscCoreNum, &IgnoredSts);
NumberOfSockets = GetPlatformNumberOfSockets ();
TaskPtr.FuncAddress.PfApTaskI = SaveFeatures;
TaskPtr.DataTransfer.DataSizeInDwords = SIZE_IN_DWORDS (CPU_FEATURES_LIST);
TaskPtr.ExeFlags = WAIT_FOR_CORE;
TaskPtr.DataTransfer.DataPtr = globalCpuFeatureList;
TaskPtr.DataTransfer.DataTransferFlags = DATA_IN_MEMORY;
for (Socket = 0; Socket < NumberOfSockets; Socket++) {
if (IsProcessorPresent (Socket, StdHeader)) {
if (Socket != BscSocket) {
ApUtilRunCodeOnSocketCore ((UINT8)Socket, 0, &TaskPtr, StdHeader);
}
}
}
ApUtilTaskOnExecutingCore (&TaskPtr, StdHeader, NULL);
if (*NeedLeveling) {
TaskPtr.FuncAddress.PfApTaskI = WriteFeatures;
for (Socket = 0; Socket < NumberOfSockets; Socket++) {
if (GetActiveCoresInGivenSocket (Socket, &NumberOfCores, StdHeader)) {
for (Core = 0; Core < NumberOfCores; Core++) {
if ((Socket != BscSocket) || (Core != BscCoreNum)) {
ApUtilRunCodeOnSocketCore ((UINT8)Socket, (UINT8)Core, &TaskPtr, StdHeader);
}
}
}
}
ApUtilTaskOnExecutingCore (&TaskPtr, StdHeader, NULL);
}
}
示例13: PcieTopologyIsGen3SupportedV5
BOOLEAN
PcieTopologyIsGen3SupportedV5 (
IN PCIe_WRAPPER_CONFIG *Wrapper
)
{
UINT8 LaneNibbleArray [4];
UINT32 LaneBitmap;
UINT8 Nibble;
UINT8 NibbleBitmap;
PCIe_ENGINE_CONFIG *Engine;
LibAmdMemFill (&LaneNibbleArray[0], 0x00, sizeof (LaneNibbleArray), PcieConfigGetStdHeader (Wrapper));
Engine = PcieConfigGetChildEngine (Wrapper);
while (Engine != NULL) {
LaneBitmap = PcieUtilGetEngineLaneBitMap (LANE_TYPE_PCIE_PHY_NATIVE, 0, Engine);
for (Nibble = 0; Nibble < 4; Nibble++) {
NibbleBitmap = (0xF << (Nibble * 4));
if ((LaneBitmap & NibbleBitmap) != 0) {
if (++LaneNibbleArray [Nibble] > 1) {
return FALSE;
}
}
}
Engine = PcieLibGetNextDescriptor (Engine);
}
return TRUE;
}
示例14: agesawrapper_amdinitearly
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;
}
示例15: agesawrapper_amdlaterunaptask
AGESA_STATUS agesawrapper_amdlaterunaptask (
UINT32 Func,
UINT32 Data,
VOID *ConfigPtr
)
{
AGESA_STATUS Status;
AP_EXE_PARAMS ApExeParams;
LibAmdMemFill (&ApExeParams,
0,
sizeof (AP_EXE_PARAMS),
&(ApExeParams.StdHeader));
ApExeParams.StdHeader.AltImageBasePtr = 0;
ApExeParams.StdHeader.CalloutPtr = &GetBiosCallout;
ApExeParams.StdHeader.Func = 0;
ApExeParams.StdHeader.ImageBasePtr = 0;
ApExeParams.FunctionNumber = Func;
ApExeParams.RelatedDataBlock = ConfigPtr;
Status = AmdLateRunApTask (&ApExeParams);
if (Status != AGESA_SUCCESS) {
/* agesawrapper_amdreadeventlog(); */
ASSERT(Status == AGESA_SUCCESS);
}
return Status;
}