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

// IIC Controller and public API Implementation

//

#include <drivers/iic.h>

#include <drivers/iic_channel.h>

#include "iic_priv.h"

#ifdef IIC_INSTRUMENTATION_MACRO

#include <drivers/iic_trace.h>

#endif

// Global Controller pointer

static DIicBusController* TheController = NULL;

//

//		Implementation of generic IicBus API for client interface

//

EXPORT_C TInt IicBus::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MQTRANSSYNC_START_PIL_TRACE;

#endif

	TInt r=TheController->QueueTransaction(aBusId, aTransaction);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MQTRANSSYNC_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt IicBus::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction, TIicBusCallback* aCallback)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MQTRANSASYNC_START_PIL_TRACE;

#endif

	TInt r=TheController->QueueTransaction(aBusId, aTransaction, aCallback);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MQTRANSASYNC_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt IicBus::CancelTransaction(TInt aBusId, TIicBusTransaction* aTransaction)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MCANCELTRANS_START_PIL_TRACE;

#endif

	TInt r=TheController->CancelTransaction(aBusId, aTransaction);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_MCANCELTRANS_END_PIL_TRACE;

#endif

	return r;

	}

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

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	if(!aAsynch)

		{

		IIC_SCAPTCHANSYNC_START_PIL_TRACE;

		}

	else

		{

		IIC_SCAPTCHANASYNC_START_PIL_TRACE;

		}

#endif

	TInt r=TheController->CaptureChannel(aBusId, aConfigHdr, aCallback, aChannelId, aAsynch);

#ifdef IIC_INSTRUMENTATION_MACRO

	if(!aAsynch)

		{

		IIC_SCAPTCHANSYNC_END_PIL_TRACE;

		}

#endif

	return r;

	}

EXPORT_C TInt IicBus::ReleaseChannel(TInt aChannelId)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SRELCHAN_START_PIL_TRACE;

#endif

	TInt r=TheController->ReleaseChannel(aChannelId);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SRELCHAN_END_PIL_TRACE;

#endif

	return r;

	}

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

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SREGRXBUF_START_PIL_TRACE;

