// 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):iChanNumber(aChanNum),iChanType(aChanType),iChan(aChan){};
	~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(KIIC, 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(KIIC, 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(KIIC, 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;
	TUint 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;
                    }
				}
	#endif
	#if !defined(MASTER_MODE) && !defined(SLAVE_MODE)
	#error I2C mode not defined as Master, Slave nor Master-Slave
	#endif
			}

#endif
	return new DDeviceIicClient;
	}



DChannelIicClient::DChannelIicClient()
// Constructor
    {
	CLIENT_PRINT(("> DChannelIicClient::DChannelIicClient()"));
    iClient=&Kern::CurrentThread();
	// Increase the DThread's ref count so that it does not close without us
	iClient->Open();
    }

DChannelIicClient::~DChannelIicClient()
// Destructor
    {
	CLIENT_PRINT(("> DChannelIicClient::~DChannelIicClient()"));
    __KTRACE_OPT(KIIC, Kern::Printf("> DChannelIicClient::~DChannelIicClient()"));
    delete iNotif;
    iArrayMutex->Close(NULL);
    iChanArrWrtSem->Close(NULL);
	iDfcQue->Destroy();
	// decrement the DThread's reference count
	Kern::SafeClose((DObject*&)iClient, NULL);

    iTransStatArrayByTrans.Reset();
    iTransStatArrayByStatus.Reset();
    iTransCbArrayByTrans.Reset();
	iExtractInfoArray.Reset();
	}


TInt DChannelIicClient::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
	CLIENT_PRINT(("> DChannelIicClient::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion &aVer)"));
	TInt r = Kern::DynamicDfcQCreate(iDfcQue,KIicClientThreadPriority,KIicClientThreadName);
	if(r!=KErrNone)
		return r;
	SetDfcQ(iDfcQue);
	iMsgQ.Receive();

	r = InitIicClient();
	return r;
	}

void DChannelIicClient::HandleMsg(TMessageBase* aMsg)
	{
	TThreadMessage& m=*(TThreadMessage*)aMsg;
    TInt id=m.iValue;

	CLIENT_PRINT((" >ldd: DChannelIicClient::HandleMsg(TMessageBase* aMsg) id=%d\n", id));

	if (id == (TInt)ECloseMsg)
		{
	    iMsgQ.iMessage->Complete(KErrNone,EFalse);
		return;
		}
    else if (id == KMaxTInt)
		{
		DoCancel(m.Int0());
		m.Complete(KErrNone,ETrue);
		return;
		}

    if (id<0)
		{
		TRequestStatus* pS=(TRequestStatus*)m.Ptr0();
		TInt r=DoRequest(~id, pS, m.Ptr1(), m.Ptr2());
		if (r!=KErrNone)
			{
	    	Kern::RequestComplete(iClient, pS, r);
			}
		m.Complete(KErrNone,ETrue);
		}
    else
		{
		TInt r=DoControl(id,m.Ptr0(),m.Ptr1());
		m.Complete(r,ETrue);
		}
	}

TInt DChannelIicClient::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction, TIicBusCallback *aCallback/*NULL*/)
	{
	TInt r = KErrNone;
#ifndef STANDALONE_CHANNEL
	if(!aCallback)
		r = IicBus::QueueTransaction(aBusId, aTransaction);
	else
		r = IicBus::QueueTransaction(aBusId, aTransaction, aCallback);
#else
	__KTRACE_OPT(KIIC, Kern::Printf("DChannelIicClient::QueueTransaction, aBusId=0x%x,aTransaction=0x%x\n", aBusId, aTransaction));
	if(!aTransaction)
		{
		return KErrArgument;
		}

	// Get a pointer to the channel
	TInt dumInt = 0;
	DIicClientChan* chanPtr = NULL;
	r = GetChanPtr(aBusId, dumInt, chanPtr);
	if(r == KErrNone)
		{
		if(!chanPtr)
			{
			r = KErrArgument;
			}
		else
			{
			switch(chanPtr->GetChanType())
				{
				// QueueTransaction requests are only supported by channels in Master mode.
				case DIicBusChannel::ESlave:
					{
					r = KErrNotSupported;
					break;
					}
				// If the request is supported by the Master channel, send it to the channel for processing in its thread
				case DIicBusChannel::EMasterSlave:
					{

					aTransaction->iBusId = aBusId;
					if(!aCallback)
					    r = (((DIicBusChannelMasterSlave*) (chanPtr->GetChannelPtr()))->QueueTransaction(aTransaction));					    
					else
						r = (((DIicBusChannelMasterSlave*) (chanPtr->GetChannelPtr()))->QueueTransaction(aTransaction, aCallback));
					break;
					}
				case DIicBusChannel::EMaster:
					{
					aTransaction->iBusId = aBusId;
					if(!aCallback)
						r = (((DIicBusChannelMaster*) (chanPtr->GetChannelPtr()))->QueueTransaction(aTransaction));
					else
						r = (((DIicBusChannelMaster*) (chanPtr->GetChannelPtr()))->QueueTransaction(aTransaction, aCallback));
					break;
					}
				default:
					{
					r = KErrGeneral;
					}
				}
			}
		}
#endif
	return r;
	}

TInt DChannelIicClient::CancelTransaction(TInt aBusId, TIicBusTransaction* aTransaction)
	{
	TInt r = KErrNone;
#ifndef STANDALONE_CHANNEL
	r = IicBus::CancelTransaction(aBusId, aTransaction);
#else
    __KTRACE_OPT(KIIC, Kern::Printf("DChannelIicClient::CancelTransaction, aBusId=0x%x,aTransaction=0x%x\n", aBusId, aTransaction));
	if(!aTransaction)
		{
		return KErrArgument;
		}

	// Get the channel
	TInt dumInt = 0;
	DIicClientChan* chanPtr = NULL;
	if(r == KErrNone)
		{
		r = GetChanPtr(aBusId, dumInt, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				// QueueTransaction requests are only supported by channels in Master mode.
				switch(chanPtr->GetChanType())
					{
					case DIicBusChannel::ESlave:
						{
						r = KErrNotSupported;
						break;
						}
					case DIicBusChannel::EMasterSlave:
						{
						r = (((DIicBusChannelMasterSlave*) (chanPtr->GetChannelPtr()))->CancelTransaction(aTransaction));
						break;
						}
					case DIicBusChannel::EMaster:
						{
						r = (((DIicBusChannelMaster*) (chanPtr->GetChannelPtr()))->CancelTransaction(aTransaction));
						break;
						}
					default:
						{
						r = KErrGeneral;
						}
					}
				}
			}
		}
#endif
	return r;
	}


TInt DChannelIicClient::StaticExtension(TUint aId, TUint aFunction, TAny* aParam1, TAny* aParam2)
	{
	TInt r = KErrNone;
#ifndef STANDALONE_CHANNEL
	r = IicBus::StaticExtension(aId, aFunction, aParam1, aParam2);
#else
	// Get the channel
	TInt dumInt = 0;
	DIicClientChan* chanPtr = NULL;
	if(r == KErrNone)
		{
		r = GetChanPtr(aId, dumInt, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				r = (chanPtr->GetChannelPtr())->StaticExtension(aFunction, aParam1, aParam2);
				}
			}
		}
#endif
	return r;
	}

TInt DChannelIicClient::CaptureChannel(TInt aBusId, TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch)
	{
	TInt r = KErrNone;
#ifndef STANDALONE_CHANNEL
	r = IicBus::CaptureChannel(aBusId, aConfigHdr, aCallback, aChannelId, aAsynch);
#else
	// Check that that aCallback!=NULL and aConfigHdr!=NULL - if not, return KErrArgument
	if(!aCallback || !aConfigHdr)
		{
		return KErrArgument;
		}

	// Get the channel
	TInt chanIndex = 0;
	DIicClientChan* chanPtr = NULL;
	if(r == KErrNone)
		{
		r = GetChanPtr(aBusId, chanIndex, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				switch(chanPtr->GetChanType())
					{
					// CaptureChannel requests are only supported by channels in Slave mode.
					case DIicBusChannel::EMaster:
						{
						r = KErrNotSupported;
						break;
						}
					case DIicBusChannel::EMasterSlave:
						{
						r = ((DIicBusChannelMasterSlave*) (chanPtr->GetChannelPtr()))->CaptureChannel(aConfigHdr, aCallback, aChannelId, aAsynch);
						break;
						}
					case DIicBusChannel::ESlave:
						{
						r = ((DIicBusChannelSlave*)(chanPtr->GetChannelPtr()))->CaptureChannel(aConfigHdr, aCallback, aChannelId, aAsynch);
						break;
						}
					default:
						{
						r = KErrArgument;
						}
					}
				// For synchronous capture, if successful then install the channel
				if(r == KErrNone)
					{
					if(!aAsynch)
						{
						 iCapturedChannel.iChanPtr = chanPtr;
						 iCapturedChannel.iChannelId = iChannelId;
						}
					else
						//For asynchronous capture, record chanPtr, if later failed capture,
						//clean iCapturedChannel in client's callback.
						iCapturedChannel.iChanPtr = chanPtr;
					}
				}
			}
		}
