xref: /freebsd/tools/bus_space/busdma.c (revision a0409676120c1e558d0ade943019934e0f15118d) 
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  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <sys/ioctl.h>
31 #include <sys/mman.h>
32 #include <assert.h>
33 #include <errno.h>
34 #include <fcntl.h>
35 #include <limits.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 
41 #include "busdma.h"
42 
43 #include "../../sys/dev/proto/proto_dev.h"
44 
45 struct obj {
46 	int	oid;
47 	u_int	type;
48 #define	OBJ_TYPE_NONE	0
49 #define	OBJ_TYPE_TAG	1
50 #define	OBJ_TYPE_MD	2
51 #define	OBJ_TYPE_SEG	3
52 	u_int	refcnt;
53 	int	fd;
54 	struct obj *parent;
55 	u_long	key;
56 	union {
57 		struct {
58 			unsigned long	align;
59 			unsigned long	bndry;
60 			unsigned long	maxaddr;
61 			unsigned long	maxsz;
62 			unsigned long	maxsegsz;
63 			unsigned long	nsegs;
64 			unsigned long	datarate;
65 		} tag;
66 		struct {
67 			struct obj	*seg[3];
68 			int		nsegs[3];
69 #define	BUSDMA_MD_BUS	0
70 #define	BUSDMA_MD_PHYS	1
71 #define	BUSDMA_MD_VIRT	2
72 		} md;
73 		struct {
74 			struct obj	*next;
75 			unsigned long	address;
76 			unsigned long	size;
77 		} seg;
78 	} u;
79 };
80 
81 static struct obj **oidtbl = NULL;
82 static int noids = 0;
83 
84 static struct obj *
85 obj_alloc(u_int type)
86 {
87 	struct obj **newtbl, *obj;
88 	int oid;
89 
90 	obj = calloc(1, sizeof(struct obj));
91 	obj->type = type;
92 
93 	for (oid = 0; oid < noids; oid++) {
94 		if (oidtbl[oid] == 0)
95 			break;
96 	}
97 	if (oid == noids) {
98 		newtbl = realloc(oidtbl, sizeof(struct obj *) * (noids + 1));
99 		if (newtbl == NULL) {
100 			free(obj);
101 			return (NULL);
102 		}
103 		oidtbl = newtbl;
104 		noids++;
105 	}
106 	oidtbl[oid] = obj;
107 	obj->oid = oid;
108 	return (obj);
109 }
110 
111 static int
112 obj_free(struct obj *obj)
113 {
114 
115 	oidtbl[obj->oid] = NULL;
116 	free(obj);
117 	return (0);
118 }
119 
120 static struct obj *
121 obj_lookup(int oid, u_int type)
122 {
123 	struct obj *obj;
124 
125 	if (oid < 0 || oid >= noids) {
126 		errno = EINVAL;
127 		return (NULL);
128 	}
129 	obj = oidtbl[oid];
130 	if (obj->refcnt == 0) {
131 		errno = ENXIO;
132 		return (NULL);
133 	}
134 	if (type != OBJ_TYPE_NONE && obj->type != type) {
135 		errno = ENODEV;
136 		return (NULL);
137 	}
138 	return (obj);
139 }
140 
141 static struct obj *
142 bd_tag_new(struct obj *ptag, int fd, u_long align, u_long bndry,
143     u_long maxaddr, u_long maxsz, u_int nsegs, u_long maxsegsz,
144     u_int datarate, u_int flags)
145 {
146 	struct proto_ioc_busdma ioc;
147 	struct obj *tag;
148 
149 	tag = obj_alloc(OBJ_TYPE_TAG);
150 	if (tag == NULL)
151 		return (NULL);
152 
153 	memset(&ioc, 0, sizeof(ioc));
154 	ioc.request = (ptag != NULL) ? PROTO_IOC_BUSDMA_TAG_DERIVE :
155 	    PROTO_IOC_BUSDMA_TAG_CREATE;
156 	ioc.key = (ptag != NULL) ? ptag->key : 0;
157 	ioc.u.tag.align = align;
158 	ioc.u.tag.bndry = bndry;
159 	ioc.u.tag.maxaddr = maxaddr;
160 	ioc.u.tag.maxsz = maxsz;
161 	ioc.u.tag.nsegs = nsegs;
162 	ioc.u.tag.maxsegsz = maxsegsz;
163 	ioc.u.tag.datarate = datarate;
164 	ioc.u.tag.flags = flags;
165 	if (ioctl(fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
166 		obj_free(tag);
167 		return (NULL);
168 	}
169 	tag->refcnt = 1;
170 	tag->fd = fd;
171 	tag->parent = ptag;
172 	tag->key = ioc.result;
173 	tag->u.tag.align = ioc.u.tag.align;
174 	tag->u.tag.bndry = ioc.u.tag.bndry;
175 	tag->u.tag.maxaddr = ioc.u.tag.maxaddr;
176 	tag->u.tag.maxsz = ioc.u.tag.maxsz;
177 	tag->u.tag.maxsegsz = ioc.u.tag.maxsegsz;
178 	tag->u.tag.nsegs = ioc.u.tag.nsegs;
179 	tag->u.tag.datarate = ioc.u.tag.datarate;
180 	return (tag);
181 }
182 
183 int
184 bd_tag_create(const char *dev, u_long align, u_long bndry, u_long maxaddr,
185     u_long maxsz, u_int nsegs, u_long maxsegsz, u_int datarate, u_int flags)
186 {
187 	char path[PATH_MAX];
188 	struct obj *tag;
189 	int fd, len;
190 
191 	len = snprintf(path, PATH_MAX, "/dev/proto/%s/busdma", dev);
192 	if (len >= PATH_MAX) {
193 		errno = EINVAL;
194 		return (-1);
195 	}
196 	fd = open(path, O_RDWR);
197 	if (fd == -1)
198 		return (-1);
199 
200 	tag = bd_tag_new(NULL, fd, align, bndry, maxaddr, maxsz, nsegs,
201 	    maxsegsz, datarate, flags);
202 	if (tag == NULL) {
203 		close(fd);
204 		return (-1);
205 	}
206 	return (tag->oid);
207 }
208 
209 int
210 bd_tag_derive(int ptid, u_long align, u_long bndry, u_long maxaddr,
211     u_long maxsz, u_int nsegs, u_long maxsegsz, u_int datarate, u_int flags)
212 {
213 	struct obj *ptag, *tag;
214 
215 	ptag = obj_lookup(ptid, OBJ_TYPE_TAG);
216 	if (ptag == NULL)
217 		return (-1);
218 
219 	tag = bd_tag_new(ptag, ptag->fd, align, bndry, maxaddr, maxsz, nsegs,
220 	    maxsegsz, datarate, flags);
221 	if (tag == NULL)
222 		return (-1);
223 	ptag->refcnt++;
224 	return (tag->oid);
225 }
226 
227 int
228 bd_tag_destroy(int tid)
229 {
230 	struct proto_ioc_busdma ioc;
231 	struct obj *ptag, *tag;
232 
233 	tag = obj_lookup(tid, OBJ_TYPE_TAG);
234 	if (tag == NULL)
235 		return (errno);
236 	if (tag->refcnt > 1)
237 		return (EBUSY);
238 
239 	memset(&ioc, 0, sizeof(ioc));
240 	ioc.request = PROTO_IOC_BUSDMA_TAG_DESTROY;
241 	ioc.key = tag->key;
242 	if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
243 		return (errno);
244 
245 	if (tag->parent != NULL)
246 		tag->parent->refcnt--;
247 	else
248 		close(tag->fd);
249 	obj_free(tag);
250 	return (0);
251 }
252 
253 static int
254 bd_md_add_seg(struct obj *md, int type, u_long addr, u_long size)
255 {
256 	struct obj *seg;
257 
258 	seg = obj_alloc(OBJ_TYPE_SEG);
259 	if (seg == NULL)
260 		return (errno);
261 	seg->refcnt = 1;
262 	seg->parent = md;
263 	seg->u.seg.address = addr;
264 	seg->u.seg.size = size;
265 
266 	md->u.md.seg[type] = seg;
267 	md->u.md.nsegs[type] = 1;
268 	return (0);
269 }
270 
271 static int
272 bd_md_del_segs(struct obj *md, int type, int unmap)
273 {
274 	struct obj *seg, *seg0;
275 
276 	for (seg = md->u.md.seg[type]; seg != NULL; seg = seg0) {
277 		if (unmap)
278 			munmap((void *)seg->u.seg.address, seg->u.seg.size);
279 		seg0 = seg->u.seg.next;
280 		obj_free(seg);
281 	}
282 	return (0);
283 }
284 
285 int
286 bd_md_create(int tid, u_int flags)
287 {
288 	struct proto_ioc_busdma ioc;
289 	struct obj *md, *tag;
290 
291 	tag = obj_lookup(tid, OBJ_TYPE_TAG);
292 	if (tag == NULL)
293 		return (-1);
294 
295 	md = obj_alloc(OBJ_TYPE_MD);
296 	if (md == NULL)
297 		return (-1);
298 
299 	memset(&ioc, 0, sizeof(ioc));
300 	ioc.request = PROTO_IOC_BUSDMA_MD_CREATE;
301 	ioc.u.md.tag = tag->key;
302 	ioc.u.md.flags = flags;
303 	if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
304 		obj_free(md);
305 		return (-1);
306 	}
307 
308 	md->refcnt = 1;
309 	md->fd = tag->fd;
310 	md->parent = tag;
311 	tag->refcnt++;
312 	md->key = ioc.result;
313 	return (md->oid);
314 }
315 
316 int
317 bd_md_destroy(int mdid)
318 {
319 	struct proto_ioc_busdma ioc;
320 	struct obj *md;
321 
322 	md = obj_lookup(mdid, OBJ_TYPE_MD);
323 	if (md == NULL)
324 		return (errno);
325 
326 	memset(&ioc, 0, sizeof(ioc));
327 	ioc.request = PROTO_IOC_BUSDMA_MD_DESTROY;
328 	ioc.key = md->key;
329 	if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
330 		return (errno);
331 
332 	md->parent->refcnt--;
333 	obj_free(md);
334 	return (0);
335 }
336 
337 int
338 bd_md_load(int mdid, void *buf, u_long len, u_int flags)
339 {
340 	struct proto_ioc_busdma ioc;
341 	struct obj *md;
342 	int error;
343 
344 	md = obj_lookup(mdid, OBJ_TYPE_MD);
345 	if (md == NULL)
346 		return (errno);
347 
348 	memset(&ioc, 0, sizeof(ioc));
349 	ioc.request = PROTO_IOC_BUSDMA_MD_LOAD;
350 	ioc.key = md->key;
351 	ioc.u.md.flags = flags;
352 	ioc.u.md.virt_addr = (uintptr_t)buf;
353 	ioc.u.md.virt_size = len;
354 	if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
355 		return (errno);
356 
357 	error = bd_md_add_seg(md, BUSDMA_MD_VIRT, ioc.u.md.virt_addr, len);
358 	error = bd_md_add_seg(md, BUSDMA_MD_PHYS, ioc.u.md.phys_addr, len);
359 	error = bd_md_add_seg(md, BUSDMA_MD_BUS, ioc.u.md.bus_addr, len);
360 	return (error);
361 }
362 
363 int
364 bd_md_unload(int mdid)
365 {
366 	struct proto_ioc_busdma ioc;
367 	struct obj *md;
368 	int error;
369 
370 	md = obj_lookup(mdid, OBJ_TYPE_MD);
371 	if (md == NULL)
372 		return (errno);
373 
374 	memset(&ioc, 0, sizeof(ioc));
375 	ioc.request = PROTO_IOC_BUSDMA_MD_UNLOAD;
376 	ioc.key = md->key;
377 	if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
378 		return (errno);
379 
380 	bd_md_del_segs(md, BUSDMA_MD_VIRT, 0);
381 	bd_md_del_segs(md, BUSDMA_MD_PHYS, 0);
382 	bd_md_del_segs(md, BUSDMA_MD_BUS, 0);
383 	return (0);
384 }
385 
386 int
387 bd_mem_alloc(int tid, u_int flags)
388 {
389 	struct proto_ioc_busdma ioc;
390 	struct obj *md, *tag;
391 	uintptr_t addr;
392 	int error;
393 
394 	tag = obj_lookup(tid, OBJ_TYPE_TAG);
395 	if (tag == NULL)
396 		return (-1);
397 
398 	md = obj_alloc(OBJ_TYPE_MD);
399 	if (md == NULL)
400 		return (-1);
401 
402 	memset(&ioc, 0, sizeof(ioc));
403 	ioc.request = PROTO_IOC_BUSDMA_MEM_ALLOC;
404 	ioc.u.md.tag = tag->key;
405 	ioc.u.md.flags = flags;
406 	if (ioctl(tag->fd, PROTO_IOC_BUSDMA, &ioc) == -1) {
407 		obj_free(md);
408 		return (-1);
409 	}
410 
411 	md->refcnt = 1;
412 	md->fd = tag->fd;
413 	md->parent = tag;
414 	tag->refcnt++;
415 	md->key = ioc.result;
416 
417 	/* XXX we need to support multiple segments */
418 	assert(ioc.u.md.phys_nsegs == 1);
419 	assert(ioc.u.md.bus_nsegs == 1);
420 	error = bd_md_add_seg(md, BUSDMA_MD_PHYS, ioc.u.md.phys_addr,
421 	    tag->u.tag.maxsz);
422 	error = bd_md_add_seg(md, BUSDMA_MD_BUS, ioc.u.md.bus_addr,
423 	    tag->u.tag.maxsz);
424 
425 	addr = (uintptr_t)mmap(NULL, tag->u.tag.maxsz, PROT_READ | PROT_WRITE,
426 	    MAP_NOCORE | MAP_SHARED, md->fd, ioc.u.md.phys_addr);
427 	if (addr == (uintptr_t)MAP_FAILED)
428 		goto fail;
429 	error = bd_md_add_seg(md, BUSDMA_MD_VIRT, addr, tag->u.tag.maxsz);
430 
431 	return (md->oid);
432 
433  fail:
434 	memset(&ioc, 0, sizeof(ioc));
435 	ioc.request = PROTO_IOC_BUSDMA_MEM_FREE;
436 	ioc.key = md->key;
437 	ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc);
438 	md->parent->refcnt--;
439 	obj_free(md);
440 	return (-1);
441 }
442 
443 int
444 bd_mem_free(int mdid)
445 {
446 	struct proto_ioc_busdma ioc;
447 	struct obj *md;
448 
449 	md = obj_lookup(mdid, OBJ_TYPE_MD);
450 	if (md == NULL)
451 		return (errno);
452 
453 	memset(&ioc, 0, sizeof(ioc));
454 	ioc.request = PROTO_IOC_BUSDMA_MEM_FREE;
455 	ioc.key = md->key;
456 	if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
457 		return (errno);
458 
459 	bd_md_del_segs(md, BUSDMA_MD_VIRT, 1);
460 	bd_md_del_segs(md, BUSDMA_MD_PHYS, 0);
461 	bd_md_del_segs(md, BUSDMA_MD_BUS, 0);
462 	md->parent->refcnt--;
463 	obj_free(md);
464 	return (0);
465 }
466 
467 int
468 bd_md_first_seg(int mdid, int space)
469 {
470 	struct obj *md, *seg;
471 
472 	md = obj_lookup(mdid, OBJ_TYPE_MD);
473 	if (md == NULL)
474 		return (-1);
475 
476 	if (space != BUSDMA_MD_BUS && space != BUSDMA_MD_PHYS &&
477 	    space != BUSDMA_MD_VIRT) {
478 		errno = EINVAL;
479 		return (-1);
480 	}
481 	seg = md->u.md.seg[space];
482 	if (seg == NULL) {
483 		errno = ENXIO;
484 		return (-1);
485 	}
486 	return (seg->oid);
487 }
488 
489 int
490 bd_md_next_seg(int mdid, int sid)
491 {
492 	struct obj *seg;
493 
494 	seg = obj_lookup(sid, OBJ_TYPE_SEG);
495 	if (seg == NULL)
496 		return (-1);
497 
498 	seg = seg->u.seg.next;
499 	if (seg == NULL) {
500 		errno = ENXIO;
501 		return (-1);
502 	}
503 	return (seg->oid);
504 }
505 
506 int
507 bd_seg_get_addr(int sid, u_long *addr_p)
508 {
509 	struct obj *seg;
510 
511 	if (addr_p == NULL)
512 		return (EINVAL);
513 
514 	seg = obj_lookup(sid, OBJ_TYPE_SEG);
515 	if (seg == NULL)
516 		return (errno);
517 
518 	*addr_p = seg->u.seg.address;
519 	return (0);
520 }
521 
522 int
523 bd_seg_get_size(int sid, u_long *size_p)
524 {
525 	struct obj *seg;
526 
527 	if (size_p == NULL)
528 		return (EINVAL);
529 
530 	seg = obj_lookup(sid, OBJ_TYPE_SEG);
531 	if (seg == NULL)
532 		return (errno);
533 
534 	*size_p = seg->u.seg.size;
535 	return (0);
536 }
537 
538 int
539 bd_sync(int mdid, u_int op, u_long ofs, u_long len)
540 {
541 	struct proto_ioc_busdma ioc;
542 	struct obj *md;
543 
544 	md = obj_lookup(mdid, OBJ_TYPE_MD);
545 	if (md == NULL)
546 		return (errno);
547 
548 	memset(&ioc, 0, sizeof(ioc));
549 	ioc.request = PROTO_IOC_BUSDMA_SYNC;
550 	ioc.key = md->key;
551 	ioc.u.sync.op = op;
552 	ioc.u.sync.base = ofs;
553 	ioc.u.sync.size = len;
554 	if (ioctl(md->fd, PROTO_IOC_BUSDMA, &ioc) == -1)
555 		return (errno);
556 
557 	return (0);
558 }
559