xref: /freebsd/sys/dev/proto/proto_busdma.c (revision 0957b409) 
1 /*-
2  * Copyright (c) 2015 Marcel Moolenaar
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25 
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
28 
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <machine/bus.h>
32 #include <machine/bus_dma.h>
33 #include <machine/resource.h>
34 #include <sys/bus.h>
35 #include <sys/conf.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/module.h>
39 #include <sys/proc.h>
40 #include <sys/queue.h>
41 #include <sys/rman.h>
42 #include <sys/sbuf.h>
43 #include <sys/uio.h>
44 #include <vm/vm.h>
45 #include <vm/pmap.h>
46 #include <vm/vm_map.h>
47 
48 #include <dev/proto/proto.h>
49 #include <dev/proto/proto_dev.h>
50 #include <dev/proto/proto_busdma.h>
51 
52 MALLOC_DEFINE(M_PROTO_BUSDMA, "proto_busdma", "DMA management data");
53 
54 #define	BNDRY_MIN(a, b)		\
55 	(((a) == 0) ? (b) : (((b) == 0) ? (a) : MIN((a), (b))))
56 
57 struct proto_callback_bundle {
58 	struct proto_busdma *busdma;
59 	struct proto_md *md;
60 	struct proto_ioc_busdma *ioc;
61 };
62 
63 static int
64 proto_busdma_tag_create(struct proto_busdma *busdma, struct proto_tag *parent,
65     struct proto_ioc_busdma *ioc)
66 {
67 	struct proto_tag *tag;
68 
69 	/* Make sure that when a boundary is specified, it's a power of 2 */
70 	if (ioc->u.tag.bndry != 0 &&
71 	    (ioc->u.tag.bndry & (ioc->u.tag.bndry - 1)) != 0)
72 		return (EINVAL);
73 
74 	/*
75 	 * If nsegs is 1, ignore maxsegsz. What this means is that if we have
76 	 * just 1 segment, then maxsz should be equal to maxsegsz. To keep it
77 	 * simple for us, limit maxsegsz to maxsz in any case.
78 	 */
79 	if (ioc->u.tag.maxsegsz > ioc->u.tag.maxsz || ioc->u.tag.nsegs == 1)
80 		ioc->u.tag.maxsegsz = ioc->u.tag.maxsz;
81 
82 	tag = malloc(sizeof(*tag), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
83 	if (parent != NULL) {
84 		tag->parent = parent;
85 		LIST_INSERT_HEAD(&parent->children, tag, peers);
86 		tag->align = MAX(ioc->u.tag.align, parent->align);
87 		tag->bndry = BNDRY_MIN(ioc->u.tag.bndry, parent->bndry);
88 		tag->maxaddr = MIN(ioc->u.tag.maxaddr, parent->maxaddr);
89 		tag->maxsz = MIN(ioc->u.tag.maxsz, parent->maxsz);
90 		tag->maxsegsz = MIN(ioc->u.tag.maxsegsz, parent->maxsegsz);
91 		tag->nsegs = MIN(ioc->u.tag.nsegs, parent->nsegs);
92 		tag->datarate = MIN(ioc->u.tag.datarate, parent->datarate);
93 		/* Write constraints back */
94 		ioc->u.tag.align = tag->align;
95 		ioc->u.tag.bndry = tag->bndry;
96 		ioc->u.tag.maxaddr = tag->maxaddr;
97 		ioc->u.tag.maxsz = tag->maxsz;
98 		ioc->u.tag.maxsegsz = tag->maxsegsz;
99 		ioc->u.tag.nsegs = tag->nsegs;
100 		ioc->u.tag.datarate = tag->datarate;
101 	} else {
102 		tag->align = ioc->u.tag.align;
103 		tag->bndry = ioc->u.tag.bndry;
104 		tag->maxaddr = ioc->u.tag.maxaddr;
105 		tag->maxsz = ioc->u.tag.maxsz;
106 		tag->maxsegsz = ioc->u.tag.maxsegsz;
107 		tag->nsegs = ioc->u.tag.nsegs;
108 		tag->datarate = ioc->u.tag.datarate;
109 	}
110 	LIST_INSERT_HEAD(&busdma->tags, tag, tags);
111 	ioc->result = (uintptr_t)(void *)tag;
112 	return (0);
113 }
114 
115 static int
116 proto_busdma_tag_destroy(struct proto_busdma *busdma, struct proto_tag *tag)
117 {
118 
119 	if (!LIST_EMPTY(&tag->mds))
120 		return (EBUSY);
121 	if (!LIST_EMPTY(&tag->children))
122 		return (EBUSY);
123 
124 	if (tag->parent != NULL) {
125 		LIST_REMOVE(tag, peers);
126 		tag->parent = NULL;
127 	}
128 	LIST_REMOVE(tag, tags);
129 	free(tag, M_PROTO_BUSDMA);
130 	return (0);
131 }
132 
133 static struct proto_tag *
134 proto_busdma_tag_lookup(struct proto_busdma *busdma, u_long key)
135 {
136 	struct proto_tag *tag;
137 
138 	LIST_FOREACH(tag, &busdma->tags, tags) {
139 		if ((void *)tag == (void *)key)
140 			return (tag);
141 	}
142 	return (NULL);
143 }
144 
145 static int
146 proto_busdma_md_destroy_internal(struct proto_busdma *busdma,
147     struct proto_md *md)
148 {
149 
150 	LIST_REMOVE(md, mds);
151 	LIST_REMOVE(md, peers);
152 	if (md->physaddr)
153 		bus_dmamap_unload(md->bd_tag, md->bd_map);
154 	if (md->virtaddr != NULL)
155 		bus_dmamem_free(md->bd_tag, md->virtaddr, md->bd_map);
156 	else
157 		bus_dmamap_destroy(md->bd_tag, md->bd_map);
158 	bus_dma_tag_destroy(md->bd_tag);
159 	free(md, M_PROTO_BUSDMA);
160 	return (0);
161 }
162 
163 static void
164 proto_busdma_mem_alloc_callback(void *arg, bus_dma_segment_t *segs, int	nseg,
165     int error)
166 {
167 	struct proto_callback_bundle *pcb = arg;
168 
169 	pcb->ioc->u.md.bus_nsegs = nseg;
170 	pcb->ioc->u.md.bus_addr = segs[0].ds_addr;
171 }
172 
173 static int
174 proto_busdma_mem_alloc(struct proto_busdma *busdma, struct proto_tag *tag,
175     struct proto_ioc_busdma *ioc)
176 {
177 	struct proto_callback_bundle pcb;
178 	struct proto_md *md;
179 	int error;
180 
181 	md = malloc(sizeof(*md), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
182 	md->tag = tag;
183 
184 	error = bus_dma_tag_create(busdma->bd_roottag, tag->align, tag->bndry,
185 	    tag->maxaddr, BUS_SPACE_MAXADDR, NULL, NULL, tag->maxsz,
186 	    tag->nsegs, tag->maxsegsz, 0, NULL, NULL, &md->bd_tag);
187 	if (error) {
188 		free(md, M_PROTO_BUSDMA);
189 		return (error);
190 	}
191 	error = bus_dmamem_alloc(md->bd_tag, &md->virtaddr, 0, &md->bd_map);
192 	if (error) {
193 		bus_dma_tag_destroy(md->bd_tag);
194 		free(md, M_PROTO_BUSDMA);
195 		return (error);
196 	}
197 	md->physaddr = pmap_kextract((uintptr_t)(md->virtaddr));
198 	pcb.busdma = busdma;
199 	pcb.md = md;
200 	pcb.ioc = ioc;
201 	error = bus_dmamap_load(md->bd_tag, md->bd_map, md->virtaddr,
202 	    tag->maxsz, proto_busdma_mem_alloc_callback, &pcb, BUS_DMA_NOWAIT);
203 	if (error) {
204 		bus_dmamem_free(md->bd_tag, md->virtaddr, md->bd_map);
205 		bus_dma_tag_destroy(md->bd_tag);
206 		free(md, M_PROTO_BUSDMA);
207 		return (error);
208 	}
209 	LIST_INSERT_HEAD(&tag->mds, md, peers);
210 	LIST_INSERT_HEAD(&busdma->mds, md, mds);
211 	ioc->u.md.virt_addr = (uintptr_t)md->virtaddr;
212 	ioc->u.md.virt_size = tag->maxsz;
213 	ioc->u.md.phys_nsegs = 1;
214 	ioc->u.md.phys_addr = md->physaddr;
215 	ioc->result = (uintptr_t)(void *)md;
216 	return (0);
217 }
218 
219 static int
220 proto_busdma_mem_free(struct proto_busdma *busdma, struct proto_md *md)
221 {
222 
223 	if (md->virtaddr == NULL)
224 		return (ENXIO);
225 	return (proto_busdma_md_destroy_internal(busdma, md));
226 }
227 
228 static int
229 proto_busdma_md_create(struct proto_busdma *busdma, struct proto_tag *tag,
230     struct proto_ioc_busdma *ioc)
231 {
232 	struct proto_md *md;
233 	int error;
234 
235 	md = malloc(sizeof(*md), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
236 	md->tag = tag;
237 
238 	error = bus_dma_tag_create(busdma->bd_roottag, tag->align, tag->bndry,
239 	    tag->maxaddr, BUS_SPACE_MAXADDR, NULL, NULL, tag->maxsz,
240 	    tag->nsegs, tag->maxsegsz, 0, NULL, NULL, &md->bd_tag);
241 	if (error) {
242 		free(md, M_PROTO_BUSDMA);
243 		return (error);
244 	}
245 	error = bus_dmamap_create(md->bd_tag, 0, &md->bd_map);
246 	if (error) {
247 		bus_dma_tag_destroy(md->bd_tag);
248 		free(md, M_PROTO_BUSDMA);
249 		return (error);
250 	}
251 
252 	LIST_INSERT_HEAD(&tag->mds, md, peers);
253 	LIST_INSERT_HEAD(&busdma->mds, md, mds);
254 	ioc->result = (uintptr_t)(void *)md;
255 	return (0);
256 }
257 
258 static int
259 proto_busdma_md_destroy(struct proto_busdma *busdma, struct proto_md *md)
260 {
261 
262 	if (md->virtaddr != NULL)
263 		return (ENXIO);
264 	return (proto_busdma_md_destroy_internal(busdma, md));
265 }
266 
267 static void
268 proto_busdma_md_load_callback(void *arg, bus_dma_segment_t *segs, int nseg,
269     bus_size_t sz, int error)
270 {
271 	struct proto_callback_bundle *pcb = arg;
272 
273 	pcb->ioc->u.md.bus_nsegs = nseg;
274 	pcb->ioc->u.md.bus_addr = segs[0].ds_addr;
275 }
276 
277 static int
278 proto_busdma_md_load(struct proto_busdma *busdma, struct proto_md *md,
279     struct proto_ioc_busdma *ioc, struct thread *td)
280 {
281 	struct proto_callback_bundle pcb;
282 	struct iovec iov;
283 	struct uio uio;
284 	pmap_t pmap;
285 	int error;
286 
287 	iov.iov_base = (void *)(uintptr_t)ioc->u.md.virt_addr;
288 	iov.iov_len = ioc->u.md.virt_size;
289 	uio.uio_iov = &iov;
290 	uio.uio_iovcnt = 1;
291 	uio.uio_offset = 0;
292 	uio.uio_resid = iov.iov_len;
293 	uio.uio_segflg = UIO_USERSPACE;
294 	uio.uio_rw = UIO_READ;
295 	uio.uio_td = td;
296 
297 	pcb.busdma = busdma;
298 	pcb.md = md;
299 	pcb.ioc = ioc;
300 	error = bus_dmamap_load_uio(md->bd_tag, md->bd_map, &uio,
301 	    proto_busdma_md_load_callback, &pcb, BUS_DMA_NOWAIT);
302 	if (error)
303 		return (error);
304 
305 	/* XXX determine *all* physical memory segments */
306 	pmap = vmspace_pmap(td->td_proc->p_vmspace);
307 	md->physaddr = pmap_extract(pmap, ioc->u.md.virt_addr);
308 	ioc->u.md.phys_nsegs = 1;	/* XXX */
309 	ioc->u.md.phys_addr = md->physaddr;
310 	return (0);
311 }
312 
313 static int
314 proto_busdma_md_unload(struct proto_busdma *busdma, struct proto_md *md)
315 {
316 
317 	if (!md->physaddr)
318 		return (ENXIO);
319 	bus_dmamap_unload(md->bd_tag, md->bd_map);
320 	md->physaddr = 0;
321 	return (0);
322 }
323 
324 static int
325 proto_busdma_sync(struct proto_busdma *busdma, struct proto_md *md,
326     struct proto_ioc_busdma *ioc)
327 {
328 	u_int ops;
329 
330 	ops = BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE |
331 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE;
332 	if (ioc->u.sync.op & ~ops)
333 		return (EINVAL);
334 	if (!md->physaddr)
335 		return (ENXIO);
336 	bus_dmamap_sync(md->bd_tag, md->bd_map, ioc->u.sync.op);
337 	return (0);
338 }
339 
340 static struct proto_md *
341 proto_busdma_md_lookup(struct proto_busdma *busdma, u_long key)
342 {
343 	struct proto_md *md;
344 
345 	LIST_FOREACH(md, &busdma->mds, mds) {
346 		if ((void *)md == (void *)key)
347 			return (md);
348 	}
349 	return (NULL);
350 }
351 
352 struct proto_busdma *
353 proto_busdma_attach(struct proto_softc *sc)
354 {
355 	struct proto_busdma *busdma;
356 
357 	busdma = malloc(sizeof(*busdma), M_PROTO_BUSDMA, M_WAITOK | M_ZERO);
358 	return (busdma);
359 }
360 
361 int
362 proto_busdma_detach(struct proto_softc *sc, struct proto_busdma *busdma)
363 {
364 
365 	proto_busdma_cleanup(sc, busdma);
366 	free(busdma, M_PROTO_BUSDMA);
367 	return (0);
368 }
369 
370 int
371 proto_busdma_cleanup(struct proto_softc *sc, struct proto_busdma *busdma)
372 {
373 	struct proto_md *md, *md1;
374 	struct proto_tag *tag, *tag1;
375 
376 	LIST_FOREACH_SAFE(md, &busdma->mds, mds, md1)
377 		proto_busdma_md_destroy_internal(busdma, md);
378 	LIST_FOREACH_SAFE(tag, &busdma->tags, tags, tag1)
379 		proto_busdma_tag_destroy(busdma, tag);
380 	return (0);
381 }
382 
383 int
384 proto_busdma_ioctl(struct proto_softc *sc, struct proto_busdma *busdma,
385     struct proto_ioc_busdma *ioc, struct thread *td)
386 {
387 	struct proto_tag *tag;
388 	struct proto_md *md;
389 	int error;
390 
391 	error = 0;
392 	switch (ioc->request) {
393 	case PROTO_IOC_BUSDMA_TAG_CREATE:
394 		busdma->bd_roottag = bus_get_dma_tag(sc->sc_dev);
395 		error = proto_busdma_tag_create(busdma, NULL, ioc);
396 		break;
397 	case PROTO_IOC_BUSDMA_TAG_DERIVE:
398 		tag = proto_busdma_tag_lookup(busdma, ioc->key);
399 		if (tag == NULL) {
400 			error = EINVAL;
401 			break;
402 		}
403 		error = proto_busdma_tag_create(busdma, tag, ioc);
404 		break;
405 	case PROTO_IOC_BUSDMA_TAG_DESTROY:
406 		tag = proto_busdma_tag_lookup(busdma, ioc->key);
407 		if (tag == NULL) {
408 			error = EINVAL;
409 			break;
410 		}
411 		error = proto_busdma_tag_destroy(busdma, tag);
412 		break;
413 	case PROTO_IOC_BUSDMA_MEM_ALLOC:
414 		tag = proto_busdma_tag_lookup(busdma, ioc->u.md.tag);
415 		if (tag == NULL) {
416 			error = EINVAL;
417 			break;
418 		}
419 		error = proto_busdma_mem_alloc(busdma, tag, ioc);
420 		break;
421 	case PROTO_IOC_BUSDMA_MEM_FREE:
422 		md = proto_busdma_md_lookup(busdma, ioc->key);
423 		if (md == NULL) {
424 			error = EINVAL;
425 			break;
426 		}
427 		error = proto_busdma_mem_free(busdma, md);
428 		break;
429 	case PROTO_IOC_BUSDMA_MD_CREATE:
430 		tag = proto_busdma_tag_lookup(busdma, ioc->u.md.tag);
431 		if (tag == NULL) {
432 			error = EINVAL;
433 			break;
434 		}
435 		error = proto_busdma_md_create(busdma, tag, ioc);
436 		break;
437 	case PROTO_IOC_BUSDMA_MD_DESTROY:
438 		md = proto_busdma_md_lookup(busdma, ioc->key);
439 		if (md == NULL) {
440 			error = EINVAL;
441 			break;
442 		}
443 		error = proto_busdma_md_destroy(busdma, md);
444 		break;
445 	case PROTO_IOC_BUSDMA_MD_LOAD:
446 		md = proto_busdma_md_lookup(busdma, ioc->key);
447 		if (md == NULL) {
448 			error = EINVAL;
449 			break;
450 		}
451 		error = proto_busdma_md_load(busdma, md, ioc, td);
452 		break;
453 	case PROTO_IOC_BUSDMA_MD_UNLOAD:
454 		md = proto_busdma_md_lookup(busdma, ioc->key);
455 		if (md == NULL) {
456 			error = EINVAL;
457 			break;
458 		}
459 		error = proto_busdma_md_unload(busdma, md);
460 		break;
461 	case PROTO_IOC_BUSDMA_SYNC:
462 		md = proto_busdma_md_lookup(busdma, ioc->key);
463 		if (md == NULL) {
464 			error = EINVAL;
465 			break;
466 		}
467 		error = proto_busdma_sync(busdma, md, ioc);
468 		break;
469 	default:
470 		error = EINVAL;
471 		break;
472 	}
473 	return (error);
474 }
475 
476 int
477 proto_busdma_mmap_allowed(struct proto_busdma *busdma, vm_paddr_t physaddr)
478 {
479 	struct proto_md *md;
480 
481 	LIST_FOREACH(md, &busdma->mds, mds) {
482 		if (physaddr >= trunc_page(md->physaddr) &&
483 		    physaddr <= trunc_page(md->physaddr + md->tag->maxsz))
484 			return (1);
485 	}
486 	return (0);
487 }
488