// 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/iic/iic_slaveclient.cpp

// Simulated client of IIC Platform Independent Layer (PIL) Slave functionality

//

#include <kernel/kern_priv.h>		// for DThread, TDfc

#ifdef STANDALONE_CHANNEL

#include <drivers/iic_transaction.h>

#else

#include <drivers/iic.h>

#endif

#include "../t_iic.h"

#ifdef STANDALONE_CHANNEL

#include <drivers/iic_channel.h>

#include "i2c.h"

#endif

#ifdef LOG_SLAVECLIENT

#define CLIENT_PRINT(str) Kern::Printf str

#else

#define CLIENT_PRINT(str)

#endif

//For channel creation

#ifdef STANDALONE_CHANNEL

#define NUM_CHANNELS 3 // Arbitrary

#if defined(MASTER_MODE) && !defined(SLAVE_MODE)

const TInt KChannelTypeArray[NUM_CHANNELS] = {DIicBusChannel::EMaster, DIicBusChannel::EMaster, DIicBusChannel::EMaster};

#elif defined(MASTER_MODE) && defined(SLAVE_MODE)

const TInt KChannelTypeArray[NUM_CHANNELS] = {DIicBusChannel::EMaster, DIicBusChannel::ESlave, DIicBusChannel::EMasterSlave};

#else

const TInt KChannelTypeArray[NUM_CHANNELS] = {DIicBusChannel::ESlave, DIicBusChannel::ESlave, DIicBusChannel::ESlave};

#endif

#define CHANNEL_TYPE(n) (KChannelTypeArray[n])

#define CHANNEL_DUPLEX(n) (DIicBusChannel::EHalfDuplex)

#define BUS_TYPE (DIicBusChannel::EI2c)

#if defined(MASTER_MODE)

const TInt8 KI2cChannelNumBase = 10;	// Arbitrary, real platform may consult the Configuration Repository

										// Note limit of 5 bit representation (0-31)

#else

const TInt8 KI2cChannelNumBase = 10 + NUM_CHANNELS;	// For Slave mode, want to provide different response

													// If client assumes Master mode, should be informed not available

#endif/*MASTER_MODE*/

LOCAL_C TInt8 AssignChanNumI2c()

	{

	static TInt8 iBaseChanNumI2c = KI2cChannelNumBase;

	CLIENT_PRINT(("I2C AssignChanNum - on entry, iBaseChanNum = 0x%x\n",iBaseChanNumI2c));

	return iBaseChanNumI2c++; // Arbitrary, for illustration

	}

class DIicSlaveClientChan : public DBase

	{

public:

	DIicSlaveClientChan(DIicBusChannel* aChan, TInt8 aChanNum, TInt aChanType):iChan(aChan),iChanNumber(aChanNum),iChanType(aChanType){};

	~DIicSlaveClientChan();

	TInt GetChanNum()const {return iChanNumber;};

	TInt GetChanType()const {return iChanType;};

	DIicBusChannel* GetChannelPtr(){return iChan;};

private:

	TInt8 iChanNumber;

	TInt iChanType;

	DIicBusChannel* iChan;

	};

DIicSlaveClientChan::~DIicSlaveClientChan()

	{

	if(iChan)

		delete iChan;

	}

#endif/*STANDALONE_CHANNEL*/

const TInt KIicSlaveClientThreadPriority = 24;

const TInt KIicSlaveClientDfcPriority = 3; // 0 to 7, 7 is highest

const TInt KMaxNumChannels = 2;	// 1 "true" slave, one "dummy"

#ifdef STANDALONE_CHANNEL

_LIT(KLddRootName,"iic_slaveclient_ctrless");

#else

_LIT(KLddRootName,"iic_slaveclient");

#endif

_LIT(KIicSlaveClientThreadName,"IicSlaveClientLddThread");

struct TCapsIicSlaveClient

    {

    TVersion version;

    };

