LXR linux/drivers/dma/virt-dma.h

   1/*
   2 * Virtual DMA channel support for DMAengine
   3 *
   4 * Copyright (C) 2012 Russell King
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 as
   8 * published by the Free Software Foundation.
   9 */
  10#ifndef VIRT_DMA_H
  11#define VIRT_DMA_H
  12
  13#include <linux/dmaengine.h>
  14#include <linux/interrupt.h>
  15
  16#include "dmaengine.h"
  17
  18struct virt_dma_desc {
  19        struct dma_async_tx_descriptor tx;
  20        /* protected by vc.lock */
  21        struct list_head node;
  22};
  23
  24struct virt_dma_chan {
  25        struct dma_chan chan;
  26        struct tasklet_struct task;
  27        void (*desc_free)(struct virt_dma_desc *);
  28
  29        spinlock_t lock;
  30
  31        /* protected by vc.lock */
  32        struct list_head desc_allocated;
  33        struct list_head desc_submitted;
  34        struct list_head desc_issued;
  35        struct list_head desc_completed;
  36
  37        struct virt_dma_desc *cyclic;
  38        struct virt_dma_desc *vd_terminated;
  39};
  40
  41static inline struct virt_dma_chan *to_virt_chan(struct dma_chan *chan)
  42{
  43        return container_of(chan, struct virt_dma_chan, chan);
  44}
  45
  46void vchan_dma_desc_free_list(struct virt_dma_chan *vc, struct list_head *head);
  47void vchan_init(struct virt_dma_chan *vc, struct dma_device *dmadev);
  48struct virt_dma_desc *vchan_find_desc(struct virt_dma_chan *, dma_cookie_t);
  49extern dma_cookie_t vchan_tx_submit(struct dma_async_tx_descriptor *);
  50extern int vchan_tx_desc_free(struct dma_async_tx_descriptor *);
  51
  52/**
  53 * vchan_tx_prep - prepare a descriptor
  54 * @vc: virtual channel allocating this descriptor
  55 * @vd: virtual descriptor to prepare
  56 * @tx_flags: flags argument passed in to prepare function
  57 */
  58static inline struct dma_async_tx_descriptor *vchan_tx_prep(struct virt_dma_chan *vc,
  59        struct virt_dma_desc *vd, unsigned long tx_flags)
  60{
  61        unsigned long flags;
  62
  63        dma_async_tx_descriptor_init(&vd->tx, &vc->chan);
  64        vd->tx.flags = tx_flags;
  65        vd->tx.tx_submit = vchan_tx_submit;
  66        vd->tx.desc_free = vchan_tx_desc_free;
  67
  68        spin_lock_irqsave(&vc->lock, flags);
  69        list_add_tail(&vd->node, &vc->desc_allocated);
  70        spin_unlock_irqrestore(&vc->lock, flags);
  71
  72        return &vd->tx;
  73}
  74
  75/**
  76 * vchan_issue_pending - move submitted descriptors to issued list
  77 * @vc: virtual channel to update
  78 *
  79 * vc.lock must be held by caller
  80 */
  81static inline bool vchan_issue_pending(struct virt_dma_chan *vc)
  82{
  83        list_splice_tail_init(&vc->desc_submitted, &vc->desc_issued);
  84        return !list_empty(&vc->desc_issued);
  85}
  86
  87/**
  88 * vchan_cookie_complete - report completion of a descriptor
  89 * @vd: virtual descriptor to update
  90 *
  91 * vc.lock must be held by caller
  92 */
  93static inline void vchan_cookie_complete(struct virt_dma_desc *vd)
  94{
  95        struct virt_dma_chan *vc = to_virt_chan(vd->tx.chan);
  96        dma_cookie_t cookie;
  97
  98        cookie = vd->tx.cookie;
  99        dma_cookie_complete(&vd->tx);
 100        dev_vdbg(vc->chan.device->dev, "txd %p[%x]: marked complete\n",
 101                 vd, cookie);
 102        list_add_tail(&vd->node, &vc->desc_completed);
 103
 104        tasklet_schedule(&vc->task);
 105}
 106
 107/**
 108 * vchan_vdesc_fini - Free or reuse a descriptor
 109 * @vd: virtual descriptor to free/reuse
 110 */
 111static inline void vchan_vdesc_fini(struct virt_dma_desc *vd)
 112{
 113        struct virt_dma_chan *vc = to_virt_chan(vd->tx.chan);
 114
 115        if (dmaengine_desc_test_reuse(&vd->tx))
 116                list_add(&vd->node, &vc->desc_allocated);
 117        else
 118                vc->desc_free(vd);
 119}
 120
 121/**
 122 * vchan_cyclic_callback - report the completion of a period
 123 * @vd: virtual descriptor
 124 */
 125static inline void vchan_cyclic_callback(struct virt_dma_desc *vd)
 126{
 127        struct virt_dma_chan *vc = to_virt_chan(vd->tx.chan);
 128
 129        vc->cyclic = vd;
 130        tasklet_schedule(&vc->task);
 131}
 132
 133/**
 134 * vchan_terminate_vdesc - Disable pending cyclic callback
 135 * @vd: virtual descriptor to be terminated
 136 *
 137 * vc.lock must be held by caller
 138 */
 139static inline void vchan_terminate_vdesc(struct virt_dma_desc *vd)
 140{
 141        struct virt_dma_chan *vc = to_virt_chan(vd->tx.chan);
 142
 143        /* free up stuck descriptor */
 144        if (vc->vd_terminated)
 145                vchan_vdesc_fini(vc->vd_terminated);
 146
 147        vc->vd_terminated = vd;
 148        if (vc->cyclic == vd)
 149                vc->cyclic = NULL;
 150}
 151
 152/**
 153 * vchan_next_desc - peek at the next descriptor to be processed
 154 * @vc: virtual channel to obtain descriptor from
 155 *
 156 * vc.lock must be held by caller
 157 */
 158static inline struct virt_dma_desc *vchan_next_desc(struct virt_dma_chan *vc)
 159{
 160        return list_first_entry_or_null(&vc->desc_issued,
 161                                        struct virt_dma_desc, node);
 162}
 163
 164/**
 165 * vchan_get_all_descriptors - obtain all submitted and issued descriptors
 166 * @vc: virtual channel to get descriptors from
 167 * @head: list of descriptors found
 168 *
 169 * vc.lock must be held by caller
 170 *
 171 * Removes all submitted and issued descriptors from internal lists, and
 172 * provides a list of all descriptors found
 173 */
 174static inline void vchan_get_all_descriptors(struct virt_dma_chan *vc,
 175        struct list_head *head)
 176{
 177        list_splice_tail_init(&vc->desc_allocated, head);
 178        list_splice_tail_init(&vc->desc_submitted, head);
 179        list_splice_tail_init(&vc->desc_issued, head);
 180        list_splice_tail_init(&vc->desc_completed, head);
 181}
 182
 183static inline void vchan_free_chan_resources(struct virt_dma_chan *vc)
 184{
 185        struct virt_dma_desc *vd;
 186        unsigned long flags;
 187        LIST_HEAD(head);
 188
 189        spin_lock_irqsave(&vc->lock, flags);
 190        vchan_get_all_descriptors(vc, &head);
 191        list_for_each_entry(vd, &head, node)
 192                dmaengine_desc_clear_reuse(&vd->tx);
 193        spin_unlock_irqrestore(&vc->lock, flags);
 194
 195        vchan_dma_desc_free_list(vc, &head);
 196}
 197
 198/**
 199 * vchan_synchronize() - synchronize callback execution to the current context
 200 * @vc: virtual channel to synchronize
 201 *
 202 * Makes sure that all scheduled or active callbacks have finished running. For
 203 * proper operation the caller has to ensure that no new callbacks are scheduled
 204 * after the invocation of this function started.
 205 * Free up the terminated cyclic descriptor to prevent memory leakage.
 206 */
 207static inline void vchan_synchronize(struct virt_dma_chan *vc)
 208{
 209        unsigned long flags;
 210
 211        tasklet_kill(&vc->task);
 212
 213        spin_lock_irqsave(&vc->lock, flags);
 214        if (vc->vd_terminated) {
 215                vchan_vdesc_fini(vc->vd_terminated);
 216                vc->vd_terminated = NULL;
 217        }
 218        spin_unlock_irqrestore(&vc->lock, flags);
 219}
 220
 221#endif
 222