Branch data     Line data    Source code

       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                 :          0 : static inline void dma_cookie_init(struct dma_chan *chan)
      17                 :            : {
      18                 :          0 :         chan->cookie = DMA_MIN_COOKIE;
      19   [ #  #  #  # ]:          0 :         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                 :          0 : static inline dma_cookie_t dma_cookie_assign(struct dma_async_tx_descriptor *tx)
      30                 :            : {
      31                 :          0 :         struct dma_chan *chan = tx->chan;
      32                 :          0 :         dma_cookie_t cookie;
      33                 :            : 
      34                 :          0 :         cookie = chan->cookie + 1;
      35                 :          0 :         if (cookie < DMA_MIN_COOKIE)
      36                 :            :                 cookie = DMA_MIN_COOKIE;
      37                 :          0 :         tx->cookie = chan->cookie = cookie;
      38                 :            : 
      39                 :          0 :         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                 :          0 : static inline void dma_cookie_complete(struct dma_async_tx_descriptor *tx)
      53                 :            : {
      54         [ #  # ]:          0 :         BUG_ON(tx->cookie < DMA_MIN_COOKIE);
      55                 :          0 :         tx->chan->completed_cookie = tx->cookie;
      56         [ #  # ]:          0 :         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                 :          0 : static inline enum dma_status dma_cookie_status(struct dma_chan *chan,
      69                 :            :         dma_cookie_t cookie, struct dma_tx_state *state)
      70                 :            : {
      71                 :          0 :         dma_cookie_t used, complete;
      72                 :            : 
      73                 :          0 :         used = chan->cookie;
      74                 :          0 :         complete = chan->completed_cookie;
      75                 :          0 :         barrier();
      76   [ #  #  #  # ]:          0 :         if (state) {
      77                 :          0 :                 state->last = complete;
      78                 :          0 :                 state->used = used;
      79                 :          0 :                 state->residue = 0;
      80                 :          0 :                 state->in_flight_bytes = 0;
      81                 :            :         }
      82   [ #  #  #  # ]:          0 :         return dma_async_is_complete(cookie, complete, used);
      83                 :            : }
      84                 :            : 
      85                 :          0 : static inline void dma_set_residue(struct dma_tx_state *state, u32 residue)
      86                 :            : {
      87   [ #  #  #  # ]:          0 :         if (state)
      88                 :          0 :                 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                 :          0 : dmaengine_desc_get_callback(struct dma_async_tx_descriptor *tx,
     115                 :            :                             struct dmaengine_desc_callback *cb)
     116                 :            : {
     117                 :          0 :         cb->callback = tx->callback;
     118                 :          0 :         cb->callback_result = tx->callback_result;
     119                 :          0 :         cb->callback_param = tx->callback_param;
     120                 :          0 : }
     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                 :          0 : dmaengine_desc_callback_invoke(struct dmaengine_desc_callback *cb,
     133                 :            :                                const struct dmaengine_result *result)
     134                 :            : {
     135                 :          0 :         struct dmaengine_result dummy_result = {
     136                 :            :                 .result = DMA_TRANS_NOERROR,
     137                 :            :                 .residue = 0
     138                 :            :         };
     139                 :            : 
     140         [ #  # ]:          0 :         if (cb->callback_result) {
     141         [ #  # ]:          0 :                 if (!result)
     142                 :          0 :                         result = &dummy_result;
     143                 :          0 :                 cb->callback_result(cb->callback_param, result);
     144         [ #  # ]:          0 :         } else if (cb->callback) {
     145                 :          0 :                 cb->callback(cb->callback_param);
     146                 :            :         }
     147                 :          0 : }
     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) ? true : false;
     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                 :            : #endif