1 files changed, 118 insertions, 72 deletions

diff --git a/src/soc/amd/common/heapmanager.c b/src/soc/amd/common/heapmanager.c
index 3205a09974..6c240eb966 100644
--- a/src/soc/amd/common/heapmanager.c
+++ b/src/soc/amd/common/heapmanager.c
@@ -25,14 +25,14 @@ UINT32 GetHeapBase(AMD_CONFIG_PARAMS *StdHeader)
 	UINT32 heap = BIOS_HEAP_START_ADDRESS;
 
 	if (acpi_is_wakeup_s3())
-		heap = (UINT32) cbmem_find(CBMEM_ID_RESUME_SCRATCH);
+		heap = (UINT32)cbmem_find(CBMEM_ID_RESUME_SCRATCH);
 
 	return heap;
 }
 
 void EmptyHeap(void)
 {
-	void *BiosManagerPtr = (void *) GetHeapBase(NULL);
+	void *BiosManagerPtr = (void *)GetHeapBase(NULL);
 	memset(BiosManagerPtr, 0, BIOS_HEAP_SIZE);
 }
 
@@ -54,26 +54,32 @@ AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
 	AGESA_BUFFER_PARAMS *AllocParams;
 
-	AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
+	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;
+	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 = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ CurrNodeOffset);
 		CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
 		CurrNodePtr->BufferSize = AllocParams->BufferLength;
 		CurrNodePtr->NextNodeOffset = 0;
-		AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof(BIOS_BUFFER_NODE);
+		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;
+		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 */
@@ -84,16 +90,20 @@ AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 		 * If it has, return AGESA_BOUNDS_CHK.
 		 */
 		CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-		CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
+		CurrNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ CurrNodeOffset);
 
 		while (CurrNodeOffset != 0) {
-			CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
-			if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
+			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.
+			/* 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 */
@@ -101,8 +111,9 @@ AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 		PrevNodeOffset = FreedNodeOffset;
 		BestFitNodeOffset = 0;
 		BestFitPrevNodeOffset = 0;
-		while (FreedNodeOffset != 0) {
-			FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
+		while (FreedNodeOffset != 0) { /* todo: simplify this */
+			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 */
@@ -110,7 +121,7 @@ AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 					BestFitPrevNodeOffset = PrevNodeOffset;
 				} else {
 					/* Find out whether current node is a better fit than the previous nodes */
-					BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
+					BestFitNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr + BestFitNodeOffset);
 					if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
 						BestFitNodeOffset = FreedNodeOffset;
 						BestFitPrevNodeOffset = PrevNodeOffset;
@@ -122,43 +133,64 @@ AGESA_STATUS agesa_AllocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 		} /* end of while loop */
 
 		if (BestFitNodeOffset == 0) {
-			/* If we could not find a node that fits the requested buffer
-			 * size, return AGESA_BOUNDS_CHK.
+			/* 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;
+			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 */
+				/* 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 BestFitNode is the first buffer in the list, then
+			 * update StartOfFreedNodes to reflect new free node.
 			 */
-			if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
-				BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
-			} else {
-				BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
-			}
+			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->BufferHandle =
+						AllocParams->BufferHandle;
 			BestFitNodePtr->NextNodeOffset = 0;
 
 			/* Remove BestFitNode from list of Freed nodes */
-			AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof(BIOS_BUFFER_NODE);
+			AllocParams->BufferPointer = (UINT8 *)BestFitNodePtr
+						+ sizeof(BIOS_BUFFER_NODE);
 		}
 	}
 
@@ -181,50 +213,57 @@ AGESA_STATUS agesa_DeallocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
 	AGESA_BUFFER_PARAMS *AllocParams;
 
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
+	AllocParams = (AGESA_BUFFER_PARAMS *)ConfigPtr;
 
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
+	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);
+	AllocNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr + AllocNodeOffset);
 	PrevNodeOffset = AllocNodeOffset;
 
