sys82xxdpramlib.c

Embedded Planet公司的ep8260单板计算机的BSP包（VxWorks）

/* sys82xxDpramLib.c - 82xx DPRAM memory allocation driver */

/* Copyright 1984-2001 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01b,17jul01,g_h   cleaning and renaming to sys82xxDpramLib.c
01a,16jul01,p_h   created
*/

/*
DESCRIPTION
This module contains 82xx DPRAM memory allocation driver.
*/

/* include */

#include "sys82xxDpramLib.h"

/* gobals */

/* external */

/* local */

LOCAL AddrResource AddrResPool[ALLOCTABLESIZE];
LOCAL Pool DprMainPool;
LOCAL Pool DprFccPool;

/* forward declaration */


/******************************************************************************
*
* sys82xxDpramAlignedAddr - aligned a given address
*
* RETURNS: new aligned address
*/

LOCAL UINT32 sys82xxDpramAlignedAddr(UINT32 Addr, UINT32 Alignment)
{
	if (Alignment) 
	{
		return ((Addr + Alignment - 1) & ~(Alignment - 1));
	}

	return (Addr);
}

/******************************************************************************
*
* sys82xxDpramAllocRange - alloc aligned mmeory
*
* RETURNS: 0
*/

LOCAL void* sys82xxDpramAllocRange(AddrResource *New, UINT32 Length, UINT32 Alignment, Pool *pPool)
{
	AddrResource *Prev, *Curr;
	UINT32 GapStart = 0,GapEnd;

	Curr = pPool->Head;
	Prev = 0;

	do
	{
		if (Prev) 
		{
			GapStart = sys82xxDpramAlignedAddr(Prev->Start+Prev->Size,Alignment);
		}
		else 
		{
			GapStart = sys82xxDpramAlignedAddr(pPool->Start,Alignment);
		}

		if (Curr) 
		{
			GapEnd = Curr->Start;
		}
		else 
		{
			GapEnd = pPool->Limit;
		}

		if (GapEnd > GapStart) 
		{
			if ((GapEnd - GapStart) >= Length) 
			{
				New->Start = GapStart;
				New->Size = Length;
				New->Next = Curr;

				if (Prev) 
				{
					Prev->Next = New;
				}

				if (!pPool->Head) 
				{
					pPool->Head = New;
				}

				return ((void*)(New->Start));
			}
		}

		Prev = Curr;
		if (Curr) 
		{
			Curr = Curr->Next;
		}
	} while (Curr || Prev);

	return 0;
}

/******************************************************************************
*
* sys82xxDpramFindFreeEntry - find first entry in the linked list
*
* RETURNS: pointer to first free entry or 0 if every thing full
*/

LOCAL AddrResource* sys82xxDpramFindFreeEntry (void)
{
	int i;

	for (i=0;i<ALLOCTABLESIZE;i++) 
	{
		if (AddrResPool[i].Start == 0) 
		{
			return &AddrResPool[i];
		}
	}
	
	return (0);
}

/******************************************************************************
*
* sys82xxDpramAllocateRange - allocate a reange of memory
*
* RETURNS: pointer to allocated memory or 0 if the is no free memory
*/

LOCAL void *sys82xxDpramAllocateRange(UINT32 RequestedLength, UINT32 Alignment, Pool *pPool)
{
	AddrResource *New;

	if((New = sys82xxDpramFindFreeEntry()) != NULL)
	{ 
		return sys82xxDpramAllocRange(New, RequestedLength, Alignment ,pPool);
	}

	return 0;
}

/******************************************************************************
*
* sys82xxDpramReleaseRenage - release allocated reange of memory
*
* RETURNS: None
*/

LOCAL void sys82xxDpramReleaseRenage(UINT32 Start, Pool *pPool)
{
	AddrResource *Curr, *Prev;

	Curr = pPool->Head;
	Prev = 0;

	while (Curr) 
	{
		if (Curr->Start == Start) 
		{
			if (Prev) 
			{
				Prev->Next = Curr->Next;
			}
			else 
			{
				pPool->Head = Curr->Next;
			}

			/* clear the released AddrResource structure */
			memset(Curr,0,sizeof(AddrResource));

			return;
		}

		Prev = Curr;
		Curr = Curr->Next;
	}

	return;
}

/******************************************************************************
*
* sys82xxDpramLibInit - init DPRAM memory allocation driver
*
* RETURNS: None
*/

void sys82xxDpramLibInit(void)
{
	UINT32 immr = vxImmrGet();	                               /* find the DPRAM start address */
	UINT32 rccr = (*(UINT32 *)(immr + 0x119C4) & 0xE000) >> 2; /* check for uCode */

	/* init the main dpram memory pool */
	DprMainPool.Start = immr + rccr + 0x100;
	DprMainPool.Limit = immr + 0x4000 -1;
	DprMainPool.Head = 0;

	/* init the spesial section memory pool (need for FCC in ATM or ETH mode)*/
	DprFccPool.Start = immr + 0xb000;
	DprFccPool.Limit = immr + 0xc000 - 1;
	DprFccPool.Head = 0;

	/* clear the AddrResource pool */
	memset(AddrResPool,0,sizeof(AddrResource) * ALLOCTABLESIZE);
}

/******************************************************************************
*
* sys82xxDpramMalloc - allocate memory from DPRAM main pool
*
* RETURNS: pointer to allocated memory 
*/

void* sys82xxDpramMalloc(size_t Length)
{
	return (sys82xxDpramAllocateRange(Length,0,&DprMainPool));
}

/******************************************************************************
*
* sys82xxDpramAlignedMalloc - allocate aligned memory from DPRAM main pool
*
* RETURNS: pointer to allocated aligend memory 
*/

void* sys82xxDpramAlignedMalloc(size_t Length, size_t Alignment)
{
	return (sys82xxDpramAllocateRange(Length, Alignment,&DprMainPool));
}

/******************************************************************************
*
* sys82xxDpramFree -  free allocated memory from DPRAM main pool
*
* RETURNS: None
*/

void sys82xxDpramFree (void* Addr)
{
	sys82xxDpramReleaseRenage((UINT32)Addr,&DprMainPool);
}

/******************************************************************************
*
* sys82xxDpramFccMalloc -  allocate memory from DPRAM FCC special pool
*
* RETURNS: pointer to allocated memory
*/

void* sys82xxDpramFccMalloc(size_t Length, size_t Alignment)
{
	return (sys82xxDpramAllocateRange(Length, Alignment,&DprFccPool));
}

/******************************************************************************
*
* sys82xxDpramFccMalloc -  free allocated memory from DPRAM FCC special pool
*
* RETURNS: pointer to allocated memory 
*/

void sys82xxDpramFccFree(void* Addr)
{
	sys82xxDpramReleaseRenage((UINT32)Addr,&DprFccPool);
}