ARM: Build fix after Tegra14 K3.4 merge
[linux-3.10.git] / 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         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