arch/arm/kernel/dma.c

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