/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#ifdef STANDALONE_CHANNEL

#include <drivers/iic_transaction.h>

#include "csi_master.h"

#include "csi_slave.h"

#else

#include <drivers/iic.h>

#endif

#include <drivers/iic_channel.h>

#include <drivers/gpio.h>

#include "cs42l51.h"

#include "d_csi.h"

#define __KTRACE(s)

//#define __KTRACE(s) __KTRACE_OPT(KIIC, s)

const TInt KMaxNumChannels = 1; // we only support one client at the time

// generic check-error macro - to not put this manually on each operation.

#define CHECK_ERR(r) \

          if(r != KErrNone){ \

          __KTRACE(Kern::Printf("d_csi.cpp, line: %d returned r=%d", __LINE__, r)); \

          return r;}

// Default Test Header

const TConfigSpiV01 DefaultHeader =

	{

	ESpiWordWidth_8, //iWordWidth

	260000, //iClkSpeed

	ESpiPolarityLowRisingEdge, //iClkMode

	500, // iTimeoutPeriod

	EBigEndian, // iEndianness

	EMsbFirst, //iBitOrder

	0, //iTransactionWaitCycles

	ESpiCSPinActiveLow //iCsPinActiveMode

	};

_LIT(KLddRootName,"d_csi");

_LIT(KIicClientThreadName,"IicClientLddThread");

// Constructor

DDeviceIicClient::DDeviceIicClient()

	{

	 __KTRACE(Kern::Printf("DDeviceIicClient::DDeviceIicClient()"));

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

	iUnitsMask = 0;

	iVersion = TVersion(KIicClientMajorVersionNumber,

	        KIicClientMinorVersionNumber, KIicClientBuildVersionNumber);

	}

// Destructor

DDeviceIicClient::~DDeviceIicClient()

	{

	__KTRACE(Kern::Printf("DDeviceIicClient::~DDeviceIicClient()"));

	}

// Install the device driver.

TInt DDeviceIicClient::Install()

	{

	__KTRACE(Kern::Printf("DDeviceIicClient::Install()"));

	return (SetName(&KLddRootName));

	}

void DDeviceIicClient::GetCaps(TDes8& aDes) const

// Return the IicClient capabilities.

	{

	TPckgBuf<TCapsIicClient> b;

	b().version = TVersion(KIicClientMajorVersionNumber, KIicClientMinorVersionNumber, KIicClientBuildVersionNumber);

	Kern::InfoCopy(aDes, b);

	}

// Create a channel on the device.

TInt DDeviceIicClient::Create(DLogicalChannelBase*& aChannel)

	{

	__KTRACE(Kern::Printf("DDeviceIicClient::Create(DLogicalChannelBase*& aChannel)"));

	if (iOpenChannels >= KMaxNumChannels)

		{

		return KErrOverflow;

		}

	aChannel = new DChannelIicClient;

	return aChannel ? KErrNone : KErrNoMemory;

	}

DChannelIicClient::DChannelIicClient()

	{

	iClient = &Kern::CurrentThread();

	iSlaveCallback = NULL;

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

	iClient->Open();

	}

DChannelIicClient::~DChannelIicClient()

	{

	__KTRACE(Kern::Printf("DChannelIicClient::~DChannelIicClient()"));

	iDfcQue->Destroy();

	//free memory:

	delete iSpiHeader;

#ifdef STANDALONE_CHANNEL

#ifdef MASTER_MODE

	if(iMasterChannel)

		delete iMasterChannel;

#endif/*MASTER_MODE*/

#ifdef SLAVE_MODE

	if(iSlaveChannel)

		delete iSlaveChannel;

#endif/*SLAVE_MODE*/

#endif

	// decrement the DThread's reference count

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

	}

