diff -r 000000000000 -r 5de814552237 navienginebsp/ne1_tb/test/csi/t_csi.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/navienginebsp/ne1_tb/test/csi/t_csi.cpp	Tue Sep 28 18:00:05 2010 +0100
@@ -0,0 +1,440 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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: 
+*
+*/
+
+
+#include <e32test.h>
+#include <e32ver.h>
+#include <e32cmn.h>
+#include <e32def.h>
+#include <e32def_private.h>
+#include "d_csi.h"
+
+_LIT(testName,"t_csi");
+_LIT(KLddFileName, "d_csi.ldd"); // Kernel-side proxy LDD acting as a client of the IIC
+_LIT(KLddFileNameRoot, "d_csi");
+
+// global data..
+GLDEF_D RTest csiTest(testName);
+GLDEF_D RBusCsiTestClient gCsiLdd; // Channel to kernel-side proxy
+GLDEF_D TConfigSpiBufV01 SpiHeader;
+GLDEF_D TUint32 SpiConfig;
+
+LOCAL_C void SetDefaultHeader()
+	{
+	const TConfigSpiV01 DefaultHeader =
+		{
+		ESpiWordWidth_8, //iWordWidth
+		260000, //iClkSpeed
+		ESpiPolarityLowRisingEdge, //iClkMode
+		500, // iTimeoutPeriod
+		EBigEndian, // iEndianness
+		EMsbFirst, //iBitOrder
+		0, //iTransactionWaitCycles
+		ESpiCSPinActiveLow //iCsPinActiveMode
+		};
+
+	SpiHeader = DefaultHeader;
+	}
+
+LOCAL_C void SetDefaultConfig()
+	{
+	//Set the default settings
+	SpiConfig = 0;
+	SET_CHAN_NUM(SpiConfig,KSpiChannel0); //0 or
+	SET_BUS_TYPE(SpiConfig,ESpi);
+	SET_SLAVE_ADDR(SpiConfig,1); // Any Number between 1 to 32  */
+	SetDefaultHeader();
+	}
+
+// ==================
+// MASTER tests
+// clock values supported by the navi-engine CSI interface
+const TUint32 TSpiClkSpeedValues[] =
+	{130000, 260000, 521000, 1040000, 2080000, 4170000, 16670000};
+
+LOCAL_C void TestClockSpeed()
+	{
+	TInt r = KErrNone;
+
+	// try to set each of the supported clk speeds. (queuing a transaction using
+	// header with one of them set)..
+	for(TUint i = 0; i < sizeof(TSpiClkSpeedValues) / sizeof(TUint32); ++i)
+		{
+		SpiHeader().iClkSpeedHz = TSpiClkSpeedValues[i];
+		r = gCsiLdd.TestConfigParams(&SpiHeader, SpiConfig);
+		csiTest(r == KErrNone);
+		}
+
+	// now try some of known - as not supported:
+	SpiHeader().iClkSpeedHz = 300000;
+	r = gCsiLdd.TestConfigParams(&SpiHeader, SpiConfig);
+	if(r != KErrNotSupported)
+		{
+		csiTest.Printf(_L("Error setting clk %d, r = %d \n"), SpiHeader().iClkSpeedHz, r);
+		csiTest(EFalse);
+		}
+	// Set it to the default header after testing
+	SetDefaultHeader();
+	}
+
+
+LOCAL_C void TestWordWidth()
+	{
+	TInt r = KErrNone;
+	for (TInt i = 0; i <= ESpiWordWidth_16; i++)
+		{
+		SpiHeader().iWordWidth = static_cast<TSpiWordWidth> (i);
+		r = gCsiLdd.TestConfigParams(&SpiHeader, SpiConfig);
+		switch (i)
+			{
+			case ESpiWordWidth_8:
+			case ESpiWordWidth_16:
+
+				csiTest(r == KErrNone);
+				break;
+			default:
+				csiTest(r == KErrNotSupported);
+				break;
+			}//Switch
+		} //For loop
+	//Set it to the default header after testing
+	SetDefaultHeader();
+	}
+
+LOCAL_C void TestAsynchTransactions()
+	{
+	// Queue 3 asynchronous Transaction and expect them to nogified in FIFO order.
+	const TInt KNumberOfTransactions = 3;
+	TRequestStatus status[KNumberOfTransactions];
+
+	TInt r = KErrNone;
+
+	for(TInt i = 0; i < KNumberOfTransactions; ++i)
+		{
+		status[i] = KErrNotReady;
+		gCsiLdd.TestAsynTransaction(status[i], &SpiHeader, SpiConfig);
+		}
+
+	// And Expect them to be notified in the same order.
+	for(TInt i = 0; i < KNumberOfTransactions; ++i)
+		{
+		User::WaitForAnyRequest();
+
+		// next should be finished..
+		if(status[i] != KErrNone)
+			{
+			r = KErrGeneral;
+			continue;
+			}
+
+		if(i == 0) // only first should be ready..
+			{
+			if((status[1] == KErrNone) ||
+			   (status[2] == KErrNone))
+				{
+				r = KErrGeneral;
+				continue;
+				}
+			}
+
+		if(i == 1) // only first two should be ready..
+			{
+			if(status[2] == KErrNone)
+				{
+				r = KErrGeneral;
+				}
+			}
+		}
+
+	csiTest(r == KErrNone);
+	}
+
+LOCAL_C void TestMaster()
+	{
+	TInt r = KErrNone;
+
+	// Instigate AudioCodecBeep
+	csiTest.Printf(_L("Testing Audio Codec Beep\n"));
+	r = gCsiLdd.TestAudioCodecBeep();	
+	if(r == KErrNotSupported)
+	    {
+	    csiTest.Printf(_L("Master mode is not supported by the client, skipping master test.. \n"));
+	    return;
+	    }
+	csiTest(r == KErrNone);
+
+	// Instigate TransferTimeout
+	csiTest.Printf(_L("Testing Transfer Timeout\n"));
+	r = gCsiLdd.TestTransferTimeout();
+	csiTest(r == KErrNone);
+
+	// Test TestBulkTransfer
+	csiTest.Printf(_L("Testing TestBulkTransfer\n"));
+	r = gCsiLdd.TestBulkTransfer();
+	csiTest(r == KErrNone);
+
+	// Test Half Duplex
+	csiTest.Printf(_L("Testing Half Duplex operations \n"));
+	r = gCsiLdd.TestHalfDuplex();
+	csiTest(r == KErrNone);
+
+	// TestDuplexTransaction
+	csiTest.Printf(_L("Testing DuplexTransaction\n"));
+	r = gCsiLdd.TestDuplexTransaction();
+	csiTest(r == KErrNone);
+
+	// Test all available  ClockSpeeds
+	csiTest.Printf(_L("Testing Different  ClockSpeeds\n"));
+	TestClockSpeed();
+
+	// Test WordWidth
+	csiTest.Printf(_L("Testing WordWidths\n"));
+	TestWordWidth();
+
+	csiTest.Printf(_L("Testing  Asynchronous Transactions\n"));
+	TestAsynchTransactions();
+	}
+
+// ==================
+// SLAVE tests
+LOCAL_C TInt SlaveCaptureChannel(TInt aBufferSize)
+	{
+	csiTest.Printf(_L("SlaveCaptureChannel(), buff %d\n"), aBufferSize);
+	// Open Slave channel (use buffers declared in the d_csi)
+	TInt r = gCsiLdd.CaptureSlaveChannel(aBufferSize);
+	if(r != KErrNone)
+		{
+		csiTest.Printf(_L("couln't Capture Slave Channel, r= %d\n"), r);
+		}
+	return r;
+	}
+
+LOCAL_C TInt SlaveAsyncCaptureChannel(TInt aBufferSize)
+	{
+	// Open Slave channel (use buffers declared in the d_csi)
+	TRequestStatus status;
+	TInt r = KErrNone;
+
+	gCsiLdd.CaptureSlaveChannel(aBufferSize, status);
+
+	User::WaitForRequest(status);
+	r = status.Int();
+	if (r != KErrCompletion)
+		{
+		csiTest.Printf(_L("SlaveAsyncCaptureChannel request returned, r= %d\n"), r);
+		}
+	return r;
+	}
+
+LOCAL_C TInt SlaveReleaseChannel()
+	{
+	TInt r = gCsiLdd.ReleaseSlaveChannel();
+	if (r != KErrNone)
+		{
+		csiTest.Printf(_L("couln't Release Slave Channel, r= %d\n"), r);
+		}
+	return r;
+	}
+
+#ifdef EXTERNAL_HW_LOOPBACK_USED
+LOCAL_C void StartSlaveRequest(TRequestStatus &aStatus)
+	{
+	csiTest.Printf(_L("StartSlaveRequest\n"));
+
+	enum TTriggers
+		{
+		ERxAllBytes = 0x01,
+		ERxUnderrun = 0x02,
+		ERxOverrun = 0x04,
+		ETxAllBytes = 0x08,
+		ETxUnderrun = 0x10,
+		ETxOverrun = 0x20,
+		EGeneralBusError = 0x40
+		};
+
+	// register for all possible notifications..
+	TInt trigger = ERxAllBytes | ERxOverrun | ERxUnderrun | ETxAllBytes | ETxOverrun | ETxUnderrun;
+
+	// Set notification trigger - this starts asynchronous Slave operation..
+	csiTest.Printf(_L("Set Notification trigger\n"));
+	gCsiLdd.SetSlaveNotificationTrigger(aStatus, trigger);
+	}
+
+LOCAL_C TInt WaitForSlaveReqest(TRequestStatus &aStatus)
+	{
+	csiTest.Printf(_L("Waiting for the slave to complete..\n"));
+	User::WaitForRequest(aStatus);
+	TInt r = aStatus.Int();
+	if(r != KErrNone)
+		{
+		csiTest.Printf(_L("request returned, r= %d\n"), r);
+		}
+	return r;
+	}
+
+// Requirements: local-HW loopback between CSI channel 0 (master) and 1 (Slave)
+// in this test scenario we will:
+// 1. Initiate Asynchronous, full duplex Slave operation with buffers set 64 Bytes
+// 2. Queue one full duplex Master transfer with 64 bytes
+// 3. Wait and check the SlaveRequest competition
+LOCAL_C TInt TestSlaveNormalTransfer()
+	{
+	csiTest.Printf(_L("TestSlaveNormalTransfer()\n"));
+	// capture the channel
+	TInt r = SlaveCaptureChannel(64);
+	csiTest(r == KErrNone);
+
+	// instigate the request..
+	TRequestStatus status;
+	StartSlaveRequest(status);
+
+	// queue One FullDuplex transaction..
+	// (it can be either synchronous or asynchronous)
+	// specify both MASTER_MODE and SLAVE_MODE to run the test
+	csiTest.Printf(_L("QueueOneDuplexTransaction\n"));
+	r = gCsiLdd.QueueOneDuplexTransaction(64);
+
+	if (r == KErrNone)
+		{
+		csiTest.Printf(_L("WaitForSlaveRequest\n"));
+		r = WaitForSlaveReqest(status);
+		}
+	else if (r == KErrNotSupported)
+		{
+		return r;
+		}
+	else
+		{
+		csiTest.Printf(_L("Error queuing duplex trans?\n"));
+		}
+
+	// release the channel..
+	SlaveReleaseChannel();
+
+	return r;
+	}
+#endif
+
+LOCAL_C void TestSlave()
+	{
+	csiTest.Printf(_L("TestSlave operations\n"));
+	TInt r = KErrNone;
+
+	csiTest.Printf(_L("Capture channel\n"));
+	r = SlaveCaptureChannel(64);
+	if(r == KErrNotSupported)
+	    {
+	    csiTest.Printf(_L("Slave mode is not supported by the client, skipping slave tests.. \n"));
+	    return;
+	    }
+	csiTest(r == KErrNone);
+
+	csiTest.Printf(_L("Capture already captured channel\n"));
+	r = SlaveCaptureChannel(64);
+	csiTest(r == KErrInUse);
+
+	csiTest.Printf(_L("Release channel\n"));
+	r = SlaveReleaseChannel();
+
+	csiTest.Printf(_L("Asynchronously capture channel\n"));
+	r = SlaveAsyncCaptureChannel(64);
+	csiTest(r == KErrCompletion);
+
+	csiTest.Printf(_L("Release channel\n"));
+	r = SlaveReleaseChannel();
+
+#ifdef EXTERNAL_HW_LOOPBACK_USED
+	// this test needs additional HW loopback (channel 0 and 1) attached to the board
+	r = TestSlaveNormalTransfer();
+	if(r == KErrNotSupported)
+		{
+		csiTest.Printf(_L("TestSlaveNormalTransfer() is not supported for slave only mode \n"));
+		return;
+		}
+	csiTest(r == KErrNone);
+#endif
+	}
+
+
+LOCAL_C void LoadTestDriver()
+	{
+	//	csiTest.Printf(_L("Loading the proxy-device driver\n"));
+	TInt r = User::LoadLogicalDevice(KLddFileName);
+	if(r != KErrNone && r != KErrAlreadyExists)
+		{
+		csiTest.Printf(_L("Failed to load the proxy-device  driver, r= %d\n"), r);
+		csiTest.End();
+		}
+	}
+
+LOCAL_C void OpenTestDriver()
+	{
+	// Open a Master SPI channel to the kernel side proxy
+	TBufC<6> proxyName(KLddFileNameRoot);
+	//	csiTest.Printf(_L("opening the proxy-device driver\n"));
+	TInt r = gCsiLdd.Open(proxyName);
+	if(r != KErrNone)
+		{
+		csiTest.Printf(_L("Failed to open the proxy-device the driver, r= %d\n"), r);
+		csiTest(r == KErrNone);
+		}
+	//Have  the default config
+	SetDefaultConfig();
+	}
+
+LOCAL_C void UnloadTestDriver()
+    {
+    TInt r = User::FreeLogicalDevice(KLddFileName);
+    if(r != KErrNone)
+        {
+        csiTest.Printf(_L("Failed to unload the proxy-device  driver, r= %d\n"), r);
+        }
+    }
+
+/*************************************************
+ *********Main************************************
+ ************************************************/
+EXPORT_C TInt E32Main()
+	{   
+	csiTest.Title();
+	csiTest.Start(_L("Test CSI Master \n"));
+
+	//Load the Test Driver
+	LoadTestDriver();
+	__KHEAP_MARK;
+	
+	OpenTestDriver();
+
+	// Run tests for the Slave
+	TestMaster();
+
+	// Run tests for the Slave
+	TestSlave();
+	
+	//Close the driver
+	csiTest.Printf(_L("Tests completed OK, about to close channel\n"));
+
+	gCsiLdd.Close();
+
+	__KHEAP_MARKEND;
+
+	UnloadTestDriver();
+	csiTest.End();	
+
+	return KErrNone;
+	}
+