[coreboot-gerrit] Patch set updated for coreboot: c8cd5ac AGESA: refactor

Kyösti Mälkki (kyosti.malkki@gmail.com) gerrit at coreboot.org
Sat May 3 13:43:04 CEST 2014


Kyösti Mälkki (kyosti.malkki at gmail.com) just uploaded a new patch set to gerrit, which you can find at http://review.coreboot.org/5632

-gerrit

commit c8cd5ac71a1443ddec96de06bcaddd1da97895e3
Author: Kyösti Mälkki <kyosti.malkki at gmail.com>
Date:   Thu May 1 15:35:34 2014 +0300

    AGESA: refactor
    
    Some ideas backported from fam15tn and fam16kb.
    
    Heap manager is really the same for all families but this one
    still has the five copies under northbridge/.
    
    Adds GetHeapBase() for fam12, fam15 and remaining fam14 boards,
    part of HAVE_ACPI_RESUME support.
    
    Change-Id: Ic84e288fae0e257522fb63027c88224f471c8b28
    Signed-off-by: Kyösti Mälkki <kyosti.malkki at gmail.com>
---
 src/mainboard/amd/dinar/BiosCallOuts.c             | 330 -----------------
 src/mainboard/amd/dinar/BiosCallOuts.h             |  50 +--
 src/mainboard/amd/dinar/agesawrapper.c             |  14 +-
 src/mainboard/amd/inagua/BiosCallOuts.c            | 339 ------------------
 src/mainboard/amd/inagua/BiosCallOuts.h            |  50 +--
 src/mainboard/amd/inagua/agesawrapper.c            |  13 +-
 src/mainboard/amd/olivehill/agesawrapper.c         |  33 +-
 src/mainboard/amd/olivehill/agesawrapper.h         |   2 -
 src/mainboard/amd/parmer/agesawrapper.c            |  32 +-
 src/mainboard/amd/parmer/agesawrapper.h            |   2 -
 src/mainboard/amd/persimmon/BiosCallOuts.c         | 344 ------------------
 src/mainboard/amd/persimmon/BiosCallOuts.h         |  51 +--
 src/mainboard/amd/persimmon/agesawrapper.c         |  32 +-
 src/mainboard/amd/persimmon/agesawrapper.h         |   2 -
 src/mainboard/amd/south_station/BiosCallOuts.c     | 342 ------------------
 src/mainboard/amd/south_station/BiosCallOuts.h     |  50 +--
 src/mainboard/amd/south_station/agesawrapper.c     |  13 +-
 src/mainboard/amd/thatcher/agesawrapper.c          |  33 +-
 src/mainboard/amd/thatcher/agesawrapper.h          |   2 -
 src/mainboard/amd/torpedo/BiosCallOuts.c           | 340 ------------------
 src/mainboard/amd/torpedo/BiosCallOuts.h           |  51 +--
 src/mainboard/amd/torpedo/Makefile.inc             |   2 -
 src/mainboard/amd/torpedo/agesawrapper.c           |  14 +-
 src/mainboard/amd/torpedo/dimmSpd.c                | 241 -------------
 src/mainboard/amd/torpedo/dimmSpd.h                |  63 ----
 src/mainboard/amd/union_station/BiosCallOuts.c     | 342 ------------------
 src/mainboard/amd/union_station/BiosCallOuts.h     |  50 +--
 src/mainboard/amd/union_station/agesawrapper.c     |  13 +-
 src/mainboard/asrock/e350m1/BiosCallOuts.c         | 342 ------------------
 src/mainboard/asrock/e350m1/BiosCallOuts.h         |  48 +--
 src/mainboard/asrock/e350m1/agesawrapper.c         |  13 +-
 src/mainboard/asrock/imb-a180/agesawrapper.c       |  33 +-
 src/mainboard/asrock/imb-a180/agesawrapper.h       |   2 -
 src/mainboard/asus/f2a85-m/agesawrapper.c          |  33 +-
 src/mainboard/asus/f2a85-m/agesawrapper.h          |   2 -
 src/mainboard/gizmosphere/gizmo/BiosCallOuts.c     | 336 +-----------------
 src/mainboard/gizmosphere/gizmo/BiosCallOuts.h     |  50 +--
 src/mainboard/gizmosphere/gizmo/agesawrapper.c     |  32 +-
 src/mainboard/gizmosphere/gizmo/agesawrapper.h     |   2 -
 src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.c |  33 +-
 src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.h |   2 -
 src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.c   | 357 +------------------
 src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.h   |  54 +--
 src/mainboard/jetway/nf81-t56n-lf/agesawrapper.c   |  32 +-
 src/mainboard/jetway/nf81-t56n-lf/agesawrapper.h   |   6 +-
 .../lippert/frontrunner-af/BiosCallOuts.c          | 344 ------------------
 .../lippert/frontrunner-af/BiosCallOuts.h          |  51 +--
 .../lippert/frontrunner-af/agesawrapper.c          |  32 +-
 .../lippert/frontrunner-af/agesawrapper.h          |   2 -
 src/mainboard/lippert/toucan-af/BiosCallOuts.c     | 344 ------------------
 src/mainboard/lippert/toucan-af/BiosCallOuts.h     |  51 +--
 src/mainboard/lippert/toucan-af/agesawrapper.c     |  32 +-
 src/mainboard/lippert/toucan-af/agesawrapper.h     |   2 -
 src/mainboard/supermicro/h8qgi/BiosCallOuts.c      | 331 -----------------
 src/mainboard/supermicro/h8qgi/BiosCallOuts.h      |  48 +--
 src/mainboard/supermicro/h8qgi/agesawrapper.c      |  13 +-
 src/mainboard/supermicro/h8scm/BiosCallOuts.c      | 331 -----------------
 src/mainboard/supermicro/h8scm/BiosCallOuts.h      |  45 +--
 src/mainboard/supermicro/h8scm/agesawrapper.c      |  13 +-
 src/mainboard/tyan/s8226/BiosCallOuts.c            | 331 -----------------
 src/mainboard/tyan/s8226/BiosCallOuts.h            |  48 +--
 src/mainboard/tyan/s8226/agesawrapper.c            |  13 +-
 src/northbridge/amd/agesa/family12/Makefile.inc    |   5 +
 src/northbridge/amd/agesa/family12/dimmSpd.c       | 241 +++++++++++++
 src/northbridge/amd/agesa/family12/dimmSpd.h       |  63 ++++
 .../amd/agesa/family12/fam12_callouts.c            | 390 ++++++++++++++++++++
 .../amd/agesa/family12/fam12_callouts.h            |  71 ++++
 src/northbridge/amd/agesa/family14/Makefile.inc    |   2 +
 .../amd/agesa/family14/fam14_callouts.c            | 394 +++++++++++++++++++++
 .../amd/agesa/family14/fam14_callouts.h            |  73 ++++
 src/northbridge/amd/agesa/family15/Makefile.inc    |   2 +
 .../amd/agesa/family15/fam15_callouts.c            | 382 ++++++++++++++++++++
 .../amd/agesa/family15/fam15_callouts.h            |  73 ++++
 .../amd/agesa/family15tn/fam15tn_callouts.c        |  23 ++
 .../amd/agesa/family15tn/fam15tn_callouts.h        |   3 +
 .../amd/agesa/family16kb/fam16kb_callouts.c        |  24 ++
 .../amd/agesa/family16kb/fam16kb_callouts.h        |   3 +
 77 files changed, 1829 insertions(+), 6178 deletions(-)

