src/drivers/amd/agesa/heapmanager.c - mirrors/cros/chromiumos/third_party/coreboot - Git at Google

 /*
  * This file is part of the coreboot project.
  *
  * 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.
  */


 #include "AGESA.h"
 #include "amdlib.h"

 #include <cbmem.h>
 #include <northbridge/amd/agesa/agesa_helper.h>
 #include <northbridge/amd/agesa/BiosCallOuts.h>

 #include <arch/acpi.h>
 #include <string.h>

 /* BIOS_HEAP_START_ADDRESS is only for cold boots. */
 #define BIOS_HEAP_SIZE		0x30000
 #define BIOS_HEAP_START_ADDRESS	0x010000000

 #if IS_ENABLED(CONFIG_HAVE_ACPI_RESUME) && (HIGH_MEMORY_SCRATCH < BIOS_HEAP_SIZE)
 #error Increase HIGH_MEMORY_SCRATCH allocation
 #endif

 void *GetHeapBase(void)
 {
 	void *heap = (void *)BIOS_HEAP_START_ADDRESS;

 	if (acpi_is_wakeup_s3()) {
 		/* FIXME: For S3 resume path, buffer is in CBMEM
 		 * with some arbitrary header. */
 		heap = cbmem_find(CBMEM_ID_RESUME_SCRATCH);
 		heap += 0x10;
 	}

 	return heap;
 }

 void EmptyHeap(void)
 {
 	void *base = GetHeapBase();
 	memset(base, 0, BIOS_HEAP_SIZE);

 	printk(BIOS_DEBUG, "Wiped HEAP at [%08x - %08x]\n",
 		(unsigned int)(uintptr_t) base, (unsigned int)(uintptr_t) base + BIOS_HEAP_SIZE - 1);
 }

 #if defined(HEAP_CALLOUT_RUNTIME) && ENV_RAMSTAGE

 #define AGESA_RUNTIME_SIZE 4096
 static AGESA_STATUS alloc_cbmem(AGESA_BUFFER_PARAMS *AllocParams)
 {
 	static unsigned int used = 0;
 	void *p = cbmem_find(CBMEM_ID_AGESA_RUNTIME);

 	if ((AGESA_RUNTIME_SIZE - used) < AllocParams->BufferLength) {
 		return AGESA_BOUNDS_CHK;
 	}

 	/* first time allocation */
 	if (!p) {
 		p = cbmem_add(CBMEM_ID_AGESA_RUNTIME, AGESA_RUNTIME_SIZE);
 		if (!p)
 			return AGESA_BOUNDS_CHK;
 	}

 	AllocParams->BufferPointer = p + used;
 	used += AllocParams->BufferLength;
 	return AGESA_SUCCESS;
 }
 #endif

 typedef struct _BIOS_HEAP_MANAGER {
 	UINT32 StartOfAllocatedNodes;
 	UINT32 StartOfFreedNodes;
 } BIOS_HEAP_MANAGER;

 typedef struct _BIOS_BUFFER_NODE {
 	UINT32 BufferHandle;
 	UINT32 BufferSize;
 	UINT32 NextNodeOffset;
 } BIOS_BUFFER_NODE;

 static AGESA_STATUS agesa_AllocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
 	AGESA_BUFFER_PARAMS *AllocParams)
 {
 	UINT32              AvailableHeapSize;
 	UINT8               *BiosHeapBaseAddr = (void *)BiosHeapBasePtr;
 	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;

 	AllocParams->BufferPointer = NULL;
 	AvailableHeapSize = BIOS_HEAP_SIZE - sizeof(BIOS_HEAP_MANAGER);

 	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
 					- (FreedNodeOffset - CurrNodeOffset)
 					- sizeof(BIOS_BUFFER_NODE);
 		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;
 }

 static AGESA_STATUS agesa_DeallocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
 	AGESA_BUFFER_PARAMS *AllocParams)
 {
 	UINT8               *BiosHeapBaseAddr = (void *)BiosHeapBasePtr;
 	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;

 	/* 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;

 	/* Add deallocated node in order to the list of freed nodes */
 	FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
 	FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);

 	EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize +
 						sizeof(BIOS_BUFFER_NODE);

 	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 +
 						sizeof(BIOS_BUFFER_NODE);
 			AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;

 			/* Zero out the FreedNode header */
 			memset((UINT8 *)FreedNodePtr, 0,
 						sizeof(BIOS_BUFFER_NODE));
 		} 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 +
 						sizeof(BIOS_BUFFER_NODE);
 			AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;

 			/* Zero out the NextNode header */
 			memset((UINT8 *)NextNodePtr, 0,
 						sizeof(BIOS_BUFFER_NODE));
 		} 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 +
 						sizeof(BIOS_BUFFER_NODE);
 		if (AllocNodeOffset == EndNodeOffset) {
 			PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
 			PrevNodePtr->BufferSize += AllocNodePtr->BufferSize +
 						sizeof(BIOS_BUFFER_NODE);

 			/* Zero out the AllocNode header */
 			memset((UINT8 *)AllocNodePtr, 0,
 						sizeof(BIOS_BUFFER_NODE));
 		} else {
 			PrevNodePtr->NextNodeOffset = AllocNodeOffset;
 		}
 	}
 	return AGESA_SUCCESS;
 }

 static AGESA_STATUS agesa_LocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
 	AGESA_BUFFER_PARAMS *AllocParams)
 {
 	UINT32              AllocNodeOffset;
 	UINT8               *BiosHeapBaseAddr = (void *)BiosHeapBasePtr;
 	BIOS_BUFFER_NODE   *AllocNodePtr;

 	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 HeapManagerCallout(UINT32 Func, UINTN Data, VOID *ConfigPtr)
 {
 	AGESA_BUFFER_PARAMS *AllocParams = ConfigPtr;

 #if defined(HEAP_CALLOUT_RUNTIME) && ENV_RAMSTAGE
 	if (Func == AGESA_ALLOCATE_BUFFER && Data == HEAP_CALLOUT_RUNTIME)
 		return alloc_cbmem(AllocParams);
 #endif

 	/* Must not call GetHeapBase() in AGESA_UNSUPPORTED path. */
 	if (Func == AGESA_LOCATE_BUFFER)
 		return agesa_LocateBuffer(GetHeapBase(), AllocParams);
 	else if (Func == AGESA_ALLOCATE_BUFFER)
 		return agesa_AllocateBuffer(GetHeapBase(), AllocParams);
 	else if (Func == AGESA_DEALLOCATE_BUFFER)
 		return agesa_DeallocateBuffer(GetHeapBase(), AllocParams);

 	return AGESA_UNSUPPORTED;
 }
	/*
	* This file is part of the coreboot project.
	*
	* 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.
	*/


	#include "AGESA.h"
	#include "amdlib.h"

	#include <cbmem.h>
	#include <northbridge/amd/agesa/agesa_helper.h>
	#include <northbridge/amd/agesa/BiosCallOuts.h>

	#include <arch/acpi.h>
	#include <string.h>

	/* BIOS_HEAP_START_ADDRESS is only for cold boots. */
	#define BIOS_HEAP_SIZE 0x30000
	#define BIOS_HEAP_START_ADDRESS 0x010000000

	#if IS_ENABLED(CONFIG_HAVE_ACPI_RESUME) && (HIGH_MEMORY_SCRATCH < BIOS_HEAP_SIZE)
	#error Increase HIGH_MEMORY_SCRATCH allocation
	#endif

	void *GetHeapBase(void)
	{
	void heap = (void )BIOS_HEAP_START_ADDRESS;

	if (acpi_is_wakeup_s3()) {
	/* FIXME: For S3 resume path, buffer is in CBMEM
	* with some arbitrary header. */
	heap = cbmem_find(CBMEM_ID_RESUME_SCRATCH);
	heap += 0x10;
	}

	return heap;
	}

	void EmptyHeap(void)
	{
	void *base = GetHeapBase();
	memset(base, 0, BIOS_HEAP_SIZE);

	printk(BIOS_DEBUG, "Wiped HEAP at [%08x - %08x]\n",
	(unsigned int)(uintptr_t) base, (unsigned int)(uintptr_t) base + BIOS_HEAP_SIZE - 1);
	}

	#if defined(HEAP_CALLOUT_RUNTIME) && ENV_RAMSTAGE

	#define AGESA_RUNTIME_SIZE 4096
	static AGESA_STATUS alloc_cbmem(AGESA_BUFFER_PARAMS *AllocParams)
	{
	static unsigned int used = 0;
	void *p = cbmem_find(CBMEM_ID_AGESA_RUNTIME);

	if ((AGESA_RUNTIME_SIZE - used) < AllocParams->BufferLength) {
	return AGESA_BOUNDS_CHK;
	}

	/* first time allocation */
	if (!p) {
	p = cbmem_add(CBMEM_ID_AGESA_RUNTIME, AGESA_RUNTIME_SIZE);
	if (!p)
	return AGESA_BOUNDS_CHK;
	}

	AllocParams->BufferPointer = p + used;
	used += AllocParams->BufferLength;
	return AGESA_SUCCESS;
	}
	#endif

	typedef struct _BIOS_HEAP_MANAGER {
	UINT32 StartOfAllocatedNodes;
	UINT32 StartOfFreedNodes;
	} BIOS_HEAP_MANAGER;

	typedef struct _BIOS_BUFFER_NODE {
	UINT32 BufferHandle;
	UINT32 BufferSize;
	UINT32 NextNodeOffset;
	} BIOS_BUFFER_NODE;

	static AGESA_STATUS agesa_AllocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
	AGESA_BUFFER_PARAMS *AllocParams)
	{
	UINT32 AvailableHeapSize;
	UINT8 BiosHeapBaseAddr = (void )BiosHeapBasePtr;
	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;

	AllocParams->BufferPointer = NULL;
	AvailableHeapSize = BIOS_HEAP_SIZE - sizeof(BIOS_HEAP_MANAGER);

	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
	- (FreedNodeOffset - CurrNodeOffset)
	- sizeof(BIOS_BUFFER_NODE);
	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;
	}

	static AGESA_STATUS agesa_DeallocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
	AGESA_BUFFER_PARAMS *AllocParams)
	{
	UINT8 BiosHeapBaseAddr = (void )BiosHeapBasePtr;
	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;

	/* 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;

	/* Add deallocated node in order to the list of freed nodes */
	FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
	FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);

	EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize +
	sizeof(BIOS_BUFFER_NODE);

	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 +
	sizeof(BIOS_BUFFER_NODE);
	AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;

	/* Zero out the FreedNode header */
	memset((UINT8 *)FreedNodePtr, 0,
	sizeof(BIOS_BUFFER_NODE));
	} 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 +
	sizeof(BIOS_BUFFER_NODE);
	AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;

	/* Zero out the NextNode header */
	memset((UINT8 *)NextNodePtr, 0,
	sizeof(BIOS_BUFFER_NODE));
	} 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 +
	sizeof(BIOS_BUFFER_NODE);
	if (AllocNodeOffset == EndNodeOffset) {
	PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
	PrevNodePtr->BufferSize += AllocNodePtr->BufferSize +
	sizeof(BIOS_BUFFER_NODE);

	/* Zero out the AllocNode header */
	memset((UINT8 *)AllocNodePtr, 0,
	sizeof(BIOS_BUFFER_NODE));
	} else {
	PrevNodePtr->NextNodeOffset = AllocNodeOffset;
	}
	}
	return AGESA_SUCCESS;
	}

	static AGESA_STATUS agesa_LocateBuffer(BIOS_HEAP_MANAGER *BiosHeapBasePtr,
	AGESA_BUFFER_PARAMS *AllocParams)
	{
	UINT32 AllocNodeOffset;
	UINT8 BiosHeapBaseAddr = (void )BiosHeapBasePtr;
	BIOS_BUFFER_NODE *AllocNodePtr;

	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 HeapManagerCallout(UINT32 Func, UINTN Data, VOID *ConfigPtr)
	{
	AGESA_BUFFER_PARAMS *AllocParams = ConfigPtr;

	#if defined(HEAP_CALLOUT_RUNTIME) && ENV_RAMSTAGE
	if (Func == AGESA_ALLOCATE_BUFFER && Data == HEAP_CALLOUT_RUNTIME)
	return alloc_cbmem(AllocParams);
	#endif

	/* Must not call GetHeapBase() in AGESA_UNSUPPORTED path. */
	if (Func == AGESA_LOCATE_BUFFER)
	return agesa_LocateBuffer(GetHeapBase(), AllocParams);
	else if (Func == AGESA_ALLOCATE_BUFFER)
	return agesa_AllocateBuffer(GetHeapBase(), AllocParams);
	else if (Func == AGESA_DEALLOCATE_BUFFER)
	return agesa_DeallocateBuffer(GetHeapBase(), AllocParams);

	return AGESA_UNSUPPORTED;
	}