// 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*/