AGESA fam14: Use common callouts

Backported from fam15tn and fam16kb.

This also implements GetHeapBase() to satisfy some requirements
of HAVE_ACPI_RESUME for the following boards:
  amd/inagua
  amd/south_station
  amd/union_station
  asrock/e350m1

Change-Id: I488d063d4eabf4bf45bcbabd1e8f13b88b2ef401
Signed-off-by: Kyösti Mälkki <kyosti.malkki@gmail.com>
Reviewed-on: http://review.coreboot.org/5658
Tested-by: build bot (Jenkins)
Reviewed-by: Edward O'Callaghan <eocallaghan@alterapraxis.com>
Reviewed-by: Patrick Georgi <patrick@georgi-clan.de>

9 files changed, 3 insertions, 1391 deletions

diff --git a/src/mainboard/amd/inagua/BiosCallOuts.c b/src/mainboard/amd/inagua/BiosCallOuts.c
index 452a5920d1..b3a73f4fb4 100644
--- a/src/mainboard/amd/inagua/BiosCallOuts.c
+++ b/src/mainboard/amd/inagua/BiosCallOuts.c
@@ -93,345 +93,6 @@ AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	return CalloutStatus;
 }
 
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	UINT32              AvailableHeapSize;
-	UINT8               *BiosHeapBaseAddr;
-	UINT32              CurrNodeOffset;
-	UINT32              PrevNodeOffset;
-	UINT32              FreedNodeOffset;
-	UINT32              BestFitNodeOffset;
-	UINT32              BestFitPrevNodeOffset;
-	UINT32              NextFreeOffset;
-	BIOS_BUFFER_NODE   *CurrNodePtr;
-	BIOS_BUFFER_NODE   *FreedNodePtr;
-	BIOS_BUFFER_NODE   *BestFitNodePtr;
-	BIOS_BUFFER_NODE   *BestFitPrevNodePtr;
-	BIOS_BUFFER_NODE   *NextFreePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS *AllocParams;
-
-	AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
-	AllocParams->BufferPointer = NULL;
-
-	AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
-	BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-	if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
-		/* First allocation */
-		CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
-		CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-		CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
-		CurrNodePtr->BufferSize = AllocParams->BufferLength;
-		CurrNodePtr->NextNodeOffset = 0;
-		AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
-
-		/* Update the remaining free space */
-		FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
-		FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-		FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
-		FreedNodePtr->NextNodeOffset = 0;
-
-		/* Update the offsets for Allocated and Freed nodes */
-		BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
-		BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
-	} else {
-		/* Find out whether BufferHandle has been allocated on the heap. */
-		/* If it has, return AGESA_BOUNDS_CHK */
-		CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-		CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-
-		while (CurrNodeOffset != 0) {
-			CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-			if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
-				return AGESA_BOUNDS_CHK;
-			}
-			CurrNodeOffset = CurrNodePtr->NextNodeOffset;
-			/* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
-			   to the end of the allocated nodes list.
-			   */
-		}
-		/* Find the node that best fits the requested buffer size */
-		FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-		PrevNodeOffset = FreedNodeOffset;
-		BestFitNodeOffset = 0;
-		BestFitPrevNodeOffset = 0;
-		while (FreedNodeOffset != 0) {
-			FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-			if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-				if (BestFitNodeOffset == 0) {
-					/* First node that fits the requested buffer size */
-					BestFitNodeOffset = FreedNodeOffset;
-					BestFitPrevNodeOffset = PrevNodeOffset;
-				} else {
-					/* Find out whether current node is a better fit than the previous nodes */
-					BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-					if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
-						BestFitNodeOffset = FreedNodeOffset;
-						BestFitPrevNodeOffset = PrevNodeOffset;
-					}
-				}
-			}
-			PrevNodeOffset = FreedNodeOffset;
-			FreedNodeOffset = FreedNodePtr->NextNodeOffset;
-		} /* end of while loop */
-
-
-		if (BestFitNodeOffset == 0) {
-			/* If we could not find a node that fits the requested buffer */
-			/* size, return AGESA_BOUNDS_CHK */
-			return AGESA_BOUNDS_CHK;
-		} else {
-			BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-			BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
-
-			/* If BestFitNode is larger than the requested buffer, fragment the node further */
-			if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-				NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
-
-				NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
-				NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
-				NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
-			} else {
-				/* Otherwise, next free node is NextNodeOffset of BestFitNode */
-				NextFreeOffset = BestFitNodePtr->NextNodeOffset;
-			}
-
-			/* If BestFitNode is the first buffer in the list, then update
-			   StartOfFreedNodes to reflect the new free node
-			   */
-			if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
-				BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
-			} else {
-				BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
-			}
-
-			/* Add BestFitNode to the list of Allocated nodes */
-			CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
-			BestFitNodePtr->BufferSize = AllocParams->BufferLength;
-			BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
-			BestFitNodePtr->NextNodeOffset = 0;
-
-			/* Remove BestFitNode from list of Freed nodes */
-			AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
-		}
-	}
-
-	return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-
-	UINT8               *BiosHeapBaseAddr;
-	UINT32              AllocNodeOffset;
-	UINT32              PrevNodeOffset;
-	UINT32              NextNodeOffset;
-	UINT32              FreedNodeOffset;
-	UINT32              EndNodeOffset;
-	BIOS_BUFFER_NODE   *AllocNodePtr;
-	BIOS_BUFFER_NODE   *PrevNodePtr;
-	BIOS_BUFFER_NODE   *FreedNodePtr;
-	BIOS_BUFFER_NODE   *NextNodePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS *AllocParams;
-
-	BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-	/* Find target node to deallocate in list of allocated nodes.
-	   Return AGESA_BOUNDS_CHK if the BufferHandle is not found
-	   */
-	AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-	AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-	PrevNodeOffset = AllocNodeOffset;
-
-	while (AllocNodePtr->BufferHandle !=  AllocParams->BufferHandle) {
-		if (AllocNodePtr->NextNodeOffset == 0) {
-			return AGESA_BOUNDS_CHK;
-		}
-		PrevNodeOffset = AllocNodeOffset;
-		AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-		AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-	}
-
-	/* Remove target node from list of allocated nodes */
-	PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-	PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-
-	/* Zero out the buffer, and clear the BufferHandle */
-	LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
-	AllocNodePtr->BufferHandle = 0;
-	AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
-
-	/* Add deallocated node in order to the list of freed nodes */
-	FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-	FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-
-	EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
-
-	if (AllocNodeOffset < FreedNodeOffset) {
-		/* Add to the start of the freed list */
-		if (EndNodeOffset == FreedNodeOffset) {
-			/* If the freed node is adjacent to the first node in the list, concatenate both nodes */
-			AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
-
-			/* Clear the BufferSize and NextNodeOffset of the previous first node */
-			FreedNodePtr->BufferSize = 0;
-			FreedNodePtr->NextNodeOffset = 0;
-		} else {
-			/* Otherwise, add freed node to the start of the list
-			   Update NextNodeOffset and BufferSize to include the
-			   size of BIOS_BUFFER_NODE
-			   */
-			AllocNodePtr->NextNodeOffset = FreedNodeOffset;
-		}
-		/* Update StartOfFreedNodes to the new first node */
-		BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
-	} else {
-		/* Traverse list of freed nodes to find where the deallocated node
-		   should be place
-		   */
-		NextNodeOffset = FreedNodeOffset;
-		NextNodePtr = FreedNodePtr;
-		while (AllocNodeOffset > NextNodeOffset) {
-			PrevNodeOffset = NextNodeOffset;
-			if (NextNodePtr->NextNodeOffset == 0) {
-				break;
-			}
-			NextNodeOffset = NextNodePtr->NextNodeOffset;
-			NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-		}
-
-		/* If deallocated node is adjacent to the next node,
-		   concatenate both nodes
-		   */
-		if (NextNodeOffset == EndNodeOffset) {
-			NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-			AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
-
-			NextNodePtr->BufferSize = 0;
-			NextNodePtr->NextNodeOffset = 0;
-		} else {
-			/*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
-			AllocNodePtr->NextNodeOffset = NextNodeOffset;
-		}
-		/* If deallocated node is adjacent to the previous node,
-		   concatenate both nodes
-		   */
-		PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-		EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
-		if (AllocNodeOffset == EndNodeOffset) {
-			PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-			PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
-			AllocNodePtr->BufferSize = 0;
-			AllocNodePtr->NextNodeOffset = 0;
-		} else {
-			PrevNodePtr->NextNodeOffset = AllocNodeOffset;
-		}
-	}
-	return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	UINT32              AllocNodeOffset;
-	UINT8               *BiosHeapBaseAddr;
-	BIOS_BUFFER_NODE   *AllocNodePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS *AllocParams;
-
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-	BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-	AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-	AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-
-	while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
-		if (AllocNodePtr->NextNodeOffset == 0) {
-			AllocParams->BufferPointer = NULL;
-			AllocParams->BufferLength = 0;
-			return AGESA_BOUNDS_CHK;
-		} else {
-			AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-			AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-		}
-	}
-
-	AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
-	AllocParams->BufferLength = AllocNodePtr->BufferSize;
-
-	return AGESA_SUCCESS;
-
-}
-
-AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS        Status;
-
-	Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
-	return Status;
-}
-
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS        Status;
-	UINT8                 Value;
-	UINTN               ResetType;
-	AMD_CONFIG_PARAMS   *StdHeader;
-
-	ResetType = Data;
-	StdHeader = ConfigPtr;
-
-	//
-	// Perform the RESET based upon the ResetType. In case of
-	// WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
-	// AmdResetManager. During the critical condition, where reset is required
-	// immediately, the reset will be invoked directly by writing 0x04 to port
-	// 0xCF9 (Reset Port).
-	//
-	switch (ResetType) {
-		case WARM_RESET_WHENEVER:
-		case COLD_RESET_WHENEVER:
-			break;
-
-		case WARM_RESET_IMMEDIATELY:
-		case COLD_RESET_IMMEDIATELY:
-			Value = 0x06;
-			LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
-			break;
-
-		default:
-			break;
-	}
-
-	Status = 0;
-	return Status;
-}
-
-AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS Status;
-#ifdef __PRE_RAM__
-	Status = agesa_ReadSPD (Func, Data, ConfigPtr);
-#else
-	Status = AGESA_UNSUPPORTED;
-#endif
-
-	return Status;
-}
-
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	return AGESA_UNSUPPORTED;
-}
 /*  Call the host environment interface to provide a user hook opportunity. */
 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