#endif
	return r;
	}

TInt DChannelIicClient::ReleaseChannel(TInt aChannelId)
	{
	TInt r = KErrNone;
#ifndef STANDALONE_CHANNEL
	r = IicBus::ReleaseChannel(aChannelId);
#else
    __KTRACE_OPT(KIIC, Kern::Printf("DChannelIicClient::ReleaseChannel, channelID = 0x%x \n",aChannelId));
    if(iCapturedChannel.iChannelId != aChannelId)
            return KErrNotFound;

    if((iCapturedChannel.iChanPtr)->GetChanType() == DIicBusChannel::EMasterSlave)
        r = ((DIicBusChannelMasterSlave*)((iCapturedChannel.iChanPtr)->GetChannelPtr()))->ReleaseChannel();
    else if((iCapturedChannel.iChanPtr)->GetChanType() == DIicBusChannel::ESlave)
        r = ((DIicBusChannelSlave*)((iCapturedChannel.iChanPtr)->GetChannelPtr()))->ReleaseChannel();
    //After release channel, reset iCapturedChan
    iCapturedChannel.iChanPtr = NULL;
    iCapturedChannel.iChannelId = 0;
#endif
    return r;
	}

void DChannelIicClient::DoCancel(TInt aMask)
	{
// Cancel an outstanding request.
	CLIENT_PRINT(("DChannelIicClient::DoCancel invoked with aMask=0x%x\n", aMask));

	// inline void CancelAsyncOperation(TRequestStatus* aStatus, TInt aBusId)	{TInt* parms[2]; parms[0]=(TInt*)aStatus; parms[1]=(TInt*)aBusId;DoCancel((TInt)&parms[0]);}
	// aMask has the address on TInt* parms[2]
	// parms[0] = TRequestStatus pointer
	// parms[1] = Bus Identifier
	TInt* parms[2];
	TInt r=Kern::ThreadRawRead(iClient,(TAny*)aMask,&(parms[0]),2*sizeof(TInt*));
	if(r!=KErrNone)
		{
		CLIENT_PRINT(("DChannelIicClient::DoCancel ERROR - Can't read parms[]\n"));
		return;	// Can't proceed if can't access request parameters
		}
	CLIENT_PRINT(("DChannelIicClient::DoCancel - TRequestStatus 0x%x, BusID = 0x%x\n",parms[0],parms[1]));

	TTransStatusPair* searchPair = new TTransStatusPair();
	TTransCbPair* cbPair = new TTransCbPair();
	searchPair->iReq = (TRequestStatus*)(parms[0]);

	GetWriteAccess();
	Lock();

	TInt pairIndexByStatus = iTransStatArrayByStatus.FindInOrder(searchPair,TransStatusOrderByStatus);
	CLIENT_PRINT(("DChannelIicClient::DoCancel - pairIndexByStatus=0x%x\n",pairIndexByStatus));
	TInt pairIndexByTrans = KErrNotFound;

	if(pairIndexByStatus<0)
		{
		// If the TRequestStatus object is not found then either the value was invalid or
		// the object may already have been completed.
		FreeWriteAccess();
		Unlock();
		CLIENT_PRINT(("DChannelIicClient::DoCancel() - (status) FindInOrder returned %d (status=0x%x)\n",pairIndexByStatus,parms[0]));
		}
	else
		{
		// The status-transaction pair exists in the status-index array - so remove it
		TTransStatusPair* pairPtrStatus = iTransStatArrayByStatus[pairIndexByStatus];
		iTransStatArrayByStatus.Remove(pairIndexByStatus);

		pairIndexByTrans = iTransStatArrayByTrans.FindInOrder(pairPtrStatus,TransStatusOrderByTrans);
		CLIENT_PRINT(("DChannelIicClient::DoCancel - pairIndexByTrans=0x%x\n",pairIndexByTrans));
		if(pairIndexByTrans>=0)
			{
			iTransStatArrayByTrans.Remove(pairIndexByTrans);
			}
		FreeWriteAccess();
		Unlock();

		CLIENT_PRINT(("DChannelIicClient::DoCancel pairPtrStatus=0x%x\n", pairPtrStatus));

		// Allow the bus to perform any required processing
		TIicBusTransaction* trans = pairPtrStatus->iTrans;
		CLIENT_PRINT(("DChannelIicClient::CancelTransaction - invoking with busId=0x%x, trans=0x%x\n",(TInt)(parms[1]),trans));
		r = CancelTransaction((TInt)(parms[1]), trans);
		cbPair->iTrans=trans;
		TInt cbIndex = iTransCbArrayByTrans.FindInOrder(cbPair,TransCbOrderByTrans);
		TTransCbPair* theCbPair = iTransCbArrayByTrans[cbIndex];
		TIicBusCallback* cb= (iTransCbArrayByTrans[cbIndex])->iCb;
		iTransCbArrayByTrans.Remove(cbIndex);
		
		// Complete the TRequestStatus object according to the returned value
		TRequestStatus* status= (TRequestStatus*)(parms[0]);
		Kern::RequestComplete(iClient, status, r);

		// Clean up
		delete cb;
		delete theCbPair;
		// We should call CleanupExtractTrans() to delete all the objects we created in ExtractTransData()
		CleanupExtractTrans(trans);
        CleanupTransaction(trans);  
		delete pairPtrStatus;
		}

	delete cbPair;
	delete searchPair;

	return;
	}


// Function to support preamble testing
void PreambleCallbackFunc(TIicBusTransaction* /*aTrans*/, TAny* aParam)
	{
	CLIENT_PRINT(("IIC Client: PreambleCallbackFunc invoked\n"));
	// aParam is the address of the client that created the transaction object
	__ASSERT_ALWAYS(aParam!=NULL,Kern::Fault("PreambleCallbackFunc, client address ==NULL",__LINE__));
	DChannelIicClient *client = (DChannelIicClient*)aParam;
	__ASSERT_ALWAYS(client->iClient!=NULL,Kern::Fault("PreambleCallbackFunc, iClient==NULL",__LINE__));
	__ASSERT_ALWAYS(client->iPreambleStatus!=NULL,Kern::Fault("PreambleCallbackFunc, iPreambleStatus==NULL",__LINE__));
	Kern::RequestComplete(client->iClient, client->iPreambleStatus, KErrNone);
	}

TIicBusTransaction* DChannelIicClient::iMultiTransac;

// Function to support multi transc testing
TIicBusTransaction* DChannelIicClient::MultiTranscCallbackFunc(TIicBusTransaction* /*aTrans*/, TAny* aParam)
	{
	CLIENT_PRINT(("IIC Client: MultiTranscCallbackFunc invoked\n"));
	// aParam is the address of the client that created the transaction object
	__ASSERT_ALWAYS(aParam!=NULL,Kern::Fault("MultiTranscCallbackFunc, client address ==NULL",__LINE__));
	DChannelIicClient *client = (DChannelIicClient*)aParam;
	__ASSERT_ALWAYS(client->iClient!=NULL,Kern::Fault("MultiTranscCallbackFunc, iClient==NULL",__LINE__));
	__ASSERT_ALWAYS(client->iMultiTranscStatus!=NULL,Kern::Fault("MultiTranscCallbackFunc, iMultiTranscStatus==NULL",__LINE__));
	Kern::RequestComplete(client->iClient, client->iMultiTranscStatus, KErrNone);
	return iMultiTransac;
	}

TInt DChannelIicClient::CleanupExtractTrans(TIicBusTransaction* aTrans)
	{
	// Clean up the data created in ExtractTransData()
	TExtractInfo *extractInfo = new TExtractInfo();
	extractInfo->iTrans = aTrans;
	TInt index = iExtractInfoArray.FindInOrder(extractInfo, ExtractInfoOrderByTrans);
	if(index >= 0)
	    {
	    delete iExtractInfoArray[index];
	    iExtractInfoArray.Remove(index);
	    }
	delete extractInfo;
	return KErrNone;
	}

