// 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_client.cpp

// Simulated (kernel-side) client of IIC Platform Independent Layer (PIL)

//

#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"

#include "spi.h"

#endif

#ifdef LOG_CLIENT

#define CLIENT_PRINT(str) Kern::Printf str

#else

#define CLIENT_PRINT(str)

#endif

const TInt KIicClientThreadPriority = 24;

const TInt KIicSlaveClientDfcPriority = 3; // 0 to 7, 7 is highest ... for MasterSlave functionality

const TInt KMaxNumChannels = 3;	// 1 SPI and 2 I2C

// Define an array of channel that the client is going to create.

// For iic_client, it needs SPI channels for Master tests, and I2c channels for MasterSlave tests.

#ifdef STANDALONE_CHANNEL

const TUint NUM_CHANNELS_SPI = 4; // Arbitrary

const TInt KChannelTypeArraySpi[NUM_CHANNELS_SPI] = {DIicBusChannel::EMaster, DIicBusChannel::EMaster, DIicBusChannel::ESlave, DIicBusChannel::EMaster};

#define CHANNEL_TYPE_SPI(n) (KChannelTypeArraySpi[n])

const DIicBusChannel::TChannelDuplex KChannelDuplexArraySpi[NUM_CHANNELS_SPI] = {DIicBusChannel::EHalfDuplex, DIicBusChannel::EHalfDuplex, DIicBusChannel::EHalfDuplex, DIicBusChannel::EFullDuplex};

#define CHANNEL_DUPLEX_SPI(n) (KChannelDuplexArraySpi[n])

#define BUS_TYPE_SPI (DIicBusChannel::ESpi)

#define NUM_CHANNELS_I2C 3

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

const TInt KChannelTypeArrayI2c[NUM_CHANNELS_I2C] = {DIicBusChannel::EMaster, DIicBusChannel::EMaster, DIicBusChannel::EMaster};

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

const TInt KChannelTypeArrayI2c[NUM_CHANNELS_I2C] = {DIicBusChannel::EMaster, DIicBusChannel::ESlave, DIicBusChannel::EMasterSlave};

#else

const TInt KChannelTypeArrayI2c[NUM_CHANNELS_I2C] = {DIicBusChannel::ESlave, DIicBusChannel::ESlave, DIicBusChannel::ESlave};

#endif

#define CHANNEL_TYPE_I2C(n) (KChannelTypeArrayI2c[n])

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

#define BUS_TYPE_I2C (DIicBusChannel::EI2c)

const TInt8 KSpiChannelNumBase = 1;	// Arbitrary, real platform may consult the Configuration Repository

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

LOCAL_C TInt8 AssignChanNumSpi()

	{

	static TInt8 iBaseChanNumSpi = KSpiChannelNumBase;

	CLIENT_PRINT(("SPI AssignChanNum - on entry, iBaseCanNum = 0x%x\n",iBaseChanNumSpi));

	return iBaseChanNumSpi++; // Arbitrary, for illustration

	}

#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

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 DIicClientChan : public DBase

	{

public:

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

	~DIicClientChan();

	TInt GetChanNum()const {return iChanNumber;};

	TUint8 GetChanType()const {return iChanType;};

	DIicBusChannel* GetChannelPtr(){return iChan;};

	inline DIicClientChan& operator=(DIicClientChan& aChan) {iChanNumber=aChan.iChanNumber; iChanType=aChan.iChanType; iChan=aChan.iChan; return *this;};

	inline TInt operator==(DIicClientChan& aChan) {if((iChanNumber == aChan.iChanNumber)&&(iChanType == aChan.iChanType)&&(iChan == aChan.iChan)) return 1;return 0;};

private:

	TInt iChanNumber;

	TUint8 iChanType;

	DIicBusChannel* iChan;

	};

DIicClientChan::~DIicClientChan()

	{

	delete iChan;

	}

#endif /*STANDALONE_CHANNEL*/

#ifdef STANDALONE_CHANNEL

_LIT(KLddRootName,"iic_client_ctrless");

#else

_LIT(KLddRootName,"iic_client");

#endif