diff --git a/src/mainboard/amd/inagua/agesawrapper.c b/src/mainboard/amd/inagua/agesawrapper.c
index ea07cf533b..41278f1c25 100644
--- a/src/mainboard/amd/inagua/agesawrapper.c
+++ b/src/mainboard/amd/inagua/agesawrapper.c
@@ -259,7 +259,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
+	BiosManagerPtr = (BIOS_HEAP_MANAGER *)GetHeapBase(&AmdParamStruct.StdHeader);
 
 	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
 	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
diff --git a/src/mainboard/amd/persimmon/BiosCallOuts.c b/src/mainboard/amd/persimmon/BiosCallOuts.c
index 700da08eba..6395484b94 100644
--- a/src/mainboard/amd/persimmon/BiosCallOuts.c
+++ b/src/mainboard/amd/persimmon/BiosCallOuts.c
@@ -97,350 +97,6 @@ AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	return CalloutStatus;
 }
 
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	UINT32              AvailableHeapSize;
-	UINT8               *BiosHeapBaseAddr;
-	UINT32              CurrNodeOffset;
-	UINT32              PrevNodeOffset;
-	UINT32              FreedNodeOffset;
-	UINT32              BestFitNodeOffset;
-	UINT32              BestFitPrevNodeOffset;
-	UINT32              NextFreeOffset;
-	BIOS_BUFFER_NODE   *CurrNodePtr;
-	BIOS_BUFFER_NODE   *FreedNodePtr;
-	BIOS_BUFFER_NODE   *BestFitNodePtr;
-	BIOS_BUFFER_NODE   *BestFitPrevNodePtr;
-	BIOS_BUFFER_NODE   *NextFreePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS *AllocParams;
-
-	AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
-	AllocParams->BufferPointer = NULL;
-
-	AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
-
-	printk(BIOS_SPEW, "%s BiosHeapBaseAddr: %x\n", __func__, (u32) BiosHeapBaseAddr);
-
-	if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
-		/* First allocation */
-		CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
-		CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-		CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
-		CurrNodePtr->BufferSize = AllocParams->BufferLength;
-		CurrNodePtr->NextNodeOffset = 0;
-		AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
-
-		/* Update the remaining free space */
-		FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
-		FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-		FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
-		FreedNodePtr->NextNodeOffset = 0;
-
-		/* Update the offsets for Allocated and Freed nodes */
-		BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
-		BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
-	} else {
-		/* Find out whether BufferHandle has been allocated on the heap. */
-		/* If it has, return AGESA_BOUNDS_CHK */
-		CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-		CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-
-		while (CurrNodeOffset != 0) {
-			CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-			if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
-				return AGESA_BOUNDS_CHK;
-			}
-			CurrNodeOffset = CurrNodePtr->NextNodeOffset;
-			/* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
-			   to the end of the allocated nodes list.
-			*/
-
-		}
-		/* Find the node that best fits the requested buffer size */
-		FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-		PrevNodeOffset = FreedNodeOffset;
-		BestFitNodeOffset = 0;
-		BestFitPrevNodeOffset = 0;
-		while (FreedNodeOffset != 0) {
-			FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-			if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-				if (BestFitNodeOffset == 0) {
-					/* First node that fits the requested buffer size */
-					BestFitNodeOffset = FreedNodeOffset;
-					BestFitPrevNodeOffset = PrevNodeOffset;
-				} else {
-					/* Find out whether current node is a better fit than the previous nodes */
-					BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-					if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
-						BestFitNodeOffset = FreedNodeOffset;
-						BestFitPrevNodeOffset = PrevNodeOffset;
-					}
-				}
-			}
-			PrevNodeOffset = FreedNodeOffset;
-			FreedNodeOffset = FreedNodePtr->NextNodeOffset;
-		} /* end of while loop */
-
-
-		if (BestFitNodeOffset == 0) {
-			/* If we could not find a node that fits the requested buffer */
-			/* size, return AGESA_BOUNDS_CHK */
-			return AGESA_BOUNDS_CHK;
-		} else {
-			BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-			BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
-
-			/* If BestFitNode is larger than the requested buffer, fragment the node further */
-			if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-				NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
-
-				NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
-				NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
-				NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
-			} else {
-				/* Otherwise, next free node is NextNodeOffset of BestFitNode */
-				NextFreeOffset = BestFitNodePtr->NextNodeOffset;
-			}
-
-			/* If BestFitNode is the first buffer in the list, then update
-			   StartOfFreedNodes to reflect the new free node
-			*/
-			if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
-				BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
-			} else {
-				BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
-			}
-
-			/* Add BestFitNode to the list of Allocated nodes */
-			CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
-			BestFitNodePtr->BufferSize = AllocParams->BufferLength;
-			BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
-			BestFitNodePtr->NextNodeOffset = 0;
-
-			/* Remove BestFitNode from list of Freed nodes */
-			AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
-		}
-	}
-
-	return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-
-	UINT8               *BiosHeapBaseAddr;
-	UINT32              AllocNodeOffset;
-	UINT32              PrevNodeOffset;
-	UINT32              NextNodeOffset;
-	UINT32              FreedNodeOffset;
-	UINT32              EndNodeOffset;
-	BIOS_BUFFER_NODE   *AllocNodePtr;
-	BIOS_BUFFER_NODE   *PrevNodePtr;
-	BIOS_BUFFER_NODE   *FreedNodePtr;
-	BIOS_BUFFER_NODE   *NextNodePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS *AllocParams;
-
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
-
-	/* Find target node to deallocate in list of allocated nodes.
-	   Return AGESA_BOUNDS_CHK if the BufferHandle is not found
-	*/
-	AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-	AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-	PrevNodeOffset = AllocNodeOffset;
-
-	while (AllocNodePtr->BufferHandle !=  AllocParams->BufferHandle) {
-		if (AllocNodePtr->NextNodeOffset == 0) {
-			return AGESA_BOUNDS_CHK;
-		}
-		PrevNodeOffset = AllocNodeOffset;
-		AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-		AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-	}
-
-	/* Remove target node from list of allocated nodes */
-	PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-	PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-
-	/* Zero out the buffer, and clear the BufferHandle */
-	LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
-	AllocNodePtr->BufferHandle = 0;
-	AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
-
-	/* Add deallocated node in order to the list of freed nodes */
-	FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-	FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-
-	EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
-
-	if (AllocNodeOffset < FreedNodeOffset) {
-		/* Add to the start of the freed list */
-		if (EndNodeOffset == FreedNodeOffset) {
-			/* If the freed node is adjacent to the first node in the list, concatenate both nodes */
-			AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
-
-			/* Clear the BufferSize and NextNodeOffset of the previous first node */
-			FreedNodePtr->BufferSize = 0;
-			FreedNodePtr->NextNodeOffset = 0;
-
-		} else {
-			/* Otherwise, add freed node to the start of the list
-			   Update NextNodeOffset and BufferSize to include the
-			   size of BIOS_BUFFER_NODE
-			*/
-			AllocNodePtr->NextNodeOffset = FreedNodeOffset;
-		}
-		/* Update StartOfFreedNodes to the new first node */
-		BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
-	} else {
-		/* Traverse list of freed nodes to find where the deallocated node
-		   should be place
-		*/
-		NextNodeOffset = FreedNodeOffset;
-		NextNodePtr = FreedNodePtr;
-		while (AllocNodeOffset > NextNodeOffset) {
-			PrevNodeOffset = NextNodeOffset;
-			if (NextNodePtr->NextNodeOffset == 0) {
-				break;
-			}
-			NextNodeOffset = NextNodePtr->NextNodeOffset;
-			NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-		}
-
-		/* If deallocated node is adjacent to the next node,
-		   concatenate both nodes
-		*/
-		if (NextNodeOffset == EndNodeOffset) {
-			NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-			AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
-
-			NextNodePtr->BufferSize = 0;
-			NextNodePtr->NextNodeOffset = 0;
-		} else {
-			/*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
-			AllocNodePtr->NextNodeOffset = NextNodeOffset;
-		}
-		/* If deallocated node is adjacent to the previous node,
-		   concatenate both nodes
-		*/
-		PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-		EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
-		if (AllocNodeOffset == EndNodeOffset) {
-			PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-			PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
-
-			AllocNodePtr->BufferSize = 0;
-			AllocNodePtr->NextNodeOffset = 0;
-		} else {
-			PrevNodePtr->NextNodeOffset = AllocNodeOffset;
-		}
-	}
-	return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	UINT32				AllocNodeOffset;
-	UINT8				*BiosHeapBaseAddr;
-	BIOS_BUFFER_NODE	*AllocNodePtr;
-	BIOS_HEAP_MANAGER	*BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS	*AllocParams;
-
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
-
-	AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-	AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-
-	while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
-		if (AllocNodePtr->NextNodeOffset == 0) {
-			AllocParams->BufferPointer = NULL;
-			AllocParams->BufferLength = 0;
-			return AGESA_BOUNDS_CHK;
-		} else {
-			AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-			AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-		}
-	}
-
-	AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
-	AllocParams->BufferLength = AllocNodePtr->BufferSize;
-
-	return AGESA_SUCCESS;
-
-}
-
-AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS		Status;
-
-	Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
-	return Status;
-}
-
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS		Status;
-	UINT8				 Value;
-	UINTN				 ResetType;
-	AMD_CONFIG_PARAMS	 *StdHeader;
-
-	ResetType = Data;
-	StdHeader = ConfigPtr;
-
-	//
-	// Perform the RESET based upon the ResetType. In case of
-	// WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
-	// AmdResetManager. During the critical condition, where reset is required
-	// immediately, the reset will be invoked directly by writing 0x04 to port
-	// 0xCF9 (Reset Port).
-	//
-	switch (ResetType) {
-	case WARM_RESET_WHENEVER:
-	case COLD_RESET_WHENEVER:
-		break;
-
-	case WARM_RESET_IMMEDIATELY:
-	case COLD_RESET_IMMEDIATELY:
-		Value = 0x06;
-		LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
-		break;
-
-	default:
-		break;
-	}
-
-	Status = 0;
-	return Status;
-}
-
-AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	AGESA_STATUS Status;
-#ifdef __PRE_RAM__
-	Status = agesa_ReadSPD (Func, Data, ConfigPtr);
-#else
-	Status = AGESA_UNSUPPORTED;
-#endif
-
-	return Status;
-}
-
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-	return AGESA_UNSUPPORTED;
-}
 /*	Call the host environment interface to provide a user hook opportunity. */
 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
