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

// e32\drivers\iic_channel.cpp

// IIC Channel Platform Independent Layer (PIL)

//

#include <drivers/iic_channel.h>

#ifdef IIC_INSTRUMENTATION_MACRO

#include <drivers/iic_trace.h>

#endif

// The timer call back function which calls the PSL's HandleSlaveTimeout()

// Note that this assumes that the channel thread has been unblocked - if this

// is not the case, the callback will never get to run

TInt DIicBusChannelMaster::DoCreate()

    {return KErrNone;}

void DIicBusChannelMaster::Lock()

    {NKern::FMWait(&iTransactionQLock);}

void DIicBusChannelMaster::Unlock()

    {NKern::FMSignal(&iTransactionQLock);}

TIicBusTransaction* DIicBusChannelMaster::NextTrans(TIicBusTransaction* aTrans)

    {

    // call multi-transaction call back function to get next transaction

    if((aTrans->iFlags&KTransactionWithPreamble)&&(aTrans->iFlags&KTransactionWithMultiTransc))

        return ((TIicBusTransactionPreambleExt*)aTrans)->iMultiTransc(aTrans, ((TIicBusTransactionPreambleExt*)aTrans)->iMultiTranscArg);

    else if(aTrans->iFlags&KTransactionWithMultiTransc)

        return ((TIicBusTransactionMultiTransc*)aTrans)->iMultiTransc(aTrans, ((TIicBusTransactionMultiTransc*)aTrans)->iMultiTranscArg);

    else

        return NULL;

    }

void DIicBusChannelMaster::UnlockAndKick()

    {iTransQDfc.Enque(&iTransactionQLock);}

void DIicBusChannelMaster::SlaveTimeoutCallback(TAny* aPtr)

	{

	DIicBusChannelMaster* aChanMaster=(DIicBusChannelMaster* )aPtr;

	TInt r = aChanMaster->HandleSlaveTimeout();

	aChanMaster->CompleteRequest(r);

	}

TInt DIicBusChannelMaster::TransFlow(TIicBusTransaction* aTransaction)

    {

    if(aTransaction->iHalfDuplexTrans == NULL)

        return KErrArgument;

    else if(aTransaction->iFullDuplexTrans == NULL)

        return DIicBusChannel::EHalfDuplex;

    else return DIicBusChannel::EFullDuplex;

    }

TInt8 DIicBusChannelMaster::IsMasterBusy()

    {

    if((iTransCount&~KTransCountMsBit) == 0)

        return 0;

    else return 1;

    }

DIicBusChannelMaster::DIicBusChannelMaster(TBusType aBusType, TChannelDuplex aChanDuplex)

		: DIicBusChannel(DIicBusChannel::EMaster, aBusType, aChanDuplex),

		iTransQDfc(DIicBusChannelMaster::MsgQFunc, this, NULL, 1), iChannelReady(EFalse)

	{

	new(&iTimeoutTimer) NTimer(SlaveTimeoutCallback,this);

	}

DIicBusChannelMaster::~DIicBusChannelMaster()

	{

	delete iSlaveTimeoutDfc;

	}

TInt DIicBusChannelMaster::Init()

	{

	iSlaveTimeoutDfc = new TDfc(SlaveTimeoutCallback,(TAny*)this, 7);	// Highest Dfc priority

	if(!iSlaveTimeoutDfc)

		return KErrNoMemory;

	else

		return KErrNone;

	}

// Function to used to indicate if the Slave response has exceeded

// an expected time

TInt DIicBusChannelMaster::StartSlaveTimeOutTimer(TInt aTime)

	{

	TInt r = iTimeoutTimer.OneShot(NKern::TimerTicks(aTime),(*iSlaveTimeoutDfc));

	return r;

	}

void DIicBusChannelMaster::SetDfcQ(TDfcQue* aDfcQue)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::SetDfcQ 0x%x\n",aDfcQue));

	__ASSERT_DEBUG(aDfcQue!=NULL, Kern::Fault(KIicChannelPanic,__LINE__));

	iDfcQ=aDfcQue;

	iTransQDfc.SetDfcQ(iDfcQ);

	iSlaveTimeoutDfc->SetDfcQ(iDfcQ);

	Lock();

	__ASSERT_DEBUG(!iChannelReady, Kern::Fault(KIicChannelPanic,__LINE__));

	if (!iTransactionQ.IsEmpty())

		{

		iTransaction=(TIicBusTransaction*)(iTransactionQ.First()->Deque());

		__KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::SetDfcQ got %08x",iTransaction));

		iTransaction->iState=TIicBusTransaction::EAccepted;

		iCurrentTransaction = iTransaction;

		UnlockAndKick();

		}

	else

		{

		__KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::SetDfcQ"));

		iChannelReady=ETrue;

		iTransaction=NULL;

		iCurrentTransaction = NULL;

		Unlock();

		}

	}

