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

	}

}