include/linux/dma-fence-chain.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * fence-chain: chain fences together in a timeline
   4  *
   5  * Copyright (C) 2018 Advanced Micro Devices, Inc.
   6  * Authors:
   7  *      Christian König <christian.koenig@amd.com>
   8  */
   9
  10 #ifndef __LINUX_DMA_FENCE_CHAIN_H
  11 #define __LINUX_DMA_FENCE_CHAIN_H
  12
  13 #include <linux/dma-fence.h>
  14 #include <linux/irq_work.h>
  15 #include <linux/slab.h>
  16
  17 /**
  18  * struct dma_fence_chain - fence to represent an node of a fence chain
  19  * @base: fence base class
  20  * @prev: previous fence of the chain
  21  * @prev_seqno: original previous seqno before garbage collection
  22  * @fence: encapsulated fence
  23  * @lock: spinlock for fence handling
  24  */
  25 struct dma_fence_chain {
  26         struct dma_fence base;
  27         struct dma_fence __rcu *prev;
  28         u64 prev_seqno;
  29         struct dma_fence *fence;
  30         union {
  31                 /**
  32                  * @cb: callback for signaling
  33                  *
  34                  * This is used to add the callback for signaling the
  35                  * complection of the fence chain. Never used at the same time
  36                  * as the irq work.
  37                  */
  38                 struct dma_fence_cb cb;
  39
  40                 /**
  41                  * @work: irq work item for signaling
  42                  *
  43                  * Irq work structure to allow us to add the callback without
  44                  * running into lock inversion. Never used at the same time as
  45                  * the callback.
  46                  */
  47                 struct irq_work work;
  48         };
  49         spinlock_t lock;
  50 };
  51
  52
  53 /**
  54  * to_dma_fence_chain - cast a fence to a dma_fence_chain
  55  * @fence: fence to cast to a dma_fence_array
  56  *
  57  * Returns NULL if the fence is not a dma_fence_chain,
  58  * or the dma_fence_chain otherwise.
  59  */
  60 static inline struct dma_fence_chain *
  61 to_dma_fence_chain(struct dma_fence *fence)
  62 {
  63         if (!fence || !dma_fence_is_chain(fence))
  64                 return NULL;
  65
  66         return container_of(fence, struct dma_fence_chain, base);
  67 }
  68
  69 /**
  70  * dma_fence_chain_contained - return the contained fence
  71  * @fence: the fence to test
  72  *
  73  * If the fence is a dma_fence_chain the function returns the fence contained
  74  * inside the chain object, otherwise it returns the fence itself.
  75  */
  76 static inline struct dma_fence *
  77 dma_fence_chain_contained(struct dma_fence *fence)
  78 {
  79         struct dma_fence_chain *chain = to_dma_fence_chain(fence);
  80
  81         return chain ? chain->fence : fence;
  82 }
  83
  84 /**
  85  * dma_fence_chain_alloc
  86  *
  87  * Returns a new struct dma_fence_chain object or NULL on failure.
  88  */
  89 static inline struct dma_fence_chain *dma_fence_chain_alloc(void)
  90 {
  91         return kmalloc(sizeof(struct dma_fence_chain), GFP_KERNEL);
  92 };
  93
  94 /**
  95  * dma_fence_chain_free
  96  * @chain: chain node to free
  97  *
  98  * Frees up an allocated but not used struct dma_fence_chain object. This
  99  * doesn't need an RCU grace period since the fence was never initialized nor
 100  * published. After dma_fence_chain_init() has been called the fence must be
 101  * released by calling dma_fence_put(), and not through this function.
 102  */
 103 static inline void dma_fence_chain_free(struct dma_fence_chain *chain)
 104 {
 105         kfree(chain);
 106 };
 107
 108 /**
 109  * dma_fence_chain_for_each - iterate over all fences in chain
 110  * @iter: current fence
 111  * @head: starting point
 112  *
 113  * Iterate over all fences in the chain. We keep a reference to the current
 114  * fence while inside the loop which must be dropped when breaking out.
 115  *
 116  * For a deep dive iterator see dma_fence_unwrap_for_each().
 117  */
 118 #define dma_fence_chain_for_each(iter, head)    \
 119         for (iter = dma_fence_get(head); iter; \
 120              iter = dma_fence_chain_walk(iter))
 121
 122 struct dma_fence *dma_fence_chain_walk(struct dma_fence *fence);
 123 int dma_fence_chain_find_seqno(struct dma_fence **pfence, uint64_t seqno);
 124 void dma_fence_chain_init(struct dma_fence_chain *chain,
 125                           struct dma_fence *prev,
 126                           struct dma_fence *fence,
 127                           uint64_t seqno);
 128
 129 #endif /* __LINUX_DMA_FENCE_CHAIN_H */