diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/arm/kernel/dma.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'arch/arm/kernel/dma.c')
-rw-r--r-- | arch/arm/kernel/dma.c | 302 |
1 files changed, 302 insertions, 0 deletions
diff --git a/arch/arm/kernel/dma.c b/arch/arm/kernel/dma.c new file mode 100644 index 000000000000..2b7883884234 --- /dev/null +++ b/arch/arm/kernel/dma.c | |||
@@ -0,0 +1,302 @@ | |||
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/slab.h> | ||
16 | #include <linux/mman.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/spinlock.h> | ||
19 | #include <linux/errno.h> | ||
20 | |||
21 | #include <asm/dma.h> | ||
22 | |||
23 | #include <asm/mach/dma.h> | ||
24 | |||
25 | DEFINE_SPINLOCK(dma_spin_lock); | ||
26 | |||
27 | #if MAX_DMA_CHANNELS > 0 | ||
28 | |||
29 | static dma_t dma_chan[MAX_DMA_CHANNELS]; | ||
30 | |||
31 | /* | ||
32 | * Get dma list for /proc/dma | ||
33 | */ | ||
34 | int get_dma_list(char *buf) | ||
35 | { | ||
36 | dma_t *dma; | ||
37 | char *p = buf; | ||
38 | int i; | ||
39 | |||
40 | for (i = 0, dma = dma_chan; i < MAX_DMA_CHANNELS; i++, dma++) | ||
41 | if (dma->lock) | ||
42 | p += sprintf(p, "%2d: %14s %s\n", i, | ||
43 | dma->d_ops->type, dma->device_id); | ||
44 | |||
45 | return p - buf; | ||
46 | } | ||
47 | |||
48 | /* | ||
49 | * Request DMA channel | ||
50 | * | ||
51 | * On certain platforms, we have to allocate an interrupt as well... | ||
52 | */ | ||
53 | int request_dma(dmach_t channel, const char *device_id) | ||
54 | { | ||
55 | dma_t *dma = dma_chan + channel; | ||
56 | int ret; | ||
57 | |||
58 | if (channel >= MAX_DMA_CHANNELS || !dma->d_ops) | ||
59 | goto bad_dma; | ||
60 | |||
61 | if (xchg(&dma->lock, 1) != 0) | ||
62 | goto busy; | ||
63 | |||
64 | dma->device_id = device_id; | ||
65 | dma->active = 0; | ||
66 | dma->invalid = 1; | ||
67 | |||
68 | ret = 0; | ||
69 | if (dma->d_ops->request) | ||
70 | ret = dma->d_ops->request(channel, dma); | ||
71 | |||
72 | if (ret) | ||
73 | xchg(&dma->lock, 0); | ||
74 | |||
75 | return ret; | ||
76 | |||
77 | bad_dma: | ||
78 | printk(KERN_ERR "dma: trying to allocate DMA%d\n", channel); | ||
79 | return -EINVAL; | ||
80 | |||
81 | busy: | ||
82 | return -EBUSY; | ||
83 | } | ||
84 | |||
85 | /* | ||
86 | * Free DMA channel | ||
87 | * | ||
88 | * On certain platforms, we have to free interrupt as well... | ||
89 | */ | ||
90 | void free_dma(dmach_t channel) | ||
91 | { | ||
92 | dma_t *dma = dma_chan + channel; | ||
93 | |||
94 | if (channel >= MAX_DMA_CHANNELS || !dma->d_ops) | ||
95 | goto bad_dma; | ||
96 | |||
97 | if (dma->active) { | ||
98 | printk(KERN_ERR "dma%d: freeing active DMA\n", channel); | ||
99 | dma->d_ops->disable(channel, dma); | ||
100 | dma->active = 0; | ||
101 | } | ||
102 | |||
103 | if (xchg(&dma->lock, 0) != 0) { | ||
104 | if (dma->d_ops->free) | ||
105 | dma->d_ops->free(channel, dma); | ||
106 | return; | ||
107 | } | ||
108 | |||
109 | printk(KERN_ERR "dma%d: trying to free free DMA\n", channel); | ||
110 | return; | ||
111 | |||
112 | bad_dma: | ||
113 | printk(KERN_ERR "dma: trying to free DMA%d\n", channel); | ||
114 | } | ||
115 | |||
116 | /* Set DMA Scatter-Gather list | ||
117 | */ | ||
118 | void set_dma_sg (dmach_t channel, struct scatterlist *sg, int nr_sg) | ||
119 | { | ||
120 | dma_t *dma = dma_chan + channel; | ||
121 | |||
122 | if (dma->active) | ||
123 | printk(KERN_ERR "dma%d: altering DMA SG while " | ||
124 | "DMA active\n", channel); | ||
125 | |||
126 | dma->sg = sg; | ||
127 | dma->sgcount = nr_sg; | ||
128 | dma->using_sg = 1; | ||
129 | dma->invalid = 1; | ||
130 | } | ||
131 | |||
132 | /* Set DMA address | ||
133 | * | ||
134 | * Copy address to the structure, and set the invalid bit | ||
135 | */ | ||
136 | void set_dma_addr (dmach_t channel, unsigned long physaddr) | ||
137 | { | ||
138 | dma_t *dma = dma_chan + channel; | ||
139 | |||
140 | if (dma->active) | ||
141 | printk(KERN_ERR "dma%d: altering DMA address while " | ||
142 | "DMA active\n", channel); | ||
143 | |||
144 | dma->sg = &dma->buf; | ||
145 | dma->sgcount = 1; | ||
146 | dma->buf.__address = bus_to_virt(physaddr); | ||
147 | dma->using_sg = 0; | ||
148 | dma->invalid = 1; | ||
149 | } | ||
150 | |||
151 | /* Set DMA byte count | ||
152 | * | ||
153 | * Copy address to the structure, and set the invalid bit | ||
154 | */ | ||
155 | void set_dma_count (dmach_t channel, unsigned long count) | ||
156 | { | ||
157 | dma_t *dma = dma_chan + channel; | ||
158 | |||
159 | if (dma->active) | ||
160 | printk(KERN_ERR "dma%d: altering DMA count while " | ||
161 | "DMA active\n", channel); | ||
162 | |||
163 | dma->sg = &dma->buf; | ||
164 | dma->sgcount = 1; | ||
165 | dma->buf.length = count; | ||
166 | dma->using_sg = 0; | ||
167 | dma->invalid = 1; | ||
168 | } | ||
169 | |||
170 | /* Set DMA direction mode | ||
171 | */ | ||
172 | void set_dma_mode (dmach_t channel, dmamode_t mode) | ||
173 | { | ||
174 | dma_t *dma = dma_chan + channel; | ||
175 | |||
176 | if (dma->active) | ||
177 | printk(KERN_ERR "dma%d: altering DMA mode while " | ||
178 | "DMA active\n", channel); | ||
179 | |||
180 | dma->dma_mode = mode; | ||
181 | dma->invalid = 1; | ||
182 | } | ||
183 | |||
184 | /* Enable DMA channel | ||
185 | */ | ||
186 | void enable_dma (dmach_t channel) | ||
187 | { | ||
188 | dma_t *dma = dma_chan + channel; | ||
189 | |||
190 | if (!dma->lock) | ||
191 | goto free_dma; | ||
192 | |||
193 | if (dma->active == 0) { | ||
194 | dma->active = 1; | ||
195 | dma->d_ops->enable(channel, dma); | ||
196 | } | ||
197 | return; | ||
198 | |||
199 | free_dma: | ||
200 | printk(KERN_ERR "dma%d: trying to enable free DMA\n", channel); | ||
201 | BUG(); | ||
202 | } | ||
203 | |||
204 | /* Disable DMA channel | ||
205 | */ | ||
206 | void disable_dma (dmach_t channel) | ||
207 | { | ||
208 | dma_t *dma = dma_chan + channel; | ||
209 | |||
210 | if (!dma->lock) | ||
211 | goto free_dma; | ||
212 | |||
213 | if (dma->active == 1) { | ||
214 | dma->active = 0; | ||
215 | dma->d_ops->disable(channel, dma); | ||
216 | } | ||
217 | return; | ||
218 | |||
219 | free_dma: | ||
220 | printk(KERN_ERR "dma%d: trying to disable free DMA\n", channel); | ||
221 | BUG(); | ||
222 | } | ||
223 | |||
224 | /* | ||
225 | * Is the specified DMA channel active? | ||
226 | */ | ||
227 | int dma_channel_active(dmach_t channel) | ||
228 | { | ||
229 | return dma_chan[channel].active; | ||
230 | } | ||
231 | |||
232 | void set_dma_page(dmach_t channel, char pagenr) | ||
233 | { | ||
234 | printk(KERN_ERR "dma%d: trying to set_dma_page\n", channel); | ||
235 | } | ||
236 | |||
237 | void set_dma_speed(dmach_t channel, int cycle_ns) | ||
238 | { | ||
239 | dma_t *dma = dma_chan + channel; | ||
240 | int ret = 0; | ||
241 | |||
242 | if (dma->d_ops->setspeed) | ||
243 | ret = dma->d_ops->setspeed(channel, dma, cycle_ns); | ||
244 | dma->speed = ret; | ||
245 | } | ||
246 | |||
247 | int get_dma_residue(dmach_t channel) | ||
248 | { | ||
249 | dma_t *dma = dma_chan + channel; | ||
250 | int ret = 0; | ||
251 | |||
252 | if (dma->d_ops->residue) | ||
253 | ret = dma->d_ops->residue(channel, dma); | ||
254 | |||
255 | return ret; | ||
256 | } | ||
257 | |||
258 | void __init init_dma(void) | ||
259 | { | ||
260 | arch_dma_init(dma_chan); | ||
261 | } | ||
262 | |||
263 | #else | ||
264 | |||
265 | int request_dma(dmach_t channel, const char *device_id) | ||
266 | { | ||
267 | return -EINVAL; | ||
268 | } | ||
269 | |||
270 | int get_dma_residue(dmach_t channel) | ||
271 | { | ||
272 | return 0; | ||
273 | } | ||
274 | |||
275 | #define GLOBAL_ALIAS(_a,_b) asm (".set " #_a "," #_b "; .globl " #_a) | ||
276 | GLOBAL_ALIAS(disable_dma, get_dma_residue); | ||
277 | GLOBAL_ALIAS(enable_dma, get_dma_residue); | ||
278 | GLOBAL_ALIAS(free_dma, get_dma_residue); | ||
279 | GLOBAL_ALIAS(get_dma_list, get_dma_residue); | ||
280 | GLOBAL_ALIAS(set_dma_mode, get_dma_residue); | ||
281 | GLOBAL_ALIAS(set_dma_page, get_dma_residue); | ||
282 | GLOBAL_ALIAS(set_dma_count, get_dma_residue); | ||
283 | GLOBAL_ALIAS(set_dma_addr, get_dma_residue); | ||
284 | GLOBAL_ALIAS(set_dma_sg, get_dma_residue); | ||
285 | GLOBAL_ALIAS(set_dma_speed, get_dma_residue); | ||
286 | GLOBAL_ALIAS(init_dma, get_dma_residue); | ||
287 | |||
288 | #endif | ||
289 | |||
290 | EXPORT_SYMBOL(request_dma); | ||
291 | EXPORT_SYMBOL(free_dma); | ||
292 | EXPORT_SYMBOL(enable_dma); | ||
293 | EXPORT_SYMBOL(disable_dma); | ||
294 | EXPORT_SYMBOL(set_dma_addr); | ||
295 | EXPORT_SYMBOL(set_dma_count); | ||
296 | EXPORT_SYMBOL(set_dma_mode); | ||
297 | EXPORT_SYMBOL(set_dma_page); | ||
298 | EXPORT_SYMBOL(get_dma_residue); | ||
299 | EXPORT_SYMBOL(set_dma_sg); | ||
300 | EXPORT_SYMBOL(set_dma_speed); | ||
301 | |||
302 | EXPORT_SYMBOL(dma_spin_lock); | ||