arch/arm/kernel/dma.c

   1 /*
   2  *  linux/arch/arm/kernel/dma.c
   3  *
   4  *  Copyright (C) 1995-2000 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  *  Front-end to the DMA handling.  This handles the allocation/freeing
  11  *  of DMA channels, and provides a unified interface to the machines
  12  *  DMA facilities.
  13  */
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/errno.h>
  18 #include <linux/scatterlist.h>
  19
  20 #include <asm/dma.h>
  21
  22 #include <asm/mach/dma.h>
  23
  24 DEFINE_SPINLOCK(dma_spin_lock);
  25 EXPORT_SYMBOL(dma_spin_lock);
  26
  27 static dma_t *dma_chan[MAX_DMA_CHANNELS];
  28
  29 static inline dma_t *dma_channel(unsigned int chan)
  30 {
  31         if (chan >= MAX_DMA_CHANNELS)
  32                 return NULL;
  33
  34         return dma_chan[chan];
  35 }
  36
  37 int __init isa_dma_add(unsigned int chan, dma_t *dma)
  38 {
  39         if (!dma->d_ops)
  40                 return -EINVAL;
  41
  42         sg_init_table(&dma->buf, 1);
  43
  44         if (dma_chan[chan])
  45                 return -EBUSY;
  46         dma_chan[chan] = dma;
  47         return 0;
  48 }
  49
  50 /*
  51  * Request DMA channel
  52  *
  53  * On certain platforms, we have to allocate an interrupt as well...
  54  */
  55 int request_dma(unsigned int chan, const char *device_id)
  56 {
  57         dma_t *dma = dma_channel(chan);
  58         int ret;
  59
  60         if (!dma)
  61                 goto bad_dma;
  62
  63         if (xchg(&dma->lock, 1) != 0)
  64                 goto busy;
  65
  66         dma->device_id = device_id;
  67         dma->active    = 0;
  68         dma->invalid   = 1;
  69
  70         ret = 0;
  71         if (dma->d_ops->request)
  72                 ret = dma->d_ops->request(chan, dma);
  73
  74         if (ret)
  75                 xchg(&dma->lock, 0);
  76
  77         return ret;
  78
  79 bad_dma:
  80         printk(KERN_ERR "dma: trying to allocate DMA%d\n", chan);
  81         return -EINVAL;
  82
  83 busy:
  84         return -EBUSY;
  85 }
  86 EXPORT_SYMBOL(request_dma);
  87
  88 /*
  89  * Free DMA channel
  90  *
  91  * On certain platforms, we have to free interrupt as well...
  92  */
  93 void free_dma(unsigned int chan)
  94 {
  95         dma_t *dma = dma_channel(chan);
  96
  97         if (!dma)
  98                 goto bad_dma;
  99
 100         if (dma->active) {
 101                 printk(KERN_ERR "dma%d: freeing active DMA\n", chan);
 102                 dma->d_ops->disable(chan, dma);
 103                 dma->active = 0;
 104         }
 105
 106         if (xchg(&dma->lock, 0) != 0) {
 107                 if (dma->d_ops->free)
 108                         dma->d_ops->free(chan, dma);
 109                 return;
 110         }
 111
 112         printk(KERN_ERR "dma%d: trying to free free DMA\n", chan);
 113         return;
 114
 115 bad_dma:
 116         printk(KERN_ERR "dma: trying to free DMA%d\n", chan);
 117 }
 118 EXPORT_SYMBOL(free_dma);
 119
 120 /* Set DMA Scatter-Gather list
 121  */
 122 void set_dma_sg (unsigned int chan, struct scatterlist *sg, int nr_sg)
 123 {
 124         dma_t *dma = dma_channel(chan);
 125
 126         if (dma->active)
 127                 printk(KERN_ERR "dma%d: altering DMA SG while "
 128                        "DMA active\n", chan);
 129
 130         dma->sg = sg;
 131         dma->sgcount = nr_sg;
 132         dma->invalid = 1;
 133 }
 134 EXPORT_SYMBOL(set_dma_sg);
 135
 136 /* Set DMA address
 137  *
 138  * Copy address to the structure, and set the invalid bit
 139  */
 140 void __set_dma_addr (unsigned int chan, void *addr)
 141 {
 142         dma_t *dma = dma_channel(chan);
 143
 144         if (dma->active)
 145                 printk(KERN_ERR "dma%d: altering DMA address while "
 146                        "DMA active\n", chan);
 147
 148         dma->sg = NULL;
 149         dma->addr = addr;
 150         dma->invalid = 1;
 151 }
 152 EXPORT_SYMBOL(__set_dma_addr);
 153
 154 /* Set DMA byte count
 155  *
 156  * Copy address to the structure, and set the invalid bit
 157  */
 158 void set_dma_count (unsigned int chan, unsigned long count)
 159 {
 160         dma_t *dma = dma_channel(chan);
 161
 162         if (dma->active)
 163                 printk(KERN_ERR "dma%d: altering DMA count while "
 164                        "DMA active\n", chan);
 165
 166         dma->sg = NULL;
 167         dma->count = count;
 168         dma->invalid = 1;
 169 }
 170 EXPORT_SYMBOL(set_dma_count);
 171
 172 /* Set DMA direction mode
 173  */
 174 void set_dma_mode (unsigned int chan, unsigned int mode)
 175 {
 176         dma_t *dma = dma_channel(chan);
 177
 178         if (dma->active)
 179                 printk(KERN_ERR "dma%d: altering DMA mode while "
 180                        "DMA active\n", chan);
 181
 182         dma->dma_mode = mode;
 183         dma->invalid = 1;
 184 }
 185 EXPORT_SYMBOL(set_dma_mode);
 186
 187 /* Enable DMA channel
 188  */
 189 void enable_dma (unsigned int chan)
 190 {
 191         dma_t *dma = dma_channel(chan);
 192
 193         if (!dma->lock)
 194                 goto free_dma;
 195
 196         if (dma->active == 0) {
 197                 dma->active = 1;
 198                 dma->d_ops->enable(chan, dma);
 199         }
 200         return;
 201
 202 free_dma:
 203         printk(KERN_ERR "dma%d: trying to enable free DMA\n", chan);
 204         BUG();
 205 }
 206 EXPORT_SYMBOL(enable_dma);
 207
 208 /* Disable DMA channel
 209  */
 210 void disable_dma (unsigned int chan)
 211 {
 212         dma_t *dma = dma_channel(chan);
 213
 214         if (!dma->lock)
 215                 goto free_dma;
 216
 217         if (dma->active == 1) {
 218                 dma->active = 0;
 219                 dma->d_ops->disable(chan, dma);
 220         }
 221         return;
 222
 223 free_dma:
 224         printk(KERN_ERR "dma%d: trying to disable free DMA\n", chan);
 225         BUG();
 226 }
 227 EXPORT_SYMBOL(disable_dma);
 228
 229 /*
 230  * Is the specified DMA channel active?
 231  */
 232 int dma_channel_active(unsigned int chan)
 233 {
 234         dma_t *dma = dma_channel(chan);
 235         return dma->active;
 236 }
 237 EXPORT_SYMBOL(dma_channel_active);
 238
 239 void set_dma_page(unsigned int chan, char pagenr)
 240 {
 241         printk(KERN_ERR "dma%d: trying to set_dma_page\n", chan);
 242 }
 243 EXPORT_SYMBOL(set_dma_page);
 244
 245 void set_dma_speed(unsigned int chan, int cycle_ns)
 246 {
 247         dma_t *dma = dma_channel(chan);
 248         int ret = 0;
 249
 250         if (dma->d_ops->setspeed)
 251                 ret = dma->d_ops->setspeed(chan, dma, cycle_ns);
 252         dma->speed = ret;
 253 }
 254 EXPORT_SYMBOL(set_dma_speed);
 255
 256 int get_dma_residue(unsigned int chan)
 257 {
 258         dma_t *dma = dma_channel(chan);
 259         int ret = 0;
 260
 261         if (dma->d_ops->residue)
 262                 ret = dma->d_ops->residue(chan, dma);
 263
 264         return ret;
 265 }
 266 EXPORT_SYMBOL(get_dma_residue);