diff --git a/src/mainboard/amd/persimmon/agesawrapper.c b/src/mainboard/amd/persimmon/agesawrapper.c
index cf8534ed95..de9d16edcf 100644
--- a/src/mainboard/amd/persimmon/agesawrapper.c
+++ b/src/mainboard/amd/persimmon/agesawrapper.c
@@ -23,9 +23,7 @@
 
 #define __SIMPLE_DEVICE__
 
-#include <arch/acpi.h>
 #include <arch/io.h>
-#include <cbmem.h>
 #include <cpu/x86/msr.h>
 #include <cpu/x86/mtrr.h>
 #include <stdint.h>
@@ -224,23 +222,6 @@ agesawrapper_amdinitearly (
 	return (UINT32)status;
 }
 
-UINT32 GetHeapBase(
-	AMD_CONFIG_PARAMS *StdHeader
-	)
-{
-	UINT32 heap;
-
-#if CONFIG_HAVE_ACPI_RESUME
-	/* Both romstage and ramstage has this S3 detect. */
-	if (acpi_get_sleep_type() == 3)
-		heap = (UINT32)cbmem_find(CBMEM_ID_RESUME_SCRATCH) + (CONFIG_HIGH_SCRATCH_MEMORY_SIZE - BIOS_HEAP_SIZE); /* himem_heap_base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
diff --git a/src/mainboard/amd/persimmon/agesawrapper.h b/src/mainboard/amd/persimmon/agesawrapper.h
index ba47c5336a..3764ab004e 100644
--- a/src/mainboard/amd/persimmon/agesawrapper.h
+++ b/src/mainboard/amd/persimmon/agesawrapper.h
@@ -90,6 +90,4 @@ UINT32 agesawrapper_amds3laterestore (void);
 UINT32 agesawrapper_amdlaterunaptask (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 void *agesawrapper_getlateinitptr (int pick);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/amd/south_station/BiosCallOuts.c b/src/mainboard/amd/south_station/BiosCallOuts.c
index 2aca184955..5ca88540c9 100644
--- a/src/mainboard/amd/south_station/BiosCallOuts.c
+++ b/src/mainboard/amd/south_station/BiosCallOuts.c
@@ -95,348 +95,6 @@ AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
   return CalloutStatus;
 }
 
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  UINT32              AvailableHeapSize;
-  UINT8               *BiosHeapBaseAddr;
-  UINT32              CurrNodeOffset;
-  UINT32              PrevNodeOffset;
-  UINT32              FreedNodeOffset;
-  UINT32              BestFitNodeOffset;
-  UINT32              BestFitPrevNodeOffset;
-  UINT32              NextFreeOffset;
-  BIOS_BUFFER_NODE   *CurrNodePtr;
-  BIOS_BUFFER_NODE   *FreedNodePtr;
-  BIOS_BUFFER_NODE   *BestFitNodePtr;
-  BIOS_BUFFER_NODE   *BestFitPrevNodePtr;
-  BIOS_BUFFER_NODE   *NextFreePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
-  AllocParams->BufferPointer = NULL;
-
-  AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
-    /* First allocation */
-    CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
-    CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-    CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
-    CurrNodePtr->BufferSize = AllocParams->BufferLength;
-    CurrNodePtr->NextNodeOffset = 0;
-    AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
-
-    /* Update the remaining free space */
-    FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
-    FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-    FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
-    FreedNodePtr->NextNodeOffset = 0;
-
-    /* Update the offsets for Allocated and Freed nodes */
-    BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
-    BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
-  } else {
-    /* Find out whether BufferHandle has been allocated on the heap. */
-    /* If it has, return AGESA_BOUNDS_CHK */
-    CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-    CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-
-    while (CurrNodeOffset != 0) {
-      CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-      if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
-        return AGESA_BOUNDS_CHK;
-      }
-      CurrNodeOffset = CurrNodePtr->NextNodeOffset;
-      /* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
-       to the end of the allocated nodes list.
-      */
-
-    }
-    /* Find the node that best fits the requested buffer size */
-    FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-    PrevNodeOffset = FreedNodeOffset;
-    BestFitNodeOffset = 0;
-    BestFitPrevNodeOffset = 0;
-    while (FreedNodeOffset != 0) {
-      FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-      if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-        if (BestFitNodeOffset == 0) {
-          /* First node that fits the requested buffer size */
-          BestFitNodeOffset = FreedNodeOffset;
-          BestFitPrevNodeOffset = PrevNodeOffset;
-        } else {
-          /* Find out whether current node is a better fit than the previous nodes */
-          BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-          if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
-            BestFitNodeOffset = FreedNodeOffset;
-            BestFitPrevNodeOffset = PrevNodeOffset;
-          }
-        }
-      }
-      PrevNodeOffset = FreedNodeOffset;
-      FreedNodeOffset = FreedNodePtr->NextNodeOffset;
-    } /* end of while loop */
-
-
-    if (BestFitNodeOffset == 0) {
-      /* If we could not find a node that fits the requested buffer */
-      /* size, return AGESA_BOUNDS_CHK */
-      return AGESA_BOUNDS_CHK;
-    } else {
-      BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-      BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
-
-      /* If BestFitNode is larger than the requested buffer, fragment the node further */
-      if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-        NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
-
-        NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
-        NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
-        NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
-      } else {
-        /* Otherwise, next free node is NextNodeOffset of BestFitNode */
-        NextFreeOffset = BestFitNodePtr->NextNodeOffset;
-      }
-
-      /* If BestFitNode is the first buffer in the list, then update
-         StartOfFreedNodes to reflect the new free node
-      */
-      if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
-        BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
-      } else {
-        BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
-      }
-
-      /* Add BestFitNode to the list of Allocated nodes */
-      CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
-      BestFitNodePtr->BufferSize = AllocParams->BufferLength;
-      BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
-      BestFitNodePtr->NextNodeOffset = 0;
-
-      /* Remove BestFitNode from list of Freed nodes */
-      AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
-    }
-  }
-
-  return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-
-  UINT8               *BiosHeapBaseAddr;
-  UINT32              AllocNodeOffset;
-  UINT32              PrevNodeOffset;
-  UINT32              NextNodeOffset;
-  UINT32              FreedNodeOffset;
-  UINT32              EndNodeOffset;
-  BIOS_BUFFER_NODE   *AllocNodePtr;
-  BIOS_BUFFER_NODE   *PrevNodePtr;
-  BIOS_BUFFER_NODE   *FreedNodePtr;
-  BIOS_BUFFER_NODE   *NextNodePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-  /* Find target node to deallocate in list of allocated nodes.
-     Return AGESA_BOUNDS_CHK if the BufferHandle is not found
-  */
-  AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-  AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-  PrevNodeOffset = AllocNodeOffset;
-
-  while (AllocNodePtr->BufferHandle !=  AllocParams->BufferHandle) {
-    if (AllocNodePtr->NextNodeOffset == 0) {
-      return AGESA_BOUNDS_CHK;
-    }
-    PrevNodeOffset = AllocNodeOffset;
-    AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-    AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-  }
-
-  /* Remove target node from list of allocated nodes */
-  PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-  PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-
-  /* Zero out the buffer, and clear the BufferHandle */
-  LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
-  AllocNodePtr->BufferHandle = 0;
-  AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
-
-  /* Add deallocated node in order to the list of freed nodes */
-  FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-  FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-
-  EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
-
-  if (AllocNodeOffset < FreedNodeOffset) {
-    /* Add to the start of the freed list */
-    if (EndNodeOffset == FreedNodeOffset) {
-      /* If the freed node is adjacent to the first node in the list, concatenate both nodes */
-      AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
-      AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
-
-      /* Clear the BufferSize and NextNodeOffset of the previous first node */
-      FreedNodePtr->BufferSize = 0;
-      FreedNodePtr->NextNodeOffset = 0;
-
-    } else {
-      /* Otherwise, add freed node to the start of the list
-         Update NextNodeOffset and BufferSize to include the
-         size of BIOS_BUFFER_NODE
-      */
-      AllocNodePtr->NextNodeOffset = FreedNodeOffset;
-    }
-    /* Update StartOfFreedNodes to the new first node */
-    BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
-  } else {
-    /* Traverse list of freed nodes to find where the deallocated node
-       should be place
-    */
-    NextNodeOffset = FreedNodeOffset;
-    NextNodePtr = FreedNodePtr;
-    while (AllocNodeOffset > NextNodeOffset) {
-      PrevNodeOffset = NextNodeOffset;
-      if (NextNodePtr->NextNodeOffset == 0) {
-        break;
-      }
-      NextNodeOffset = NextNodePtr->NextNodeOffset;
-      NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-    }
-
-    /* If deallocated node is adjacent to the next node,
-       concatenate both nodes
-    */
-    if (NextNodeOffset == EndNodeOffset) {
-      NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-      AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
-      AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
-
-      NextNodePtr->BufferSize = 0;
-      NextNodePtr->NextNodeOffset = 0;
-    } else {
-      /*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
-      AllocNodePtr->NextNodeOffset = NextNodeOffset;
-    }
-    /* If deallocated node is adjacent to the previous node,
-       concatenate both nodes
-    */
-    PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-    EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
-    if (AllocNodeOffset == EndNodeOffset) {
-      PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-      PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
-
-      AllocNodePtr->BufferSize = 0;
-      AllocNodePtr->NextNodeOffset = 0;
-    } else {
-      PrevNodePtr->NextNodeOffset = AllocNodeOffset;
-    }
-  }
-  return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  UINT32              AllocNodeOffset;
-  UINT8               *BiosHeapBaseAddr;
-  BIOS_BUFFER_NODE   *AllocNodePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-  AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-
-  while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
-    if (AllocNodePtr->NextNodeOffset == 0) {
-      AllocParams->BufferPointer = NULL;
-      AllocParams->BufferLength = 0;
-      return AGESA_BOUNDS_CHK;
-    } else {
-      AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-      AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-    }
-  }
-
-  AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
-  AllocParams->BufferLength = AllocNodePtr->BufferSize;
-
-  return AGESA_SUCCESS;
-
-}
-
-AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS        Status;
-
-  Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
-  return Status;
-}
-
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS        Status;
-  UINT8                 Value;
-  UINTN               ResetType;
-  AMD_CONFIG_PARAMS   *StdHeader;
-
-  ResetType = Data;
-  StdHeader = ConfigPtr;
-
-  //
-  // Perform the RESET based upon the ResetType. In case of
-  // WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
-  // AmdResetManager. During the critical condition, where reset is required
-  // immediately, the reset will be invoked directly by writing 0x04 to port
-  // 0xCF9 (Reset Port).
-  //
-  switch (ResetType) {
-  case WARM_RESET_WHENEVER:
-  case COLD_RESET_WHENEVER:
-    break;
-
-  case WARM_RESET_IMMEDIATELY:
-  case COLD_RESET_IMMEDIATELY:
-      Value = 0x06;
-      LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
-    break;
-
-  default:
-    break;
-  }
-
-  Status = 0;
-  return Status;
-}
-
-AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS Status;
-#ifdef __PRE_RAM__
-  Status = agesa_ReadSPD (Func, Data, ConfigPtr);
-#else
-  Status = AGESA_UNSUPPORTED;
-#endif
-
-  return Status;
-}
-
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  return AGESA_UNSUPPORTED;
-}
 /*  Call the host environment interface to provide a user hook opportunity. */
 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