diff --git a/src/mainboard/amd/dinar/BiosCallOuts.c b/src/mainboard/amd/dinar/BiosCallOuts.c
index c9888b9..47bf962 100644
--- a/src/mainboard/amd/dinar/BiosCallOuts.c
+++ b/src/mainboard/amd/dinar/BiosCallOuts.c
@@ -220,332 +220,6 @@ AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 }
 
 
-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 (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;
@@ -565,10 +239,6 @@ AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	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/dinar/BiosCallOuts.h b/src/mainboard/amd/dinar/BiosCallOuts.h
index 4159076..179634d 100644
--- a/src/mainboard/amd/dinar/BiosCallOuts.h
+++ b/src/mainboard/amd/dinar/BiosCallOuts.h
@@ -20,54 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family15/fam15_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-	//UINT32 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -76,4 +33,5 @@ AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
+
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/dinar/agesawrapper.c b/src/mainboard/amd/dinar/agesawrapper.c
index d61c5dc..3b717a0 100644
--- a/src/mainboard/amd/dinar/agesawrapper.c
+++ b/src/mainboard/amd/dinar/agesawrapper.c
@@ -392,10 +392,7 @@ agesawrapper_amdinitpost (
 		)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 			0,
@@ -419,16 +416,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/inagua/BiosCallOuts.c b/src/mainboard/amd/inagua/BiosCallOuts.c
index 452a592..b3a73f4 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/BiosCallOuts.h b/src/mainboard/amd/inagua/BiosCallOuts.h
index 35056fa..f3483e7 100644
--- a/src/mainboard/amd/inagua/BiosCallOuts.h
+++ b/src/mainboard/amd/inagua/BiosCallOuts.h
@@ -20,54 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-	//UINT32 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -76,4 +33,5 @@ AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
+
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/inagua/agesawrapper.c b/src/mainboard/amd/inagua/agesawrapper.c
index ea07cf5..44b349c 100644
--- a/src/mainboard/amd/inagua/agesawrapper.c
+++ b/src/mainboard/amd/inagua/agesawrapper.c
@@ -239,10 +239,7 @@ agesawrapper_amdinitpost (
 		)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -259,15 +256,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/olivehill/agesawrapper.c b/src/mainboard/amd/olivehill/agesawrapper.c
index a1cf7de..76ef5e2 100644
--- a/src/mainboard/amd/olivehill/agesawrapper.c
+++ b/src/mainboard/amd/olivehill/agesawrapper.c
@@ -41,8 +41,6 @@
 #include "FchPlatform.h"
 #include "Fch.h"
 #include <cpu/amd/agesa/s3_resume.h>
-#include <cbmem.h>
-#include <arch/acpi.h>
 #include <arch/io.h>
 #include <device/device.h>
 #include "hudson.h"
@@ -248,34 +246,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -295,16 +273,7 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	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++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/olivehill/agesawrapper.h b/src/mainboard/amd/olivehill/agesawrapper.h
index 5007510..579350f 100644
--- a/src/mainboard/amd/olivehill/agesawrapper.h
+++ b/src/mainboard/amd/olivehill/agesawrapper.h
@@ -92,6 +92,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/amd/parmer/agesawrapper.c b/src/mainboard/amd/parmer/agesawrapper.c
index 827ce6d..bbe72c1 100644
--- a/src/mainboard/amd/parmer/agesawrapper.c
+++ b/src/mainboard/amd/parmer/agesawrapper.c
@@ -41,8 +41,6 @@
 #include "FchPlatform.h"
 #include "Fch.h"
 #include <cpu/amd/agesa/s3_resume.h>
-#include <cbmem.h>
-#include <arch/acpi.h>
 #include <arch/io.h>
 #include <device/device.h>
 #include "hudson.h"
@@ -248,34 +246,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -295,16 +273,8 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)GetHeapBase(&AmdParamStruct.StdHeader);
+	GetEmptyHeap();
 
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/parmer/agesawrapper.h b/src/mainboard/amd/parmer/agesawrapper.h
index 5007510..579350f 100644
--- a/src/mainboard/amd/parmer/agesawrapper.h
+++ b/src/mainboard/amd/parmer/agesawrapper.h
@@ -92,6 +92,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/amd/persimmon/BiosCallOuts.c b/src/mainboard/amd/persimmon/BiosCallOuts.c
index 700da08..6395484 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/BiosCallOuts.h b/src/mainboard/amd/persimmon/BiosCallOuts.h
index c4f4f70..92e8ce5 100644
--- a/src/mainboard/amd/persimmon/BiosCallOuts.h
+++ b/src/mainboard/amd/persimmon/BiosCallOuts.h
@@ -20,54 +20,9 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.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 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/persimmon/agesawrapper.c b/src/mainboard/amd/persimmon/agesawrapper.c
index cf8534e..79d84ed 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,33 +222,13 @@ 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
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -267,15 +245,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	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++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/persimmon/agesawrapper.h b/src/mainboard/amd/persimmon/agesawrapper.h
index ba47c53..3764ab0 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 2aca184..5ca8854 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/BiosCallOuts.h b/src/mainboard/amd/south_station/BiosCallOuts.h
index be14425..f3483e7 100644
--- a/src/mainboard/amd/south_station/BiosCallOuts.h
+++ b/src/mainboard/amd/south_station/BiosCallOuts.h
@@ -20,54 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-  //UINT32 AvailableSize;
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -76,4 +33,5 @@ AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
+
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/south_station/agesawrapper.c b/src/mainboard/amd/south_station/agesawrapper.c
index fef304d..990ee7d 100644
--- a/src/mainboard/amd/south_station/agesawrapper.c
+++ b/src/mainboard/amd/south_station/agesawrapper.c
@@ -239,10 +239,7 @@ agesawrapper_amdinitpost (
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -259,15 +256,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/thatcher/agesawrapper.c b/src/mainboard/amd/thatcher/agesawrapper.c
index c50f3a0..533e8f2 100644
--- a/src/mainboard/amd/thatcher/agesawrapper.c
+++ b/src/mainboard/amd/thatcher/agesawrapper.c
@@ -41,8 +41,6 @@
 #include "FchPlatform.h"
 #include "Fch.h"
 #include <cpu/amd/agesa/s3_resume.h>
-#include <cbmem.h>
-#include <arch/acpi.h>
 #include <arch/io.h>
 #include <device/device.h>
 #include "hudson.h"
@@ -246,34 +244,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -293,16 +271,7 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	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++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/amd/thatcher/agesawrapper.h b/src/mainboard/amd/thatcher/agesawrapper.h
index 5007510..579350f 100644
--- a/src/mainboard/amd/thatcher/agesawrapper.h
+++ b/src/mainboard/amd/thatcher/agesawrapper.h
@@ -92,6 +92,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/amd/torpedo/BiosCallOuts.c b/src/mainboard/amd/torpedo/BiosCallOuts.c
index 7d49c07..a52b8bc 100644
--- a/src/mainboard/amd/torpedo/BiosCallOuts.c
+++ b/src/mainboard/amd/torpedo/BiosCallOuts.c
@@ -19,7 +19,6 @@
 
 #include "agesawrapper.h"
 #include "amdlib.h"
-#include "dimmSpd.h"
 #include "BiosCallOuts.h"
 #include "Ids.h"
 #include "OptionsIds.h"
@@ -171,345 +170,6 @@ AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
   return AGESA_SUCCESS;
 }
 