TInt DChannelIicClient::DoCreate(TInt aUnit, const TDesC8* /*aInfo*/,

        const TVersion& /*aVer*/)

	{

	__KTRACE(Kern::Printf("DChannelIicClient::DoCreate(), UNIT %d", aUnit));

	TInt r = KErrNone;

	// Bus Realisation Config iCsiBusId;

	iCsiBusId = 0;

	SET_BUS_TYPE(iCsiBusId,DIicBusChannel::ESpi);

	SET_CHAN_NUM(iCsiBusId,KCodecChannelNumber);

	SET_SLAVE_ADDR(iCsiBusId,14);

#ifdef STANDALONE_CHANNEL

#ifdef MASTER_MODE

	// create channel 0 - as master..

	iMasterChannel = DCsiChannelMaster::New(0, DIicBusChannel::ESpi, DIicBusChannel::EFullDuplex);

	if (!iMasterChannel)

		{

		__KTRACE_OPT(KIIC, Kern::Printf("Error no memory"));

		return KErrNoMemory;

		}

#endif /*MASTER_MODE*/

#ifdef SLAVE_MODE

	// and created channel 1 - as slave..

	iSlaveChannel = DCsiChannelSlave::New(1, DIicBusChannel::ESpi, DIicBusChannel::EFullDuplex);

	if (!iSlaveChannel)

		{

		__KTRACE_OPT(KIIC, Kern::Printf("Error no memory"));

		#ifdef MASTER_MODE

		delete iMasterChannel; //Free memory

		#endif

		return KErrNoMemory;

		}

#endif  /*SLAVE_MODE*/

#endif/*STANDALONE_CHANNEL*/

	r = Kern::DynamicDfcQCreate(iDfcQue, KIicClientThreadPriority, KIicClientThreadName);

	if(r == KErrNone)

		{

		iSpiHeader = new TConfigSpiBufV01(DefaultHeader);

		if(iSpiHeader)

			{

			SetDfcQ(iDfcQue);

			iMsgQ.Receive();

			}

		else

			{

			r = KErrNoMemory;

			}

		}

	return r;

	}

void DChannelIicClient::HandleMsg(TMessageBase* aMsg)

	{

	TThreadMessage& m = *(TThreadMessage*) aMsg;

	TInt id = m.iValue;

	if (id == ECloseMsg)

		{

		// make sure, we've released the SlaveChannel on closure..

		DoControl(RBusCsiTestClient::EReleaseSlaveChannel, NULL, NULL);

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

		}

	}

void DChannelIicClient::DoCancel(TInt aMask)

	{

	// Cancel an outstanding request.

	// Not implemented.

	return;

	}

#ifdef MASTER_MODE

TInt DChannelIicClient::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction, TIicBusCallback *aCallback/*=NULL*/)

	{

#ifndef STANDALONE_CHANNEL

	if(!aCallback)

		return IicBus::QueueTransaction(aBusId, aTransaction);

	else

		return IicBus::QueueTransaction(aBusId, aTransaction, aCallback);

#else

	if(iMasterChannel)

		{

		aTransaction->iBusId = aBusId;

		if(!aCallback)

			return iMasterChannel->QueueTransaction(aTransaction);

		else

			return iMasterChannel->QueueTransaction(aTransaction, aCallback);

		}

	else 

		return KErrGeneral; //iMaster not initialised? - channels not created?

#endif

	}

#endif /*MASTER_MODE*/

#ifdef SLAVE_MODE

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

	{

#ifdef STANDALONE_CHANNEL

	if(iSlaveChannel)

		return iSlaveChannel->RegisterTxBuffer(aRxBuffer, aBufGranularity, aNumWords, aOffset);

	else 

		return KErrGeneral;

#else

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

#endif

	}

TInt DChannelIicClient::RegisterTxBuffer(TInt aChannelId, TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)

	{

#ifdef STANDALONE_CHANNEL

	if(iSlaveChannel)

		return iSlaveChannel->RegisterTxBuffer(aRxBuffer, aBufGranularity, aNumWords, aOffset);

	else 

		return KErrGeneral;

#else

	return IicBus::RegisterTxBuffer(aChannelId, aRxBuffer, aBufGranularity, aNumWords, aOffset);

#endif

	}

TInt DChannelIicClient::CaptureChannel(TInt aBusId, TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch)

	{

#ifdef STANDALONE_CHANNEL

	if(iSlaveChannel)

		return iSlaveChannel->CaptureChannel(aConfigHdr, aCallback, aChannelId, aAsynch);

	else 

		return KErrGeneral;

#else

	return IicBus::CaptureChannel(aBusId, aConfigHdr, aCallback, aChannelId, aAsynch);

#endif

	}

TInt DChannelIicClient::ReleaseChannel(TInt aChannelId)

	{

#ifdef STANDALONE_CHANNEL

	if(iSlaveChannel)

		return iSlaveChannel->ReleaseChannel();

	else 

		return KErrGeneral;

#else

		return IicBus::ReleaseChannel(aChannelId);

#endif

	}

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

	{

#ifdef STANDALONE_CHANNEL

	if(iSlaveChannel)

		return iSlaveChannel->SetNotificationTrigger(aTrigger);

	else

		return KErrGeneral;

#else

		return IicBus::SetNotificationTrigger(aChannelId, aTrigger);

#endif

	}

