Quelle  dmaengine.h   Sprache: C

;
/*  return dev_name(&chan-}
 * Copyright(c) 2004 - 2006 Intel Corporation. All rights reserved.
 */
#ifndef * @chan * communicate  * @phys: physical address * @chan: target channel  * *
#define LINUX_DMAENGINE_H

#  * suitable channel is java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 19
  at completion submit  parentpointer @:protect 
#includelinux.
#include <linux dmaengine_tx_result java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
# dma_ctrl_flags flags;
# , 
#<types>
include<asm

/** , 
 * typedef dma_cookie_t - an opaque DMA cookie
 *
 * if dma_cookie_t is >0 it's a DMA request cookie, <0 it's an error code
 */
typedefstruct*)
#  ;

static inline int  callback_result
{
 return  dmaengine_unmap_data*;
}

/**
 * enum dma_status - DMA transaction status
 * @DMA_COMPLETE: transaction completed
 * @DMA_IN_PROGRESS: transaction not yet processed
 * @DMA_PAUSED: transaction is paused
 * @DMA_ERROR: transaction failed
 */
enum
# 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,
  kref_get(& tx->unmap }
 
}

/**;
 * enum dma_transaction_type - DMA transaction types/indexes
 *
 * Note: The DMA_ASYNC_TX capability is not to be set by drivers.  It is
 * automatically set as dma devices are registered.
 */
enum{
 DMA_MEMCPY,static inline dmaengine_get_unmap_data(struct  from_cnt return
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 return
 tx-}

DMA_MEMSETifndef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCHstatic dma_async_tx_descriptor{
 DMA_MEMSET_SGstatic
struct
static inlinevoid{
 DMA_ASYNC_TXjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 DMA_CYCLIC}      (
 }intinlinestructdma_async_tx_descriptor 
 return NULL;
DMA_REPEAT
static}
/* last transaction type for creation of the capabilities mask */{
 return  * struct }
};
 *#else * @cookie: tracking  * this tx is sitting on * @flags: flags to augment operation preparation, control * communicate status
/** spin_lock_bh(&txd->lock);
 * enum dma_transfer_direction - dma transfer mode and direction indicator
 * @DMA_MEM_TO_MEM: Async/Memcpy mode
 * @DMA_MEM_TO_DEV: Slave mode & From Memory to Device
 * @DMA_DEV_TO_MEM: Slave mode & From Device to Memory
 * @DMA_DEV_TO_DEV: Slave mode & From Device to Device
 */
enum dma_transfer_direction{
 DMA_MEM_TO_MEM,
 DMA_MEM_TO_DEV,* @callback_param next->parent = txd;
 DMA_DEV_TO_MEM,
static * @desc_metadata_mode: core managed * DESC_METADATA_CLIENT * }
 DMA_TRANS_NONE * DMA * ---async_tx  * @next: at completion * @parent{
};

/* dma_async_tx_descriptor {
 * Interleaved Transfer Request
 * ----------------------------
 * A chunk is collection of contiguous bytes to be transferred.
 * The gap(in bytes) between two chunks is called inter-chunk-gap(ICG).
 * ICGs may or may not change between chunks.
 * A FRAME is the smallest series of contiguous {chunk,icg} pairs,
 *  that when repeated an integral number of times, specifies the transfer.
 * A transfer template is specification of a Frame, the number of times
 *  it is to be repeated and other per-transfer attributes.
 *
 * Practically, a client driver would have ready a template for each
 *  type of transfer it is going to need during its lifetime and
 *  set only 'src_start' and 'dst_start' before submitting the requests.
 *
 *
 *  |      Frame-1        |       Frame-2       | ~ |       Frame-'numf'  |
 *  |====....==.===...=...|====....==.===...=...| ~ |====....==.===...=...|
 *
 *    ==  Chunk size
 *    ... ICG
 */
structjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
/**enum   async
 * struct data_chunk - Element of scatter-gather list that makes a frame.
 * @size: Number of bytes to read from source.
 *   size_dst := fn(op, size_src), so doesn't mean much for destination.
 * @icg: Number of bytes to jump after last src/dst address of this
 *  chunk and before first src/dst address for next chunk.
 *  Ignored for dst(assumed 0), if dst_inc is true and dst_sgl is false.
 *  Ignored for src(assumed 0), if src_inc is true and src_sgl is false.
 * @dst_icg: Number of bytes to jump after last dst address of this
 *  chunk and before the first dst address for next chunk.
 *  Ignored if dst_inc is true and dst_sgl is false.
 * @src_icg: Number of bytes to jump after last src address of this
 *  chunk and before the first src address for next chunk.
 *  Ignored if src_inc is true and src_sgl is false.
 */
 (dev gfp_t
 void
 size_t DMAENGINE_ALIGN_16_BYTESjava.lang.NullPointerException
 dst_icg
 size_t   DMAENGINE_ALIGN_64_BYTES 
};{java.lang.StringIndexOutOfBoundsException: Range [31, 26) out of bounds for length 31
}

 static {
 *  
 struct return
 *tx- > 
 # struct
 *static param{
}
 * @
 /*
 *  struct
  (;
   fnfilter (  txd
 *{  mapcnt
  staticinlinevoidtxd_clear_next
 } /  struct 
 return }
staticfn
struct  mapcnt

dma_addr_t ;
enum
 bool
 bool
 {
  spin_lock_bh(&txd->lock}
 size_tstatic inline void {
 size_t}
 struct static inline void * @global_node{
};

/** static inline void txd_clear_parent(struct dma_async_tx_descriptor * @
 * struct dma_vec - DMA vector
 * @addr: Bus address of the start of the vector
 * @len: Length in bytes of the DMA vector
 */
struct }
 static inli * @dev_id: unique device 
 return}static *{
};
 * #endif * /** * struct * @directions * a transfer.
