--- /dev/null
+/**
+ * @file
+ *
+ * AMD Integrated Debug Debug_library Routines
+ *
+ * Contains AMD AGESA debug macros and library functions
+ *
+ * @xrefitem bom "File Content Label" "Release Content"
+ * @e project: AGESA
+ * @e sub-project: IDS
+ * @e \$Revision: 44323 $ @e \$Date: 2010-12-22 01:24:58 -0700 (Wed, 22 Dec 2010) $
+ */
+/*****************************************************************************
+ * Copyright (c) 2011, Advanced Micro Devices, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Advanced Micro Devices, Inc. nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ******************************************************************************
+ */
+
+ /*----------------------------------------------------------------------------------------
+ * M O D U L E S U S E D
+ *----------------------------------------------------------------------------------------
+ */
+#include "AGESA.h"
+#include "Ids.h"
+#include "IdsLib.h"
+#include "amdlib.h"
+#include "AMD.h"
+#include "heapManager.h"
+#include "cpuRegisters.h"
+#include "Filecode.h"
+#define FILECODE PROC_IDS_DEBUG_IDSDEBUG_FILECODE
+
+extern BUILD_OPT_CFG UserOptions;
+typedef struct _IDS_CONSOLE IDS_CONSOLE;
+
+/*--------------------------------------------------------------------------------------*/
+/**
+ * IDS back-end code for AGESA_TESTPOINT
+ *
+ * @param[in] TestPoint Progress indicator value, see @ref AGESA_TP
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ *
+ **/
+/*--------------------------------------------------------------------------------------*/
+VOID
+IdsAgesaTestPoint (
+ IN AGESA_TP TestPoint,
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ LibAmdIoWrite (AccessWidth8, IDS_DEBUG_PORT, &TestPoint, StdHeader);
+ IDS_PERF_TIMESTAMP (StdHeader, TestPoint);
+ if (TestPoint == EndAgesaTps) {
+ IDS_PERF_ANALYSE (StdHeader);
+ }
+}
+
+#define DEBUG_PRINT_INIT 0x10BF0000
+#define DEBUG_PRINT_EXIT 0xE0BF0000
+#define DEBUG_PRINT_COMMAND 0xC0BF0000
+#define DEBUG_PRINT_BREAKPOINT 0xB0BF0000
+#define DEBUG_PRINT_EVENT 0x1EBF0000
+
+#define IDS_HDTOUT_BPFLAG_FORMAT_STR 0
+#define IDS_HDTOUT_BPFLAG_STATUS_STR 1
+
+#define HDTOUT_BP_ACTION_HALT 1
+#define HDTOUT_BP_ACTION_PRINTON 2
+#define HDTOUT_BP_ACTION_PRINTONE 3
+#define HDTOUT_BP_ACTION_PRINTOFF 4
+
+typedef struct _BREAKPOINT_UNIT {
+ UINT8 AndFlag : 1; ///< Next string is ANDed to current string
+ UINT8 BpFlag : 1; ///< Format string or Status string
+ UINT8 Action : 4; ///< Halt, start HDTOUT, or stop HDT,...
+ UINT8 BpStrOffset; ///< Offset from BreakpointList to the breakpoint string
+} BREAKPOINT_UNIT;
+
+typedef enum {
+ IDS_STATE_OFF = 0xF0,
+ IDS_STATE_ON
+} IDS_STATE_TYPE;
+
+typedef enum {
+ NON_CONSOLE = 0xD0,
+ HDT_CONSOLE,
+ IDS_CONSOLE_END
+} IDS_CONSOLE_TYPE;
+
+// IDS HdtOut Event Level
+typedef enum {
+ EVENT_OFF = 0x30, ///< Default,no event triggered.
+ EVENT_WARNING, ///< Event warning.
+ EVENT_ERROR, ///< Event error.
+ EVENT_FAIL_BUFFER_ALLOCATION, ///< Reserved, fail buffer allocation
+ EVENT_END ///< Event end sentinel.
+} CONSOLE_EVENT_TYPE;
+
+#define _INT_SIZE_OF(n) ((sizeof (n) + sizeof (UINTN) - 1) &~(sizeof (UINTN) - 1))
+
+//
+// Also support coding convention rules for var arg macros
+//
+typedef CHAR8 *VA_LIST;
+#define VA_START(ap, v) (ap = (VA_LIST) & (v) + _INT_SIZE_OF (v))
+#define VA_ARG(ap, t) (*(t *) ((ap += _INT_SIZE_OF (t)) - _INT_SIZE_OF (t)))
+#define VA_END(ap) (ap = (VA_LIST) 0)
+
+#define LEFT_JUSTIFY 0x01
+#define PREFIX_SIGN 0x02
+#define PREFIX_BLANK 0x04
+#define COMMA_TYPE 0x08
+#define LONG_TYPE 0x10
+#define PREFIX_ZERO 0x20
+
+/**
+ * Create console context
+ *
+ * Do hardware settings related with specific console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_CREATE_CONSOLE_CONTEXT (
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_CREATE_CONSOLE_CONTEXT *PF_CREATE_CONSOLE_CONTEXT;
+
+/**
+ * Initialize console context
+ *
+ * Initilize preference settings related with specific console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_INIT_CONSOLE_CONTEXT (
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_INIT_CONSOLE_CONTEXT *PF_INIT_CONSOLE_CONTEXT;
+
+/**
+ * Update console context
+ *
+ * Update preference settings related with specific console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_UPDATE_CONSOLE_CONTEXT (
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_UPDATE_CONSOLE_CONTEXT *PF_UPDATE_CONSOLE_CONTEXT;
+
+/**
+ * Save console context
+ *
+ * Save console context snapshot
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_SAVE_CONSOLE_CONTEXT (
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_SAVE_CONSOLE_CONTEXT *PF_SAVE_CONSOLE_CONTEXT;
+
+/**
+ * Destroy console context
+ *
+ * Destroy console context snapshot
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_DESTROY_CONSOLE_CONTEXT (
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_DESTROY_CONSOLE_CONTEXT *PF_DESTROY_CONSOLE_CONTEXT;
+
+/**
+ * Print function
+ *
+ * Print function related with specific console
+ *
+ * @param[in] PrintType Print Type
+ * @param[in] ConsoleBufferAddress The address of console buffer
+ * @param[in] ConsoleBufferSize The size of console buffer
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+typedef VOID F_PRINT (
+ IN UINT32 PrintType,
+ IN UINT32 ConsoleBufferAddress,
+ IN UINT32 ConsoleBufferSize,
+ IN OUT IDS_CONSOLE *IdsConsole
+ );
+/// Reference to a method.
+typedef F_PRINT *PF_PRINT;
+
+/// IDS Console Operations
+typedef struct _IDS_CONSOLE_OPERATIONS {
+ PF_CREATE_CONSOLE_CONTEXT CreateConsoleContext;
+ PF_INIT_CONSOLE_CONTEXT InitConsoleContext;
+ PF_UPDATE_CONSOLE_CONTEXT UpdateConsoleContext;
+ PF_DESTROY_CONSOLE_CONTEXT DestroyConsoleContext;
+ PF_PRINT Print;
+} IDS_CONSOLE_OPERATIONS;
+
+/// IDS Console Header
+typedef struct _IDS_CONSOLE_HEADER {
+ UINT32 Signature; ///< Signature information.
+ UINT32 Version; ///< Version.
+ UINT8 ConsoleType; ///< Console type
+ UINT8 Event; ///< Event type.
+ UINT8 PrintState; ///< On or Off
+ UINT8 OutBufferMode; ///< Off:stack mode, On: heap mode
+ UINT16 OutBufferSize; ///< Buffer size
+ UINT16 OutBufferIndex; ///< Buffer index
+ UINT32 NumBreakpointUnit; ///< default 0 no bp unit others number of bp unit
+} IDS_CONSOLE_HEADER;
+
+/// IDS Console
+struct _IDS_CONSOLE
+{
+ IDS_CONSOLE_HEADER Header; /**< IDS console header - 5 dwords */
+ UINT32 FuncListAddr; /**< 32 bit address to the list of functions that script can execute */
+ UINT8 Reserved[56 - 24]; /**< ----------------- New fields must be added here. */
+ CHAR8 BreakpointList[300]; /**< Breakpoint list */
+ CHAR8 StatusStr[156]; /**< Shows current node, DCT, CS,... */
+ CHAR8 OutBuffer[2]; /**< Console Out content. Its size will be determined by BufferSize. */
+};
+
+/**
+ * Create hdt console context
+ *
+ * Do hardware settings for hdt console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+STATIC VOID
+CreateHdtConsoleContext (
+ IN OUT IDS_CONSOLE *IdsConsole
+ )
+{
+ UINT64 SMsr;
+ UINT32 CR4reg;
+
+ LibAmdMsrRead (0xC001100A, (UINT64*)&SMsr, NULL);
+ SMsr |= 1;
+ LibAmdMsrWrite (0xC001100A, (UINT64*)&SMsr, NULL);
+
+ LibAmdWriteCpuReg (DR2_REG, 0x99CC);
+ LibAmdWriteCpuReg (DR7_REG, 0x02000420);
+
+ LibAmdReadCpuReg (CR4_REG, &CR4reg);
+ LibAmdWriteCpuReg (CR4_REG, CR4reg | ((UINT32)1 << 3));
+}
+
+/**
+ * Initialize hdt console context
+ *
+ * Initilize preference settings for hdt console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+STATIC VOID
+InitHdtConsoleContext (
+ IN OUT IDS_CONSOLE *IdsConsole
+ )
+{
+ IDS_FUNCLIST_EXTERN ();
+
+ IdsConsole->FuncListAddr = (UINT32) IDS_FUNCLIST_ADDR;
+ IdsConsole->StatusStr[0] = 0;
+
+}
+
+/**
+ * Update hdt console context
+ *
+ * Update preference settings for hdt console context
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+STATIC VOID
+UpdateHdtConsoleContext (
+ IN OUT IDS_CONSOLE *IdsConsole
+ )
+{
+ if (IdsConsole->Header.OutBufferMode == IDS_STATE_OFF) {
+ IdsConsole->Header.OutBufferSize = 0;
+ }
+
+}
+
+/**
+ * Destroy hdt console context
+ *
+ * Save hdt console context snapshot
+ *
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+STATIC VOID
+DestroyHdtConsoleContext (
+ IN OUT IDS_CONSOLE *IdsConsole
+ )
+{
+ UINT64 SMsr;
+
+ LibAmdMsrRead (0xC001100A, (UINT64 *)&SMsr, NULL);
+ SMsr &= ~BIT0;
+ LibAmdMsrWrite (0xC001100A, (UINT64 *)&SMsr, NULL);
+
+ LibAmdWriteCpuReg (DR2_REG, 0);
+ LibAmdWriteCpuReg (DR3_REG, 0);
+ LibAmdWriteCpuReg (DR7_REG, 0);
+}
+
+/**
+ * Hdt console print function
+ *
+ * Print function related with hdt console
+ *
+ * @param[in] PrintType Print Type
+ * @param[in] ConsoleBufferAddress The address of console buffer
+ * @param[in] ConsoleBufferSize The size of console buffer
+ * @param[in,out] IdsConsole The Pointer of IDS console
+ *
+ **/
+STATIC VOID
+HdtConsolePrint (
+ IN UINT32 PrintType,
+ IN UINT32 ConsoleBufferAddress,
+ IN UINT32 ConsoleBufferSize,
+ IN OUT IDS_CONSOLE *IdsConsole
+ )
+{
+ IdsOutPort (PrintType | 0x99CC, ConsoleBufferAddress, ConsoleBufferSize);
+}
+
+/// Initial construction data for HDT console header.
+CONST IDS_CONSOLE_HEADER ROMDATA HdtConsoleHeader =
+{
+ 0xDB1099CC,
+ 0x0100,
+ IDS_STATE_ON,
+ EVENT_OFF,
+ IDS_STATE_ON,
+ IDS_STATE_ON,
+ 0x1000,
+ 0x0,
+ 0,
+};
+
+#define OPTION_HDT_CONSOLE_HEADER &HdtConsoleHeader
+
+/// Initial construction data for HDT console operations.
+CONST IDS_CONSOLE_OPERATIONS ROMDATA HdtConsoleOperations =
+{
+ CreateHdtConsoleContext,
+ InitHdtConsoleContext,
+ UpdateHdtConsoleContext,
+ DestroyHdtConsoleContext,
+ HdtConsolePrint
+};
+
+#define OPTION_HDT_CONSOLE_OPERATIONS &HdtConsoleOperations
+
+/**
+ * Parses flag and width information from theFormat string and returns the next index
+ * into the Format string that needs to be parsed. See file headed for details of Flag and Width.
+ *
+ * @param[in] Format Current location in the AvSPrint format string.
+ * @param[out] Flags Returns flags
+ * @param[out] Width Returns width of element
+ * @param[out] Marker Vararg list that may be partially consumed and returned.
+ *
+ * @retval Pointer indexed into the Format string for all the information parsed by this routine.
+ *
+ **/
+STATIC CHAR8 *
+GetFlagsAndWidth (
+ IN CHAR8 *Format,
+ OUT UINTN *Flags,
+ OUT UINTN *Width,
+ IN OUT VA_LIST *Marker
+ )
+{
+ UINTN Count;
+ BOOLEAN Done;
+
+ *Flags = 0;
+ *Width = 0;
+ for (Done = FALSE; !Done; ) {
+ Format++;
+
+ switch (*Format) {
+
+ case '-':
+ *Flags |= LEFT_JUSTIFY;
+ break;
+ case '+':
+ *Flags |= PREFIX_SIGN;
+ break;
+ case ' ':
+ *Flags |= PREFIX_BLANK;
+ break;
+ case ',':
+ *Flags |= COMMA_TYPE;
+ break;
+ case 'L':
+ case 'l':
+ *Flags |= LONG_TYPE;
+ break;
+
+ case '*':
+ *Width = VA_ARG (*Marker, UINTN);
+ break;
+
+ case '0':
+ *Flags |= PREFIX_ZERO;
+ break;
+
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ Count = 0;
+ do {
+ Count = (Count * 10) + *Format - '0';
+ Format++;
+ } while ((*Format >= '0') && (*Format <= '9'));
+ Format--;
+ *Width = Count;
+ break;
+
+ default:
+ Done = TRUE;
+ }
+ }
+ return Format;
+}
+
+CHAR8 STATIC HexStr[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+/**
+ *
+ * @param[in] Buffer Location to place ascii hex string of Value.
+ * @param[in] Value - Hex value to convert to a string in Buffer.
+ * @param[in] Flags - Flags to use in printing Hex string, see file header for details.
+ * @param[in] Width - Width of hex value.
+ *
+ * @retval Number of characters printed.
+ **/
+
+STATIC UINTN
+ValueTomHexStr (
+ IN OUT CHAR8 *Buffer,
+ IN UINT64 Value,
+ IN UINTN Flags,
+ IN UINTN Width
+ )
+{
+ CHAR8 TempBuffer[30];
+ CHAR8 *TempStr;
+ CHAR8 Prefix;
+ CHAR8 *BufferPtr;
+ UINTN Count;
+ UINTN Index;
+
+ TempStr = TempBuffer;
+ BufferPtr = Buffer;
+ //
+ // Count starts at one since we will null terminate. Each iteration of the
+ // loop picks off one nibble. Oh yea TempStr ends up backwards
+ //
+ Count = 0;
+ do {
+ *(TempStr++) = HexStr[Value & 0x0f];
+ Value >>= 4;
+ Count++;
+ } while (Value != 0);
+
+ if (Flags & PREFIX_ZERO) {
+ Prefix = '0';
+ } else if (!(Flags & LEFT_JUSTIFY)) {
+ Prefix = ' ';
+ } else {
+ Prefix = 0x00;
+ }
+ for (Index = Count; Index < Width; Index++) {
+ *(TempStr++) = Prefix;
+ }
+
+ //
+ // Reverse temp string into Buffer.
+ //
+ while (TempStr != TempBuffer) {
+ *(BufferPtr++) = *(--TempStr);
+ }
+
+ *BufferPtr = 0;
+ return Index;
+}
+
+/**
+ * Prints a Value as a decimal number in Buffer
+ *
+ * @param[in] Buffer Location to place ascii decimal number string of Value.
+ * @param[in] Value Decimal value to convert to a string in Buffer.
+ * @param[in] Flags Flags to use in printing decimal string, see file header for details.
+ *
+ * @retval Number of characters printed.
+ *
+**/
+
+STATIC UINTN
+ValueToString (
+ IN OUT CHAR8 *Buffer,
+ IN INT32 Value,
+ IN UINTN Flags
+ )
+{
+ CHAR8 TempBuffer[30];
+ CHAR8 *TempStr;
+ CHAR8 *BufferPtr;
+ UINTN Count;
+ UINTN Remainder;
+
+ TempStr = TempBuffer;
+ BufferPtr = Buffer;
+ Count = 0;
+
+ if (Value < 0) {
+ *(BufferPtr++) = '-';
+ Value = - Value;
+ Count++;
+ }
+
+ do {
+ Remainder = Value % 10;
+ Value /= 10;
+ *(TempStr++) = (CHAR8)(Remainder + '0');
+ Count++;
+ if ((Flags & COMMA_TYPE) == COMMA_TYPE) {
+ if (Count % 3 == 0) {
+ *(TempStr++) = ',';
+ }
+ }
+ } while (Value != 0);
+
+ //
+ // Reverse temp string into Buffer.
+ //
+ while (TempStr != TempBuffer) {
+ *(BufferPtr++) = *(--TempStr);
+ }
+
+ *BufferPtr = 0;
+ return Count;
+}
+
+/**
+ * Check if String contain the substring
+ *
+ * @param[in] String Pointer of string.
+ * @param[in] Substr Pointer of sub string.
+ *
+ * @retval TRUE S2 is substring of S1
+ * @retval FALSE S2 isn't substring of S1
+ *
+**/
+STATIC BOOLEAN
+AmdIdsSubStr (
+ IN CHAR8 *String,
+ IN CHAR8 *Substr
+ )
+{
+ UINT16 i;
+ UINT16 j;
+
+ for (i = 0; String[i] != 0 ; i++) {
+ for (j = 0; (Substr[j] != 0) && (Substr[j] == String[i + j]); j++) {
+ }
+ if (Substr[j] == 0) {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * IDS Backend Function for Memory timeout control
+ *
+ * This function is used to override Memory timeout control.
+ *
+ * @param[in,out] DataPtr The Pointer of UINT8.
+ *
+ **/
+VOID
+IdsMemTimeOut (
+ IN OUT VOID *DataPtr
+ )
+{
+ UINT32 DR2reg;
+
+ LibAmdReadCpuReg (DR2_REG, &DR2reg);
+ if (DR2reg == 0x99CC) {
+ // Turn timeout off if HDTout is on
+ *((UINT8 *)DataPtr) = (UINT8)0;
+ }
+}
+
+/**
+ *
+ * IDS Debug Function to check the sentinels are intact
+ *
+ * This function complete heap walk and check to be performed at any time.
+ *
+ * @param[in] StdHeader Config handle for library and services.
+ *
+ * @retval TRUE No error
+ *
+ **/
+BOOLEAN
+AmdHeapIntactCheck (
+ IN AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ UINT8 *HeapBufferPtr;
+ BUFFER_NODE *StartOfBufferPtr;
+ BUFFER_NODE *EndOfBufferPtr;
+ HEAP_MANAGER *HeapManagerPtr;
+ BUFFER_NODE *HeadNodePtr;
+ BUFFER_NODE *CurrentNodePtr;
+ UINT32 AmdHeapRamAddress;
+ UINT32 SentinelBefore;
+ UINT32 SentinelAfter;
+
+ ASSERT (StdHeader != NULL);
+
+ AmdHeapRamAddress = (UINT32)UserOptions.CfgHeapDramAddress;
+
+ if (StdHeader->HeapStatus == HEAP_LOCAL_CACHE) {
+ HeapBufferPtr = (UINT8 *) HeapGetCurrentBase (StdHeader);
+ } else if (StdHeader->HeapStatus == HEAP_TEMP_MEM) {
+ HeapBufferPtr = (UINT8 *) AmdHeapRamAddress;
+ } else {
+ return TRUE;
+ }
+
+ HeapManagerPtr = (HEAP_MANAGER *) HeapBufferPtr;
+ HeadNodePtr = (BUFFER_NODE *) (HeapBufferPtr + sizeof (HEAP_MANAGER));
+ CurrentNodePtr = HeadNodePtr;
+
+ if (HeapManagerPtr->AvailableSize != AMD_HEAP_SIZE_PER_CORE - sizeof (HEAP_MANAGER)) {
+ while (CurrentNodePtr != NULL) {
+ StartOfBufferPtr = (BUFFER_NODE *) ((UINT8 *) CurrentNodePtr + sizeof (BUFFER_NODE) + CurrentNodePtr->BufferSize + 2 * SIZE_OF_SENTINEL);
+ EndOfBufferPtr = (BUFFER_NODE *) ((UINT8 *) HeadNodePtr + AMD_HEAP_SIZE_PER_CORE);
+ if (CurrentNodePtr->NextNodePtr != NULL) {
+ ASSERT ((CurrentNodePtr->NextNodePtr >= StartOfBufferPtr) && (CurrentNodePtr->NextNodePtr < EndOfBufferPtr));
+ SentinelBefore = *(UINT32 *) ((UINT8 *) CurrentNodePtr + sizeof (BUFFER_NODE));
+ SentinelAfter = *(UINT32 *) ((UINT8 *) CurrentNodePtr + sizeof (BUFFER_NODE) + SIZE_OF_SENTINEL + CurrentNodePtr->BufferSize);
+
+ ASSERT ((SentinelBefore == SENTINEL_BEFORE_VALUE) && (SentinelAfter == SENTINEL_AFTER_VALUE));
+ } else {
+ ASSERT ((UINT8 *) StartOfBufferPtr == HeapBufferPtr + AMD_HEAP_SIZE_PER_CORE - HeapManagerPtr->AvailableSize);
+ SentinelBefore = *(UINT32 *) ((UINT8 *) CurrentNodePtr + sizeof (BUFFER_NODE));
+ SentinelAfter = *(UINT32 *) ((UINT8 *) CurrentNodePtr + sizeof (BUFFER_NODE) + SIZE_OF_SENTINEL + CurrentNodePtr->BufferSize);
+ ASSERT ((SentinelBefore == SENTINEL_BEFORE_VALUE) && (SentinelAfter == SENTINEL_AFTER_VALUE));
+ }
+ CurrentNodePtr = CurrentNodePtr->NextNodePtr;
+ }
+ }
+ return TRUE;
+}
+
+/**
+ * Determine whether IDS console is enabled.
+ *
+ * @param[in,out] IdsConsole The Pointer of Ids console data
+ *
+ * @retval TRUE Ids console is enabled.
+ * @retval FALSE Ids console is disabled.
+ *
+ **/
+BOOLEAN
+STATIC
+IsIdsConsoleEnabled (
+ IN OUT UINTN *IdsConsole
+ )
+{
+ BOOLEAN Result;
+ UINT32 DR2reg;
+
+ Result = FALSE;
+
+ LibAmdReadCpuReg (DR2_REG, &DR2reg);
+ if (DR2reg == 0x99CC) {
+ Result = TRUE;
+ }
+
+ return Result;
+}
+
+/**
+ * Get IDS console.
+ *
+ * @param[in,out] IdsConsolePtr The Pointer of Ids console data
+ *
+ **/
+STATIC VOID
+GetIdsConsole (
+ IN OUT UINTN *IdsConsolePtr
+ )
+{
+ UINT32 DR3Reg;
+
+ LibAmdReadCpuReg (DR3_REG, &DR3Reg);
+ *IdsConsolePtr = (UINTN) DR3Reg;
+}
+
+/**
+ * Get IDS console operations.
+ *
+ * @param[in,out] IdsConsoleOperations The Pointer of Ids console operations
+ *
+ **/
+STATIC VOID
+GetIdsConsoleHeader (
+ IN OUT UINTN *IdsConsoleHeader
+ )
+{
+ IDS_CONSOLE_TYPE IdsConsoleType;
+
+ IdsConsoleType = (IDS_CONSOLE_TYPE) OPTION_IDS_CONSOLE;
+
+ if (IdsConsoleType == HDT_CONSOLE) {
+ *IdsConsoleHeader = (UINTN) OPTION_HDT_CONSOLE_HEADER;
+ } else {
+ ASSERT (FALSE);
+ }
+}
+
+/**
+ * Get IDS console operations.
+ *
+ * @param[in,out] IdsConsoleOperations The Pointer of Ids console operations
+ *
+ **/
+STATIC VOID
+GetIdsConsoleOperations (
+ IN OUT UINTN *IdsConsoleOperations
+ )
+{
+ IDS_CONSOLE_TYPE IdsConsoleType;
+
+ IdsConsoleType = (IDS_CONSOLE_TYPE) OPTION_IDS_CONSOLE;
+
+ if (IdsConsoleType == HDT_CONSOLE) {
+ *IdsConsoleOperations = (UINTN) OPTION_HDT_CONSOLE_OPERATIONS;
+ } else {
+ ASSERT (FALSE);
+ }
+}
+
+/**
+ * Create IDS console.
+ *
+ * @param[in,out] IdsConsole The Pointer of Ids console data
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ **/
+STATIC VOID
+NewIdsConsole (
+ IN OUT IDS_CONSOLE *IdsConsole,
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ IDS_CONSOLE_HEADER *IdsConsoleHeader;
+ UINTN IdsConsoleHeaderPtr;
+
+ GetIdsConsoleHeader (&IdsConsoleHeaderPtr);
+ IdsConsoleHeader = &(IdsConsole->Header);
+
+ LibAmdMemCopy ((VOID *)IdsConsoleHeader, (VOID *) (IdsConsoleHeaderPtr), (UINT32) sizeof (IDS_CONSOLE_HEADER), StdHeader);
+}
+
+/**
+ * Destroy IDS console.
+ *
+ * @param[in,out] IdsConsole The Pointer of Ids console data
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ **/
+STATIC VOID
+DestroyIdsConsole (
+ IN OUT IDS_CONSOLE *IdsConsole,
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ HeapDeallocateBuffer (IDS_HDT_OUT_BUFFER_HANDLE, StdHeader);
+}
+
+/**
+ * Save IDS console Snapshot.
+ *
+ * @param[in,out] IdsConsole The Pointer of Ids console data
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ **/
+STATIC VOID
+SaveIdsConsole (
+ IN OUT IDS_CONSOLE *IdsConsole,
+ IN OUT IDS_CONSOLE_OPERATIONS *IdsConsoleOps,
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ ALLOCATE_HEAP_PARAMS AllocHeapParams;
+
+ do {
+ AllocHeapParams.RequestedBufferSize = IdsConsole->Header.OutBufferSize + sizeof (IDS_CONSOLE) - 2;
+ AllocHeapParams.BufferHandle = IDS_HDT_OUT_BUFFER_HANDLE;
+ AllocHeapParams.Persist = HEAP_SYSTEM_MEM;
+ if (HeapAllocateBuffer (&AllocHeapParams, StdHeader) == AGESA_SUCCESS) {
+ break;
+ } else {
+ IdsConsole->Header.OutBufferSize -= 256;
+ IdsConsole->Header.Event = EVENT_FAIL_BUFFER_ALLOCATION;
+ IdsConsoleOps->Print (DEBUG_PRINT_EVENT, (UINT32)IdsConsole, 0, IdsConsole);
+ }
+ } while ((IdsConsole->Header.OutBufferSize & 0x8000) == 0);
+
+ if ((IdsConsole->Header.OutBufferSize & 0x8000) == 0) {
+ LibAmdWriteCpuReg (DR3_REG, (UINT32)AllocHeapParams.BufferPtr);
+ LibAmdMemCopy (AllocHeapParams.BufferPtr, (VOID *) IdsConsole, (UINT32) sizeof (IDS_CONSOLE) - 2, StdHeader);
+ }
+}
+
+/**
+ *
+ * Initial function for IDS console.
+ *
+ * Create IDS console context, let Ids console function to be ready.
+ *
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ *
+ **/
+VOID
+AmdIdsConsoleInit (
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ IDS_CONSOLE IdsConsole;
+ IDS_CONSOLE_OPERATIONS *IdsConsoleOps;
+ UINTN IdsConsolePtr;
+ UINTN IdsConsoleOpsPtr;
+
+ if (IsIdsConsoleEnabled (&IdsConsolePtr)) {
+ GetIdsConsoleOperations (&IdsConsoleOpsPtr);
+ IdsConsoleOps = (IDS_CONSOLE_OPERATIONS *) IdsConsoleOpsPtr;
+ NewIdsConsole (&IdsConsole, StdHeader);
+
+ IdsConsoleOps->CreateConsoleContext (&IdsConsole);
+ IdsConsoleOps->InitConsoleContext (&IdsConsole);
+ IdsConsoleOps->Print (DEBUG_PRINT_INIT, (UINT32)&IdsConsole, 0, &IdsConsole);
+ IdsConsoleOps->UpdateConsoleContext (&IdsConsole);
+
+ SaveIdsConsole (&IdsConsole, IdsConsoleOps, StdHeader);
+ }
+}
+
+/**
+ * Prints string to debug host like printf in C
+ *
+ * @param[in] Format of string
+ * @param[in] ... Variable parameter
+ *
+**/
+VOID
+AmdIdsConsolePrint (
+ IN CHAR8 *Format,
+ IN ...
+ )
+{
+ IDS_CONSOLE *IdsConsole;
+ UINTN IdsConsolePtr;
+ IDS_CONSOLE_OPERATIONS *IdsConsoleOps;
+ UINTN IdsConsoleOpsPtr;
+ VA_LIST Marker;
+ CHAR8 LocalBuffer[256];
+ CHAR8 *ConsoleBuffer;
+ CHAR8 Null_Str[] = " < null string > ";
+ CHAR8 *AsciiStr;
+ UINTN Index;
+ UINTN Flags;
+ UINTN Width;
+ UINTN ConsoleBufferSize;
+ UINT64 Value;
+ UINT16 *Array;
+ UINT32 ArrayLength;
+ UINT32 ArrayIndex;
+ BOOLEAN SaveStatus;
+ UINT32 LastIndex;
+ UINT32 i;
+ UINT32 j;
+ UINT32 NumBpUnit;
+ BREAKPOINT_UNIT *Pbpunit;
+ CHAR8 *Pbpstr;
+ CHAR8 *PCmpStr;
+ CHAR8 *EventLevelStr;
+ BOOLEAN LastBpmatched;
+ BOOLEAN Bpmatched;
+ IDS_STATE_TYPE PrintCtrl;
+
+ //Init the default Value
+ IdsConsole = NULL;
+ IdsConsolePtr = 0;
+ ConsoleBuffer = LocalBuffer;
+ Index = 0;
+ LastIndex = 0;
+ ConsoleBufferSize = 256;
+ NumBpUnit = 0;
+ PrintCtrl = IDS_STATE_ON;
+
+ if (IsIdsConsoleEnabled (&IdsConsolePtr)) {
+ GetIdsConsole (&IdsConsolePtr);
+ IdsConsole = (IDS_CONSOLE *) IdsConsolePtr;
+ GetIdsConsoleOperations (&IdsConsoleOpsPtr);
+ IdsConsoleOps = (IDS_CONSOLE_OPERATIONS *) IdsConsoleOpsPtr;
+
+ if (IdsConsole->Header.OutBufferMode == IDS_STATE_ON) {
+ ConsoleBuffer = IdsConsole->OutBuffer;
+ Index = IdsConsole->Header.OutBufferIndex;
+ ConsoleBufferSize = (UINTN) (IdsConsole->Header.OutBufferSize);
+ NumBpUnit = IdsConsole->Header.NumBreakpointUnit;
+ PrintCtrl = IdsConsole->Header.PrintState;
+ }
+
+ if ((PrintCtrl != 0) || (NumBpUnit > 0)) {
+ VA_START(Marker,Format); //init marker to 1st dynamic parameters.
+
+ LastIndex = (UINT32) Index;
+
+ if (*Format != '@') {
+ if (*Format == '!') {
+ SaveStatus = TRUE;
+ Format++;
+ } else {
+ SaveStatus = FALSE;
+ }
+
+ for (; *Format != '\0'; Format++) {
+ if (*Format != '%') {
+ ConsoleBuffer[Index++] = *Format;
+ } else {
+ Format = GetFlagsAndWidth (Format, &Flags, &Width, &Marker);
+ switch (*Format) {
+ // Using %[EventType] style to catch predefined event.
+ case '[':
+ EventLevelStr = Format;
+ EventLevelStr++;
+ if ((*EventLevelStr > EVENT_OFF) && (*EventLevelStr < EVENT_END)) {
+ EventLevelStr++;
+ if (*EventLevelStr == ']') {
+ EventLevelStr--;
+ IdsConsole->Header.Event = (UINT8) (CONSOLE_EVENT_TYPE) (*EventLevelStr);
+ }
+ }
+ break;
+ case 'X':
+ Flags |= PREFIX_ZERO;
+ Width = sizeof (UINT64) * 2;
+ //
+ // break skipped on purpose
+ //
+ case 'x':
+ if ((Flags & LONG_TYPE) == LONG_TYPE) {
+ Value = VA_ARG (Marker, UINT64);
+ } else {
+ Value = VA_ARG (Marker, UINTN);
+ }
+ Index += ValueTomHexStr (&ConsoleBuffer[Index], Value, Flags, Width);
+ break;
+
+ case 'd':
+ Value = (UINTN)VA_ARG (Marker, UINT32);
+ Index += ValueToString (&ConsoleBuffer[Index], (UINT32)Value, Flags);
+ break;
+
+ case 's':
+ case 'S':
+ AsciiStr = (CHAR8 *)VA_ARG (Marker, CHAR8 *);
+ if (AsciiStr == NULL) {
+ AsciiStr = Null_Str; //" < null string > ";
+ }
+ while (*AsciiStr != '\0') {
+ ConsoleBuffer[Index++] = *AsciiStr++;
+ }
+ break;
+
+ case 'c':
+ ConsoleBuffer[Index++] = (CHAR8)VA_ARG (Marker, UINTN);
+ break;
+
+ case 'a':
+ Array = (UINT16 *) VA_ARG (Marker, VOID *);
+ ArrayLength = (UINT32) VA_ARG (Marker, UINT32);
+ for (ArrayIndex = 0; ArrayIndex < ArrayLength; ArrayIndex++) {
+ // Only support hex format of an array of UINT16 for now.
+ Width = 2;
+ Flags = PREFIX_ZERO;
+ ConsoleBuffer[Index++] = ' ';
+ Index += ValueTomHexStr (&ConsoleBuffer[Index], Array[ArrayIndex] & 0xFF, Flags, Width);
+
+ // If buffer is full
+ if (Index > (ConsoleBufferSize - 8)) {
+ if (IdsConsole != NULL) {
+ if (LastIndex != 0) {
+ // Stream all out except current string
+ if (PrintCtrl != 0) {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, LastIndex, IdsConsole);
+ }
+ Index = Index - LastIndex;
+ // Move current string too top
+ for (i = 0; i < Index; i++) {
+ ConsoleBuffer[i] = ConsoleBuffer[LastIndex + i];
+ }
+ LastIndex = 0;
+ } else {
+ // Buffer size is too small
+ ASSERT (FALSE);
+ }
+ } else {
+ break;
+ }
+ }
+ }
+ break;
+
+ case 'v':
+ ConsoleBuffer[Index++] = '%';
+ ConsoleBuffer[Index++] = 'v';
+ Format++;
+ ConsoleBuffer[Index++] = *Format;
+ if (*Format == 'h') {
+ Format++;
+ ConsoleBuffer[Index++] = *Format;
+ }
+ break;
+
+ case '%':
+ ConsoleBuffer[Index++] = *Format;
+ break;
+
+ default:
+ //
+ // if the type is unknown print it to the screen
+ //
+ ConsoleBuffer[Index++] = '%';
+ ConsoleBuffer[Index++] = *Format;
+ }
+ }
+
+ // If buffer is full
+ if (Index > (ConsoleBufferSize - 32)) {
+ if (IdsConsole != NULL) {
+ if (LastIndex != 0) {
+ // Stream all out except current string
+ if (PrintCtrl != IDS_STATE_OFF) {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, LastIndex, IdsConsole);
+ }
+ Index = Index - LastIndex;
+ // Move current string too top
+ for (i = 0; i < Index; i++) {
+ ConsoleBuffer[i] = ConsoleBuffer[LastIndex + i];
+ }
+ LastIndex = 0;
+ } else {
+ // Buffer size is too small
+ ASSERT (FALSE);
+ }
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (IdsConsole->Header.OutBufferMode == IDS_STATE_OFF) {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, (UINT32) Index, IdsConsole);
+ Index = 0;
+ }
+
+ if ((IdsConsole->Header.Event > EVENT_OFF) && (IdsConsole->Header.Event < EVENT_END) ) {
+ // if HdtOut Buffer is on, flush hdtout buffer contents out.
+ if (IdsConsole->Header.OutBufferMode == IDS_STATE_ON) {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, (UINT32) Index, IdsConsole);
+ Index = 0;
+ }
+
+ IdsConsoleOps->Print (DEBUG_PRINT_EVENT, (UINT32)IdsConsole, 0, IdsConsole);
+ IdsConsole->Header.Event = EVENT_OFF;
+ }
+
+ //
+ // Check breakpoint
+ //
+ if (NumBpUnit) {
+ Pbpunit = (BREAKPOINT_UNIT *) IdsConsole->BreakpointList;
+ LastBpmatched = TRUE;
+ Bpmatched = TRUE;
+ for (i = 0; i < NumBpUnit; i++) {
+ Pbpstr = IdsConsole->BreakpointList + Pbpunit[i].BpStrOffset;
+ if (Pbpunit[i].BpFlag == IDS_HDTOUT_BPFLAG_FORMAT_STR) {
+ PCmpStr = &ConsoleBuffer[LastIndex];
+ ConsoleBuffer[Index] = 0;
+ } else {
+ PCmpStr = IdsConsole->StatusStr;
+ }
+
+ if (LastBpmatched) {
+ Bpmatched = AmdIdsSubStr (PCmpStr, Pbpstr);
+ if (Bpmatched) {
+ if (Pbpunit[i].AndFlag == 0) {
+ // This is the last of matching string of an AND block, apply action here
+ switch (Pbpunit[i].Action) {
+ case HDTOUT_BP_ACTION_HALT:
+ IdsConsoleOps->Print (DEBUG_PRINT_BREAKPOINT, (UINT32)(ConsoleBuffer + LastIndex), ( i << 16) | (UINT32) Index, IdsConsole);
+ break;
+ case HDTOUT_BP_ACTION_PRINTON:
+ PrintCtrl = IDS_STATE_ON;
+ IdsConsole->Header.PrintState = IDS_STATE_ON;
+ break;
+ case HDTOUT_BP_ACTION_PRINTOFF:
+ if (IdsConsole->Header.PrintState != IDS_STATE_OFF) {
+ IdsConsole->Header.PrintState = IDS_STATE_OFF;
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, (UINT32)Index, IdsConsole);
+ }
+ break;
+ default:
+ ASSERT (FALSE);
+ }
+ break;
+ }
+ }
+ }
+ if (Pbpunit[i].AndFlag == 1) {
+ LastBpmatched = Bpmatched;
+ } else {
+ LastBpmatched = TRUE;
+ }
+ }
+ }
+
+ //
+ // Store status fields
+ //
+ if (SaveStatus) {
+ // Look for the start of the first word
+ for (; LastIndex < Index; LastIndex++) {
+ if ((ConsoleBuffer[LastIndex] > 32) && (ConsoleBuffer[LastIndex] < 127)) {
+ break;
+ }
+ }
+ if (LastIndex < Index) {
+ // Match the first word in StatusStr
+ SaveStatus = FALSE;
+ j = LastIndex;
+ for (i = 0; !SaveStatus && (IdsConsole->StatusStr[i] != 0); i++) {
+ ArrayLength = 1;
+ for (j = LastIndex; ConsoleBuffer[j] == IdsConsole->StatusStr[i]; j++) {
+ i++;
+ ArrayLength++;
+ if ((j == (Index - 1)) || (ConsoleBuffer[j] == ' ')) {
+ // Find the length of this entry
+ ArrayIndex = i;
+ for (; IdsConsole->StatusStr[i] != '\n'; i++) {
+ ArrayLength++;
+ }
+
+ // Remove old entry if it does not fit
+ if (ArrayLength != ((UINT32) Index - LastIndex)) {
+ for (i++; IdsConsole->StatusStr[i] != 0; i++) {
+ IdsConsole->StatusStr[i - ArrayLength] = IdsConsole->StatusStr[i];
+ }
+ j = LastIndex;
+ i = i - ArrayLength - 1;
+ // Mark the end of string
+ IdsConsole->StatusStr[i + ((UINT32) Index - LastIndex) + 1] = 0;
+ } else {
+ i = ArrayIndex - 2;
+ }
+
+ // Word match, exit for saving
+ SaveStatus = TRUE;
+ break;
+ }
+ }
+ }
+
+ // Copy string to StatusStr
+ for (; j < Index; j++, i++) {
+ IdsConsole->StatusStr[i] = ConsoleBuffer[j];
+ }
+ if (!SaveStatus) {
+ // Mark the end of string if not done so
+ IdsConsole->StatusStr[i] = 0;
+ }
+ }
+ }
+
+ }
+ }
+
+ if (IdsConsole != NULL) {
+ if (IdsConsole->Header.PrintState == IDS_STATE_OFF) {
+ Index = 0; // Clear buffer if the data will not be printed out.
+ }
+ IdsConsole->Header.OutBufferIndex = (UINT16) Index;
+ } else {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)ConsoleBuffer, (UINT32)Index, IdsConsole);
+ }
+ }
+}
+
+/**
+ *
+ * Exit function for IDS console Function.
+ *
+ * Restore debug register and Deallocate heap.
+ *
+ * @param[in,out] StdHeader The Pointer of AGESA Header
+ *
+ **/
+VOID
+AmdIdsConsoleExit (
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+ IDS_CONSOLE *IdsConsole;
+ UINTN IdsConsolePtr;
+ IDS_CONSOLE_OPERATIONS *IdsConsoleOps;
+ UINTN IdsConsoleOpsPtr;
+
+ if (IsIdsConsoleEnabled (&IdsConsolePtr)) {
+ GetIdsConsole (&IdsConsolePtr);
+ IdsConsole = (IDS_CONSOLE *) IdsConsolePtr;
+ GetIdsConsoleOperations (&IdsConsoleOpsPtr);
+ IdsConsoleOps = (IDS_CONSOLE_OPERATIONS *) IdsConsoleOpsPtr;
+
+ if (IdsConsole != NULL) {
+ if (IdsConsole->Header.PrintState != IDS_STATE_OFF) {
+ IdsConsoleOps->Print (DEBUG_PRINT_COMMAND, (UINT32)(IdsConsole->OutBuffer), IdsConsole->Header.OutBufferIndex, IdsConsole);
+ }
+
+ IdsConsoleOps->Print (DEBUG_PRINT_EXIT, (UINT32)IdsConsole, 0, IdsConsole);
+
+ IdsConsoleOps->DestroyConsoleContext (IdsConsole);
+ DestroyIdsConsole (IdsConsole, StdHeader);
+
+ }
+ }
+}
+/**
+ * Check for CAR Corruption, the performance monitor number three programed to log the CAR Corruption.
+ * Check to see if control register is enabled and then check the preformance counter and stop the system by executing
+ * IDS_ERROR_TRAP if counter has any value other than zero.
+ *
+ * @param[in,out] StdHeader The Pointer of Standard Header.
+ *
+ *
+ **/
+VOID
+IdsCarCorruptionCheck (
+ IN OUT AMD_CONFIG_PARAMS *StdHeader
+ )
+{
+
+ UINT64 Perf_Msr;
+
+ LibAmdMsrRead (MSR_PERF_CONTROL3, (UINT64*)&Perf_Msr, StdHeader);
+ if ((Perf_Msr & PERF_RESERVE_BIT_MASK) == PERF_CAR_CORRUPTION_EVENT) {
+ LibAmdMsrRead (MSR_PERF_COUNTER3, (UINT64*)&Perf_Msr, StdHeader);
+ if ((Perf_Msr != 0)) {
+ IDS_ERROR_TRAP;
+ }
+ }
+}
projects / coreboot.git / blobdiff