1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * The contents of this file are private to DMA engine drivers, and is not 4 * part of the API to be used by DMA engine users. 5 */ 6 #ifndef DMAENGINE_H 7 #define DMAENGINE_H 8 9 #include <linux/bug.h> 10 #include <linux/dmaengine.h> 11 12 /** 13 * dma_cookie_init - initialize the cookies for a DMA channel 14 * @chan: dma channel to initialize 15 */ 16 static inline void dma_cookie_init(struct dma_chan *chan) 17 { 18 chan->cookie = DMA_MIN_COOKIE; 19 chan->completed_cookie = DMA_MIN_COOKIE; 20 } 21 22 /** 23 * dma_cookie_assign - assign a DMA engine cookie to the descriptor 24 * @tx: descriptor needing cookie 25 * 26 * Assign a unique non-zero per-channel cookie to the descriptor. 27 * Note: caller is expected to hold a lock to prevent concurrency. 28 */ 29 static inline dma_cookie_t dma_cookie_assign(struct dma_async_tx_descriptor *tx) 30 { 31 struct dma_chan *chan = tx->chan; 32 dma_cookie_t cookie; 33 34 cookie = chan->cookie + 1; 35 if (cookie < DMA_MIN_COOKIE) 36 cookie = DMA_MIN_COOKIE; 37 tx->cookie = chan->cookie = cookie; 38 39 return cookie; 40 } 41 42 /** 43 * dma_cookie_complete - complete a descriptor 44 * @tx: descriptor to complete 45 * 46 * Mark this descriptor complete by updating the channels completed 47 * cookie marker. Zero the descriptors cookie to prevent accidental 48 * repeated completions. 49 * 50 * Note: caller is expected to hold a lock to prevent concurrency. 51 */ 52 static inline void dma_cookie_complete(struct dma_async_tx_descriptor *tx) 53 { 54 BUG_ON(tx->cookie < DMA_MIN_COOKIE); 55 tx->chan->completed_cookie = tx->cookie; 56 tx->cookie = 0; 57 } 58 59 /** 60 * dma_cookie_status - report cookie status 61 * @chan: dma channel 62 * @cookie: cookie we are interested in 63 * @state: dma_tx_state structure to return last/used cookies 64 * 65 * Report the status of the cookie, filling in the state structure if 66 * non-NULL. No locking is required. 67 */ 68 static inline enum dma_status dma_cookie_status(struct dma_chan *chan, 69 dma_cookie_t cookie, struct dma_tx_state *state) 70 { 71 dma_cookie_t used, complete; 72 73 used = chan->cookie; 74 complete = chan->completed_cookie; 75 barrier(); 76 if (state) { 77 state->last = complete; 78 state->used = used; 79 state->residue = 0; 80 state->in_flight_bytes = 0; 81 } 82 return dma_async_is_complete(cookie, complete, used); 83 } 84 85 static inline void dma_set_residue(struct dma_tx_state *state, u32 residue) 86 { 87 if (state) 88 state->residue = residue; 89 } 90 91 static inline void dma_set_in_flight_bytes(struct dma_tx_state *state, 92 u32 in_flight_bytes) 93 { 94 if (state) 95 state->in_flight_bytes = in_flight_bytes; 96 } 97 98 struct dmaengine_desc_callback { 99 dma_async_tx_callback callback; 100 dma_async_tx_callback_result callback_result; 101 void *callback_param; 102 }; 103 104 /** 105 * dmaengine_desc_get_callback - get the passed in callback function 106 * @tx: tx descriptor 107 * @cb: temp struct to hold the callback info 108 * 109 * Fill the passed in cb struct with what's available in the passed in 110 * tx descriptor struct 111 * No locking is required. 112 */ 113 static inline void 114 dmaengine_desc_get_callback(struct dma_async_tx_descriptor *tx, 115 struct dmaengine_desc_callback *cb) 116 { 117 cb->callback = tx->callback; 118 cb->callback_result = tx->callback_result; 119 cb->callback_param = tx->callback_param; 120 } 121 122 /** 123 * dmaengine_desc_callback_invoke - call the callback function in cb struct 124 * @cb: temp struct that is holding the callback info 125 * @result: transaction result 126 * 127 * Call the callback function provided in the cb struct with the parameter 128 * in the cb struct. 129 * Locking is dependent on the driver. 130 */ 131 static inline void 132 dmaengine_desc_callback_invoke(struct dmaengine_desc_callback *cb, 133 const struct dmaengine_result *result) 134 { 135 struct dmaengine_result dummy_result = { 136 .result = DMA_TRANS_NOERROR, 137 .residue = 0 138 }; 139 140 if (cb->callback_result) { 141 if (!result) 142 result = &dummy_result; 143 cb->callback_result(cb->callback_param, result); 144 } else if (cb->callback) { 145 cb->callback(cb->callback_param); 146 } 147 } 148 149 /** 150 * dmaengine_desc_get_callback_invoke - get the callback in tx descriptor and 151 * then immediately call the callback. 152 * @tx: dma async tx descriptor 153 * @result: transaction result 154 * 155 * Call dmaengine_desc_get_callback() and dmaengine_desc_callback_invoke() 156 * in a single function since no work is necessary in between for the driver. 157 * Locking is dependent on the driver. 158 */ 159 static inline void 160 dmaengine_desc_get_callback_invoke(struct dma_async_tx_descriptor *tx, 161 const struct dmaengine_result *result) 162 { 163 struct dmaengine_desc_callback cb; 164 165 dmaengine_desc_get_callback(tx, &cb); 166 dmaengine_desc_callback_invoke(&cb, result); 167 } 168 169 /** 170 * dmaengine_desc_callback_valid - verify the callback is valid in cb 171 * @cb: callback info struct 172 * 173 * Return a bool that verifies whether callback in cb is valid or not. 174 * No locking is required. 175 */ 176 static inline bool 177 dmaengine_desc_callback_valid(struct dmaengine_desc_callback *cb) 178 { 179 return cb->callback || cb->callback_result; 180 } 181 182 struct dma_chan *dma_get_slave_channel(struct dma_chan *chan); 183 struct dma_chan *dma_get_any_slave_channel(struct dma_device *device); 184 185 #ifdef CONFIG_DEBUG_FS 186 #include <linux/debugfs.h> 187 188 static inline struct dentry * 189 dmaengine_get_debugfs_root(struct dma_device *dma_dev) { 190 return dma_dev->dbg_dev_root; 191 } 192 #else 193 struct dentry; 194 static inline struct dentry * 195 dmaengine_get_debugfs_root(struct dma_device *dma_dev) 196 { 197 return NULL; 198 } 199 #endif /* CONFIG_DEBUG_FS */ 200 201 #endif 202