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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// include/drivers/dma_v2.h

// DMA Framework - Client API v2 definition.

//

// NB: DMA clients should never include this file directly, but only ever the

// generic header file <drivers/dma.h>.

//

#ifndef __DMA_H__

#error "dma_v2.h must'n be included directly - use <drivers/dma.h> instead"

#endif	// #ifndef __DMA_H__

#ifndef __DMA_V2_H__

#define __DMA_V2_H__

#include <kernel/kernel.h>

#include <drivers/dmadefs.h>

//////////////////////////////////////////////////////////////////////////////

// Debug Support - KDmaPanicCat is defined in each source file

#define __DMA_ASSERTD(e) __ASSERT_DEBUG(e, Kern::Fault(KDmaPanicCat, __LINE__))

#define __DMA_ASSERTA(e) __ASSERT_ALWAYS(e, Kern::Fault(KDmaPanicCat, __LINE__))

#ifdef _DEBUG

#define __DMA_CANT_HAPPEN() Kern::Fault(KDmaPanicCat, __LINE__)

#define __DMA_DECLARE_INVARIANT public: void Invariant();

#define __DMA_INVARIANT() Invariant()

#else

#define __DMA_CANT_HAPPEN()

#define __DMA_DECLARE_INVARIANT

#define __DMA_INVARIANT()

#endif

//////////////////////////////////////////////////////////////////////////////

// INTERFACE EXPOSED TO DEVICE-DRIVERS

//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

/** Bitmasks used for configuring a DMA request.

	In general, specify KDmaMemSrc|KDmaIncSrc (resp. KDmaMemDest|KDmaIncDest)

	if the source (resp. destination) is a memory buffer and clear

	KDmaMemSrc|KDmaIncSrc (resp. KDmaMemDest|KDmaIncDest) if the source

	(resp. destination) is a peripheral.

	If the location is given as a physical address (rather than a linear one)

	then also specify KDmaPhysAddrSrc and/or KDmaPhysAddrDest.

	The EKA1 "Fill Mode" can be implemented by omitting KDmaIncSrc.

	Some peripherals may require a post-increment address mode.

	@see DDmaRequest::Fragment

	@publishedPartner

	@released

*/

enum TDmaRequestFlags

	{

	// Note: This enum is only required for backwards compatibility with the

	// old DMA framework, it can be removed once this is no longer needed.

	/** Source is address of memory buffer */

	KDmaMemSrc       = 0x01,

	/** Destination is address of memory buffer */

	KDmaMemDest      = 0x02,

	/** Source address must be post-incremented during transfer */

	KDmaIncSrc       = 0x04,

	/** Destination address must be post-incremented during transfer */

	KDmaIncDest      = 0x08,

	/** Source address is a physical address (as opposed to a linear one) */

	KDmaPhysAddrSrc  = 0x10,

	/** Destination address is a physical address (as opposed to a linear one) */

	KDmaPhysAddrDest = 0x20,

	/** Request a different max transfer size (for instance for test purposes) */

	KDmaAltTransferLen = 0x40

	};

/** Each hardware or pseudo descriptor is associated with a header.  Headers

	are needed because hardware descriptors can not easily be extended to store

	additional information.

	@publishedPartner

	@released

*/

struct SDmaDesHdr

	{

	SDmaDesHdr* iNext;

	};

/** Pointer to signature of the new extended callback function.

	TUint - bitmask of one or more TDmaCallbackType values

	TDmaResult - just that

	TAny* - was provided by client in DDmaRequest constructor

	SDmaDesHdr* - points to header (and thus descriptor) which caused a

	'descriptor completed' or 'descriptor paused' event.

 */

typedef void (*TDmaCallback)(TUint, TDmaResult, TAny*, SDmaDesHdr*);

class TDmaChannel;

/** A DMA request is a list of fragments small enough to be transferred in one go

	by the DMAC.

	In general, fragmentation is done in the framework by calling Fragment() but

	clients with special needs can allocate a blank descriptor list with

	ExpandDesList() and customise it to fit their needs.

	Clients should not set attributes directly, but should use the various functions

	instead.

	This class has not been designed to be called from several concurrent threads.

	Multithreaded clients must implement their own locking scheme (via DMutex).

	Mutexes are used internally to protect data structures accessed both by the

	client thread and the DFC thread. Therefore no fast mutex can be held when

	calling a request function.

	@publishedPartner

	@released

 */

