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