// Copyright (c) 2003-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\math\t_vfp.cpp

// Overview:

// Test the ARM Vector Floating Point operations.

// API Information:

// VFP

// Details:

// - Check that the HAL agrees with the hardware about whether

// VFP is supported.

// - Test setting VFP to IEEE with no exceptions mode, if IEEE mode is

// supported, otherwise leave the mode alone.

// - Test single and double precision vector floating point operations:

// ABS, NEG, ADD, SUB, MUL, DIV, NMUL, SQRT, MAC, MSC, NMAC and NMSC.

// Verify results are as expected - if IEEE mode was set, verify

// bit-for-bit, in accordance with the IEEE specification, otherwise

// use normal floating point equality.

// - Test VFP context save.

// - Test various VFP operations that cause bounces to support code if

// IEEE mode is supported.

// - Test setting VFP to RunFast mode if RunFast mode is supported.

// - Test setting VFP rounding mode.

// - Test inheriting VFP mode to created threads.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

//! @file

//! @SYMTestCaseID KBASE-0017-T_VFP

//! @SYMTestCaseDesc VFPv2 general functionality and bounce handling

//! @SYMREQ 5159

//! @SYMTestPriority Critical

//! @SYMTestActions Check VFP functions correctly in all modes and that mode switching works correctly.

//! @SYMTestExpectedResults Test runs until this message is emitted: RTEST: SUCCESS : T_VFP test completed O.K.

//! @SYMTestType UT

#include "t_vfp.h"

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32math.h>

#include <hal.h>

#include <e32svr.h>

#include <u32hal.h>

RTest test(_L("T_VFP"));

TUint32 FPSID;

TUint32 ArchVersion; 

TBool Double;

TBool IEEEMode;

TInt CPUs;

TInt CurrentCpu1;

TInt CurrentCpu2;

typedef void TSglTest(const TReal32* aArgs, TReal32* aResults);

typedef void TDblTest(const TReal64* aArgs, TReal64* aResults);

TBool DetectVFP()

	{

	TInt r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalFloatingPointSystemId, &FPSID, NULL);

	return (r==KErrNone);

	}

TInt TestVFPInitThreadFn(TAny* aPtr)

	{

	UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*)CurrentCpu1, 0);

	TReal32* p = (TReal32*)aPtr;

	TInt i;

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

		*p++ = Vfp::SReg(i);

	return 0;

	}

void TestVFPInitialState()

	{

	for (CurrentCpu1 = 0; CurrentCpu1 < CPUs; CurrentCpu1++)

		{

		TReal32 f[32];

		RThread t;

		TInt r = t.Create(KNullDesC, &TestVFPInitThreadFn, 0x1000, NULL, f);

		test(r==KErrNone);

		TRequestStatus s;

		t.Logon(s);

		t.Resume();

		User::WaitForRequest(s);

		TInt xt = t.ExitType();

		TInt xr = t.ExitReason();

		test(xt == EExitKill && xr == KErrNone);

		CLOSE_AND_WAIT(t);

		UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*)CurrentCpu1, 0);

		test.Printf(_L("FPSCR = %08x for core %d\n"), Vfp::Fpscr(), CurrentCpu1);

		const TUint32* p = (const TUint32*)f;

		for (TInt i=0; i<32; ++i)

			{

			if (f[i] != 0.0f)

				{

				test.Printf(_L("S%d = 0x%08x\n"), i, p[i]);

				test(f[i] == 0.0f);

				}

			}

		}

	}

void TestVFPSglRegs(TInt aIter=2)

	{

	TInt i;

	TInt j;

	TInt nSglRegs=0; 

	switch(ArchVersion)	

		{ 

		case ARCH_VERSION_VFPV2:

		case ARCH_VERSION_VFPV3_SUBARCH_V2:

		case ARCH_VERSION_VFPV3_SUBARCH_NULL:

		case ARCH_VERSION_VFPV3_SUBARCH_V3:

			nSglRegs = 32;

			break; 		

		case 0:

		default:

			__ASSERT_ALWAYS(0, User::Panic(_L("Bad VFP version"),__LINE__)); 

			/* NOTREACHED */

		} 

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

		{

		for (j=0; j<nSglRegs; ++j)

			{

			TInt32 f = i + j;

			Vfp::SetSReg(f, j);

			}

		for (j=0; j<nSglRegs; ++j)

			{

			TInt32 f = i + j;

			TInt32 g = Vfp::SRegInt(j);

			test(f == g);

			}

		}

	}

TInt TestVFPSglRegsThread(TAny*)

	{

	UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*)CurrentCpu1, 0);

	TestVFPSglRegs(KMaxTInt);

	return 0;

	}