void DIicBusChannelMaster::CompleteRequest(TInt aResult)

	{

	// Ensure the timeout timer has been cancelled

	CancelTimeOut();

	TIicBusTransaction* nextTrans=NextTrans(iCurrentTransaction);

	if((aResult != KErrNone)||(nextTrans == NULL))

		EndTransaction(iTransaction,aResult,iTransaction->iCallback);

	else

		{

		nextTrans->iBusId = iCurrentTransaction->iBusId; // Pass the bus configuration info to the PSL

		iCurrentTransaction = nextTrans;

		DoRequest(nextTrans);

		}

	}

#ifdef MASTER_MODE

/*

For Master-side transaction queuing APIs

the Channel implementation sends the transaction as a message to the Channel's message queue,

optionally blocking the client thread on the message's semaphore (synchronous APIs).

*/

TInt DIicBusChannelMaster::QueueTransaction(TIicBusTransaction* aTransaction)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::QueueTransaction, aTransaction=0x%x\n",aTransaction));

	// Send the transaction as a message to the Channel's message queue

	// Synchronous API, so block the calling thread during the processing

	TInt r = QueueTransaction(aTransaction, NULL);

	if(r!=KErrNone)

		return r;	// Transaction was not queued - so don't wait for a notification that it completed.

	__KTRACE_OPT(KIIC, Kern::Printf("<DIicBusChannelMaster::QueueTransaction ret %d",aTransaction->iResult));

	return aTransaction->iResult;

	}

TInt DIicBusChannelMaster::QueueTransaction(TIicBusTransaction* aTransaction, TIicBusCallback* aCallback)

	{

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::QueueTransaction, aTransaction=0x%x, aCallback=0x%x\n",aTransaction,aCallback));

	// Check aTransaction is non-NULL (aCallback may be NULL if the synchronous operation is required).

	if(aTransaction == NULL)

		{

		return KErrArgument;

		}

	// Send the transaction as a message to the Channel's message queue and return

	aTransaction->iCallback = aCallback;

	if(aCallback != NULL)

		{

		aCallback->iTransaction = aTransaction;

		}

	// Call the PSL implementation to check that the header is valid for this channel

	TInt r = CheckHdr(aTransaction->iHeader);

	if(r!=KErrNone)

		{

		return r;

		}

	// Duplex operation is indicated in the transaction object

	if((TransFlow((TIicBusTransaction*)aTransaction) == DIicBusChannel::EFullDuplex) &&

	   (ChannelDuplex()                              != DIicBusChannel::EFullDuplex))

		{

		return KErrNotSupported;

		}

	DThread* pC =& Kern::CurrentThread();

	Lock();

	__ASSERT_DEBUG(aTransaction->iState == TIicBusTransaction::EFree, Kern::Fault(KIicChannelPanic,__LINE__));

	if(!(iTransCount & KTransCountMsBit))

		{

		if(iTransCount < ~KTransCountMsBit)

			{

			++iTransCount;

			}

		else

			{

			Unlock();

			return KErrOverflow;

			}

		}

	aTransaction->iSyncNotification.iCount = 0;

	aTransaction->iSyncNotification.iOwningThread = &pC->iNThread;

	pC->Open();

	if (iChannelReady)

		{

		aTransaction->iState = TIicBusTransaction::EAccepted;

		iTransaction = aTransaction;

		iCurrentTransaction = aTransaction;

		iChannelReady = EFalse;

		UnlockAndKick();

		}

	else

		{

		iTransactionQ.Add(aTransaction);

		aTransaction->iState = TIicBusTransaction::EDelivered;

		Unlock();

		}

	// Wait on a semaphore if called from synchronous version

	if(aCallback == NULL)

		{

		NKern::FSWait(&aTransaction->iSyncNotification);

		}

	return KErrNone;

	}

TInt DIicBusChannelMaster::CancelTransaction(TIicBusTransaction* aTransaction)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::CancelTransaction, aTransaction=0x%x\n",aTransaction));

	// Check aTransaction is non-NULL

	if(aTransaction == NULL)

		{

		return KErrArgument;

		}

	// If the method is called on a synchronous transaction return KErrNotSupported

	if(aTransaction->iCallback == NULL)

		{

		return KErrNotSupported;

		}

	DThread* pT = NULL;

	Lock();

	TInt r = KErrNone;

	switch(aTransaction->iState)

		{

		case TIicBusTransaction::EDelivered:

			{

			aTransaction->Deque();

			pT=_LOFF(aTransaction->iSyncNotification.iOwningThread,DThread,iNThread);

			aTransaction->iState=TIicBusTransaction::EFree;

			--iTransCount; // Count must be greater than zero if the transaction is in this state

			r = KErrCancel;

			break;

			}

		case TIicBusTransaction::EAccepted:

			{

			r = KErrInUse;

			break;

			}

		case TIicBusTransaction::EFree:

			{

			r = KErrCancel;

			break;

			}

		}

	Unlock();

	if (pT)

		{

		pT->AsyncClose();

		}

	return r;

	}