#endif /*SLAVE_MODE*/

// This test tests the timeout for the half-duplex Write requests.

// it creates a transaction with one transfer.

// Clk 200kHz actually sets the clock to  260000 kHz. With 8bit granularity - gives 25kB/s

// 32,5 bytes should be transferred in 1ms

// so e.g. setting the timeout to 1ms and the transfer size to more than that 32 bytes should

// cause a transfer timeout for transmission.

// test case:

// 1. setting timeout to 1ms with buffer 128 bytes - should result in KErrTImeout return value.

// 2. setting timeout to 5ms (~160 bytes transfer) - should result in KErrNone return value.

#ifdef MASTER_MODE

TInt DChannelIicClient::TestTransferTimeout()

	{

	__KTRACE(Kern::Printf("DChannelIicClient::TestTransferTimeout()"));

	TInt r = KErrNone;

	TUint32 busId = 0;

	SET_BUS_TYPE(busId,DIicBusChannel::ESpi);

	SET_CHAN_NUM(busId,0);

	SET_SLAVE_ADDR(busId,13); // test it with any number between 1-32

	// Create a transaction header

	const TConfigSpiV01 TestHeader =

		{

		ESpiWordWidth_8, //iWordWidth

		260000, //iClkSpeed

		ESpiPolarityLowRisingEdge, //iClkMode

		1, // iTimeoutPeriod

		EBigEndian, // iEndianness

		EMsbFirst, //iBitOrder

		0, //iTransactionWaitCycles

		ESpiCSPinActiveLow //iCsPinActiveMode

		};

	TPckgBuf<TConfigSpiV01> header(TestHeader);

	// create transfer object

	TBuf8<128> transfer_buf; // buffer..

	transfer_buf.SetLength(transfer_buf.MaxLength());

	TIicBusTransfer transfer(TIicBusTransfer::EMasterWrite, 8, &transfer_buf);

	// Create a transaction using header and transfer..

	TIicBusTransaction transaction1(&header, &transfer);

	// this transaction should return KErrTimeout

	r = QueueTransaction(busId, &transaction1);

	if (r != KErrTimedOut)

		{

		__KTRACE(Kern::Printf("no timeout??, r= %d", r));

		return r;

		}

	// change the timeout to  and create another transaction..

	header().iTimeoutPeriod = 6; // it works for 4 too (~130Bytes)

	transfer_buf.SetLength(transfer_buf.MaxLength());

	TIicBusTransfer transfer2(TIicBusTransfer::EMasterWrite, 8, &transfer_buf);

	TIicBusTransaction transaction2(&header, &transfer2);

	// this transaction should return KErrNone

	r = QueueTransaction(busId, &transaction2);

	if (r != KErrNone)

		{

		__KTRACE(Kern::Printf("Transaction failed, r= %d", r));

		}

	return r;

	}

TInt DChannelIicClient::TestHalfDuplexTransaction()

	{

	__KTRACE(Kern::Printf("DChannelIicClient::TestHalfDuplexTransaction()"));

	TInt r = KErrNone;

	TUint32 busId = 0;

	SET_BUS_TYPE(busId,DIicBusChannel::ESpi);

	SET_CHAN_NUM(busId,0);

	SET_SLAVE_ADDR(busId,13); // test it with any number between 1-32

	// create header

	const TConfigSpiV01 TestHeader =

		{

		ESpiWordWidth_8, //iWordWidth

		260000, //iClkSpeed

		ESpiPolarityLowRisingEdge, //iClkMode

		500, // iTimeoutPeriod

		EBigEndian, // iEndianness

		EMsbFirst, //iBitOrder

		0, //iTransactionWaitCycles

		ESpiCSPinActiveLow //iCsPinActiveMode

		};

	TPckgBuf<TConfigSpiV01> header(TestHeader);

	// create transfer object

	TBuf8<32> txTransferBuf; // buffer..

	TBuf8<32> rxTransferBuf; // buffer..

	for (TInt i = 0; i < txTransferBuf.MaxLength(); ++i)

		{

		txTransferBuf.Append(i);

		}

	txTransferBuf.SetLength(txTransferBuf.MaxLength());

	rxTransferBuf.SetLength(rxTransferBuf.MaxLength());

	// combine some transfers -in one transaction.

	TIicBusTransfer txTransfer(TIicBusTransfer::EMasterWrite, 8, &txTransferBuf);

	TIicBusTransfer rxTransfer(TIicBusTransfer::EMasterRead, 8, &rxTransferBuf);

	txTransfer.LinkAfter(&rxTransfer);

	TIicBusTransfer txTransfer2(TIicBusTransfer::EMasterWrite, 8, &txTransferBuf);

	rxTransfer.LinkAfter(&txTransfer2);

	TIicBusTransfer  rxTransfer2(TIicBusTransfer::EMasterRead, 8, &rxTransferBuf);

	txTransfer2.LinkAfter(&rxTransfer2);

	// Create a transaction using header and list of transfers..

	TIicBusTransaction transaction(&header, &txTransfer);

	// queue the transaction - it should complete successful

	r = QueueTransaction(busId, &transaction);

	return r;

	}