void TestVFPDblRegs(TInt aIter=2)

	{

	TInt i;

	TInt j;

	TInt nDblRegs=0; 

	switch(ArchVersion)

		{ 

		case ARCH_VERSION_VFPV2:

			{

			nDblRegs = 16;

			break;

			}

		case ARCH_VERSION_VFPV3_SUBARCH_V2:

		case ARCH_VERSION_VFPV3_SUBARCH_NULL:

		case ARCH_VERSION_VFPV3_SUBARCH_V3:

			{

			TInt vfpType;

			TInt ret = HAL::Get(HALData::EHardwareFloatingPoint, vfpType);

			if (ret == KErrNone && vfpType == EFpTypeVFPv3)

				nDblRegs = 32;

			else

				nDblRegs = 16;

			break;

				}

		case 0:

		default:

			__ASSERT_ALWAYS(0, User::Panic(_L("Bad VFP version"),__LINE__)); 

		} 

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

		{

		for (j=0; j<nDblRegs; ++j)

			{

			TInt64 f = i + j + KMaxTUint;

			Vfp::SetDReg(f, j);

			}

		for (j=0; j<nDblRegs; ++j)

			{

			TInt64 f = i + j + KMaxTUint;

			TInt64 g = Vfp::DRegInt(j);

			test(f == g);

			}

		}

	}

TInt TestVFPDblRegsThread(TAny*)

	{

	UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*)CurrentCpu2, 0);

	TestVFPDblRegs(KMaxTInt);

	return 0;

	}

void TestVFPContextSave()

	{

	for (CurrentCpu2 = 0; CurrentCpu2 < CPUs; CurrentCpu2++)

		{

		for (CurrentCpu1 = 0; CurrentCpu1 < CPUs; CurrentCpu1++)

			{

			TThreadFunction tf1 = &TestVFPSglRegsThread;

			TThreadFunction tf2 = Double ? &TestVFPDblRegsThread : &TestVFPSglRegsThread;

			RThread t1, t2;

			TInt r;

			r = t1.Create(KNullDesC, tf1, 0x1000, 0x1000, 0x1000, NULL);

			test(r==KErrNone);

			t1.SetPriority(EPriorityLess);

			r = t2.Create(KNullDesC, tf2, 0x1000, 0x1000, 0x1000, NULL);

			test(r==KErrNone);

			t2.SetPriority(EPriorityLess);

			TRequestStatus s1, s2;

			t1.Logon(s1);

			t2.Logon(s2);

			t1.Resume();

			t2.Resume();

			test.Printf(_L("Let threads run concurrently (cores %d and %d)\n"), CurrentCpu1, CurrentCpu2);

			User::After(20*1000*1000/CPUs);

			test.Printf(_L("Kill threads\n"));

			t1.Kill(0);

			t2.Kill(0);

			User::WaitForRequest(s1);

			User::WaitForRequest(s2);

			test(t1.ExitType()==EExitKill && t1.ExitReason()==KErrNone);

			test(t2.ExitType()==EExitKill && t2.ExitReason()==KErrNone);

			CLOSE_AND_WAIT(t1);

			CLOSE_AND_WAIT(t2);

			}

		}

	}

TInt TestBounceCtxThread1(TAny*)

	{

	for(TInt iter=0; iter<KMaxTInt; ++iter)

		{

		Vfp::SReg(0);

		}

	return KErrNone;

	}

TInt TestBounceCtxThread2(TAny*)

	{

	TInt start_rep = 0x00800000; // smallest single precision normal number, 1*2^-126

	TReal32 start = *(TReal32*)&start_rep;

	for(TInt iter=0; iter<KMaxTInt; ++iter)

		{

		Vfp::SetSReg(start, 1);

		Vfp::SetSReg(2.0f, 2);

		Vfp::DivS();

		Vfp::CpyS0(1);

		Vfp::MulS();

		Vfp::CpyS0(1);

		TReal32 end = Vfp::SReg(0);

		TInt end_rep = *(TInt*)&end;

		if (start_rep != end_rep)

			{

			RDebug::Printf("mismatch in iter %d, start %08x end %08x\n", iter, start_rep, end_rep);

			test(0);

			}

		}

	return KErrNone;

	}

void DoBounceContextSwitchTests()

	{

	RThread t1, t2;

	TInt r;

	r = t1.Create(KNullDesC, &TestBounceCtxThread1, 0x1000, 0x1000, 0x1000, NULL);

	test(r==KErrNone);

	t1.SetPriority(EPriorityLess);

	r = t2.Create(KNullDesC, &TestBounceCtxThread2, 0x1000, 0x1000, 0x1000, NULL);

	test(r==KErrNone);

	t2.SetPriority(EPriorityLess);

	TRequestStatus s1, s2;

	t1.Logon(s1);

	t2.Logon(s2);

	t1.Resume();

	t2.Resume();

	test.Printf(_L("Let threads run concurrently ...\n"));

	User::After(20*1000*1000);

	test.Printf(_L("Kill threads\n"));

	t1.Kill(0);

	t2.Kill(0);

	User::WaitForRequest(s1);

	User::WaitForRequest(s2);

	test(t1.ExitType()==EExitKill && t1.ExitReason()==KErrNone);

	test(t2.ExitType()==EExitKill && t2.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(t1);

	CLOSE_AND_WAIT(t2);

	}

void TestAbsS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::AbsS();

	r[0] = Vfp::SReg(0);

	r[1] = Abs(a[0]);

	}