TInt DChannelIicClient::ExtractTransData(TUsideTracnDesc* aUsideTrancnDesc, TIicBusTransaction*& aTrans)
	{
// Utility function to create a TIicBusTransaction object from the parameters passed by the user-side TUsideTracnDesc object

	TInt r = KErrNone;
	TUsideTracnDesc usTrans;
	r=Kern::ThreadRawRead(iClient,aUsideTrancnDesc,&usTrans,sizeof(TUsideTracnDesc));
	if(r!=KErrNone)
		{
		CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read usTrans\n"));
		return KErrGeneral;	// Can't proceed if can't access request parameters
		}
	// Ensure pointers potentially used for allocation are NULL, to facilitate cleanup
	iSpiBuf=NULL;
	iI2cBuf=NULL;
	iTfer=NULL;
	iTransPreamble=NULL;
	iFdTfer=NULL;

	// Get the header (depends on the bus type)
	TBusType busType = usTrans.iType;
	TConfigSpiBufV01 *spiBuf = NULL;
	TConfigI2cBufV01 *i2cBuf = NULL;
	// extractInfo is used to keep the bufPtr and tfer of the transaction,
	// and will later be stored in iExtractInfoArray, sorting by transaction.
	// The extractInfo object will be freed in CleanupExtractTrans.
	TExtractInfo *extractInfo = new TExtractInfo();
	TDes8* bufPtr=NULL;
	if(busType == ESpi)
		{
		if((spiBuf = new TConfigSpiBufV01()) == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - unable to allocate spiBuf\n"));
			return KErrNoMemory;
			}
		if((r=Kern::ThreadDesRead(iClient, usTrans.iHeader, *spiBuf, 0, KChunkShiftBy0 ))!=KErrNone)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read usTrans.iHeader to spiBuf\n"));
			return KErrGeneral;
			}
		bufPtr=(TDes8*)spiBuf;
		}
	else if(busType == EI2c)
		{
		if((i2cBuf = new TConfigI2cBufV01()) == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - unable to allocate i2cBuf\n"));
			return KErrNoMemory;
			}
		if((r=Kern::ThreadDesRead(iClient, usTrans.iHeader, *i2cBuf, 0, KChunkShiftBy0 ))!=KErrNone)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read usTrans.iHeader to i2cBuf\n"));
			return KErrGeneral;
			}
		bufPtr=(TDes8*)i2cBuf;
		}
	else
		{
		CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - unrecognised bus type\n"));
		return KErrGeneral;
		}
	extractInfo->iBufPtr = bufPtr;
	// Get the half-duplex transfer information
	TUsideTferDesc* usTferPtr = usTrans.iHalfDuplexTrans;
	TUsideTferDesc usTfer;
	r=Kern::ThreadRawRead(iClient,usTferPtr,&usTfer,sizeof(TUsideTferDesc));
	if(r!=KErrNone)
		{
		CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read half-duplex usTfer\n"));
		return KErrGeneral;	// Can't proceed if can't access request parameters
		}
	// Need to access the descriptor holding the information to be transferred
	TBuf8 <MAX_TRANS_LENGTH> tferData;
	r=Kern::ThreadDesRead(iClient,usTfer.iBuffer,tferData,0,KChunkShiftBy0);
	if(r!=KErrNone)
		{
		CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read half-duplex tferData\n"));
		return KErrGeneral;	// Can't proceed if can't access request parameters
		}

	TIicBusTransfer::TReqType type=(usTfer.iType == EMasterWrite)?TIicBusTransfer::EMasterWrite:TIicBusTransfer::EMasterRead;
	tfer7 = new TIicBusTransfer(type, usTfer.iBufGranularity, &tferData);
	extractInfo->iTfer = tfer7;
	// Construct the appropriate transaction object with the half-duplex information
	TUint8 transFlags = usTrans.iFlags;

	if((transFlags&KTransactionWithPreamble)&&(transFlags&KTransactionWithMultiTransc))
		{
		if(usTrans.iPreambleArg == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - ExtTrans TRequestStatus==NULL\n"));
			return KErrArgument;
			}
		if(usTrans.iMultiTranscArg == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - ExtTrans TRequestStatus==NULL\n"));
			return KErrArgument;
			}
		iPreambleStatus = (TRequestStatus*)(usTrans.iPreambleArg);
		iMultiTranscStatus = (TRequestStatus*)(usTrans.iMultiTranscArg);
		TIicBusTransactionPreambleExt* transExt;

		transExt = new TIicBusTransactionPreambleExt(bufPtr, tfer7, (TIicBusPreamble)(&PreambleCallbackFunc), this,
							(TIicBusMultiTranscCbFn)(&MultiTranscCallbackFunc), this);
		if(transExt == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't create trans\n"));
			return KErrNoMemory;	// Can't proceed if can't access request parameters
			}
		aTrans = transExt;

		}
	else if(transFlags & KTransactionWithPreamble)
		{
		// Preamble required - construct the derived-class transaction object
		if(usTrans.iPreambleArg == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - preamble TRequestStatus==NULL\n"));
			return KErrArgument;
			}
		iPreambleStatus = (TRequestStatus*)(usTrans.iPreambleArg);
		TIicBusTransactionPreamble* TransPreamble;
		TransPreamble = new TIicBusTransactionPreamble(bufPtr, tfer7, (TIicBusPreamble)(&PreambleCallbackFunc), this);
		if(TransPreamble == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't create trans\n"));
			return KErrNoMemory;	// Can't proceed if can't access request parameters
			}
		aTrans = TransPreamble;
		}
	else if(transFlags & KTransactionWithMultiTransc)
		{
		// Preamble required - construct the derived-class transaction object
		if(usTrans.iMultiTranscArg == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Multi Transc TRequestStatus==NULL\n"));
			return KErrArgument;
			}
		iMultiTranscStatus = (TRequestStatus*)(usTrans.iMultiTranscArg);
		TIicBusTransactionMultiTransc* transMultiTransc;
		transMultiTransc = new TIicBusTransactionMultiTransc(bufPtr, tfer7, (TIicBusMultiTranscCbFn)(&MultiTranscCallbackFunc), this);
		if(transMultiTransc == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't create trans\n"));
			return KErrNoMemory;	// Can't proceed if can't access request parameters
			}
		aTrans = transMultiTransc;
		}
	else
		{
		// Preamble not required
		aTrans = new TIicBusTransaction(bufPtr, tfer7);
		if(aTrans == NULL)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't create trans\n"));
			return KErrNoMemory;	// Can't proceed if can't access request parameters
			}
		}

	// If full duplex transaction is required get that information, too
	usTferPtr = usTrans.iFullDuplexTrans;
	if(usTferPtr!=NULL)
		{
		r=Kern::ThreadRawRead(iClient,usTferPtr,&usTfer,sizeof(TUsideTferDesc));
		if(r!=KErrNone)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read full-duplex usTfer\n"));
			return KErrGeneral;	// Can't proceed if can't access request parameters
			}
		// Need to access the descriptor holding the information to be transferred
		TBuf8 <MAX_TRANS_LENGTH> fdTferData;
		r=Kern::ThreadDesRead(iClient,usTfer.iBuffer,fdTferData,0,KChunkShiftBy0);
		if(r!=KErrNone)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - Can't read full-duplex tferData\n"));
			return KErrGeneral;	// Can't proceed if can't access request parameters
			}

		type=(usTfer.iType == EMasterWrite)?TIicBusTransfer::EMasterWrite:TIicBusTransfer::EMasterRead;
		r=aTrans->SetFullDuplexTrans(iFdTfer);
		if(r!=KErrNone)
			{
			CLIENT_PRINT(("DChannelIicClient::ExtractTransData ERROR - SetFullDuplexTrans returned %d\n",r));
			return r;
			}
		}
	extractInfo->iTrans = aTrans;
	iExtractInfoArray.InsertInOrder(extractInfo, ExtractInfoOrderByTrans);
	return r;
	}

#define KMaxTferTextLength 20
#define KLongNodeTestLength 15
#define KShortNodeTestLength 5
_LIT(KFullTracnHdrText,"Full duplex test");		// length = 22
#define KFullTracnHdrTextLength 16