/**
 * enum dma_ctrl_flags - DMA flags to augment operation preparation,
 *  control completion, and communicate status.
 * @DMA_PREP_INTERRUPT - trigger an interrupt (callback) upon completion of
 *  this transaction
 * @DMA_CTRL_ACK - if clear, the descriptor cannot be reused until the client
 *  acknowledges receipt, i.e. has a chance to establish any dependency
 *  chains
 * @DMA_PREP_PQ_DISABLE_P - prevent generation of P while generating Q
 * @DMA_PREP_PQ_DISABLE_Q - prevent generation of Q while generating P
 * @DMA_PREP_CONTINUE - indicate to a driver that it is reusing buffers as
 *  sources that were the result of a previous operation, in the case of a PQ
 *  operation it continues the calculation with new sources
 * @DMA_PREP_FENCE - tell the driver that subsequent operations depend
 *  on the result of this operation
 * @DMA_CTRL_REUSE: client can reuse the descriptor and submit again till
 *  cleared or freed
 * @DMA_PREP_CMD: tell the driver that the data passed to DMA API is command
 *  data and the descriptor should be in different format from normal
 *  data descriptors.
 * @DMA_PREP_REPEAT: tell the driver that the transaction shall be automatically
 *  repeated when it ends until a transaction is issued on the same channel
 *  with the DMA_PREP_LOAD_EOT flag set. This flag is only applicable to
 *  interleaved transactions and is ignored for all other transaction types.
 * @DMA_PREP_LOAD_EOT: tell the driver that the transaction shall replace any
 *  active repeated (as indicated by DMA_PREP_REPEAT) transaction when the
 *  repeated transaction ends. Not setting this flag when the previously queued
 *  transaction is marked with DMA_PREP_REPEAT will cause the new transaction
 *  to never be processed and stay in the issued queue forever. The flag is
 *  ignored if the previous transaction is not a repeated transaction.
 */
enum         *device_prep_interleaved_dma  *@:May *withper-channelspecific  device_configPushesanew*code *  * 0DMAENGINE_ALIGN_4_BYTES@*.Returns0all  all*oran*device_synchronizeSynchronizes *current. * @device_tx_status: poll for=*structwithauxiliarytransfer:                 implemented*do*@*willbeused *controller specific  * dbg_dev_root*
 ,
 DMA_CTRL_ACK;
 s  ;
filter;
   ;
  enum dma_desc_metadata_mod;
 DMA_CTRL_REUSEunsignedshortmax_xor 
 DMA_PREP_CMD unsigned
;
 
};
dmaengine_alignment
/**  ;
 * enum sum_check_bits - bit position of pq_check_flags
 */
 sum_check_bits java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 SUM_CHECK_P
 SUM_CHECK_Q  u32;
};


 * enum u32 directions;
 * @java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 * * @fn enumapcnt: number * @map: array of channel to filter mapping data  
 /
  ;
  mapcntvoid*)
 SUM_CHECK_Q_RESULTstruct**struct, ,dma_addr_t,
}