#else /*MASTER_MODE*/

TInt DIicBusChannelMaster::QueueTransaction(TIicBusTransaction* /*aTransaction*/)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::QueueTransaction invoked when not in MASTER_MODE!\n"));

	return KErrNotSupported;

	}

TInt DIicBusChannelMaster::QueueTransaction(TIicBusTransaction* /*aTransaction*/, TIicBusCallback* /*aCallback*/)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::QueueTransaction invoked when not in MASTER_MODE!\n"));

	return KErrNotSupported;

	}

TInt DIicBusChannelMaster::CancelTransaction(TIicBusTransaction* /*aTransaction*/)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::CancelTransaction invoked when not in MASTER_MODE!\n"));

	return KErrNotSupported;

	}

#endif/*MASTER_MODE*/

// Invoked in response to receiving a message

// Function argument is a pointer to the required channel object

// Invoke the channel's PSL implementation of the DoRequest method with a pointer to the transaction object

//

void DIicBusChannelMaster::MsgQFunc(TAny* aPtr)

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc, aPtr=0x%x\n",aPtr));

	DIicBusChannelMaster* channel=(DIicBusChannelMaster*)aPtr;

	TIicBusTransaction* trans = channel->iTransaction;

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MPROCESSTRANS_START_PIL_TRACE;

#endif

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc trans->iHeader=0x%x\n",trans->iHeader));

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc trans->iHalfDuplexTrans=0x%x\n",trans->iHalfDuplexTrans));

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc trans->iFullDuplexTrans=0x%x\n",trans->iFullDuplexTrans));

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc trans->iCallback=0x%x\n",trans->iCallback));

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelMaster::MsgQFunc trans->iFlags=0x%x\n",trans->iFlags));

	TInt r = KErrNone;

	// invoke the preamble callback function supplied by the client of the IIC if there is any

	if(GetTransFlags(trans) & KTransactionWithPreamble)

		{

		TIicBusTransactionPreamble* transPreamble = (TIicBusTransactionPreamble*)trans;

		TIicBusPreamble funcPtr=NULL;

		funcPtr=(GetPreambleFuncPtr(transPreamble));

		funcPtr(transPreamble,GetPreambleFuncArg(transPreamble));

		}

	r = channel->DoRequest(trans);	// Instigate processing in the PSL

	if(r!=KErrNone)

		channel->EndTransaction(trans, r, trans->iCallback);

	}

void DIicBusChannelMaster::EndTransaction(TIicBusTransaction* aTrans, TInt aResult, TIicBusCallback* aCb)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MPROCESSTRANS_END_PIL_TRACE;

#endif

	Complete(aResult,aTrans);

	if(aCb != NULL)

		{

		aCb->iResult = aResult;

		aCb->Enque();

		}

	}

void DIicBusChannelMaster::CancelTimeOut()

	{

	// Silently cancel the timer and associated DFC

	//

	// NTimer::Cancel returns ETrue if cancelled, EFalse otherwise - which may mean it wasn't active

	// TDfc::Cancel returns ETrue if actually de-queued, EFalse otherwise - which may mean it wasn't queued

	//

	iTimeoutTimer.Cancel();

	iSlaveTimeoutDfc->Cancel();

	}

void DIicBusChannelMaster::Complete(TInt aResult, TIicBusTransaction* aTransaction) //Completes a kernel message and receive the next one

	{

	__KTRACE_OPT(KIIC, Kern::Printf("MsgB::Complete %08x, %d",this,aResult));

	Lock();

	__ASSERT_DEBUG(aTransaction->iState == TIicBusTransaction::EAccepted, Kern::Fault(KIicChannelPanic,__LINE__));

	aTransaction->iResult=aResult;

	aTransaction->iState=TIicBusTransaction::EFree;

	--iTransCount;

	DThread* pT=_LOFF(aTransaction->iSyncNotification.iOwningThread,DThread,iNThread);

	__ASSERT_DEBUG(!iChannelReady, Kern::Fault(KIicChannelPanic,__LINE__));

	if (!iTransactionQ.IsEmpty())

		{

		TIicBusTransaction* pM=(TIicBusTransaction*)iTransactionQ.First()->Deque();

		__KTRACE_OPT(KIIC, Kern::Printf("rxnext: got %08x",pM));

		pM->iState=TIicBusTransaction::EAccepted;

		iTransaction = pM;

		iCurrentTransaction = pM;

		iTransQDfc.Enque();

		}

	else

		{

		__KTRACE_OPT(KIIC, Kern::Printf("rxnext"));

		iChannelReady=ETrue;

		iTransaction=NULL;

		iCurrentTransaction = NULL;

		}

	NKern::FSSignal(&aTransaction->iSyncNotification,&iTransactionQLock);

	pT->AsyncClose();

	}

