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