class DDmaRequest : public DBase

	{

	friend class TDmaChannel;

public:

	/** The outcome of the transfer

		@deprecated

		@see TDmaResult

	*/

	enum TResult {EBadResult=0, EOk, EError};

	/** The signature of the completion/failure callback function

		@deprecated

		@see TDmaCallback

	*/

	typedef void (*TCallback)(TResult, TAny*);

public:

    /** Constructor.

		Create a new transfer request.

		@param aChannel The channel this request is bound to.

		@param aCb Callback function called on transfer completion or failure

		(in channel DFC context).  Can be NULL.

		@param aCbArg   Argument passed to callback function.

		@param aMaxTransferSize Maximum fragment size.  If not specified, defaults to the maximum size

		supported by the DMA controller for the type of transfer that is later scheduled.

		@deprecated

    */

	IMPORT_C DDmaRequest(TDmaChannel& aChannel, TCallback aCb=NULL, TAny* aCbArg=NULL,

						 TInt aMaxTransferSize=0);

	/** Constructor.

		Create a new transfer request.

		@param aChannel The channel this request is bound to.

		@param aDmaCb Callback function called on transfer completion or

		failure (in channel DFC or ISR context). Can be NULL.

		@param aCbArg Argument passed to callback function.

		@param aMaxTransferSize Maximum fragment size. If not specified,

		defaults to the maximum size supported by the DMA controller for the

		type of transfer that is later scheduled.

	*/

	IMPORT_C DDmaRequest(TDmaChannel& aChannel, TDmaCallback aDmaCb, TAny* aCbArg=NULL,

						 TUint aMaxTransferSize=0);

	/** Destructor.

		Assume the request is not being transferred or pending.

    */

	IMPORT_C ~DDmaRequest();

	/** Split request into a list of fragments small enough to be fed to the

		DMAC.

		The size of each fragment is smaller than or equal to the maximum

		transfer size supported by the DMAC. If the source and/or destination

		is memory, each fragment points to memory which is physically

		contiguous.

		The kind of transfer to perform is specified via a set of flags used by

		a PIL and a magic cookie passed to the PSL. If the source

		(resp. destination) is a peripheral, aSrc (resp. aDest) is treated as a

		magic cookie by the PIL and passed straight to the PSL.

		The request can be uninitialised or may have been fragmented

		previously. The previous configuration if any is lost whether or not

		the function succeeds.

		@param aSrc Source memory buffer linear address or peripheral magic

		cookie.

		@param aDest Destination memory buffer linear address or peripheral

		magic cookie.

		@param aCount Number of bytes to transfer.

		@param aFlags Bitmask characterising the transfer.

		@param aPslInfo Hardware-specific information passed to PSL.

		@return KErrNone if success. KErrArgument if aFlags and/or aPslInfo are

		invalid when finding the maximum transfer size. May also fail if

		running out of descriptors.

		@pre The request is not being transferred or pending.

		@pre The various parameters must be valid. The PIL or PSL will fault the

		kernel if not.

		@see TDmaRequestFlags

		@deprecated

    */

	IMPORT_C TInt Fragment(TUint32 aSrc, TUint32 aDest, TInt aCount, TUint aFlags, TUint32 aPslInfo);

	/** New version of the DMA request fragment function, to be used with the

		TDmaTransferArgs structure.

	*/

	IMPORT_C TInt Fragment(const TDmaTransferArgs& aTransferArgs);

	/** Transfer asynchronously this request.

		If this request's channel is idle, the request is transferred

		immediately. Otherwise, it is queued and transferred later.

		The client is responsible for ensuring cache consistency before and/or

		after the transfer if necessary.

		@return KErrNone if success, KErrGeneral otherwise.

    */

	IMPORT_C TInt Queue();

    /** Append new descriptor(s) to existing list.

		Clients needing to build a custom descriptor list should call this

		function to allocate the list and access the resulting list through

		iFirstHdr and iLastHdr.

		Clients should not change the value of iFirstHdr, iLastHdr and the

		iNext field of the descriptor headers to ensure descriptors can be

		deallocated. Clients are free to change hardware descriptors, including

		chaining, in whatever way suit them.

		Assume the request is not being transferred or pending.

		@param aCount Number of descriptors to append.

		@return KErrNone or standard error code.

    */

	IMPORT_C TInt ExpandDesList(TInt aCount=1);

    /** Append new descriptor(s) to existing list. This function variant

		operates on the source port descriptor chain.

		Works like ExpandDesList except that it uses the iSrcFirstHdr and

		iSrcLastHdr fields.

		@see ExpandDesList

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will just return KErrGeneral.

		@param aCount Number of descriptors to append.

		@return KErrNone or standard error code.

    */

	IMPORT_C TInt ExpandSrcDesList(TInt aCount=1);

    /** Append new descriptor(s) to existing list. This function variant

		operates on the destination port descriptor chain.

		Works like ExpandDesList except that it uses the iDstFirstHdr and

		iDstLastHdr fields.

		@see ExpandDesList

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will just return KErrGeneral.

		@param aCount Number of descriptors to append.

		@return KErrNone or standard error code.

    */

	IMPORT_C TInt ExpandDstDesList(TInt aCount=1);

	/** Free resources associated with this request.

		Assume the request is not being transferred or pending.

    */

	IMPORT_C void FreeDesList();

	/** Free resources associated with this request. This function variant

		operates on the source port descriptor chain.

		@see FreeDesList

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will do nothing.

    */

	IMPORT_C void FreeSrcDesList();

	/** Free resources associated with this request. This function variant

		operates on the destination port descriptor chain.

		@see FreeDesList

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will do nothing.

    */

	IMPORT_C void FreeDstDesList();

	/** Enables the functionality for counting the transferred source

		elements.

		This function can be called at any time, but the enabled/disabled

		status is checked by the framework only at two points in time.

		The first one is after a request has been queued, and if it is enabled

		then the counting will commence as soon as the transfer starts.

		The second point is when Resume() is called for a paused transfer, and

		in this case the following applies. If counting was enabled when the

		transfer was paused and it is now disabled then the counting is stopped

		at that point and the count value frozen. If counting was disabled when

		the transfer was paused and it is now enabled then the counting will

		commence when the transfer resumes. (The starting value will depend on

		the argument of the enable function.) Otherwise nothing will change,

		i.e. counting will either continue normally (enabled/enabled) or

		neither stop nor continue (disabled/disabled).

		Once a status has been set, it remains valid for the entire duration of

		the transfer (and beyond, if it is not changed again).

		@param aResetElementCount If ETrue (the default) then the count

		variable will be reset to zero, otherwise it will retain its current

		value.

		@see Queue()

		@see TotalNumSrcElementsTransferred()

	*/

	IMPORT_C void EnableSrcElementCounting(TBool aResetElementCount=ETrue);

	/** Enables the functionality for counting the transferred destination

		elements.

		This function can be called at any time, but the enabled/disabled

		status is checked by the framework only at two points in time.

		The first one is after a request has been queued, and if it is enabled

		then the counting will commence as soon as the transfer starts.

		The second point is when Resume() is called for a paused transfer, and

		in this case the following applies. If counting was enabled when the

		transfer was paused and it is now disabled then the counting is stopped

		at that point and the count value frozen. If counting was disabled when

		the transfer was paused and it is now enabled then the counting will

		commence when the transfer resumes. (The starting value will depend on

		the argument of the enable function.) Otherwise nothing will change,

		i.e. counting will either continue normally (enabled/enabled) or

		neither stop nor continue (disabled/disabled).

		Once a status has been set, it remains valid for the entire duration of

		the transfer (and beyond, if it is not changed again).

		@param aResetElementCount If ETrue (the default) then the count

		variable will be reset to zero, otherwise it will retain its current

		value.

		@see Queue()

		@see TotalNumDstElementsTransferred()

	*/

	IMPORT_C void EnableDstElementCounting(TBool aResetElementCount=ETrue);

	/** Disables the functionality for counting the transferred source

		elements.

		This function can be called at any time, but the enabled/disabled

		status is checked by the framework only at two points in time.

		The first one is after a request has been queued, and if it is enabled

		then the counting will commence as soon as the transfer starts.

		The second point is when Resume() is called for a paused transfer, and

		in this case the following applies. If counting was enabled when the

		transfer was paused and it is now disabled then the counting is stopped

		at that point and the count value frozen. If counting was disabled when

		the transfer was paused and it is now enabled then the counting will

		commence when the transfer resumes. (The starting value will depend on

		the argument of the enable function.) Otherwise nothing will change,

		i.e. counting will either continue normally (enabled/enabled) or

		neither stop nor continue (disabled/disabled).

		Once a status has been set, it remains valid for the entire duration of

		the transfer (and beyond, if it is not changed again).

		@see Queue()

		@see TotalNumSrcElementsTransferred()

	*/

	IMPORT_C void DisableSrcElementCounting();

	/** Disables the functionality for counting the transferred destination

		elements.

		This function can be called at any time, but the enabled/disabled

		status is checked by the framework only at two points in time.

		The first one is after a request has been queued, and if it is enabled

		then the counting will commence as soon as the transfer starts.

		The second point is when Resume() is called for a paused transfer, and

		in this case the following applies. If counting was enabled when the

		transfer was paused and it is now disabled then the counting is stopped

		at that point and the count value frozen. If counting was disabled when

		the transfer was paused and it is now enabled then the counting will

		commence when the transfer resumes. (The starting value will depend on

		the argument of the enable function.) Otherwise nothing will change,

		i.e. counting will either continue normally (enabled/enabled) or

		neither stop nor continue (disabled/disabled).

		Once a status has been set, it remains valid for the entire duration of

		the transfer (and beyond, if it is not changed again).

		@see Queue()

		@see TotalNumDstElementsTransferred()

	*/

	IMPORT_C void DisableDstElementCounting();

	/** Returns the number of elements that have been transferred by this

		transfer request at the source port.

		To use this method, the counting functionality has to be explicitly

		enabled, either before the transfer request is queued or while it is

		paused.

		@see EnableSrcElementCounting()

		@see DisableSrcElementCounting()

		This function should only be called after the transfer has finished

		(completed with or without error, or because it was cancelled) or while

		it is paused. Otherwise it may just return 0.

		@return The number of elements that have been transferred by this

		transfer request at the source port.

	*/

	IMPORT_C TUint32 TotalNumSrcElementsTransferred();

	/** Returns the number of elements that have been transferred by this

		transfer request at the destination port.

		To use this method, the counting functionality has to be explicitly

		enabled, either before the transfer request is queued or while it is

		paused.

		@see EnableDstElementCounting()

		@see DisableDstElementCounting()

		This function should only be called after the transfer has finished

		(completed with or without error, or because it was cancelled) or while

		it is paused. Otherwise it may just return 0.

		@return The number of elements that have been transferred by this

		transfer request at the destination port.

	*/

	IMPORT_C TUint32 TotalNumDstElementsTransferred();

	/** Returns the number of fragments that this transfer request has been

		split into.

		This number will only be different from 0 once Fragment() has been

		called or after descriptors have been manually allocated by the client

		using ExpandDesList().

		If SDmacCaps::iAsymHwDescriptors is true then this function will always

		return 0, and SrcFragmentCount() / DstFragmentCount() should be used

		instead.

		@return The number of fragments (descriptors / pseudo descriptors) that

		this transfer request has been split into.

	 */

	IMPORT_C TInt FragmentCount();

	/** Returns the number of source port fragments that this transfer request

		has been split into.

		This number will only be different from 0 once Fragment() has been

		called or after descriptors have been manually allocated by the client

		using ExpandSrcDesList().

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will always return 0.

		@return The number of source port fragments (descriptors) that this

		transfer request has been split into.

	 */

	IMPORT_C TInt SrcFragmentCount();

	/** Returns the number of destination port fragments that this transfer

		request has been split into.

		This number will only be different from 0 once Fragment() has been

		called or after descriptors have been manually allocated by the client

		using ExpandDstDesList().

		This function can only be used if SDmacCaps::iAsymHwDescriptors is

		true, otherwise it will always return 0.

		@return The number of destination port fragments (descriptors) that

		this transfer request has been split into.

	 */

	IMPORT_C TInt DstFragmentCount();

private:

	inline void OnDeque();

	TUint GetTransferCount(const TDmaTransferArgs& aTransferArgs);

	TInt Frag(TDmaTransferArgs& aTransferArgs);

	TInt FragSym(TDmaTransferArgs& aTransferArgs, TUint aCount, TUint aMaxTransferLen);

	TInt FragAsym(TDmaTransferArgs& aTransferArgs, TUint aCount, TUint aMaxTransferLen);

	TInt FragAsymSrc(TDmaTransferArgs& aTransferArgs, TUint aCount, TUint aMaxTransferLen);

	TInt FragAsymDst(TDmaTransferArgs& aTransferArgs, TUint aCount, TUint aMaxTransferLen);

	TInt ExpandDesList(TInt aCount, TInt& aDesCount, SDmaDesHdr*& aFirstHdr,

					   SDmaDesHdr*& aLastHdr);

	void FreeDesList(TInt& aDesCount, SDmaDesHdr*& aFirstHdr, SDmaDesHdr*& aLastHdr);

	TInt FragmentCount(const SDmaDesHdr* aHdr);

public:

	// WARNING: The following attributes are accessed both in client and DFC

	// context and so accesses must be protected with the channel lock.

	TDmaChannel& iChannel;		/**< The channel this request is bound to */

	TCallback iCb;			 /**< Called on completion/failure (can be NULL) */

	TAny* iCbArg;			 /**< Callback argument */

	TDmaCallback iDmaCb;		// the new-style callback function

	TAny* iDmaCbArg;			// the new-style callback arg

	TBool iIsrCb;				// client wants callback in ISR context

	TInt iDesCount;			   /**< The number of fragments in list */

	SDmaDesHdr* iFirstHdr;	   /**< The first fragment in the list (or NULL) */

	SDmaDesHdr* iLastHdr;	   /**< The last fragment in the list (or NULL) */

	TInt iSrcDesCount;		   /**< The number of fragments in list */

	SDmaDesHdr* iSrcFirstHdr;  /**< The first fragment in the list (or NULL) */

	SDmaDesHdr* iSrcLastHdr;   /**< The last fragment in the list (or NULL) */

	TInt iDstDesCount;		   /**< The number of fragments in list */

	SDmaDesHdr* iDstFirstHdr;  /**< The first fragment in the list (or NULL) */

	SDmaDesHdr* iDstLastHdr;   /**< The last fragment in the list (or NULL) */

	SDblQueLink iLink;			/**< The link on channel queue of pending requests */

	TBool iQueued;				/**< Indicates whether request is pending or being transferred */

	TUint iMaxTransferSize;		/**< Defaults to DMA controller max. transfer size */

	TUint32 iTotalNumSrcElementsTransferred;

	TUint32 iTotalNumDstElementsTransferred;

	__DMA_DECLARE_INVARIANT

	};