TInt DChannelIicClient::TestBulkTransfer()

	{

	//Create a Transaction object which  contains 2 Transfers. of buffer sizes say 256 and 64

	const TUint8 KTrBuf1Length = 128;

	const TUint8 KTrBuf2Length = 64;

	TUint32 busId = 0;

	SET_BUS_TYPE(busId,DIicBusChannel::ESpi);

	SET_CHAN_NUM(busId,0);

	SET_SLAVE_ADDR(busId,5);

	// create header

	const TConfigSpiV01 TestHeader =

		{

		ESpiWordWidth_16, //iWordWidth

		260000, //iClkSpeed

		ESpiPolarityLowRisingEdge, //iClkMode

		3000, // iTimeoutPeriod

		EBigEndian, // iEndianness

		EMsbFirst, //iBitOrder

		0, //iTransactionWaitCycles

		ESpiCSPinActiveLow //iCsPinActiveMode

		};

	TPckgBuf<TConfigSpiV01> header(TestHeader);

	TBuf8<KTrBuf1Length> transBuf1;

	TBuf8<KTrBuf2Length> transBuf2;

	TInt r = KErrNone;

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

		{

		transBuf1.Append(i + '0');

		}

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

		{

		transBuf2.Append(i + 'a');

		}

	transBuf1.SetLength(KTrBuf1Length);

	transBuf2.SetLength(KTrBuf2Length);

	//TIicBusTransfer  trans1;

	TIicBusTransfer trans1(TIicBusTransfer::TIicBusTransfer::EMasterWrite, 8, &transBuf2);

	TIicBusTransfer trans2(TIicBusTransfer::TIicBusTransfer::EMasterRead, 8, &transBuf1);

	trans1.LinkAfter(&trans2);

	// for the other direction - re-use buffers..(they will be interleaved)

	TIicBusTransfer trans3(TIicBusTransfer::TIicBusTransfer::EMasterRead, 8, &transBuf1);

	TIicBusTransfer trans4(TIicBusTransfer::TIicBusTransfer::EMasterWrite, 8, &transBuf2);

	trans3.LinkAfter(&trans4);

	// transaction

	TIicBusTransaction trans(&header, &trans1); // this will set the transaction with trans1 and trans2

	trans.SetFullDuplexTrans(&trans3); // and this will add trans3 and trans4 for the other direction

	r = QueueTransaction(busId, &trans);

	return r;

	}

// Testing CSI interface with AudioCodec:

// this involves several CSI write transactions to set-up the AudioCodec

// and configure it to generate the sound (of a particular frequency)

// CSI configuration parameters needed to transmit data to the Codec

// these are used as the transaction header object.

const TConfigSpiV01 KCodecSpiV01Config =

	{

	ESpiWordWidth_8, //iWordWidth

	260000, //iClkSpeed

	ESpiPolarityHighFallingEdge, //iClkMode

	100, // iTimeoutPeriod

	EBigEndian, // iEndianness

	EMsbFirst, //iBitOrder

	0, //iTransactionWaitCycles

	ESpiCSPinActiveLow //iCsPinActiveMode

	};

// helper function - to update buffer data and queue the transaction with the updated data

TInt DChannelIicClient::QueueRegisterWriteTransaction(TInt16 aRegister,

        TInt16 aValue, TIicBusTransaction* aTrans, TInt aConfig)

	{