AGESA: Use common heap allocator

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

11 files changed, 32 insertions, 1676 deletions

diff --git a/src/northbridge/amd/agesa/def_callouts.h b/src/northbridge/amd/agesa/def_callouts.h
index 3b14cbf03e..033abc31ec 100644
--- a/src/northbridge/amd/agesa/def_callouts.h
+++ b/src/northbridge/amd/agesa/def_callouts.h
@@ -25,6 +25,38 @@
 #include "Porting.h"
 #include "AGESA.h"
 
+#if CONFIG_NORTHBRIDGE_AMD_AGESA_FAMILY15_TN || CONFIG_NORTHBRIDGE_AMD_AGESA_FAMILY16_KB
+
+#define BIOS_HEAP_START_ADDRESS 	0x010000000
+#define BIOS_HEAP_SIZE			0x30000
+#define BSP_STACK_BASE_ADDR		0x30000
+
+#else
+
+#define BIOS_HEAP_START_ADDRESS		0x10000 /* HEAP during cold boot */
+#define BIOS_HEAP_SIZE			0x20000
+#define BSP_STACK_BASE_ADDR		0x30000
+
+#endif
+
+typedef struct _BIOS_HEAP_MANAGER {
+	UINT32 StartOfAllocatedNodes;
+	UINT32 StartOfFreedNodes;
+} BIOS_HEAP_MANAGER;
+
+typedef struct _BIOS_BUFFER_NODE {
+	UINT32 BufferHandle;
+	UINT32 BufferSize;
+	UINT32 NextNodeOffset;
+} BIOS_BUFFER_NODE;
+
+UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
+void EmptyHeap(void);
+
+
+AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS agesa_DeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS agesa_LocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 AGESA_STATUS agesa_NoopUnsupported (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 AGESA_STATUS agesa_NoopSuccess (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
diff --git a/src/northbridge/amd/agesa/family12/fam12_callouts.c b/src/northbridge/amd/agesa/family12/fam12_callouts.c
index 2f8406cf9d..203c883b05 100644
--- a/src/northbridge/amd/agesa/family12/fam12_callouts.c
+++ b/src/northbridge/amd/agesa/family12/fam12_callouts.c
@@ -25,312 +25,6 @@
 #include "OptionsIds.h"
 #include "heapManager.h"
 #include "Hudson-2.h"
-#include <cbmem.h>
-#include <arch/acpi.h>
-#include <string.h>
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
-{
-	UINT32 heap = BIOS_HEAP_START_ADDRESS;
-
-#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 */
-#endif
-
-	return heap;
-}
-
-void EmptyHeap(void)
-{
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
-	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
-}
-
-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;
-
-	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 BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
diff --git a/src/northbridge/amd/agesa/family12/fam12_callouts.h b/src/northbridge/amd/agesa/family12/fam12_callouts.h
index 7259594add..6fb9fbb08d 100644
--- a/src/northbridge/amd/agesa/family12/fam12_callouts.h
+++ b/src/northbridge/amd/agesa/family12/fam12_callouts.h
@@ -23,33 +23,8 @@
 #include "Porting.h"
 #include "AGESA.h"
 
-#define BIOS_HEAP_START_ADDRESS			0x10000 /* HEAP during cold boot */
-#define BIOS_HEAP_SIZE				0x20000
-#define BSP_STACK_BASE_ADDR			0x30000
-
-typedef struct _BIOS_HEAP_MANAGER {
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-void EmptyHeap(void);
-
-/* REQUIRED CALLOUTS
- * AGESA ADVANCED CALLOUTS - CPU
- */
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 /* AGESA ADVANCED CALLOUTS - MEMORY */
 AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
 
-
 #endif /* CALLOUTS_AMD_AGESA_FAM12_H */
diff --git a/src/northbridge/amd/agesa/family14/fam14_callouts.c b/src/northbridge/amd/agesa/family14/fam14_callouts.c
index ac309c54d6..05d378dc5a 100644
--- a/src/northbridge/amd/agesa/family14/fam14_callouts.c
+++ b/src/northbridge/amd/agesa/family14/fam14_callouts.c
@@ -23,314 +23,6 @@
 #include "heapManager.h"
 #include "SB800.h"
 #include "dimmSpd.h"
-#include <cbmem.h>
-#include <arch/acpi.h>
-#include <string.h>
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
-{
-	UINT32 heap = BIOS_HEAP_START_ADDRESS;
-
-#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 */
-#endif
-
-	return heap;
-}
-
-void EmptyHeap(void)
-{
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
-	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
-}
-
-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;
-
-}
 
 
 
diff --git a/src/northbridge/amd/agesa/family14/fam14_callouts.h b/src/northbridge/amd/agesa/family14/fam14_callouts.h
index 2ad6258569..c88576167a 100755
--- a/src/northbridge/amd/agesa/family14/fam14_callouts.h
+++ b/src/northbridge/amd/agesa/family14/fam14_callouts.h
@@ -24,31 +24,6 @@
 #include "Porting.h"
 #include "AGESA.h"
 
-#define BIOS_HEAP_START_ADDRESS			0x10000 /* HEAP during cold boot */
-#define BIOS_HEAP_SIZE				0x20000
-#define BSP_STACK_BASE_ADDR			0x30000
-
-typedef struct _BIOS_HEAP_MANAGER {
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-void EmptyHeap(void);
-
-/* REQUIRED CALLOUTS
- * AGESA ADVANCED CALLOUTS - CPU
- */
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
 /* AGESA ADVANCED CALLOUTS - MEMORY */
 AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
 AGESA_STATUS BiosReadSpd_from_cbfs(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
diff --git a/src/northbridge/amd/agesa/family15/fam15_callouts.c b/src/northbridge/amd/agesa/family15/fam15_callouts.c
index 74876fb645..5aa50ef261 100644
--- a/src/northbridge/amd/agesa/family15/fam15_callouts.c
+++ b/src/northbridge/amd/agesa/family15/fam15_callouts.c
@@ -25,310 +25,4 @@
 #include "heapManager.h"
 #include <northbridge/amd/agesa/family15/dimmSpd.h>
 #include <arch/io.h>
-#include <arch/acpi.h>
-#include <cbmem.h>
-#include <string.h>
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
-{
-	UINT32 heap = BIOS_HEAP_START_ADDRESS;
-
-#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 */
-#endif
-
-	return heap;
-}
-
-void EmptyHeap(void)
-{
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
-	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
-}
-
-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;
-
-	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;
-
-}
 
diff --git a/src/northbridge/amd/agesa/family15/fam15_callouts.h b/src/northbridge/amd/agesa/family15/fam15_callouts.h
index 5e95c4388c..2be43db14c 100644
--- a/src/northbridge/amd/agesa/family15/fam15_callouts.h
+++ b/src/northbridge/amd/agesa/family15/fam15_callouts.h
@@ -21,33 +21,6 @@
 #ifndef CALLOUTS_AMD_AGESA_FAM15_H
 #define CALLOUTS_AMD_AGESA_FAM15_H
 
-#include "Porting.h"
-#include "AGESA.h"
-
-#define BIOS_HEAP_START_ADDRESS			0x10000 /* HEAP during cold boot */
-#define BIOS_HEAP_SIZE				0x20000
-#define BSP_STACK_BASE_ADDR			0x30000
-
-typedef struct _BIOS_HEAP_MANAGER {
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-void EmptyHeap(void);
-
-/* REQUIRED CALLOUTS
- * AGESA ADVANCED CALLOUTS - CPU
- */
-AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 
 /*	Call the host environment interface to provide a user hook opportunity. */
diff --git a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
index cda4753fae..3cd81c69e0 100644
--- a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
+++ b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
@@ -26,337 +26,6 @@
 #include "cbfs.h"
 #include "dimmSpd.h"
 #include "fam15tn_callouts.h"
-#include <cbmem.h>
-#include <arch/acpi.h>
-#include <string.h>
-
-#define AGESA_RUNTIME_SIZE 4096
-
-static AGESA_STATUS alloc_cbmem(AGESA_BUFFER_PARAMS *AllocParams) {
-	static unsigned int used = 0;
-	void *p = cbmem_find(CBMEM_ID_AGESA_RUNTIME);
-
-	if ((AGESA_RUNTIME_SIZE - used) < AllocParams->BufferLength) {
-		return AGESA_BOUNDS_CHK;
-	}
-
-	/* first time allocation */
-	if (!p) {
-		p = cbmem_add(CBMEM_ID_AGESA_RUNTIME, AGESA_RUNTIME_SIZE);
-		if (!p)
-			return AGESA_BOUNDS_CHK;
-	}
-
-	AllocParams->BufferPointer = p + used;
-	used += AllocParams->BufferLength;
-	return AGESA_SUCCESS;
-}
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
-{
-	UINT32 heap = BIOS_HEAP_START_ADDRESS;
-
-#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 */
-#endif
-
-	return heap;
-}
-
-void EmptyHeap(void)
-{
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
-	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
-}
-
-AGESA_STATUS fam15tn_AllocateBuffer (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;
-
-	/* if the allocation is for runtime use simple CBMEM data */
-	if (Data == HEAP_CALLOUT_RUNTIME)
-		return alloc_cbmem(AllocParams);
-
-	AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) 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 fam15tn_DeallocateBuffer (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 fam15tn_LocateBuffer (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 fam15tn_ReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
diff --git a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
index 355172df1d..6864b5049a 100644
--- a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
+++ b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
@@ -23,28 +23,6 @@
 #include "Porting.h"
 #include "AGESA.h"
 
-#define BIOS_HEAP_START_ADDRESS  0x010000000
-#define BIOS_HEAP_SIZE				0x30000
-#define BSP_STACK_BASE_ADDR			0x30000
-
-
-typedef struct _BIOS_HEAP_MANAGER {
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-void EmptyHeap(void);
-
-AGESA_STATUS fam15tn_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS fam15tn_DeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS fam15tn_LocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 AGESA_STATUS fam15tn_ReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
diff --git a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
index d98cbe358f..87e2dc8748 100644
--- a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
+++ b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
@@ -26,311 +26,7 @@
 #include "cbfs.h"
 #include "dimmSpd.h"
 #include "fam16kb_callouts.h"
-#include <cbmem.h>
-#include <arch/acpi.h>
-#include <string.h>
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
-{
-	UINT32 heap = BIOS_HEAP_START_ADDRESS;
-
-#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 */
-#endif
-
-	return heap;
-}
-
-void EmptyHeap(void)
-{
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
-	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
-}
-
-AGESA_STATUS fam16kb_AllocateBuffer (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;
-
-	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 fam16kb_DeallocateBuffer (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 fam16kb_LocateBuffer (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;
-
-}
 
 
 
diff --git a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
index 927f096d6e..c83ae27727 100644
--- a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
+++ b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
@@ -23,28 +23,6 @@
 #include "Porting.h"
 #include "AGESA.h"
 
-#define BIOS_HEAP_START_ADDRESS  0x010000000
-#define BIOS_HEAP_SIZE				0x30000
-#define BSP_STACK_BASE_ADDR			0x30000
-
-
-typedef struct _BIOS_HEAP_MANAGER {
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-void EmptyHeap(void);
-
-AGESA_STATUS fam16kb_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS fam16kb_DeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS fam16kb_LocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 AGESA_STATUS fam16kb_ReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr);