// 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;
			}
		else
			{
			switch(chanPtr->ChannelType())
				{
				// 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:
					{
					r = RequestTypeSupported(aBusId, ((DIicBusChannelMasterSlave*)chanPtr)->iMasterChannel);
					if(r == KErrNone)
						{
						aTransaction->iBusId = aBusId;
						r = (((DIicBusChannelMasterSlave*) chanPtr)->QueueTransaction(aTransaction));
						}
					break;
					}
				case DIicBusChannel::EMaster:
					{
					r = RequestTypeSupported(aBusId, (DIicBusChannelMaster*)chanPtr);
					if(r == KErrNone)
						{
						aTransaction->iBusId = aBusId;
						r = (((DIicBusChannelMaster*) chanPtr)->QueueTransaction(aTransaction));
						}
					break;
					}
				default:
					{
					r = KErrGeneral;
					}
				}
			}
		}
	FreeChanReadAccess();
	return r;
	}

TInt DIicBusController::QueueTransaction(TInt aBusId, TIicBusTransaction* aTransaction, TIicBusCallback* aCallback)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::QueueTransaction, aBusId=0x%x,aTransaction=0x%x,aCallback=0x%x\n",aBusId,aTransaction,aCallback));
	if(!aTransaction || !aCallback)
		{
		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)
		{
		r = GetChanPtr(aBusId, dumInt, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				switch(chanPtr->ChannelType())
					{
					// 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:
						{
						r = RequestTypeSupported(aBusId, ((DIicBusChannelMasterSlave*)chanPtr)->iMasterChannel);
						if(r == KErrNone)
							{
							aTransaction->iBusId = aBusId;
							r = (((DIicBusChannelMasterSlave*) chanPtr)->QueueTransaction(aTransaction, aCallback));
							}
						break;
						}
					case DIicBusChannel::EMaster:
						{
						r = RequestTypeSupported(aBusId, (DIicBusChannelMaster*)chanPtr);
						if(r == KErrNone)
							{
							aTransaction->iBusId = aBusId;
							r = (((DIicBusChannelMaster*) chanPtr)->QueueTransaction(aTransaction, aCallback));
							}
						break;
						}
					default:
						{
						r = KErrGeneral;
						}
					}
				}
			}
		}
	FreeChanReadAccess();
	return r;
	}


TInt DIicBusController::GetChanPtr(const TInt aBusId, TInt &aIndex, DIicBusChannel*& aChan)
	{
    __KTRACE_OPT(KIIC, 	Kern::Printf("DIicBusController::GetChanPtr, aBusId=0x%x\n",aBusId));

	TInt32 chanId;
	chanId = GET_CHAN_NUM(aBusId);

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::GetChanPtr, chanId=0x%x\n", chanId));
	DIicBusChannelSearcher searchChannel(DIicBusChannel::EMasterSlave, DIicBusChannel::ESccb, DIicBusChannel::EFullDuplex);
	searchChannel.SetChannelNumber((TInt8)chanId);

	TInt r = KErrNotFound;
	aIndex = iChannelArray.FindInOrder(&searchChannel, EntryOrder);
	if(aIndex >= 0)
		{
		aChan = iChannelArray[aIndex];
		r = KErrNone;
		}

	__KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::GetChanPtr, chanPtr=0x%x, index=%d\n", aChan, aIndex));
	return r;
	}


TInt DIicBusController::CancelTransaction(TInt aBusId, TIicBusTransaction* aTransaction)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::CancelTransaction, aBusId=0x%x,aTransaction=0x%x\n", aBusId, aTransaction));
	if(!aTransaction)
		{
		return KErrArgument;
		}

	// Get 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)
		{
		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->ChannelType())
					{
					case DIicBusChannel::ESlave:
						{
						r = KErrNotSupported;
						break;
						}
					case DIicBusChannel::EMasterSlave:
						{
						r = RequestTypeSupported(aBusId, ((DIicBusChannelMasterSlave*)chanPtr)->iMasterChannel);
						if(r == KErrNone)
							{
							r = (((DIicBusChannelMasterSlave*) chanPtr)->CancelTransaction(aTransaction));
							}
						break;
						}
					case DIicBusChannel::EMaster:
						{
						r = RequestTypeSupported(aBusId, (DIicBusChannelMaster*)chanPtr);
						if(r == KErrNone)
							{
							r = (((DIicBusChannelMaster*) chanPtr)->CancelTransaction(aTransaction));
							}
						break;
						}
					default:
						{
						r = KErrGeneral;
						}
					}
				}
			}
		}
	FreeChanReadAccess();
	return r;
	}

	// Slave-side API
TInt DIicBusController::CaptureChannel(TInt aBusId, TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch)
	{
	// Check that that aCallback!=NULL and aConfigHdr!=NULL - if not, return KErrArgument
	if(!aCallback || !aConfigHdr)
		{
		return KErrArgument;
		}

	// Get the channel
	TInt chanIndex = 0;
	DIicBusChannel* chanPtr = NULL;

	// Can only read the channel array if it is not currently being modified
	TInt r = GetChanReadAccess();
	if(r == KErrNone)
		{
		r = GetChanPtr(aBusId, chanIndex, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				DIicBusChannelSlave* slaveChanPtr = NULL;
				switch(chanPtr->ChannelType())
					{
					// CaptureChannel requests are only supported by channels in Slave mode.
					case DIicBusChannel::EMaster:
						{
						r = KErrNotSupported;
						break;
						}
					case DIicBusChannel::EMasterSlave:
						{
						slaveChanPtr = ((DIicBusChannelMasterSlave*) chanPtr)->iSlaveChannel;
						__ASSERT_DEBUG(slaveChanPtr!=NULL, Kern::Fault(KIicPanic,__LINE__)); // MasterSlave channel should have a valid Slave channel
						// Send the request to the channel
						slaveChanPtr->iController = this;
						r = ((DIicBusChannelMasterSlave*) chanPtr)->CaptureChannel(aConfigHdr, aCallback, aChannelId, aAsynch);
						break;
						}
					case DIicBusChannel::ESlave:
						{
						slaveChanPtr = (DIicBusChannelSlave*) chanPtr; // chanPtr is non-NULL
						// Send the request to the channel
						slaveChanPtr->iController = this;
						r = (slaveChanPtr->CaptureChannel(aConfigHdr, aCallback, aChannelId, aAsynch));
						break;
						}
					default:
						{
						r = KErrArgument;
						}
					}
				// For synchronous capture, if successful then install the channel
				if(r == KErrNone && slaveChanPtr)
					{
					if(!aAsynch)
						{
						InstallCapturedChannel(aChannelId, slaveChanPtr);
						}
					}
				}
			}
		}
	FreeChanReadAccess();
	return r;
	}


TInt DIicBusController::GetSlaveChanPtr(TInt aChannelId, DIicBusChannelSlave*& aSlaveChanPtr)
	{
	TInt r=KErrNone;
	// Check that the channelID is recognised
	TCapturedChannel capturedChan(aChannelId,NULL);
	TInt chanIndex=-1;
	// Ensure the array of captured channels will not be modified before it has been searched
	// Because searches 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=FindCapturedChanById(capturedChan, chanIndex);
	if((chanIndex < 0)||(r == KErrNotFound))
		r=KErrArgument;
	else
		aSlaveChanPtr = (DIicBusChannelSlave*)(iCapturedChannels[chanIndex].iChanPtr);
	__SPIN_UNLOCK_IRQRESTORE(*iCaptLock,captIntState);

	__ASSERT_DEBUG(aSlaveChanPtr!=NULL, Kern::Fault(KIicPanic,__LINE__));
	return r;
	}


TInt DIicBusController::ReleaseChannel(TInt aChannelId)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::ReleaseChannel, channelID = 0x%x \n",aChannelId));
	TInt r = KErrNone;
	DIicBusChannel* chanPtr = NULL;
	
	// Get the pointer to the Slave Channel
	DIicBusChannelSlave* slaveChanPtr = NULL;
	if((r = GetSlaveChanPtr(aChannelId, slaveChanPtr)) != KErrNone)
		return r;
		
	DIicBusChannelSearcher searchChannel(DIicBusChannel::EMasterSlave, DIicBusChannel::ESccb, DIicBusChannel::EFullDuplex);
	searchChannel.SetChannelNumber(slaveChanPtr->ChannelNumber());

	TInt dumIndex = iChannelArray.FindInOrder(&searchChannel, EntryOrder);
	if(dumIndex < 0)
		{
		return KErrNotFound;
		}
	chanPtr = iChannelArray[dumIndex];

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

	//if it is the masterslave channel, then call the masterslave's RelaseChannel
	// which will call the slave channel's ReleaseChannel internally
	if(chanPtr->ChannelType() == DIicBusChannel::EMasterSlave)
		r = ((DIicBusChannelMasterSlave*)chanPtr)->ReleaseChannel();
	else // Call the slave only ReleaseChannel
		r = slaveChanPtr->ReleaseChannel();
	
	// In either case de-install the captured slave channel
	if(r == KErrNone)
		{
		r = DeInstallCapturedChannel(aChannelId, slaveChanPtr);
		}

	// No need to unset iController - there is only one IIC Controller
	return r;
	}


