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 #include <linux/seq_file.h>
  20 #include <linux/proc_fs.h>
  21
  22 #include <asm/dma.h>
  23
  24 #include <asm/mach/dma.h>
  25
  26 DEFINE_RAW_SPINLOCK(dma_spin_lock);
  27 EXPORT_SYMBOL(dma_spin_lock);
  28
  29 static dma_t *dma_chan[MAX_DMA_CHANNELS];
  30
  31 static inline dma_t *dma_channel(unsigned int chan)
  32 {
  33         if (chan >= MAX_DMA_CHANNELS)
  34                 return NULL;
  35
  36         return dma_chan[chan];
  37 }
  38
  39 int __init isa_dma_add(unsigned int chan, dma_t *dma)
  40 {
  41         if (!dma->d_ops)
  42                 return -EINVAL;
  43
  44         sg_init_table(&dma->buf, 1);
  45
  46         if (dma_chan[chan])
  47                 return -EBUSY;
  48         dma_chan[chan] = dma;
  49         return 0;
  50 }
  51
  52 /*
  53  * Request DMA channel
  54  *
  55  * On certain platforms, we have to allocate an interrupt as well...
  56  */
  57 int request_dma(unsigned int chan, const char *device_id)
  58 {
  59         dma_t *dma = dma_channel(chan);
  60         int ret;
  61
  62         if (!dma)
  63                 goto bad_dma;
  64
  65         if (xchg(&dma->lock, 1) != 0)
  66                 goto busy;
  67
  68         dma->device_id = device_id;
  69         dma->active    = 0;
  70         dma->invalid   = 1;
  71
  72         ret = 0;
  73         if (dma->d_ops->request)
  74                 ret = dma->d_ops->request(chan, dma);
  75
  76         if (ret)
  77                 xchg(&dma->lock, 0);
  78
  79         return ret;
  80
  81 bad_dma:
  82         pr_err("dma: trying to allocate DMA%d\n", chan);
  83         return -EINVAL;
  84
  85 busy:
  86         return -EBUSY;
  87 }
  88 EXPORT_SYMBOL(request_dma);
  89
  90 /*
  91  * Free DMA channel
  92  *
  93  * On certain platforms, we have to free interrupt as well...
  94  */
  95 void free_dma(unsigned int chan)
  96 {
  97         dma_t *dma = dma_channel(chan);
  98
  99         if (!dma)
 100                 goto bad_dma;
 101
 102         if (dma->active) {
 103                 pr_err("dma%d: freeing active DMA\n", chan);
 104                 dma->d_ops->disable(chan, dma);
 105                 dma->active = 0;
 106         }
 107
 108         if (xchg(&dma->lock, 0) != 0) {
 109                 if (dma->d_ops->free)
 110                         dma->d_ops->free(chan, dma);
 111                 return;
 112         }
 113
 114         pr_err("dma%d: trying to free free DMA\n", chan);
 115         return;
 116
 117 bad_dma:
 118         pr_err("dma: trying to free DMA%d\n", chan);
 119 }
 120 EXPORT_SYMBOL(free_dma);
 121
 122 /* Set DMA Scatter-Gather list
 123  */
 124 void set_dma_sg (unsigned int chan, struct scatterlist *sg, int nr_sg)
 125 {
 126         dma_t *dma = dma_channel(chan);
 127
 128         if (dma->active)
 129                 pr_err("dma%d: altering DMA SG while DMA active\n", chan);
 130
 131         dma->sg = sg;
 132         dma->sgcount = nr_sg;
 133         dma->invalid = 1;
 134 }
 135 EXPORT_SYMBOL(set_dma_sg);
 136
 137 /* Set DMA address
 138  *
 139  * Copy address to the structure, and set the invalid bit
 140  */
 141 void __set_dma_addr (unsigned int chan, void *addr)
 142 {
 143         dma_t *dma = dma_channel(chan);
 144
 145         if (dma->active)
 146                 pr_err("dma%d: altering DMA address while 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                 pr_err("dma%d: altering DMA count while DMA active\n", chan);
 164
 165         dma->sg = NULL;
 166         dma->count = count;
 167         dma->invalid = 1;
 168 }
 169 EXPORT_SYMBOL(set_dma_count);
 170
 171 /* Set DMA direction mode
 172  */
 173 void set_dma_mode (unsigned int chan, unsigned int mode)
 174 {
 175         dma_t *dma = dma_channel(chan);
 176
 177         if (dma->active)
 178                 pr_err("dma%d: altering DMA mode while DMA active\n", chan);
 179
 180         dma->dma_mode = mode;
 181         dma->invalid = 1;
 182 }
 183 EXPORT_SYMBOL(set_dma_mode);
 184
 185 /* Enable DMA channel
 186  */
 187 void enable_dma (unsigned int chan)
 188 {
 189         dma_t *dma = dma_channel(chan);
 190
 191         if (!dma->lock)
 192                 goto free_dma;
 193
 194         if (dma->active == 0) {
 195                 dma->active = 1;
 196                 dma->d_ops->enable(chan, dma);
 197         }
 198         return;
 199
 200 free_dma:
 201         pr_err("dma%d: trying to enable free DMA\n", chan);
 202         BUG();
 203 }
 204 EXPORT_SYMBOL(enable_dma);
 205
 206 /* Disable DMA channel
 207  */
 208 void disable_dma (unsigned int chan)
 209 {
 210         dma_t *dma = dma_channel(chan);
 211
 212         if (!dma->lock)
 213                 goto free_dma;
 214
 215         if (dma->active == 1) {
 216                 dma->active = 0;
 217                 dma->d_ops->disable(chan, dma);
 218         }
 219         return;
 220
 221 free_dma:
 222         pr_err("dma%d: trying to disable free DMA\n", chan);
 223         BUG();
 224 }
 225 EXPORT_SYMBOL(disable_dma);
 226
 227 /*
 228  * Is the specified DMA channel active?
 229  */
 230 int dma_channel_active(unsigned int chan)
 231 {
 232         dma_t *dma = dma_channel(chan);
 233         return dma->active;
 234 }
 235 EXPORT_SYMBOL(dma_channel_active);
 236
 237 void set_dma_page(unsigned int chan, char pagenr)
 238 {
 239         pr_err("dma%d: trying to set_dma_page\n", chan);
 240 }
 241 EXPORT_SYMBOL(set_dma_page);
 242
 243 void set_dma_speed(unsigned int chan, int cycle_ns)
 244 {
 245         dma_t *dma = dma_channel(chan);
 246         int ret = 0;
 247
 248         if (dma->d_ops->setspeed)
 249                 ret = dma->d_ops->setspeed(chan, dma, cycle_ns);
 250         dma->speed = ret;
 251 }
 252 EXPORT_SYMBOL(set_dma_speed);
 253
 254 int get_dma_residue(unsigned int chan)
 255 {
 256         dma_t *dma = dma_channel(chan);
 257         int ret = 0;
 258
 259         if (dma->d_ops->residue)
 260                 ret = dma->d_ops->residue(chan, dma);
 261
 262         return ret;
 263 }
 264 EXPORT_SYMBOL(get_dma_residue);
 265
 266 #ifdef CONFIG_PROC_FS
 267 static int proc_dma_show(struct seq_file *m, void *v)
 268 {
 269         int i;
 270
 271         for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) {
 272                 dma_t *dma = dma_channel(i);
 273                 if (dma && dma->lock)
 274                         seq_printf(m, "%2d: %s\n", i, dma->device_id);
 275         }
 276         return 0;
 277 }
 278
 279 static int proc_dma_open(struct inode *inode, struct file *file)
 280 {
 281         return single_open(file, proc_dma_show, NULL);
 282 }
 283
 284 static const struct file_operations proc_dma_operations = {
 285         .open           = proc_dma_open,
 286         .read           = seq_read,
 287         .llseek         = seq_lseek,
 288         .release        = single_release,
 289 };
 290
 291 static int __init proc_dma_init(void)
 292 {
 293         proc_create("dma", 0, NULL, &proc_dma_operations);
 294         return 0;
 295 }
 296
 297 __initcall(proc_dma_init);
 298 #endif