AGESA: Use common heap allocator
Change-Id: I5df1f0efdef2592b762fe391edaadbca4593e85a Signed-off-by: Kyösti Mälkki <kyosti.malkki@gmail.com> Reviewed-on: http://review.coreboot.org/5689 Tested-by: build bot (Jenkins) Reviewed-by: Patrick Georgi <patrick@georgi-clan.de>
This commit is contained in:
Kyösti Mälkki
342
src/cpu/amd/agesa/heapmanager.c
Normal file
342
src/cpu/amd/agesa/heapmanager.c
Normal file
@ -0,0 +1,342 @@
|
||||
|
||||
#include "agesawrapper.h"
|
||||
#include "amdlib.h"
|
||||
#include "northbridge/amd/agesa/def_callouts.h"
|
||||
#include "heapManager.h"
|
||||
|
||||
#include <cbmem.h>
|
||||
#include <arch/acpi.h>
|
||||
#include <string.h>
|
||||
|
||||
UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
|
||||
{
|
||||
UINT32 heap = BIOS_HEAP_START_ADDRESS;
|
||||
|
||||
#if CONFIG_HAVE_ACPI_RESUME
|
||||
/* Both romstage and ramstage has this S3 detect. */
|
||||
if (acpi_get_sleep_type() == 3)
|
||||
heap = (UINT32) cbmem_find(CBMEM_ID_RESUME_SCRATCH) +
|
||||
(CONFIG_HIGH_SCRATCH_MEMORY_SIZE - BIOS_HEAP_SIZE);
|
||||
/* himem_heap_base + high_stack_size */
|
||||
#endif
|
||||
return heap;
|
||||
}
|
||||
|
||||
void EmptyHeap(void)
|
||||
{
|
||||
void *BiosManagerPtr = (void *) GetHeapBase(NULL);
|
||||
memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
|
||||
}
|
||||
|
||||
#if CONFIG_NORTHBRIDGE_AMD_AGESA_FAMILY15_TN
|
||||
|
||||
#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
|
||||
|
||||
AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
|
||||
{
|
||||
UINT32 AvailableHeapSize;
|
||||
UINT8 *BiosHeapBaseAddr;
|
||||
UINT32 CurrNodeOffset;
|
||||
UINT32 PrevNodeOffset;
|
||||
UINT32 FreedNodeOffset;
|
||||
UINT32 BestFitNodeOffset;
|
||||
UINT32 BestFitPrevNodeOffset;
|
||||
UINT32 NextFreeOffset;
|
||||
BIOS_BUFFER_NODE *CurrNodePtr;
|
||||
BIOS_BUFFER_NODE *FreedNodePtr;
|
||||
BIOS_BUFFER_NODE *BestFitNodePtr;
|
||||
BIOS_BUFFER_NODE *BestFitPrevNodePtr;
|
||||
BIOS_BUFFER_NODE *NextFreePtr;
|
||||
BIOS_HEAP_MANAGER *BiosHeapBasePtr;
|
||||
AGESA_BUFFER_PARAMS *AllocParams;
|
||||
|
||||
AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
|
||||
AllocParams->BufferPointer = NULL;
|
||||
|
||||
#if CONFIG_NORTHBRIDGE_AMD_AGESA_FAMILY15_TN
|
||||
/* if the allocation is for runtime use simple CBMEM data */
|
||||
if (Data == HEAP_CALLOUT_RUNTIME)
|
||||
return alloc_cbmem(AllocParams);
|
||||
#endif
|
||||
|
||||
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 agesa_DeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
|
||||
{
|
||||
|
||||
UINT8 *BiosHeapBaseAddr;
|
||||
UINT32 AllocNodeOffset;
|
||||
UINT32 PrevNodeOffset;
|
||||
UINT32 NextNodeOffset;
|
||||
UINT32 FreedNodeOffset;
|
||||
UINT32 EndNodeOffset;
|
||||
BIOS_BUFFER_NODE *AllocNodePtr;
|
||||
BIOS_BUFFER_NODE *PrevNodePtr;
|
||||
BIOS_BUFFER_NODE *FreedNodePtr;
|
||||
BIOS_BUFFER_NODE *NextNodePtr;
|
||||
BIOS_HEAP_MANAGER *BiosHeapBasePtr;
|
||||
AGESA_BUFFER_PARAMS *AllocParams;
|
||||
|
||||
AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
|
||||
|
||||
BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
|
||||
BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
|
||||
|
||||
/* Find target node to deallocate in list of allocated nodes.
|
||||
* Return AGESA_BOUNDS_CHK if the BufferHandle is not found.
|
||||
*/
|
||||
AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
|
||||
AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
|
||||
PrevNodeOffset = AllocNodeOffset;
|
||||
|
||||
while (AllocNodePtr->BufferHandle != AllocParams->BufferHandle) {
|
||||
if (AllocNodePtr->NextNodeOffset == 0) {
|
||||
return AGESA_BOUNDS_CHK;
|
||||
}
|
||||
PrevNodeOffset = AllocNodeOffset;
|
||||
AllocNodeOffset = AllocNodePtr->NextNodeOffset;
|
||||
AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
|
||||
}
|
||||
|
||||
/* Remove target node from list of allocated nodes */
|
||||
PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
|
||||
PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
|
||||
|
||||
/* Zero out the buffer, and clear the BufferHandle */
|
||||
LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
|
||||
AllocNodePtr->BufferHandle = 0;
|
||||
AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
|
||||
|
||||
/* Add deallocated node in order to the list of freed nodes */
|
||||
FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
|
||||
FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
|
||||
|
||||
EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
|
||||
|
||||
if (AllocNodeOffset < FreedNodeOffset) {
|
||||
/* Add to the start of the freed list */
|
||||
if (EndNodeOffset == FreedNodeOffset) {
|
||||
/* If the freed node is adjacent to the first node in the list, concatenate both nodes */
|
||||
AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
|
||||
AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
|
||||
|
||||
/* Clear the BufferSize and NextNodeOffset of the previous first node */
|
||||
FreedNodePtr->BufferSize = 0;
|
||||
FreedNodePtr->NextNodeOffset = 0;
|
||||
|
||||
} else {
|
||||
/* Otherwise, add freed node to the start of the list
|
||||
* Update NextNodeOffset and BufferSize to include the
|
||||
* size of BIOS_BUFFER_NODE.
|
||||
*/
|
||||
AllocNodePtr->NextNodeOffset = FreedNodeOffset;
|
||||
}
|
||||
/* Update StartOfFreedNodes to the new first node */
|
||||
BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
|
||||
} else {
|
||||
/* Traverse list of freed nodes to find where the deallocated node
|
||||
* should be 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 agesa_LocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
|
||||
{
|
||||
UINT32 AllocNodeOffset;
|
||||
UINT8 *BiosHeapBaseAddr;
|
||||
BIOS_BUFFER_NODE *AllocNodePtr;
|
||||
BIOS_HEAP_MANAGER *BiosHeapBasePtr;
|
||||
AGESA_BUFFER_PARAMS *AllocParams;
|
||||
|
||||
AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
|
||||
|
||||
BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
|
||||
BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
|
||||
|
||||
AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
|
||||
AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
|
||||
|
||||
while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
|
||||
if (AllocNodePtr->NextNodeOffset == 0) {
|
||||
AllocParams->BufferPointer = NULL;
|
||||
AllocParams->BufferLength = 0;
|
||||
return AGESA_BOUNDS_CHK;
|
||||
} else {
|
||||
AllocNodeOffset = AllocNodePtr->NextNodeOffset;
|
||||
AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
|
||||
}
|
||||
}
|
||||
|
||||
AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
|
||||
AllocParams->BufferLength = AllocNodePtr->BufferSize;
|
||||
|
||||
return AGESA_SUCCESS;
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user