TInt DIicBusController::RegisterRxBuffer(TInt aChannelId, TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RegisterRxBuffer, channelID=0x%x,aRxBuffer=0x%x,aBufGranularity=0x%x,aNumWords=0x%x,aOffset=0x%x \n",aChannelId,(TInt)&aRxBuffer,aBufGranularity,aNumWords,aOffset));

    // Acquire the pointer to the Slave Channel
	DIicBusChannelSlave* slaveChanPtr = NULL;
	TInt r = GetSlaveChanPtr(aChannelId, slaveChanPtr);
	if(r != KErrNone)
		{
		return r;
		}

	// Instigate the channel functionality
	return(slaveChanPtr->RegisterRxBuffer(aRxBuffer,aBufGranularity,aNumWords,aOffset));
	}

TInt DIicBusController::RegisterTxBuffer(TInt aChannelId, TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::RegisterTxBuffer, channelID=0x%x,aTxBuffer=0x%x,aBufGranularity=0x%x,aNumWords=0x%x,aOffset=0x%x \n",aChannelId,(TInt)&aTxBuffer,aBufGranularity,aNumWords,aOffset));

	// Acquire the pointer to the Slave Channel
	DIicBusChannelSlave* slaveChanPtr = NULL;
	TInt r = GetSlaveChanPtr(aChannelId, slaveChanPtr);
	if(r != KErrNone)
		{
		return r;
		}

	// Instigate the channel functionality
	return (slaveChanPtr->RegisterTxBuffer(aTxBuffer, aBufGranularity, aNumWords, aOffset));
	}


TInt DIicBusController::SetNotificationTrigger(TInt aChannelId, TInt aTrigger)
	{
    __KTRACE_OPT(KIIC, Kern::Printf("DIicBusController::SetNotificationTrigger - for aChannelId=0x%x, aTrigger=0x%x\n",aChannelId,aTrigger));
	// Acquire the pointer to the Slave Channel
	DIicBusChannelSlave* slaveChanPtr = NULL;
	TInt r = GetSlaveChanPtr(aChannelId, slaveChanPtr);
	if( r != KErrNone)
		{
		return r;
		}

	// Instigate the channel functionality
	return(slaveChanPtr->SetNotificationTrigger(aTrigger));
	}


TInt DIicBusController::StaticExtension(TUint aId, TUint aFunction, TAny* aParam1, TAny* aParam2)
	{
//		The IIC controller and channel classes are generic, and can serve many differing client and
//		bus implementations. If a client and bus make use of specific functionality that is not
//		common to other bus types, it makes sense to provide only the minimum-required support in the
//		generic code. Here, the channel identifier is checked but all other parameters are passed
//		directly to the bus implementation channel for processing; if the channel does not provide
//		StaticExtension implementation, the generic DIicBusChannel::StaticExtension method is invoked.

#ifdef IIC_INSTRUMENTATION_MACRO
	if((aFunction & KControlIoMask) == KMasterSlaveControlIo)
		{
		IIC_MSSTATEXT_START_PIL_TRACE
		}
	else if((aFunction & KControlIoMask) == KMasterControlIo)
		{
		IIC_MSTATEXT_START_PIL_TRACE
		}
	else if((aFunction & KControlIoMask) == KSlaveControlIo)
		{
		IIC_SSTATEXT_START_PIL_TRACE
		}
//	else - Unexpected value - just pass silently to the PSL ...
#endif

	// Get 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)
		{
		r = GetChanPtr(aId, dumInt, chanPtr);
		if(r == KErrNone)
			{
			if(!chanPtr)
				{
				r = KErrArgument;
				}
			else
				{
				r = chanPtr->StaticExtension(aFunction, aParam1, aParam2);
				}
			}
		}

#ifdef IIC_INSTRUMENTATION_MACRO
	if((aFunction & KControlIoMask) == KMasterSlaveControlIo)
		{
		IIC_MSSTATEXT_START_PIL_TRACE
		}
	else if((aFunction & KControlIoMask) == KMasterControlIo)
		{
		IIC_MSTATEXT_START_PIL_TRACE
		}
	else if((aFunction & KControlIoMask) == KSlaveControlIo)
		{
		IIC_SSTATEXT_START_PIL_TRACE
		}
//	else	... do nothing
#endif
	FreeChanReadAccess();
	return r;
	}