class DDeviceIicSlaveClient : public DLogicalDevice

    {

    public:

    /**

     * The constructor

     */

    DDeviceIicSlaveClient();

    /**

     * The destructor

     */

    ~DDeviceIicSlaveClient();

    /**

     * Second stage constructor - install the device

     */

    virtual TInt Install();

    /**

     * Get the Capabilites of the device

     * @param aDes descriptor that will contain the returned capibilites

     */

    virtual void GetCaps(TDes8 &aDes) const;

    /**

     * Create a logical channel to the device

     */

    virtual TInt Create(DLogicalChannelBase*& aChannel);

    };

class DChannelIicSlaveClient : public DLogicalChannel

    {

    public:

    DChannelIicSlaveClient();

    ~DChannelIicSlaveClient();

    virtual TInt DoCreate(TInt aUnit, const TDesC8* aInfo, const TVersion& aVer);

	void RequestComplete(TInt r);

	TInt CheckDataWritten();

	TInt CheckDataRead();

	static void SlaveClientCallbackFunc(TInt aChannelId, TInt aReturn, TInt aTrigger, TInt16 aRxWords, TInt16 aTxWords, TAny*	aParam);

#ifdef STANDALONE_CHANNEL

	static TInt OrderEntries(const DIicSlaveClientChan& aMatch, const DIicSlaveClientChan& aEntry);

#endif

    protected:

    virtual void HandleMsg(TMessageBase* aMsg);	// Note: this is a pure virtual in DLogicalChannel

	TInt DoControl(TInt aId, TAny* a1, TAny* a2); // Name for convenience!

    TInt DoRequest(TInt aId, TRequestStatus* aStatus, TAny* a1, TAny* a2); // Name for convenience!

	private:

	TInt InitSlaveClient();

	TInt CbProcessOverUnderRunRxTx();

	TInt RegisterRxBuffer(TInt aChannelId, TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);

	TInt SetNotificationTrigger(TInt aChannelId, TInt aTrigger);

	TInt StaticExtension(TUint aId, TUint aFunction, TAny* aParam1, TAny* aParam2);

	TInt RegisterTxBuffer(TInt aChannelId, TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);

	TInt CaptureChannel(TInt aBusId, TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch=NULL);

	TInt ReleaseChannel(TInt aChannelId);

	private:

	TDynamicDfcQue* iDfcQue;

	TIicBusSlaveCallback* iNotif;

	HBuf8* iConfigHdr;

	TRequestStatus* iStatus;

	TUint8* iRxBuf;

	TUint8* iTxBuf;

	TUint8* iBusTxCheckBuf;

	TInt8 iNumRegRxWords;

	TInt8 iNumRegTxWords;

	TInt8 iTxRegGranularity;

	TInt8 iTxRegOffset;

	TInt8 iTxReqNumWords;

	TInt8 iRxRegGranularity;

	TInt8 iRxRegOffset;

	TInt8 iRxReqNumWords;

	TUint iBusId;

#ifdef STANDALONE_CHANNEL

	// For some slave-channel-only functions,e.g. ReleaseChannel, RegisterRxBuffer, etc.

	// the client needs to remember the slave channel that has been captured

	struct TCapturedChannel

		{

		DIicSlaveClientChan* iChannel;

		TInt iChannelId;

		};

	TCapturedChannel iCapturedChan;

#endif

	public:

	DThread* iClient;

	TInt iChannelId;	// public to be accessible by callback

	TInt* iClientChanId;

	TInt iExpectedTrigger;

	TInt iFullDuplexReq;

	TInt iBlockedTrigger;

	typedef enum TTestOverUnderState

		{

		EStartState  = 0x1,

		ERxOverrun_1,

		ERxOverrun_2,

		ETxUnderrun_1,

		ETxUnderrun_2

		};

	TTestOverUnderState iTestOverUnderState;

	};

DDeviceIicSlaveClient::DDeviceIicSlaveClient()

// Constructor

    {

	CLIENT_PRINT(("> DDeviceIicSlaveClient::DDeviceIicSlaveClient()"));

    iParseMask=0;		// No info, no PDD, no Units

    iUnitsMask=0;

    iVersion=TVersion(KIicClientMajorVersionNumber,

		      KIicClientMinorVersionNumber,

		      KIicClientBuildVersionNumber);

    }

#ifdef STANDALONE_CHANNEL

//Store all the channels created by the client into an array

