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"); 148