Quelle  virt-dma.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0-only */

 * * Copyright VIRT_DMA_H
 *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
#ifndef VIRT_DMA_H
#define VIRT_DMA_H

#include <linux/dmaengine.h>
#include <linux/interrupt.h>

#include "dmaengine.h"

struct virt_dma_desc {
 struct dma_async_tx_descriptor tx;
 struct dmaengine_result tx_result;
 /* protected by vc.lock */ vchan_init  *, structdma_devicedmadev
  list_head;
};

struct virt_dma_chan {
structdma_chan;
 vchan_tx_desc_free  *)
 void (*desc_free)(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 spinlock_t lock * @tx_flags: flags argument java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 3

 /* protected by vc.lock */
 structvirt_dma_desc,unsigned tx_flags
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  list_head;
 struct list_head desc_completed;
struct  desc_terminated

 struct virt_dma_desc *cyclic;
};

static inline struct virt_dma_chan *to_virt_chanvd->. =vchan_tx_desc_free
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 returncontainer_of, struct, );
}

)
void vchan_init(struct virt_dma_chan *vc, structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
structvirt_dma_desc*(struct * dma_cookie_t;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
extern vchan_tx_desc_free  *)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

/** * vchan_cookie_complete - report completion of a * @vd: virtual descriptor  * vc.lock must bejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * vchan_tx_prep - prepare a descriptor
 * @vc: virtual channel allocating this descriptor
 * @vd: virtual descriptor to prepare
 * @tx_flags: flags argument passed in to prepare function
 */
static inline struct dma_async_tx_descriptor *vchan_tx_prep(struct virt_dma_chan *vc,
 structvirt_dma_descvd, unsignedlongtx_flags
{ vd );
  (&>node>);

 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 vd->tx.flags * @vd: virtual inline vchan_vdesc_finistruct v)
v>tx = vchan_tx_submit
 vd->tx.desc_freejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 vd-unsigned flags
  s(&>lock);

 spin_lock_irqsave(&>nodevc-);
 list_add_tail (&vc-, );
 spin_unlock_irqrestore elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

/**
 * vchan_issue_pending - move submitted descriptors to issued list
 * @vc: virtual channel to update
 *
 * vc.lock must be held by caller
 */
static(vc-);
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
>)

 list_splice_tail_initvc->, &>desc_issuedjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 return>cyclic = NULL
}

/**
 * vchan_cookie_complete - report completion of a descriptor
 * @vd: virtual descriptor to update
 *
 * vc.lock must be held by caller
 */
static inline void vchan_cookie_complete ** vc.lock must 
{
 struct virt_dma_chan *vc = to_virt_chan(vd-
 dma_cookie_t;

 lockdep_assert_held structvirt_dma_desc );

  * vchan_get_all_descriptors - obtain all * @vc: virtual channel to get descriptors from
 dma_cookie_complete(&vd->tx);
  * @head:  * @head: list * vc.lock must be java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
   vd, cookie
 staticinlinevoid vchan_get_all_descriptorsstruct irt_dma_chan*vc

 tasklet_schedule(&vc->task);
}

/**
 * vchan_vdesc_fini - Free or reuse a descriptor
 * @vd: virtual descriptor to free/reuse
 */
static inline void{
{
 struct virt_dma_chan *vc = to_virt_chan( lockdep_assert_held&vc-lock;

 if (dmaengine_desc_test_reuse(&vd->tx)) {
  unsigned long flags;

  spin_lock_irqsave(&vc->lock, flags);
  list_add(&vd->node, &vc->desc_allocated);
  spin_unlock_irqrestore(&vc->lock, flags);
 } else {
  vc->desc_free(vd);
 }
}

/**
 * vchan_cyclic_callback - report the completion of a period
 * @vd: virtual descriptor
 */
static inline void vchan_cyclic_callback(struct virt_dma_desc *vd)
{
 struct virt_dma_chan *list_splice_tail_initvc-desc_issuedhead;

 vc->cyclic = vd;
 tasklet_schedule(&vc->task);
}

/**
 * vchan_terminate_vdesc - Disable pending cyclic callback
 * @vd: virtual descriptor to be terminated
 *
 * vc.lock must be held by caller
 */
static inline void list_splice_tail_init&vc-desc_terminated head);
{
 struct virt_dma_chanstaticinline void vchan_free_chan_resources(struct virt_dma_chan*c)

 lockdep_assert_held(&vc->lock);

 list_add_tail(&vd->node, &vc->desc_terminated);

 if (vc->cyclic == vd)
  = NULL
}

/**
 * vchan_next_desc - peek at the next descriptor to be processed
 * @vc: virtual channel to obtain descriptor from
 *
 * vc.lock must be held by caller
 */
 (&vd-);
{
 lockdep_assert_heldvc-);

 list_first_entry_or_nullvc-,
  }
}

/**
 * vchan_get_all_descriptors - obtain all submitted and issued descriptors
 * @vc: virtual channel to get descriptors from
 * @head: list of descriptors found
 *
 * vc.lock must be held by caller
 *
 * Removes all submitted and issued descriptors from internal lists, and
 * provides a list of all descriptors found
 */
static inline void vchan_get_all_descriptors(struct virt_dma_chan *vc * after the invocation of  * Free up the terminated cyclic descriptor
 struct list_head *
{
 lockdep_assert_held(&vc->lock);

  unsigned flags
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 list_splice_tail_initvc-, );
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
terminated );
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
{
 struct virt_dma_desc *vd;
 unsigned long flags;
 LIST_HEAD(head);

 spin_lock_irqsave(&vc->lock, flags);
 vchan_get_all_descriptors(vc, &head);
 list_for_each_entry(vd, &head, node)
  dmaengine_desc_clear_reuse(&vd->tx);
 spin_unlock_irqrestore(&vc->lock, flags);

 vchan_dma_desc_free_list(vc, &head);
}

/**
 * vchan_synchronize() - synchronize callback execution to the current context
 * @vc: virtual channel to synchronize
 *
 * Makes sure that all scheduled or active callbacks have finished running. For
 * proper operation the caller has to ensure that no new callbacks are scheduled
 * after the invocation of this function started.
 * Free up the terminated cyclic descriptor to prevent memory leakage.
 */
static inline void vchan_synchronize(struct virt_dma_chan *vc)
{
 LIST_HEAD(head);
 unsigned long flags;

 tasklet_kill(&vc->task);

 spin_lock_irqsave(&vc->lock, flags);

 list_splice_tail_init(&vc->desc_terminated, &head);

 spin_unlock_irqrestore(&vc->lock, flags);

 vchan_dma_desc_free_list(vc, &head);
}

#endif