// 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.
Since the PIL links the hardware descriptor chains of adjacent queued
requests (for speed) it is necessary to break the chain when a request
is completed so that the request may be requeued by the client without
having called DDmaRequest::Fragment again.
@param aHdr The header for a descriptor, which must be unlinked
from its next descriptor (if there is one)
*/
virtual void DoUnlink(SDmaDesHdr& aHdr);
/** Called by the PIL whenever a transfer associated with aCurReq is
done. The implementation must advance the channel's state and
may transfer the next header if necessary (the provided
scatter-gather channel does not do this). It must also report
back which header was associated with the last transfer to
complete.
@param aCurReq The current request.
@param aCompletedHdr Must be set by the implementation to the header
of the last transfer to complete.
*/
virtual void DoDfc(const DDmaRequest& aCurReq, SDmaDesHdr*& aCompletedHdr);
/** Called by the PIL whenever a transfer associated with aCurReq is
done. The implementation must advance the channel's state and
may start the transfer for the next headers if necessary (the
provided scatter-gather channels do not do this). If one
header has a successor but the other is the last in the chain it
is an error.
@note Must be implemented by PSL if channel uses asymmetric hardware
descriptors and is not derived from TDmaAsymSgChannel.
@param aCurReq The current request.
@param aSrcCompletedHdr Must be set by the implementation to
the header of the last source descriptor to complete.
@param aDstCompletedHdr Must be set by the implementation to
the header of the last destination descriptor to complete.
*/
virtual void DoDfc(const DDmaRequest& aCurReq, SDmaDesHdr*& aSrcCompletedHdr,
SDmaDesHdr*& aDstCompletedHdr);
virtual ~TDmaChannel();
private:
static void Dfc(TAny*);
void DoDfc();
inline void Wait();
inline void Signal();
inline void Flash();
void ResetStateMachine();
protected:
TDmac* iController; // DMAC this channel belongs to (NULL when closed)
const SDmacCaps* iDmacCaps; // what is supported by DMAC on this channel
TUint32 iPslId; // unique identifier provided by PSL
TBool iDynChannel; // this is a dynamically allocated channel
TUint iPriority; // hardware priority of this channel
DMutex* iMutex; // for data accessed in both client & DFC context
SDmaDesHdr* iCurHdr; // fragment being transferred or NULL
SDmaDesHdr** iNullPtr; // Pointer to NULL pointer following last fragment
TDfc iDfc; // transfer completion/failure DFC
TInt iMaxDesCount; // maximum number of allocable descriptors
TInt iAvailDesCount; // available number of descriptors
volatile TUint32 iIsrDfc; // Interface between ISR and DFC:
enum {KErrorFlagMask = 0x80000000}; // bit 31 - error flag
enum {KCancelFlagMask = 0x40000000}; // bit 30 - cancel flag
enum {KDfcCountMask = 0x3FFFFFFF}; // bits 0-29 - number of queued DFCs
SDblQue iReqQ; // being/about to be transferred request queue
TInt iReqCount; // number of requests attached to this channel
private:
TDmaCancelInfo* iCancelInfo; // ...
TBool iRedoRequest; // client ISR callback wants a redo of request
TBool iIsrCbRequest; // request on queue using ISR callback
__DMA_DECLARE_INVARIANT
};
//////////////////////////////////////////////////////////////////////////////
// INTERFACE WITH TEST HARNESS
//////////////////////////////////////////////////////////////////////////////
/** Set of information used by test harness.
@publishedPartner
@released
*/
struct TDmaTestInfo
{
/** Maximum transfer size in bytes for all channels (ie. the minimum of all channels' maximum size)*/
TUint iMaxTransferSize;
/** 3->Memory buffers must be 4-byte aligned, 7->8-byte aligned, ... */
TUint iMemAlignMask;
/** Cookie to pass to DDmaRequest::Fragment for memory-memory transfer*/
TUint32 iMemMemPslInfo;
/** Number of test single-buffer channels */
TInt iMaxSbChannels;
/** Pointer to array containing single-buffer test channel ids */
TUint32* iSbChannels;
/** Number of test double-buffer channels */
TInt iMaxDbChannels;
/** Pointer to array containing double-buffer test channel ids */
TUint32* iDbChannels;
/** Number of test scatter-gather channels */
TInt iMaxSgChannels;
/** Pointer to array containing scatter-gather test channel ids */
TUint32* iSgChannels;
};
/** Provides access to test information structure stored in the PSL.
Must be implemented by the PSL.
@publishedPartner
@released
*/
IMPORT_C const TDmaTestInfo& DmaTestInfo();
/** Provides access to test information structure stored in the PSL.
Must be implemented by the PSL.
@publishedPartner
@released
*/
IMPORT_C const TDmaV2TestInfo& DmaTestInfoV2();
//////////////////////////////////////////////////////////////////////////////
#include <drivers/dma_compat.inl>
#include <drivers/dma_v2.inl>
#endif // #ifndef __DMA_V2_H__