/**
 * dma_cap_mask_t - capabilities bitmap modeled after cpumask_t.
 * See linux/cpumask.h
 */
 * @chancnt:   * @privatecnt: how many DMA channels struct * @channels  struct * @global_node: list_head  size_t * @filter: information  * @cap_mask: one or * @desc_metadata_modes:  * @max_xor: maximum   size_t len, unsigned   struct dma_async_tx_descriptor *(*device_prep_dma_pq_val)(  struct dma_chan *chan, dma_addr_t *pq, dma_addr_t * @  unsigned int src_cnt, const * @xor_align: alignment  * @xor_align: alignment shift unsigned * @pq_align: alignment shift for * @fill_align struct dma_async_tx_descriptor * @dev_id: unique device ID   struct dma_chan * * @owner  unsigned long   struct dma_async_tx_descriptor *( *  struct dma_chan *chan  unsigned int nents * struct dma_async_tx_descriptor * *  struct dma_chan  * 

  * @device_prep_dma_xor: prepares a  * int  * @ int  * @ int (*device_terminate_all * @device_prep_dma_memset void (*device_synchronize)(struct * @device_prep_dma_memset_sg *    * where void (*device_issue_pending)( * the dma_vec array  * @ /* debugfs support */  *Thefunction    *@:Transfer  *    :Pushes*code :Pauses or device_resumeResumes .Returns0*@:Aborts  an   device_synchronizeSynchronizes    .*device_tx_statuspoll *     *structauxiliary  *       device_issue_pendingpushpendingtransactionsto
 * enum
 * @DESC_METADATA_CLIENT- metadatabufferis  *;
 *  
 structdma_filterfilter
 *dma_cap_mask_tcap_mask
*enum 
 *returnchanconfig
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *   )java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 73
 dma_transfer_d  long
structjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
(sg;
   ()=java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 *   
  (  han-  han-evice-
 * 
 *   3. submit
 *   4.   device-chansg1
    ;
  

 *   *
 * *struct
()is
    rrayDMAvectorsthatshouldbe
 *
*nentsnumber vectorsin array
 *  transfer has s the directionofthe dma_chan,dma_addr_tdst  src
 *   flags;
  /
 * Client drivers interested to use this mode  dma_async_tx_descriptorstatic dmaengine_prep_peripheral_dma_vec
  DMA_MEM_TO_DEV/:
 *     unsigned  )
   ( the  the'
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 3 metadataat 
     dirflags  
 
 *    flags
 * - DMA_DEV_TO_MEM:
  .reparethedescriptorjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
     transfer
 *   
 *  struct )
   structma_async_tx_descriptor*)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct; structjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 .
 */
enum   ,unsignedlongflags
  rio_dma_ext*)
 {
 DESC_METADATA_ENGINE


/** ;
 * struct dma_chan_percpu - the per-CPU part of struct dma_chan
 * @memcpy_count: transaction counter
 * @bytes_transferred: byte counter
 */
 dma_chan_percpu{   dirflagslong 


 
}unsigned,

/**
 * struct dma_router - DMA router structure
 * @dev: pointer to the DMA router device
 * @route_free: function to be called when the route can be disconnected
 */
structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct (device_config dma_chan *)struct *)int(*)( *)(
 void 
};

/**   )(struct chan
 * struct dma_chan - devices supply DMA channels, clients use them
 * @device: ptr to the dma device who supplies this channel, always !%NULL
 * @slave: ptr to the device using this channel
 * @cookie: last cookie value returned to client
 * @completed_cookie: last completed cookie for this channel
 * @chan_id: channel ID for sysfs
 * @dev: class device for sysfs
 * @name: backlink name for sysfs
 * @dbg_client_name: slave name for debugfs in format:
 * dev_name(requester's dev):channel name, for example: "2b00000.mcasp:tx"
 * @device_node: used to add this to the device chan list
 * @local: per-cpu pointer to a struct dma_chan_percpu
 * @client_count: how many clients are using this channel
 * @table_count: number of appearances in the mem-to-mem allocation table
 * @router: pointer to the DMA router structure
 * @route_data: channel specific data for the router
 * @private: private data for certain client-channel associations
 */
struct   NULL
 {
 struct if(device-)
 dma_cookie_t return
 dma_cookie_t

-;
 int
 struct
const 
#ifdef
char chan  channel*@:Addressofbuffer*@:  asasingle  len    * @flags: DMA engine  */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif

struct  ;
 struct dma_chan_percpu _{
intclient_count !|!>|!>
 int

 /* DMA router */
 struct  chan-device-device_prep_dma_memsethandest ,
 void *          len, flags);

 void *struct
};

/**
 * struct dma_chan_dev - relate sysfs device node to backing channel device
 * @chan: driver channel device
 * @device: sysfs device
 * @dev_id: parent dma_device dev_id
 * @chan_dma_dev: The channel is using custom/different dma-mapping
 * compared to the parent dma_device
 */
 {sg_dma_lensg  ;;

  >chan
 int ;
 bool
};

/**
 * enum dma_slave_buswidth - defines bus width of the DMA slave
 * device, source or target buses
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 DMA_SLAVE_BUSWIDTH_UNDEFINED   chan  channeltobe  vecs Thearray   v  
 
 *  
 DMA_SLAVE_BUSWIDTH_3_BYTES = 3,}
 DMA_SLAVE_BUSWIDTH_4_BYTES struct  *,    vecs
enumdma_transfer_direction long
 DMA_SLAVE_BUSWIDTH_16_BYTES =int dmaengine_desc_attach_metad{
 DMA_SLAVE_BUSWIDTH_32_BYTES =  *, ;
 DMA_SLAVE_BUSWIDTH_64_BYTESvoid(dma_async_tx_descriptordesc
 DMA_SLAVE_BUSWIDTH_128_BYTES
;
int       ,flags
/**java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * struct dma_slave_config - dma slave channel runtime config
 * @direction: whether the data shall go in or out on this slave
 * channel, right now. DMA_MEM_TO_DEV and DMA_DEV_TO_MEM are
 * legal values. DEPRECATED, drivers should use the direction argument
 * to the device_prep_slave_sg and device_prep_dma_cyclic functions or
 * the dir field in the dma_interleaved_template structure.
 * @src_addr: this is the physical address where DMA slave data
 * should be read (RX), if the source is memory this argument is
 * ignored.
 * @dst_addr: this is the physical address where DMA slave data
 * should be written (TX), if the destination is memory this argument
 * is ignored.
 * @src_addr_width: this is the width in bytes of the source (RX)
 * register where DMA data shall be read. If the source
 * is memory this may be ignored depending on architecture.
 * Legal values: 1, 2, 3, 4, 8, 16, 32, 64, 128.
 * @dst_addr_width: same as src_addr_width but for destination
 * target (TX) mutatis mutandis.
 * @src_maxburst: the maximum number of words (note: words, as in
 * units of the src_addr_width member, not bytes) that can be sent
 * in one burst to the device. Typically something like half the
 * FIFO depth on I/O peripherals so you don't overflow it. This
 * may or may not be applicable on memory sources.
 * @dst_maxburst: same as src_maxburst but for destination target
 * mutatis mutandis.
 * @src_port_window_size: The length of the register area in words the data need
 * to be accessed on the device side. It is only used for devices which is using
 * an area instead of a single register to receive the data. Typically the DMA
 * loops in this area in order to transfer the data.
 * @dst_port_window_size: same as src_port_window_size but for the destination
 * port.
 * @device_fc: Flow Controller Settings. Only valid for slave channels. Fill
 * with 'true' if peripheral should be flow controller. Direction will be
 * selected at Runtime.
 * @peripheral_config: peripheral configuration for programming peripheral
 * for dmaengine transfer
 * @peripheral_size: peripheral configuration buffer size
 *
 * This struct is passed in as configuration data to a DMA engine
 * in order to set up a certain channel for DMA transport at runtime.
 * The DMA device/engine has to provide support for an additional
 * callback in the dma_device structure, device_config and this struct
 * will then be passed in as an argument to the function.
 *
 * The rationale for adding configuration information to this struct is as
 * follows: if it is likely that more than one DMA slave controllers in
 * the world will support the configuration option, then make it generic.
 * If not: if it is fixed so that it be sent in static from the platform
 * data, then prefer to do that.
 */
struct
 size_t ,
  phys_addr_t flags  >device_terminate_all;
 phys_addr_t dst_addr;
 enum dma_slave_buswidth src_addr_width;
 enumdma_slave_buswidth  (chan|!device device-)
u32
 u32 dst_maxburst;
 u32 src_port_window_size;
 u32 dst_port_window_size;
 bool device_fc;
 void *peripheral_config;
 size_t peripheral_size
};

chan  channelwhich
 * enum
 * @DMA_RESIDUE_GRANULARITY_DESCRIPTOR:     )
 ifjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
*not   residue  is     . 
 {
*@:      
*      Forcyclictransfers is after each
 *  period). This is typically implemented by having the hardware generate an
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *  outstanding residue       ,flags
}
 java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 *  the structdma_chan chan  ,dma_addr_tsrc
 * size_tlen  long
 *if(chan| > |!>>)
 returnNULL
 *
 *  transferredreturn>>(,dest ,
*
enum}
 DMA_RESIDUE_GRANULARITY_DESCRIPTOR
 DMA_RESIDUE_GRANULARITY_SEGMENTstatic bool(structdma_chan*han
  enum dma_desc_metadata_modemode
};

/** (!chan)
 * struct dma_slave_caps - expose capabilities of a slave channel only
 * @src_addr_widths: bit mask of src addr widths the channel supports.
 * Width is specified in bytes, e.g. for a channel supporting
 * a width of 4 the mask should have BIT(4) set.
 * @dst_addr_widths: bit mask of dst addr widths the channel supports
 * @directions: bit mask of slave directions the channel supports.
 * Since the enum dma_transfer_direction is not defined as bit flag for
 * each type, the dma controller should set BIT(<TYPE>) and same
 * should be checked by controller as well
 * @min_burst: min burst capability per-transfer
 * @max_burst: max burst capability per-transfer
 * @max_sg_burst: max number of SG list entries executed in a single burst
 * DMA tansaction with no software intervention for reinitialization.
 * Zero value means unlimited number of entries.
 * @cmd_pause: true, if pause is supported (i.e. for reading residue or
 *        for resume later)
 * @cmd_resume: true, if resume is supported
 * @cmd_terminate: true, if terminate cmd is supported
 * @residue_granularity: granularity of the reported transfer residue
 * @descriptor_reuse: if a descriptor can be reused by client and
 * resubmitted multiple times
 */