RPointerArray<DIicSlaveClientChan> ChannelArray;

#endif

DDeviceIicSlaveClient::~DDeviceIicSlaveClient()

// Destructor

    {

	CLIENT_PRINT(("> DDeviceIicSlaveClient::~DDeviceIicSlaveClient()"));

#ifdef STANDALONE_CHANNEL

	//The client is reponsible for channel destroy in STANDALONE_CHANNEL mode

    ChannelArray.ResetAndDestroy();

#endif

	}

TInt DDeviceIicSlaveClient::Install()

// Install the device driver.

    {

	CLIENT_PRINT(("> DDeviceIicSlaveClient::Install()"));

    return(SetName(&KLddRootName));

    }

void DDeviceIicSlaveClient::GetCaps(TDes8& aDes) const

// Return the IicClient capabilities.

    {

	CLIENT_PRINT(("> DDeviceIicSlaveClient::GetCaps(TDes8& aDes) const"));

    TPckgBuf<TCapsIicSlaveClient> b;

    b().version=TVersion(KIicClientMajorVersionNumber,

			 KIicClientMinorVersionNumber,

			 KIicClientBuildVersionNumber);

    Kern::InfoCopy(aDes,b);

    }

TInt DDeviceIicSlaveClient::Create(DLogicalChannelBase*& aChannel)

// Create a channel on the device.

    {

	CLIENT_PRINT(("> DDeviceIicSlaveClient::Create(DLogicalChannelBase*& aChannel)"));

	if(iOpenChannels>=KMaxNumChannels)

		return KErrOverflow;

    aChannel=new DChannelIicSlaveClient;

    return aChannel?KErrNone:KErrNoMemory;

    }

#ifdef STANDALONE_CHANNEL

//  auxiliary function for ordering entries in the array of channels

TInt DChannelIicSlaveClient::OrderEntries(const DIicSlaveClientChan& aMatch, const DIicSlaveClientChan& aEntry)

	{

	TUint8 l=(TUint8)aMatch.GetChanNum();

	TUint8 r=(TUint8)aEntry.GetChanNum();

	if(l>r)

		return -1;

	else if(l<r)

		return 1;

	else

		return 0;

	}

// global ordering object to be passed to RPointerArray InsertInOrderXXX and FindInOrder

TLinearOrder<DIicSlaveClientChan> EntryOrder(DChannelIicSlaveClient::OrderEntries);

TInt GetChanPtr(const TInt aBusId, DIicSlaveClientChan*& aChan)

	{

    __KTRACE_OPT(KIIC, 	Kern::Printf("GetChanPtr, aBusId=0x%x\n",aBusId));

	TInt32 chanId;

	chanId = GET_CHAN_NUM(aBusId);

    __KTRACE_OPT(KIIC, 	Kern::Printf("GetChanPtr, chanId=0x%x\n",chanId));

	DIicSlaveClientChan chanEntry(NULL,(TInt8)chanId, DIicBusChannel::EMasterSlave);

	TInt r = KErrNotFound;

	TInt aIndex = ChannelArray.FindInOrder(&chanEntry, EntryOrder);

	if(aIndex >= 0)

		{

		aChan = ChannelArray[aIndex];

		r = KErrNone;

		}

	return r;

	}

#endif/*STANDALONE_CHANNEL*/