//////////////////////////////////////////////////////////////////////////////

class TDmac;

class DmaChannelMgr;

class TDmaCancelInfo;

/** DMA channel base class.

	Standard derived classes are provided for this channel (see

	TDmaSbChannel, TDmaDbChannel, TDmaSgChannel, and TDmaAsymSgChannel).

	The base-port implementor will only need to write their own derived

	class if one of the standard classes is unsuitable.

	This class has not been designed to be called from several concurrent

	client threads. Multithreaded clients must implement their own locking

	scheme (via DMutex).

	Mutexes are used internally to protect data structures accessed both by the

	client thread and the DFC one. Therefore no fast mutex can be held when

	calling a channel function.

	@publishedPartner

	@released

 */

class TDmaChannel

	{

	friend class DDmaRequest;

	friend class TDmac;

	friend class DmaChannelMgr;

public:

	/** Information passed by client when opening a channel */

	struct SCreateInfo

		{

		/** Default constructor. Initializes all fields with meaningful default

			values.

			Must be inline (for now) because exporting it would break existing

			custom DMA libs as their clients would need the export which would

			be missing from the custom .def files.

		*/

		SCreateInfo() : iPriority(KDmaPriorityNone), iDynChannel(EFalse) {};

		/** Identifier used by PSL to select channel to open */

		TUint32 iCookie;

		/** Number of descriptors this channel can use.

			This number is not used in the upgraded version of the DMA

			framework and is kept there only for source compatibility. If the

			client is certain that it will only ever use that version, then the

			value passed here doesn't matter - the framework will ignore it.

			@deprecated

		 */

		TInt iDesCount;

		/** DFC queue used to service DMA interrupts.

			The DFC thread priority must be higher than any client thread

			priority to avoid a situation where a transfer completes while

			being cancelled and another transfer is started before the DFC

			thread gets a chance to run. This would lead to a stray DFC.

		*/

		TDfcQue* iDfcQ;

		/** DFC priority */

		TUint8 iDfcPriority;

		/** Used by PSL to configure a channel priority (if possible).

			The default is KDmaPriorityNone (the don't care value).

		    @see TDmaPriority

		*/

		TUint iPriority;

		/** Request a dynamic DMA channel.

			If this is set to ETrue then the Open call is for a 'dynamic' as

			opposed to a static and solely owned DMA channel. A number of

			properties of the opened TDmaChannel object will be different in

			that case.

			The default value is EFalse.

		 */

		TBool iDynChannel;

		};

public:

    /** Opens the DMA channel.

		Channel selection is done by the hardware-specific layer using a cookie

		passed in via aInfo.

		The client should not delete the returned pointer as the framework owns

		channel objects. However, the client should explicitly close the

		channel when finished with it.

		@param aInfo Information passed by caller to select and configure

		channel.

		@param aChannel Points to open channel on successful return. NULL

		otherwise.

		@return KErrNone or standard error code.

 	*/

	IMPORT_C static TInt Open(const SCreateInfo& aInfo, TDmaChannel*& aChannel);

	/** Closes a previously opened DMA channel.

		Assumes the channel is idle and all requests have been deleted.

		The call will cause the resources associated with this channel to be

		released, and the pointer/reference to it mustn't therefore be accessed

		any longer after the function has returned. The channel pointer should

		be set to NULL by the client.

 	*/

	IMPORT_C void Close();

	/** Logically links this channel to the one specified as an argument, or,

		if the argument is NULL, unlinks this channel.

		The effect of channel linking is that once a transfer on this channel

		has finished, instead of causing the associated client callback to be

		called, 'aChannel' will be enabled by hardware and a preconfigured

		transfer on that channel will start.

		Note that conceptually 'linking' here always refers to the end of a

		channel transfer, not the beginning, i.e. a channel can only be linked

		once and always to a successor, never twice or to a predecessor. (This

		does not preclude the possibility that two channels are linked in a

		circular fashion.)

		This function can only be used if the DMAC supports logical channel

		linking.

		@see SDmacCaps::iChannelLinking

		@param aChannel Points to the channel this one should be linked to, or

		NULL if this channel is to be unlinked from any other one.

		@return KErrNone if the channel has been linked or unlinked

		successfully, KErrCompletion if this channel was already linked to

		aChannel or already unlinked, KErrNotSupported if the DMAC doesn't

		support channel linking, KErrArgument if this channel was already

		linked to a different channel, KErrGeneral if a general error occurred

		preventing a successful outcome.

	 */

	IMPORT_C TInt LinkToChannel(TDmaChannel* aChannel);

	/** Pauses an active transfer on this channel.

		A paused channel transfer can be resumed by calling Resume() or it can

		be stopped altogether by calling CancelAll().

		@see TDmaChannel::Resume()

		Function can only be used if the DMAC supports this functionality.

		@see SDmacCaps::iChannelPauseAndResume

		@return KErrNone if a transfer has been paused successfully,

		KErrCompletion if a transfer was already paused, KErrNotSupported if

		the DMAC doesn't support channel transfer pausing/resuming, KErrGeneral

		if a general error occurred preventing a successful outcome.

	 */

	IMPORT_C TInt Pause();

	/** Resumes a transfer on this channel that is paused.

		Resume() can be called to resume channel operation when the transfer is

		paused as a result of a previous call to Pause() or because the DMAC

		has encountered a Pause bit in a H/W descriptor.

		@see TDmaChannel::Pause()

		@see TDmaCallbackType::EDmaCallbackLinkedListPaused

		Function can only be used if the DMAC supports this functionality.

		@see SDmacCaps::iChannelPauseAndResume

		@return KErrNone if a paused transfer has been resumed successfully,

		KErrCompletion if there was no paused transfer, KErrNotSupported if the

		DMAC doesn't support channel transfer pausing/resuming, KErrGeneral if

		a general error occurred preventing a successful outcome.

	 */

	IMPORT_C TInt Resume();

	/** Cancels the current request and all the pending ones.

	 */

	IMPORT_C void CancelAll();

	/** Returns the channel's maximum transfer length based on the passed

		arguments.

		@param aSrcFlags Bitmask characterising transfer source

		@see TDmaTransferArgs::iSrcConfig::iFlags

		@param aDstFlags Bitmask characterising transfer destination

		@see TDmaTransferArgs::iDstConfig::iFlags

		@param aPslInfo Cookie passed to the PSL

		@see TDmaTransferArgs::iPslRequestInfo

		@return 0 if transfer length is not limited, the maximum transfer

		length in bytes otherwise.

 	*/

	IMPORT_C TUint MaxTransferLength(TUint aSrcFlags, TUint aDstFlags, TUint32 aPslInfo);

	/** Retrieves from the PSL the address / memory alignment mask based on the

		parameters passed. Some DMA controllers impose alignment constraints on

		the base address of memory buffers. This mask is AND'ed against memory

		addresses computed during fragmentation.

		This function needs to be called separately for source and destination.

		@param aTargetFlags Bitmask characterising transfer source or

		destination

		@see TDmaTransferArgs::iSrcConfig::iFlags

		@see TDmaTransferArgs::iDstConfig::iFlags

		@param aElementSize Element size used for the transfer. Can be zero if

		not known or 'don't care'.

		@param aPslInfo Cookie passed to the PSL

		@see TDmaTransferArgs::iPslRequestInfo

		@return A value representing the alignment mask (e.g. 3 if buffer must

		be 4-byte aligned)

	 */

	IMPORT_C TUint AddressAlignMask(TUint aTargetFlags, TUint aElementSize,

									TUint32 aPslInfo);

	/** Returns a reference to a structure containing the capabilities and

		features of the DMA controller associated with this channel.

		@return A reference to a structure containing the capabilities and

		features of the DMA controller associated with this channel.

	 */

	IMPORT_C const SDmacCaps& DmacCaps();

	/** Sets up once more the transfer request that has just completed, after

		optionally having adjusted the transfer parameters as specified.

		This function is meant to be called exclusively from a client-supplied

		callback that is executed in ISR context, and only in response to a

		transfer completion notification.

		If this call returns to the caller with KErrNone then the framework's

		ISR handler will subsequently not queue the channel DFC for this

		completed request.

		The parameters specify which changes the framework should apply to the

		descriptors of the transfer request before rescheduling it. Arguments

		for which no change is required should be passed as their default

		values. The parameters correspond to those in the TDmaTransferArgs

		struct as follows.

		@param aSrcAddr @see TDmaTransferArgs::iSrcConfig::iAddr

		@param aDstAddr @see TDmaTransferArgs::iDstConfig::iAddr

		@param aTransferCount @see TDmaTransferArgs::iTransferCount

		@param aPslRequestInfo @see TDmaTransferArgs::iPslRequestInfo

		@param aIsrCb If set to ETrue (the default) then the callback of the

		rescheduled request will again be called in ISR context

		Since Epoc::LinearToPhysical() cannot be called in ISR context the

		addresses passed into this function must be physical ones, i.e.

		TDmaTransferFlags::KDmaPhysAddr is implied.

		If an address refers to a memory target then

		TDmaTransferFlags::KDmaMemIsContiguous is implied as well as no

		fragmentation is possible at this point.

		@pre Must only be called from a 'transfer complete' client callback in

		ISR context.

		@post Framework won't queue the channel DFC for the completed request

		in success case.

		@see DDmaRequest::DDmaRequest(TDmaChannel&, TDmaCallback, TAny*, TUint)

		@see TDmaCallbackType::EDmaCallbackRequestCompletion

		@see TDmaPILFlags::KDmaRequestCallbackFromIsr

		@return KErrGeneral if there was an error, KErrNone otherwise.

	 */

	IMPORT_C TInt IsrRedoRequest(TUint32 aSrcAddr=KPhysAddrInvalid,

								 TUint32 aDstAddr=KPhysAddrInvalid,

								 TUint aTransferCount=0,

								 TUint32 aPslRequestInfo=0,

								 TBool aIsrCb=ETrue);

	/** Tests whether the channel is currently opened.

		@return ETrue if channel is currently opened, EFalse otherwise.

		NB: This API should not be used any longer.

		After calling TDmaChannel::Open() successfully the channel is

		guaranteed to be open. Therefore there seems no good reason for this

		API to exist.

		@deprecated

	 */

	inline TBool IsOpened() const;

	/** Tests whether the channel's request queue is currently empty.

		@return ETrue if request queue is currently empty, EFalse otherwise.

	 */

	inline TBool IsQueueEmpty() const;

	/** Returns a PSL-specific value which uniquely identifies this channel -

		it is used for debug tracing by the PIL.

		@return PSL-specific value which uniquely identifies this channel.

	 */

	inline TUint32 PslId() const;

	/** Called by a test harness to force an error when the next fragment is

		transferred.

		@param aFragmentCount The number of consecutive fragments to fail

	 */

	IMPORT_C TInt FailNext(TInt aFragmentCount);

	/** Called by a test harness to force the DMA controller to miss one or

		more interrupts.

		@param aInterruptCount The number of consecutive interrupts to miss

	 */

	IMPORT_C TInt MissNextInterrupts(TInt aInterruptCount);

	/** Function allowing platform-specific layer to extend channel API with

		new channel-specific operations.

		@param aCmd Command identifier. Negative values are reserved for use by

		Nokia.

		@param aArg PSL-specific argument

		@return KErrNotSupported if aCmd is not supported. PSL-specific value

		otherwise.

	 */

	IMPORT_C TInt Extension(TInt aCmd, TAny* aArg);

	/** This is a function that allows the Platform Specific Layer (PSL) to

		extend the DMA API with new channel-independent operations.

		@param aCmd Command identifier. Negative values are reserved for

		Symbian use.

		@param aArg PSL-specific.

		@return KErrNotSupported if aCmd is not supported; a PSL specific value

		otherwise.

 	*/

	IMPORT_C TInt StaticExtension(TInt aCmd, TAny* aArg);

	/** @deprecated

		@see DmacCaps()

	 */

	inline const TDmac* Controller() const;

	/** @deprecated

		@see MaxTransferLength()

	 */

	inline TInt MaxTransferSize(TUint aFlags, TUint32 aPslInfo);

	/** @deprecated

		@see AddressAlignMask()

	 */

	inline TUint MemAlignMask(TUint aFlags, TUint32 aPslInfo);

protected:

	// Interface with state machines

	TDmaChannel();

	/** Called by the PIL when adding a new request to the channel's queue.

		The implementation should update the channel's state as appropriate

		and begin transfer of aReq if possible.

		@param aReq The request which has been added to the queue

	*/

	virtual void DoQueue(const DDmaRequest& aReq);

	/** Called by the PIL in response to a CancelAll call. It should update

		the channel state appropriately.

	*/

	virtual void DoCancelAll() = 0;

	/** This is called by the PIL when a DDmaRequest is removed from the

		channel's queue. In general the implementation simply needs to unlink

		the hardware descriptor corresponding to aHdr from the next.