// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\include\memmodel\epoc\mmubase\ramalloc.h

// 

//

/**

 @file

 @internalComponent

*/

#ifndef __RAMALLOC_H__

#define __RAMALLOC_H__

#include <kernel/klib.h>

// RAM information block passed from bootstrap to kernel.

// Consists of two consecutive lists of SRamBank structures, each terminated by

// a bank with iSize=0.

// The first list specifies all available blocks of RAM in the system.

// The second list specifies any blocks of RAM which are reserved and not

// available for general allocation. This should not include RAM mapped by the

// bootstrap - this will be discovered when the initial page mappings are

// analysed.

struct SRamInfo

	{

	SRamBank iBanks[1];				// extend for multiple banks

//	SRamBank iReservedBlocks[1];

	};

/** The number of types of pages that can't be moved or discarded

*/

const TInt KPageImmovable = EPageMovable;

/** The lowest enum from TZonePageType that DRamAllocater will allocate

*/

const TUint KPageTypeAllocBase = EPageFixed;

/** Element 0 of SZone::iBma is the bit map of all allocated pages 

regardless of type.

*/

const TUint KBmaAllPages = 0;

/** The maximum number of freeable contiguous pages that can be found by

DRamAllocator::FindFreeableContiguousPages and RamCacheBase::AllocFreeContiguousPages.

*/

const TUint KMaxFreeableContiguousPages = 16;

/** Structure to store the information on a zone.

*/

struct SZone

	{

	TBitMapAllocator* iBma[EPageTypes];	/**< Pointers to bit map allocators for each type of page*/

	TPhysAddr iPhysBase;	/**< physical base address of this zone*/

	TPhysAddr iPhysEnd;		/**< physical end address of this zone*/

	TUint32 iPhysPages;		/**< the total no. of pages that are in this zone*/

	TUint32 iAllocPages[EPageTypes]; /**< number of pages allocated of each type*/

	TUint32 iFreePages;		/**< number of pages free*/

	SDblQueLink iPrefLink;	/**< The link of this zone into the preference ordered list*/

	TUint iPrefRank;		/**< The rank of this zone in the preference ordered list.*/

	TUint iId;				/**< the ID of the zone*/

	TUint iFlags;			/**< bit flags for this zone, all flags masked KRamZoneFlagInvalid are 

								 for use by the kernel only*/

	TUint8 iPref;			/**< the preference of the zone, lower preference zones are used first*/

	};

/** The different stages of a general defragmentation*/

enum TGenDefragStage

	{

	EGenDefragStage0,	/**< 	This stage should discard any pages needed to

								allow the required movable pages to fit into the

								RAM zones to be in use after the general defrag.*/

	EGenDefragStage1,	/**< 	This stage should reduce the number of RAM

								zones in use to the minmum required.*/

	EGenDefragStage2,	/**<	This stage clears space in most preferable RAM 

								zones for fixed page allocations by placing movable 

								and discardable pages in the least preferable RAM 

								zones in use.*/

	EGenDefragStageEnd,

	};

// forward declare

struct SPageInfo;

class DRamAllocator : public DBase

	{

private:

	/** Used with NextAllocZone to specify which order to run through the zones

	*/

	enum TZoneSearchState

		{

		EZoneSearchPref,

		EZoneSearchAddr,

		EZoneSearchEnd,

		};

	enum TPanic

		{

		EDoNotUse=0,

		EDoMarkPagesAllocated1=1,

		EAllocRamPagesInconsistent=2,

		EZonesTooNumerousOrFew=3,	/**<There are too many or too few RAM zones*/

		EZonesNotDistinct=4,		/**<Some of the RAM zones overlap*/

		EZonesIncomplete=5,			/**<The RAM zones don't cover all the RAM, either because the zones 

										are too small or at least one zone is mapped to an incorrect address*/

		EZonesIDInvalid=6,			/**<KRamZoneInvalidId can't be used for any zone's ID*/

		EZonesIDNotUnique=7,		/**<At least two zones share the same ID*/

		EZonesAlignment=8,			/**<Zones are not aligned to page boundaries*/

		EZonesCountErr=9,			/**<The count of free and alloc'd zone pages is corrupted*/

		EZonesCallbackErr=10,		/**<Unexpected error when zone call back invoked*/

		EZonesFlagsInvalid=11,		/**<Attempt to create a zone with flags set to invalid values*/

		ECreateNoMemory=12,			/**<Not enough free RAM to create a DRamAllocator object*/

		ECreateInvalidReserveBank=13,/**<A specified reserve bank could not be reserved*/

		ECreateInvalidRamBanks=14,	/**<The specified RAM banks are invalid*/

		EFreeingLockedPage=15, 		/**< A locked page was requested for freeing*/

		};

public:

	static DRamAllocator* New(const SRamInfo& aInfo, const SRamZone* aZoneInfo, TRamZoneCallback aZoneCallback);

	static void Panic(TPanic aPanic);

	TUint TotalPhysicalRamPages();

	TInt FreeRamInBytes();

	TUint FreeRamInPages();

	TInt ClaimPhysicalRam(TPhysAddr aBase, TInt aSize);

	TInt FreePhysicalRam(TPhysAddr aBase, TInt aSize);

	void Create(const SRamInfo& aInfo, const SRamZone* aZones, TRamZoneCallback aZoneCallback);

	TInt MarkPageAllocated(TPhysAddr aAddr, TZonePageType aType);

	void MarkPagesAllocated(TPhysAddr aAddr, TInt aCount, TZonePageType aType);

	TInt FreeRamPage(TPhysAddr aAddr, TZonePageType aType);

	void FreeRamPages(TPhysAddr* aPageList, TInt aNumPages, TZonePageType aType);

	TInt AllocRamPages(TPhysAddr* aPageList, TInt aNumPages, TZonePageType aType, TUint aBlockedZoneId=KRamZoneInvalidId, TBool aBlockRest=EFalse);

	TInt ZoneAllocRamPages(TUint* aZoneIdList, TUint aZoneIdCount, TPhysAddr* aPageList, TInt aNumPages, TZonePageType aType);

	TInt AllocContiguousRam(TUint aNumPages, TPhysAddr& aPhysAddr, TZonePageType aType, TInt aAlign=0, TUint aBlockZoneId=KRamZoneInvalidId, TBool aBlockRest=EFalse);

	TInt ZoneAllocContiguousRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aSize, TPhysAddr& aPhysAddr, TZonePageType aType, TInt aAlign);

