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 printk(KERN_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 printk(KERN_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 printk(KERN_ERR "dma%d: trying to free free DMA\n", chan); 115 return; 116 117 bad_dma: 118 printk(KERN_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 printk(KERN_ERR "dma%d: altering DMA SG while " 130 "DMA active\n", chan); 131 132 dma->sg = sg; 133 dma->sgcount = nr_sg; 134 dma->invalid = 1; 135 } 136 EXPORT_SYMBOL(set_dma_sg); 137 138 /* Set DMA address 139 * 140 * Copy address to the structure, and set the invalid bit 141 */ 142 void __set_dma_addr (unsigned int chan, void *addr) 143 { 144 dma_t *dma = dma_channel(chan); 145 146 if (dma->active) 147 printk(KERN_ERR "dma%d: altering DMA address while " 148 "DMA active\n", chan); 149 150 dma->sg = NULL; 151 dma->addr = addr; 152 dma->invalid = 1; 153 } 154 EXPORT_SYMBOL(__set_dma_addr); 155 156 /* Set DMA byte count 157 * 158 * Copy address to the structure, and set the invalid bit 159 */ 160 void set_dma_count (unsigned int chan, unsigned long count) 161 { 162 dma_t *dma = dma_channel(chan); 163 164 if (dma->active) 165 printk(KERN_ERR "dma%d: altering DMA count while " 166 "DMA active\n", chan); 167 168 dma->sg = NULL; 169 dma->count = count; 170 dma->invalid = 1; 171 } 172 EXPORT_SYMBOL(set_dma_count); 173 174 /* Set DMA direction mode 175 */ 176 void set_dma_mode (unsigned int chan, unsigned int mode) 177 { 178 dma_t *dma = dma_channel(chan); 179 180 if (dma->active) 181 printk(KERN_ERR "dma%d: altering DMA mode while " 182 "DMA active\n", chan); 183 184 dma->dma_mode = mode; 185 dma->invalid = 1; 186 } 187 EXPORT_SYMBOL(set_dma_mode); 188 189 /* Enable DMA channel 190 */ 191 void enable_dma (unsigned int chan) 192 { 193 dma_t *dma = dma_channel(chan); 194 195 if (!dma->lock) 196 goto free_dma; 197 198 if (dma->active == 0) { 199 dma->active = 1; 200 dma->d_ops->enable(chan, dma); 201 } 202 return; 203 204 free_dma: 205 printk(KERN_ERR "dma%d: trying to enable free DMA\n", chan); 206 BUG(); 207 } 208 EXPORT_SYMBOL(enable_dma); 209 210 /* Disable DMA channel 211 */ 212 void disable_dma (unsigned int chan) 213 { 214 dma_t *dma = dma_channel(chan); 215 216 if (!dma->lock) 217 goto free_dma; 218 219 if (dma->active == 1) { 220 dma->active = 0; 221 dma->d_ops->disable(chan, dma); 222 } 223 return; 224 225 free_dma: 226 printk(KERN_ERR "dma%d: trying to disable free DMA\n", chan); 227 BUG(); 228 } 229 EXPORT_SYMBOL(disable_dma); 230 231 /* 232 * Is the specified DMA channel active? 233 */ 234 int dma_channel_active(unsigned int chan) 235 { 236 dma_t *dma = dma_channel(chan); 237 return dma->active; 238 } 239 EXPORT_SYMBOL(dma_channel_active); 240 241 void set_dma_page(unsigned int chan, char pagenr) 242 { 243 printk(KERN_ERR "dma%d: trying to set_dma_page\n", chan); 244 } 245 EXPORT_SYMBOL(set_dma_page); 246 247 void set_dma_speed(unsigned int chan, int cycle_ns) 248 { 249 dma_t *dma = dma_channel(chan); 250 int ret = 0; 251 252 if (dma->d_ops->setspeed) 253 ret = dma->d_ops->setspeed(chan, dma, cycle_ns); 254 dma->speed = ret; 255 } 256 EXPORT_SYMBOL(set_dma_speed); 257 258 int get_dma_residue(unsigned int chan) 259 { 260 dma_t *dma = dma_channel(chan); 261 int ret = 0; 262 263 if (dma->d_ops->residue) 264 ret = dma->d_ops->residue(chan, dma); 265 266 return ret; 267 } 268 EXPORT_SYMBOL(get_dma_residue); 269 270 #ifdef CONFIG_PROC_FS 271 static int proc_dma_show(struct seq_file *m, void *v) 272 { 273 int i; 274 275 for (i = 0 ; i < MAX_DMA_CHANNELS ; i++) { 276 dma_t *dma = dma_channel(i); 277 if (dma && dma->lock) 278 seq_printf(m, "%2d: %s\n", i, dma->device_id); 279 } 280 return 0; 281 } 282 283 static int proc_dma_open(struct inode *inode, struct file *file) 284 { 285 return single_open(file, proc_dma_show, NULL); 286 } 287 288 static const struct file_operations proc_dma_operations = { 289 .open = proc_dma_open, 290 .read = seq_read, 291 .llseek = seq_lseek, 292 .release = single_release, 293 }; 294 295 static int __init proc_dma_init(void) 296 { 297 proc_create("dma", 0, NULL, &proc_dma_operations); 298 return 0; 299 } 300 301 __initcall(proc_dma_init); 302 #endif 303