// Create transfer list with three nodes
// All memories are allocated from the kernel heap and referenced by class members
// DeleteFullDuplexTest should be called to release memory after use.
// List created here will be assigned to iHalfDuplexTrans in TIicBusTransaction
// If aNodeLength3 = 0, only return a 2 nodes transfer
TInt DChannelIicClient::CreateTransferListHalfDuplex(
			TIicBusTransfer::TReqType aNodeDir1, TInt aNodeLength1,
			TIicBusTransfer::TReqType aNodeDir2, TInt aNodeLength2,
			TIicBusTransfer::TReqType aNodeDir3, TInt aNodeLength3)
	{
	buf1 = HBuf8::New(KMaxTferTextLength);
	buf2 = HBuf8::New(KMaxTferTextLength);
	buf3 = HBuf8::New(KMaxTferTextLength);
	tfer1 = new TIicBusTransfer(aNodeDir1,8,buf1);
	tfer2 = new TIicBusTransfer(aNodeDir2,8,buf2);
	tfer3 = new TIicBusTransfer(aNodeDir3,8,buf3);

	if(buf1 == NULL||buf2 == NULL||buf3 == NULL||
		tfer1 == NULL||tfer2 == NULL||tfer3 == NULL)
		{
		delete buf1; delete buf2; delete buf3;
		delete tfer1; delete tfer2;	delete tfer3;
		return KErrNoMemory;
		}

	TInt i;
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength1); i++) buf1->Append('*');
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength2); i++) buf2->Append('*');
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength3); i++) buf3->Append('*');

	tfer1->LinkAfter(tfer2);

	//allow two nodes
	if(aNodeLength3>0)
		{
		tfer2->LinkAfter(tfer3);
		}

	return KErrNone;

	}

// Create transfer list with three nodes
// All memories are allocated from the kernel heap and referenced by class members
// DeleteFullDuplexTest should be called to release memory after use.
// List created here will be assigned to iFullDuplexTrans in TIicBusTransaction
// If aNodeLength3 = 0, only return a 2 nodes transfer
TInt DChannelIicClient::CreateTransferListFullDuplex(
			TIicBusTransfer::TReqType aNodeDir1, TInt aNodeLength1,
			TIicBusTransfer::TReqType aNodeDir2, TInt aNodeLength2,
			TIicBusTransfer::TReqType aNodeDir3, TInt aNodeLength3)
	{
	buf4 = HBuf8::New(KMaxTferTextLength);
	buf5 = HBuf8::New(KMaxTferTextLength);
	buf6 = HBuf8::New(KMaxTferTextLength);
	tfer4 = new TIicBusTransfer(aNodeDir1,8,buf4);
	tfer5 = new TIicBusTransfer(aNodeDir2,8,buf5);
	tfer6 = new TIicBusTransfer(aNodeDir3,8,buf6);

	if(buf4 == NULL||buf5 == NULL||buf6 == NULL||
		tfer4 == NULL||tfer5 == NULL||tfer6 == NULL)
		{
		delete buf4; delete buf5; delete buf6;
		delete tfer4; delete tfer5;	delete tfer6;
		return KErrNoMemory;
		}

	TInt i;
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength1); i++) buf4->Append('*');
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength2); i++) buf5->Append('*');
	for(i=0; (i<KMaxTferTextLength)&&(i<aNodeLength3); i++) buf6->Append('*');

	tfer4->LinkAfter(tfer5);

	//allow two nodes
	if(aNodeLength3>0)
		{
		tfer5->LinkAfter(tfer6);
		}

	return KErrNone;

	}

// Delete transaction and all allocated transfers and buffers
TInt DChannelIicClient::DeleteFullDuplexTest(TIicBusTransaction *aTrans)
	{
	delete buf1; delete buf2; delete buf3;
	delete tfer1; delete tfer2; delete tfer3;

	delete buf4; delete buf5; delete buf6;
	delete tfer4; delete tfer5; delete tfer6;

	delete header;
	delete aTrans;

	return KErrNone;
	}

// Do full duplex creation test
TInt DChannelIicClient::DoCreateFullDuplexTransTest(TInt aTestType)
	{
	CLIENT_PRINT(("DChannelIicClient::DoCreateFullDuplexTransTest starts\n"));

	TInt r=KErrNone;
	switch(aTestType)
		{
		case RBusDevIicClient::ETestValidFullDuplexTrans:
			{
			// equal length, opposite transfer direction
			r = CreateTransferListHalfDuplex(
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength);
			if(r!=KErrNone) break;
			r = CreateTransferListFullDuplex(
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength);
			if(r!=KErrNone) break;
			break;
			}
		case RBusDevIicClient::ETestInvalidFullDuplexTrans1:
			{
			// equal length, same transfer direction
			r = CreateTransferListHalfDuplex(
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength);
			if(r!=KErrNone) break;
			r = CreateTransferListFullDuplex(
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength);
			if(r!=KErrNone) break;
			break;
			}
		case RBusDevIicClient::ETestInvalidFullDuplexTrans2:
			{
			// different, opposite transfer direction
			r = CreateTransferListHalfDuplex(
						TIicBusTransfer::EMasterWrite, KShortNodeTestLength,
						TIicBusTransfer::EMasterRead, KShortNodeTestLength,
						TIicBusTransfer::EMasterWrite, KShortNodeTestLength);
			if(r!=KErrNone) break;
			r = CreateTransferListFullDuplex(
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength);
			if(r!=KErrNone) break;
			break;
			}
		case RBusDevIicClient::ETestLastNodeFullDuplexTrans:
			{
			// different length for the last node
			r = CreateTransferListHalfDuplex(
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KShortNodeTestLength);
			if(r!=KErrNone) break;
			r = CreateTransferListFullDuplex(
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength);
			if(r!=KErrNone) break;
			break;
			}
		case RBusDevIicClient::ETestDiffNodeNoFullDuplexTrans:
			{
			// equal length, opposite transfer direction
			r = CreateTransferListHalfDuplex(
						TIicBusTransfer::EMasterWrite, KLongNodeTestLength,
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KShortNodeTestLength);
			if(r!=KErrNone) break;
			r = CreateTransferListFullDuplex(
						TIicBusTransfer::EMasterRead, KLongNodeTestLength,
						TIicBusTransfer::EMasterWrite, KShortNodeTestLength,
						TIicBusTransfer::EMasterRead, 0);
			if(r!=KErrNone) break;
			break;
			}


		default:
			break;
		}

	header = HBuf8::New(KFullTracnHdrTextLength);
	TIicBusTransaction *Trans = new TIicBusTransaction(header,tfer1);

	if((r!=KErrNone) || (header == NULL) || (Trans == NULL))
		{
		CLIENT_PRINT(("DChannelIicClient::DoCreateFullDuplexTransTest ERROR - failed to allocate the necessary memory\n"));
		DeleteFullDuplexTest(Trans);
		return KErrNoMemory;
		}

	header->Copy(KFullTracnHdrText);

	TInt TestResult = Trans->SetFullDuplexTrans(tfer4);

	CLIENT_PRINT(("DChannelIicClient::DoCreateFullDuplexTransTest IIC after SetFullDuplexTrans TestResult =%d\n", TestResult));

	r = DeleteFullDuplexTest(Trans);

	return TestResult;

	}


TInt DChannelIicClient::CreateDefaultSpiBuf(TConfigSpiBufV01*& aBuf)
// Utility function to create a buffer for the SPI bus
	{
	TInt r=CreateSpiBuf(aBuf, ESpiWordWidth_8, 100000, ESpiPolarityLowRisingEdge, 100 ,ELittleEndian, EMsbFirst, 10, ESpiCSPinActiveLow);
	return r;
	}