void TestAddS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SetSReg(a[1], 2);

	Vfp::AddS();

	r[0] = Vfp::SReg(0);

	r[1] = a[0] + a[1];

	}

void TestDivS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SetSReg(a[1], 2);

	Vfp::DivS();

	r[0] = Vfp::SReg(0);

	TRealX x(a[0]);

	TRealX y(a[1]);

	x.DivEq(y);

	r[1] = (TReal32)x;

	}

void TestMacS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 0);

	Vfp::SetSReg(a[1], 1);

	Vfp::SetSReg(a[2], 2);

	Vfp::MacS();

	r[0] = Vfp::SReg(0);

	r[1] = a[0] + a[1] * a[2];

	}

void TestMscS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 0);

	Vfp::SetSReg(a[1], 1);

	Vfp::SetSReg(a[2], 2);

	Vfp::MscS();

	r[0] = Vfp::SReg(0);

	r[1] = a[1] * a[2] - a[0];

	}

void TestMulS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SetSReg(a[1], 2);

	Vfp::MulS();

	r[0] = Vfp::SReg(0);

	TRealX x(a[0]);

	TRealX y(a[1]);

	x.MultEq(y);

	r[1] = (TReal32)x;

	}

void TestNegS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::NegS();

	r[0] = Vfp::SReg(0);

	r[1] = -a[0];

	}

void TestNMacS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 0);

	Vfp::SetSReg(a[1], 1);

	Vfp::SetSReg(a[2], 2);

	Vfp::NMacS();

	r[0] = Vfp::SReg(0);

	r[1] = a[0] - a[1] * a[2];

	}

void TestNMscS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 0);

	Vfp::SetSReg(a[1], 1);

	Vfp::SetSReg(a[2], 2);

	Vfp::NMscS();

	r[0] = Vfp::SReg(0);

	r[1] = -a[1] * a[2] - a[0];

	}

void TestNMulS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SetSReg(a[1], 2);

	Vfp::NMulS();

	r[0] = Vfp::SReg(0);

	TRealX x(a[0]);

	TRealX y(a[1]);

	x.MultEq(y);

	r[1] = -(TReal32)x;

	}

void TestSqrtS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SqrtS();

	r[0] = Vfp::SReg(0);

	TReal x = a[0];

	TReal y;

	Math::Sqrt(y, x);

	r[1] = (TReal32)y;

	}

void TestSubS(const TReal32* a, TReal32* r)

	{

	Vfp::SetSReg(a[0], 1);

	Vfp::SetSReg(a[1], 2);

	Vfp::SubS();

	r[0] = Vfp::SReg(0);

	r[1] = a[0] - a[1];

	}

void TestAbsD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 1);

	Vfp::AbsD();

	r[0] = Vfp::DReg(0);

	r[1] = Abs(a[0]);

	}

void TestAddD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 1);

	Vfp::SetDReg(a[1], 2);

	Vfp::AddD();

	r[0] = Vfp::DReg(0);

	r[1] = a[0] + a[1];

	}

void TestDivD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 1);

	Vfp::SetDReg(a[1], 2);

	Vfp::DivD();

	r[0] = Vfp::DReg(0);

	TRealX x(a[0]);

	TRealX y(a[1]);

	x.DivEq(y);

	r[1] = (TReal64)x;

	}

void TestMacD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 0);

	Vfp::SetDReg(a[1], 1);

	Vfp::SetDReg(a[2], 2);

	Vfp::MacD();

	r[0] = Vfp::DReg(0);

	r[1] = a[0] + a[1] * a[2];

	}

void TestMscD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 0);

	Vfp::SetDReg(a[1], 1);

	Vfp::SetDReg(a[2], 2);

	Vfp::MscD();

	r[0] = Vfp::DReg(0);

	r[1] = a[1] * a[2] - a[0];

	}

void TestMulD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 1);

	Vfp::SetDReg(a[1], 2);

	Vfp::MulD();

	r[0] = Vfp::DReg(0);

	TRealX x(a[0]);

	TRealX y(a[1]);

	x.MultEq(y);

	r[1] = (TReal64)x;

	}

void TestNegD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 1);

	Vfp::NegD();

	r[0] = Vfp::DReg(0);

	r[1] = -a[0];

	}

void TestNMacD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 0);

	Vfp::SetDReg(a[1], 1);

	Vfp::SetDReg(a[2], 2);

	Vfp::NMacD();

	r[0] = Vfp::DReg(0);

	r[1] = a[0] - a[1] * a[2];

	}

void TestNMscD(const TReal64* a, TReal64* r)

	{

	Vfp::SetDReg(a[0], 0);

	Vfp::SetDReg(a[1], 1);

	Vfp::SetDReg(a[2], 2);

	Vfp::NMscD();

	r[0] = Vfp::DReg(0);

	r[1] = -a[1] * a[2] - a[0];

	}

void TestNMulD(const TReal64* a, TReal64* r)