-
-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 (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;
-  Status = AmdMemoryReadSPD (Func, Data, (AGESA_READ_SPD_PARAMS *)ConfigPtr);
-
-  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/torpedo/BiosCallOuts.h b/src/mainboard/amd/torpedo/BiosCallOuts.h
index a68f0f1..16b70b4 100644
--- a/src/mainboard/amd/torpedo/BiosCallOuts.h
+++ b/src/mainboard/amd/torpedo/BiosCallOuts.h
@@ -20,57 +20,14 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family12/fam12_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
-
-typedef struct _BIOS_HEAP_MANAGER {
-  //UINT32 AvailableSize;
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 // These registers are not defined in cimx/SB900/Hudson-2.h
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG15   15
 #define SB_GPIO_REG25   25
+
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/torpedo/Makefile.inc b/src/mainboard/amd/torpedo/Makefile.inc
index 1102ea2..86b025b 100644
--- a/src/mainboard/amd/torpedo/Makefile.inc
+++ b/src/mainboard/amd/torpedo/Makefile.inc
@@ -33,14 +33,12 @@ endif
 
 romstage-y += buildOpts.c
 romstage-y += agesawrapper.c
-romstage-y += dimmSpd.c
 romstage-y += BiosCallOuts.c
 romstage-y += PlatformGnbPcie.c
 romstage-y += gpio.c
 
 ramstage-y += buildOpts.c
 ramstage-y += agesawrapper.c
-ramstage-y += dimmSpd.c
 ramstage-y += BiosCallOuts.c
 ramstage-y += PlatformGnbPcie.c
 
diff --git a/src/mainboard/amd/torpedo/agesawrapper.c b/src/mainboard/amd/torpedo/agesawrapper.c
index 45b591a..e4e4bfd 100644
--- a/src/mainboard/amd/torpedo/agesawrapper.c
+++ b/src/mainboard/amd/torpedo/agesawrapper.c
@@ -368,10 +368,7 @@ agesawrapper_amdinitpost (
   )
 {
   AGESA_STATUS status;
-  UINT16                  i;
-  UINT32          *HeadPtr;
   AMD_INTERFACE_PARAMS  AmdParamStruct;
-  BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
   LibAmdMemFill (&AmdParamStruct,
                  0,
@@ -391,16 +388,7 @@ agesawrapper_amdinitpost (
   AmdReleaseStruct (&AmdParamStruct);
 
   /* Initialize heap space */
-  BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-  HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-  for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++)
-  {
-    *HeadPtr = 0x00000000;
-    HeadPtr++;
-  }
-  BiosManagerPtr->StartOfAllocatedNodes = 0;
-  BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
   return (UINT32)status;
 }
diff --git a/src/mainboard/amd/torpedo/dimmSpd.c b/src/mainboard/amd/torpedo/dimmSpd.c
deleted file mode 100644
index 55fb2c3..0000000
--- a/src/mainboard/amd/torpedo/dimmSpd.c
+++ /dev/null
@@ -1,241 +0,0 @@
-/*****************************************************************************
- *
- * Copyright (c) 2011, Advanced Micro Devices, Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of Advanced Micro Devices, Inc. nor the names of
- *       its contributors may be used to endorse or promote products derived
- *       from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ***************************************************************************/
-
-/*----------------------------------------------------------------------------------------
- *                             M O D U L E S    U S E D
- *----------------------------------------------------------------------------------------
- */
-
-#include "Porting.h"
-#include "AGESA.h"
-#include "amdlib.h"
-#include "dimmSpd.h"
-
-/*----------------------------------------------------------------------------------------
- *                   D E F I N I T I O N S    A N D    M A C R O S
- *----------------------------------------------------------------------------------------
- */
-#define SMBUS_BASE_ADDR  0xB00
-#define DIMENSION(array)(sizeof (array)/ sizeof (array [0]))
-
-/*----------------------------------------------------------------------------------------
- *                  T Y P E D E F S     A N D     S T R U C T U  R E S
- *----------------------------------------------------------------------------------------
- */
-
-typedef struct _DIMM_INFO_SMBUS{
-  UINT8   SocketId;
-  UINT8   MemChannelId;
-  UINT8   DimmId;
-  UINT8   SmbusAddress;
-} DIMM_INFO_SMBUS;
-/*
-* SPD address table - porting required
-*/
-STATIC CONST DIMM_INFO_SMBUS SpdAddrLookup [] =
-{
-  /* Socket, Channel, Dimm, Smbus */
-  {0, 0, 0, 0xA0},
-  {0, 1, 0, 0xA2}
-};
-
-/*----------------------------------------------------------------------------------------
- *           P R O T O T Y P E S     O F     L O C A L     F U  N C T I O N S
- *----------------------------------------------------------------------------------------
- */
-
-/*----------------------------------------------------------------------------------------
- *                          E X P O R T E D    F U N C T I O N S
- *----------------------------------------------------------------------------------------
- */
-
-/*---------------------------------------------------------------------------------------
- *                          L O C A L    F U N C T I O N S
- *---------------------------------------------------------------------------------------
- */
-
-STATIC
-VOID
-WritePmReg (
-  IN UINT8 Reg,
-  IN UINT8 Data
-  )
-{
-   __outbyte (0xCD6, Reg);
-   __outbyte (0xCD7, Data);
-}
-STATIC
-VOID
-SetupFch (
-  IN UINT16
-  IN IoBase
-  )
-{
-   WritePmReg (0x2D, IoBase >> 8);
-   WritePmReg (0x2C, IoBase | 1);
-   WritePmReg (0x29, 0x80);
-   WritePmReg (0x28, 0x61);
-   /* set SMBus clock to 400 KHz */
-   __outbyte (IoBase + 0x0E, 66000000 / 400000 / 4);
-}
-
-/*
- *
- * ReadSmbusByteData - read a single SPD byte from any offset
- *
- */
-
-STATIC
-AGESA_STATUS
-ReadSmbusByteData (
-  IN UINT16 Iobase,
-  IN UINT8  Address,
-  OUT UINT8 *Buffer,
-  IN UINTN  Offset
-  )
-{
-   UINTN  Status;
-   UINT64 Limit;
-
-   Address |= 1; // set read bit
-
-   __outbyte (Iobase + 0, 0xFF);                // clear error status
-   __outbyte (Iobase + 1, 0x1F);                // clear error status
-   __outbyte (Iobase + 3, Offset);              // offset in eeprom
-   __outbyte (Iobase + 4, Address);             // slave address and read bit
-   __outbyte (Iobase + 2, 0x48);                // read byte command
-
-   /* time limit to avoid hanging for unexpected error status (should never happen) */
-   Limit = __rdtsc () + 2000000000 / 10;
-   for (;;) {
-     Status = __inbyte (Iobase);
-     if (__rdtsc () > Limit) break;
-     if ((Status & 2) == 0) continue;               // SMBusInterrupt not set, keep waiting
-     if ((Status & 1) == 1) continue;               // HostBusy set, keep waiting
-     break;
-   }
-
-   Buffer [0] = __inbyte (Iobase + 5);
-   if (Status == 2) Status = 0;                      // check for done with no errors
-   return Status;
-   }
-
-/*
- *
- * ReadSmbusByte - read a single SPD byte from the default offset
- *                 this function is faster function readSmbusByteData
- *
- */
-
-STATIC
-AGESA_STATUS
-ReadSmbusByte (
-  IN UINT16 Iobase,
-  IN UINT8  Address,
-  OUT UINT8 *Buffer
-  )
-{
-  UINTN   Status;
-  UINT64  Limit;
-
-  __outbyte (Iobase + 0, 0xFF);                // clear error status
-  __outbyte (Iobase + 2, 0x44);                // read command
-
-  // time limit to avoid hanging for unexpected error status
-  Limit = __rdtsc () + 2000000000 / 10;
-  for (;;) {
-    Status = __inbyte (Iobase);
-    if (__rdtsc () > Limit) break;
-    if ((Status & 2) == 0) continue;               // SMBusInterrupt not set, keep waiting
-    if ((Status & 1) == 1) continue;               // HostBusy set, keep waiting
-    break;
-  }
-
-  Buffer [0] = __inbyte (Iobase + 5);
-  if (Status == 2) Status = 0;                      // check for done with no errors
-  return Status;
-}
-
-/*
- *
- * ReadSpd - Read one or more SPD bytes from a DIMM.
- *           Start with offset zero and read sequentially.
- *           Optimization relies on autoincrement to avoid
- *           sending offset for every byte.
- *           Reads 128 bytes in 7-8 ms at 400 KHz.
- *
- */
-
-STATIC
-AGESA_STATUS
-ReadSpd (
-  IN UINT16 IoBase,
-  IN UINT8  SmbusSlaveAddress,
-  OUT UINT8 *Buffer,
-  IN UINTN  Count
-  )
-{
-  UINTN Index, Status;
-
-  /* read the first byte using offset zero */
-  Status = ReadSmbusByteData (IoBase, SmbusSlaveAddress, Buffer, 0);
-  if (Status) return Status;
-
-  /* read the remaining bytes using auto-increment for speed */
-  for (Index = 1; Index < Count; Index++){
-    Status = ReadSmbusByte (IoBase, SmbusSlaveAddress, &Buffer [Index]);
-    if (Status) return Status;
-  }
-  return 0;
-}
-
-AGESA_STATUS
-AmdMemoryReadSPD (
-  IN UINT32 Func,
-  IN UINT32 Data,
-  IN OUT AGESA_READ_SPD_PARAMS *SpdData
-  )
-{
-   UINT8  SmBusAddress = 0;
-   UINTN  Index;
-   UINTN  MaxSocket = DIMENSION (SpdAddrLookup);
-   for (Index = 0; Index < MaxSocket; Index ++){
-     if ((SpdData->SocketId     == SpdAddrLookup[Index].SocketId)     &&
-         (SpdData->MemChannelId == SpdAddrLookup[Index].MemChannelId) &&
-         (SpdData->DimmId       == SpdAddrLookup[Index].DimmId)) {
-        SmBusAddress = SpdAddrLookup[Index].SmbusAddress;
-        break;
-      }
-   }
-
-
-   if (SmBusAddress == 0) return AGESA_ERROR;
-   SetupFch (SMBUS_BASE_ADDR);
-   return ReadSpd (SMBUS_BASE_ADDR, SmBusAddress, SpdData->Buffer, 128);
-}
diff --git a/src/mainboard/amd/torpedo/dimmSpd.h b/src/mainboard/amd/torpedo/dimmSpd.h
deleted file mode 100644
index 81ab02e..0000000
--- a/src/mainboard/amd/torpedo/dimmSpd.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * This file is part of the coreboot project.
- *
- * Copyright (C) 2011 Advanced Micro Devices, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/*----------------------------------------------------------------------------------------
- *                             M O D U L E S    U S E D
- *----------------------------------------------------------------------------------------
- */
-
-#ifndef _DIMMSPD_H_
-#define _DIMMSPD_H_
-
-#include "Porting.h"
-#include "AGESA.h"
-
-/*----------------------------------------------------------------------------------------
- *                   D E F I N I T I O N S    A N D    M A C R O S
- *----------------------------------------------------------------------------------------
- */
-
-/*----------------------------------------------------------------------------------------
- *                  T Y P E D E F S     A N D     S T R U C T U  R E S
- *----------------------------------------------------------------------------------------
- */
-
-/*----------------------------------------------------------------------------------------
- *           P R O T O T Y P E S     O F     L O C A L     F U  N C T I O N S
- *----------------------------------------------------------------------------------------
- */
-
-/*----------------------------------------------------------------------------------------
- *                          E X P O R T E D    F U N C T I O N S
- *----------------------------------------------------------------------------------------
- */
-
-AGESA_STATUS
-AmdMemoryReadSPD (
-  IN UINT32 Func,
-  IN UINT32 Data,
-  IN OUT AGESA_READ_SPD_PARAMS *SpdData
-  );
-
-/*---------------------------------------------------------------------------------------
- *                          L O C A L    F U N C T I O N S
- *---------------------------------------------------------------------------------------
- */
-
-#endif
diff --git a/src/mainboard/amd/union_station/BiosCallOuts.c b/src/mainboard/amd/union_station/BiosCallOuts.c
index 2aca184..5ca8854 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/BiosCallOuts.h b/src/mainboard/amd/union_station/BiosCallOuts.h
index be14425..f3483e7 100644
--- a/src/mainboard/amd/union_station/BiosCallOuts.h
+++ b/src/mainboard/amd/union_station/BiosCallOuts.h
@@ -20,54 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-  //UINT32 AvailableSize;
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -76,4 +33,5 @@ AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
+
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/amd/union_station/agesawrapper.c b/src/mainboard/amd/union_station/agesawrapper.c
index fef304d..990ee7d 100644
--- a/src/mainboard/amd/union_station/agesawrapper.c
+++ b/src/mainboard/amd/union_station/agesawrapper.c
@@ -239,10 +239,7 @@ agesawrapper_amdinitpost (
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -259,15 +256,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/asrock/e350m1/BiosCallOuts.c b/src/mainboard/asrock/e350m1/BiosCallOuts.c
index a6a82f9..3e0a6fb 100644
--- a/src/mainboard/asrock/e350m1/BiosCallOuts.c
+++ b/src/mainboard/asrock/e350m1/BiosCallOuts.c
@@ -93,348 +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/asrock/e350m1/BiosCallOuts.h b/src/mainboard/asrock/e350m1/BiosCallOuts.h
index ac40410..92e8ce5 100644
--- a/src/mainboard/asrock/e350m1/BiosCallOuts.h
+++ b/src/mainboard/asrock/e350m1/BiosCallOuts.h
@@ -20,51 +20,9 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS  0x00010000
-#define BIOS_HEAP_SIZE       0x20000   /* 64MB */
-
-typedef struct _BIOS_HEAP_MANAGER {
-  //UINT32 AvailableSize;
-  UINT32 StartOfAllocatedNodes;
-  UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-  UINT32 BufferHandle;
-  UINT32 BufferSize;
-  UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/asrock/e350m1/agesawrapper.c b/src/mainboard/asrock/e350m1/agesawrapper.c
index 0ef235c..9dad9e8 100644
--- a/src/mainboard/asrock/e350m1/agesawrapper.c
+++ b/src/mainboard/asrock/e350m1/agesawrapper.c
@@ -239,10 +239,7 @@ agesawrapper_amdinitpost (
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -259,15 +256,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/asrock/imb-a180/agesawrapper.c b/src/mainboard/asrock/imb-a180/agesawrapper.c
index 0f9212f..c83cfc3 100644
--- a/src/mainboard/asrock/imb-a180/agesawrapper.c
+++ b/src/mainboard/asrock/imb-a180/agesawrapper.c
@@ -41,8 +41,6 @@
 #include "FchPlatform.h"
 #include "Fch.h"
 #include <cpu/amd/agesa/s3_resume.h>
-#include <cbmem.h>
-#include <arch/acpi.h>
 #include <arch/io.h>
 #include <device/device.h>
 #include "hudson.h"
@@ -248,34 +246,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -295,16 +273,7 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	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++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/asrock/imb-a180/agesawrapper.h b/src/mainboard/asrock/imb-a180/agesawrapper.h
index db893cd..32b24cb 100644
--- a/src/mainboard/asrock/imb-a180/agesawrapper.h
+++ b/src/mainboard/asrock/imb-a180/agesawrapper.h
@@ -92,6 +92,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/asus/f2a85-m/agesawrapper.c b/src/mainboard/asus/f2a85-m/agesawrapper.c
index 3b7b263..e3b87bf 100644
--- a/src/mainboard/asus/f2a85-m/agesawrapper.c
+++ b/src/mainboard/asus/f2a85-m/agesawrapper.c
@@ -26,9 +26,7 @@
 #include "BiosCallOuts.h"
 #include "PlatformGnbPcieComplex.h"
 
-#include <arch/acpi.h>
 #include <arch/io.h>
-#include <cbmem.h>
 #include <cpu/amd/agesa/s3_resume.h>
 #include <cpu/x86/mtrr.h>
 #include <device/device.h>
@@ -239,34 +237,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -286,16 +264,7 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	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++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/asus/f2a85-m/agesawrapper.h b/src/mainboard/asus/f2a85-m/agesawrapper.h
index 29eedaf..71f0ff6 100644
--- a/src/mainboard/asus/f2a85-m/agesawrapper.h
+++ b/src/mainboard/asus/f2a85-m/agesawrapper.h
@@ -91,6 +91,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/gizmosphere/gizmo/BiosCallOuts.c b/src/mainboard/gizmosphere/gizmo/BiosCallOuts.c
index ada7853..51fcee6 100755
--- a/src/mainboard/gizmosphere/gizmo/BiosCallOuts.c
+++ b/src/mainboard/gizmosphere/gizmo/BiosCallOuts.c
@@ -50,7 +50,7 @@ STATIC BIOS_CALLOUT_STRUCT BiosCallouts[] =
 	},
 
 	{AGESA_READ_SPD,
-	 BiosReadSpd
+	 BiosReadSpd_from_cbfs
 	},
 
 	{AGESA_READ_SPD_RECOVERY,
@@ -104,335 +104,7 @@ 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 placed
-		*/
-		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_WHENEVER 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 0x06 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 BiosReadSpd_from_cbfs(UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	AGESA_STATUS Status;
 #ifdef __PRE_RAM__
@@ -482,10 +154,6 @@ AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	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/gizmosphere/gizmo/BiosCallOuts.h b/src/mainboard/gizmosphere/gizmo/BiosCallOuts.h
index 463ca09..101a350 100755
--- a/src/mainboard/gizmosphere/gizmo/BiosCallOuts.h
+++ b/src/mainboard/gizmosphere/gizmo/BiosCallOuts.h
@@ -21,53 +21,9 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.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;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/gizmosphere/gizmo/agesawrapper.c b/src/mainboard/gizmosphere/gizmo/agesawrapper.c
index 04c4dd6..0f2cb21 100755
--- a/src/mainboard/gizmosphere/gizmo/agesawrapper.c
+++ b/src/mainboard/gizmosphere/gizmo/agesawrapper.c
@@ -24,9 +24,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>
@@ -225,33 +223,13 @@ 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
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -268,15 +246,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	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++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/gizmosphere/gizmo/agesawrapper.h b/src/mainboard/gizmosphere/gizmo/agesawrapper.h
index e4d8060..511df26 100755
--- a/src/mainboard/gizmosphere/gizmo/agesawrapper.h
+++ b/src/mainboard/gizmosphere/gizmo/agesawrapper.h
@@ -91,6 +91,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/hp/pavilion_m6_1035dx/agesawrapper.c b/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.c
index 2720f16..194dc01 100644
--- a/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.c
+++ b/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.c
@@ -28,9 +28,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 <device/device.h>
@@ -230,34 +228,14 @@ 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); /* base + high_stack_size */
-	else
-#endif
-		heap = BIOS_HEAP_START_ADDRESS; /* Low mem */
-
-	return heap;
-}
-
 UINT32
 agesawrapper_amdinitpost (
 	VOID
 	)
 {
 	AGESA_STATUS status;
-	UINT16                  i;
-	UINT32          *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS       *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 
 	LibAmdMemFill (&AmdParamStruct,
 		       0,
@@ -277,16 +255,7 @@ agesawrapper_amdinitpost (
 	if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 	AmdReleaseStruct (&AmdParamStruct);
 	/* Initialize heap space */
-	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++)
-	{
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.h b/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.h
index aa3cc2e..e5f028a 100644
--- a/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.h
+++ b/src/mainboard/hp/pavilion_m6_1035dx/agesawrapper.h
@@ -91,6 +91,4 @@ UINT32 agesawrapper_amds3laterestore (VOID);
 UINT32 agesawrapper_fchs3earlyrestore (VOID);
 UINT32 agesawrapper_fchs3laterestore (VOID);
 
-UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif
diff --git a/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.c b/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.c
index 441661e..275cceb 100644
--- a/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.c
+++ b/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.c
@@ -77,7 +77,7 @@ STATIC BIOS_CALLOUT_STRUCT BiosCallouts[] =
 	},
 };
 
-AGESA_STATUS GetBiosCallout (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	size_t i;
 	AGESA_STATUS CalloutStatus;
@@ -99,359 +99,14 @@ AGESA_STATUS GetBiosCallout (uint32_t Func, uint32_t Data, void *ConfigPtr)
 	return CalloutStatus;
 }
 
-AGESA_STATUS BiosAllocateBuffer (uint32_t Func, uint32_t Data, void *ConfigPtr)
-{
-	uint32_t              AvailableHeapSize;
-	uint8_t               *BiosHeapBaseAddr;
-	uint32_t              CurrNodeOffset;
-	uint32_t              PrevNodeOffset;
-	uint32_t              FreedNodeOffset;
-	uint32_t              BestFitNodeOffset;
-	uint32_t              BestFitPrevNodeOffset;
-	uint32_t              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_t *) 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_t *) 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_t *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
-		}
-	}
-
-	return AGESA_SUCCESS;
-}
-
-AGESA_STATUS BiosDeallocateBuffer (uint32_t Func, uint32_t Data, void *ConfigPtr)
-{
-
-	uint8_t               *BiosHeapBaseAddr;
-	uint32_t              AllocNodeOffset;
-	uint32_t              PrevNodeOffset;
-	uint32_t              NextNodeOffset;
-	uint32_t              FreedNodeOffset;
-	uint32_t              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_t *) 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_t *)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_t Func, uint32_t Data, void *ConfigPtr)
-{
-	uint32_t				AllocNodeOffset;
-	uint8_t				*BiosHeapBaseAddr;
-	BIOS_BUFFER_NODE	*AllocNodePtr;
-	BIOS_HEAP_MANAGER	*BiosHeapBasePtr;
-	AGESA_BUFFER_PARAMS	*AllocParams;
-
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
-
-	BiosHeapBaseAddr = (uint8_t *) 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_t *) ((uint8_t *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
-	AllocParams->BufferLength = AllocNodePtr->BufferSize;
-
-	return AGESA_SUCCESS;
-
-}
-
-AGESA_STATUS BiosRunFuncOnAp (uint32_t Func, uint32_t Data, void *ConfigPtr)
-{
-	AGESA_STATUS		Status;
-
-	Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
-	return Status;
-}
-
-AGESA_STATUS BiosReset (uint32_t Func, uint32_t Data, void *ConfigPtr)
-{
-	AGESA_STATUS		Status;
-	uint8_t			Value;
-	uint32_t		ResetType;
-	AMD_CONFIG_PARAMS	 *StdHeader;
-
-	ResetType = Data;
-	StdHeader = ConfigPtr;
-
-	/*
-	 * Perform the RESET based upon the ResetType. In case of
-	 * WARM_RESET_WHENEVER 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_t Func, uint32_t 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_t Func, uint32_t Data, void *ConfigPtr)
-{
-	return AGESA_UNSUPPORTED;
-}
-
 /* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	return AGESA_SUCCESS;
 }
 
 /* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	/* Unlike e.g. AMD Inagua, Persimmon is unable to vary the RAM voltage.
 	 * Make sure the right speed settings are selected.
@@ -461,19 +116,19 @@ AGESA_STATUS BiosHookBeforeDramInit (uint32_t Func, uint32_t Data, void *ConfigP
 }
 
 /* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	return AGESA_SUCCESS;
 }
 
 /* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	return AGESA_SUCCESS;
 }
 
 /* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (uint32_t Func, uint32_t Data, void *ConfigPtr)
+AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	AGESA_STATUS Status;
 	uint32_t 		FcnData;
diff --git a/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.h b/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.h
index 2c509a2..92e8ce5 100644
--- a/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.h
+++ b/src/mainboard/jetway/nf81-t56n-lf/BiosCallOuts.h
@@ -20,55 +20,9 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 
-#include <stdint.h>
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-#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_t AvailableSize;
-	uint32_t StartOfAllocatedNodes;
-	uint32_t StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	uint32_t BufferHandle;
-	uint32_t BufferSize;
-	uint32_t NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-/* Callouts */
-AGESA_STATUS GetBiosCallout (uint32_t Func, uint32_t Data, void *ConfigPtr);
-
-/* Required Callouts
- * AGESA Advanced Callouts - CPU
- */
-AGESA_STATUS BiosAllocateBuffer (uint32_t Func, uint32_t Data, void *ConfigPtr);
-AGESA_STATUS BiosDeallocateBuffer (uint32_t Func, uint32_t Data, void *ConfigPtr);
-AGESA_STATUS BiosLocateBuffer (uint32_t Func, uint32_t Data, void *ConfigPtr);
-AGESA_STATUS BiosRunFuncOnAp (uint32_t Func, uint32_t Data, void *ConfigPtr);
-AGESA_STATUS BiosReset (uint32_t Func, uint32_t Data, void *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (uint32_t Func, uint32_t Data, void *ConfigPtr);
-
-/* AGESA Advanced Callouts - Memory */
-AGESA_STATUS BiosReadSpd (uint32_t Func, uint32_t Data, void *ConfigPtr);
-
-/* BIOS default RET */
-AGESA_STATUS BiosDefaultRet (uint32_t Func, uint32_t Data, void *ConfigPtr);
-
-/* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (uint32_t Func, uint32_t Data, void *ConfigPtr);
-/* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (uint32_t Func, uint32_t Data, void *ConfigPtr);
-/* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (uint32_t Func, uint32_t Data, void *ConfigPtr);
-/* Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (uint32_t Func, uint32_t Data, void *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (uint32_t Func, uint32_t Data, void *ConfigPtr);
-
-#endif /* _BIOS_CALLOUT_H_ */
+#endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.c b/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.c
index 4f25756..d4f51f3 100644
--- a/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.c
+++ b/src/mainboard/jetway/nf81-t56n-lf/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>
@@ -181,30 +179,10 @@ AGESA_STATUS agesawrapper_amdinitearly(void)
 	return status;
 }
 
-uint32_t GetHeapBase(
-	AMD_CONFIG_PARAMS *StdHeader
-	)
-{
-	uint32_t heap;
-
-#if CONFIG_HAVE_ACPI_RESUME
-	/* Both romstage and ramstage has this S3 detect. */
-	if (acpi_get_sleep_type() == 3)
-		heap = (uint32_t)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;
-}
-
 AGESA_STATUS agesawrapper_amdinitpost(void)
 {
 	AGESA_STATUS status;
-	uint16_t					i;
-	uint32_t					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -221,15 +199,7 @@ AGESA_STATUS agesawrapper_amdinitpost(void)
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)GetHeapBase(&AmdParamStruct.StdHeader);
-
-	HeadPtr = (uint32_t *) ((uint8_t *) BiosManagerPtr + sizeof (BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof (BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return status;
 }
diff --git a/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.h b/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.h
index b97b6d5..32ae13e 100644
--- a/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.h
+++ b/src/mainboard/jetway/nf81-t56n-lf/agesawrapper.h
@@ -42,8 +42,8 @@ enum {
 };
 
 typedef struct {
-	uint32_t CalloutName;
-	AGESA_STATUS (*CalloutPtr) (uint32_t Func, uint32_t Data, void* ConfigPtr);
+	UINT32 CalloutName;
+	AGESA_STATUS (*CalloutPtr) (UINT32 Func, UINT32 Data, VOID* ConfigPtr);
 } BIOS_CALLOUT_STRUCT;
 
 
@@ -64,6 +64,4 @@ AGESA_STATUS agesawrapper_amds3laterestore(void);
 AGESA_STATUS agesawrapper_amdlaterunaptask(uint32_t, uint32_t, void *);
 void * agesawrapper_getlateinitptr(int);
 
-uint32_t GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
-
 #endif /* _AGESAWRAPPER_H_ */
diff --git a/src/mainboard/lippert/frontrunner-af/BiosCallOuts.c b/src/mainboard/lippert/frontrunner-af/BiosCallOuts.c
index fdb228c..9b44c67 100644
--- a/src/mainboard/lippert/frontrunner-af/BiosCallOuts.c
+++ b/src/mainboard/lippert/frontrunner-af/BiosCallOuts.c
@@ -96,350 +96,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/lippert/frontrunner-af/BiosCallOuts.h b/src/mainboard/lippert/frontrunner-af/BiosCallOuts.h
index cd743f0..97d8ead 100644
--- a/src/mainboard/lippert/frontrunner-af/BiosCallOuts.h
+++ b/src/mainboard/lippert/frontrunner-af/BiosCallOuts.h
@@ -20,56 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 #include "SB800.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 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 /* FCH GPIO access helpers */
 #define FCH_IOMUX(gpio_nr) (*(u8*)(ACPI_MMIO_BASE+IOMUX_BASE+(gpio_nr)))
diff --git a/src/mainboard/lippert/frontrunner-af/agesawrapper.c b/src/mainboard/lippert/frontrunner-af/agesawrapper.c
index cf8534e..79d84ed 100644
--- a/src/mainboard/lippert/frontrunner-af/agesawrapper.c
+++ b/src/mainboard/lippert/frontrunner-af/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,33 +222,13 @@ 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
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -267,15 +245,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	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++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/lippert/frontrunner-af/agesawrapper.h b/src/mainboard/lippert/frontrunner-af/agesawrapper.h
index ba47c53..3764ab0 100644
--- a/src/mainboard/lippert/frontrunner-af/agesawrapper.h
+++ b/src/mainboard/lippert/frontrunner-af/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/lippert/toucan-af/BiosCallOuts.c b/src/mainboard/lippert/toucan-af/BiosCallOuts.c
index 6398e31..9ba6017 100644
--- a/src/mainboard/lippert/toucan-af/BiosCallOuts.c
+++ b/src/mainboard/lippert/toucan-af/BiosCallOuts.c
@@ -96,350 +96,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/lippert/toucan-af/BiosCallOuts.h b/src/mainboard/lippert/toucan-af/BiosCallOuts.h
index 48ee595..15b5eee 100644
--- a/src/mainboard/lippert/toucan-af/BiosCallOuts.h
+++ b/src/mainboard/lippert/toucan-af/BiosCallOuts.h
@@ -20,56 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family14/fam14_callouts.h>
 #include "SB800.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 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*	Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/* PCIE slot reset control */
-AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
 /* FCH GPIO access helpers */
 #define FCH_IOMUX(gpio_nr) (*(u8*)(ACPI_MMIO_BASE+IOMUX_BASE+(gpio_nr)))
diff --git a/src/mainboard/lippert/toucan-af/agesawrapper.c b/src/mainboard/lippert/toucan-af/agesawrapper.c
index cf8534e..79d84ed 100644
--- a/src/mainboard/lippert/toucan-af/agesawrapper.c
+++ b/src/mainboard/lippert/toucan-af/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,33 +222,13 @@ 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
 	)
 {
 	AGESA_STATUS status;
-	UINT16					i;
-	UINT32					*HeadPtr;
 	AMD_INTERFACE_PARAMS	AmdParamStruct;
-	BIOS_HEAP_MANAGER		*BiosManagerPtr;
 
 	memset(&AmdParamStruct, 0, sizeof(AMD_INTERFACE_PARAMS));
 
@@ -267,15 +245,7 @@ agesawrapper_amdinitpost (
 	AmdReleaseStruct (&AmdParamStruct);
 
 	/* Initialize heap space */
-	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++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	return (UINT32)status;
 }
diff --git a/src/mainboard/lippert/toucan-af/agesawrapper.h b/src/mainboard/lippert/toucan-af/agesawrapper.h
index ba47c53..3764ab0 100644
--- a/src/mainboard/lippert/toucan-af/agesawrapper.h
+++ b/src/mainboard/lippert/toucan-af/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/supermicro/h8qgi/BiosCallOuts.c b/src/mainboard/supermicro/h8qgi/BiosCallOuts.c
index 2fbe70a..32fc47e 100644
--- a/src/mainboard/supermicro/h8qgi/BiosCallOuts.c
+++ b/src/mainboard/supermicro/h8qgi/BiosCallOuts.c
@@ -203,332 +203,6 @@ AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 }
 
 
-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 (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;
@@ -550,11 +224,6 @@ AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	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/supermicro/h8qgi/BiosCallOuts.h b/src/mainboard/supermicro/h8qgi/BiosCallOuts.h
index 53c23a9..0b4fb57 100644
--- a/src/mainboard/supermicro/h8qgi/BiosCallOuts.h
+++ b/src/mainboard/supermicro/h8qgi/BiosCallOuts.h
@@ -20,51 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family15/fam15_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS		0x00010000
-#define BIOS_HEAP_SIZE			0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-	//UINT32 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -73,5 +33,5 @@ AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *Conf
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
-#endif //_BIOS_CALLOUT_H_
 
+#endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/supermicro/h8qgi/agesawrapper.c b/src/mainboard/supermicro/h8qgi/agesawrapper.c
index 4704c26..e3d45b1 100644
--- a/src/mainboard/supermicro/h8qgi/agesawrapper.c
+++ b/src/mainboard/supermicro/h8qgi/agesawrapper.c
@@ -286,11 +286,8 @@ UINT32 agesawrapper_amdinitearly(VOID)
 UINT32 agesawrapper_amdinitpost(VOID)
 {
 	AGESA_STATUS status;
-	UINT16 i;
-	UINT32 *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 	UINT32 TscRateInMhz;
 	CPU_SPECIFIC_SERVICES *FamilySpecificServices;
 
@@ -318,15 +315,7 @@ UINT32 agesawrapper_amdinitpost(VOID)
 	AmdReleaseStruct(&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof(BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof(BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	GetCpuServicesOfCurrentCore ((CONST CPU_SPECIFIC_SERVICES **)&FamilySpecificServices, &AmdParamStruct.StdHeader);
 	FamilySpecificServices->GetTscRate (FamilySpecificServices, &TscRateInMhz, &AmdParamStruct.StdHeader);
diff --git a/src/mainboard/supermicro/h8scm/BiosCallOuts.c b/src/mainboard/supermicro/h8scm/BiosCallOuts.c
index 97f59b3..708b0fc 100644
--- a/src/mainboard/supermicro/h8scm/BiosCallOuts.c
+++ b/src/mainboard/supermicro/h8scm/BiosCallOuts.c
@@ -157,332 +157,6 @@ AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 }
 
 
-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 (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;
@@ -495,11 +169,6 @@ AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	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/supermicro/h8scm/BiosCallOuts.h b/src/mainboard/supermicro/h8scm/BiosCallOuts.h
index 38bb85c..bbd9ba3 100644
--- a/src/mainboard/supermicro/h8scm/BiosCallOuts.h
+++ b/src/mainboard/supermicro/h8scm/BiosCallOuts.h
@@ -20,48 +20,9 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family15/fam15_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS		0x00010000
-#define BIOS_HEAP_SIZE			0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-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;
-
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/supermicro/h8scm/agesawrapper.c b/src/mainboard/supermicro/h8scm/agesawrapper.c
index 7700489..1525693 100644
--- a/src/mainboard/supermicro/h8scm/agesawrapper.c
+++ b/src/mainboard/supermicro/h8scm/agesawrapper.c
@@ -286,11 +286,8 @@ UINT32 agesawrapper_amdinitearly(VOID)
 UINT32 agesawrapper_amdinitpost(VOID)
 {
 	AGESA_STATUS status;
-	UINT16 i;
-	UINT32 *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 	UINT32 TscRateInMhz;
 	CPU_SPECIFIC_SERVICES *FamilySpecificServices;
 
@@ -318,15 +315,7 @@ UINT32 agesawrapper_amdinitpost(VOID)
 	AmdReleaseStruct(&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof(BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof(BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	GetCpuServicesOfCurrentCore ((CONST CPU_SPECIFIC_SERVICES **)&FamilySpecificServices, &AmdParamStruct.StdHeader);
 	FamilySpecificServices->GetTscRate (FamilySpecificServices, &TscRateInMhz, &AmdParamStruct.StdHeader);
diff --git a/src/mainboard/tyan/s8226/BiosCallOuts.c b/src/mainboard/tyan/s8226/BiosCallOuts.c
index 0d6e175..00a1bef 100644
--- a/src/mainboard/tyan/s8226/BiosCallOuts.c
+++ b/src/mainboard/tyan/s8226/BiosCallOuts.c
@@ -211,332 +211,6 @@ AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 }
 
 
-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 (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;
@@ -558,11 +232,6 @@ AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 	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/tyan/s8226/BiosCallOuts.h b/src/mainboard/tyan/s8226/BiosCallOuts.h
index 53c23a9..0b4fb57 100644
--- a/src/mainboard/tyan/s8226/BiosCallOuts.h
+++ b/src/mainboard/tyan/s8226/BiosCallOuts.h
@@ -20,51 +20,11 @@
 #ifndef _BIOS_CALLOUT_H_
 #define _BIOS_CALLOUT_H_
 
-#include "Porting.h"
-#include "AGESA.h"
+#include <northbridge/amd/agesa/family15/fam15_callouts.h>
 
-#define BIOS_HEAP_START_ADDRESS		0x00010000
-#define BIOS_HEAP_SIZE			0x20000   /* 64MB */
+/* CALLOUT Initialization */
+AGESA_STATUS GetBiosCallout(UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 
-typedef struct _BIOS_HEAP_MANAGER {
-	//UINT32 AvailableSize;
-	UINT32 StartOfAllocatedNodes;
-	UINT32 StartOfFreedNodes;
-} BIOS_HEAP_MANAGER;
-
-typedef struct _BIOS_BUFFER_NODE {
-	UINT32 BufferHandle;
-	UINT32 BufferSize;
-	UINT32 NextNodeOffset;
-} BIOS_BUFFER_NODE;
-
-/*
- * CALLOUTS
- */
-AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* 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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/* AGESA ADVANCED CALLOUTS - MEMORY */
-AGESA_STATUS BiosReadSpd (UINT32  Func,UINT32  Data,VOID *ConfigPtr);
-
-/* BIOS DEFAULT RET */
-AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
-/*  Call the host environment interface to provide a user hook opportunity. */
-AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
 #define SB_GPIO_REG02   2
 #define SB_GPIO_REG09   9
 #define SB_GPIO_REG10   10
@@ -73,5 +33,5 @@ AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *Conf
 #define SB_GPIO_REG21   21
 #define SB_GPIO_REG25   25
 #define SB_GPIO_REG28   28
-#endif //_BIOS_CALLOUT_H_
 
+#endif //_BIOS_CALLOUT_H_
diff --git a/src/mainboard/tyan/s8226/agesawrapper.c b/src/mainboard/tyan/s8226/agesawrapper.c
index e5419db..c422599 100644
--- a/src/mainboard/tyan/s8226/agesawrapper.c
+++ b/src/mainboard/tyan/s8226/agesawrapper.c
@@ -296,11 +296,8 @@ UINT32 agesawrapper_amdinitearly(VOID)
 UINT32 agesawrapper_amdinitpost(VOID)
 {
 	AGESA_STATUS status;
-	UINT16 i;
-	UINT32 *HeadPtr;
 	AMD_INTERFACE_PARAMS  AmdParamStruct;
 	AMD_POST_PARAMS *PostParams;
-	BIOS_HEAP_MANAGER    *BiosManagerPtr;
 	UINT32 TscRateInMhz;
 	CPU_SPECIFIC_SERVICES *FamilySpecificServices;
 
@@ -328,15 +325,7 @@ UINT32 agesawrapper_amdinitpost(VOID)
 	AmdReleaseStruct(&AmdParamStruct);
 
 	/* Initialize heap space */
-	BiosManagerPtr = (BIOS_HEAP_MANAGER *)BIOS_HEAP_START_ADDRESS;
-
-	HeadPtr = (UINT32 *) ((UINT8 *) BiosManagerPtr + sizeof(BIOS_HEAP_MANAGER));
-	for (i = 0; i < ((BIOS_HEAP_SIZE/4) - (sizeof(BIOS_HEAP_MANAGER)/4)); i++) {
-		*HeadPtr = 0x00000000;
-		HeadPtr++;
-	}
-	BiosManagerPtr->StartOfAllocatedNodes = 0;
-	BiosManagerPtr->StartOfFreedNodes = 0;
+	GetEmptyHeap();
 
 	GetCpuServicesOfCurrentCore ((CONST CPU_SPECIFIC_SERVICES **)&FamilySpecificServices, &AmdParamStruct.StdHeader);
 	FamilySpecificServices->GetTscRate (FamilySpecificServices, &TscRateInMhz, &AmdParamStruct.StdHeader);
diff --git a/src/northbridge/amd/agesa/family12/Makefile.inc b/src/northbridge/amd/agesa/family12/Makefile.inc
index 9676d54..62c8519 100644
--- a/src/northbridge/amd/agesa/family12/Makefile.inc
+++ b/src/northbridge/amd/agesa/family12/Makefile.inc
@@ -17,6 +17,11 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 #
 
+romstage-y += fam12_callouts.c
+romstage-y += dimmSpd.c
+
 ramstage-y += northbridge.c
+ramstage-y += fam12_callouts.c
+ramstage-y += dimmSpd.c
 
 ramstage-$(CONFIG_GENERATE_ACPI_TABLES) += ssdt.asl
diff --git a/src/northbridge/amd/agesa/family12/dimmSpd.c b/src/northbridge/amd/agesa/family12/dimmSpd.c
new file mode 100644
index 0000000..55fb2c3
--- /dev/null
+++ b/src/northbridge/amd/agesa/family12/dimmSpd.c
@@ -0,0 +1,241 @@
+/*****************************************************************************
+ *
+ * Copyright (c) 2011, Advanced Micro Devices, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Advanced Micro Devices, Inc. nor the names of
+ *       its contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+/*----------------------------------------------------------------------------------------
+ *                             M O D U L E S    U S E D
+ *----------------------------------------------------------------------------------------
+ */
+
+#include "Porting.h"
+#include "AGESA.h"
+#include "amdlib.h"
+#include "dimmSpd.h"
+
+/*----------------------------------------------------------------------------------------
+ *                   D E F I N I T I O N S    A N D    M A C R O S
+ *----------------------------------------------------------------------------------------
+ */
+#define SMBUS_BASE_ADDR  0xB00
+#define DIMENSION(array)(sizeof (array)/ sizeof (array [0]))
+
+/*----------------------------------------------------------------------------------------
+ *                  T Y P E D E F S     A N D     S T R U C T U  R E S
+ *----------------------------------------------------------------------------------------
+ */
+
+typedef struct _DIMM_INFO_SMBUS{
+  UINT8   SocketId;
+  UINT8   MemChannelId;
+  UINT8   DimmId;
+  UINT8   SmbusAddress;
+} DIMM_INFO_SMBUS;
+/*
+* SPD address table - porting required
+*/
+STATIC CONST DIMM_INFO_SMBUS SpdAddrLookup [] =
+{
+  /* Socket, Channel, Dimm, Smbus */
+  {0, 0, 0, 0xA0},
+  {0, 1, 0, 0xA2}
+};
+
+/*----------------------------------------------------------------------------------------
+ *           P R O T O T Y P E S     O F     L O C A L     F U  N C T I O N S
+ *----------------------------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------------------
+ *                          E X P O R T E D    F U N C T I O N S
+ *----------------------------------------------------------------------------------------
+ */
+
+/*---------------------------------------------------------------------------------------
+ *                          L O C A L    F U N C T I O N S
+ *---------------------------------------------------------------------------------------
+ */
+
+STATIC
+VOID
+WritePmReg (
+  IN UINT8 Reg,
+  IN UINT8 Data
+  )
+{
+   __outbyte (0xCD6, Reg);
+   __outbyte (0xCD7, Data);
+}
+STATIC
+VOID
+SetupFch (
+  IN UINT16
+  IN IoBase
+  )
+{
+   WritePmReg (0x2D, IoBase >> 8);
+   WritePmReg (0x2C, IoBase | 1);
+   WritePmReg (0x29, 0x80);
+   WritePmReg (0x28, 0x61);
+   /* set SMBus clock to 400 KHz */
+   __outbyte (IoBase + 0x0E, 66000000 / 400000 / 4);
+}
+
+/*
+ *
+ * ReadSmbusByteData - read a single SPD byte from any offset
+ *
+ */
+
+STATIC
+AGESA_STATUS
+ReadSmbusByteData (
+  IN UINT16 Iobase,
+  IN UINT8  Address,
+  OUT UINT8 *Buffer,
+  IN UINTN  Offset
+  )
+{
+   UINTN  Status;
+   UINT64 Limit;
+
+   Address |= 1; // set read bit
+
+   __outbyte (Iobase + 0, 0xFF);                // clear error status
+   __outbyte (Iobase + 1, 0x1F);                // clear error status
+   __outbyte (Iobase + 3, Offset);              // offset in eeprom
+   __outbyte (Iobase + 4, Address);             // slave address and read bit
+   __outbyte (Iobase + 2, 0x48);                // read byte command
+
+   /* time limit to avoid hanging for unexpected error status (should never happen) */
+   Limit = __rdtsc () + 2000000000 / 10;
+   for (;;) {
+     Status = __inbyte (Iobase);
+     if (__rdtsc () > Limit) break;
+     if ((Status & 2) == 0) continue;               // SMBusInterrupt not set, keep waiting
+     if ((Status & 1) == 1) continue;               // HostBusy set, keep waiting
+     break;
+   }
+
+   Buffer [0] = __inbyte (Iobase + 5);
+   if (Status == 2) Status = 0;                      // check for done with no errors
+   return Status;
+   }
+
+/*
+ *
+ * ReadSmbusByte - read a single SPD byte from the default offset
+ *                 this function is faster function readSmbusByteData
+ *
+ */
+
+STATIC
+AGESA_STATUS
+ReadSmbusByte (
+  IN UINT16 Iobase,
+  IN UINT8  Address,
+  OUT UINT8 *Buffer
+  )
+{
+  UINTN   Status;
+  UINT64  Limit;
+
+  __outbyte (Iobase + 0, 0xFF);                // clear error status
+  __outbyte (Iobase + 2, 0x44);                // read command
+
+  // time limit to avoid hanging for unexpected error status
+  Limit = __rdtsc () + 2000000000 / 10;
+  for (;;) {
+    Status = __inbyte (Iobase);
+    if (__rdtsc () > Limit) break;
+    if ((Status & 2) == 0) continue;               // SMBusInterrupt not set, keep waiting
+    if ((Status & 1) == 1) continue;               // HostBusy set, keep waiting
+    break;
+  }
+
+  Buffer [0] = __inbyte (Iobase + 5);
+  if (Status == 2) Status = 0;                      // check for done with no errors
+  return Status;
+}
+
+/*
+ *
+ * ReadSpd - Read one or more SPD bytes from a DIMM.
+ *           Start with offset zero and read sequentially.
+ *           Optimization relies on autoincrement to avoid
+ *           sending offset for every byte.
+ *           Reads 128 bytes in 7-8 ms at 400 KHz.
+ *
+ */
+
+STATIC
+AGESA_STATUS
+ReadSpd (
+  IN UINT16 IoBase,
+  IN UINT8  SmbusSlaveAddress,
+  OUT UINT8 *Buffer,
+  IN UINTN  Count
+  )
+{
+  UINTN Index, Status;
+
+  /* read the first byte using offset zero */
+  Status = ReadSmbusByteData (IoBase, SmbusSlaveAddress, Buffer, 0);
+  if (Status) return Status;
+
+  /* read the remaining bytes using auto-increment for speed */
+  for (Index = 1; Index < Count; Index++){
+    Status = ReadSmbusByte (IoBase, SmbusSlaveAddress, &Buffer [Index]);
+    if (Status) return Status;
+  }
+  return 0;
+}
+
+AGESA_STATUS
+AmdMemoryReadSPD (
+  IN UINT32 Func,
+  IN UINT32 Data,
+  IN OUT AGESA_READ_SPD_PARAMS *SpdData
+  )
+{
+   UINT8  SmBusAddress = 0;
+   UINTN  Index;
+   UINTN  MaxSocket = DIMENSION (SpdAddrLookup);
+   for (Index = 0; Index < MaxSocket; Index ++){
+     if ((SpdData->SocketId     == SpdAddrLookup[Index].SocketId)     &&
+         (SpdData->MemChannelId == SpdAddrLookup[Index].MemChannelId) &&
+         (SpdData->DimmId       == SpdAddrLookup[Index].DimmId)) {
+        SmBusAddress = SpdAddrLookup[Index].SmbusAddress;
+        break;
+      }
+   }
+
+
+   if (SmBusAddress == 0) return AGESA_ERROR;
+   SetupFch (SMBUS_BASE_ADDR);
+   return ReadSpd (SMBUS_BASE_ADDR, SmBusAddress, SpdData->Buffer, 128);
+}
diff --git a/src/northbridge/amd/agesa/family12/dimmSpd.h b/src/northbridge/amd/agesa/family12/dimmSpd.h
new file mode 100644
index 0000000..81ab02e
--- /dev/null
+++ b/src/northbridge/amd/agesa/family12/dimmSpd.h
@@ -0,0 +1,63 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*----------------------------------------------------------------------------------------
+ *                             M O D U L E S    U S E D
+ *----------------------------------------------------------------------------------------
+ */
+
+#ifndef _DIMMSPD_H_
+#define _DIMMSPD_H_
+
+#include "Porting.h"
+#include "AGESA.h"
+
+/*----------------------------------------------------------------------------------------
+ *                   D E F I N I T I O N S    A N D    M A C R O S
+ *----------------------------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------------------
+ *                  T Y P E D E F S     A N D     S T R U C T U  R E S
+ *----------------------------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------------------
+ *           P R O T O T Y P E S     O F     L O C A L     F U  N C T I O N S
+ *----------------------------------------------------------------------------------------
+ */
+
+/*----------------------------------------------------------------------------------------
+ *                          E X P O R T E D    F U N C T I O N S
+ *----------------------------------------------------------------------------------------
+ */
+
+AGESA_STATUS
+AmdMemoryReadSPD (
+  IN UINT32 Func,
+  IN UINT32 Data,
+  IN OUT AGESA_READ_SPD_PARAMS *SpdData
+  );
+
+/*---------------------------------------------------------------------------------------
+ *                          L O C A L    F U N C T I O N S
+ *---------------------------------------------------------------------------------------
+ */
+
+#endif
diff --git a/src/northbridge/amd/agesa/family12/fam12_callouts.c b/src/northbridge/amd/agesa/family12/fam12_callouts.c
new file mode 100644
index 0000000..5f96801
--- /dev/null
+++ b/src/northbridge/amd/agesa/family12/fam12_callouts.c
@@ -0,0 +1,390 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "agesawrapper.h"
+#include "amdlib.h"
+#include "dimmSpd.h"
+#include "BiosCallOuts.h"
+#include "Ids.h"
+#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 GetEmptyHeap(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 BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
+{
+	AGESA_STATUS		Status;
+
+	Status = agesawrapper_amdlaterunaptask (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;
+	Status = AmdMemoryReadSPD (Func, Data, (AGESA_READ_SPD_PARAMS *)ConfigPtr);
+
+	return Status;
+}
+
+AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
+{
+	return AGESA_UNSUPPORTED;
+}
diff --git a/src/northbridge/amd/agesa/family12/fam12_callouts.h b/src/northbridge/amd/agesa/family12/fam12_callouts.h
new file mode 100644
index 0000000..86274b4
--- /dev/null
+++ b/src/northbridge/amd/agesa/family12/fam12_callouts.h
@@ -0,0 +1,71 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef CALLOUTS_AMD_AGESA_FAM12_H
+#define CALLOUTS_AMD_AGESA_FAM12_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 GetEmptyHeap(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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+/* AGESA ADVANCED CALLOUTS - MEMORY */
+AGESA_STATUS BiosReadSpd (UINT32 Func,UINT32	Data,VOID *ConfigPtr);
+
+/* BIOS DEFAULT RET */
+AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* PCIE slot reset control */
+AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+#endif /* CALLOUTS_AMD_AGESA_FAM12_H */
diff --git a/src/northbridge/amd/agesa/family14/Makefile.inc b/src/northbridge/amd/agesa/family14/Makefile.inc
index e7093fe..db2f05f 100644
--- a/src/northbridge/amd/agesa/family14/Makefile.inc
+++ b/src/northbridge/amd/agesa/family14/Makefile.inc
@@ -17,6 +17,8 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 #
 
+romstage-y += fam14_callouts.c
 romstage-y += dimmSpd.c
 
 ramstage-y += northbridge.c
+ramstage-y += fam14_callouts.c
diff --git a/src/northbridge/amd/agesa/family14/fam14_callouts.c b/src/northbridge/amd/agesa/family14/fam14_callouts.c
new file mode 100644
index 0000000..3f151c4
--- /dev/null
+++ b/src/northbridge/amd/agesa/family14/fam14_callouts.c
@@ -0,0 +1,394 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "agesawrapper.h"
+#include "amdlib.h"
+#include "fam14_callouts.h"
+#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 GetEmptyHeap(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;
+
+}
+
+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;
+}
diff --git a/src/northbridge/amd/agesa/family14/fam14_callouts.h b/src/northbridge/amd/agesa/family14/fam14_callouts.h
new file mode 100755
index 0000000..45bb517
--- /dev/null
+++ b/src/northbridge/amd/agesa/family14/fam14_callouts.h
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ * Copyright (C) 2013 Sage Electronic Engineering, LLC
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef CALLOUTS_AMD_AGESA_FAM14_H
+#define CALLOUTS_AMD_AGESA_FAM14_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 GetEmptyHeap(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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosGetIdsInitData (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);
+
+/* BIOS DEFAULT RET */
+AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* PCIE slot reset control */
+AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+#endif /* CALLOUTS_AMD_AGESA_FAM14_H */
diff --git a/src/northbridge/amd/agesa/family15/Makefile.inc b/src/northbridge/amd/agesa/family15/Makefile.inc
index 4a75499..41b7d7f 100644
--- a/src/northbridge/amd/agesa/family15/Makefile.inc
+++ b/src/northbridge/amd/agesa/family15/Makefile.inc
@@ -17,6 +17,8 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 #
 
+romstage-y += fam15_callouts.c
 romstage-y += dimmSpd.c
 
 ramstage-y += northbridge.c
+ramstage-y += fam15_callouts.c
diff --git a/src/northbridge/amd/agesa/family15/fam15_callouts.c b/src/northbridge/amd/agesa/family15/fam15_callouts.c
new file mode 100644
index 0000000..2060af9
--- /dev/null
+++ b/src/northbridge/amd/agesa/family15/fam15_callouts.c
@@ -0,0 +1,382 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "agesawrapper.h"
+#include "amdlib.h"
+#include "BiosCallOuts.h"
+#include "Ids.h"
+#include "OptionsIds.h"
+#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 GetEmptyHeap(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 BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
+{
+	AGESA_STATUS        Status;
+
+	Status = agesawrapper_amdlaterunaptask (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 BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
+{
+	return AGESA_UNSUPPORTED;
+}
diff --git a/src/northbridge/amd/agesa/family15/fam15_callouts.h b/src/northbridge/amd/agesa/family15/fam15_callouts.h
new file mode 100644
index 0000000..ead8634
--- /dev/null
+++ b/src/northbridge/amd/agesa/family15/fam15_callouts.h
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2011 Advanced Micro Devices, Inc.
+ * Copyright (C) 2013 Sage Electronic Engineering, LLC
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#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 GetEmptyHeap(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_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+AGESA_STATUS BiosGetIdsInitData (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);
+
+/* BIOS DEFAULT RET */
+AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/*	Call the host environment interface to provide a user hook opportunity. */
+AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+/* PCIE slot reset control */
+AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr);
+
+#endif /* CALLOUTS_AMD_AGESA_FAM15_H */
diff --git a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
index cf84b39..ed07c57 100644
--- a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
+++ b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.c
@@ -27,6 +27,8 @@
 #include "dimmSpd.h"
 #include "fam15tn_callouts.h"
 #include <cbmem.h>
+#include <arch/acpi.h>
+#include <string.h>
 
 #define AGESA_RUNTIME_SIZE 4096
 
@@ -50,6 +52,27 @@ static AGESA_STATUS alloc_cbmem(AGESA_BUFFER_PARAMS *AllocParams) {
 	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 GetEmptyHeap(void)
+{
+	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
+	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
+}
+
 AGESA_STATUS fam15tn_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
 	UINT32              AvailableHeapSize;
diff --git a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
index ff0cc44..463bd5e 100644
--- a/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
+++ b/src/northbridge/amd/agesa/family15tn/fam15tn_callouts.h
@@ -39,6 +39,9 @@ typedef struct _BIOS_BUFFER_NODE {
   UINT32 NextNodeOffset;
 } BIOS_BUFFER_NODE;
 
+UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
+void GetEmptyHeap(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);
diff --git a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
index b290931..f772a22 100644
--- a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
+++ b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.c
@@ -26,6 +26,30 @@
 #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 GetEmptyHeap(void)
+{
+	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
+	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
+}
 
 AGESA_STATUS fam16kb_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
 {
diff --git a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
index c17a20d..4d9a645 100644
--- a/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
+++ b/src/northbridge/amd/agesa/family16kb/fam16kb_callouts.h
@@ -39,6 +39,9 @@ typedef struct _BIOS_BUFFER_NODE {
   UINT32 NextNodeOffset;
 } BIOS_BUFFER_NODE;
 
+UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader);
+void GetEmptyHeap(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);



More information about the coreboot-gerrit mailing list