Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
1da177e4 LT |
15 | #include <linux/init.h> |
16 | #include <linux/spinlock.h> | |
17 | #include <linux/errno.h> | |
d667522f | 18 | #include <linux/scatterlist.h> |
1da177e4 LT |
19 | |
20 | #include <asm/dma.h> | |
21 | ||
22 | #include <asm/mach/dma.h> | |
23 | ||
24 | DEFINE_SPINLOCK(dma_spin_lock); | |
d7b4a756 | 25 | EXPORT_SYMBOL(dma_spin_lock); |
1da177e4 | 26 | |
2f757f2a | 27 | static dma_t *dma_chan[MAX_DMA_CHANNELS]; |
1da177e4 | 28 | |
3afb6e9c RK |
29 | static inline dma_t *dma_channel(unsigned int chan) |
30 | { | |
2f757f2a | 31 | if (chan >= MAX_DMA_CHANNELS) |
3afb6e9c RK |
32 | return NULL; |
33 | ||
2f757f2a RK |
34 | return dma_chan[chan]; |
35 | } | |
36 | ||
37 | int __init isa_dma_add(unsigned int chan, dma_t *dma) | |
38 | { | |
39 | if (!dma->d_ops) | |
40 | return -EINVAL; | |
d667522f RK |
41 | |
42 | sg_init_table(&dma->buf, 1); | |
43 | ||
2f757f2a RK |
44 | if (dma_chan[chan]) |
45 | return -EBUSY; | |
46 | dma_chan[chan] = dma; | |
47 | return 0; | |
3afb6e9c RK |
48 | } |
49 | ||
1da177e4 LT |
50 | /* |
51 | * Request DMA channel | |
52 | * | |
53 | * On certain platforms, we have to allocate an interrupt as well... | |
54 | */ | |
1df81302 | 55 | int request_dma(unsigned int chan, const char *device_id) |
1da177e4 | 56 | { |
3afb6e9c | 57 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
58 | int ret; |
59 | ||
3afb6e9c | 60 | if (!dma) |
1da177e4 LT |
61 | goto bad_dma; |
62 | ||
63 | if (xchg(&dma->lock, 1) != 0) | |
64 | goto busy; | |
65 | ||
66 | dma->device_id = device_id; | |
67 | dma->active = 0; | |
68 | dma->invalid = 1; | |
69 | ||
70 | ret = 0; | |
71 | if (dma->d_ops->request) | |
1df81302 | 72 | ret = dma->d_ops->request(chan, dma); |
1da177e4 LT |
73 | |
74 | if (ret) | |
75 | xchg(&dma->lock, 0); | |
76 | ||
77 | return ret; | |
78 | ||
79 | bad_dma: | |
1df81302 | 80 | printk(KERN_ERR "dma: trying to allocate DMA%d\n", chan); |
1da177e4 LT |
81 | return -EINVAL; |
82 | ||
83 | busy: | |
84 | return -EBUSY; | |
85 | } | |
d7b4a756 | 86 | EXPORT_SYMBOL(request_dma); |
1da177e4 LT |
87 | |
88 | /* | |
89 | * Free DMA channel | |
90 | * | |
91 | * On certain platforms, we have to free interrupt as well... | |
92 | */ | |
1df81302 | 93 | void free_dma(unsigned int chan) |
1da177e4 | 94 | { |
3afb6e9c | 95 | dma_t *dma = dma_channel(chan); |
1da177e4 | 96 | |
3afb6e9c | 97 | if (!dma) |
1da177e4 LT |
98 | goto bad_dma; |
99 | ||
100 | if (dma->active) { | |
1df81302 RK |
101 | printk(KERN_ERR "dma%d: freeing active DMA\n", chan); |
102 | dma->d_ops->disable(chan, dma); | |
1da177e4 LT |
103 | dma->active = 0; |
104 | } | |
105 | ||
106 | if (xchg(&dma->lock, 0) != 0) { | |
107 | if (dma->d_ops->free) | |
1df81302 | 108 | dma->d_ops->free(chan, dma); |
1da177e4 LT |
109 | return; |
110 | } | |
111 | ||
1df81302 | 112 | printk(KERN_ERR "dma%d: trying to free free DMA\n", chan); |
1da177e4 LT |
113 | return; |
114 | ||
115 | bad_dma: | |
1df81302 | 116 | printk(KERN_ERR "dma: trying to free DMA%d\n", chan); |
1da177e4 | 117 | } |
d7b4a756 | 118 | EXPORT_SYMBOL(free_dma); |
1da177e4 LT |
119 | |
120 | /* Set DMA Scatter-Gather list | |
121 | */ | |
1df81302 | 122 | void set_dma_sg (unsigned int chan, struct scatterlist *sg, int nr_sg) |
1da177e4 | 123 | { |
3afb6e9c | 124 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
125 | |
126 | if (dma->active) | |
127 | printk(KERN_ERR "dma%d: altering DMA SG while " | |
1df81302 | 128 | "DMA active\n", chan); |
1da177e4 LT |
129 | |
130 | dma->sg = sg; | |
131 | dma->sgcount = nr_sg; | |
1da177e4 LT |
132 | dma->invalid = 1; |
133 | } | |
d7b4a756 | 134 | EXPORT_SYMBOL(set_dma_sg); |
1da177e4 LT |
135 | |
136 | /* Set DMA address | |
137 | * | |
138 | * Copy address to the structure, and set the invalid bit | |
139 | */ | |
1df81302 | 140 | void __set_dma_addr (unsigned int chan, void *addr) |
1da177e4 | 141 | { |
3afb6e9c | 142 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
143 | |
144 | if (dma->active) | |
145 | printk(KERN_ERR "dma%d: altering DMA address while " | |
1df81302 | 146 | "DMA active\n", chan); |
1da177e4 | 147 | |
7cdad482 RK |
148 | dma->sg = NULL; |
149 | dma->addr = addr; | |
1da177e4 LT |
150 | dma->invalid = 1; |
151 | } | |
d7b4a756 | 152 | EXPORT_SYMBOL(__set_dma_addr); |
1da177e4 LT |
153 | |
154 | /* Set DMA byte count | |
155 | * | |
156 | * Copy address to the structure, and set the invalid bit | |
157 | */ | |
1df81302 | 158 | void set_dma_count (unsigned int chan, unsigned long count) |
1da177e4 | 159 | { |
3afb6e9c | 160 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
161 | |
162 | if (dma->active) | |
163 | printk(KERN_ERR "dma%d: altering DMA count while " | |
1df81302 | 164 | "DMA active\n", chan); |
1da177e4 | 165 | |
7cdad482 RK |
166 | dma->sg = NULL; |
167 | dma->count = count; | |
1da177e4 LT |
168 | dma->invalid = 1; |
169 | } | |
d7b4a756 | 170 | EXPORT_SYMBOL(set_dma_count); |
1da177e4 LT |
171 | |
172 | /* Set DMA direction mode | |
173 | */ | |
f0ffc816 | 174 | void set_dma_mode (unsigned int chan, unsigned int mode) |
1da177e4 | 175 | { |
3afb6e9c | 176 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
177 | |
178 | if (dma->active) | |
179 | printk(KERN_ERR "dma%d: altering DMA mode while " | |
1df81302 | 180 | "DMA active\n", chan); |
1da177e4 LT |
181 | |
182 | dma->dma_mode = mode; | |
183 | dma->invalid = 1; | |
184 | } | |
d7b4a756 | 185 | EXPORT_SYMBOL(set_dma_mode); |
1da177e4 LT |
186 | |
187 | /* Enable DMA channel | |
188 | */ | |
1df81302 | 189 | void enable_dma (unsigned int chan) |
1da177e4 | 190 | { |
3afb6e9c | 191 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
192 | |
193 | if (!dma->lock) | |
194 | goto free_dma; | |
195 | ||
196 | if (dma->active == 0) { | |
197 | dma->active = 1; | |
1df81302 | 198 | dma->d_ops->enable(chan, dma); |
1da177e4 LT |
199 | } |
200 | return; | |
201 | ||
202 | free_dma: | |
1df81302 | 203 | printk(KERN_ERR "dma%d: trying to enable free DMA\n", chan); |
1da177e4 LT |
204 | BUG(); |
205 | } | |
d7b4a756 | 206 | EXPORT_SYMBOL(enable_dma); |
1da177e4 LT |
207 | |
208 | /* Disable DMA channel | |
209 | */ | |
1df81302 | 210 | void disable_dma (unsigned int chan) |
1da177e4 | 211 | { |
3afb6e9c | 212 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
213 | |
214 | if (!dma->lock) | |
215 | goto free_dma; | |
216 | ||
217 | if (dma->active == 1) { | |
218 | dma->active = 0; | |
1df81302 | 219 | dma->d_ops->disable(chan, dma); |
1da177e4 LT |
220 | } |
221 | return; | |
222 | ||
223 | free_dma: | |
1df81302 | 224 | printk(KERN_ERR "dma%d: trying to disable free DMA\n", chan); |
1da177e4 LT |
225 | BUG(); |
226 | } | |
d7b4a756 | 227 | EXPORT_SYMBOL(disable_dma); |
1da177e4 LT |
228 | |
229 | /* | |
230 | * Is the specified DMA channel active? | |
231 | */ | |
1df81302 | 232 | int dma_channel_active(unsigned int chan) |
1da177e4 | 233 | { |
3afb6e9c RK |
234 | dma_t *dma = dma_channel(chan); |
235 | return dma->active; | |
1da177e4 | 236 | } |
ec14d796 | 237 | EXPORT_SYMBOL(dma_channel_active); |
1da177e4 | 238 | |
1df81302 | 239 | void set_dma_page(unsigned int chan, char pagenr) |
1da177e4 | 240 | { |
1df81302 | 241 | printk(KERN_ERR "dma%d: trying to set_dma_page\n", chan); |
1da177e4 | 242 | } |
d7b4a756 | 243 | EXPORT_SYMBOL(set_dma_page); |
1da177e4 | 244 | |
1df81302 | 245 | void set_dma_speed(unsigned int chan, int cycle_ns) |
1da177e4 | 246 | { |
3afb6e9c | 247 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
248 | int ret = 0; |
249 | ||
250 | if (dma->d_ops->setspeed) | |
1df81302 | 251 | ret = dma->d_ops->setspeed(chan, dma, cycle_ns); |
1da177e4 LT |
252 | dma->speed = ret; |
253 | } | |
d7b4a756 | 254 | EXPORT_SYMBOL(set_dma_speed); |
1da177e4 | 255 | |
1df81302 | 256 | int get_dma_residue(unsigned int chan) |
1da177e4 | 257 | { |
3afb6e9c | 258 | dma_t *dma = dma_channel(chan); |
1da177e4 LT |
259 | int ret = 0; |
260 | ||
261 | if (dma->d_ops->residue) | |
1df81302 | 262 | ret = dma->d_ops->residue(chan, dma); |
1da177e4 LT |
263 | |
264 | return ret; | |
265 | } | |
d7b4a756 | 266 | EXPORT_SYMBOL(get_dma_residue); |