#ifdef _DEBUG

void DIicBusController::DumpCapturedChannels()
	{
	// Print iCapturedChannels ...
	TInt count=0;
	TInt i=0;
	TCapturedChannel emptyChan;
	for(;i<KMaxNumCapturedChannels;++i)
		{
		if(iCapturedChannels[i] == emptyChan)
			continue;
		++count;
		}

	i = 0;
    __KTRACE_OPT(KIIC, Kern::Printf("	- Count gave %d\n",count));
	for(;i<KMaxNumCapturedChannels;++i)
		{
		if(iCapturedChannels[i] == emptyChan)
			continue;
		DIicBusChannel* ptr=(DIicBusChannel*)(iCapturedChannels[i]).iChanPtr;
	    __KTRACE_OPT(KIIC, Kern::Printf("	- ptr %d=0x%x\n",i,ptr));
		ptr->StaticExtension(KCtrlIoDumpChan,0,0);
		};
	}

void DIicBusController::DumpChannelArray()
	{
	TInt i = 0;
	__KTRACE_OPT(KIIC, Kern::Printf("\nDIicBusController::DumpChannelArray\n"));
    __KTRACE_OPT(KIIC, Kern::Printf("	- Count gave %d\n",iChannelArray.Count()));
	for(i=0; i<iChannelArray.Count(); i++)
		{
		DIicBusChannel* ptr=iChannelArray[i];
	    __KTRACE_OPT(KIIC, Kern::Printf("	- ptr %d=0x%x\n",i,ptr));
		ptr->StaticExtension(KCtrlIoDumpChan,0,0);
		};
	}

#endif

#ifdef IIC_SIMULATED_PSL
TVersion DIicPdd::VersionRequired()
	{
	const TInt KIicMajorVersionNumber=1;
	const TInt KIicMinorVersionNumber=0;
	const TInt KIicBuildVersionNumber=KE32BuildVersionNumber;
	return TVersion(KIicMajorVersionNumber,KIicMinorVersionNumber,KIicBuildVersionNumber);
	}

/** Factory class constructor */
DIicPdd::DIicPdd()
	{
    iVersion = DIicPdd::VersionRequired();
	}

DIicPdd::~DIicPdd()
	{
	delete TheController;
	}

TInt DIicPdd::Install()
    {
    return(SetName(&KPddName));
    }

/**  Called by the kernel's device driver framework to create a Physical Channel. */
TInt DIicPdd::Create(DBase*& /*aChannel*/, TInt /*aUint*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)
    {
    return KErrNone;
    }

/**  Called by the kernel's device driver framework to check if this PDD is suitable for use with a Logical Channel.*/
TInt DIicPdd::Validate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
    {
   	if (!Kern::QueryVersionSupported(DIicPdd::VersionRequired(),aVer))
		return(KErrNotSupported);
    return KErrNone;
    }

/** Return the driver capabilities */
void DIicPdd::GetCaps(TDes8& aDes) const
    {
	// Create a capabilities object
	TCaps caps;
	caps.iVersion = iVersion;
	// Zero the buffer
	TInt maxLen = aDes.MaxLength();
	aDes.FillZ(maxLen);
	// Copy cpabilities
	TInt size=sizeof(caps);
	if(size>maxLen)
	   size=maxLen;
	aDes.Copy((TUint8*)&caps,size);
    }
#endif

#ifndef IIC_SIMULATED_PSL
// Client interface entry point
DECLARE_EXTENSION_WITH_PRIORITY(KExtensionMaximumPriority-1)	// highest priority after Resource Manager
	{
	TheController = new DIicBusController;
	if(!TheController)
		return KErrNoMemory;
	TInt r=TheController->Create();
	return r;
	}
#else
static DIicPdd* TheIicPdd;

DECLARE_STANDARD_PDD()
	{
	TheController = new DIicBusController;
	if(!TheController)
		return NULL;
	TInt r = TheController->Create();
	if(r == KErrNone)
		{
		TheIicPdd = new DIicPdd;
		if(TheIicPdd)
			return TheIicPdd;
		}
	
	delete TheController; 
	return NULL;
	}
#endif