// DoPriorityTest does the following actions:
// 1. switch the bus (only use SPI test PSL) to priority test mode
// 2. create 5 test transactions with different priorities and 1 blocking transaction
// 3. enable blocking in test channel
//     we can only block the test channel, we cannot suspend the bus controller
// 3. send blocking transaction to the test channel
//     the blocking transaction is just normal transaction.
//     the test channel will be blocked once the first transaction is arrived
// 4. send test transactions in opposite order to their priority
// 5. unblock test channel
// 6. read test result from channel
// 7. switch the bus to normal mode
TInt DChannelIicClient::DoPriorityTest(TInt aBusId)
	{
	TInt TestResult=KErrNone;
	// Use the IIC StaticExtension interface to pass the request to the bus implementation
	// To support testing, any values of aId for StaticExtension must be shifted left one place
	TUint testId = ((TUint)(RBusDevIicClient::ECtlIoPriorityTest))<<1;
	TInt r = KErrNone;

	r = StaticExtension(aBusId, testId, NULL, NULL);
	__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
	if(r == KErrNone)
		{
		buf1 = HBuf8::New(1);
		buf2 = HBuf8::New(1);
		buf3 = HBuf8::New(1);
		buf4 = HBuf8::New(1);
		buf5 = HBuf8::New(1);
		//buffer for blocking transaction
		buf6 = HBuf8::New(1);

		if(buf1 == NULL||buf2 == NULL||buf3 == NULL||buf4 == NULL||buf5 == NULL||buf6 == NULL)
			{
			delete buf1; delete buf2; delete buf3; delete buf4; delete buf5; delete buf6;
			r = StaticExtension(aBusId, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			return KErrNoMemory;
			}
		tfer1 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf1);
		tfer2 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf2);
		tfer3 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf3);
		tfer4 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf4);
		tfer5 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf5);
		//transfer for blocking transaction
		tfer6 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf6);

		if(tfer1 == NULL||tfer2 == NULL||tfer3 == NULL||tfer4 == NULL||tfer5 == NULL||tfer6 == NULL)
			{
			delete buf1; delete buf2; delete buf3; delete buf4; delete buf5; delete buf6;
			delete tfer1; delete tfer2; delete tfer3; delete tfer4; delete tfer5; delete tfer6;
			r = StaticExtension(aBusId, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			return KErrNoMemory;
			}

		TConfigSpiBufV01* spiHeader1 = NULL;
		TConfigSpiBufV01* spiHeader2 = NULL;
		TConfigSpiBufV01* spiHeader3 = NULL;
		TConfigSpiBufV01* spiHeader4 = NULL;
		TConfigSpiBufV01* spiHeader5 = NULL;
		TConfigSpiBufV01* spiHeaderBlock = NULL; 		//header for blocking transaction


		TInt r = CreateDefaultSpiBuf(spiHeader1);
		if(r == KErrNone)	r = CreateDefaultSpiBuf(spiHeader2);
		if(r == KErrNone)	r = CreateDefaultSpiBuf(spiHeader3);
		if(r == KErrNone)	r = CreateDefaultSpiBuf(spiHeader4);
		if(r == KErrNone)	r = CreateDefaultSpiBuf(spiHeader5);
		//header for blocking transaction
		if(r == KErrNone)	r = CreateDefaultSpiBuf(spiHeaderBlock);

		if(r != KErrNone||spiHeader1 == NULL||spiHeader2 == NULL||spiHeader3 == NULL||spiHeader4 == NULL||spiHeader5 == NULL||spiHeaderBlock == NULL)
			{
			delete buf1; delete buf2; delete buf3; delete buf4; delete buf5; delete buf6;
			delete tfer1; delete tfer2; delete tfer3; delete tfer4; delete tfer5; delete tfer6;
			delete spiHeader1; delete spiHeader2; delete spiHeader3; delete spiHeader4; delete spiHeader5; delete spiHeaderBlock;
			r = StaticExtension(aBusId, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			return KErrNoMemory;
			}

		TIicBusTransaction* Transc1; Transc1 = new TIicBusTransaction(spiHeader1,tfer1, KPriorityTestPrio[0]);
		TIicBusTransaction* Transc2; Transc2 = new TIicBusTransaction(spiHeader2,tfer2, KPriorityTestPrio[1]);
		TIicBusTransaction* Transc3; Transc3 = new TIicBusTransaction(spiHeader3,tfer3, KPriorityTestPrio[2]);
		TIicBusTransaction* Transc4; Transc4 = new TIicBusTransaction(spiHeader4,tfer4, KPriorityTestPrio[3]);
		TIicBusTransaction* Transc5; Transc5 = new TIicBusTransaction(spiHeader5,tfer5, KPriorityTestPrio[4]);
		//blocking transaction
		TIicBusTransaction* TranscBlock; TranscBlock = new TIicBusTransaction(spiHeaderBlock,tfer6, KPriorityTestPrio[5]);

		if(Transc1 == NULL||Transc2 == NULL||Transc3 == NULL||Transc4 == NULL||Transc5 == NULL||TranscBlock == NULL)
			{
			delete buf1; delete buf2; delete buf3; delete buf4; delete buf5; delete buf6;
			delete tfer1; delete tfer2; delete tfer3; delete tfer4; delete tfer5; delete tfer6;
			delete spiHeader1; delete spiHeader2; delete spiHeader3; delete spiHeader4; delete spiHeader5; delete spiHeaderBlock;
			delete Transc1; delete Transc2; delete Transc3; delete Transc4; delete Transc5; delete TranscBlock;
			r = StaticExtension(aBusId, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			return KErrNoMemory;
			}

		//dummy call back func is provided for asyn call
		TIicBusCallback* cb = new TIicBusCallback(DummyCallbackFunc, this, iDfcQue, 5); // 5 arbitrary

		// block the device channel. the channel will not be blocked until the first transaction arrive the channel
		// To support testing, any values of aId for StaticExtension must be shifted left one place
		TUint testId=((TUint)RBusDevIicClient::ECtlIoBlockReqCompletion)<<1;
		r = StaticExtension(aBusId, testId, NULL, NULL);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));

		r = QueueTransaction(aBusId, TranscBlock, cb);  //send TranscBlock to block the channel
		// send ordered transactions
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));

		r = QueueTransaction(aBusId, Transc1, cb);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
		r = QueueTransaction(aBusId, Transc2, cb);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
		r = QueueTransaction(aBusId, Transc3, cb);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
		r = QueueTransaction(aBusId, Transc4, cb);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
		r = QueueTransaction(aBusId, Transc5, cb);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));

		// unblock device channel
		testId=((TUint)RBusDevIicClient::ECtlIoUnblockReqCompletion)<<1;
		r = StaticExtension(aBusId, testId, NULL, NULL);
		__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));

		#define KPriorityTestGetResultRetry 3
		for(TInt i=0; i<KPriorityTestGetResultRetry ; i++)
			{
			NKern::Sleep(500);
			testId=((TUint)RBusDevIicClient::EGetTestResult)<<1;
			TestResult = StaticExtension(aBusId, testId, NULL, NULL);
			if(TestResult!=KErrNotReady) break;
			}

		cb->Cancel();
		delete cb;
		delete buf1; delete buf2; delete buf3; delete buf4; delete buf5; delete buf6;
		delete tfer1; delete tfer2; delete tfer3; delete tfer4; delete tfer5; delete tfer6;
		delete spiHeader1; delete spiHeader2; delete spiHeader3; delete spiHeader4; delete spiHeader5; delete spiHeaderBlock;
		delete Transc1; delete Transc2; delete Transc3; delete Transc4; delete Transc5; delete TranscBlock;

		}
	r = StaticExtension(aBusId, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
	return TestResult;
	}

TInt DChannelIicClient::ConstructTransactionOne(TIicBusTransaction*& aTrans)
	{
	// Transaction is to contain three transfers, with data defined by
	// KTransOneTferOne[], KTransOneTferTwo[], KTransOneTferThree[]
	buf1 = HBuf8::New(21);
	buf2 = HBuf8::New(8);
	buf3 = HBuf8::New(6);
	tfer1 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf1);
	tfer2 = new TIicBusTransfer(TIicBusTransfer::EMasterRead,8,buf2);
	tfer3 = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf3);
	TInt r = CreateDefaultSpiBuf(spiHeader);
	if((r != KErrNone)||(spiHeader == NULL)||(buf1 == NULL)||(buf2 == NULL)||(buf3 == NULL)||(tfer1 == NULL)||(tfer2 == NULL)||(tfer3 == NULL))
		{
		CLIENT_PRINT(("DChannelIicClient::ConstructTransactionOne ERROR - failed to allocate the necessary memory\n"));
		delete buf1;
		delete buf2;
		delete buf3;
		delete tfer1;
		delete tfer2;
		delete tfer3;
		delete spiHeader;
		delete aTrans;
		return KErrNoMemory;
		}
	aTrans = new TIicBusTransaction(spiHeader,tfer1);
	buf1->Copy(&(KTransOneTferOne[0]),21);
	buf2->Copy(&(KTransOneTferTwo[0]),8);
	buf3->Copy(&(KTransOneTferThree[0]),6);
	tfer1->LinkAfter(tfer2);
	tfer2->LinkAfter(tfer3);
	return KErrNone;
	}

void DChannelIicClient::CleanupTransactionOne(TIicBusTransaction*& aTrans)
	{
	// Release the allocated memory
	delete buf1;
	buf1=NULL;
	delete buf2;
	buf2=NULL;
	delete buf3;
	buf3=NULL;
	delete tfer1;
	tfer1=NULL;
	delete tfer2;
	tfer2=NULL;
	delete tfer3;
	tfer3=NULL;
	delete spiHeader;
	spiHeader=NULL;
	delete aTrans;
	aTrans=NULL;
	}


