dc357566ea
Propagate commit 9107e53 from amd/agesa and fix some related #includes under cpu/amd/pi. Change test to return true on S2 wakeup too. In S2 CPU would have been powered down so MTRR recovery is required. Change-Id: I18cb31c1124da53e5fcba2610f6b02d755feb092 Signed-off-by: Kyösti Mälkki <kyosti.malkki@gmail.com> Reviewed-on: http://review.coreboot.org/8171 Tested-by: build bot (Jenkins) Reviewed-by: Edward O'Callaghan <eocallaghan@alterapraxis.com>
343 lines
12 KiB
C
343 lines
12 KiB
C
|
|
#include "AGESA.h"
|
|
#include "amdlib.h"
|
|
#include <northbridge/amd/pi/BiosCallOuts.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;
|
|
|
|
}
|