/*

* Copyright (c) 2008 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:  This is the header file for the PCI driver test. 

*

*/

#ifndef __TPCI_TEST_H

#define __TPCI_TEST_H

#ifndef __KERNEL_MODE__

#define __E32TEST_EXTENSION__

#include <e32def_private.h>

// Following contents are carbon copy of \os\kernelhwsrv\kerneltest\e32test\misc\test_thread.h

#include <e32test.h>

#include <e32svr.h>

#include <e32des8.h>

#include <e32des8_private.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <e32std.h>

#include <e32std_private.h>

_LIT(KPciPanicCat, "test_thread.h");

static const TInt KPciHeapSize=0x2000;

enum TPciPanicCode

	{

	EThreadCreateFailed

	};

/**

A utility class for running functions in other threads/processes

*/

class TTestRemote

	{

public:

	virtual TInt WaitForExitL() = 0;

	virtual ~TTestRemote()

		{}

	virtual void Rendezvous(TRequestStatus& aStatus) = 0;

protected:

	TTestRemote()

		{}

	static TInt RunFunctor(TAny* aFunctor)

		{

		TFunctor& functor = *(TFunctor*)aFunctor;

		functor();

		return KErrNone;

		}

	TRequestStatus iLogonStatus;

	static TInt iCount;

	};

TInt TTestRemote::iCount=0;

class TTestThread : public TTestRemote

	{

public:

	TTestThread(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume=ETrue)

		{

		Init(aName, aFn, aData, aAutoResume);

		}

	/**

	Run aFunctor in another thread

	*/

	TTestThread(const TDesC& aName, TFunctor& aFunctor, TBool aAutoResume=ETrue)

		{

		Init(aName, RunFunctor, &aFunctor, aAutoResume);

		}

	~TTestThread()

		{

		//RTest::CloseHandleAndWaitForDestruction(iThread);

		iThread.Close();

		}

	void Resume()

		{

		iThread.Resume();

		}

	/**

	If thread exited normally, return its return code

	Otherwise, leave with exit reason

	*/

	virtual TInt WaitForExitL()

		{

		User::WaitForRequest(iLogonStatus);

		const TInt exitType = iThread.ExitType();

		const TInt exitReason = iThread.ExitReason();

		__ASSERT_ALWAYS(exitType != EExitPending, User::Panic(_L("TTestThread"),0));

		if(exitType != EExitKill)

			User::Leave(exitReason);

		return exitReason;

		}

	virtual void Rendezvous(TRequestStatus& aStatus)

		{

		iThread.Rendezvous(aStatus);

		}

private:

	void Init(const TDesC& aName, TThreadFunction aFn, TAny* aData, TBool aAutoResume)

		{

		TKName name(aName);

		name.AppendFormat(_L("-%d"), iCount++);	

		TInt r=iThread.Create(name, aFn, KDefaultStackSize, KPciHeapSize, KPciHeapSize, aData);

		if(r!=KErrNone)

			{

			RDebug::Printf("RThread::Create failed, code=%d", r);

			User::Panic(KPciPanicCat, EThreadCreateFailed);

			}

		iThread.Logon(iLogonStatus);

		__ASSERT_ALWAYS(iLogonStatus == KRequestPending, User::Panic(_L("TTestThread"),0));

		if(aAutoResume)

			iThread.Resume();

		}

	RThread iThread;

	};

class CTest : public CBase, public TFunctor

	{

public:

	~CTest()

		{

		iName.Close();

		}

	virtual void operator()()

		{

		RTest test(iName);

		test.Start(iName);

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

			{

			test.Next(iName);

			RunTest();

			}

		test.End();

		}

	virtual void RunTest() = 0; 

	virtual CTest* Clone() const = 0;

	const TDesC& Name() const

		{

		return iName;

		}

protected:

	CTest(const TDesC& aName, TInt aIterations)

		:iIterations(aIterations)

		{

		iName.CreateL(aName);

		}

	CTest(const CTest& aOther)

		:iIterations(aOther.iIterations)

		{

		iName.CreateL(aOther.iName);

		}

	//It would be useful to have an RTest member, but this can't be

	//initialised untill the new thread is running as it will refer to

	//the creating thread

	RBuf iName;

	const TInt iIterations; 

	};