void DChannelIicClient::CleanupTransaction(TIicBusTransaction*& aTrans)
	{
	delete iSpiBuf;
	iSpiBuf=NULL;
	delete iI2cBuf;
	iI2cBuf=NULL;
	TIicBusTransfer* currTfer = iTfer;
	while(currTfer)
		{
		TIicBusTransfer* nextTfer = (TIicBusTransfer*)(currTfer->Next());
		delete currTfer;
		if(nextTfer)
			currTfer = nextTfer;
		else
			currTfer = NULL;
		};
	iTfer=NULL;
	currTfer = iFdTfer;
	while(currTfer)
		{
		TIicBusTransfer* nextTfer = (TIicBusTransfer*)(currTfer->Next());
		delete currTfer;
		if(nextTfer)
			currTfer = nextTfer;
		else
			currTfer = NULL;
		};
	iFdTfer=NULL;
	if(aTrans!=NULL)
		{
		delete aTrans;
		aTrans=NULL;
		}
	if(iTransPreamble!=NULL)
		{
		delete iTransPreamble;
		iTransPreamble=NULL;
		}
	}

void DChannelIicClient::TransModifCallback(TIicBusTransaction* /*aTrans*/, TInt /*aBusId*/, TInt aResult, TAny* aParam)
	{
	// Callback function used to test re-use of transaction and transfer buffers
	// aParam is the address of the simulated client driver
	DChannelIicClient* channel = (DChannelIicClient*)aParam;
	TTransBufReuseData* reuseData = &(channel->iTransBufReuseData);

	// Since the transaction is no longer queued, should be able to modify the transfer and transaction content
	channel->TestTransModification(reuseData->iTransaction, reuseData->iHdTfer, reuseData->iFdTfer, reuseData->iHdr);

	// Complete the user's request, delete objects allocated for this test and return
	Kern::RequestComplete(channel->iClient, channel->iStatus, aResult);
	delete reuseData->iCallback;	// Must do this before deleting the Transaction, in CleanupTransaction
	channel->CleanupTransaction(channel->iTrans);
	return;
	}


void DChannelIicClient::TestTransModification(TIicBusTransaction* aTransaction,
											  TIicBusTransfer* aHdTfer,
											  TIicBusTransfer* aFdTfer,
											  TDes8* aHdr)
	{
	// Function to test that the content of Transaction and Transfer objects can be modified
	// This assumes that the Transaction is in the appropriate state (EFree) - otherwise, the code will assert
	// This function also assumes that transaction has aleady added the half-duplex and full-duplex transfers
	// that are passed in as arguments, and that the transfers lists are non-NULL
	// The original type of the transfers (read, write) are ignored, since it is not of interest in this test -
	// instead, what is important is to ensure that the half-duplex and full-duplex transfer types are in opposing
	// directions - so the types are explicitly set in this test.
	//
	TDes8* origBuf = NULL;
	TInt8 origGranularity = 0;

	// Create a buffer for use in this function
	_LIT(temporaryText,"Temporary Text");
	TBuf8<15> tempBuf_8;
	tempBuf_8.Copy(temporaryText);

	// Test modification of the two transfer lists while still part of the transaction
	origBuf = (TDes8*)(aHdTfer->GetBuffer());
	origGranularity = aHdTfer->WordWidth();
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, &tempBuf_8);
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, origBuf);

	origBuf = (TDes8*)(aFdTfer->GetBuffer());
	origGranularity = aFdTfer->WordWidth();
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, &tempBuf_8);
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, origBuf);

	// Test transfers can be removed from the transaction
	aTransaction->RemoveHalfDuplexTrans();
	aTransaction->RemoveFullDuplexTrans();

	// Test modification of the two transfer lists while not part of a transaction
	origBuf = (TDes8*)(aHdTfer->GetBuffer());
	origGranularity = aHdTfer->WordWidth();
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, &tempBuf_8);
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, origBuf);

	origBuf = (TDes8*)(aFdTfer->GetBuffer());
	origGranularity = aFdTfer->WordWidth();
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, &tempBuf_8);
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, origBuf);

	// Test transfers can be re-added to the transaction
	aTransaction->SetHalfDuplexTrans(aHdr,aHdTfer);
	aTransaction->SetFullDuplexTrans(aFdTfer);

	// Test modification of the two transfer lists now re-added to the transaction
	origBuf = (TDes8*)(aHdTfer->GetBuffer());
	origGranularity = aHdTfer->WordWidth();
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, &tempBuf_8);
	aHdTfer->SetTransferData(TIicBusTransfer::EMasterRead, origGranularity, origBuf);

	origBuf = (TDes8*)(aFdTfer->GetBuffer());
	origGranularity = aFdTfer->WordWidth();
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, &tempBuf_8);
	aFdTfer->SetTransferData(TIicBusTransfer::EMasterWrite, origGranularity, origBuf);

	return;
	}

