// Copyright (c) 1995-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\euser\epoc\up_utl.cpp
// 
//

#include <u32exec.h>
#include "up_std.h"
#include <e32svr.h>
#include <e32uid.h>

#ifdef __EPOC32__
#include <e32rom.h>
#endif

#include <e32atomics.h>

//#define __DEBUG_IMAGE__ 1
#if defined(__DEBUG_IMAGE__) && defined (__EPOC32__)
extern RDebug debug;
#define __IF_DEBUG(t) {debug.t;}
#else
#define __IF_DEBUG(t)
#endif


/**
Atomically (i.e. in a manner which is safe against concurrent access by other
threads) increments a TInt value by 1.

As an example of its use, the function is used in the implementation of
critical sections.

@param aValue A reference to an integer whose value is to be incremented. 
              On return contains the incremented value.
              
@return The value of aValue before it is incremented.

@see User::LockedDec
@see RCrticalSection
*/
EXPORT_C TInt User::LockedInc(TInt& aValue)
	{
	return (TInt)__e32_atomic_add_ord32(&aValue, 1);
	}


/**
Atomically (i.e. in a manner which is safe against concurrent access by other
threads) decrements a TInt value by 1.

As an example of its use, the function is used in the implementation of
critical sections.

@param aValue A reference to an integer whose value is to be decremented. 
              On return contains the decremented value.
              
@return The value of aValue before it is decremented.

@see User::LockedInc
@see RCrticalSection
*/
EXPORT_C TInt User::LockedDec(TInt& aValue)
	{
	return (TInt)__e32_atomic_add_ord32(&aValue, 0xFFFFFFFF);
	}




EXPORT_C TInt User::SafeInc(TInt& aValue)
/**
Atomically increments the specified value by 1, if the value is > 0.

@param aValue The value to be incremented; on return the incremented value.

@return The original value of aValue
*/
	{
	return __e32_atomic_tas_ord32(&aValue, 1, 1, 0);
	}




EXPORT_C TInt User::SafeDec(TInt &aValue)
/**
Atomically decrements the specified value by 1, if the value is > 0.

@param aValue The value to be decremented; on return the decremented value.

@return The original value of aValue
*/
	{
	return __e32_atomic_tas_ord32(&aValue, 1, -1, 0);
	}


EXPORT_C void UserSvr::WsRegisterThread()
//
// Register the window server thread.
//
    {

	Exec::WsRegisterThread();
	}

EXPORT_C void UserSvr::FsRegisterThread()
//
// Register the file server thread.
//
	{
	Exec::FsRegisterThread();
	}

EXPORT_C void UserSvr::RegisterTrustedChunk(TInt aHandle)
/**
Registers file server's chunk intended for DMA transfer.
@internalComponent
@released 
 */
	{
	Exec::RegisterTrustedChunk(aHandle);
	}

EXPORT_C TInt UserHeap::SetupThreadHeap(TBool, SStdEpocThreadCreateInfo& aInfo)
/**
@internalComponent
*/
	{
	TInt r = KErrNone;
	if (!aInfo.iAllocator && aInfo.iHeapInitialSize>0)
		{
		// new heap required
		RHeap* pH = NULL;
		r = CreateThreadHeap(aInfo, pH);
		}
	else if (aInfo.iAllocator)
		{
		// sharing a heap
		RAllocator* pA = aInfo.iAllocator;
		pA->Open();
		User::SwitchAllocator(pA);
		}
	return r;
	}




EXPORT_C void User::HandleException(TAny* aInfo)
/**
Enables the current thread to handle an exception.

The function is called by the kernel.

@param aInfo A pointer to a TExcType type containing the exception information.

@see TExcType
*/
	{

	const TUint32* p = (const TUint32*)aInfo;
	TUint32 excType = p[0];
	TExceptionHandler f = Exec::ExceptionHandler(KCurrentThreadHandle);
	TRAPD(r, (*f)(TExcType(excType)) );
	Exec::ThreadSetFlags(KCurrentThreadHandle,KThreadFlagLastChance,0);
	if (r!=KErrNone)
		User::Leave(r);
	}




#ifdef __EPOC32__
EXPORT_C TInt User::IsRomAddress(TBool &aBool, TAny *aPtr)
/**
Tests whether the specified address is in the ROM.

@param aBool True, if the address at aPtr is within the ROM; false, 
             otherwise.
@param aPtr  The address to be tested.

@return Always KErrNone.
*/
    {
    
	TUint a = (TUint)aPtr;
	TUint main_start = UserSvr::RomHeaderAddress();
	TUint main_end = main_start + ((TRomHeader*)main_start)->iUncompressedSize;
	aBool = (a>=main_start && a<main_end);
	if (aBool)
		return KErrNone;  // address is in main ROM
	
	TUint rda = UserSvr::RomRootDirectoryAddress();
	
	// We assume here, the primary rom starts a multiple of 4k.
	if (rda > main_end)
		{
		// ASSUMPTIONS HERE
		// 1. root directory is past the end of the main ROM so there must be an extension ROM
		// 2. the ROM file system in the extension ROM is at the beginning of the ROM (similar to the
		//    main ROM)
		// 3. the extension ROM is mapped starting at a megabyte boundary
		// Thus the address of the extension ROM header may be obtained by rounding the root directory
		// address down to the next megabyte boundary.
         
 		TUint ext_start = rda &~ 0x000fffffu;
		TUint ext_base = ((TExtensionRomHeader*)ext_start)->iRomBase;
		TUint ext_end = ext_start + ((TExtensionRomHeader*)ext_start)->iUncompressedSize;
		aBool = (ext_base==ext_start && a>=ext_start && a<ext_end);
 		}    return KErrNone;
    }
#endif


#ifdef __MARM__
EXPORT_C void E32Loader::GetV7StubAddresses(TLinAddr& aExe, TLinAddr& aDll)
	{
	// Only need V7 support on ARM platforms
	aExe = (TLinAddr)&E32Loader::V7ExeEntryStub;
	aDll = (TLinAddr)&E32Loader::V7DllEntryStub;
	}
#endif

#ifdef __MARM__
// Only need V7 support on ARM platforms

_LIT(KEka1EntryStubName, "eka1_entry_stub.dll");
extern "C" TLinAddr GetEka1ExeEntryPoint()
	{
	TLinAddr a = 0;
	RLibrary l;
	TInt r = l.Load(KEka1EntryStubName, KNullDesC, TUidType(KDynamicLibraryUid, KEka1EntryStubUid));
	if (r == KErrNone)
		r = l.Duplicate(RThread(), EOwnerProcess);
	if (r == KErrNone)
		{
		a = (TLinAddr)l.Lookup(1);
		if (!a)
			r = KErrNotSupported;
		}
	if (r != KErrNone)
		RThread().Kill(r);
	Exec::SetReentryPoint(a);
	return a;
	}
#endif