/**

Make aNumberOfThreads copies of aTest and run

each in its own thread

@param test Reference to test object

@param aTest Referance

*/

void MultipleTestRun(RTest& test, const CTest& aTest, TInt aNumberOfThreads)

	{

	RPointerArray<CTest> testArray;

	RPointerArray<TTestThread> threadArray;

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

		{		

		test.Printf(_L("Create test thread"));

		CTest* newTest = aTest.Clone();

		test_NotNull(newTest);

		TTestThread* thread = new TTestThread(aTest.Name(), *newTest);

		test_NotNull(thread);

		threadArray.AppendL(thread);

		testArray.AppendL(newTest);

		}

	const TInt count = threadArray.Count();

	for(TInt j=0; j<count; j++)

		{

		TTestThread* thread = threadArray[j];

		TInt r = KErrNone;

		TRAPD(leaveCode, r = thread->WaitForExitL());

		if(leaveCode != KErrNone)

			{

			test.Printf(_L("Thread %d: Panic code:%d\n"), j, leaveCode);

			test_KErrNone(leaveCode);

			}

		if(r!=KErrNone)

			{

			test.Printf(_L("Thread Number %d\n"), j);

			test_KErrNone(r);

			}

		}

	threadArray.ResetAndDestroy();

	threadArray.Close();

	testArray.ResetAndDestroy();

	testArray.Close();

	}

// end of \os\kernelhwsrv\kerneltest\e32test\misc\test_thread.h

#endif // __KERNEL_MODE__

_LIT(KPciLdd, "d_pci.ldd");

_LIT(KPciLddFactory, "PCI_test_factory");

_LIT(KPciTest, "PCI Test LDD");

/**

Test driver op-codes

*/

enum TPciTestCmd

	{

	EGetTestInfo,

	EAccessConfigSpace,

	EAccessMemorySpace,

	EOpenPciDChunk,

	EOpenPciPlatHwChunk,

	EOpenPciMappedChunk,

	EOpenPciWindowChunk,

	ERunUnitTests

	};

/**

Identifies a PCI Function (device) on the system

*/

struct TPciDevice

	{

	TPciDevice()

		:iVendorId(0xFFFFFFFF), iDeviceId(0xFFFFFFFF), iInstance(0) {}

	TPciDevice(TUint aVendorId, TUint aDeviceId, TInt aInstance=0)

		:iVendorId(aVendorId), iDeviceId(aDeviceId), iInstance(aInstance) {}

	TUint iVendorId;

	TUint iDeviceId;

	TInt iInstance; //< Unit to open (there could be multiple devices on system)

	};

/**

Used to send chunk size and recieve

PCI address

*/

struct TPciChunkCreateInfo

	{

	TPciChunkCreateInfo()

		:iSize(0), iPciAddress(NULL)

		{

		}

	TPciChunkCreateInfo(TInt aSize, TUint& aPciAddress, TRequestStatus* aStatus=NULL)

		:iSize(aSize), iPciAddress(&aPciAddress), iStatus(aStatus)

		{

		}

	TInt iSize;

	TUint* iPciAddress;

	TRequestStatus* iStatus;

	};	

/**

Information about the PSL required by the

user side test

*/