TInt DChannelIicClient::DoControl(TInt aId, TAny* a1, TAny* a2)
	{
	CLIENT_PRINT(("DChannelIicClient::DoControl invoked with aId=0x%x, a1=0x%x, a2=0x%x\n", aId,a1,a2));
	TInt r=KErrNone;
	// To support testing, any values of aId for StaticExtension must be shifted left one place
	// and for a Slave tests, the two msbs must be zero
	TInt ctrlIoVal = 0;
	if((aId & KTestMasterControlIo) == KTestMasterControlIo)
		ctrlIoVal = (aId << 1);
	if((aId & KTestSlaveControlIo) == KTestSlaveControlIo)
		ctrlIoVal = (aId << 1) & 0x3FFFFFFF;
	switch(aId)
		{
		case(RBusDevIicClient::EQTransSync):
			{
			// a1 specifies Bus Realisation Config to use
			// a2 is a pointer to TUsideTracnDesc
			TIicBusTransaction* trans = NULL;
			TIicBusTransfer* tfer = NULL;
			TConfigSpiBufV01 *spiBuf = NULL;
			
			//Read the transaction header to determin if it is a multi-transaction type
			TUsideTracnDesc usTrans;

			if((Kern::ThreadRawRead(iClient,a2,&usTrans,sizeof(TUsideTracnDesc)))!=KErrNone)
				{
				CLIENT_PRINT(("DChannelIicClient::DoControl ERROR - Can't read iHeader to spiBuf\n"));
				return KErrGeneral;
				}

			if((usTrans.iFlags)&KTransactionWithMultiTransc)
				{
				// Since we are testing a multi-transaction, create another transaction object iMultiTransac,
				// to represent the delayed part of the multi-transaction. After the preliminary
				// transaction(passed from t_iic, with one read transfer) has been performed, 
				// the IIC code will find that it is part of a 
				// multi-transaction; it will call the callback for the transaction(set as MultiTranscCallbackFunc,
				// in ExtractTransData) and this will return a pointer to the next part of the multi-transaction
				// to be performed(iMultiTransac). It will then immediately pass this transaction object
				// to the PSL for processing - before considering any other transactions that have been 
				// requested, and without completing the multi-transaction request(this is done once 
				// iMultiTransac has been processed)
				buf1 = HBuf8::New(1);
				spiBuf = new TConfigSpiBufV01();
				if(buf1 == NULL||spiBuf == NULL) {delete buf1;delete spiBuf; return KErrNoMemory;}


				if((r=Kern::ThreadDesRead(iClient, usTrans.iHeader, *spiBuf, 0, KChunkShiftBy0 ))!=KErrNone)
					{
					CLIENT_PRINT(("DChannelIicClient::DoControl ERROR - Can't read iHeader to spiBuf\n"));
					return KErrGeneral;
					}

				tfer = new TIicBusTransfer(TIicBusTransfer::EMasterWrite,8,buf1);
				if(tfer == NULL) {delete buf1; delete spiBuf; return KErrNoMemory;}

				iMultiTransac = new TIicBusTransaction((TDes8*)spiBuf, tfer);
				if(iMultiTransac == NULL) {delete buf1; delete spiBuf; delete tfer; return KErrNoMemory;}
				}
			r = ExtractTransData((TUsideTracnDesc*)a2, trans);
			if(r!=KErrNone)
				{
				CLIENT_PRINT(("DChannelIicClient::DoControl ERROR - ExtractTransData returned %d\n",r));
				return r;
				}
			CLIENT_PRINT(("DChannelIicClient::DoControl invoking (synchronous) QueueTransaction with busId=0x%x, trans=0x%x\n",(TUint32)a1,trans));

			r = QueueTransaction((TUint32)a1, trans);
			CleanupExtractTrans(trans);
			CleanupTransaction(trans);
			if((usTrans.iFlags)&KTransactionWithMultiTransc)
				{
				delete buf1;
				delete spiBuf;
				delete tfer;
				delete iMultiTransac;
				}
			break;
			}
		case(RBusDevIicClient::ECtlIoBlockReqCompletion):
		case(RBusDevIicClient::ECtlIoUnblockReqCompletion):
		case(RBusDevIicClient::ECtlIoDeRegChan):
			{
			// a1 specifies Bus Realisation Config to use
			CLIENT_PRINT(("DChannelIicClient::DoControl invoking StaticExtension with aId=%d, busId=0x%x\n",aId,(TUint32)a1));
			// Use the IIC StaticExtension interface to pass the request to the bus implementation
			r = StaticExtension((TUint32)a1, (TUint)ctrlIoVal, NULL, NULL);
			break;
			}
		case(RBusDevIicClient::ECtlIoTestFullDuplexTrans):
			{
			// a1 specifies Bus Realisation Config to use
			CLIENT_PRINT(("DChannelIicClient::DoControl invoking StaticExtension with aId=%d, busId=0x%x\n",aId,(TUint32)a1));
			r = DoCreateFullDuplexTransTest((TInt)a2);
			break;
			}
		case(RBusDevIicClient::ECtlIoPriorityTest):
			{
			// a1 specifies Bus Realisation Config to use
			CLIENT_PRINT(("DChannelIicClient::DoControl invoking StaticExtension with aId=%d, busId=0x%x\n",aId,(TUint32)a1));
			r = DoPriorityTest((TUint32)a1);
			break;
			}

		case(RBusDevIicClient::ECtlIoTracnOne):
			{
			// a1 specifies Bus Realisation Config to use
			CLIENT_PRINT(("DChannelIicClient::StaticExtension invoking StaticExtension with ctrlIoVal=%d, busId=0x%x\n",aId,(TUint32)a1));
			// Use the IIC StaticExtension interface to pass the request to the bus implementation
			r = StaticExtension((TUint32)a1, (TUint)ctrlIoVal, NULL, NULL);
			__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("StaticExtension",__LINE__));
			if(r == KErrNone)
				{
				// Create then send (synchronously) Transaction One
				r = ConstructTransactionOne(iTrans);
				__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
				r = QueueTransaction((TUint32)a1, iTrans);
				__ASSERT_ALWAYS(r == KErrNone,Kern::Fault("DoControl",__LINE__));
				CleanupTransactionOne(iTrans);
				}
			r = StaticExtension((TUint32)a1, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			break;
			}
		case(RBusDevIicClient::ECtlIoSetTimeOutFlag):
			{
			CLIENT_PRINT(("DChannelIicClient::DoControl instruct the bus that it is to simulate a slave timeout"));
			// To support testing, function index passed to StaticExtension must be shifted one place to the left
			TUint testIndex = ((TUint)RBusDevIicClient::ECtlIoSetTimeOutFlag)<<1;;
			r = StaticExtension((TUint32)a1, testIndex, NULL, NULL);
			break;
			}
		case(RBusDevIicClient::ECtlIoNone):
			{
			CLIENT_PRINT(("DChannelIicClient::DoControl Return the bus to its default test state"));
			r = StaticExtension((TUint32)a1, (TUint)RBusDevIicClient::ECtlIoNone, NULL, NULL);
			break;
			}

// Support for MasterSlave processing

		case(RBusDevIicClient::ECaptureChanSync):
			{
			// a1 is a pointer to the TDes8* aConfigHdr
			// a2 is a pointer to TInt* parms[2], where:
			// parms[0]=(TInt*)aBusId;
			// parms[1]=&aChannelId;
			//
			TInt* parms[2];
			r=Kern::ThreadRawRead(iClient,a2,&(parms[0]),2*sizeof(TInt*));
			if(r!=KErrNone)
				break;	// Can't proceed if can't access request parameters
			//
		  	TInt hdrSize = Kern::ThreadGetDesLength(iClient,a1);
			CLIENT_PRINT(("DChannelIicSlaveClient::DoControl hdrSize = 0x%x\n",hdrSize));
  			if (hdrSize<=0)
				{
				CLIENT_PRINT(("DChannelIicSlaveClient::DoControl ERROR, hdrSize is invalid\n"));
 				return KErrArgument;
				}
			if((iConfigHdr = HBuf8::New(hdrSize)) == NULL)
				return KErrNoMemory;
			r = Kern::ThreadDesRead(iClient,a1,*iConfigHdr,0);
			if(r!=KErrNone)
				{
				delete iConfigHdr;
				return r;
				}
			// Store the address of the user-side variable to update with the ChannelId
			iClientChanId=parms[1];

			CLIENT_PRINT(("DChannelIicSlaveClient::DoControl invoking (synchronous) CaptureChannel\n"));
			r = CaptureChannel((TInt)(parms[0]), iConfigHdr, iNotif, iChannelId);
			if(r != KErrNone)
			    delete iConfigHdr;
			CLIENT_PRINT(("DChannelIicSlaveClient::DoControl CaptureChannelgave iChannelId=0x%x\n",iChannelId));

			TInt r=Kern::ThreadRawWrite(iClient,iClientChanId,&iChannelId,sizeof(TInt));
			(void)r;	// Silence the compiler

			break;
			}

		case(RBusDevIicClient::EReleaseChan):
			{
			// a1 represents TInt aChannelId
			CLIENT_PRINT(("DChannelIicSlaveClient::DoControl invoking ReleaseChannel\n"));
			r = ReleaseChannel((TInt)a1);
			delete iConfigHdr;
			break;
			}

		case(RBusDevIicClient::EInitSlaveClient):
			{
			r=InitSlaveClient();
			break;
			}
		
#ifdef STANDALONE_CHANNEL		
        case(RBusDevIicClient::ETestIicChannelInlineFunc):
            {  
            TTestIicChannelInterface channelInterface(DIicBusChannel::EMaster, DIicBusChannel::EI2c, DIicBusChannel::EHalfDuplex);
            r = channelInterface.TestInterface();
            break;         
            }
#endif
        
        default:
			{
			CLIENT_PRINT(("DChannelIicClient::DoControl - unrecognised value for aId=0x%x\n",aId));
			r=KErrArgument;
			break;
			}
		}
	return r;
	}