DECLARE_STANDARD_LDD()

	{

#ifdef STANDALONE_CHANNEL

	TInt r = KErrNone;

	DIicBusChannel *chan = NULL, *chanM = NULL, *chanS = NULL;

	DIicSlaveClientChan* aSlaveClientChan;

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

			{

			CLIENT_PRINT(("\n"));

	#if defined(MASTER_MODE)

			if(CHANNEL_TYPE(i) == (DIicBusChannel::EMaster))

				{

				chan=new DSimulatedIicBusChannelMasterI2c(BUS_TYPE,CHANNEL_DUPLEX(i));

				if(!chan)

					{

					CLIENT_PRINT(("\n\nI2C: Channel of type (%d) not created for index %d\n\n",CHANNEL_TYPE(i),i));

					return NULL;

					}

				CLIENT_PRINT(("I2C chan created at 0x%x\n",chan));

				if(((DSimulatedIicBusChannelMasterI2c*)chan)->Create()!=KErrNone)

					{

					delete chan;

					return NULL;

					}

				aSlaveClientChan = new DIicSlaveClientChan(chan,AssignChanNumI2c(),DIicBusChannel::EMaster);

				if(!aSlaveClientChan)

					{

					delete chan;

					return NULL;

					}

				r = ChannelArray.InsertInOrder(aSlaveClientChan,EntryOrder);

				if(r!=KErrNone)

					{

					delete chan;

					delete aSlaveClientChan;

					break;

					}

				}

	#endif

	#if defined(MASTER_MODE) && defined(SLAVE_MODE)

			if(CHANNEL_TYPE(i) == DIicBusChannel::EMasterSlave)

				{

				chanM=new DSimulatedIicBusChannelMasterI2c(BUS_TYPE,CHANNEL_DUPLEX(i));

				if(!chanM)

					return NULL;

				chanS=new DSimulatedIicBusChannelSlaveI2c(BUS_TYPE,CHANNEL_DUPLEX(i));

				if(!chanS)

					{

					delete chanM;

					return NULL;

					}

				chan=new DSimulatedIicBusChannelMasterSlaveI2c(BUS_TYPE,CHANNEL_DUPLEX(i),(DSimulatedIicBusChannelMasterI2c*)chanM,(DSimulatedIicBusChannelSlaveI2c*)chanS); // Generic implementation

				if(!chan)

					{

					CLIENT_PRINT(("\n\nI2C: Channel of type (%d) not created for index %d\n\n",CHANNEL_TYPE(i),i));

					delete chanM;

					delete chanS;

					return NULL;

					}

				CLIENT_PRINT(("I2C chan created at 0x%x\n",chan));

				if(((DIicBusChannelMasterSlave*)chan)->DoCreate()!=KErrNone)

					{

					delete chanM;

					delete chanS;

					delete chan;

					return NULL;

					}

				aSlaveClientChan = new DIicSlaveClientChan(chan,AssignChanNumI2c(),DIicBusChannel::EMasterSlave);

				if(!aSlaveClientChan)

					{

					delete chanM;

					delete chanS;

					delete chan;

					return NULL;

					}

				r = ChannelArray.InsertInOrder(aSlaveClientChan,EntryOrder);

				if(r!=KErrNone)

					{

					delete chanM;

					delete chanS;

					delete chan;

					delete aSlaveClientChan;

					break;

					}

				}

	#endif

	#if defined(SLAVE_MODE)

			if(CHANNEL_TYPE(i) == (DIicBusChannel::ESlave))

				{

				chan=new DSimulatedIicBusChannelSlaveI2c(BUS_TYPE,CHANNEL_DUPLEX(i));

				if(!chan)

					{

					CLIENT_PRINT(("\n\nI2C: Channel of type (%d) not created for index %d\n\n",CHANNEL_TYPE(i),i));

					return NULL;

					}

				CLIENT_PRINT(("I2C chan created at 0x%x\n",chan));

				if(((DSimulatedIicBusChannelSlaveI2c*)chan)->Create()!=KErrNone)

					return NULL;

				aSlaveClientChan = new DIicSlaveClientChan(chan,AssignChanNumI2c(),DIicBusChannel::ESlave);

				if(!aSlaveClientChan)

					{

					delete chan;

					return NULL;

					}

				r = ChannelArray.InsertInOrder(aSlaveClientChan,EntryOrder);

				if(r!=KErrNone)

					{

					delete chan;

					delete aSlaveClientChan;

					break;

					}

				}

	#endif

	#if !defined(MASTER_MODE) && !defined(SLAVE_MODE)

	#error I2C mode not defined as Master, Slave nor Master-Slave

	#endif

			}

#endif

	return new DDeviceIicSlaveClient;

	}

DChannelIicSlaveClient::DChannelIicSlaveClient()

// Constructor

    {

	iFullDuplexReq=iBlockedTrigger=iExpectedTrigger=0;

	CLIENT_PRINT(("> DChannelIicSlaveClient::DChannelIicSlaveClient()"));

    iClient=&Kern::CurrentThread();

	// Increase the DThread's ref count so that it does not close without us

	iClient->Open();

	iTestOverUnderState = EStartState;

    }