_LIT(KIicClientThreadName,"IicClientLddThread");

struct TCapsIicClient

    {

    TVersion version;

    };

struct TTransStatusPair

	{

	TRequestStatus* iReq;

	TIicBusTransaction* iTrans;

	};

struct TTransCbPair

	{

	TIicBusTransaction* iTrans;

	TIicBusCallback* iCb;

	};

struct TExtractInfo

    {

    TExtractInfo(){iBufPtr = NULL; iTfer = NULL;}

    ~TExtractInfo(){delete iBufPtr; delete iTfer;}

    TDes8* iBufPtr;

    TIicBusTransfer* iTfer;

    TIicBusTransaction* iTrans;

    };

struct TTransBufReuseData

	{

	// Convenience for testing, only - retain pointers to private data

	// so that it can be re-used from a callback.

	TIicBusTransaction* iTransaction;

	TIicBusTransfer* iHdTfer;

	TIicBusTransfer* iFdTfer;

	TDes8* iHdr;

	// Pointer to callback object (for cleanup)

	TIicBusCallback* iCallback;

	};

class DDeviceIicClient : public DLogicalDevice

    {

    public:

    /**

     * The constructor

     */

    DDeviceIicClient();

    /**

     * The destructor

     */

    ~DDeviceIicClient();

    /**

     * 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);

	public:

    };

#ifdef STANDALONE_CHANNEL

/*This class is used to test the set and get inline functions

 *  of DIicBusChannel Interface.

 * */

class TTestIicChannelInterface: public DIicBusChannel

{

public:

    TTestIicChannelInterface(TChannelType aChannelType, TBusType aBusType, TChannelDuplex aChanDuplex);

    ~TTestIicChannelInterface(){};

    TInt DoCreate(){return 0;};

    TInt CheckHdr(TDes8* /*aHdr*/){return 0;};

    TInt TestInterface();

private:

    TBool TestChannelType(DIicBusChannel::TChannelType aType );

    TBool TestBusType(DIicBusChannel::TBusType aType );

    TBool TestDuplexType(DIicBusChannel::TChannelDuplex aType );

};

TTestIicChannelInterface::TTestIicChannelInterface(TChannelType aChannelType, TBusType aBusType, TChannelDuplex aChanDuplex)

        : DIicBusChannel(aChannelType, aBusType, aChanDuplex)

    {}

TBool TTestIicChannelInterface::TestChannelType(DIicBusChannel::TChannelType aType)

    {

    CLIENT_PRINT(("Setting channel type 0x%x\n", aType));

    SetChannelType(aType);

    if(aType != ChannelType())

        {

        CLIENT_PRINT(("ERROR: Mismatch, looking for channel 0x%x but found 0x%x\n", aType, ChannelType()));

        return EFalse;

        }

    else

        {

        CLIENT_PRINT(("Looking for channel 0x%x and found 0x%x\n", aType, ChannelType()));

        }

    return ETrue;

    }

TBool TTestIicChannelInterface::TestBusType(DIicBusChannel::TBusType aType)

    {

    CLIENT_PRINT(("Setting Bus type 0x%x\n", aType));

    SetBusType(aType);

    if(aType != BusType())

        {

        CLIENT_PRINT(("ERROR: Mismatch, looking for Bus 0x%x but found 0x%x\n", aType, BusType()));

        return EFalse;

        }

    else

        {

        CLIENT_PRINT(("Looking for Bus 0x%x and found 0x%x\n", aType, BusType()));

        }    

    return ETrue;   

    }

TBool TTestIicChannelInterface::TestDuplexType(DIicBusChannel::TChannelDuplex aType)

    {

    CLIENT_PRINT(("Setting duplex channel type 0x%x\n", aType));

    SetChannelType(aType);

    if(aType != ChannelDuplex())

        {

        CLIENT_PRINT(("ERROR: Mismatch, looking for duplex channel 0x%x but found 0x%x\n", aType, ChannelDuplex()));

        return EFalse;

        }

    else

        {

        CLIENT_PRINT(("Looking for Duplex Channel 0x%x and found 0x%x\n", aType, ChannelDuplex()));

        }    

    return ETrue;   

    }

TInt TTestIicChannelInterface::TestInterface()

    {

    RArray <DIicBusChannel::TChannelType> chtype;

    RArray <DIicBusChannel::TBusType> bustype;

    RArray <DIicBusChannel::TChannelDuplex> dutype;

    chtype.Append(DIicBusChannel::EMaster);

    chtype.Append(DIicBusChannel::ESlave);

    chtype.Append(DIicBusChannel::EMasterSlave);

    bustype.Append(DIicBusChannel::EI2c);

    bustype.Append(DIicBusChannel::ESpi);

    bustype.Append(DIicBusChannel::EMicrowire);

    bustype.Append(DIicBusChannel::ECci);

    bustype.Append(DIicBusChannel::ESccb);

    dutype.Append(DIicBusChannel::EHalfDuplex);

    dutype.Append(DIicBusChannel::EFullDuplex);

    int result = KErrNone;

    int count = chtype.Count();

    int i=0;

    CLIENT_PRINT(("\nCheck Master/Slave channel setting\n"));

    CLIENT_PRINT(("\nChannel MASK  = 0x%x\n", KChannelTypeMask));    

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

        {

        if(!TestChannelType(chtype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    CLIENT_PRINT(("\nCheck Master/Slave channel setting from higher bit number to lower, reverse enum.\n"));

    for(i=count-1; i >= 0; --i)

        {

        if(!TestChannelType(chtype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    CLIENT_PRINT(("\nCheck Channel Bus type settings\n"));

    CLIENT_PRINT(("\nBus MASK  = 0x%x\n", KBusTypeMask));     

    count = bustype.Count();    

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

        {

        if(!TestBusType(bustype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    CLIENT_PRINT(("\nCheck Channel Bus type settings from higher bit number to lower, reverse enum.\n"));   

    for(i = count-1; i >= 0; --i)

        {

        if(!TestBusType(bustype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    CLIENT_PRINT(("\nCheck Channel Duplex settings\n"));

    CLIENT_PRINT(("\nDuplex MASK  = 0x%x\n", KChannelDuplexMask));     

    count = dutype.Count();

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

        {

        if(!TestDuplexType(dutype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    CLIENT_PRINT(("\nCheck Channel Duplex setting from higher bit number to lower, reverse enum.\n"));        

    for(i = count-1; i >= 0; --i)

        {

        if(!TestDuplexType(dutype[i]))

            {

            result = KErrGeneral;

            break;

            }

        }

    chtype.Close();

    dutype.Close();

    bustype.Close();

    return result;

    }

#endif //STANDALONE_CHANNEL

class DChannelIicClient : public DLogicalChannel

    {

    public:

    DChannelIicClient();

    ~DChannelIicClient();

	TInt CleanupExtractTrans(TIicBusTransaction *aTrans);

	TInt InitIicClient();

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

    protected:

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

    void DoCancel(TInt aMask);	// Name for convenience!

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

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

	void TestTransModification(TIicBusTransaction* aTransaction, // public to be accessed by callback

							  TIicBusTransfer* aHdTfer,

							  TIicBusTransfer* aFdTfer,

							  TDes8* aHdr);

#ifdef STANDALONE_CHANNEL

    public:

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

#endif

	private:

	TInt ExtractTransData(TUsideTracnDesc* aUsideTrancnDesc, TIicBusTransaction*& aTrans);

	TInt CreateTransferListHalfDuplex(

				TIicBusTransfer::TReqType aNodeDir1, TInt aNodeLength1,

				TIicBusTransfer::TReqType aNodeDir2, TInt aNodeLength2,

				TIicBusTransfer::TReqType aNodeDir3, TInt aNodeLength3);

	TInt CreateTransferListFullDuplex(

				TIicBusTransfer::TReqType aNodeDir1, TInt aNodeLength1,

				TIicBusTransfer::TReqType aNodeDir2, TInt aNodeLength2,

				TIicBusTransfer::TReqType aNodeDir3, TInt aNodeLength3);

	TInt DeleteFullDuplexTest(TIicBusTransaction *aTrans);

	TInt DoCreateFullDuplexTransTest(TInt aTestType);

	TInt DoPriorityTest(TInt aBusId);

	TInt ConstructTransactionOne(TIicBusTransaction*& aTrans);

	void CleanupTransactionOne(TIicBusTransaction*& aTrans);

	TInt InsertPairs(TTransStatusPair* aPair, TTransCbPair* aCbPair);

	TInt CreateDefaultSpiBuf(TConfigSpiBufV01*& aBuf);

	//Add new functions for controller-less mode

	TInt QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction, TIicBusCallback *aCallback=NULL);

	TInt CancelTransaction(TInt aBusId, TIicBusTransaction* aTransaction);

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

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

	TInt ReleaseChannel(TInt aChannelId);

	public:

	inline void Lock() {Kern::MutexWait(*iArrayMutex);}

	inline void Unlock() {Kern::MutexSignal(*iArrayMutex);}

	inline void GetWriteAccess() {Kern::SemaphoreWait(*iChanArrWrtSem);}	// aNTicks not specified = wait forever

	inline void FreeWriteAccess() {Kern::SemaphoreSignal(*iChanArrWrtSem);}

	void CleanupTransaction(TIicBusTransaction*& aTrans); // public for access by callback

	static TIicBusTransaction* MultiTranscCallbackFunc(TIicBusTransaction* aTrans, TAny* aParam);

	static void TransModifCallback(TIicBusTransaction* aTrans, TInt aBusId, TInt aResult, TAny* aParam);

	private:

	TDynamicDfcQue* iDfcQue;

	DMutex* iArrayMutex;		// used to protect array of channels

	DSemaphore* iChanArrWrtSem;	// used to synchronise write access to iChannelArray

	// Used for Transaction One

	HBuf8* buf1;

	HBuf8* buf2;

	HBuf8* buf3;

	HBuf8* buf4;

	HBuf8* buf5;

	HBuf8* buf6;

	TIicBusTransfer* tfer1;

	TIicBusTransfer* tfer2;

	TIicBusTransfer* tfer3;

	TIicBusTransfer* tfer4;

	TIicBusTransfer* tfer5;

	TIicBusTransfer* tfer6;

	TIicBusTransfer* tfer7;

	HBuf8* header;

	HBuf8* header2;

	HBuf8* header3;

	HBuf8* header4;

	HBuf8* header5;

	HBuf8* headerBlock;

	TConfigSpiBufV01* spiHeader;

	static TIicBusTransaction* iMultiTransac;

	// Used for simple transactions

	TIicBusTransaction* iTrans;

	TConfigSpiBufV01* iSpiBuf;

	TConfigI2cBufV01* iI2cBuf;

	TIicBusTransfer* iTfer;

	TIicBusTransactionPreamble* iTransPreamble;

	TIicBusTransfer* iFdTfer;

	public:

	DThread* iClient;

	RPointerArray<TTransStatusPair> iTransStatArrayByTrans;

	RPointerArray<TTransStatusPair> iTransStatArrayByStatus;

	RPointerArray<TTransCbPair> iTransCbArrayByTrans;

	RPointerArray<TExtractInfo> iExtractInfoArray;

	// Support for Preamble testing

	TRequestStatus* iPreambleStatus;

	TRequestStatus* iMultiTranscStatus;

	// Support for buffer re-use testing

	TTransBufReuseData iTransBufReuseData;

	// Support for MasterSlave processing

	private:

	TInt InitSlaveClient();

	private:

	HBuf8* iConfigHdr;

	TRequestStatus* iStatus;

	public:

	void RequestComplete(TInt r);

	public:

	TIicBusSlaveCallback* iNotif;		// public to be accessible by callback

	TInt iChannelId;				// public to be accessible by callback

	TInt* iClientChanId;

#ifdef STANDALONE_CHANNEL

	//Used to store the captured channel

	struct TCapturedChannel

        {

        DIicClientChan* iChanPtr;

        TInt iChannelId;

        };

	TCapturedChannel iCapturedChannel;

#endif

	};

DDeviceIicClient::DDeviceIicClient()

// Constructor

    {

	CLIENT_PRINT(("> DDeviceIicClient::DDeviceIicClient()"));

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceIicClient::DDeviceIicClient()"));

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

    iUnitsMask=0;

    iVersion=TVersion(KIicClientMajorVersionNumber,

		      KIicClientMinorVersionNumber,

		      KIicClientBuildVersionNumber);

    }

#ifdef STANDALONE_CHANNEL

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

TInt DChannelIicClient::OrderEntries(const DIicClientChan& aMatch, const DIicClientChan& 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<DIicClientChan> EntryOrder(DChannelIicClient::OrderEntries);

// Store all the channels created by the client

RPointerArray<DIicClientChan> ChannelArray;

#endif /*STANDALONE_CHANNEL*/

DDeviceIicClient::~DDeviceIicClient()

    {

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

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceIicClient::~DDeviceIicClient()"));

#ifdef STANDALONE_CHANNEL

    //For Standalone Channel, the client is responsible for channel destroy

    ChannelArray.ResetAndDestroy();

#endif

	}

TInt DDeviceIicClient::Install()

// Install the device driver.

    {

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

    __KTRACE_OPT(KRESMANAGER, Kern::Printf("> DDeviceIicClient::Install()"));

    return(SetName(&KLddRootName));

    }

// Auxiliary functions for ordering entries in the array of TTransStatusPair pointers

// The first is to enable searching by Transaction (used by the callback)

// The second is to enable searching by the TRequestStatus (used by cancel calls)

TInt OrderEntriesByTrans(const TTransStatusPair& aMatch, const TTransStatusPair& aEntry)

	{

	TUint l=(TUint)(aMatch.iTrans);

	TUint r=(TUint)(aEntry.iTrans);

	if(l>r)

		return -1;

	else if(l<r)

		return 1;

	else

		return 0;

	}

TLinearOrder<TTransStatusPair> TransStatusOrderByTrans(OrderEntriesByTrans);

TInt OrderEntriesByStatus(const TTransStatusPair& aMatch, const TTransStatusPair& aEntry)

	{

	TUint l=(TUint)(aMatch.iReq);

	TUint r=(TUint)(aEntry.iReq);

	if(l>r)

		return -1;

	else if(l<r)

		return 1;

	else

		return 0;

	}

TLinearOrder<TTransStatusPair> TransStatusOrderByStatus(OrderEntriesByStatus);

// Auxilliary function to track callback objects assigned to asynchronous transactions

TInt OrderCbEntriesByTrans(const TTransCbPair& aMatch, const TTransCbPair& aEntry)

	{

	TUint l=(TUint)(aMatch.iTrans);

	TUint r=(TUint)(aEntry.iTrans);

	if(l>r)

		return -1;

	else if(l<r)

		return 1;

	else

		return 0;

	}

TLinearOrder<TTransCbPair> TransCbOrderByTrans(OrderCbEntriesByTrans);

TInt OrderExtractInfoByTrans(const TExtractInfo& aMatch, const TExtractInfo& aEntry)

    {

    TUint l=(TUint)(aMatch.iTrans);

    TUint r=(TUint)(aEntry.iTrans);

    if(l>r)

        return -1;

    else if(l<r)

        return 1;

    else

        return 0;

    }

TLinearOrder<TExtractInfo> ExtractInfoOrderByTrans(OrderExtractInfoByTrans);

_LIT(KLitArrayMutexName,"IIC_CLIENT_ARRAY_MUTEX");

_LIT(KLitArraySemName,"IIC_CLIENT_ARRAY_SEM");

#define IIC_CLIENT_MUTEX_ORDER KMutexOrdGeneral4	// Semi-arbitrary - middle of general purpose range, allow higher and lower priorities

TInt DChannelIicClient::InitIicClient()

	{

	TInt r = Kern::MutexCreate(iArrayMutex,KLitArrayMutexName,IIC_CLIENT_MUTEX_ORDER);

	if(r!=KErrNone)

		return r;

	r = Kern::SemaphoreCreate(iChanArrWrtSem,KLitArraySemName,1); // Initial count of one allows first wait to be non-blocking

	if(r!=KErrNone)

		iArrayMutex->Close(NULL);

	return r;

	}

TInt DChannelIicClient::InsertPairs(TTransStatusPair* aPair, TTransCbPair* aCbPair)

	{

	CLIENT_PRINT(("DChannelIicClient::InsertPairs invoked with aPair=0x%x, aPair->iReq=0x%x, aPair-iTrans=0x%x\n",aPair,aPair->iReq,aPair->iTrans ));

	CLIENT_PRINT(("DChannelIicClient::InsertPairs ... and aCbPair=0x%x, aCbPair->iCb=0x%x, aCbPair-iTrans=0x%x\n",aCbPair,aCbPair->iCb,aCbPair->iTrans ));

	TInt r = KErrNone;

	GetWriteAccess();

	Lock();

	if((r = iTransStatArrayByTrans.InsertInOrder(aPair,TransStatusOrderByTrans)) == KErrNone)

		{

		if((r = iTransStatArrayByStatus.InsertInOrder(aPair,TransStatusOrderByStatus)) == KErrNone)

			{

			if((r = iTransCbArrayByTrans.InsertInOrder(aCbPair,TransCbOrderByTrans))!=KErrNone)

				{

				CLIENT_PRINT(("DChannelIicClient::InsertPairs, aCbPair=0x%x InsertInOrder(status) returned %d\n",aCbPair,r));

				}

			}

		else

			{

			CLIENT_PRINT(("DChannelIicClient::InsertPairs, aPair=0x%x InsertInOrder(status) returned %d\n",aPair,r));

			}

		}

	else

		{

		CLIENT_PRINT(("DChannelIicClient::InsertPairs, aPair=0x%x InsertInOrder(trans) returned %d\n",aPair,r));

		}

	FreeWriteAccess();

	Unlock();

	return r;

	}

//dummy call back func is provided for asyn call in priority test

static void DummyCallbackFunc(TIicBusTransaction* /*aTrans*/, TInt /*aBusId*/, TInt /*aResult*/, TAny* /*aParam*/)

	{

	//do nothing

	}

static void AsyncCallbackFunc(TIicBusTransaction* aTrans, TInt aBusId, TInt aResult, TAny* aParam)

	{

	(void)aBusId; // aBusId is not used if CLIENT_PRINT is disabled

	CLIENT_PRINT(("> AsyncCallbackFunc() - aTrans=0x%x, aBusId=0x%x, aResult=%d, aParam=0x%x\n",aTrans,aBusId,aResult,aParam));

	DChannelIicClient* channel = (DChannelIicClient*)aParam;

	CLIENT_PRINT(("AsyncCallbackFunc() - channel=0x%x\n",channel));

	// Use the channel to get the user-side client's TRequestStatus and complete it with aResult

	TTransStatusPair* searchPair = new TTransStatusPair();

	searchPair->iTrans = aTrans;

	channel->GetWriteAccess();

	channel->Lock();

	TInt pairIndex = (channel->iTransStatArrayByTrans).FindInOrder(searchPair,TransStatusOrderByTrans);

	delete searchPair;

	if(pairIndex<0)

		{

		CLIENT_PRINT(("AsyncCallbackFunc() - (trans) FindInOrder returned %d (aTrans=0x%x)\n",pairIndex,aTrans));

		return;

		}

	TTransStatusPair* pairPtr = (channel->iTransStatArrayByTrans)[pairIndex];

	TRequestStatus* status = pairPtr->iReq;

	// Now remove the TTransStatusPair objects in iTransStatArrayByTrans, iTransStatArrayByStatus

	(channel->iTransStatArrayByTrans).Remove(pairIndex);

	pairIndex = (channel->iTransStatArrayByStatus).FindInOrder(pairPtr,TransStatusOrderByStatus);

	if(pairIndex<0)

		{

		CLIENT_PRINT(("AsyncCallbackFunc() - (status) FindInOrder returned %d (status=0x%x)\n",pairIndex,status));

		return;

		}

	(channel->iTransStatArrayByStatus).Remove(pairIndex);

	// Now remove the TTransCbPair object in iTransCbArrayByTrans

	TTransCbPair* SearchCbPair = new TTransCbPair();

	SearchCbPair->iTrans = aTrans;

	pairIndex = (channel->iTransCbArrayByTrans).FindInOrder(SearchCbPair,TransCbOrderByTrans);

	delete SearchCbPair;

	if(pairIndex<0)

		{

		CLIENT_PRINT(("AsyncCallbackFunc() - (cb) FindInOrder returned %d (aTrans=0x%x)\n",pairIndex,aTrans));

		return;

		}

	TTransCbPair* cbPair = (channel->iTransCbArrayByTrans)[pairIndex];

	(channel->iTransCbArrayByTrans).Remove(pairIndex);

	delete cbPair->iCb;

	delete cbPair;

	channel->FreeWriteAccess();

	channel->Unlock();

	Kern::RequestComplete(channel->iClient, status, aResult);

	// We should call CleanupExtractTrans() to delete all the objects created in ExtractTransData()

	channel->CleanupExtractTrans(pairPtr->iTrans);

	// The object referred to be pairPtr is finished with and can be deleted

	channel->CleanupTransaction(pairPtr->iTrans);

	delete pairPtr;

	}

void DDeviceIicClient::GetCaps(TDes8& aDes) const

// Return the IicClient capabilities.

    {

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

    TPckgBuf<TCapsIicClient> b;

    b().version=TVersion(KIicClientMajorVersionNumber,

			 KIicClientMinorVersionNumber,

			 KIicClientBuildVersionNumber);

    Kern::InfoCopy(aDes,b);

    }

TInt DDeviceIicClient::Create(DLogicalChannelBase*& aChannel)

// Create a channel on the device.

    {

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

	if(iOpenChannels>=KMaxNumChannels)

		return KErrOverflow;

    aChannel=new DChannelIicClient;

    return aChannel?KErrNone:KErrNoMemory;

    }

#ifdef STANDALONE_CHANNEL

TInt GetChanPtr(const TInt aBusId, TInt &aIndex, DIicClientChan*& 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));

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

	TInt r = KErrNotFound;

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

	if(aIndex >= 0)

		{

		aChan = ChannelArray[aIndex];

		r = KErrNone;

		}

	__KTRACE_OPT(KIIC, 	Kern::Printf("GetChanPtr, chanPtr=0x%x, index=%d\n",aChan,aIndex));

	return r;

	}

#endif

DECLARE_STANDARD_LDD()

	{

	//If in STANDALONE_CHANNEL mode, the client creates a list of channels

#ifdef STANDALONE_CHANNEL

	DIicClientChan* aClientChan;

	TInt r = KErrNone;

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

	TInt i;

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

		{

		CLIENT_PRINT(("\n"));

#if defined(MASTER_MODE)

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

			{

			chan=new DSimulatedIicBusChannelMasterSpi(BUS_TYPE_SPI,CHANNEL_DUPLEX_SPI(i));

			if(!chan)

			    {

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

				return NULL;

			    }

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

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

			    {

			    delete chan;

				return NULL;

			    }

			aClientChan = new DIicClientChan(chan,AssignChanNumSpi(),DIicBusChannel::EMaster);

            if(!aClientChan)

                {

                delete chan;

                return NULL;

                }

            r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

            if(r!=KErrNone)

                {

                delete chan;

                delete aClientChan;

                break;

                }

			}

#endif

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

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

			{

			//For MasterSlave channel, the client creates a Master channel, a Slave

			//channel and a MasterSlave Channel, then store all of them in ChannelArray.

			chanM=new DSimulatedIicBusChannelMasterSpi(BUS_TYPE_SPI,CHANNEL_DUPLEX_SPI(i));

			if(!chanM)

				return NULL;

			chanS=new DSimulatedIicBusChannelSlaveSpi(BUS_TYPE_SPI,CHANNEL_DUPLEX_SPI(i));

			if(!chanS)

			    {

			    delete chanM;

				return NULL;

			    }

			chan=new DIicBusChannelMasterSlave(BUS_TYPE_SPI,CHANNEL_DUPLEX_SPI(i),(DSimulatedIicBusChannelMasterSpi*)chanM,(DSimulatedIicBusChannelSlaveSpi*)chanS); // Generic implementation

			if(!chan)

			    {

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

			    delete chanM;

			    delete chanS;

				return NULL;

			    }

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

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

			    {

			    delete chanM;

			    delete chanS;

			    delete chan;

				return NULL;

			    }

			aClientChan = new DIicClientChan(chan,AssignChanNumSpi(),DIicBusChannel::EMasterSlave);

			if(!aClientChan)

			    {

			    delete chanM;

			    delete chanS;

			    delete chan;

			    return NULL;

			    }

            r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

            if(r!=KErrNone)

                {

                delete chanM;

                delete chanS;

                delete chan;

                delete aClientChan;

                break;

                }

			}

#endif

#if defined(SLAVE_MODE)

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

			{

			chan=new DSimulatedIicBusChannelSlaveSpi(BUS_TYPE_SPI,CHANNEL_DUPLEX_SPI(i));

			if(!chan)

			    {

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

				return NULL;

			    }

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

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

			    {

			    delete chan;

				return NULL;

			    }

			aClientChan = new DIicClientChan(chan,AssignChanNumSpi(),DIicBusChannel::ESlave);

            if(!aClientChan)

                {

                delete chan;

                return NULL;

                }

            r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

            if(r!=KErrNone)

                {

                delete chan;

                delete aClientChan;

                break;

                }

			}

#endif

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

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

#endif

		}

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

			{

			CLIENT_PRINT(("\n"));

	#if defined(MASTER_MODE)

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

				{

				chan=new DSimulatedIicBusChannelMasterI2c(BUS_TYPE_I2C,CHANNEL_DUPLEX_I2C(i));

				if(!chan)

				    {

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

					return NULL;

				    }

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

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

				    {

				    delete chan;

					return NULL;

					}

				aClientChan = new DIicClientChan(chan,AssignChanNumI2c(),DIicBusChannel::EMaster);

				if(!aClientChan)

				    {

				    delete chan;

				    return NULL;

				    }

                r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

                if(r!=KErrNone)

                    {

                    delete chan;

                    delete aClientChan;

                    break;

                    }

				}

	#endif

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

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

				{

				chanM=new DSimulatedIicBusChannelMasterI2c(BUS_TYPE_I2C,CHANNEL_DUPLEX_I2C(i));

				if(!chanM)

					return NULL;

				chanS=new DSimulatedIicBusChannelSlaveI2c(BUS_TYPE_I2C,CHANNEL_DUPLEX_I2C(i));

				if(!chanS)

				    {

				    delete chanM;

					return NULL;

				    }

				//The client doesn't create the Master and Slave channels, as they should be created

				//in MasterSlave channel's DoCreate().

				chan=new DSimulatedIicBusChannelMasterSlaveI2c(BUS_TYPE_I2C,CHANNEL_DUPLEX_I2C(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_I2C(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;

				    }

			    aClientChan = new DIicClientChan(chan,AssignChanNumI2c(),DIicBusChannel::EMasterSlave);

                if(!aClientChan)

                    {

                    delete chanM;

                    delete chanS;

                    delete chan;

                    return NULL;

                    }

                r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

                if(r!=KErrNone)

                    {

                    delete chanM;

                    delete chanS;

                    delete chan;

                    delete aClientChan;

                    break;

                    }

				}

	#endif

	#if defined(SLAVE_MODE)

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

				{

				chan=new DSimulatedIicBusChannelSlaveI2c(BUS_TYPE_I2C,CHANNEL_DUPLEX_I2C(i));

				if(!chan)

				    {

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

					return NULL;

				    }

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

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

				    {

				    delete chan;

					return NULL;

				    }

			    aClientChan = new DIicClientChan(chan,AssignChanNumI2c(),DIicBusChannel::ESlave);

                if(!aClientChan)

                    {

                    delete chan;

                    return NULL;

                    }

                r = ChannelArray.InsertInOrder(aClientChan,EntryOrder);

                if(r!=KErrNone)

                    {

                    delete chan;

                    delete aClientChan;

                    break;