#endif

	TInt r=TheController->RegisterRxBuffer(aChannelId, aRxBuffer, aBufGranularity, aNumWords, aOffset);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SREGRXBUF_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt IicBus::RegisterTxBuffer(TInt aChannelId, TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SREGTXBUF_START_PIL_TRACE;

#endif

	TInt r=TheController->RegisterTxBuffer(aChannelId, aTxBuffer, aBufGranularity, aNumWords, aOffset);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SREGTXBUF_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt IicBus::SetNotificationTrigger(TInt aChannelId, TInt aTrigger)

	{

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SNOTIFTRIG_START_PIL_TRACE;

#endif

	TInt r=TheController->SetNotificationTrigger(aChannelId, aTrigger);

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_SNOTIFTRIG_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt IicBus::StaticExtension(TUint aId, TUint aFunction, TAny* aParam1, TAny* aParam2)

	{

	return(TheController->StaticExtension(aId, aFunction, aParam1, aParam2));

	}

//

//		Bus Controller

//

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

TInt DIicBusController::OrderEntries(const DIicBusChannel& aMatch, const DIicBusChannel& aEntry)

	{

	TUint8 l=(TUint8)aMatch.ChannelNumber();

	TUint8 r=(TUint8)aEntry.ChannelNumber();

	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<DIicBusChannel> EntryOrder(DIicBusController::OrderEntries);

// Implementation for DIicBusController

//

TInt DIicBusController::Create()

	{

	TInt r=KErrNone;

	iChanLock = new TSpinLock(TSpinLock::EOrderGenericIrqLow2);  // Semi-arbitrary, low priority value

	iCaptLock = new TSpinLock(TSpinLock::EOrderGenericIrqLow2);  // Semi-arbitrary, low priority value

	if((iChanLock == NULL)||(iCaptLock == NULL))

		{

		delete iChanLock;

		delete iCaptLock;

		r=KErrNoMemory;

		}

	return r;

	}

DIicBusController::~DIicBusController()

	{

#ifdef IIC_SIMULATED_PSL

	for(TInt i=0; i<iChannelArray.Count(); i++)

		{

		DIicBusChannel* ptr=iChannelArray[i];

		// Remove the channel from the array

		iChannelArray.Remove(i);

		// Delete the channel object

		delete ptr;

		};

	iChannelArray.Reset();

	delete iChanLock;

	delete iCaptLock;

#endif

	}

TInt DIicBusController::GetChanWriteAccess()

	{

	// Can only have one insertion or removal active at any one time

	// Can not perform an insertion or removal while a read is in progress

	// If either of the two above conditions exist, return KErrInUse

	// Otherwise, set the flag to indicate that a write is in progress

	// and return KErrNone.

	TInt chanIntState=0;

	chanIntState=__SPIN_LOCK_IRQSAVE(*iChanLock);

	if(iChanRwFlags != 0)

		{

		__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

		return KErrInUse;

		}

	iChanRwFlags |= EWriteInProgress;

	__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

	return KErrNone;

	}

void DIicBusController::FreeChanWriteAccess()

	{

	// If an insertion or removal is in progress, no other modifying operation

	// can be active. Reads are also not permitted - so iChanRwFlags can only be

	// EWriteInProgress.

	__ASSERT_DEBUG(iChanRwFlags == EWriteInProgress, Kern::Fault(KIicPanic,__LINE__));

	TInt chanIntState=0;

 	chanIntState=__SPIN_LOCK_IRQSAVE(*iChanLock);

 	iChanRwFlags &= ~EWriteInProgress;

 	__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

	}

TInt DIicBusController::GetChanReadAccess()

	{

	// No reads are permitted while an insertion or removal is in progress

	// If one of the above operations is in progress return KErrInUse

	// Can have several concurrent reads at any one time - so increment

	// the count of such operations as well as ensuring the flag is set to indicate

	// a read is in progress

	TInt chanIntState=0;

	chanIntState=__SPIN_LOCK_IRQSAVE(*iChanLock);

	if(iChanRwFlags == EWriteInProgress)

		{

		__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

		return KErrInUse;

		}

	__ASSERT_DEBUG(iChanRdCount!=0xFFFFFFFF, Kern::Fault(KIicPanic,__LINE__)); // Overflow

	iChanRdCount++;

	iChanRwFlags |= EReadInProgress;

	__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

	return KErrNone;

	}

void DIicBusController::FreeChanReadAccess()

	{

	// No insertions or removals are permitted while a read is in progress

	// so iChanRwFlags can only be EReadInProgress

	// Multiple reads can be in progress concurrently, so the count must be decremented

	TInt chanIntState=0;

	chanIntState=__SPIN_LOCK_IRQSAVE(*iChanLock);

	__ASSERT_DEBUG(iChanRwFlags == EReadInProgress, Kern::Fault(KIicPanic,__LINE__));

	__ASSERT_DEBUG(iChanRdCount>0, Kern::Fault(KIicPanic,__LINE__));

	iChanRdCount--;

	if(iChanRdCount == 0)

		iChanRwFlags &= ~EReadInProgress;

	__SPIN_UNLOCK_IRQRESTORE(*iChanLock,chanIntState);

	}

TInt DIicBusController::RequestTypeSupported(const TInt aBusId, DIicBusChannelMaster* const aChannel)

	{

	TInt32 reqBusType;

	reqBusType = GET_BUS_TYPE(aBusId);

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RequestTypeSupported, BusType=0x%x\n", reqBusType));

	if(reqBusType != aChannel->BusType())

		{

		return KErrNotSupported;

		}

	return KErrNone;

	}

EXPORT_C TInt DIicBusController::RegisterChannels(DIicBusChannel** aListChannels, TInt aNumberChannels)

	{

// To be used by Channel implementations to register a list of supported channels

    __KTRACE_OPT(KIIC, Kern::Printf("\nDIicBusController::RegisterChannels, aListChannels=0x%x, aNumberChannels=%d\n",aListChannels,aNumberChannels));

	__ASSERT_DEBUG(aListChannels!=NULL, Kern::Fault(KIicPanic,__LINE__));

	RPointerArray<DIicBusChannel>* chanArray = TheController->ChannelArray();

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_REGISTERCHANS_START_PIL_TRACE;

#endif

	// Get access to the channel pointer array - exit if it is currently being modfied

	TInt r=KErrNone;

	if((r=TheController->GetChanWriteAccess()) == KErrNone)

		{

#ifdef _DEBUG

		__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RegisterChannels - On entry, iChannelArray ...\n"));

		TheController->DumpChannelArray();

#endif

		// Loop for aNumberChannels	and write directly to the channel array

		DIicBusChannel** chanIterator = aListChannels;

		for(TInt iteration = 0; iteration < aNumberChannels; ++iteration, ++chanIterator)

			{

			DIicBusChannel* chanPtr = *chanIterator;

			__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RegisterChannels - adding channel number %d\n",chanPtr->ChannelNumber()));

			TInt r = chanArray->InsertInOrder(chanPtr,EntryOrder);

			if(r!=KErrNone)

				break;

			}

#ifdef _DEBUG

		 __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RegisterChannels - On exit, iChannelArray ...\n"));

		TheController->DumpChannelArray();

#endif

		TheController->FreeChanWriteAccess();

		}

	else

		{

		__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::GetChanWriteAccess returned %d\n",r));

		}

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_REGISTERCHANS_END_PIL_TRACE;

#endif

	return r;

	}

EXPORT_C TInt DIicBusController::DeRegisterChannel(DIicBusChannel* aChannel)

	{

// To be used by Channel implementations to deregister a channel

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::DeRegisterChannel, aChannel=0x%x\n",aChannel));

	if(aChannel == NULL)

		return KErrArgument;

	RPointerArray<DIicBusChannel>* chanArray = TheController->ChannelArray();

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_DEREGISTERCHAN_START_PIL_TRACE;

#endif

	TInt r=KErrNone;

	// Get access to the channel pointer array - exit if it is currently unavailable

	// Gaining write access will prevent a client of a Master Channel from instigating a new QueueTransaction

	// (or CancelTransaction), and it will obstruct a client of a Slave Channel in CaptureChannel.

	if((r=TheController->GetChanWriteAccess())!=KErrNone)

		return r;

	// Check channel is registered

	TInt chanIndex = chanArray->FindInOrder(aChannel,EntryOrder);

	if(chanIndex<0)

		{

		TheController->FreeChanWriteAccess();

		return KErrNotFound;

		}

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::DeRegisterChannel - On entry, iChannelArray ...\n"));

	TheController->DumpChannelArray();

#endif

	// Remove the channel from the array

	// Note that this does not delete the channel object

	chanArray->Remove(chanIndex);

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::DeRegisterChannel - On exit, iChannelArray ...\n"));

	TheController->DumpChannelArray();

#endif

	TheController->FreeChanWriteAccess();

#ifdef IIC_INSTRUMENTATION_MACRO

	IIC_DEREGISTERCHAN_END_PIL_TRACE;

#endif

	return KErrNone;

	}

TInt DIicBusController::FindCapturedChanById(TCapturedChannel aCapturedChan, TInt& aIndex)

	{

	TInt index=0;

	TInt r=KErrNotFound;

	do

		{

		if(iCapturedChannels[index].iChannelId == aCapturedChan.iChannelId)

			{

			aIndex=index;

			r=KErrNone;

			}

		index++;

		} while ((index < KMaxNumCapturedChannels)&&(r == KErrNotFound));

	return r;

	}

TInt DIicBusController::FindCapturedChan(TCapturedChannel aCapturedChan, TInt& aIndex)

	{

	TInt index=0;

	TInt r=KErrNotFound;

	do

		{

		if(iCapturedChannels[index] == aCapturedChan)

			{

			aIndex=index;

			r=KErrNone;

			}

		index++;

		} while ((index < KMaxNumCapturedChannels)&&(r == KErrNotFound));

	return r;

	}

TInt DIicBusController::InsertCaptChanInArray(TCapturedChannel aCapturedChan)

	{

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::InsertCaptChanInArray \n"));

	// Ensure the channel hasn't already been inserted in the array

	// If found, fault the Kernel

	TInt dumInt = 0;

	TInt r=FindCapturedChan(aCapturedChan,dumInt);

	__ASSERT_DEBUG(r!=KErrNone, Kern::Fault(KIicPanic,__LINE__));

	// Loop the array and insert in the first available slot

	// If no slots are available return KErrNotReady

	TInt index=0;

	TCapturedChannel emptyChan;

	for(;index<KMaxNumCapturedChannels;++index)

		{

		if(iCapturedChannels[index] == emptyChan)

			{

			// Found a space

			iCapturedChannels[index]=aCapturedChan;

			break;

			}

		}

	if(index>=KMaxNumCapturedChannels)

		r = KErrNotReady;

	return r;

	}

TInt DIicBusController::RemoveCaptChanFromArray(TCapturedChannel aCapturedChan)

	{

	// Remove the entry from the array

	// If the entry is not present return KErrArgument

	TInt index=-1;

	TInt r=FindCapturedChan(aCapturedChan,index);

	if((r!=KErrNone)||(index>=KMaxNumCapturedChannels))

		return KErrArgument;

	iCapturedChannels[index].iChanPtr=NULL;

	iCapturedChannels[index].iChannelId=0;

	return KErrNone;

	}

TInt DIicBusController::InstallCapturedChannel(const TInt aChannelId, const DIicBusChannelSlave* aChanPtr)

	{

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::InstallCapturedChannel - On entry, iCapturedChannels ...\n"));

	DumpCapturedChannels();

#endif

	TInt r=KErrNone;

	TCapturedChannel capturedChan((TInt)aChannelId,(DIicBusChannelSlave*)aChanPtr);

	// Because insertions are bounded by the size of the array and do not involve allocating

	// or freeing memory, simply take the spinlock at the start of the operation and release at the end

	TInt captIntState=__SPIN_LOCK_IRQSAVE(*iCaptLock);

	r=InsertCaptChanInArray(capturedChan);

	__SPIN_UNLOCK_IRQRESTORE(*iCaptLock,captIntState);

	if(r!=KErrNone)

		return r;

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::InstallCapturedChannel - On exit, iCapturedChannels ...\n"));

	DumpCapturedChannels();

#endif

	return KErrNone;

	}

TInt DIicBusController::DeInstallCapturedChannel(const TInt aChannelId, const DIicBusChannelSlave* aChanPtr)

	{

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::DeInstallCapturedChannel - On entry, iCapturedChannels ...\n"));

	DumpCapturedChannels();

#endif

	TInt r = KErrNone;

	TCapturedChannel capturedChan((TInt) aChannelId, (DIicBusChannelSlave*) aChanPtr);

	// Because removals are bounded by the size of the array and do not involve allocating

	// or freeing memory, simply take the spinlock at the start of the operation and release at the end

	TInt captIntState = __SPIN_LOCK_IRQSAVE(*iCaptLock);

	r = RemoveCaptChanFromArray(capturedChan);

	__SPIN_UNLOCK_IRQRESTORE(*iCaptLock, captIntState);

	if(r != KErrNone)

		return r;

#ifdef _DEBUG

    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::DeInstallCapturedChannel - On exit, iCapturedChannels ...\n"));

	DumpCapturedChannels();

#endif

	return KErrNone;

	}

	// Master-side API

TInt DIicBusController::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction)

	{

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

	if(!aTransaction)

		{

		return KErrArgument;

		}

	// Get a pointer to the channel

	TInt dumInt = 0;

	DIicBusChannel* chanPtr = NULL;

	// Can only read the channel array if it is not currently being modified

	TInt r = GetChanReadAccess();

	if(r != KErrNone)

		{

		return r;

		}

	r = GetChanPtr(aBusId, dumInt, chanPtr);

	if(r == KErrNone)

		{

		if(!chanPtr)

			{

			r = KErrArgument;

			}