TInt DChannelIicClient::DoRequest(TInt aId, TRequestStatus* aStatus, TAny* a1, TAny* a2)
	{
	CLIENT_PRINT(("DChannelIicClient::DoRequest invoked with aId=0x%x, aStatus=0x%x, a1=0x%x, a2=0x%x\n", aId,aStatus,a1,a2));

	TInt r=KErrNone;
	switch(aId)
		{
		case(RBusDevIicClient::EQTransAsync):
			{
			// a1 specifies Bus Realisation Config to use
			// a2 is a pointer to TIicBusTransaction
			TIicBusTransaction* trans = NULL;
			r = ExtractTransData((TUsideTracnDesc*)a2, trans);
			if(r!=KErrNone)
				{
				CLIENT_PRINT(("DChannelIicClient::DoRequest ERROR - ExtractTransData returned %d\n",r));
				return r;
				}
			// Create TIicBusCallback object
			TIicBusCallback* cb = new TIicBusCallback(AsyncCallbackFunc, this, iDfcQue, 5); // 5 arbitrary
			TTransCbPair* cbPair = new TTransCbPair();
			cbPair->iCb=cb;
			cbPair->iTrans=trans;
			// Create an entry in the RPointerArray for TRequestStatus - TIicBusTransaction pairs
			TTransStatusPair* pair = new TTransStatusPair();
			pair->iReq=aStatus;
			pair->iTrans=trans;
			r=InsertPairs(pair,cbPair);
			if(r!=KErrNone)
				{
				CLIENT_PRINT(("DChannelIicClient::DoRequest ERROR - InsertInOrder returned %d\n",r));
				return r;
				}
			CLIENT_PRINT(("DChannelIicClient::DoRequest invoking (asynchronous) QueueTransaction with busId=0x%x, trans=0x%x, cb=0x%x\n",(TUint32)a1,trans,cb));
			r = QueueTransaction((TUint32)a1, trans, cb);
			if(r!=KErrNone)
				{
				// The transaction was not queued - since it will not be completed asynchronously, need to remove it here
				GetWriteAccess();
				Lock();
				TInt pairIndex=iTransStatArrayByTrans.FindInOrder(pair,TransStatusOrderByTrans);
				__ASSERT_ALWAYS(pairIndex>=0,Kern::Fault("IIC Client, DoRequest, EQTransAsync ByTrans pairIndex<0",__LINE__));
				iTransStatArrayByTrans.Remove(pairIndex);
				pairIndex = iTransStatArrayByStatus.FindInOrder(pair,TransStatusOrderByStatus);
				__ASSERT_ALWAYS(pairIndex>=0,Kern::Fault("IIC Client, DoRequest, EQTransAsync ByStatus pairIndex<0",__LINE__));
				iTransStatArrayByStatus.Remove(pairIndex);
				pairIndex = iTransCbArrayByTrans.FindInOrder(cbPair,TransCbOrderByTrans);
				__ASSERT_ALWAYS(pairIndex>=0,Kern::Fault("IIC Client, DoRequest, EQTransAsync Cb by Trans pairIndex<0",__LINE__));
				iTransCbArrayByTrans.Remove(pairIndex);
				FreeWriteAccess();
				Unlock();
				Kern::RequestComplete(iClient, aStatus, r);
				delete cb;
				delete cbPair;
				CleanupExtractTrans(pair->iTrans);
				CleanupTransaction(pair->iTrans);			
				delete pair;
				}
			break;
			}

		case(RBusDevIicClient::ECtrlIoTestBufReUse):
			{
			iStatus = aStatus;
			// a1 specifies Bus Realisation Config to use

			// Ensure object pointers are made available
			CleanupTransaction(iTrans);

			TInt r = KErrNone;
			TIicBusCallback* cb = NULL;

			// Use default constructor to create an empty transaction
			iTrans = new TIicBusTransaction();
			if(iTrans == NULL)
				{
				CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - iTrans=NULL\n"));
				r = KErrNoMemory;
				}

			// Create a header for the transaction
			if(r == KErrNone)
				{
				r = CreateDefaultSpiBuf(iSpiBuf);
				if(r != KErrNone)
					{
					CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - CreateDefaultSpiBuf returned %d\n",r));
					}
				}

			// Create and add transfer lists for half-duplex and full-duplex entries in the transaction
			if(r == KErrNone)
				{
				// Use simple text as payload, 8bit granularity, half-duplex write, full-duplex read (ie payload ignored)
				_LIT(halfDuplexText1,"Half Duplex Text 1");
				TBuf8<19> halfDuplexBuf_8;
				halfDuplexBuf_8.Copy(halfDuplexText1);
				iTfer = new TIicBusTransfer(TIicBusTransfer::EMasterWrite, 8, &halfDuplexBuf_8);
				if(iTfer == NULL)
					{
					CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - iTfer=NULL\n"));
					r = KErrNoMemory;
					}
				else
					{
					_LIT(halfDuplexText2,"Half Duplex Text 2");
					TBuf8<19> halfDuplexBuf2_8;
					halfDuplexBuf2_8.Copy(halfDuplexText2);
					TIicBusTransfer* tempHdTfer = new TIicBusTransfer(TIicBusTransfer::EMasterWrite, 8, &halfDuplexBuf2_8);
					if(tempHdTfer == NULL)
						{
						CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - tempHdTfer=NULL\n"));
						r = KErrNoMemory;
						}
					else
						{
						iTfer->LinkAfter(tempHdTfer);
						}
					}
				if(r == KErrNone)
					{
					_LIT(fullDuplexText1,"Full Duplex Text 1");
					TBuf8<19> fullDuplexBuf1_8;
					fullDuplexBuf1_8.Copy(fullDuplexText1);
					iFdTfer = new TIicBusTransfer(TIicBusTransfer::EMasterRead, 8, &fullDuplexBuf1_8);
					if(iFdTfer == NULL)
						{
						CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - iFdTfer=NULL\n"));
						r = KErrNoMemory;
						}
					else
						{
						_LIT(fullDuplexText2,"Full Duplex Text 2");
						TBuf8<19> fullDuplexBuf2_8;
						fullDuplexBuf2_8.Copy(fullDuplexText2);
						TIicBusTransfer* tempFdTfer = new TIicBusTransfer(TIicBusTransfer::EMasterRead, 8, &fullDuplexBuf2_8);
						if(tempFdTfer == NULL)
							{
							CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - tempFdTfer=NULL\n"));
							r = KErrNoMemory;
							}
						else
							{
							iFdTfer->LinkAfter(tempFdTfer);
							}
						}
					}
				}

			// Add the Header and Transfers to the Transaction
			if(r == KErrNone)
				r = iTrans->SetHalfDuplexTrans(iSpiBuf, iTfer);
				if(r != KErrNone)
					{
					CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - SetHalfDuplexTrans returned %d\n",r));
					}

			if(r == KErrNone)
				r = iTrans->SetFullDuplexTrans(iFdTfer);
				if(r != KErrNone)
					{
					CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - SetFullDuplexTrans returned %d\n",r));
					}

			// Specify the callback object to use
			if(r == KErrNone)
				{
				cb = new TIicBusCallback(TransModifCallback, this, iDfcQue, 5); // 5 arbitrary
				if(cb == NULL)
					{
					CLIENT_PRINT(("DChannelIicClient::DoRequest ECtrlIoTestBufReUse ERROR - cb=NULL\n"));
					r = KErrNoMemory;
					}
				}

			// Since the transaction is not yet queued, should be able to modify the transfer and transaction content
			TestTransModification(iTrans, iTfer, iFdTfer, iSpiBuf);

			// Store the relevant data in this object's iTransBufReuseData member
			iTransBufReuseData.iTransaction = iTrans;
			iTransBufReuseData.iHdTfer = iTfer;
			iTransBufReuseData.iFdTfer = iFdTfer;
			iTransBufReuseData.iHdr = iSpiBuf;
			iTransBufReuseData.iCallback = cb;

			// Now queue the transaction. The callback function will re-apply the modification tests and delete the
			// objects created here
			// If the queueing fails, complete the test here and clean up
			r = QueueTransaction((TInt)a1, iTrans, cb);
			if(r != KErrNone)
				{
				Kern::RequestComplete(iClient, iStatus, r);
				delete iTransBufReuseData.iCallback;	// Must do this before deleting the Transaction in CleanupTransaction
				CleanupTransaction(iTrans);
				}
			break;
			}
		default:
			{
			CLIENT_PRINT(("DChannelIicClient::DoRequest - unrecognised value for aId=0x%x\n",aId));
			r=KErrArgument;
			break;
			}
		}
	return r;
	}


// Support for MasterSlave processing
static void MsSlaveClientCallbackFunc(TInt aChannelId, TInt aReturn, TInt aTrigger, TInt16 aRxWords, TInt16 aTxWords, TAny*	aParam)
	{
	CLIENT_PRINT(("> MsSlaveClientCallbackFunc() - aChannelId=0x%x,aReturn=%d,aTrigger=0x%x,aRxWords=0x%x,aTxWords=0x%x,aParam=0x%x\n",aChannelId,aReturn,aTrigger,aRxWords,aTxWords,aParam));
	(void)aTxWords; // Unused if CLIENT_PRINT is disabled
	(void)aRxWords; // Unused if CLIENT_PRINT is disabled
	DChannelIicClient* channel = (DChannelIicClient*)aParam;
	CLIENT_PRINT(("MsSlaveClientCallbackFunc() - channel=0x%x\n",channel));
	if(aTrigger == EAsyncCaptChan)
		{
		CLIENT_PRINT(("MsSlaveClientCallbackFunc: capture channel completed\n"));
		// Set iChannelId, and write to user-side variable.
		channel->iChannelId=aChannelId;
		TInt r=Kern::ThreadRawWrite(channel->iClient,channel->iClientChanId,&aChannelId,sizeof(TInt));
		if(r == KErrNone)
			r=aReturn;
	    channel->RequestComplete(r);	// Inform user of error
		return;
		}
	else
		{
		CLIENT_PRINT(("\nMsSlaveClientCallbackFunc: trigger condition 0x%x is not recognised \n\n",aTrigger));
		channel->RequestComplete(aReturn);	// Inform user of error
		}
	}

void DChannelIicClient::RequestComplete(TInt r)
	{
	Kern::RequestComplete(iClient, iStatus, r);
	}


TInt DChannelIicClient::InitSlaveClient()
	{
	iNotif = new TIicBusSlaveCallback(MsSlaveClientCallbackFunc, (TAny*)this, iDfcQue, KIicSlaveClientDfcPriority);
	if(iNotif == NULL)
		{
		CLIENT_PRINT(("> DChannelIicClient::InitSlaveClient ERROR unable to allocate space TIicBusSlaveCallback* iNotif \n"));
		return KErrNoMemory;
		}
	return KErrNone;
	}