diff --git a/src/mainboard/amd/south_station/agesawrapper.c b/src/mainboard/amd/south_station/agesawrapper.c
index fef304d07f..f6ee700ddd 100644
--- a/src/mainboard/amd/south_station/agesawrapper.c
+++ b/src/mainboard/amd/south_station/agesawrapper.c
@@ -259,7 +259,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
+	BiosManagerPtr = (BIOS_HEAP_MANAGER *)GetHeapBase(&AmdParamStruct.StdHeader);
 
 	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
 	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
diff --git a/src/mainboard/amd/union_station/BiosCallOuts.c b/src/mainboard/amd/union_station/BiosCallOuts.c
index 2aca184955..5ca88540c9 100644
--- a/src/mainboard/amd/union_station/BiosCallOuts.c
+++ b/src/mainboard/amd/union_station/BiosCallOuts.c
@@ -95,348 +95,6 @@ AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
   return CalloutStatus;
 }
 
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  UINT32              AvailableHeapSize;
-  UINT8               *BiosHeapBaseAddr;
-  UINT32              CurrNodeOffset;
-  UINT32              PrevNodeOffset;
-  UINT32              FreedNodeOffset;
-  UINT32              BestFitNodeOffset;
-  UINT32              BestFitPrevNodeOffset;
-  UINT32              NextFreeOffset;
-  BIOS_BUFFER_NODE   *CurrNodePtr;
-  BIOS_BUFFER_NODE   *FreedNodePtr;
-  BIOS_BUFFER_NODE   *BestFitNodePtr;
-  BIOS_BUFFER_NODE   *BestFitPrevNodePtr;
-  BIOS_BUFFER_NODE   *NextFreePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
-  AllocParams->BufferPointer = NULL;
-
-  AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
-    /* First allocation */
-    CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
-    CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-    CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
-    CurrNodePtr->BufferSize = AllocParams->BufferLength;
-    CurrNodePtr->NextNodeOffset = 0;
-    AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
-
-    /* Update the remaining free space */
-    FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
-    FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-    FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
-    FreedNodePtr->NextNodeOffset = 0;
-
-    /* Update the offsets for Allocated and Freed nodes */
-    BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
-    BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
-  } else {
-    /* Find out whether BufferHandle has been allocated on the heap. */
-    /* If it has, return AGESA_BOUNDS_CHK */
-    CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-    CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-
-    while (CurrNodeOffset != 0) {
-      CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-      if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
-        return AGESA_BOUNDS_CHK;
-      }
-      CurrNodeOffset = CurrNodePtr->NextNodeOffset;
-      /* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
-       to the end of the allocated nodes list.
-      */
-
-    }
-    /* Find the node that best fits the requested buffer size */
-    FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-    PrevNodeOffset = FreedNodeOffset;
-    BestFitNodeOffset = 0;
-    BestFitPrevNodeOffset = 0;
-    while (FreedNodeOffset != 0) {
-      FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-      if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-        if (BestFitNodeOffset == 0) {
-          /* First node that fits the requested buffer size */
-          BestFitNodeOffset = FreedNodeOffset;
-          BestFitPrevNodeOffset = PrevNodeOffset;
-        } else {
-          /* Find out whether current node is a better fit than the previous nodes */
-          BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-          if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
-            BestFitNodeOffset = FreedNodeOffset;
-            BestFitPrevNodeOffset = PrevNodeOffset;
-          }
-        }
-      }
-      PrevNodeOffset = FreedNodeOffset;
-      FreedNodeOffset = FreedNodePtr->NextNodeOffset;
-    } /* end of while loop */
-
-
-    if (BestFitNodeOffset == 0) {
-      /* If we could not find a node that fits the requested buffer */
-      /* size, return AGESA_BOUNDS_CHK */
-      return AGESA_BOUNDS_CHK;
-    } else {
-      BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
-      BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
-
-      /* If BestFitNode is larger than the requested buffer, fragment the node further */
-      if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
-        NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
-
-        NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
-        NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
-        NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
-      } else {
-        /* Otherwise, next free node is NextNodeOffset of BestFitNode */
-        NextFreeOffset = BestFitNodePtr->NextNodeOffset;
-      }
-
-      /* If BestFitNode is the first buffer in the list, then update
-         StartOfFreedNodes to reflect the new free node
-      */
-      if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
-        BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
-      } else {
-        BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
-      }
-
-      /* Add BestFitNode to the list of Allocated nodes */
-      CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
-      BestFitNodePtr->BufferSize = AllocParams->BufferLength;
-      BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
-      BestFitNodePtr->NextNodeOffset = 0;
-
-      /* Remove BestFitNode from list of Freed nodes */
-      AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
-    }
-  }
-
-  return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-
-  UINT8               *BiosHeapBaseAddr;
-  UINT32              AllocNodeOffset;
-  UINT32              PrevNodeOffset;
-  UINT32              NextNodeOffset;
-  UINT32              FreedNodeOffset;
-  UINT32              EndNodeOffset;
-  BIOS_BUFFER_NODE   *AllocNodePtr;
-  BIOS_BUFFER_NODE   *PrevNodePtr;
-  BIOS_BUFFER_NODE   *FreedNodePtr;
-  BIOS_BUFFER_NODE   *NextNodePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-  /* Find target node to deallocate in list of allocated nodes.
-     Return AGESA_BOUNDS_CHK if the BufferHandle is not found
-  */
-  AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-  AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-  PrevNodeOffset = AllocNodeOffset;
-
-  while (AllocNodePtr->BufferHandle !=  AllocParams->BufferHandle) {
-    if (AllocNodePtr->NextNodeOffset == 0) {
-      return AGESA_BOUNDS_CHK;
-    }
-    PrevNodeOffset = AllocNodeOffset;
-    AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-    AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-  }
-
-  /* Remove target node from list of allocated nodes */
-  PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-  PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-
-  /* Zero out the buffer, and clear the BufferHandle */
-  LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
-  AllocNodePtr->BufferHandle = 0;
-  AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
-
-  /* Add deallocated node in order to the list of freed nodes */
-  FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
-  FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
-
-  EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
-
-  if (AllocNodeOffset < FreedNodeOffset) {
-    /* Add to the start of the freed list */
-    if (EndNodeOffset == FreedNodeOffset) {
-      /* If the freed node is adjacent to the first node in the list, concatenate both nodes */
-      AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
-      AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
-
-      /* Clear the BufferSize and NextNodeOffset of the previous first node */
-      FreedNodePtr->BufferSize = 0;
-      FreedNodePtr->NextNodeOffset = 0;
-
-    } else {
-      /* Otherwise, add freed node to the start of the list
-         Update NextNodeOffset and BufferSize to include the
-         size of BIOS_BUFFER_NODE
-      */
-      AllocNodePtr->NextNodeOffset = FreedNodeOffset;
-    }
-    /* Update StartOfFreedNodes to the new first node */
-    BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
-  } else {
-    /* Traverse list of freed nodes to find where the deallocated node
-       should be place
-    */
-    NextNodeOffset = FreedNodeOffset;
-    NextNodePtr = FreedNodePtr;
-    while (AllocNodeOffset > NextNodeOffset) {
-      PrevNodeOffset = NextNodeOffset;
-      if (NextNodePtr->NextNodeOffset == 0) {
-        break;
-      }
-      NextNodeOffset = NextNodePtr->NextNodeOffset;
-      NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-    }
-
-    /* If deallocated node is adjacent to the next node,
-       concatenate both nodes
-    */
-    if (NextNodeOffset == EndNodeOffset) {
-      NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
-      AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
-      AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
-
-      NextNodePtr->BufferSize = 0;
-      NextNodePtr->NextNodeOffset = 0;
-    } else {
-      /*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
-      AllocNodePtr->NextNodeOffset = NextNodeOffset;
-    }
-    /* If deallocated node is adjacent to the previous node,
-       concatenate both nodes
-    */
-    PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
-    EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
-    if (AllocNodeOffset == EndNodeOffset) {
-      PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
-      PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
-
-      AllocNodePtr->BufferSize = 0;
-      AllocNodePtr->NextNodeOffset = 0;
-    } else {
-      PrevNodePtr->NextNodeOffset = AllocNodeOffset;
-    }
-  }
-  return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  UINT32              AllocNodeOffset;
-  UINT8               *BiosHeapBaseAddr;
-  BIOS_BUFFER_NODE   *AllocNodePtr;
-  BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
-  AGESA_BUFFER_PARAMS *AllocParams;
-
-  AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-  BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
-  BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
-
-  AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-  AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-
-  while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
-    if (AllocNodePtr->NextNodeOffset == 0) {
-      AllocParams->BufferPointer = NULL;
-      AllocParams->BufferLength = 0;
-      return AGESA_BOUNDS_CHK;
-    } else {
-      AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-      AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
-    }
-  }
-
-  AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
-  AllocParams->BufferLength = AllocNodePtr->BufferSize;
-
-  return AGESA_SUCCESS;
-
-}
-
-AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS        Status;
-
-  Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
-  return Status;
-}
-
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS        Status;
-  UINT8                 Value;
-  UINTN               ResetType;
-  AMD_CONFIG_PARAMS   *StdHeader;
-
-  ResetType = Data;
-  StdHeader = ConfigPtr;
-
-  //
-  // Perform the RESET based upon the ResetType. In case of
-  // WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
-  // AmdResetManager. During the critical condition, where reset is required
-  // immediately, the reset will be invoked directly by writing 0x04 to port
-  // 0xCF9 (Reset Port).
-  //
-  switch (ResetType) {
-  case WARM_RESET_WHENEVER:
-  case COLD_RESET_WHENEVER:
-    break;
-
-  case WARM_RESET_IMMEDIATELY:
-  case COLD_RESET_IMMEDIATELY:
-      Value = 0x06;
-      LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
-    break;
-
-  default:
-    break;
-  }
-
-  Status = 0;
-  return Status;
-}
-
-AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  AGESA_STATUS Status;
-#ifdef __PRE_RAM__
-  Status = agesa_ReadSPD (Func, Data, ConfigPtr);
-#else
-  Status = AGESA_UNSUPPORTED;
-#endif
-
-  return Status;
-}
-
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
-{
-  return AGESA_UNSUPPORTED;
-}
 /*  Call the host environment interface to provide a user hook opportunity. */
 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
diff --git a/src/mainboard/amd/union_station/agesawrapper.c b/src/mainboard/amd/union_station/agesawrapper.c
index fef304d07f..f6ee700ddd 100644
--- a/src/mainboard/amd/union_station/agesawrapper.c
+++ b/src/mainboard/amd/union_station/agesawrapper.c
@@ -259,7 +259,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
+	BiosManagerPtr = (BIOS_HEAP_MANAGER *)GetHeapBase(&AmdParamStruct.StdHeader);
 
 	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
 	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {