// Copyright (c) 2008-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\arm\armutils.cpp

// 

//

#include <arm.h>

#include <nktest/nkutils.h>

const TUint32 KPageSize = 0x1000u;

extern "C" {

void thread_request_signal(NThread* aThread);

TUint64 fcf;

TUint32 nfcf;

TUint32 nfcfs;

TUint32 round_to_page(TUint32 x)

	{

	return (x + KPageSize - 1) &~ (KPageSize - 1);

	}

TLinAddr __initial_stack_base()

	{

	return __stack_pointer() & ~0xfff;

	}

TInt __initial_stack_size()

	{

	return 0x1000;

	}

TUint64 fast_counter_freq()

	{

	return fcf;

	}

TUint32 norm_fast_counter_freq()

	{

	return nfcf;

	}

void init_fast_counter()

	{

	NKern::Sleep(30);

	TUint64 initial = fast_counter();

	NKern::Sleep(1000);

	TUint64 final = fast_counter();

	fcf = final - initial;

	TUint64 f = fcf;

	nfcfs = 0;

	while (f > 2000000)

		f>>=1, ++nfcfs;

	nfcf = (TUint32)(fcf >> nfcfs);

	DEBUGPRINT("fcf=%lx",fcf);

	DEBUGPRINT("nfcf=%d",nfcf);

	}

TInt __microseconds_to_fast_counter(TInt us)

	{

	TUint64 x = TUint64(TUint32(us));

	x *= fcf;

	x += TUint64(500000);

	x /= TUint64(1000000);

	return (TInt)x;

	}

TInt __microseconds_to_norm_fast_counter(TInt us)

	{

	TUint64 x = TUint64(TUint32(us));

	x *= nfcf;

	x += TUint64(500000);

	x /= TUint64(1000000);

	return (TInt)x;

	}

void nfcfspin(TUint32 aTicks)

	{

	TUint64 ticks = aTicks;

	ticks <<= nfcfs;

	fcfspin(ticks);

	}

void fcfspin(TUint64 aTicks)

	{

	TUint64 t0 = fast_counter();

	TUint64 t1;

	do	{

		t1 = fast_counter();

		t1 -= t0;

		} while (t1<aTicks);

	}

extern TUint32 __cpsr();

void CheckPoint()

	{

	KPrintf("CPSR=%08x", __cpsr());

	}

void thread_request_signal(NThread* aThread)

	{

	NKern::ThreadRequestSignal(aThread);

	}

}

TAny* operator new(TUint aSize) __NO_THROW

//

// The global new operator.

//

	{

	return malloc(aSize);

	}

TAny* operator new[](TUint aSize) __NO_THROW

    {

    return malloc(aSize);

    }

void operator delete(TAny* aPtr) __NO_THROW

//

// The replacement delete operator.

//

	{

	free(aPtr);

	}

void operator delete[](TAny* aPtr) __NO_THROW

    {

	free(aPtr);

    }

#ifdef __ARMCC__

TAny* operator new(TUint aSize, const std::nothrow_t& aNoThrow) __NO_THROW

//

// The global new operator.

//

	{

	(void)aNoThrow;

	return malloc(aSize);

	}

TAny* operator new[](TUint aSize, const std::nothrow_t& aNoThrow) __NO_THROW

    {

    (void)aNoThrow;

    return malloc(aSize);

    }

#endif

#ifdef __SMP__

#include <arm_tmr.h>

void TickTimerFn(TAny*);

NFastSemaphore TTSem;

void TTIDfcFn(TAny*)

	{

	TTSem.Signal();

	}

TDfc TTIDfc(&TTIDfcFn,0);

NTimer TickTimer(&TickTimerFn,0);

volatile TInt State=0;

volatile TInt Cycle=0;

volatile TInt WC[1024];

volatile TInt WCI=0;

void TickTimerFn(TAny* aPtr)

	{

	ArmLocalTimer& T = LOCAL_TIMER;

	TInt c = (TInt)T.iWatchdogCount;

	WC[WCI++]=c;

	if (c<0)

		{

		if (++State==3)

			{

			if (++Cycle==3)

				{

				TTIDfc.Add();

				return;

				}

			T.iWatchdogCount = 1900000u;

			State = 0;

			}

		}

	TickTimer.Again(1);

	}

void DoWatchdogTimerTest()

	{

	NKern::FSSetOwner(&TTSem, NKern::CurrentThread());

	ArmLocalTimer& T = LOCAL_TIMER;

	T.iWatchdogLoad = KMaxTUint32;

	T.iWatchdogCount = 2097152;

	T.iWatchdogIntStatus = 1;

	__e32_io_completion_barrier();

	T.iWatchdogCtrl = 3;

	__e32_io_completion_barrier();

	TickTimer.OneShot(1);

	NKern::FSWait(&TTSem);

	TInt i;

	for (i=0; i<WCI; ++i)

		{

		DEBUGPRINT("%03d: %d", i, WC[i]);

		}

	}

#endif