1 /* $NetBSD: bus_dma.c,v 1.1 2024/01/02 07:41:02 thorpej Exp $ */
2
3 /*
4 * This file was taken from next68k/dev/bus_dma.c, which was originally
5 * taken from alpha/common/bus_dma.c.
6 * It should probably be re-synced when needed.
7 * original cvs id: NetBSD: bus_dma.c,v 1.13 1999/11/13 00:30:40 thorpej Exp
8 */
9
10 /*-
11 * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
12 * All rights reserved.
13 *
14 * This code is derived from software contributed to The NetBSD Foundation
15 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
16 * NASA Ames Research Center.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */
41
42 __KERNEL_RCSID(0, "$NetBSD: bus_dma.c,v 1.1 2024/01/02 07:41:02 thorpej Exp $");
43
44 #define _VIRT68K_BUS_DMA_PRIVATE
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/kernel.h>
49 #include <sys/device.h>
50 #include <sys/kmem.h>
51 #include <sys/proc.h>
52 #include <sys/mbuf.h>
53 #include <sys/kcore.h>
54
55 #include <uvm/uvm.h>
56
57 #include <machine/cpu.h>
58 #include <machine/pmap.h>
59 #include <machine/bus.h>
60 #include <m68k/cacheops.h>
61
62 int _bus_dmamap_load_buffer_direct_common(bus_dma_tag_t,
63 bus_dmamap_t, void *, bus_size_t, struct vmspace *, int,
64 paddr_t *, int *, int);
65
66 static size_t
_bus_dmamap_mapsize(int const nsegments)67 _bus_dmamap_mapsize(int const nsegments)
68 {
69 KASSERT(nsegments > 0);
70 return sizeof(struct virt68k_bus_dmamap) +
71 (sizeof(bus_dma_segment_t) * (nsegments - 1));
72 }
73
74 /*
75 * Common function for DMA map creation. May be called by bus-specific
76 * DMA map creation functions.
77 */
78 int
_bus_dmamap_create(bus_dma_tag_t t,bus_size_t size,int nsegments,bus_size_t maxsegsz,bus_size_t boundary,int flags,bus_dmamap_t * dmamp)79 _bus_dmamap_create(bus_dma_tag_t t, bus_size_t size, int nsegments,
80 bus_size_t maxsegsz, bus_size_t boundary, int flags, bus_dmamap_t *dmamp)
81 {
82 struct virt68k_bus_dmamap *map;
83 void *mapstore;
84
85 /*
86 * Allocate and initialize the DMA map. The end of the map
87 * is a variable-sized array of segments, so we allocate enough
88 * room for them in one shot.
89 *
90 * Note we don't preserve the WAITOK or NOWAIT flags. Preservation
91 * of ALLOCNOW notifies others that we've reserved these resources,
92 * and they are not to be freed.
93 *
94 * The bus_dmamap_t includes one bus_dma_segment_t, hence
95 * the (nsegments - 1).
96 */
97 if ((mapstore = kmem_zalloc(_bus_dmamap_mapsize(nsegments),
98 (flags & BUS_DMA_NOWAIT) ? KM_NOSLEEP : KM_SLEEP)) == NULL)
99 return ENOMEM;
100
101 map = (struct virt68k_bus_dmamap *)mapstore;
102 map->_dm_size = size;
103 map->_dm_segcnt = nsegments;
104 map->_dm_maxmaxsegsz = maxsegsz;
105 map->_dm_boundary = boundary;
106 map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT);
107 map->dm_maxsegsz = maxsegsz;
108 map->dm_mapsize = 0; /* no valid mappings */
109 map->dm_nsegs = 0;
110
111 *dmamp = map;
112 return 0;
113 }
114
115 /*
116 * Common function for DMA map destruction. May be called by bus-specific
117 * DMA map destruction functions.
118 */
119 void
_bus_dmamap_destroy(bus_dma_tag_t t,bus_dmamap_t map)120 _bus_dmamap_destroy(bus_dma_tag_t t, bus_dmamap_t map)
121 {
122
123 kmem_free(map, _bus_dmamap_mapsize(map->_dm_segcnt));
124 }
125
126 /*
127 * Utility function to load a linear buffer. lastaddrp holds state
128 * between invocations (for multiple-buffer loads). segp contains
129 * the starting segment on entrance, and the ending segment on exit.
130 * first indicates if this is the first invocation of this function.
131 */
132 int
_bus_dmamap_load_buffer_direct_common(bus_dma_tag_t t,bus_dmamap_t map,void * buf,bus_size_t buflen,struct vmspace * vm,int flags,paddr_t * lastaddrp,int * segp,int first)133 _bus_dmamap_load_buffer_direct_common(bus_dma_tag_t t, bus_dmamap_t map,
134 void *buf, bus_size_t buflen, struct vmspace *vm, int flags,
135 paddr_t *lastaddrp, int *segp, int first)
136 {
137 bus_size_t sgsize;
138 bus_addr_t curaddr, lastaddr, baddr, bmask;
139 vaddr_t vaddr = (vaddr_t)buf;
140 int seg, cacheable, coherent = BUS_DMA_COHERENT;
141
142 lastaddr = *lastaddrp;
143 bmask = ~(map->_dm_boundary - 1);
144
145 for (seg = *segp; buflen > 0 ; ) {
146 /*
147 * Get the physical address for this segment.
148 */
149 (void) pmap_extract(vm_map_pmap(&vm->vm_map), vaddr, &curaddr);
150 cacheable = _pmap_page_is_cacheable(vm_map_pmap(&vm->vm_map),
151 vaddr);
152
153 if (cacheable)
154 coherent = 0;
155
156 /*
157 * Compute the segment size, and adjust counts.
158 */
159 sgsize = PAGE_SIZE - ((u_long)vaddr & PGOFSET);
160 if (buflen < sgsize)
161 sgsize = buflen;
162
163 /*
164 * Make sure we don't cross any boundaries.
165 */
166 if (map->_dm_boundary > 0) {
167 baddr = (curaddr + map->_dm_boundary) & bmask;
168 if (sgsize > (baddr - curaddr))
169 sgsize = (baddr - curaddr);
170 }
171
172 /*
173 * Insert chunk into a segment, coalescing with
174 * the previous segment if possible.
175 */
176 if (first) {
177 map->dm_segs[seg].ds_addr =
178 map->dm_segs[seg]._ds_cpuaddr = curaddr;
179 map->dm_segs[seg].ds_len = sgsize;
180 map->dm_segs[seg]._ds_flags =
181 cacheable ? 0 : BUS_DMA_COHERENT;
182 first = 0;
183 } else {
184 if (curaddr == lastaddr &&
185 (map->dm_segs[seg].ds_len + sgsize) <=
186 map->dm_maxsegsz &&
187 (map->_dm_boundary == 0 ||
188 (map->dm_segs[seg].ds_addr & bmask) ==
189 (curaddr & bmask)))
190 map->dm_segs[seg].ds_len += sgsize;
191 else {
192 if (++seg >= map->_dm_segcnt)
193 break;
194 map->dm_segs[seg].ds_addr =
195 map->dm_segs[seg]._ds_cpuaddr = curaddr;
196 map->dm_segs[seg].ds_len = sgsize;
197 map->dm_segs[seg]._ds_flags =
198 cacheable ? 0 : BUS_DMA_COHERENT;
199 }
200 }
201
202 lastaddr = curaddr + sgsize;
203 vaddr += sgsize;
204 buflen -= sgsize;
205 }
206
207 *segp = seg;
208 *lastaddrp = lastaddr;
209 map->_dm_flags &= ~BUS_DMA_COHERENT;
210 map->_dm_flags |= coherent;
211
212 /*
213 * Did we fit?
214 */
215 if (buflen != 0) {
216 /*
217 * If there is a chained window, we will automatically
218 * fall back to it.
219 */
220 return EFBIG; /* XXX better return value here? */
221 }
222
223 return 0;
224 }
225
226 /*
227 * Common function for loading a direct-mapped DMA map with a linear
228 * buffer. Called by bus-specific DMA map load functions with the
229 * OR value appropriate for indicating "direct-mapped" for that
230 * chipset.
231 */
232 int
_bus_dmamap_load_direct(bus_dma_tag_t t,bus_dmamap_t map,void * buf,bus_size_t buflen,struct proc * p,int flags)233 _bus_dmamap_load_direct(bus_dma_tag_t t, bus_dmamap_t map, void *buf,
234 bus_size_t buflen, struct proc *p, int flags)
235 {
236 paddr_t lastaddr;
237 int seg, error;
238 struct vmspace *vm;
239
240 /*
241 * Make sure that on error condition we return "no valid mappings".
242 */
243 map->dm_mapsize = 0;
244 map->dm_nsegs = 0;
245 KASSERT(map->dm_maxsegsz <= map->_dm_maxmaxsegsz);
246
247 if (buflen > map->_dm_size)
248 return EINVAL;
249
250 if (p != NULL) {
251 vm = p->p_vmspace;
252 } else {
253 vm = vmspace_kernel();
254 }
255
256 seg = 0;
257 error = _bus_dmamap_load_buffer_direct_common(t, map, buf, buflen,
258 vm, flags, &lastaddr, &seg, 1);
259 if (error == 0) {
260 map->dm_mapsize = buflen;
261 map->dm_nsegs = seg + 1;
262 }
263 return error;
264 }
265
266 /*
267 * Like _bus_dmamap_load_direct_common(), but for mbufs.
268 */
269 int
_bus_dmamap_load_mbuf_direct(bus_dma_tag_t t,bus_dmamap_t map,struct mbuf * m0,int flags)270 _bus_dmamap_load_mbuf_direct(bus_dma_tag_t t, bus_dmamap_t map,
271 struct mbuf *m0, int flags)
272 {
273 paddr_t lastaddr;
274 int seg, error, first;
275 struct mbuf *m;
276
277 /*
278 * Make sure that on error condition we return "no valid mappings."
279 */
280 map->dm_mapsize = 0;
281 map->dm_nsegs = 0;
282 KASSERT(map->dm_maxsegsz <= map->_dm_maxmaxsegsz);
283
284 #ifdef DIAGNOSTIC
285 if ((m0->m_flags & M_PKTHDR) == 0)
286 panic("_bus_dmamap_load_mbuf_direct_common: no packet header");
287 #endif
288
289 if (m0->m_pkthdr.len > map->_dm_size)
290 return EINVAL;
291
292 first = 1;
293 seg = 0;
294 error = 0;
295 for (m = m0; m != NULL && error == 0; m = m->m_next) {
296 if (m->m_len == 0)
297 continue;
298 error = _bus_dmamap_load_buffer_direct_common(t, map,
299 m->m_data, m->m_len, vmspace_kernel(), flags, &lastaddr,
300 &seg, first);
301 first = 0;
302 }
303 if (error == 0) {
304 map->dm_mapsize = m0->m_pkthdr.len;
305 map->dm_nsegs = seg + 1;
306 }
307 return error;
308 }
309
310 /*
311 * Like _bus_dmamap_load_direct_common(), but for uios.
312 */
313 int
_bus_dmamap_load_uio_direct(bus_dma_tag_t t,bus_dmamap_t map,struct uio * uio,int flags)314 _bus_dmamap_load_uio_direct(bus_dma_tag_t t, bus_dmamap_t map, struct uio *uio,
315 int flags)
316 {
317 paddr_t lastaddr;
318 int seg, i, error, first;
319 bus_size_t minlen, resid;
320 struct iovec *iov;
321 void *addr;
322
323 /*
324 * Make sure that on error condition we return "no valid mappings."
325 */
326 map->dm_mapsize = 0;
327 map->dm_nsegs = 0;
328 KASSERT(map->dm_maxsegsz <= map->_dm_maxmaxsegsz);
329
330 resid = uio->uio_resid;
331 iov = uio->uio_iov;
332
333 first = 1;
334 seg = 0;
335 error = 0;
336 for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) {
337 /*
338 * Now at the first iovec to load. Load each iovec
339 * until we have exhausted the residual count.
340 */
341 minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len;
342 addr = (void *)iov[i].iov_base;
343
344 error = _bus_dmamap_load_buffer_direct_common(t, map,
345 addr, minlen, uio->uio_vmspace, flags, &lastaddr, &seg,
346 first);
347 first = 0;
348
349 resid -= minlen;
350 }
351 if (error == 0) {
352 map->dm_mapsize = uio->uio_resid;
353 map->dm_nsegs = seg + 1;
354 }
355 return error;
356 }
357
358 /*
359 * Like _bus_dmamap_load_direct_common(), but for raw memory.
360 */
361 int
_bus_dmamap_load_raw_direct(bus_dma_tag_t t,bus_dmamap_t map,bus_dma_segment_t * segs,int nsegs,bus_size_t size,int flags)362 _bus_dmamap_load_raw_direct(bus_dma_tag_t t, bus_dmamap_t map,
363 bus_dma_segment_t *segs, int nsegs, bus_size_t size, int flags)
364 {
365 /*
366 * @@@ This routine doesn't enforce map boundary requirement
367 * @@@ perhaps it should return an error instead of panicking
368 */
369
370 #ifdef DIAGNOSTIC
371 if (map->_dm_size < size) {
372 panic("_bus_dmamap_load_raw_direct: size is too large for map");
373 }
374 if (map->_dm_segcnt < nsegs) {
375 panic("_bus_dmamap_load_raw_direct: too many segments for map");
376 }
377 #endif
378
379 {
380 int i;
381 for (i = 0; i < nsegs; i++) {
382 #ifdef DIAGNOSTIC
383 if (map->dm_maxsegsz < map->dm_segs[i].ds_len) {
384 panic("%s: segment too large for map",
385 __func__);
386 }
387 #endif
388 map->dm_segs[i] = segs[i];
389 }
390 }
391
392 map->dm_nsegs = nsegs;
393 map->dm_mapsize = size;
394
395 return 0;
396 }
397
398 /*
399 * Common function for unloading a DMA map. May be called by
400 * chipset-specific DMA map unload functions.
401 */
402 void
_bus_dmamap_unload(bus_dma_tag_t t,bus_dmamap_t map)403 _bus_dmamap_unload(bus_dma_tag_t t, bus_dmamap_t map)
404 {
405
406 /*
407 * No resources to free; just mark the mappings as
408 * invalid.
409 */
410 map->dm_maxsegsz = map->_dm_maxmaxsegsz;
411 map->dm_mapsize = 0;
412 map->dm_nsegs = 0;
413 map->_dm_flags &= ~BUS_DMA_COHERENT;
414 }
415
416 /*
417 * 68030 DMA map synchronization. May be called
418 * by chipset-specific DMA map synchronization functions.
419 */
420 void
_bus_dmamap_sync_030(bus_dma_tag_t t,bus_dmamap_t map,bus_addr_t offset,bus_size_t len,int ops)421 _bus_dmamap_sync_030(bus_dma_tag_t t, bus_dmamap_t map, bus_addr_t offset,
422 bus_size_t len, int ops)
423 {
424
425 /* Nothing yet */
426 }
427
428 /*
429 * 68040/68060 DMA map synchronization. May be called
430 * by chipset-specific DMA map synchronization functions.
431 */
432 void
_bus_dmamap_sync_0460(bus_dma_tag_t t,bus_dmamap_t map,bus_addr_t offset,bus_size_t len,int ops)433 _bus_dmamap_sync_0460(bus_dma_tag_t t, bus_dmamap_t map, bus_addr_t offset,
434 bus_size_t len, int ops)
435 {
436 bus_addr_t p, e, ps, pe;
437 bus_size_t seglen;
438 int i;
439
440 /* If the whole DMA map is uncached, do nothing. */
441 if (map->_dm_flags & BUS_DMA_COHERENT)
442 return;
443
444 /* Short-circuit for unsupported `ops' */
445 if ((ops & (BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE)) == 0)
446 return;
447
448 for (i = 0; i < map->dm_nsegs && len > 0; i++) {
449 if (map->dm_segs[i].ds_len <= offset) {
450 /* Segment irrelevant - before requested offset */
451 offset -= map->dm_segs[i].ds_len;
452 continue;
453 }
454
455 seglen = map->dm_segs[i].ds_len - offset;
456 if (seglen > len)
457 seglen = len;
458 len -= seglen;
459
460 /* Ignore cache-inhibited segments */
461 if (map->dm_segs[i]._ds_flags & BUS_DMA_COHERENT)
462 continue;
463
464 ps = map->dm_segs[i]._ds_cpuaddr + offset;
465 pe = ps + seglen;
466
467 if (ops & BUS_DMASYNC_PREWRITE) {
468 p = ps & ~0xf;
469 e = (pe + 15) & ~0xf;
470
471 /* flush cache line (060 too) */
472 while((p < e) && (p % PAGE_SIZE)) {
473 DCFL_40(p);
474 p += 16;
475 }
476
477 /* flush page (060 too) */
478 while((p + PAGE_SIZE) <= e) {
479 DCFP_40(p);
480 p += PAGE_SIZE;
481 }
482
483 /* flush cache line (060 too) */
484 while(p < e) {
485 DCFL_40(p);
486 p += 16;
487 }
488 }
489
490 /*
491 * Normally, the `PREREAD' flag instructs us to purge the
492 * cache for the specified offset and length. However, if
493 * the offset/length is not aligned to a cacheline boundary,
494 * we may end up purging some legitimate data from the
495 * start/end of the cache. In such a case, *flush* the
496 * cachelines at the start and end of the required region.
497 */
498 if (ops & BUS_DMASYNC_PREREAD) {
499 if (ps & 0xf) {
500 DCFL_40(ps & ~0xf);
501 ICPL_40(ps & ~0xf);
502 }
503 if (pe & 0xf) {
504 DCFL_40(pe & ~0xf);
505 ICPL_40(pe & ~0xf);
506 }
507
508 p = (ps + 15) & ~0xf;
509 e = pe & ~0xf;
510
511 /* purge cache line */
512 while((p < e) && (p % PAGE_SIZE)) {
513 DCPL_40(p);
514 ICPL_40(p);
515 p += 16;
516 }
517
518 /* purge page */
519 while((p + PAGE_SIZE) <= e) {
520 DCPP_40(p);
521 ICPP_40(p);
522 p += PAGE_SIZE;
523 }
524
525 /* purge cache line */
526 while(p < e) {
527 DCPL_40(p);
528 ICPL_40(p);
529 p += 16;
530 }
531 }
532 }
533 }
534
535 /*
536 * Common function for DMA-safe memory allocation. May be called
537 * by bus-specific DMA memory allocation functions.
538 */
539 int
_bus_dmamem_alloc_common(bus_dma_tag_t t,bus_addr_t low,bus_addr_t high,bus_size_t size,bus_size_t alignment,bus_size_t boundary,bus_dma_segment_t * segs,int nsegs,int * rsegs,int flags)540 _bus_dmamem_alloc_common(bus_dma_tag_t t, bus_addr_t low, bus_addr_t high,
541 bus_size_t size, bus_size_t alignment, bus_size_t boundary,
542 bus_dma_segment_t *segs, int nsegs, int *rsegs, int flags)
543 {
544 paddr_t curaddr, lastaddr;
545 struct vm_page *m;
546 struct pglist mlist;
547 int curseg, error;
548
549 /* Always round the size. */
550 size = round_page(size);
551 high -= PAGE_SIZE;
552
553 /*
554 * Allocate pages from the VM system.
555 *
556 * XXXSCW: This will be sub-optimal if the base-address of offboard
557 * RAM is significantly higher than the end-address of onboard RAM.
558 * (Due to how uvm_pglistalloc() is implemented.)
559 *
560 * uvm_pglistalloc() also currently ignores the 'nsegs' parameter,
561 * and always returns only one (contiguous) segment.
562 */
563 error = uvm_pglistalloc(size, low, high, alignment, boundary,
564 &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0);
565 if (error)
566 return error;
567
568 /*
569 * Compute the location, size, and number of segments actually
570 * returned by the VM code.
571 */
572 m = mlist.tqh_first;
573 curseg = 0;
574 lastaddr = VM_PAGE_TO_PHYS(m);
575 segs[curseg].ds_addr = segs[curseg]._ds_cpuaddr = lastaddr;
576 segs[curseg].ds_len = PAGE_SIZE;
577 segs[curseg]._ds_flags = 0;
578 m = m->pageq.queue.tqe_next;
579
580 for (; m != NULL; m = m->pageq.queue.tqe_next) {
581 if (curseg > nsegs) {
582 #ifdef DIAGNOSTIC
583 printf("%s: too many segments\n", __func__);
584 #ifdef DEBUG
585 panic("%s", __func__);
586 #endif
587 #endif
588 uvm_pglistfree(&mlist);
589 return -1;
590 }
591
592 curaddr = VM_PAGE_TO_PHYS(m);
593 #ifdef DIAGNOSTIC
594 if (curaddr < low || curaddr > high) {
595 printf("uvm_pglistalloc returned non-sensical"
596 " address 0x%lx\n", curaddr);
597 panic("%s", __func__);
598 }
599 #endif
600 if (curaddr == (lastaddr + PAGE_SIZE))
601 segs[curseg].ds_len += PAGE_SIZE;
602 else {
603 curseg++;
604 segs[curseg].ds_addr =
605 segs[curseg]._ds_cpuaddr = curaddr;
606 segs[curseg].ds_len = PAGE_SIZE;
607 segs[curseg]._ds_flags = 0;
608 }
609 lastaddr = curaddr;
610 }
611
612 *rsegs = curseg + 1;
613
614 return 0;
615 }
616 /*
617 * Common function for DMA-safe memory allocation. May be called
618 * by bus-specific DMA memory allocation functions.
619 */
620 int
_bus_dmamem_alloc(bus_dma_tag_t t,bus_size_t size,bus_size_t alignment,bus_size_t boundary,bus_dma_segment_t * segs,int nsegs,int * rsegs,int flags)621 _bus_dmamem_alloc(bus_dma_tag_t t, bus_size_t size, bus_size_t alignment,
622 bus_size_t boundary, bus_dma_segment_t *segs, int nsegs, int *rsegs,
623 int flags)
624 {
625 extern paddr_t avail_start, avail_end;
626
627 return _bus_dmamem_alloc_common(t, avail_start, avail_end,
628 size, alignment, boundary, segs, nsegs, rsegs, flags);
629 }
630
631 /*
632 * Common function for freeing DMA-safe memory. May be called by
633 * bus-specific DMA memory free functions.
634 */
635 void
_bus_dmamem_free(bus_dma_tag_t t,bus_dma_segment_t * segs,int nsegs)636 _bus_dmamem_free(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs)
637 {
638 struct vm_page *m;
639 bus_addr_t addr;
640 struct pglist mlist;
641 int curseg;
642
643 /*
644 * Build a list of pages to free back to the VM system.
645 */
646 TAILQ_INIT(&mlist);
647 for (curseg = 0; curseg < nsegs; curseg++) {
648 for (addr = segs[curseg]._ds_cpuaddr;
649 addr < (segs[curseg]._ds_cpuaddr + segs[curseg].ds_len);
650 addr += PAGE_SIZE) {
651 m = PHYS_TO_VM_PAGE(addr);
652 TAILQ_INSERT_TAIL(&mlist, m, pageq.queue);
653 }
654 }
655
656 uvm_pglistfree(&mlist);
657 }
658
659 /*
660 * Common function for mapping DMA-safe memory. May be called by
661 * bus-specific DMA memory map functions.
662 */
663 int
_bus_dmamem_map(bus_dma_tag_t t,bus_dma_segment_t * segs,int nsegs,size_t size,void ** kvap,int flags)664 _bus_dmamem_map(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs,
665 size_t size, void **kvap, int flags)
666 {
667 vaddr_t va;
668 bus_addr_t addr;
669 int curseg;
670 const uvm_flag_t kmflags =
671 (flags & BUS_DMA_NOWAIT) != 0 ? UVM_KMF_NOWAIT : 0;
672
673 size = round_page(size);
674
675 va = uvm_km_alloc(kernel_map, size, 0, UVM_KMF_VAONLY | kmflags);
676
677 if (va == 0)
678 return ENOMEM;
679
680 *kvap = (void *)va;
681
682 for (curseg = 0; curseg < nsegs; curseg++) {
683 for (addr = segs[curseg]._ds_cpuaddr;
684 addr < (segs[curseg]._ds_cpuaddr + segs[curseg].ds_len);
685 addr += PAGE_SIZE, va += PAGE_SIZE, size -= PAGE_SIZE) {
686 if (size == 0)
687 panic("%s: size botch", __func__);
688
689 pmap_enter(pmap_kernel(), va, addr,
690 VM_PROT_READ | VM_PROT_WRITE,
691 VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED);
692
693 /* Cache-inhibit the page if necessary */
694 if ((flags & BUS_DMA_COHERENT) != 0)
695 _pmap_set_page_cacheinhibit(pmap_kernel(), va);
696
697 segs[curseg]._ds_flags &= ~BUS_DMA_COHERENT;
698 segs[curseg]._ds_flags |= (flags & BUS_DMA_COHERENT);
699 }
700 }
701 pmap_update(pmap_kernel());
702
703 if ((flags & BUS_DMA_COHERENT) != 0)
704 TBIAS();
705
706 return 0;
707 }
708
709 /*
710 * Common function for unmapping DMA-safe memory. May be called by
711 * bus-specific DMA memory unmapping functions.
712 */
713 void
_bus_dmamem_unmap(bus_dma_tag_t t,void * kva,size_t size)714 _bus_dmamem_unmap(bus_dma_tag_t t, void *kva, size_t size)
715 {
716 vaddr_t va;
717 size_t s;
718
719 #ifdef DIAGNOSTIC
720 if ((u_long)kva & PGOFSET)
721 panic("%s", __func__);
722 #endif
723
724 size = round_page(size);
725
726 /*
727 * Re-enable cacheing on the range
728 * XXXSCW: There should be some way to indicate that the pages
729 * were mapped DMA_MAP_COHERENT in the first place...
730 */
731 for (s = 0, va = (vaddr_t)kva; s < size;
732 s += PAGE_SIZE, va += PAGE_SIZE)
733 _pmap_set_page_cacheable(pmap_kernel(), va);
734
735 pmap_remove(pmap_kernel(), (vaddr_t)kva, (vaddr_t)kva + size);
736 pmap_update(pmap_kernel());
737 uvm_km_free(kernel_map, (vaddr_t)kva, size, UVM_KMF_VAONLY);
738 }
739
740 /*
741 * Common function for mmap(2)'ing DMA-safe memory. May be called by
742 * bus-specific DMA mmap(2)'ing functions.
743 */
744 paddr_t
_bus_dmamem_mmap(bus_dma_tag_t t,bus_dma_segment_t * segs,int nsegs,off_t off,int prot,int flags)745 _bus_dmamem_mmap(bus_dma_tag_t t, bus_dma_segment_t *segs, int nsegs,
746 off_t off, int prot, int flags)
747 {
748 int i;
749
750 for (i = 0; i < nsegs; i++) {
751 #ifdef DIAGNOSTIC
752 if (off & PGOFSET)
753 panic("%s: offset unaligned", __func__);
754 if (segs[i]._ds_cpuaddr & PGOFSET)
755 panic("%s: segment unaligned", __func__);
756 if (segs[i].ds_len & PGOFSET)
757 panic("%s: segment size not multiple of page size",
758 __func__);
759 #endif
760 if (off >= segs[i].ds_len) {
761 off -= segs[i].ds_len;
762 continue;
763 }
764
765 /*
766 * XXXSCW: What about BUS_DMA_COHERENT ??
767 */
768
769 return m68k_btop((char *)segs[i]._ds_cpuaddr + off);
770 }
771
772 /* Page not found. */
773 return -1;
774 }
775