TInt DIicBusChannelMaster::StaticExtension(TUint /*aFunction*/, TAny* /*aParam1*/, TAny* /*aParam*/)

 	{

 	return KErrNotSupported;

 	}

TInt DIicBusChannelMaster::Spare1(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/)

	{

	return KErrNotSupported;

	}

#ifdef SLAVE_MODE

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

	{

	// Only one client can have access to the Slave channel at any one time. Any subsequent attempts to capture the

	// same channel should return an error.

	//

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelSlave::CaptureChannel\n"));

	if((aConfigHdr == NULL) || (aCallback == NULL))

		{

	    __KTRACE_OPT(KIIC, Kern::Printf("ERROR: non-NULL argument aConfigHdr=0x%x, aCallback=0x%x\n",aConfigHdr,aCallback));

		return KErrArgument;

		}

	//

	// Check the header is valid for the channel

	TInt r = CheckHdr(aConfigHdr);

	if(r == KErrNone)

		{

		// Check Slave channel is available for capture

		// If iChannelInUse is not set, capture should succeed

		// If this Slave channel is part of a MasterSlave channel iChannelInUse will already be set

		// but iClient will still be NULL. In this case, the capture should succeed.

		TInt intState=__SPIN_LOCK_IRQSAVE(iSpinLock);

		DThread* pT=&(Kern::CurrentThread());

		if((iChannelInUse)&&(iClient!=NULL))

			r=KErrInUse;

		else

			{

			iChannelInUse=1;

			iClient=pT;

			}

		__SPIN_UNLOCK_IRQRESTORE(iSpinLock,intState);

		if(r == KErrNone)

			{

			iClient->Open();

			aCallback->iChannel=this;

			iNotif = aCallback;

			iConfigHeader=aConfigHdr;	// Header alread checked, so just assign it

			// Invoke the PSL processing

			if(aAsynch)

				{

				aChannelId = 0; // the client should read iChannelId from the callback object.

				r=DoRequest(EAsyncConfigPwrUp);

				}

			else

				r=DoRequest(ESyncConfigPwrUp);

			if(r == KErrNone)

				{

				if(!aAsynch)	// For asynchronous version there is nothing more to do until the callback is invoked

					{

					SetChannelId(aChannelId);

					iClientTimeoutDfc->SetDfcQ(iNotif->iDfcQ);

					}

				}

			else

				{

				// PSL encountered an error

				ReleaseChannel();

				if(aAsynch)

					CompleteAsynchCapture(r);	// Queue the client callback for execution

				}

			}

		}

	return r;

	}

TInt DIicBusChannelSlave::ReleaseChannel()

	{

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelSlave::ReleaseChannel\n"));

	 // Release a previously-captured channel.

	TInt r=KErrNone;;

	// Ensure that only the channel's client may release the channel

	DThread* pT=&(Kern::CurrentThread());

	if(iClient!=pT)			// Direct access since iClient can't be modified while channel is still captured

		return KErrAccessDenied;

	r=SetNotificationTrigger(0);			// Attempt to clear notification requests

	if((r!=KErrNone)&&(r!=KErrTimedOut))	// KErrTimedOut refers to an earlier transaction, and is for information only

		return r;

	StopTimer();

	r=DoRequest(EPowerDown);

	if(r == KErrNone)

		{

		TInt intState=__SPIN_LOCK_IRQSAVE(iSpinLock);

		iClient=NULL;

		iChannelInUse=0;	// Channel now available for capture by other clients

		__SPIN_UNLOCK_IRQRESTORE(iSpinLock,intState);

		pT->AsyncClose();	// Allow Client thread to close now channel has been released

		}

	else

		{

		// PSL error when releasing the channel - have to assume the hardware has a problem.

		// The channel is no longer considered "captured" by the controller, i.e. will not accept commands

		// But not having cleared the busy flag means that it can not be used for master channel

		// operations if it is part of a MasterSlave channel

		// Must Fault the Kernel.

		__KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelSlave::ReleaseChannel - PSL returned error code %d\n",r));

		__ASSERT_ALWAYS(EFalse, Kern::Fault(KIicChannelPanic,__LINE__));

		}

	return r;

	}

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

	{

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusChannelSlave::RegisterRxBuffer\n"));

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SREGRXBUF_START_PIL_TRACE;

#endif

	TInt r=KErrNone;

	// Ensure that only the channel's client may perform this operation

	DThread* pT=&(Kern::CurrentThread());

	if(iClient!=pT)			// Direct access since iClient can't be modified while channel is still captured

		return KErrAccessDenied;

	//If the buffer pointer is NULL, return KErrArgument