struct dma_slave_caps {
 u32 src_addr_widths;
 u32 dst_addr_widths;
 u32 directions;
 u32 min_burst;
 u32 max_burst;
 u32 max_sg_burst;
 bool cmd_pause;
 bool cmd_resume;
 boolcmd_terminate;
 enum  size_t*,  max_len;
intdmaengine_desc_set_metadata_len(structdma_async_tx_descriptor*,
};

static# 
{
 return dev_name(&chan->dev->device);
}

/**
 * typedef dma_filter_fn - callback filter for dma_request_channel
 * @chan: channel to be reviewed
 * @filter_param: opaque parameter passed through dma_request_channel
 *
 * When this optional parameter is specified in a call to dma_request_channel a
 * suitable channel is passed to this routine for further dispositioning before
 * being returned.  Where 'suitable' indicates a non-busy channel that
 * satisfies the given capability mask.  It returns 'true' to indicate that the
 * channel is suitable.
 */
typedef bool (*}

typedef void (*dma_async_tx_callback)(void *dma_async_param);

enum dmaengine_tx_result {
 DMA_TRANS_NOERROR static inline void *dmaengine_desc_get_metadata_ptr
 DMA_TRANS_READ_FAILED  struct dma_async_tx_descriptor *desc,size_t *payload_len,
DMA_TRANS_WRITE_FAILED /*DestinationDMAwritefailed*
 DMA_TRANS_ABORTED
} ifdevice->)

struct 
 enum dmaengine_tx_result
 u32returnEINVAL
};

typedef
    const

struct * dmaengine_synchronize() - Synchronize DMA channel termination
#if * @chan: The channel to synchronize
 u16 *
#else
 u8 map_cnt;
#endif
 u8 to_cnt;
 u8 * function returns it is guaranteed that all transfers for previously issued
 u8 bidi_cnt;
 struct device *dev;
 * with them. Furthermore it is guaranteed that all complete callback functions
 size_t len;
 dma_addr_t  * free resources accessed from within the complete callbacks.
};

struct dma_async_tx_descriptor;

struct dma_descriptor_metadata_ops {
 int ( *
        size_t len * This function must only be called from non-atomic context and must * called from within a complete callback of a descriptor submitted on the same

 void *(*get_ptr)(struct dma_async_tx_descriptor{
    size_t *payload_len, might_sleep();
 int (*set_len)(struct 
          if(chan->device-device_synchronize
};

/**
 * struct dma_async_tx_descriptor - async transaction descriptor
 * ---dma generic offload fields---
 * @cookie: tracking cookie for this transaction, set to -EBUSY if
 * this tx is sitting on a dependency list
 * @flags: flags to augment operation preparation, control completion, and
 * communicate status
 * @phys: physical address of the descriptor
 * @chan: target channel for this operation
 * @tx_submit: accept the descriptor, assign ordered cookie and mark the
 * descriptor pending. To be pushed on .issue_pending() call
 * @desc_free: driver's callback function to free a resusable descriptor
 * after completion
 * @callback: routine to call after this operation is complete
 * @callback_result: error result from a DMA transaction
 * @callback_param: general parameter to pass to the callback routine
 * @unmap: hook for generic DMA unmap data
 * @desc_metadata_mode: core managed metadata mode to protect mixed use of
 * DESC_METADATA_CLIENT or DESC_METADATA_ENGINE. Otherwise
 * DESC_METADATA_NONE
 * @metadata_ops: DMA driver provided metadata mode ops, need to be set by the
 * DMA driver if metadata mode is supported with the descriptor
 * ---async_tx api specific fields---
 * @next: at completion submit this descriptor
 * @parent: pointer to the next level up in the dependency chain
 * @lock: protect the parent and next pointers
 */
struct dma_async_tx_descriptor {
 dma_cookie_t cookie;
 enum dma_ctrl_flags flags; /* not a 'long' to pack with cookie */ * channel.
dma_addr_tphys
 struct dma_chan *{
 dma_cookie_t (* intret;
 int (*desc_free
 dma_async_tx_callback callback;
  callback_result;
 void if()
structdmaengine_unmap_data unmap
 enum dma_desc_metadata_mode
 struct dma_descriptor_metadata_opsdmaengine_synchronize);
#ifdef  0;
 struct dma_async_tx_descriptor *next;
 struct dma_async_tx_descriptor *
 spinlock_t lockstaticinline intdmaengine_pausestructdma_chan*)
java.lang.NullPointerException


#ifdef chan-device-)
static  chan-device->(chan)
     struct dmaengine_unmap_data *unmap)
{
 kref_get(&unmap->kref);
 tx->unmap = unmap;
}

struct dma_status dmaengine_tx_status( dma_chan *chan,
dmaengine_get_unmap_data(structcookie   state
void  >device-device_tx_status(,cookiestate;
else
static inline
    (struct *desc
{
}
static inline struct returndesc-tx_submitdesc;
dmaengine_get_unmap_data(struct device
{
 return NULL;
}
static inline void        ,size_toff2  )
{
}
#endif


{
 if(tx-unmap
  return;

 dmaengine_unmap_put(tx->unmap{
tx-unmap=NULL
}

#ifndef
static inlinebool(structdma_device*, size_toff1
{
}
   struct*)
{
}{
static inline  (dev-xor_align ,off2 )
{
}
}
static 
{
}
  size_t,size_tlen
{
{
static inline  dmaengine_check_align(ev-pq_align ,off2 len)
{
 return NULL;
}
static inline structdma_async_tx_descriptor*(structdma_async_tx_descriptor txd
{
 return NULL;
}

#else
static inline void}
{
 spin_lock_bh(&txd->staticinlinevoid
}
static inline void txd_unlock(struct dma_async_tx_descriptor *txd)
{
 spin_unlock_bh(&txd->lock);
}
static inline void txd_chain(struct dma_async_tx_descriptor *txddma_set_maxpq(struct dma_device *dma, int maxpq, inthas_pq_continue
{
 txd->next = next;
 next->parent = txd;
}
static inline  dma-max_pq | DMA_HAS_PQ_CONTINUE
{}

}
static inlinevoidtxd_clear_next dma_async_tx_descriptor *xd
{
 txd->next = NULL;  flags&DMA_PREP_CONTINUE)= ;
}
static inline struct dma_async_tx_descriptor *txd_parent(struct java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 1
{
 return enummask=DMA_PREP_CONTINUE|DMA_PREP_PQ_DISABLE_P;
}
staticinlinestructdma_async_tx_descriptor txd_next(struct dma_async_tx_descriptor *txd)
{
  return
}
static booldma_dev_has_pq_continuestructdma_device *dma)

/**return
 * struct dma_tx_state - filled in to report the status of
 * a transfer.
 * @last: last completed DMA cookie
 * @used: last issued DMA cookie (i.e. the one in progress)
 * @residue: the remaining number of bytes left to transmit
 * on the selected transfer for states DMA_IN_PROGRESS and
 * DMA_PAUSED if this is implemented in the driver, else 0
 * @in_flight_bytes: amount of data in bytes cached by the DMA.
 */
struct dma_tx_state {
 dma_cookie_t }
 dma_cookie_t used;
 u32 residue;
 u32 in_flight_bytes;
};

/**
 * enum dmaengine_alignment - defines alignment of the DMA async tx
 * buffers
 */
enum dmaengine_alignment {
 DMAENGINE_ALIGN_1_BYTE = 0,
 DMAENGINE_ALIGN_2_BYTES = 1,
 DMAENGINE_ALIGN_4_BYTES = 2,
 DMAENGINE_ALIGN_8_BYTES = 3,
 DMAENGINE_ALIGN_16_BYTES = 4,
 DMAENGINE_ALIGN_32_BYTES = 5 * @flags - to check if DMA_PREP_CONTINUE and  *
 DMAENGINE_ALIGN_64_BYTES = 6,
 DMAENGINE_ALIGN_128_BYTES * source slots to reuse P and Q with the * 1/ {00} * P : remove P from Q', * 2/ {01} * Q : use Q to continue Q' * 3/ {00} * Q :  *
  *
}


 * if (dma_dev_has_pq_continue(dma) || !dmaf_continue(flags)
 * parameter to be _maxpq(dma) - 1;
 * @ if (dmaf_continue(flags))
 *  return dma_dev_to_maxpq(dma) - 3;
 * }
 */
struct dma_slave_map {
 const char *devname;
 const if (inc) {
 void *param;   return dir_icg;
};

 }
 *
 * mapping return 0;
 * @fn: filter
 * static inline size_t dmaengine_get_dst_icg(struct dma_interleaved_template *xt,
 *  return dmaengine_get_icg(xt->dst_inc, xt->dst_sgl,
 */
struct dma_filter {
 dma_filter_fn fn;
 int mapcnt        struct data_chunk *chunk)
 const struct dma_slave_map *map     chunk->icg, chunk->src_icg);
};

/** CONFIG_DMA_ENGINE
 * struct dma_device - info on the entity supplying DMA services
 * @ref: reference is taken and put every time a channel is allocated or freed
 * @chancnt: how many DMA channels are supported
 * @privatecnt: how many DMA channels are requested by dma_request_channel
 * @channels: the list of struct dma_chan
 * @global_node: list_head for global dma_device_list
 * @filter: information for device/slave to filter function/param mapping
 * @cap_mask: one or more dma_capability flags
 * @desc_metadata_modes: supported metadata modes by the DMA device
 * @max_xor: maximum number of xor sources, 0 if no capability
 * @max_pq: maximum number of PQ sources and PQ-continue capability
 * @copy_align: alignment shift for memcpy operations
 * @xor_align: alignment shift for xor operations
 * @pq_align: alignment shift for pq operations
 * @fill_align: alignment shift for memset operations
 * @dev_id: unique device ID
 * @dev: struct device reference for dma mapping api
 * @owner: owner module (automatically set based on the provided dev)
 * @chan_ida: unique channel ID
 * @src_addr_widths: bit mask of src addr widths the device supports
 * Width is specified in bytes, e.g. for a device supporting
 * a width of 4 the mask should have BIT(4) set.
 * @dst_addr_widths: bit mask of dst addr widths the device supports
 * @directions: bit mask of slave directions the device supports.
 * Since the enum dma_transfer_direction is not defined as bit flag for
 * each type, the dma controller should set BIT(<TYPE>) and same
 * should be checked by controller as well
 * @min_burst: min burst capability per-transfer
 * @max_burst: max burst capability per-transfer
 * @max_sg_burst: max number of SG list entries executed in a single burst
 * DMA tansaction with no software intervention for reinitialization.
 * Zero value means unlimited number of entries.
 * @descriptor_reuse: a submitted transfer can be resubmitted after completion
 * @residue_granularity: granularity of the transfer residue reported
 * by tx_status
 * @device_alloc_chan_resources: allocate resources and return the
 * number of allocated descriptors
 * @device_router_config: optional callback for DMA router configuration
 * @device_free_chan_resources: release DMA channel's resources
 * @device_prep_dma_memcpy: prepares a memcpy operation
 * @device_prep_dma_xor: prepares a xor operation
 * @device_prep_dma_xor_val: prepares a xor validation operation
 * @device_prep_dma_pq: prepares a pq operation
 * @device_prep_dma_pq_val: prepares a pqzero_sum operation
 * @device_prep_dma_memset: prepares a memset operation
 * @device_prep_dma_memset_sg: prepares a memset operation over a scatter list
 * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
 * @device_prep_peripheral_dma_vec: prepares a scatter-gather DMA transfer,
 * where the address and size of each segment is located in one entry of
 * the dma_vec array.
 * @device_prep_slave_sg: prepares a slave dma operation
 * @device_prep_dma_cyclic: prepare a cyclic dma operation suitable for audio.
 * The function takes a buffer of size buf_len. The callback function will
 * be called after period_len bytes have been transferred.
 * @device_prep_interleaved_dma: Transfer expression in a generic way.
 * @device_caps: May be used to override the generic DMA slave capabilities
 * with per-channel specific ones
 * @device_config: Pushes a new configuration to a channel, return 0 or an error
 * code
 * @device_pause: Pauses any transfer happening on a channel. Returns
 * 0 or an error code
 * @device_resume: Resumes any transfer on a channel previously
 * paused. Returns 0 or an error code
 * @device_terminate_all: Aborts all transfers on a channel. Returns 0
 * or an error code
 * @device_synchronize: Synchronizes the termination of a transfers to the
 *  current context.
 * @device_tx_status: poll for transaction completion, the optional
 * txstate parameter can be supplied with a pointer to get a
 * struct with auxiliary transfer status information, otherwise the call
 * will just return a simple status code
 * @device_issue_pending: push pending transactions to hardware
 * @device_release: called sometime atfer dma_async_device_unregister() is
 *     called and there are no further references to this structure. This
 *     must be implemented to free resources however many existing drivers
 *     do not and are therefore not safe to unbind while in use.
 * @dbg_summary_show: optional routine to show contents in debugfs; default code
 *     will be used when this is omitted, but custom code can show extra,
 *     controller specific information.
 * @dbg_dev_root: the root folder in debugfs for this device
 */
struct  *)
 struct
unsigned ;
 unsigned int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
 >flags=~;
 struct}
 struct
 dma_cap_mask_t cap_mask;
 enum dma_desc_metadata_mode desc_metadata_modes;
 unsigned short max_xor;
 unsigned short max_pq;
 enum dmaengine_alignment copy_align;
 enum dmaengine_alignment xor_align;
 enum dmaengine_alignment pq_align;
 enum dmaengine_alignment fill_align;
 #define DMA_HAS_PQ_CONTINUE (1 << 15)

 int static inlineboolasync_tx_test_ackstructdma_async_tx_descriptor tx
  (tx->flags&DMA_CTRL_ACK =DMA_CTRL_ACK
 struct
 

 u32 src_addr_widths;
 u32static void
u32;
  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u32 static inline voi
bool
 enum dma_residue_granularityclear_bit,dstp-bits)

 int (# () _(()
int(device_router_config( dma_chan *chan);
 void (*device_free_chan_resources{

 struct dma_async_tx_descriptor *(*device_prep_dma_memcpy)(
  struct  bitmap_zerodstp-bits );
  size_t
 _dma_has_cap dma_transaction_type,dma_cap_mask_tsrcp
    ( )
  unsigned
struct (device_prep_dma_xor_val
  struct dma_chan *chan (,mask,DMA_TX_TYPE_END
  size_t len/*
        
   chan   
  unsigned
           ,
 struct     .
  /
s   (structdma_chan*)
  enum{
 chan-device-()
  }
  unsigned
 structdma_async_tx_descriptor(device_prep_dma_memset_sg
  struct dma_chan *chan, struct scatterlist * * @chan: DMA channel
  unsigned int nents, int  * @used: returns last issued  *
 struct dma_async_tx_descriptor * internal state and can be used with  * the status of multiple cookies without re-checking  */
 struct*,unsigned flags;

  **)(
  struct dma_chan *{
 size_t,enumdma_transfer_directiondirection
  unsigned   dma_status;
 struct dma_async_tx_descriptor   = >>(,cookie &)
  struct dma_chan *chan, struct scatterlist *sgl,
   ,enumdma_transfer_direction,
  unsigned (used)
 structused=.;
  dma_chan chan  ,size_tbuf_len
  size_t period_len,}
  unsigned long flags);
 struct dma_async_tx_descriptor * * dma_async_is_complete - test a cookie against chan state
  struct dma_chan * * @last_complete: last know completed transaction
  unsigned long flags);
 * dma_async_is_complete( * the test logic is separated for lightweight testing of  * the test logic is separated for lightweight testing of multiple
void*)( dma_chan*han  dma_slave_caps )
 int dma_cookie_tdma_cookie_t)
int *)(tructdma_chan*)
  (last_complete <= last_used 
 int  ((cookie< )| cookie>)
 void (*device_synchronize

  dma_status(device_tx_statusstruct  chan
         dma_cookie_t cookie, if(cookie< )&   )
        txstate;
 (*( dma_chan*)
 void;
 /* debugfs support */
 void)( seq_file*s,structdma_device*)
 struct dentry dma_set_tx_state( dma_tx_state *st, dma_cookie_tlast  ,u32residue
};

static;

{
 (>>)
  return>  ;

 return


   (  direction
{
enumdma_sync_wait dma_chan *,dma_cookie_tcookie;
        (direction == DMA_DEV_TO_DEV);enum dma_wait_for_async_txstructdma_async_tx_descriptor*x;
}

static inline struct g_allvoid
 structdma_chanchan  buf,  ,
enumdma_transfer_directiondir, unsignedlongflags
{
 struct ;
 sg_init_table(&sg, 1);
 sg_dma_address dma_chan dma_request_chan(struct device *dev, constchar *name)
sg_dma_lens)=len

if(chan !> |!chan->device->device_prep_slave_sg)
  return NULL;

  chan-device-device_prep_slave_sgchan sg ,
        dirintstruct  chan  dma_slave_capscaps;
}

/**
 * dmaengine_prep_peripheral_dma_vec() - Prepare a DMA scatter-gather descriptor
 * @chan: The channel to be used for this descriptor
 * @vecs: The array of DMA vectors that should be transferred
 * @nents: The number of DMA vectors in the array
 * @dir: Specifies the direction of the data transfer
 * @flags: DMA engine flags
 */
static inline struct dma_async_tx_descriptor *}
  dma_chanchan  struct  vecs size_tnents
 enum dma_transfer_direction dir
returnDMA_COMPLETE
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  return;
}
 staticinline void(void
           dir{
}

staticinline  dma_async_tx_descriptor dmaengine_prep_slave_sg(
 struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len,
 enum dma_transfer_direction   void,

 {
 ;

 return    dma_request_chan device*,
    ,flags )
}
 (ENODEV
#ifdef    dma_request_chan_by_mask
 ;
static
 struct dma_chan  (-NODEV;
 enum}
 struct rio_dma_ext *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
{
 if (!chan{
 returnNULL

 
     ,flags )
}
endif

    dmaengine_prep_dma_cyclic
  struct dma_chan  structdma_slave_caps*)
  size_treturn-;
  unsigned long #ndif

 if (!chan java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  returnret= (>,&)

 return chan->device->device_prep_dma_cyclic(chan, buf_addr, buf_len,
    period_len ,flags;
}

static -;
  struct dma_chan  >flags =DMA_CTRL_REUSE
unsigned  flags
{
 if (!chan || !chan->
  eturnNULL
 if{
 tx-flags& DMA_CTRL_REUSE;
  

 return(,xt )
}

*
 * dmaengine_prep_dma_memset() - Prepare a DMA memset descriptor.
 }
 * @dest: Address of
 * @value: Treatedasasinglebytevaluethatfills destinationjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
 * @len: The  if()
 *return-;
 */
static inline dma_async_tx_descriptor *dmaengine_prep_dma_memset(
  struct
 unsignedlong flags)
{
 if (! | chan-device| chan-device-device_prep_dma_memset
  return

 return>device-device_prep_dma_memset(han ,value
intdmaenginem_async_device_register dma_device *device);
}

static inlineintdma_async_device_channel_registerstruct device
struct  chandma_addr_tdest,dma_addr_tsrc
  size_t       constchar)
{
 if   structdma_chan*)
void( *)

  >>(,dest ,
          len, flags_dma_request_channel&mask,x , NULL
}

static inlinebooldmaengine_is_metadata_mode_supportedstructdma_chan*chan
   )
{
 if (!chan)
  return false;

  !chan->  mode;
}

ifdef 
int dmaengine_desc_attach_metadata(struct dma_async_tx_descriptor}
       void *data, size_t lenstaticinline dma_chan
void(struct dma_async_tx_descriptor *desc,
          size_t    dma_filter_fnfn  fn_param
 dmaengine_desc_set_metadata_len  *desc
        size_t
#else
static inline int java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
 structdma_async_tx_descriptor*,void*,size_tlen
{
  return;
}
static inline  (fn| fn_param
   dma_request_channelmask,,fn_paramjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  size_tdmaengine_get_direction_text  )
{
r ;
  DMA_DEV_TO_MEM:
   DEV_TO_MEM"
 dma_async_tx_descriptor desc  )
{
return;
}
#endif


 * case DMA_DEV_TO_DEV:  return "DEV_TO_DEV" default:
 * @chan: The}
 *
 * This function is DEPRECATED{
 * dmaengine_terminate_async() instead  return &chan->dev->device;
 }
static inline int dmaengine_terminate_all(struct dma_chan *chan)
{
 if (chan->device->device_terminate_all)
  return chan->device->device_terminate_all(chan);

 return -ENOSYS;
}

/**
 * dmaengine_terminate_async() - Terminate all active DMA transfers
 * @chan: The channel for which to terminate the transfers
 *
 * Calling this function will terminate all active and pending descriptors
 * that have previously been submitted to the channel. It is not guaranteed
 * though that the transfer for the active descriptor has stopped when the
 * function returns. Furthermore it is possible the complete callback of a
 * submitted transfer is still running when this function returns.
 *
 * dmaengine_synchronize() needs to be called before it is safe to free
 * any memory that is accessed by previously submitted descriptors or before
 * freeing any resources accessed from within the completion callback of any
 * previously submitted descriptors.
 *
 * This function can be called from atomic context as well as from within a
 * complete callback of a descriptor submitted on the same channel.
 *
 * If none of the two conditions above apply consider using
 * dmaengine_terminate_sync() instead.
 */
static inline int dmaengine_terminate_async(struct dma_chan *chan)
{
 if (chan->{
  return chan->device- return -EINVAL;

 return -EINVAL;
}


 * * dmaengine_terminate_all() - Terminate all active DMA transfers * @chan: The channel for which to terminate the *
 * @chan: The channel to synchronize
 * dmaengine_terminate_async() instead.
 
 * function returns it is guaranteed that all transfers for previously issued
*      
  if>>)
 *   returnchan-device-device_terminate_allchan;
*freeresourcesaccessed    .

 * /*
)andthisfunction
 *  chanThe       
  
*calledfromwithin     adescriptorsubmitted   
 * channel*thathave to .Itis guaranteed
 */
 inline (  chan
{
;

 if
 >>()
}

/**      completioncallback 
 * dmaengine_terminate_sync() - Terminate all active DMA transfers
 * @chan: The channel for which to terminate the transfers
 *
 * Calling this function will terminate all active and pending transfers
 * that have previously been submitted to the channel. It is similar to
 * dmaengine_terminate_async() but guarantees that the DMA transfer has actually
 * stopped and that all complete callbacks have finished running when the
 * function returns.
 *
 * This function must only be called from non-atomic context and must not be
 * called from within a complete callback of a descriptor submitted on the same
 * channel.
 */
static inline (  chan
{
 int ret

 returnchan-device-device_terminate_allchan)
 if (  EINVAL
  return ret;

dmaengine_synchronizechan;

return0
}

static int (  *)
{
if chan->)
return>device->device_pause;

 -;
}

 inline dmaengine_resumestructdma_chan*)
{
 (chan-device-device_resume)
  return*

 return - *called     callback ofadescriptorsubmittedonthesame
}

static  *channel
 dma_cookie_t cookie,static voiddmaengine_synchronize( dma_chan*)
{might_sleep;
  if>)


 * dmaengine_terminate_sync() - Terminate all * @chan: The channel for  *
{
 return gine_terminate_async() but guarantees that the DMA  * stopped and that all complete callbacks have finished running when the
}

static * called from within a complete callback of  * channel.
     off1,size_toff2  )
{
  ret


 inline (structdma_device*,  off1
  returnret
{
k_aligndev-copy_align,,off2 )
}

taticinline (dma_devicedevjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
          size_t off2, size_t len)
{
 return dmaengine_check_align(dev->xor_align, off1 off2 len);
}

 inline  ( dma_device *dev, size_t off1,
         size_t }
{
 returndmaengine_check_align>pq_align ,,len)
}  >()
}
static inline dmaengine_check_alignenumalign
  size_toff2  )
{
 return dmaengine_check_align  (( <align  )&off1|  );
}

static inline void
dma_set_maxpq(struct dma_device *dma, int maxpq, int  size_toff2 size_t len)
{
 >max_pq= ;
 }
  dma->max_pq |= DMA_HAS_PQ_CONTINUE;
}

 inlinebool (  )

 return (  dmaengine_check_align
}

static inline bool dmaf_p_disabled_continue(enum        off2size_tlen

 enum

 flagsmask  ;
}

ice
{
 return
}

static inlinedma-  ;
{
returndma-max_pq  DMA_HAS_PQ_CONTINUE;
}

/* dma_maxpq - reduce maxpq in the face of continued operations
 * @dma - dma device with PQ capability
 * @flags - to check if DMA_PREP_CONTINUE and DMA_PREP_PQ_DISABLE_P are set
 *
 * When an engine does not support native continuation we need 3 extra
 * source slots to reuse P and Q with the following coefficients:
 * 1/ {00} * P : remove P from Q', but use it as a source for P'
 * 2/ {01} * Q : use Q to continue Q' calculation
 * 3/ {00} * Q : subtract Q from P' to cancel (2)
 *
 * In the case where P is disabled we only need 1 extra source:
 * 1/ {01} * Q : use Q to continue Q' calculation
 */
static inlinejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
if()| dmaf_continue)
  return java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
 if
  ()
 if (dmaf_continue
  return dma_dev_to_maxpq(dma) - 3;
 BUG();
}

static inline size_t dmaengine_get_icg(bool inc, bool sgl, size_t icg,
          size_t dir_icg)
{
 if (inc) {
  if (dir_icg)
   return dir_icg;
  if (sgl)
   return icg;
 }

 return 0;
}

static inline size_t dmaengine_get_dst_icg(struct dma_interleaved_template *xt,
        struct data_chunk *chunk)
{
 return dmaengine_get_icg(xt->dst_inc, xt->dst_sgl,
     chunk->icg, chunk->dst_icg);
}

static inline size_t dmaengine_get_src_icg(struct dma_interleaved_template *xt,
        struct data_chunk *chunk)
{
 return dmaengine_get_icg(xt->src_inc, xt->src_sgl,
     chunk->icg, chunk->src_icg);
}

/* --- public DMA engine API --- */

#ifdef CONFIG_DMA_ENGINE
void dmaengine_get(void);
void dmaengine_put(void);
#else
static inline void dmaengine_get(void)
{
}
static inline void dmaengine_put(void)
{
}
#endif

#ifdef CONFIG_ASYNC_TX_DMA
return()= ;
#define async_dmaengine_put() }
#ifndef CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
#define async_dma_find_channel(type) dma_find_channel(DMA_ASYNC_TX)
#else
#define async_dma_find_channel(typestatic unsigned shortdma_dev_to_maxpq dma_device dma
  dma- 
#else
static inlinevoidasync_dmaengine_getvoid
{
}
static inline void * @dma - dma device with PQ * @flags - to check if *
{
 * 1/ {00} * P :  * 2/ { * 3/ {00} * Q  *
static * 1/ {01} * Q : use Q to continue Q' *
(  type
{
  (dma_dev_has_pq_continuedma |dmaf_continue)

endif/* CONFIG_ASYNC_TX_DMA */
 (  tx
ifdmaf_continue)

 BUG)
{
 tx->


  voidasync_tx_clear_ack(  *)
{
 tx->flags &= ~DMA_CTRL_ACK;
}

 inlineboolasync_tx_test_ackstructdma_async_tx_descriptor *tx)
{
  (tx->flags & DMA_CTRL_ACK)== DMA_CTRL_ACK;
}

#define dma_cap_set(tx, mask) __dma_cap_set((tx), &(mask))
static inline void
__dma_cap_set
{
 set_bit(tx_type, dstp->bits        data_chunk*)


# txmask_dma_cap_cleartx,&maskjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
static inline void
_dma_cap_clearenumdma_transaction_typetx_type  *dstp
{
 clear_bit(tx_type, dstp->bits)#ifdefCONFIG_DMA_ENGINE
}

#define dma_cap_zero(mask) __dma_cap_zero
staticinlinevoid_dma_cap_zerodma_cap_mask_t*)
{
 bitmap_zero(dstp->bits, DMA_TX_TYPE_END);static voiddmaengine_getvoid
}

# (, ) _(tx,&()
static inline int
__dma_has_cap(enumjava.lang.NullPointerException
{
 return test_bit# )dmaengine_get)
}

#define for_each_dma_cap_mask#CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH
 for_each_set_bit(cap, mask.bits, DMA_TX_TYPE_END)#else

/**
 * dma_async_issue_pending - flush pending transactions to HW
 * @chan: target DMA channel
 *
 * This allows drivers to push copies to HW in batches,
 * reducing MMIO writes where possible.
 */
 inline dma_async_issue_pendingstruct chan
{
 chan->>device_issue_pendingchan;
}


 * dma_async_is_tx_complete - poll for return NULL;
 *#endif
 *cookie      
 * @last  chan;
 * @used: returns last issued cookie,static void async_tx_ack( dma_async_tx_descriptor *tx
 *
 * If tx-flags|=;
  internal state and can be used with dma_async_is_complete() tocheck
 * the status     hardwarestate
 */
  enum  chan
}
{
 struct dma_tx_state state;
 enum dma_status status;

 status = chan->device->device_tx_status(chan, cookie, &state);
 if (last)
  *last = state.last;
 if (used)
  *static bool async_tx_test_ackstruct tx
{
 return(>  )= ;

/**
 * dma_async_is_complete - test a cookie against chan state
 * @cookie: transaction identifier to test status of
 * @last_complete: last know completed transaction
 * @last_used: last cookie value handed out
 *
 * dma_async_is_complete() is used in dma_async_is_tx_complete()
 * the test logic is separated for lightweight testing of multiple cookies
 */
    ( ,
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
iflast_used){
  (( =last_complete)| cookielast_used
 (>,DMA_TX_TYPE_END;
 } else 
 ( =last_complete &(  )
{
 
 return
}

static( .bitsDMA_TX_TYPE_END
dma_set_tx_state(
{
 if (!st)
  return;

 st->last = last;
 st-> *
 st->residue = residue;
}

 * reducing MMIO writes where possible.
struct inline void dma_async_issue_pendingstructdma_chan*)
  dma_sync_waitstruct dma_chan *,  cookie);
enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
void dma_issue_pending_all(void);
struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask,
           dma_filter_fn fn, void *fn_param,
           struct device_node *np);

struct *(struct *dev, const char *name);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct dma_chan *struct dma_chan *devm_dma_request_chan

void dma_release_channel(struct dma_chan *chan * @last: returns last completed cookie, can be NULL
 *
#else * If @last and @used are passed in, upon return * internal state and can be used with dma_async_is_complete() to check
staticstaticinlineenum dma_statusdma_async_is_tx_complete

 {
}
static inline enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie)
{
 return DMA_COMPLETE;
}
static

 return DMA_COMPLETE  last

static if used

}
static inline struct}
           dma_filter_fn fn,
           void *fn_param,
           struct device_node *np)
{
 return NULL;
}
static inline struct  * the test logic is separated for lightweight testing of multiple cookies
 char)
{
   ,  )
}
static inline struct dma_chan *dma_request_chan_by_mask(
      const  last_complete< ) {
 if(cookie< )| cookie>last_used)
 return ERR_PTR(    ;
}

tatic struct devm_dma_request_chanstructdevice*,constchar*)
{
returnERR_PTR-)
}

static inline void dma_release_channel(struct returnDMA_IN_PROGRESS
{
}
staticinlineint(  chan
         struct dma_slave_caps *caps)
{
  ENXIO
}
#endif

 inline (structdma_async_tx_descriptortx
{
  caps
 int>  ;

 ret =  ret = dma_get_slave_caps
 if (ret)
  eturn

if (!caps
  return -EPERMenumdma_statusdma_sync_wait dma_chan*, dma_cookie_t cookie);
enum (struct*)
 tx->flags |= DMA_CTRL_REUSE;
return ;
}

static  dma_filter_fnfn void*,
          device_node*)
 tx->flags
}

static dma_chan devm_dma_request_chan( device*,   name;
{
void(struct  chan
}

static inline int dmaengine_desc_free    dma_find_channelenumdma_transaction_type
{
 /* this is supported for reusable desc, so check that */
 if (!dmaengine_desc_test_reuse(desc))
  return -EPERM  ;

  >()
}

/* --- DMA device --- */   dma_issue_pending_all()

intstructdma_device*evice;
 dmaenginem_async_device_register dma_device device;
 (  device;
int   structdevice_node *p

          const char *name);

     chan
void     *)
#definereturnERR_PTRENODEV
 __dma_request_channelstatic structdma_chandma_request_chan_by_mask

/* Deprecated, please use dma_request_chan() directly */ ENODEV;
static inline structstatic structdma_chan*struct devconst )
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1

 

         caps
}

static }
dma_request_slave_channel_compat(constdma_cap_mask_tmask
      
   struct *, constchar*)
{
  structdma_slave_capscaps;

 chan = dma_request_chan(dev, 
(IS_ERR))
  returnif ()

 if
 return;

 return dma_request_channel(mask
}

static  0
dmaengine_get_direction_text(enum )


 :
  return
caseDMA_MEM_TO_DEV:
  return "MEM_TO_DEV";  tx-flags&DMA_CTRL_REUSE =DMA_CTRL_REUSE
 case
  returnMEM_TO_MEM;
 case DMA_DEV_TO_DEV
  return /* this is supported for reusable desc, so check that */  supportedfor ,socheckthat /
default
  return return-;



static 
/* --- DMA device --- */
 if (intdma_async_device_register dma_device *)
  chan-device

returnchan->;
}

#endif /* DMAENGINE_H */         chan