DChannelIicSlaveClient::~DChannelIicSlaveClient()

// Destructor

    {

	CLIENT_PRINT(("> DChannelIicSlaveClient::~DChannelIicSlaveClient()"));

	iDfcQue->Destroy();

	delete iNotif;

	delete iRxBuf;

	delete iTxBuf;

	delete iBusTxCheckBuf;

	// decrement the DThread's reference count

	Kern::SafeClose((DObject*&)iClient, NULL);

	}

void DChannelIicSlaveClient::RequestComplete(TInt r)

	{

	Kern::RequestComplete(iClient, iStatus, r);

	}

TInt DChannelIicSlaveClient::RegisterRxBuffer(TInt aChannelId, TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)

	{

	TInt r = KErrNone;

#ifdef STANDALONE_CHANNEL

	DIicSlaveClientChan* aChanPtr = NULL;

	if(iCapturedChan.iChannelId == aChannelId)

		aChanPtr = iCapturedChan.iChannel;

	if(!aChanPtr)

		return KErrArgument;

	if(aChanPtr->GetChanType() == DIicBusChannel::EMasterSlave)

		r = ((DIicBusChannelMasterSlave*)(aChanPtr->GetChannelPtr()))->RegisterRxBuffer(aRxBuffer, aBufGranularity, aNumWords, aOffset);

	else if(aChanPtr->GetChanType() == DIicBusChannel::ESlave)

		r = ((DIicBusChannelSlave*)(aChanPtr->GetChannelPtr()))->RegisterRxBuffer(aRxBuffer, aBufGranularity, aNumWords, aOffset);

#else

	r = IicBus::RegisterRxBuffer(aChannelId, aRxBuffer, aBufGranularity, aNumWords, aOffset);

#endif

	return r;

	}

TInt DChannelIicSlaveClient::SetNotificationTrigger(TInt aChannelId, TInt aTrigger)

	{

	TInt r = KErrNone;

#ifdef STANDALONE_CHANNEL

	DIicSlaveClientChan* aChanPtr = NULL;

	if(iCapturedChan.iChannelId == aChannelId)

		aChanPtr = iCapturedChan.iChannel;

	if(!aChanPtr)

		return KErrArgument;

	if(aChanPtr->GetChanType() == DIicBusChannel::EMasterSlave)

		r = ((DIicBusChannelMasterSlave*)(aChanPtr->GetChannelPtr()))->SetNotificationTrigger(aTrigger);

	else if(aChanPtr->GetChanType() == DIicBusChannel::ESlave)

		r = ((DIicBusChannelSlave*)(aChanPtr->GetChannelPtr()))->SetNotificationTrigger(aTrigger);

#else

	r = IicBus::SetNotificationTrigger(aChannelId, aTrigger);

#endif

	return r;

	}

TInt DChannelIicSlaveClient::StaticExtension(TUint aId, TUint aFunction, TAny* aParam1, TAny* aParam2)

	{

	TInt r = KErrNone;

#ifdef STANDALONE_CHANNEL

	DIicSlaveClientChan* aChanPtr;

	r = GetChanPtr(aId, aChanPtr);

	if(r != KErrNone)

		return r;

	if(!aChanPtr)

		return KErrArgument;

	if(aChanPtr->GetChanType() == DIicBusChannel::EMasterSlave)

		r = ((DIicBusChannelMasterSlave*)(aChanPtr->GetChannelPtr()))->StaticExtension(aFunction, aParam1, aParam2);

	else if(aChanPtr->GetChanType() == DIicBusChannel::ESlave)

	r = ((DIicBusChannelSlave*)(aChanPtr->GetChannelPtr()))->StaticExtension(aFunction, aParam1, aParam2);

#else

	r = IicBus::StaticExtension(aId, aFunction, aParam1, aParam2);

#endif

	return r;

	}

TInt DChannelIicSlaveClient::RegisterTxBuffer(TInt aChannelId, TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)

	{

	TInt r = KErrNone;

#ifdef STANDALONE_CHANNEL