#ifdef _DEBUG

	void DebugDump();

#endif

#ifdef __VERIFY_LEASTMOVDIS

	void VerifyLeastPrefMovDis();

#endif

	TInt GetZonePageCount(TUint aId, SRamZonePageCount& aPageData);

	void ChangePageType(SPageInfo* aPageInfo, TZonePageType aOldType, TZonePageType aNewType);

#ifdef BTRACE_RAM_ALLOCATOR

	void SendInitialBtraceLogs(void);

#endif

	TInt GetZoneAddress(TUint aZoneId, TPhysAddr& aPhysBase, TUint& aNumPages);

	TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);

	TInt NextAllocatedPage(SZone* aZone, TUint& aOffset, TZonePageType aType) const;

	TUint GenDefragFreePages(TZonePageType aType) const;

	SZone* GeneralDefragStart0(TGenDefragStage& aStage, TUint& aRequiredToBeDiscarded);

	SZone* GeneralDefragNextZone0();

	SZone* GeneralDefragStart1();

	SZone* GeneralDefragNextZone1();

	SZone* GeneralDefragStart2();

	SZone* GeneralDefragNextZone2();

	void GeneralDefragEnd();

	SZone* ZoneFromId(TUint aId) const;

	void ZoneClaimStart(SZone& aZone);

	void ZoneClaimEnd(SZone& aZone);

	TInt ModifyZoneFlags(TUint aId, TUint aClearFlags, TUint aSetFlags);

	void ZoneMark(SZone& aZone);

	TBool ZoneUnmark(SZone& aZone);

	void InitialCallback();

private:

	static DRamAllocator* New();

	SZone* GetZoneAndOffset(TPhysAddr aAddr, TInt& aOffset);

	inline void CountZones(const SRamZone* aZones);

	inline void SortRamZones(const SRamZone* aZones, TUint8* aZoneAddrOrder);

	void ZoneAllocPages(SZone* aZone, TUint32 aCount, TZonePageType aType);

	void ZoneFreePages(SZone* aZone, TUint32 aCount, TZonePageType aType);

	void ZoneClearPages(SZone& aZone, TUint aRequiredPages);

	TUint32 ZoneFindPages(TPhysAddr*& aPageList, SZone& aZone, TUint32 aNumPages, TZonePageType aType);

	TInt SetPhysicalRamState(TPhysAddr aBase, TInt aSize, TBool aState, TZonePageType aType);

	inline TUint InitSPageInfos(const SZone* aZone);

	TBool NextAllocZone(SZone*& aZone, TZoneSearchState& aState, TZonePageType aType, TUint aBlockedZoneId, TBool aBlockRest);

	TBool NoAllocOfPageType(SZone& aZone, TZonePageType aType) const;

private:

	TPhysAddr iPhysAddrBase;	// lowest valid physical address

	TPhysAddr iPhysAddrTop;		// highest valid physical address

	TUint iTotalFreeRamPages;

	TUint iTotalRamPages;

	SZone* iZones;				/**< per-zone info stored in ascending address order*/

	TUint32 iNumZones;			/**< The number of zones*/

	SDblQue iZonePrefList;		/**< Doubly linked list of zones in preference order*/

	SDblQueLink* iZoneLeastMovDis; 		/**< Link to the least preferable RAM zone that has discardable or movable pages*/

	TUint iZoneLeastMovDisRank; 		/**< Rank of the least preferable RAM zone that has discardable or movable pages*/

	TUint64 iZonePwrState;				/**< mask of currently used power blocks*/

	TBool iZoneCallbackInitSent;		/**< Set to ETrue once an ERamZoneOp_Init has been issued*/

	TRamZoneCallback iZonePowerFunc;	/**< Callback function to invoke when RAM zone power state changes*/

	TInt iZoneTmpAddrIndex;				/**< Used by NextAllocZone*/

	SDblQueLink* iZoneTmpPrefLink;		/**< Used by NextAllocZone*/

	SDblQueLink* iZoneGeneralPrefLink;	/**< Link to the current RAM zone being defragged*/

	SDblQueLink* iZoneGeneralTmpLink;	/**< Link to the current RAM zone being defragged*/

	TUint iZoneGeneralStage;			/**< The current stage of any general defrag operation*/

#ifdef _DEBUG

	TBool iAllowBmaVerify;

#endif

	};

#endif