drivers/dma/virt-dma.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Virtual DMA channel support for DMAengine
   4  *
   5  * Copyright (C) 2012 Russell King
   6  */
   7 #include <linux/device.h>
   8 #include <linux/dmaengine.h>
   9 #include <linux/module.h>
  10 #include <linux/spinlock.h>
  11
  12 #include "virt-dma.h"
  13
  14 static struct virt_dma_desc *to_virt_desc(struct dma_async_tx_descriptor *tx)
  15 {
  16         return container_of(tx, struct virt_dma_desc, tx);
  17 }
  18
  19 dma_cookie_t vchan_tx_submit(struct dma_async_tx_descriptor *tx)
  20 {
  21         struct virt_dma_chan *vc = to_virt_chan(tx->chan);
  22         struct virt_dma_desc *vd = to_virt_desc(tx);
  23         unsigned long flags;
  24         dma_cookie_t cookie;
  25
  26         spin_lock_irqsave(&vc->lock, flags);
  27         cookie = dma_cookie_assign(tx);
  28
  29         list_move_tail(&vd->node, &vc->desc_submitted);
  30         spin_unlock_irqrestore(&vc->lock, flags);
  31
  32         dev_dbg(vc->chan.device->dev, "vchan %p: txd %p[%x]: submitted\n",
  33                 vc, vd, cookie);
  34
  35         return cookie;
  36 }
  37 EXPORT_SYMBOL_GPL(vchan_tx_submit);
  38
  39 /**
  40  * vchan_tx_desc_free - free a reusable descriptor
  41  * @tx: the transfer
  42  *
  43  * This function frees a previously allocated reusable descriptor. The only
  44  * other way is to clear the DMA_CTRL_REUSE flag and submit one last time the
  45  * transfer.
  46  *
  47  * Returns 0 upon success
  48  */
  49 int vchan_tx_desc_free(struct dma_async_tx_descriptor *tx)
  50 {
  51         struct virt_dma_chan *vc = to_virt_chan(tx->chan);
  52         struct virt_dma_desc *vd = to_virt_desc(tx);
  53         unsigned long flags;
  54
  55         spin_lock_irqsave(&vc->lock, flags);
  56         list_del(&vd->node);
  57         spin_unlock_irqrestore(&vc->lock, flags);
  58
  59         dev_dbg(vc->chan.device->dev, "vchan %p: txd %p[%x]: freeing\n",
  60                 vc, vd, vd->tx.cookie);
  61         vc->desc_free(vd);
  62         return 0;
  63 }
  64 EXPORT_SYMBOL_GPL(vchan_tx_desc_free);
  65
  66 struct virt_dma_desc *vchan_find_desc(struct virt_dma_chan *vc,
  67         dma_cookie_t cookie)
  68 {
  69         struct virt_dma_desc *vd;
  70
  71         list_for_each_entry(vd, &vc->desc_issued, node)
  72                 if (vd->tx.cookie == cookie)
  73                         return vd;
  74
  75         return NULL;
  76 }
  77 EXPORT_SYMBOL_GPL(vchan_find_desc);
  78
  79 /*
  80  * This tasklet handles the completion of a DMA descriptor by
  81  * calling its callback and freeing it.
  82  */
  83 static void vchan_complete(unsigned long arg)
  84 {
  85         struct virt_dma_chan *vc = (struct virt_dma_chan *)arg;
  86         struct virt_dma_desc *vd, *_vd;
  87         struct dmaengine_desc_callback cb;
  88         LIST_HEAD(head);
  89
  90         spin_lock_irq(&vc->lock);
  91         list_splice_tail_init(&vc->desc_completed, &head);
  92         vd = vc->cyclic;
  93         if (vd) {
  94                 vc->cyclic = NULL;
  95                 dmaengine_desc_get_callback(&vd->tx, &cb);
  96         } else {
  97                 memset(&cb, 0, sizeof(cb));
  98         }
  99         spin_unlock_irq(&vc->lock);
 100
 101         dmaengine_desc_callback_invoke(&cb, &vd->tx_result);
 102
 103         list_for_each_entry_safe(vd, _vd, &head, node) {
 104                 dmaengine_desc_get_callback(&vd->tx, &cb);
 105
 106                 list_del(&vd->node);
 107                 vchan_vdesc_fini(vd);
 108
 109                 dmaengine_desc_callback_invoke(&cb, &vd->tx_result);
 110         }
 111 }
 112
 113 void vchan_dma_desc_free_list(struct virt_dma_chan *vc, struct list_head *head)
 114 {
 115         struct virt_dma_desc *vd, *_vd;
 116
 117         list_for_each_entry_safe(vd, _vd, head, node) {
 118                 if (dmaengine_desc_test_reuse(&vd->tx)) {
 119                         list_move_tail(&vd->node, &vc->desc_allocated);
 120                 } else {
 121                         dev_dbg(vc->chan.device->dev, "txd %p: freeing\n", vd);
 122                         list_del(&vd->node);
 123                         vc->desc_free(vd);
 124                 }
 125         }
 126 }
 127 EXPORT_SYMBOL_GPL(vchan_dma_desc_free_list);
 128
 129 void vchan_init(struct virt_dma_chan *vc, struct dma_device *dmadev)
 130 {
 131         dma_cookie_init(&vc->chan);
 132
 133         spin_lock_init(&vc->lock);
 134         INIT_LIST_HEAD(&vc->desc_allocated);
 135         INIT_LIST_HEAD(&vc->desc_submitted);
 136         INIT_LIST_HEAD(&vc->desc_issued);
 137         INIT_LIST_HEAD(&vc->desc_completed);
 138
 139         tasklet_init(&vc->task, vchan_complete, (unsigned long)vc);
 140
 141         vc->chan.device = dmadev;
 142         list_add_tail(&vc->chan.device_node, &dmadev->channels);
 143 }
 144 EXPORT_SYMBOL_GPL(vchan_init);
 145
 146 MODULE_AUTHOR("Russell King");
 147 MODULE_LICENSE("GPL");