-	while (AllocNodePtr->BufferHandle !=  AllocParams->BufferHandle) {
-		if (AllocNodePtr->NextNodeOffset == 0) {
+	while (AllocNodePtr->BufferHandle != AllocParams->BufferHandle) {
+		if (AllocNodePtr->NextNodeOffset == 0)
 			return AGESA_BOUNDS_CHK;
-		}
 		PrevNodeOffset = AllocNodeOffset;
 		AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-		AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
+		AllocNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ AllocNodeOffset);
 	}
 
 	/* Remove target node from list of allocated nodes */
-	PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
+	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));
+	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);
+	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 */
+			/* If the freed node is adjacent to the first node in
+			 * the list, concatenate both nodes
+			 */
 			AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
+			AllocNodePtr->NextNodeOffset =
+						FreedNodePtr->NextNodeOffset;
 
-			/* Clear the BufferSize and NextNodeOffset of the previous first node */
+			/* Clear the BufferSize and NextNodeOffset of the
+			 * previous first node
+			 */
 			FreedNodePtr->BufferSize = 0;
 			FreedNodePtr->NextNodeOffset = 0;
 
@@ -238,41 +277,46 @@ AGESA_STATUS agesa_DeallocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 		/* 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.
+		/* 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) {
+			if (NextNodePtr->NextNodeOffset == 0)
 				break;
-			}
 			NextNodeOffset = NextNodePtr->NextNodeOffset;
-			NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + 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);
+			NextNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ NextNodeOffset);
 			AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
-			AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
+			AllocNodePtr->NextNodeOffset =
+						NextNodePtr->NextNodeOffset;
 
 			NextNodePtr->BufferSize = 0;
 			NextNodePtr->NextNodeOffset = 0;
 		} else {
-			/*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
+			/*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);
+		PrevNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ PrevNodeOffset);
 		EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
 		if (AllocNodeOffset == EndNodeOffset) {
-			PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
+			PrevNodePtr->NextNodeOffset =
+						AllocNodePtr->NextNodeOffset;
 			PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
 
 			AllocNodePtr->BufferSize = 0;
@@ -288,17 +332,17 @@ AGESA_STATUS agesa_LocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 {
 	UINT32              AllocNodeOffset;
 	UINT8               *BiosHeapBaseAddr;
-	BIOS_BUFFER_NODE   *AllocNodePtr;
-	BIOS_HEAP_MANAGER  *BiosHeapBasePtr;
+	BIOS_BUFFER_NODE    *AllocNodePtr;
+	BIOS_HEAP_MANAGER   *BiosHeapBasePtr;
 	AGESA_BUFFER_PARAMS *AllocParams;
 
-	AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
+	AllocParams = (AGESA_BUFFER_PARAMS *)ConfigPtr;
 
-	BiosHeapBaseAddr = (UINT8 *) GetHeapBase(&(AllocParams->StdHeader));
-	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BiosHeapBaseAddr;
+	BiosHeapBaseAddr = (UINT8 *)GetHeapBase(&(AllocParams->StdHeader));
+	BiosHeapBasePtr = (BIOS_HEAP_MANAGER *)BiosHeapBaseAddr;
 
 	AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
-	AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
+	AllocNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr + AllocNodeOffset);
 
 	while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
 		if (AllocNodePtr->NextNodeOffset == 0) {
@@ -307,11 +351,13 @@ AGESA_STATUS agesa_LocateBuffer (UINT32 Func, UINTN Data, VOID *ConfigPtr)
 			return AGESA_BOUNDS_CHK;
 		} else {
 			AllocNodeOffset = AllocNodePtr->NextNodeOffset;
-			AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
+			AllocNodePtr = (BIOS_BUFFER_NODE *)(BiosHeapBaseAddr
+						+ AllocNodeOffset);
 		}
 	}
 
-	AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof(BIOS_BUFFER_NODE));
+	AllocParams->BufferPointer = (UINT8 *)((UINT8 *)AllocNodePtr
+						+ sizeof(BIOS_BUFFER_NODE));
 	AllocParams->BufferLength = AllocNodePtr->BufferSize;
 
 	return AGESA_SUCCESS;