// 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