// Copyright (c) 2006-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:

 // e32test\nkernsa\nkutils.cpp

 // 

 //

 #include <nktest/nkutils.h>

 extern TDfcQue* CleanupDfcQ;

 class NThreadX : public NThread

 	{

 public:

 	NThreadX();

 	static void KillDfcFn(TAny*);

 	static TDfc* ExitHandler(NThread* aThread);

 	static void ExceptionHandler(TAny* aPtr, NThread* aThread);

 	static void SignalSemaphoreOnExit(TAny* aP, NThread* aT, TInt aC);

 public:

 	TDfc iKillDfc;

 	TExitFunc iExitFunc;

 	TAny* iExitParam;

 	};

 extern const SNThreadHandlers ThreadHandlers =

 	{

 	&NThreadX::ExitHandler,

 	NTHREAD_DEFAULT_STATE_HANDLER,

 	&NThreadX::ExceptionHandler,

 	0

 	};

 NThreadX::NThreadX()

 	: iKillDfc(&KillDfcFn, this, 1), iExitFunc(0)

 	{

 	}

 void NThreadX::KillDfcFn(TAny* a)

 	{

 	NThreadX* t = (NThreadX*)a;

 	TExitFunc f = t->iExitFunc;

 	TAny* p = t->iExitParam;

 	if (f)

 		(*f)(p, t, 1);

 #ifdef __SMP__

 	free((TAny*)t->iNThreadBaseSpare8);

 #else

 	free((TAny*)t->iSpare8);

 #endif

 	free((TAny*)t->iStackBase);

 	free(t);

 	if (f)

 		(*f)(p, t, 2);

 	}

 TDfc* NThreadX::ExitHandler(NThread* aT)

 	{

 	NThreadX* t = (NThreadX*)aT;

 	if (t->iExitFunc)

 		(*t->iExitFunc)(t->iExitParam, t, 0);

 	return &t->iKillDfc;

 	}

 extern "C" void ExcFault(TAny*);

 void NThreadX::ExceptionHandler(TAny* aPtr, NThread*)

 	{

 	NKern::DisableAllInterrupts();

 	ExcFault(aPtr);

 	}

 extern "C" unsigned int strlen(const char*);

 NThread* CreateThread(const char* aName, NThreadFunction aFunc, TInt aPri, const TAny* aParams, TInt aPSize, TBool aResume, TInt aTimeslice, TExitFunc aExitFunc, TAny* aExitParam, TUint32 aCpuAffinity, NThreadGroup* aGroup)

 	{

 	__KTRACE_OPT(KTHREAD,DEBUGPRINT("CreateThread %s pri %d", aName, aPri));

 	TInt nlen = (TInt)strlen(aName);

 	NThreadX* t = new NThreadX;

 	TAny* stack = malloc(KStackSize);

 	memset(stack, 0xee, KStackSize);

 	TAny* namebuf = malloc(nlen+1);

 	memcpy(namebuf, aName, nlen+1);

 	__KTRACE_OPT(KTHREAD,DEBUGPRINT("CreateThread -> thread at %08x stack %08x", t, stack));

 	SNThreadCreateInfo info;

 	info.iFunction = aFunc;

 	info.iStackBase = stack;

 	info.iStackSize = KStackSize;

 	info.iPriority = aPri;

 	info.iTimeslice = aTimeslice;

 	info.iAttributes = 0;

 	info.iHandlers = &ThreadHandlers;

 	info.iFastExecTable = 0;

 	info.iSlowExecTable = 0;

 	info.iParameterBlock = (const TUint32*)aParams;

 	info.iParameterBlockSize = aPSize;

 #ifdef __SMP__

 	info.iCpuAffinity = aCpuAffinity;

 	info.iGroup = aGroup;

 #endif

 	TInt r = NKern::ThreadCreate(t, info);

 	__NK_ASSERT_ALWAYS(r==KErrNone);

 #ifdef __SMP__

 	t->iNThreadBaseSpare8 = (TUint32)namebuf;

 #else

 	t->iSpare8 = (TUint32)namebuf;

 #endif

 	t->iKillDfc.SetDfcQ(CleanupDfcQ);

 	t->iExitFunc = aExitFunc;

 	t->iExitParam = aExitParam;

 	if (aResume)

 		NKern::ThreadResume(t);

 	return t;

 	}

 void NThreadX::SignalSemaphoreOnExit(TAny* aP, NThread* aT, TInt aC)

 	{

 	NFastSemaphore* s = (NFastSemaphore*)aP;

 	(void)aT;

 	if (aC==EAfterFree)

 		NKern::FSSignal(s);

 	}

 NThread* CreateThreadSignalOnExit(const char* aName, NThreadFunction aFunc, TInt aPri, const TAny* aParams, TInt aPSize, TInt aTimeslice, NFastSemaphore* aExitSem, TUint32 aCpuAffinity, NThreadGroup* aGroup)

 	{

 	return CreateThread(aName, aFunc, aPri, aParams, aPSize, TRUE, aTimeslice, &NThreadX::SignalSemaphoreOnExit, aExitSem, aCpuAffinity, aGroup);

 	}

 NThread* CreateUnresumedThreadSignalOnExit(const char* aName, NThreadFunction aFunc, TInt aPri, const TAny* aParams, TInt aPSize, TInt aTimeslice, NFastSemaphore* aExitSem, TUint32 aCpuAffinity, NThreadGroup* aGroup)

 	{

 	return CreateThread(aName, aFunc, aPri, aParams, aPSize, FALSE, aTimeslice, &NThreadX::SignalSemaphoreOnExit, aExitSem, aCpuAffinity, aGroup);

 	}

 void CreateThreadAndWaitForExit(const char* aName, NThreadFunction aFunc, TInt aPri, const TAny* aParams, TInt aPSize, TInt aTimeslice, TUint32 aCpuAffinity, NThreadGroup* aGroup)

 	{

 	NFastSemaphore s(0);

 	CreateThread(aName, aFunc, aPri, aParams, aPSize, TRUE, aTimeslice, &NThreadX::SignalSemaphoreOnExit, &s, aCpuAffinity, aGroup);

 	NKern::FSWait(&s);

 	}

 TDfcQue* CreateDfcQ(const char* aName, TInt aPri, TUint32 aCpuAffinity, NThreadGroup* aGroup)

 	{

 	__KTRACE_OPT(KTHREAD,DEBUGPRINT("CreateDfcQ %s pri %d cpu %08x", aName, aPri, aCpuAffinity));

 	__KTRACE_OPT(KTHREAD,DEBUGPRINT("NKern::CurrentThread() = %08x\n", NKern::CurrentThread()));

 	TDfcQue* q = new TDfcQue;

 	__KTRACE_OPT(KTHREAD,DEBUGPRINT("CreateDfcQ -> %08x", q));

 	NThread* t = CreateThread(aName, &TDfcQue::ThreadFunction, aPri, q, 0, FALSE, KTimeslice, 0, 0, aCpuAffinity, aGroup);

 	q->iThread = t;

 	NKern::ThreadResume(t);

 	return q;

 	}

 void killDfcFn(TAny* aPtr)

 	{

 	TDfcQue* q = (TDfcQue*)aPtr;

 	delete q;

 	NKern::Exit();

 	}

 void DestroyDfcQ(TDfcQue* aQ)

 	{

 	NFastSemaphore exitSem(0);

 	TDfc killDfc(&killDfcFn, aQ, aQ, 0);

 	NThreadX* t = (NThreadX*)aQ->iThread;

 	t->iExitFunc = &NThreadX::SignalSemaphoreOnExit;

 	t->iExitParam = &exitSem;

 	killDfc.Enque();

 	NKern::FSWait(&exitSem);

 	}

 #ifdef __SMP__

 class NKTest

 	{

 public:

 	static TInt FSWait(NFastSemaphore* aS, TUint32 aTimeout);

 	};

 TInt WaitWithTimeout(NFastSemaphore* aS, TUint32 aTimeout)

 	{

 	return NKTest::FSWait(aS, aTimeout);

 	}

 TInt NKTest::FSWait(NFastSemaphore* aS, TUint32 aTimeout)

 	{

 	NThreadBase* pC = NKern::LockC();

 	pC->iWaitState.SetUpWait(NThreadBase::EWaitFastSemaphore, 0, aS, aTimeout);

 	if (aS->Dec(pC))					// full barrier

 		pC->iWaitState.CancelWait();	// don't have to wait

 	else

 		RescheduleNeeded();				// have to wait

 	NKern::PreemptionPoint();

 	TInt r = pC->iWaitState.iWtC.iRetVal;

 	NKern::Unlock();

 	return r;

 	}

 #else

 TInt WaitWithTimeout(NFastSemaphore* aS, TUint32 aTimeout)

 	{

 	NThreadBase* pC = NKern::LockC();

 	if (--aS->iCount < 0)

 		{

 		NKern::NanoBlock(aTimeout, NThreadBase::EWaitFastSemaphore, aS);

 		}

 	NKern::PreemptionPoint();

 	TInt r = pC->iReturnValue;

 	if (r == KErrNone)

 		pC->Release(KErrNone);	// cancel the timer on normal completion

 	NKern::Unlock();

 	return r;

 	}

 #endif

 void FMWaitFull(NFastMutex* aMutex)

 	{

 	NKern::Lock();

 	aMutex->Wait();

 	NKern::Unlock();

 	}

 void FMSignalFull(NFastMutex* aMutex)

 	{

 	NKern::Lock();

 	aMutex->Signal();

 	NKern::Unlock();

 	}

 void WaitForRequest(NRequestStatus& aStatus)

 	{

 	TInt n = -1;

 	do	{

 		++n;

 		NKern::WaitForAnyRequest();

 		} while (aStatus == KRequestPending);

 	if (n > 0)

 		NKern::ThreadRequestSignal(0, n);

 	}

 extern "C" {

 void SpinWait(TUint32 aTicks)

 	{

 	TUint32 tc = NKern::TickCount() + aTicks;

 	TUint32 x;

 	do	{

 		x = NKern::TickCount();

 		} while (TInt(x-tc)<0);

 	}

 }