Annotation of sys/arch/vax/vax/bus_dma.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: bus_dma.c,v 1.16 2005/11/08 15:05:56 martin Exp $ */
! 2: /* $NetBSD: bus_dma.c,v 1.5 1999/11/13 00:32:20 thorpej Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1996, 1997, 1998 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
! 10: * NASA Ames Research Center.
! 11: *
! 12: * Redistribution and use in source and binary forms, with or without
! 13: * modification, are permitted provided that the following conditions
! 14: * are met:
! 15: * 1. Redistributions of source code must retain the above copyright
! 16: * notice, this list of conditions and the following disclaimer.
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in the
! 19: * documentation and/or other materials provided with the distribution.
! 20: * 3. All advertising materials mentioning features or use of this software
! 21: * must display the following acknowledgement:
! 22: * This product includes software developed by the NetBSD
! 23: * Foundation, Inc. and its contributors.
! 24: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 25: * contributors may be used to endorse or promote products derived
! 26: * from this software without specific prior written permission.
! 27: *
! 28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 38: * POSSIBILITY OF SUCH DAMAGE.
! 39: */
! 40: /*
! 41: * bus_dma routines for vax. File copied from arm32/bus_dma.c.
! 42: * NetBSD: bus_dma.c,v 1.11 1998/09/21 22:53:35 thorpej Exp
! 43: */
! 44:
! 45: #include <sys/param.h>
! 46: #include <sys/systm.h>
! 47: #include <sys/kernel.h>
! 48: #include <sys/proc.h>
! 49: #include <sys/buf.h>
! 50: #include <sys/reboot.h>
! 51: #include <sys/conf.h>
! 52: #include <sys/file.h>
! 53: #include <sys/malloc.h>
! 54: #include <sys/mbuf.h>
! 55: #include <sys/vnode.h>
! 56: #include <sys/device.h>
! 57:
! 58: #include <uvm/uvm_extern.h>
! 59:
! 60: #define _VAX_BUS_DMA_PRIVATE
! 61: #include <machine/bus.h>
! 62:
! 63: #include <machine/ka43.h>
! 64: #include <machine/sid.h>
! 65:
! 66: extern vaddr_t avail_start, avail_end, virtual_avail;
! 67:
! 68: int _bus_dmamap_load_buffer(bus_dma_tag_t, bus_dmamap_t, void *,
! 69: bus_size_t, struct proc *, int, paddr_t *, int *, int);
! 70: int _bus_dma_inrange(bus_dma_segment_t *, int, bus_addr_t);
! 71: int _bus_dmamem_alloc_range(bus_dma_tag_t, bus_size_t, bus_size_t,
! 72: bus_size_t, bus_dma_segment_t*, int, int *, int, vaddr_t, vaddr_t);
! 73: /*
! 74: * Common function for DMA map creation. May be called by bus-specific
! 75: * DMA map creation functions.
! 76: */
! 77: int
! 78: _bus_dmamap_create(t, size, nsegments, maxsegsz, boundary, flags, dmamp)
! 79: bus_dma_tag_t t;
! 80: bus_size_t size;
! 81: int nsegments;
! 82: bus_size_t maxsegsz;
! 83: bus_size_t boundary;
! 84: int flags;
! 85: bus_dmamap_t *dmamp;
! 86: {
! 87: struct vax_bus_dmamap *map;
! 88: void *mapstore;
! 89: size_t mapsize;
! 90:
! 91: #ifdef DEBUG_DMA
! 92: printf("dmamap_create: t=%p size=%lx nseg=%x msegsz=%lx boundary=%lx flags=%x\n",
! 93: t, size, nsegments, maxsegsz, boundary, flags);
! 94: #endif /* DEBUG_DMA */
! 95:
! 96: /*
! 97: * Allocate and initialize the DMA map. The end of the map
! 98: * is a variable-sized array of segments, so we allocate enough
! 99: * room for them in one shot.
! 100: *
! 101: * Note we don't preserve the WAITOK or NOWAIT flags. Preservation
! 102: * of ALLOCNOW notifies others that we've reserved these resources,
! 103: * and they are not to be freed.
! 104: *
! 105: * The bus_dmamap_t includes one bus_dma_segment_t, hence
! 106: * the (nsegments - 1).
! 107: */
! 108: mapsize = sizeof(struct vax_bus_dmamap) +
! 109: (sizeof(bus_dma_segment_t) * (nsegments - 1));
! 110: if ((mapstore = malloc(mapsize, M_DEVBUF,
! 111: (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL)
! 112: return (ENOMEM);
! 113:
! 114: bzero(mapstore, mapsize);
! 115: map = (struct vax_bus_dmamap *)mapstore;
! 116: map->_dm_size = size;
! 117: map->_dm_segcnt = nsegments;
! 118: map->_dm_maxsegsz = maxsegsz;
! 119: map->_dm_boundary = boundary;
! 120: map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT);
! 121: map->dm_mapsize = 0; /* no valid mappings */
! 122: map->dm_nsegs = 0;
! 123:
! 124: *dmamp = map;
! 125: #ifdef DEBUG_DMA
! 126: printf("dmamap_create:map=%p\n", map);
! 127: #endif /* DEBUG_DMA */
! 128: return (0);
! 129: }
! 130:
! 131: /*
! 132: * Common function for DMA map destruction. May be called by bus-specific
! 133: * DMA map destruction functions.
! 134: */
! 135: void
! 136: _bus_dmamap_destroy(t, map)
! 137: bus_dma_tag_t t;
! 138: bus_dmamap_t map;
! 139: {
! 140:
! 141: #ifdef DEBUG_DMA
! 142: printf("dmamap_destroy: t=%p map=%p\n", t, map);
! 143: #endif /* DEBUG_DMA */
! 144: #ifdef DIAGNOSTIC
! 145: if (map->dm_nsegs > 0)
! 146: printf("bus_dmamap_destroy() called for map with valid mappings\n");
! 147: #endif /* DIAGNOSTIC */
! 148: free(map, M_DEVBUF);
! 149: }
! 150:
! 151: /*
! 152: * Common function for loading a DMA map with a linear buffer. May
! 153: * be called by bus-specific DMA map load functions.
! 154: */
! 155: int
! 156: _bus_dmamap_load(t, map, buf, buflen, p, flags)
! 157: bus_dma_tag_t t;
! 158: bus_dmamap_t map;
! 159: void *buf;
! 160: bus_size_t buflen;
! 161: struct proc *p;
! 162: int flags;
! 163: {
! 164: paddr_t lastaddr;
! 165: int seg, error;
! 166:
! 167: #ifdef DEBUG_DMA
! 168: printf("dmamap_load: t=%p map=%p buf=%p len=%lx p=%p f=%d\n",
! 169: t, map, buf, buflen, p, flags);
! 170: #endif /* DEBUG_DMA */
! 171:
! 172: /*
! 173: * Make sure that on error condition we return "no valid mappings".
! 174: */
! 175: map->dm_mapsize = 0;
! 176: map->dm_nsegs = 0;
! 177:
! 178: if (buflen > map->_dm_size)
! 179: return (EINVAL);
! 180:
! 181: seg = 0;
! 182: error = _bus_dmamap_load_buffer(t, map, buf, buflen, p, flags,
! 183: &lastaddr, &seg, 1);
! 184: if (error == 0) {
! 185: map->dm_mapsize = buflen;
! 186: map->dm_nsegs = seg + 1;
! 187: }
! 188: #ifdef DEBUG_DMA
! 189: printf("dmamap_load: error=%d\n", error);
! 190: #endif /* DEBUG_DMA */
! 191: return (error);
! 192: }
! 193:
! 194: /*
! 195: * Like _bus_dmamap_load(), but for mbufs.
! 196: */
! 197: int
! 198: _bus_dmamap_load_mbuf(t, map, m0, flags)
! 199: bus_dma_tag_t t;
! 200: bus_dmamap_t map;
! 201: struct mbuf *m0;
! 202: int flags;
! 203: {
! 204: paddr_t lastaddr;
! 205: int seg, error, first;
! 206: struct mbuf *m;
! 207:
! 208: #ifdef DEBUG_DMA
! 209: printf("dmamap_load_mbuf: t=%p map=%p m0=%p f=%d\n",
! 210: t, map, m0, flags);
! 211: #endif /* DEBUG_DMA */
! 212:
! 213: /*
! 214: * Make sure that on error condition we return "no valid mappings."
! 215: */
! 216: map->dm_mapsize = 0;
! 217: map->dm_nsegs = 0;
! 218:
! 219: #ifdef DIAGNOSTIC
! 220: if ((m0->m_flags & M_PKTHDR) == 0)
! 221: panic("_bus_dmamap_load_mbuf: no packet header");
! 222: #endif /* DIAGNOSTIC */
! 223:
! 224: if (m0->m_pkthdr.len > map->_dm_size)
! 225: return (EINVAL);
! 226:
! 227: first = 1;
! 228: seg = 0;
! 229: error = 0;
! 230: for (m = m0; m != NULL && error == 0; m = m->m_next) {
! 231: if (m->m_len == 0)
! 232: continue;
! 233: error = _bus_dmamap_load_buffer(t, map, m->m_data, m->m_len,
! 234: NULL, flags, &lastaddr, &seg, first);
! 235: first = 0;
! 236: }
! 237: if (error == 0) {
! 238: map->dm_mapsize = m0->m_pkthdr.len;
! 239: map->dm_nsegs = seg + 1;
! 240: }
! 241: #ifdef DEBUG_DMA
! 242: printf("dmamap_load_mbuf: error=%d\n", error);
! 243: #endif /* DEBUG_DMA */
! 244: return (error);
! 245: }
! 246:
! 247: /*
! 248: * Like _bus_dmamap_load(), but for uios.
! 249: */
! 250: int
! 251: _bus_dmamap_load_uio(t, map, uio, flags)
! 252: bus_dma_tag_t t;
! 253: bus_dmamap_t map;
! 254: struct uio *uio;
! 255: int flags;
! 256: {
! 257: paddr_t lastaddr;
! 258: int seg, i, error, first;
! 259: bus_size_t minlen, resid;
! 260: struct proc *p = NULL;
! 261: struct iovec *iov;
! 262: caddr_t addr;
! 263:
! 264: /*
! 265: * Make sure that on error condition we return "no valid mappings."
! 266: */
! 267: map->dm_mapsize = 0;
! 268: map->dm_nsegs = 0;
! 269:
! 270: resid = uio->uio_resid;
! 271: iov = uio->uio_iov;
! 272:
! 273: if (uio->uio_segflg == UIO_USERSPACE) {
! 274: p = uio->uio_procp;
! 275: #ifdef DIAGNOSTIC
! 276: if (p == NULL)
! 277: panic("_bus_dmamap_load_uio: USERSPACE but no proc");
! 278: #endif
! 279: }
! 280:
! 281: first = 1;
! 282: seg = 0;
! 283: error = 0;
! 284: for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) {
! 285: /*
! 286: * Now at the first iovec to load. Load each iovec
! 287: * until we have exhausted the residual count.
! 288: */
! 289: minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len;
! 290: addr = (caddr_t)iov[i].iov_base;
! 291:
! 292: error = _bus_dmamap_load_buffer(t, map, addr, minlen,
! 293: p, flags, &lastaddr, &seg, first);
! 294: first = 0;
! 295:
! 296: resid -= minlen;
! 297: }
! 298: if (error == 0) {
! 299: map->dm_mapsize = uio->uio_resid;
! 300: map->dm_nsegs = seg + 1;
! 301: }
! 302: return (error);
! 303: }
! 304:
! 305: /*
! 306: * Like _bus_dmamap_load(), but for raw memory allocated with
! 307: * bus_dmamem_alloc().
! 308: */
! 309: int
! 310: _bus_dmamap_load_raw(t, map, segs, nsegs, size, flags)
! 311: bus_dma_tag_t t;
! 312: bus_dmamap_t map;
! 313: bus_dma_segment_t *segs;
! 314: int nsegs;
! 315: bus_size_t size;
! 316: int flags;
! 317: {
! 318:
! 319: panic("_bus_dmamap_load_raw: not implemented");
! 320: }
! 321:
! 322: /*
! 323: * Common function for unloading a DMA map. May be called by
! 324: * bus-specific DMA map unload functions.
! 325: */
! 326: void
! 327: _bus_dmamap_unload(t, map)
! 328: bus_dma_tag_t t;
! 329: bus_dmamap_t map;
! 330: {
! 331:
! 332: #ifdef DEBUG_DMA
! 333: printf("dmamap_unload: t=%p map=%p\n", t, map);
! 334: #endif /* DEBUG_DMA */
! 335:
! 336: /*
! 337: * No resources to free; just mark the mappings as
! 338: * invalid.
! 339: */
! 340: map->dm_mapsize = 0;
! 341: map->dm_nsegs = 0;
! 342: }
! 343:
! 344: /*
! 345: * Common function for DMA map synchronization. May be called
! 346: * by bus-specific DMA map synchronization functions.
! 347: */
! 348: void
! 349: _bus_dmamap_sync(t, map, offset, len, ops)
! 350: bus_dma_tag_t t;
! 351: bus_dmamap_t map;
! 352: bus_addr_t offset;
! 353: bus_size_t len;
! 354: int ops;
! 355: {
! 356: #ifdef DEBUG_DMA
! 357: printf("dmamap_sync: t=%p map=%p offset=%lx len=%lx ops=%x\n",
! 358: t, map, offset, len, ops);
! 359: #endif /* DEBUG_DMA */
! 360: /*
! 361: * A vax only has snoop-cache, so this routine is a no-op.
! 362: */
! 363: return;
! 364: }
! 365:
! 366: /*
! 367: * Common function for DMA-safe memory allocation. May be called
! 368: * by bus-specific DMA memory allocation functions.
! 369: */
! 370:
! 371: int
! 372: _bus_dmamem_alloc(t, size, alignment, boundary, segs, nsegs, rsegs, flags)
! 373: bus_dma_tag_t t;
! 374: bus_size_t size, alignment, boundary;
! 375: bus_dma_segment_t *segs;
! 376: int nsegs;
! 377: int *rsegs;
! 378: int flags;
! 379: {
! 380: int error;
! 381:
! 382: error = (_bus_dmamem_alloc_range(t, size, alignment, boundary,
! 383: segs, nsegs, rsegs, flags, round_page(avail_start),
! 384: trunc_page(avail_end)));
! 385: return(error);
! 386: }
! 387:
! 388: /*
! 389: * Common function for freeing DMA-safe memory. May be called by
! 390: * bus-specific DMA memory free functions.
! 391: */
! 392: void
! 393: _bus_dmamem_free(t, segs, nsegs)
! 394: bus_dma_tag_t t;
! 395: bus_dma_segment_t *segs;
! 396: int nsegs;
! 397: {
! 398: struct vm_page *m;
! 399: bus_addr_t addr;
! 400: struct pglist mlist;
! 401: int curseg;
! 402:
! 403: #ifdef DEBUG_DMA
! 404: printf("dmamem_free: t=%p segs=%p nsegs=%x\n", t, segs, nsegs);
! 405: #endif /* DEBUG_DMA */
! 406:
! 407: /*
! 408: * Build a list of pages to free back to the VM system.
! 409: */
! 410: TAILQ_INIT(&mlist);
! 411: for (curseg = 0; curseg < nsegs; curseg++) {
! 412: for (addr = segs[curseg].ds_addr;
! 413: addr < (segs[curseg].ds_addr + segs[curseg].ds_len);
! 414: addr += PAGE_SIZE) {
! 415: m = PHYS_TO_VM_PAGE(addr);
! 416: TAILQ_INSERT_TAIL(&mlist, m, pageq);
! 417: }
! 418: }
! 419: uvm_pglistfree(&mlist);
! 420: }
! 421:
! 422: /*
! 423: * Common function for mapping DMA-safe memory. May be called by
! 424: * bus-specific DMA memory map functions.
! 425: */
! 426: int
! 427: _bus_dmamem_map(t, segs, nsegs, size, kvap, flags)
! 428: bus_dma_tag_t t;
! 429: bus_dma_segment_t *segs;
! 430: int nsegs;
! 431: size_t size;
! 432: caddr_t *kvap;
! 433: int flags;
! 434: {
! 435: vaddr_t va;
! 436: bus_addr_t addr;
! 437: int curseg;
! 438:
! 439: /*
! 440: * Special case (but common):
! 441: * If there is only one physical segment then the already-mapped
! 442: * virtual address is returned, since all physical memory is already
! 443: * in the beginning of kernel virtual memory.
! 444: */
! 445: if (nsegs == 1) {
! 446: *kvap = (caddr_t)(segs[0].ds_addr | KERNBASE);
! 447: /*
! 448: * KA43 (3100/m76) must have its DMA-safe memory accessed
! 449: * through DIAGMEM. Remap it here.
! 450: */
! 451: if (vax_boardtype == VAX_BTYP_43) {
! 452: pmap_map((vaddr_t)*kvap, segs[0].ds_addr|KA43_DIAGMEM,
! 453: (segs[0].ds_addr|KA43_DIAGMEM) + size,
! 454: VM_PROT_READ|VM_PROT_WRITE);
! 455: }
! 456: return 0;
! 457: }
! 458: size = round_page(size);
! 459: va = uvm_km_valloc(kernel_map, size);
! 460:
! 461: if (va == 0)
! 462: return (ENOMEM);
! 463:
! 464: *kvap = (caddr_t)va;
! 465:
! 466: for (curseg = 0; curseg < nsegs; curseg++) {
! 467: for (addr = segs[curseg].ds_addr;
! 468: addr < (segs[curseg].ds_addr + segs[curseg].ds_len);
! 469: addr += NBPG, va += NBPG, size -= NBPG) {
! 470: if (size == 0)
! 471: panic("_bus_dmamem_map: size botch");
! 472: if (vax_boardtype == VAX_BTYP_43)
! 473: addr |= KA43_DIAGMEM;
! 474: pmap_enter(pmap_kernel(), va, addr,
! 475: VM_PROT_READ | VM_PROT_WRITE,
! 476: VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED);
! 477: }
! 478: }
! 479: pmap_update(pmap_kernel());
! 480: return (0);
! 481: }
! 482:
! 483: /*
! 484: * Common function for unmapping DMA-safe memory. May be called by
! 485: * bus-specific DMA memory unmapping functions.
! 486: */
! 487: void
! 488: _bus_dmamem_unmap(t, kva, size)
! 489: bus_dma_tag_t t;
! 490: caddr_t kva;
! 491: size_t size;
! 492: {
! 493:
! 494: #ifdef DEBUG_DMA
! 495: printf("dmamem_unmap: t=%p kva=%p size=%x\n", t, kva, size);
! 496: #endif /* DEBUG_DMA */
! 497: #ifdef DIAGNOSTIC
! 498: if ((u_long)kva & PGOFSET)
! 499: panic("_bus_dmamem_unmap");
! 500: #endif /* DIAGNOSTIC */
! 501:
! 502: /* Avoid free'ing if not mapped */
! 503: if (kva >= (caddr_t)virtual_avail)
! 504: uvm_km_free(kernel_map, (vaddr_t)kva, round_page(size));
! 505: }
! 506:
! 507: /*
! 508: * Common functin for mmap(2)'ing DMA-safe memory. May be called by
! 509: * bus-specific DMA mmap(2)'ing functions.
! 510: */
! 511: paddr_t
! 512: _bus_dmamem_mmap(t, segs, nsegs, off, prot, flags)
! 513: bus_dma_tag_t t;
! 514: bus_dma_segment_t *segs;
! 515: int nsegs;
! 516: off_t off;
! 517: int prot, flags;
! 518: {
! 519: int i;
! 520:
! 521: for (i = 0; i < nsegs; i++) {
! 522: #ifdef DIAGNOSTIC
! 523: if (off & PGOFSET)
! 524: panic("_bus_dmamem_mmap: offset unaligned");
! 525: if (segs[i].ds_addr & PGOFSET)
! 526: panic("_bus_dmamem_mmap: segment unaligned");
! 527: if (segs[i].ds_len & PGOFSET)
! 528: panic("_bus_dmamem_mmap: segment size not multiple"
! 529: " of page size");
! 530: #endif /* DIAGNOSTIC */
! 531: if (off >= segs[i].ds_len) {
! 532: off -= segs[i].ds_len;
! 533: continue;
! 534: }
! 535:
! 536: return (atop(segs[i].ds_addr + off));
! 537: }
! 538:
! 539: /* Page not found. */
! 540: return (-1);
! 541: }
! 542:
! 543: /**********************************************************************
! 544: * DMA utility functions
! 545: **********************************************************************/
! 546:
! 547: /*
! 548: * Utility function to load a linear buffer. lastaddrp holds state
! 549: * between invocations (for multiple-buffer loads). segp contains
! 550: * the starting segment on entrance, and the ending segment on exit.
! 551: * first indicates if this is the first invocation of this function.
! 552: */
! 553: int
! 554: _bus_dmamap_load_buffer(t, map, buf, buflen, p, flags, lastaddrp, segp, first)
! 555: bus_dma_tag_t t;
! 556: bus_dmamap_t map;
! 557: void *buf;
! 558: bus_size_t buflen;
! 559: struct proc *p;
! 560: int flags;
! 561: paddr_t *lastaddrp;
! 562: int *segp;
! 563: int first;
! 564: {
! 565: bus_size_t sgsize;
! 566: bus_addr_t curaddr, lastaddr, baddr, bmask;
! 567: vaddr_t vaddr = (vaddr_t)buf;
! 568: int seg;
! 569: pmap_t pmap;
! 570:
! 571: #ifdef DEBUG_DMA
! 572: printf("_bus_dmamem_load_buffer(buf=%p, len=%lx, flags=%d, 1st=%d)\n",
! 573: buf, buflen, flags, first);
! 574: #endif /* DEBUG_DMA */
! 575:
! 576: if (p != NULL)
! 577: pmap = p->p_vmspace->vm_map.pmap;
! 578: else
! 579: pmap = pmap_kernel();
! 580:
! 581: lastaddr = *lastaddrp;
! 582: bmask = ~(map->_dm_boundary - 1);
! 583:
! 584: for (seg = *segp; buflen > 0; ) {
! 585: /*
! 586: * Get the physical address for this segment.
! 587: */
! 588: pmap_extract(pmap, (vaddr_t)vaddr, &curaddr);
! 589: #if 0
! 590: /*
! 591: * Make sure we're in an allowed DMA range.
! 592: */
! 593: if (t->_ranges != NULL &&
! 594: _bus_dma_inrange(t->_ranges, t->_nranges, curaddr) == 0)
! 595: return (EINVAL);
! 596: #endif
! 597:
! 598: /*
! 599: * Compute the segment size, and adjust counts.
! 600: */
! 601: sgsize = NBPG - ((u_long)vaddr & PGOFSET);
! 602: if (buflen < sgsize)
! 603: sgsize = buflen;
! 604:
! 605: /*
! 606: * Make sure we don't cross any boundaries.
! 607: */
! 608: if (map->_dm_boundary > 0) {
! 609: baddr = (curaddr + map->_dm_boundary) & bmask;
! 610: if (sgsize > (baddr - curaddr))
! 611: sgsize = (baddr - curaddr);
! 612: }
! 613:
! 614: /*
! 615: * Insert chunk into a segment, coalescing with
! 616: * previous segment if possible.
! 617: */
! 618: if (first) {
! 619: map->dm_segs[seg].ds_addr = curaddr;
! 620: map->dm_segs[seg].ds_len = sgsize;
! 621: first = 0;
! 622: } else {
! 623: if (curaddr == lastaddr &&
! 624: (map->dm_segs[seg].ds_len + sgsize) <=
! 625: map->_dm_maxsegsz &&
! 626: (map->_dm_boundary == 0 ||
! 627: (map->dm_segs[seg].ds_addr & bmask) ==
! 628: (curaddr & bmask)))
! 629: map->dm_segs[seg].ds_len += sgsize;
! 630: else {
! 631: if (++seg >= map->_dm_segcnt)
! 632: break;
! 633: map->dm_segs[seg].ds_addr = curaddr;
! 634: map->dm_segs[seg].ds_len = sgsize;
! 635: }
! 636: }
! 637:
! 638: lastaddr = curaddr + sgsize;
! 639: vaddr += sgsize;
! 640: buflen -= sgsize;
! 641: }
! 642:
! 643: *segp = seg;
! 644: *lastaddrp = lastaddr;
! 645:
! 646: /*
! 647: * Did we fit?
! 648: */
! 649: if (buflen != 0)
! 650: return (EFBIG); /* XXX better return value here? */
! 651: return (0);
! 652: }
! 653:
! 654: /*
! 655: * Check to see if the specified page is in an allowed DMA range.
! 656: */
! 657: int
! 658: _bus_dma_inrange(ranges, nranges, curaddr)
! 659: bus_dma_segment_t *ranges;
! 660: int nranges;
! 661: bus_addr_t curaddr;
! 662: {
! 663: bus_dma_segment_t *ds;
! 664: int i;
! 665:
! 666: for (i = 0, ds = ranges; i < nranges; i++, ds++) {
! 667: if (curaddr >= ds->ds_addr &&
! 668: round_page(curaddr) <= (ds->ds_addr + ds->ds_len))
! 669: return (1);
! 670: }
! 671:
! 672: return (0);
! 673: }
! 674:
! 675: /*
! 676: * Allocate physical memory from the given physical address range.
! 677: * Called by DMA-safe memory allocation methods.
! 678: */
! 679: int
! 680: _bus_dmamem_alloc_range(t, size, alignment, boundary, segs, nsegs, rsegs,
! 681: flags, low, high)
! 682: bus_dma_tag_t t;
! 683: bus_size_t size, alignment, boundary;
! 684: bus_dma_segment_t *segs;
! 685: int nsegs;
! 686: int *rsegs;
! 687: int flags;
! 688: vaddr_t low;
! 689: vaddr_t high;
! 690: {
! 691: paddr_t curaddr, lastaddr;
! 692: struct vm_page *m;
! 693: struct pglist mlist;
! 694: int curseg, error;
! 695:
! 696: #ifdef DEBUG_DMA
! 697: printf("alloc_range: t=%p size=%lx align=%lx boundary=%lx segs=%p nsegs=%x rsegs=%p flags=%x lo=%lx hi=%lx\n",
! 698: t, size, alignment, boundary, segs, nsegs, rsegs, flags, low, high);
! 699: #endif /* DEBUG_DMA */
! 700:
! 701: /* Always round the size. */
! 702: size = round_page(size);
! 703:
! 704: /*
! 705: * Allocate pages from the VM system.
! 706: */
! 707: TAILQ_INIT(&mlist);
! 708: error = uvm_pglistalloc(size, low, high, alignment, boundary,
! 709: &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0);
! 710: if (error)
! 711: return (error);
! 712:
! 713: /*
! 714: * Compute the location, size, and number of segments actually
! 715: * returned by the VM code.
! 716: */
! 717: m = TAILQ_FIRST(&mlist);
! 718: curseg = 0;
! 719: lastaddr = segs[curseg].ds_addr = VM_PAGE_TO_PHYS(m);
! 720: segs[curseg].ds_len = PAGE_SIZE;
! 721: #ifdef DEBUG_DMA
! 722: printf("alloc: page %lx\n", lastaddr);
! 723: #endif /* DEBUG_DMA */
! 724: m = TAILQ_NEXT(m, pageq);
! 725:
! 726: for (; m != TAILQ_END(&mlist); m = TAILQ_NEXT(m, pageq)) {
! 727: curaddr = VM_PAGE_TO_PHYS(m);
! 728: #ifdef DIAGNOSTIC
! 729: if (curaddr < low || curaddr >= high) {
! 730: printf("vm_page_alloc_memory returned non-sensical"
! 731: " address 0x%lx\n", curaddr);
! 732: panic("_bus_dmamem_alloc_range");
! 733: }
! 734: #endif /* DIAGNOSTIC */
! 735: #ifdef DEBUG_DMA
! 736: printf("alloc: page %lx\n", curaddr);
! 737: #endif /* DEBUG_DMA */
! 738: if (curaddr == (lastaddr + PAGE_SIZE))
! 739: segs[curseg].ds_len += PAGE_SIZE;
! 740: else {
! 741: curseg++;
! 742: segs[curseg].ds_addr = curaddr;
! 743: segs[curseg].ds_len = PAGE_SIZE;
! 744: }
! 745: lastaddr = curaddr;
! 746: }
! 747:
! 748: *rsegs = curseg + 1;
! 749:
! 750: return (0);
! 751: }
! 752:
! 753: /*
! 754: * "generic" DMA struct, nothing special.
! 755: */
! 756: struct vax_bus_dma_tag vax_bus_dma_tag = {
! 757: NULL,
! 758: 0,
! 759: 0,
! 760: 0,
! 761: 0,
! 762: 0,
! 763: _bus_dmamap_create,
! 764: _bus_dmamap_destroy,
! 765: _bus_dmamap_load,
! 766: _bus_dmamap_load_mbuf,
! 767: _bus_dmamap_load_uio,
! 768: _bus_dmamap_load_raw,
! 769: _bus_dmamap_unload,
! 770: _bus_dmamap_sync,
! 771: _bus_dmamem_alloc,
! 772: _bus_dmamem_free,
! 773: _bus_dmamem_map,
! 774: _bus_dmamem_unmap,
! 775: _bus_dmamem_mmap,
! 776: };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to bus_dma.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / vax