struct TPciTestInfo

	{

	TPciDevice iDevice; //< Probe for this

	/**

	Supplies the necessary information to test Read, Write, and

	Modify for a word of PCI memory or configuration space

	*/

	struct TAddrSpaceTest

		{

		TAddrSpaceTest()

			:iOffset(0), iExpectedValue(0), iReadOnlyMask(0)

			{}

		TAddrSpaceTest(TUint aOffset, TUint aExpectedValue, TUint aReadOnlyMask)

			:iOffset(aOffset), iExpectedValue(aExpectedValue), iReadOnlyMask(aReadOnlyMask)

			{}

		/**

		Returns a specified sub byte, or word from the whole dword

		*/

		inline TUint Expected(TInt aBitWidth, TInt aExtraOffset) const

			{

			//the right shift required to get field to bit 0

			const TInt shift = 8 *((aExtraOffset + iOffset) % 4);

			const TUint mask = 0xFFFFFFFF >> (32-aBitWidth);

			return (iExpectedValue >> shift) & mask;

			}

		const TUint iOffset;

		const TUint iExpectedValue; //< The initial value of word

		const TUint iReadOnlyMask; //< Mask of unwritable bits

		//Future work, memory spaces should state a bar index

		};

	TAddrSpaceTest iCfgSpaceRead;

	TAddrSpaceTest iCfgSpaceWrite;

	TUint iMemSpaceIndex; //< Memory space to select

	TAddrSpaceTest iMemSpaceRead;

	TAddrSpaceTest iMemSpaceWrite;

	TInt iNumberOfBars; //< Number of simultaneous mappings into PCI space

	};

class RPci;

class TAddrSpace;

/**

This class encapsulates all the various read/write/and modify commands

that can be carried out on a PCI memory space. The command is stored user

side, and then executed on kernel side when KRun() is called.

*/

class TUserPciSpace

	{

public:

	TUserPciSpace()

		:iPci(NULL), iOperation(EInvalid), iBitWidth(0), iOffset(0),

		iWriteValue(0), iClearMask(0), iSetMask(0)

	{}

	TUserPciSpace(RPci& aPci);

	/**

	Perform the encapsulated read/write/or modify

	@note Only run on kernel side

	*/

	TUint KRun(TAddrSpace& aAddrSpace);

	/**

	Clone method is required so that multiple threads may

	have their own copy of a TUserPciSpace (without knowing

	its runtime type)

	*/

	virtual TUserPciSpace* Clone() const = 0;

	TUint Read(TInt aBitWidth, TUint aOffset)

		{

		iOffset = aOffset;

		iOperation = ERead;

		iBitWidth = aBitWidth;

		return Call();

		}

	void Write(TInt aBitWidth, TUint aOffset, TUint aValue)

		{

		iOffset = aOffset;

		iOperation = EWrite;

		iBitWidth = aBitWidth;

		iWriteValue = aValue;

		Call();

		}

	void Modify(TInt aBitWidth, TUint aOffset, TUint aClearMask, TUint aSetMask)

		{

		iOffset = aOffset;

		iOperation = EModify;

		iBitWidth = aBitWidth;

		iClearMask = aClearMask;

		iSetMask = aSetMask;

		Call();

		}

protected:

	/**

	Makes a request to iPci and passes a copy of this object to

	the kernel side.

	*/

	virtual TUint Call() =0;

	enum TOperation {EInvalid, ERead, EWrite, EModify};

	/**

	Pointer to a PCI device handle

	*/

	RPci* iPci;

	TOperation iOperation; //!< Type of access to perform

	TInt iBitWidth;

	TUint iOffset;

	TUint32 iWriteValue;

	TUint32 iClearMask;

	TUint32 iSetMask;

	};

/**

Grants access to a PCI device's (identified

by aPci) config space from user side

*/

class TUserConfigSpace : public TUserPciSpace

	{

public:

	TUserConfigSpace()

		:TUserPciSpace()

		{}

	TUserConfigSpace(RPci& aPci);

	virtual TUserPciSpace* Clone() const;

private:

	TUint Call();

	};

/**

Grants access to some region of a PCI

device's memory space. A PCI device(or function)

may have up to 8 distinct memory spaces

*/

class TUserMemorySpace : public TUserPciSpace

	{

public:

	TUserMemorySpace()

		:TUserPciSpace(), iBarIndex(-1)

		{}

	TUserMemorySpace(RPci& aPci, TInt aBarIndex);	

	virtual TUserPciSpace* Clone() const;

	inline TInt BarIndex() {return iBarIndex;}

private:

	TUint Call();

	TInt iBarIndex; //< Each PCI function may have up to 8 memory spaces

	};

#endif //__TPCI_TEST_H