diff -r 000000000000 -r a41df078684a kernel/eka/include/drivers/iic_channel.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/drivers/iic_channel.h	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,901 @@
+// 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/include/drivers/iic_channel.h
+// Include file for channel implementation
+//
+// WARNING: This file contains some APIs which are internal and are subject
+//          to change without notice. Such APIs should therefore not be used
+//          outside the Kernel and Hardware Services package.
+
+/**
+@file
+@internalTechnology
+*/
+#ifndef __IIC_CHANNEL_H__
+#define __IIC_CHANNEL_H__
+
+#ifdef STANDALONE_CHANNEL
+#include <drivers/iic_transaction.h>
+#else
+#include <drivers/iic.h>
+#endif
+
+static const char KIicChannelPanic[]="Iic Channel PIL";
+
+const static TInt KChannelTypeMask	= 0x03;
+const static TInt KBusTypeShift		= 2;
+const static TInt KBusTypeMask		= 0x07<<KBusTypeShift; // number of buses may grow in future
+const static TInt KChannelDuplexShift= 5;
+const static TInt KChannelDuplexMask	= 0x01<<KChannelDuplexShift;
+const static TInt16 KTransCountMsBit = (TInt16)((TUint16)0x8000);
+
+const static TInt8 KMaxWaitTime = 0x21; // Maximum allowable time in milliseconds for a Slave channel to wait for a response
+										// (from Master or Client). This constant is used to limit run-time selected values
+										// for timeouts. The value stated here is semi-arbitrary.
+
+#ifdef IIC_SIMULATED_PSL
+// In a real system, the following timeout values are likely to be excessive. However, they are available
+// for use in the test framework, to account for the processing overhead.
+const TInt KSlaveDefMWaitTime = 32;
+const TInt KSlaveDefCWaitTime = 16;
+#else
+const TInt KSlaveDefMWaitTime = 1;	// Default wait time for Master timeout. PSL can use SetMasterWaitTime to override.
+const TInt KSlaveDefCWaitTime = 1;	// Default wait time for Client timeout. PSL can use SetClientWaitTime to override.
+#endif
+
+
+/**
+@internalComponent
+@prototype 9.6
+Base class for a Channel (not directly instantiable)
+*/
+class DIicBusChannel : public DBase
+	{
+public:
+	enum TChannelType
+		{
+		EMaster			= 0,
+		ESlave			= 0x01,
+		EMasterSlave	= 0x02
+		};
+	enum TBusType
+		{
+		EI2c	   = 0,
+		ESpi	   = 0x01,
+		EMicrowire = 0x02,
+		ECci	   = 0x03,
+		ESccb	   = 0x04
+		};
+	enum TChannelDuplex
+		{
+		EHalfDuplex = 0,	// supports only half duplex transactions (even if bus spec supports full duplex)
+		EFullDuplex = 0x1	// supports full duplex transactions (queud transactions may still be half duplex)
+		};
+
+public:
+	virtual TInt StaticExtension(TUint aFunction, TAny* /*aParam1*/, TAny* /*aParam2*/)
+		{
+#ifdef _DEBUG
+		if(aFunction == KCtrlIoDumpChan)
+			{
+			DumpChannel();
+			return KErrNone;
+			}
+		else
+#else
+			(void)aFunction;
+#endif
+
+			return KErrNotSupported;
+		};
+protected:
+	// constructor
+	inline DIicBusChannel(TChannelType aChanType, TBusType aBusType, TChannelDuplex aChanDuplex);
+	// second phase construction - empty, to be implemented by derived types if required
+	virtual TInt DoCreate()=0;
+
+	// helper function to read an set flags
+	inline TChannelType ChannelType();
+	inline void SetChannelType(TChannelType aChanType);
+	inline TBusType BusType();
+	inline void SetBusType(TBusType aBusType);
+	inline TChannelDuplex ChannelDuplex();
+	inline void SetChannelType(TChannelDuplex aChanDuplex);
+	inline TInt8 ChannelNumber() const;
+
+	virtual TInt CheckHdr(TDes8* aHdr) = 0;	// PSL to check the header is valid for this channel
+protected:
+#ifdef _DEBUG
+	inline void DumpChannel();
+#endif
+protected:
+	NTimer iTimeoutTimer;	// timeout timer
+	TInt8 iChannelNumber;	// this is the Key for ordering channels in the array
+	TUint8 iFlags;			// combination of TChannelType, TChannelDuplex and TBusType
+	TInt8 iSpare1;
+	TInt8 iSpare2;
+private:
+	TAny* iReserved;
+
+	friend class DIicBusController;
+	};
+
+/**
+@publishedPartner
+@prototype 9.6
+
+Base class for a Master Channel (not directly instantiable)
+
+*/
+class DIicBusChannelMaster : public DIicBusChannel
+	{
+public:
+	// interface to Bus Controller (implemented by PIL)
+	// For stand-alone channel, there is no controller. So some parts of
+	// the interface are exported for client direct use. 
+	/**
+    @publishedPartner
+    @prototype 9.6
+    Master channel interface to queue a transaction synchronously.
+
+    @param aTransaction		A pointer to a transaction object containing the details of the transaction.
+
+    @return KErrNone, when successfully completed;
+			KErrArgument, if aTransaction is NULL;
+			KErrTimedOut, if the channel terminates the transaction because  the addressed Slave exceeded the alloted time to respond;
+            KErrNotSupported, if either the channel does not support Master mode or the transaction is not valid on this channel (e.g. valid full duplex transaction queued on half duplex channel).
+    */
+	virtual TInt QueueTransaction(TIicBusTransaction* aTransaction);
+    /**
+	@publishedPartner
+	@prototype 9.6
+    Master channel interface to queue a transaction asynchronously.
+
+    @param aTransaction		A pointer to a transaction object containing the details of the transaction.
+    @param aCallback		A pointer to a callback object.
+
+    @return KErrNone, if successfully accepted; KErrArgument, if either aTransaction or aCallback are NULL;
+            KErrNotSupported, if either the channel does not support Master mode or the transaction is not valid on this channel(e.g. valid full duplex transaction queued on half duplex channel).
+    */
+	virtual TInt QueueTransaction(TIicBusTransaction* aTransaction, TIicBusCallback* aCallback);
+    /**
+	@publishedPartner
+	@prototype 9.6
+    Master channel interface to cancel a previously queued transaction.
+
+    @param aTransaction		A pointer to a transaction object containing the details of the transaction.
+
+    @return KErrCancel, if successfully cancelled; KErrArgument, if aTransaction is NULL;
+			KErrNotFound if the transaction cannot be found on channel's queue of transactions;
+			KErrInUse if this method is called on a transaction that has already been started;
+            KErrNotSupported, if the channel does not support Master mode, or the method is called on a synchronous transaction..
+    */
+	virtual TInt CancelTransaction(TIicBusTransaction* aTransaction);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Master channel interface interface to provide extended functionality
+
+    @param aFunction	A function identifier. If bit 31 is set and bit 30 cleared it is used to extend the Master-Slave channel;
+						if bit 31 is cleared and bit 30 is set, it extends the Master channel; if both bits 31 and 30 are cleared it
+						extends the Slave channel interface.
+    @param aParam1		A generic argument to be passed to the function identified by aFunction.
+    @param aParam2		A generic argument to be passed to the function identified by aFunction.
+
+    @return KErrNone, if successful;
+			KErrNotSupported, function is not supported;
+			Any other system wide error code.
+	*/
+	virtual TInt StaticExtension(TUint aFunction, TAny* aParam1, TAny* aParam2);
+
+//
+	virtual TInt Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2);
+
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Destructor for DIicBusChannelMaster
+	*/
+	~DIicBusChannelMaster();
+
+protected:
+	// PSL implemented
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Gateway function for PSL implementation (to be called by the interface APIs)
+	*/
+	virtual TInt DoRequest(TIicBusTransaction* aTransaction) = 0;
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function to be invoked in the event of a Slave timeout. May be overridden by the PSL.
+	*/
+	virtual TInt HandleSlaveTimeout() = 0;
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Second phase constructor to be implemented by the PSL
+	*/
+	virtual TInt DoCreate() = 0;
+
+	// Called by PSL
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Constructor for DIicBusChannelMaster
+
+	@param aBusType		Argument to specify the type of Bus
+    @param aChanDuplex	Argument to specify the duplex support offered by this channel
+	*/
+	DIicBusChannelMaster(TBusType aBusType, TChannelDuplex aChanDuplex);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function to instigate DIicBusChannel initialisation
+
+	@return KErrNone if no error
+			KErrNoMemory if allocation of required objects
+	*/
+	TInt Init();
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to start the timer to check the Slave responsiveness.
+
+	@param aTime		Timeout in milliseconds
+
+	@return KErrNone if no error,
+			KErrInUse if timer is already active.
+
+	*/
+	TInt StartSlaveTimeOutTimer(TInt aTime);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to specify the DFC queue for the channel to use
+
+	@param aDfcQue		Pointer to the DFC queue to use
+
+	*/
+	void SetDfcQ(TDfcQue* aDfcQue);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to Complete the transaction being processed by the channel
+
+	@param aResult		Error code to complete the transaction with
+
+	*/
+	void CompleteRequest(TInt aResult);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to cancel the timer to check the Slave responsiveness.
+
+	*/
+	void CancelTimeOut();
+
+	// Methods to make private data of TIicBusTransaction object accessible to derivatives of this class
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the Transaction Header of a specified TIicBusTransaction object
+
+	@return The Transaction Header of the specified TIicBusTransaction object
+
+	@see TIicBusTransaction
+	*/
+	static inline TDes8* GetTransactionHeader(const TIicBusTransaction* aTransaction);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the Half Duplex Transfer pointer of a specified TIicBusTransaction object
+
+	@return The Half Duplex Transfer pointer of the specified TIicBusTransaction object
+
+	@see TIicBusTransaction
+	*/
+	static inline TIicBusTransfer* GetTransHalfDuplexTferPtr(const TIicBusTransaction* aTransaction);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the Full Duplex Transfer pointer of a specified TIicBusTransaction object
+
+	@return The Full Duplex Transfer pointer of the specified TIicBusTransaction object
+
+	@see TIicBusTransaction
+	*/
+	static inline TIicBusTransfer* GetTransFullDuplexTferPtr(const TIicBusTransaction* aTransaction);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the address of the callback object of a specified TIicBusTransaction object
+
+	@return The address of the callback object of the specified TIicBusTransaction object
+
+	@see TIicBusTransaction
+	*/
+	static inline TIicBusCallback* GetTransCallback(const TIicBusTransaction* aTransaction);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the value of the TransFlags member of a specified TIicBusTransaction object
+
+	@return The value of the TransFlags member of the specified TIicBusTransaction object
+
+	@see TIicBusTransaction
+	*/
+	static inline TUint8 GetTransFlags(const TIicBusTransaction* aTransaction);
+
+	// Methods to make private data of TIicBusTransfer object accessible to derivatives of this class
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return Transfer Type the of a specified TIicBusTransfer object
+
+	@return The Transfer Type of the specified TIicBusTransfer object
+
+	@see TIicBusTransfer
+	*/
+	static inline TInt8 GetTferType(const TIicBusTransfer* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the Buffer Granularity of a specified TIicBusTransfer object
+
+	@return The Buffer Granularity of the specified TIicBusTransfer object
+
+	@see TIicBusTransfer
+	*/
+	static inline TInt8 GetTferBufGranularity(const TIicBusTransfer* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the descriptor for the data for a specified TIicBusTransfer object
+
+	@return The descriptor for the data for the specified TIicBusTransfer object
+
+	@see TIicBusTransfer
+	*/
+	static inline const TDes8* GetTferBuffer(const TIicBusTransfer* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the address of the next transfer for a specified TIicBusTransfer object
+
+	@return The address of the next transfer for the specified TIicBusTransfer object
+
+	@see TIicBusTransfer
+	*/
+	static inline TIicBusTransfer* GetTferNextTfer(const TIicBusTransfer* aTransfer);
+
+	// Methods to make private data of TIicBusTransactionPreamble object accessible to derivatives of this class
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function pointer for a specified TIicBusTransactionPreamble object
+
+	@return The function pointer for the specified TIicBusTransactionPreamble object
+
+	@see TIicBusTransactionPreamble
+	*/
+	static inline TIicBusPreamble GetPreambleFuncPtr(const TIicBusTransactionPreamble* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function argument for a specified TIicBusTransactionPreamble object
+
+	@return The function argument for the specified TIicBusTransactionPreamble object
+
+	@see TIicBusTransactionPreamble
+	*/
+	static inline TAny* GetPreambleFuncArg(const TIicBusTransactionPreamble* aTransfer);
+
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function pointer of a specified TIicBusTransactionMultiTransc object
+
+	@return The function pointer of the specified TIicBusTransactionMultiTransc object
+
+	@see TIicBusTransactionMultiTransc
+	*/
+	static inline TIicBusMultiTranscCbFn GetMultiTranscFuncPtr(const TIicBusTransactionMultiTransc* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function argument of a specified TIicBusTransactionMultiTransc object
+
+	@return The function argument of the specified TIicBusTransactionMultiTransc object
+
+	@see TIicBusTransactionMultiTransc
+	*/
+	static inline TAny* GetMultiTranscFuncArg(const TIicBusTransactionMultiTransc* aTransfer);
+
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function pointer of a specified TIicBusTransactionPreambleExt object
+
+	@return The function pointer of the specified TIicBusTransactionPreambleExt object
+
+	@see TIicBusTransaction
+	*/
+	static inline TIicBusMultiTranscCbFn GetExtTranscFuncPtr(const TIicBusTransactionPreambleExt* aTransfer);
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Function to return the function argument of a specified TIicBusTransactionPreambleExt object
+
+	@return The function argument of the specified TIicBusTransactionPreambleExt object
+
+	@see TIicBusTransaction
+	*/
+	static inline TAny* GetExtTranscFuncArg(const TIicBusTransactionPreambleExt* aTransfer);
+
+private:
+	// Function to acquire the NFastMutex of the channel
+	void Lock();
+	// Function to release the NFastMutex of the channel
+	void Unlock();
+
+	// function to run on receiving a message
+    static void MsgQFunc(TAny* aPtr);
+
+	TIicBusTransaction* NextTrans(TIicBusTransaction* aTrans);
+	void EndTransaction(TIicBusTransaction* aTrans, TInt aResult, TIicBusCallback* aCb);
+	void Complete(TInt aResult, TIicBusTransaction* aTransaction);
+	void UnlockAndKick();
+
+	static void SlaveTimeoutCallback(TAny*);
+
+	// Used by DIidBusController (a friend of this class)
+	TInt TransFlow(TIicBusTransaction* aTransaction);
+
+	TInt8 IsMasterBusy();
+
+protected:
+	TDfcQue* iDfcQ;
+
+private:
+	TDfc iTransQDfc;
+	SOrdQue iTransactionQ;
+	TIicBusTransaction* iTransaction;			// Pointer to current transaction
+	TIicBusTransaction* iCurrentTransaction;	// Pointer to current fragment of a multiple transaction
+
+	NFastMutex iTransactionQLock;
+
+	TDfc* iSlaveTimeoutDfc;
+
+	TInt16 iTransCount; // Count of pending transactions
+	TInt8 iChannelReady;
+	TInt8 iSpare1;
+
+private:
+	TAny* iReserved1;
+	TAny* iReserved2;
+
+	friend class DIicBusChannelMasterSlave;
+	friend class DIicBusController; // For static method DIicBusController::DeRegisterChannel
+	};
+
+
+/**
+@publishedPartner
+@prototype 9.6
+
+Base class for a Slave Channel (not directly instantiable)
+
+*/
+class DIicBusChannelSlave : public DIicBusChannel
+	{
+protected:
+    /**
+	@publishedPartner
+	@prototype 9.6
+	The set of operation values for processing by the PSL
+    */
+	enum TPslOperation
+		{
+		ESyncConfigPwrUp = 0x01,
+		EAsyncConfigPwrUp = 0x02,
+		EPowerDown = 0x04,
+		ETransmit = 0x08,
+		EReceive = 0x10,
+		EAbort = 0x20
+		};
+private:
+	// Values used by the internal state machine
+	enum TSlaveTimerStates
+		{
+		EInactive = 0x01,
+		EWaitForMaster = 0x02,
+		EWaitForClient = 0x04,
+		EClientTimeout = 0x08
+		};
+
+public:
+
+	// Interface to Controller.
+    // For stand-alone channel, the interface is exported.
+    /**
+    @publishedPartner
+    @prototype 9.6
+    Capture this Slave channel.
+
+    @param aConfigHdr	A pointer to a descriptor containing the device specific configuration option applicable to all transactions.
+    @param aCallback	A pointer to a callback to be called upon specified triggers.
+    @param aChannelId	If this API is to complete synchronously, and the processing was successful, then on return aChannelId
+                      contains a platform-specific cookie that uniquely identifies the channel instance to be used by this client.
+                      If the processing was unsuccessful for the synchronous completion case, aChannelId will be unchanged.
+                      If the API was called to complete asynchronously, aChannelId will, in all cases, be set to zero; the valid
+                      value for the cookie will be set by the callback.
+    @param aAsynch		A boolean value that indicates if this API is to complete synchronously (EFalse) or asynchronously (ETrue).
+
+    @return KErrNone, if successfully captured, or if API is asynchronous, if the request to capture the channel was accepted;
+			KErrInUse if channel is already in use; KErrArgument, if aCallback is NULL;
+            KErrNotSupported, if the channel does not support Slave mode.
+    */
+	virtual TInt CaptureChannel(TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch);
+	/**
+	@publishedPartner
+	@prototype 9.6
+    Release this previously captured Slave channel.
+
+    @return KErrNone, if successfully released;
+			KErrInUse if a transaction is currently underway on this channel; KErrArgument
+    */
+	virtual TInt ReleaseChannel();
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Register a receive buffer with this Slave channel.
+
+    @param aRxBuffer	A pointer to the receive buffer, in a client created descriptor.
+	@param aBufGranularity The number of buffer bytes used to store a word.
+    @param aNumWords	The number of words expected to be received.
+    @param aOffset		The offset from the start of the buffer where to store the received data.
+
+    @return KErrNone, if successfully registered;
+			KErrAlreadyExists if a receive buffer is already pending;
+			KErrArgument, if the pointer descriptor is NULL;
+    */
+	virtual TInt RegisterRxBuffer(TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Register a transmit buffer with this Slave channel.
+	This client may create a single buffer for the entire transaction and control where the received data
+	is to be placed and the transmit data is to be found, by specifying the number of bytes to transmit (receive)
+	and the offset into the buffer.
+
+    @param aTxBuffer	A pointer to the transmit buffer, in a client created descriptor.
+	@param aBufGranularity The number of buffer bytes used to store a word.
+    @param aNumWords	The number of words to be transmitted.
+    @param aOffset		The offset from the start of the buffer where to fetch the data to be transmitted.
+
+    @return KErrNone, if successfully registered;
+			KErrAlreadyExists if a transmit buffer is already pending;
+			KErrArgument, if the pointer descriptor is NULL;
+    */
+	virtual TInt RegisterTxBuffer(TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Sets the notification triggers and readies the receive path and/or kick starts a transmit (if the node is being addressed).
+	It is only after a receive buffer has been registered and this API has been called that the channel is ready to receive data (when addressed).
+	If a transmit buffer has been registered and this API has been called the channel will immediately transmit when addressed by the Master
+	If the channel supports full duplex, both paths can be readied in one call to this API.
+
+    @param aTrigger		A bitmask specifying the notification trigger. Masks for individual triggers are specified by the TIicBusSlaveTrigger enumeration.
+
+    @return KErrNone, if successful;
+			KErrArgument, if the trigger is invalid for this channel;
+			KErrInUse if a transaction is already underway on this channel;
+			KErrTimedOut, if the client exceeded the alloted time to respond by invoking this API;
+    */
+	virtual TInt SetNotificationTrigger(TInt aTrigger);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Interface to provide extended functionality
+
+    @param aFunction	A function identifier. If bit 31 is set and bit 30 cleared it is used to extend the Master-Slave channel;
+						if bit 31 is cleared and bit 30 is set, it extends the Master channel; if both bits 31 and 30 are cleared it
+						extends the Slave channel interface.
+    @param aParam1		A generic argument to be passed to the function identified by aFunction.
+    @param aParam2		A generic argument to be passed to the function identified by aFunction.
+
+    @return KErrNone, if successful;
+			KErrNotSupported, function is not supported;
+			Any other system wide error code.
+	*/
+	virtual TInt StaticExtension(TUint aFunction, TAny* aParam1, TAny* aParam2);
+//
+	/**
+	@internalTechnology
+	@prototype 9.6
+	Function reserved for future use
+	*/
+	virtual TInt Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2);
+
+	// Interface to TIicBusSlaveCallback
+	// channel-specific function to process data received/transmitted (called from NotifyClient or DFC queued from it)
+	// Must fill in the aCb object's iReturn, iRxWords and/or iTxWords using the appropriate funtions
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked when an asynchronous event occurs on the Slave channel. Implemented by the PSL.
+    @param aTrigger		Argument to indicate the type of event that occurred
+    @param aCb			Address of the Slave client callback object to process
+
+    @return KErrNone, if successful;
+			KErrNotSupported, function is not supported;
+			Any other system wide error code.
+	*/
+#ifdef STANDALONE_CHANNEL
+	friend class TIicBusSlaveCallback;
+protected:
+    virtual void ProcessData(TInt aTrigger, TIicBusSlaveCallback*  aCb) = 0;
+private:
+    TInt UpdateReqTrig(TInt8& aCbTrigVal, TInt& aCallbackRet);
+    void StartTimerByState();
+    void StopTimer();
+#else
+public:
+    virtual void ProcessData(TInt aTrigger, TIicBusSlaveCallback*  aCb) = 0;
+    virtual TInt UpdateReqTrig(TInt8& aCbTrigVal, TInt& aCallbackRet);
+    virtual void StartTimerByState();
+    virtual void StopTimer();
+#endif
+
+public:
+	// Values used by the Interface to TIicBusSlaveCallback
+	enum TSlaveNotifProcSteps
+		{
+		EStopTimer = 0x01,
+		EInvokeCb = 0x02,
+		EStartTimer = 0x04
+		};
+
+protected:
+	// PSL implemented
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	PSL specific second phase constructor
+
+	@return KErrNone, if succesful;
+			KErrNotSupported, function is not supported;
+			Any other system wide error code.
+	*/
+	virtual TInt DoCreate() = 0;
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Gateway function for PSL implementation: aOperation is a bitmask made of TPslOperation (to be called by the  interface APIs)
+
+	@return KErrNone, if succesful;
+			KErrNotSupported, function is not supported;
+			Any other system wide error code.
+	*/
+	virtual TInt DoRequest(TInt aOperation) = 0;
+
+	// Called by PSL
+	/**
+	@publishedPartner
+	@prototype 9.6
+
+	Constructor for DIicBusChannelSlave
+
+	@param aBusType		Argument to specify the type of Bus
+    @param aChanDuplex	Argument to specify the duplex support offered by this channel
+	@param aChannelId	Argument to specify the identifier to use for this channel
+	*/
+	DIicBusChannelSlave(TBusType aBusType, TChannelDuplex aChanDuplex, TInt16 aChannelId);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function to instigate DIicBusChannelSlave initialisation
+
+	@return KErrNone
+	*/
+	TInt Init();
+	
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Destructor for DIicBusChannelSlave
+	*/
+	~DIicBusChannelSlave();
+
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked when an asynchronous channel capture completes
+
+	@param aResult		Argument specifying the error code reurned by the capture operation
+
+	@return KErrNone
+	*/
+	void ChanCaptureCallback(TInt aResult);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked to instigate processing by the PSL, PIL and Client when an asynchronous event occurs
+
+	@param aResult		Argument specifying the trigger value associated with the asynchronous event
+
+	@return KErrNone
+	*/
+	void NotifyClient(TInt aTrigger);
+
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked by the PSL to set the timeout period to wait for a response from the bus master
+
+	@param aWaitTime		Argument specifying the wait time, in milliseconds (limit=KMaxWaitTime)
+
+	@return KErrNone, if succesful;
+	KErrArgument, if aWaitTime > KMaxWaitTime
+	*/
+	TInt SetMasterWaitTime(TInt8 aWaitTime);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked by the PSL to get the timeout period to wait for a response from the bus master
+
+	@return The wait time, in milliseconds
+	*/
+	inline TInt8 GetMasterWaitTime();
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked by the PSL to set the timeout period to wait for a response from the Client
+
+	@param aWaitTime		Argument specifying the wait time, in milliseconds (limit=KMaxWaitTime)
+	@return KErrNone
+	*/
+	TInt SetClientWaitTime(TInt8 aWaitTime);
+	/**
+	@publishedPartner
+	@prototype 9.6
+	Function invoked by the PSL to get the timeout period to wait for a response from the Client
+
+	@return The wait time, in milliseconds
+	*/
+	inline TInt8 GetClientWaitTime();
+private:
+	//Method to instruct PSL to indicate a bus error to the bus Master, then return
+	void SendBusErrorAndReturn();
+	void SetChannelId(TInt& aChannelId);
+
+	void CompleteAsynchCapture(TInt aResult);
+	void SlaveTimerCallBack();
+	static void SlaveStaticCB(TAny* aDumPtr);
+
+protected:
+	TInt8 iRxGranularity;
+	TInt8 iTxGranularity;
+	TInt8 iNumRxWords;
+	TInt8 iNumTxWords;
+	TInt8 iRxOffset;
+	TInt8 iTxOffset;
+private:
+	TInt8 iChannelInUse;
+	TInt8 iSpare1;
+protected:
+	TInt16 iChannelId;		// channel identifier to be returned to client (in aChannelId)
+private:
+	TInt16 iInstanceCount;	// instance count part of aChannelId
+protected:
+	TDes8* iConfigHeader;
+	TInt8* iTxBuf;
+	TInt8* iRxBuf;
+private:
+	TIicBusSlaveCallback* iNotif;
+	TDfc* iClientTimeoutDfc;	// To be queued on the dfc queue used by iNotif
+	DThread* iClient;		// stored when client captures channel
+#ifndef STANDALONE_CHANNEL
+	DIicBusController* iController;
+#endif
+
+	TInt8 iTimerState;
+	TInt8 iMasterWaitTime;	// 8 bits allows maximum wait time of 0.25 seconds
+	TInt8 iClientWaitTime;	// 8 bits allows maximum wait time of 0.25 seconds
+	TInt8 iSpare2;
+
+	TInt8 iReqTrig;			// Represents the trigger required by the Client (bitmask from TIicBusSlaveTrigger).
+	TInt8 iAccumTrig;		// Represents the events accumulated during the current trigger period
+	TInt16 iSpare3;
+
+	TSpinLock iSpinLock;
+	TAny* iReserved1;
+	TAny* iReserved2;
+
+	friend class DIicBusChannelMasterSlave;
+	friend class DIicBusController; // For static method DIicBusController::DeRegisterChannel
+	};
+
+/**
+@internalComponent
+@prototype 9.6
+The Master-Slave Channel class (not for derivation)
+*/
+class DIicBusChannelMasterSlave : public DIicBusChannel
+	{
+public:
+	// constructor
+#ifdef STANDALONE_CHANNEL
+    IMPORT_C DIicBusChannelMasterSlave(TBusType aBusType, TChannelDuplex aChanDuplex, DIicBusChannelMaster* aMasterChan, DIicBusChannelSlave* aSlaveChan);    
+#else
+	inline DIicBusChannelMasterSlave(TBusType aBusType, TChannelDuplex aChanDuplex, DIicBusChannelMaster* aMasterChan, DIicBusChannelSlave* aSlaveChan);
+#endif
+	~DIicBusChannelMasterSlave(){delete iMasterChannel; delete iSlaveChannel; }
+	inline TInt DoCreate();
+	// Master side interface to Bus Controller
+	virtual TInt QueueTransaction(TIicBusTransaction* aTransaction);
+	virtual TInt QueueTransaction(TIicBusTransaction* aTransaction, TIicBusCallback* aCallback);
+	inline TInt CancelTransaction(TIicBusTransaction* aTransaction);
+
+	// Slave side interface to Bus Controller
+	virtual TInt CaptureChannel(TDes8* aConfigHdr, TIicBusSlaveCallback* aCallback, TInt& aChannelId, TBool aAsynch);
+	virtual TInt ReleaseChannel();  
+	inline TInt RegisterRxBuffer(TPtr8 aRxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);
+	inline TInt RegisterTxBuffer(TPtr8 aTxBuffer, TInt8 aBufGranularity, TInt8 aNumWords, TInt8 aOffset);
+	inline TInt SetNotificationTrigger(TInt aTrigger);
+	virtual TInt StaticExtension(TUint aFunction, TAny* aParam1, TAny* aParam2);
+
+private:
+	// Base class support
+	virtual TInt CheckHdr(TDes8* /*aHdr*/){	__ASSERT_DEBUG(0,Kern::Fault("DIicBusChannelMasterSlave::CheckHdr",__LINE__));	\
+											return KErrGeneral;}; // Not accessed. PSL implementation for Master or Slave used.
+protected:
+	DIicBusChannelMaster* iMasterChannel;
+	DIicBusChannelSlave* iSlaveChannel;
+private:
+
+	friend class DIicBusChannelMaster;
+	friend class DIicBusChannelSlave;
+	friend class DIicBusController; // For static method DIicBusController::DeRegisterChannel
+	};
+
+#include <drivers/iic_channel.inl>
+
+#endif  // #ifndef __IIC_CHANNEL_H__
+