1 /* $NetBSD: bus_dma.c,v 1.9 2002/06/02 14:44:43 drochner Exp $ */ 2 3 /*- 4 * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 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/param.h> 41 #include <sys/systm.h> 42 #include <sys/mbuf.h> 43 #include <sys/device.h> 44 #include <sys/proc.h> 45 46 #include <uvm/uvm_extern.h> 47 48 #define _MIPSCO_BUS_DMA_PRIVATE 49 #include <machine/bus.h> 50 51 #include <mips/cache.h> 52 53 paddr_t kvtophys __P((vaddr_t)); /* XXX */ 54 55 static int _bus_dmamap_load_buffer __P((bus_dma_tag_t, bus_dmamap_t, 56 void *, bus_size_t, struct proc *, int, paddr_t *, 57 int *, int)); 58 59 extern paddr_t avail_start, avail_end; /* from pmap.c */ 60 61 void 62 _bus_dma_tag_init(t) 63 bus_dma_tag_t t; 64 { 65 t->dma_offset = 0; 66 67 t->_dmamap_create = _bus_dmamap_create; 68 t->_dmamap_destroy = _bus_dmamap_destroy; 69 t->_dmamap_load = _bus_dmamap_load; 70 t->_dmamap_load_mbuf = _bus_dmamap_load_mbuf; 71 t->_dmamap_load_uio = _bus_dmamap_load_uio; 72 t->_dmamap_load_raw = _bus_dmamap_load_raw; 73 t->_dmamap_unload = _bus_dmamap_unload; 74 t->_dmamap_sync = _bus_dmamap_sync; 75 t->_dmamem_alloc = _bus_dmamem_alloc; 76 t->_dmamem_free = _bus_dmamem_free; 77 t->_dmamem_map = _bus_dmamem_map; 78 t->_dmamem_unmap = _bus_dmamem_unmap; 79 t->_dmamem_mmap = _bus_dmamem_mmap; 80 } 81 82 /* 83 * Common function for DMA map creation. May be called by bus-specific 84 * DMA map creation functions. 85 */ 86 int 87 _bus_dmamap_create(t, size, nsegments, maxsegsz, boundary, flags, dmamp) 88 bus_dma_tag_t t; 89 bus_size_t size; 90 int nsegments; 91 bus_size_t maxsegsz; 92 bus_size_t boundary; 93 int flags; 94 bus_dmamap_t *dmamp; 95 { 96 struct mipsco_bus_dmamap *map; 97 void *mapstore; 98 size_t mapsize; 99 100 /* 101 * Allocate and initialize the DMA map. The end of the map 102 * is a variable-sized array of segments, so we allocate enough 103 * room for them in one shot. 104 * 105 * Note we don't preserve the WAITOK or NOWAIT flags. Preservation 106 * of ALLOCNOW notifies others that we've reserved these resources, 107 * and they are not to be freed. 108 * 109 * The bus_dmamap_t includes one bus_dma_segment_t, hence 110 * the (nsegments - 1). 111 */ 112 mapsize = sizeof(struct mipsco_bus_dmamap) + 113 (sizeof(bus_dma_segment_t) * (nsegments - 1)); 114 if ((mapstore = malloc(mapsize, M_DMAMAP, 115 (flags & BUS_DMA_NOWAIT) ? M_NOWAIT : M_WAITOK)) == NULL) 116 return (ENOMEM); 117 118 memset(mapstore, 0, mapsize); 119 map = (struct mipsco_bus_dmamap *)mapstore; 120 map->_dm_size = size; 121 map->_dm_segcnt = nsegments; 122 map->_dm_maxsegsz = maxsegsz; 123 map->_dm_boundary = boundary; 124 map->_dm_flags = flags & ~(BUS_DMA_WAITOK|BUS_DMA_NOWAIT); 125 map->dm_mapsize = 0; /* no valid mappings */ 126 map->dm_nsegs = 0; 127 128 *dmamp = map; 129 return (0); 130 } 131 132 /* 133 * Common function for DMA map destruction. May be called by bus-specific 134 * DMA map destruction functions. 135 */ 136 void 137 _bus_dmamap_destroy(t, map) 138 bus_dma_tag_t t; 139 bus_dmamap_t map; 140 { 141 142 free(map, M_DMAMAP); 143 } 144 145 /* 146 * Utility function to load a linear buffer. lastaddrp holds state 147 * between invocations (for multiple-buffer loads). segp contains 148 * the starting segment on entrance, and the ending segment on exit. 149 * first indicates if this is the first invocation of this function. 150 */ 151 static int 152 _bus_dmamap_load_buffer(t, map, buf, buflen, p, flags, lastaddrp, segp, first) 153 bus_dma_tag_t t; 154 bus_dmamap_t map; 155 void *buf; 156 bus_size_t buflen; 157 struct proc *p; 158 int flags; 159 paddr_t *lastaddrp; 160 int *segp; 161 int first; 162 { 163 bus_size_t sgsize; 164 bus_addr_t baddr, bmask; 165 paddr_t curaddr, lastaddr; 166 vaddr_t vaddr = (vaddr_t)buf; 167 int seg; 168 169 lastaddr = *lastaddrp; 170 bmask = ~(map->_dm_boundary - 1); 171 172 for (seg = *segp; buflen > 0 ; ) { 173 /* 174 * Get the physical address for this segment. 175 */ 176 if (p != NULL) { 177 (void) pmap_extract(p->p_vmspace->vm_map.pmap, 178 vaddr, &curaddr); 179 } else 180 curaddr = kvtophys(vaddr); 181 182 /* 183 * Compute the segment size, and adjust counts. 184 */ 185 sgsize = NBPG - ((u_long)vaddr & PGOFSET); 186 if (buflen < sgsize) 187 sgsize = buflen; 188 189 /* 190 * Make sure we don't cross any boundaries. 191 */ 192 if (map->_dm_boundary > 0) { 193 baddr = (curaddr + map->_dm_boundary) & bmask; 194 if (sgsize > (baddr - curaddr)) 195 sgsize = (baddr - curaddr); 196 } 197 198 /* 199 * Insert chunk into a segment, coalescing with 200 * the previous segment if possible. 201 */ 202 if (first) { 203 map->dm_segs[seg].ds_addr = curaddr + t->dma_offset; 204 map->dm_segs[seg].ds_len = sgsize; 205 map->dm_segs[seg]._ds_vaddr = vaddr; 206 map->dm_segs[seg]._ds_paddr = curaddr; 207 first = 0; 208 } else { 209 if (curaddr == lastaddr && 210 (map->dm_segs[seg].ds_len + sgsize) <= 211 map->_dm_maxsegsz && 212 (map->_dm_boundary == 0 || 213 (map->dm_segs[seg]._ds_paddr & bmask) == 214 (curaddr & bmask))) 215 map->dm_segs[seg].ds_len += sgsize; 216 else { 217 if (++seg >= map->_dm_segcnt) 218 break; 219 map->dm_segs[seg].ds_addr = 220 curaddr + t->dma_offset; 221 map->dm_segs[seg].ds_len = sgsize; 222 map->dm_segs[seg]._ds_vaddr = vaddr; 223 map->dm_segs[seg]._ds_paddr = curaddr; 224 } 225 } 226 227 lastaddr = curaddr + sgsize; 228 vaddr += sgsize; 229 buflen -= sgsize; 230 } 231 232 *segp = seg; 233 *lastaddrp = lastaddr; 234 235 /* 236 * Did we fit? 237 */ 238 if (buflen != 0) 239 return (EFBIG); /* XXX better return value here? */ 240 241 return (0); 242 } 243 244 /* 245 * Common function for loading a direct-mapped DMA map with a linear 246 * buffer. 247 */ 248 int 249 _bus_dmamap_load(t, map, buf, buflen, p, flags) 250 bus_dma_tag_t t; 251 bus_dmamap_t map; 252 void *buf; 253 bus_size_t buflen; 254 struct proc *p; 255 int flags; 256 { 257 paddr_t lastaddr; 258 int seg, error; 259 260 /* 261 * Make sure that on error condition we return "no valid mappings". 262 */ 263 map->dm_mapsize = 0; 264 map->dm_nsegs = 0; 265 266 if (buflen > map->_dm_size) 267 return (EINVAL); 268 269 seg = 0; 270 error = _bus_dmamap_load_buffer(t, map, buf, buflen, 271 p, flags, &lastaddr, &seg, 1); 272 if (error == 0) { 273 map->dm_mapsize = buflen; 274 map->dm_nsegs = seg + 1; 275 276 /* 277 * For linear buffers, we support marking the mapping 278 * as COHERENT. 279 * 280 * XXX Check TLB entries for cache-inhibit bits? 281 */ 282 if (buf >= (void *)MIPS_KSEG1_START && 283 buf < (void *)MIPS_KSEG2_START) 284 map->_dm_flags |= MIPSCO_DMAMAP_COHERENT; 285 } 286 return (error); 287 } 288 289 /* 290 * Like _bus_dmamap_load(), but for mbufs. 291 */ 292 int 293 _bus_dmamap_load_mbuf(t, map, m0, flags) 294 bus_dma_tag_t t; 295 bus_dmamap_t map; 296 struct mbuf *m0; 297 int flags; 298 { 299 paddr_t lastaddr; 300 int seg, error, first; 301 struct mbuf *m; 302 303 /* 304 * Make sure that on error condition we return "no valid mappings." 305 */ 306 map->dm_mapsize = 0; 307 map->dm_nsegs = 0; 308 309 #ifdef DIAGNOSTIC 310 if ((m0->m_flags & M_PKTHDR) == 0) 311 panic("_bus_dmamap_load_mbuf: no packet header"); 312 #endif 313 314 if (m0->m_pkthdr.len > map->_dm_size) 315 return (EINVAL); 316 317 first = 1; 318 seg = 0; 319 error = 0; 320 for (m = m0; m != NULL && error == 0; m = m->m_next) { 321 error = _bus_dmamap_load_buffer(t, map, 322 m->m_data, m->m_len, NULL, flags, &lastaddr, &seg, first); 323 first = 0; 324 } 325 if (error == 0) { 326 map->dm_mapsize = m0->m_pkthdr.len; 327 map->dm_nsegs = seg + 1; 328 } 329 return (error); 330 } 331 332 /* 333 * Like _bus_dmamap_load(), but for uios. 334 */ 335 int 336 _bus_dmamap_load_uio(t, map, uio, flags) 337 bus_dma_tag_t t; 338 bus_dmamap_t map; 339 struct uio *uio; 340 int flags; 341 { 342 paddr_t lastaddr; 343 int seg, i, error, first; 344 bus_size_t minlen, resid; 345 struct proc *p = NULL; 346 struct iovec *iov; 347 caddr_t addr; 348 349 /* 350 * Make sure that on error condition we return "no valid mappings." 351 */ 352 map->dm_mapsize = 0; 353 map->dm_nsegs = 0; 354 355 resid = uio->uio_resid; 356 iov = uio->uio_iov; 357 358 if (uio->uio_segflg == UIO_USERSPACE) { 359 p = uio->uio_procp; 360 #ifdef DIAGNOSTIC 361 if (p == NULL) 362 panic("_bus_dmamap_load_uio: USERSPACE but no proc"); 363 #endif 364 } 365 366 first = 1; 367 seg = 0; 368 error = 0; 369 for (i = 0; i < uio->uio_iovcnt && resid != 0 && error == 0; i++) { 370 /* 371 * Now at the first iovec to load. Load each iovec 372 * until we have exhausted the residual count. 373 */ 374 minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len; 375 addr = (caddr_t)iov[i].iov_base; 376 377 error = _bus_dmamap_load_buffer(t, map, addr, minlen, 378 p, flags, &lastaddr, &seg, first); 379 first = 0; 380 381 resid -= minlen; 382 } 383 if (error == 0) { 384 map->dm_mapsize = uio->uio_resid; 385 map->dm_nsegs = seg + 1; 386 } 387 return (error); 388 } 389 390 /* 391 * Like _bus_dmamap_load(), but for raw memory. 392 */ 393 int 394 _bus_dmamap_load_raw(t, map, segs, nsegs, size, flags) 395 bus_dma_tag_t t; 396 bus_dmamap_t map; 397 bus_dma_segment_t *segs; 398 int nsegs; 399 bus_size_t size; 400 int flags; 401 { 402 panic("_bus_dmamap_load_raw: not implemented"); 403 } 404 405 /* 406 * Common function for unloading a DMA map. May be called by 407 * chipset-specific DMA map unload functions. 408 */ 409 void 410 _bus_dmamap_unload(t, map) 411 bus_dma_tag_t t; 412 bus_dmamap_t map; 413 { 414 415 /* 416 * No resources to free; just mark the mappings as 417 * invalid. 418 */ 419 map->dm_mapsize = 0; 420 map->dm_nsegs = 0; 421 map->_dm_flags &= ~MIPSCO_DMAMAP_COHERENT; 422 } 423 424 /* 425 * Common function for MIPS1 DMA map synchronization. May be called 426 * by chipset-specific DMA map synchronization functions. 427 * 428 * This is the R3000 version. 429 */ 430 void 431 _bus_dmamap_sync(t, map, offset, len, ops) 432 bus_dma_tag_t t; 433 bus_dmamap_t map; 434 bus_addr_t offset; 435 bus_size_t len; 436 int ops; 437 { 438 bus_size_t minlen; 439 bus_addr_t addr; 440 int i; 441 442 #ifdef DIAGNOSTIC 443 /* 444 * Mixing PRE and POST operations is not allowed. 445 */ 446 if ((ops & (BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE)) != 0 && 447 (ops & (BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE)) != 0) 448 panic("_bus_dmamap_sync: mix PRE and POST"); 449 450 if (offset >= map->dm_mapsize) 451 panic("_bus_dmamap_sync: bad offset %lu (map size is %lu)", 452 offset, map->dm_mapsize); 453 if (len == 0 || (offset + len) > map->dm_mapsize) 454 panic("_bus_dmamap_sync: bad length"); 455 #endif 456 457 /* 458 * The R3000 cache is write-through. Therefore, we only need 459 * to drain the write buffer on PREWRITE. The cache is not 460 * coherent, however, so we need to invalidate the data cache 461 * on POSTREAD. 462 * 463 * PREREAD and POSTWRITE are noops. 464 */ 465 466 if (ops & BUS_DMASYNC_PREWRITE) { 467 /* 468 * Flush the write buffer. 469 */ 470 wbflush(); 471 } 472 473 /* 474 * If we're not doing a POSTREAD, nothing more to do. 475 */ 476 if ((ops & BUS_DMASYNC_POSTREAD) == 0) 477 return; 478 479 /* 480 * If the mapping is of COHERENT DMA-safe memory, no cache 481 * flush is necessary. 482 */ 483 if (map->_dm_flags & MIPSCO_DMAMAP_COHERENT) 484 return; 485 486 /* 487 * If we are going to hit something as large or larger 488 * than the entire data cache, just nail the whole thing. 489 * 490 * NOTE: Even though this is `wbinv_all', since the cache is 491 * write-through, it just invalidates it. 492 */ 493 if (len >= mips_pdcache_size) { 494 mips_dcache_wbinv_all(); 495 return; 496 } 497 498 for (i = 0; i < map->dm_nsegs && len != 0; i++) { 499 /* Find the beginning segment. */ 500 if (offset >= map->dm_segs[i].ds_len) { 501 offset -= map->dm_segs[i].ds_len; 502 continue; 503 } 504 505 /* 506 * Now at the first segment to sync; nail 507 * each segment until we have exhausted the 508 * length. 509 */ 510 minlen = len < map->dm_segs[i].ds_len - offset ? 511 len : map->dm_segs[i].ds_len - offset; 512 513 addr = map->dm_segs[i].ds_addr; 514 515 #ifdef BUS_DMA_DEBUG 516 printf("bus_dmamap_sync: flushing segment %d " 517 "(0x%lx..0x%lx) ...", i, addr + offset, 518 addr + offset + minlen - 1); 519 #endif 520 mips_dcache_inv_range( 521 MIPS_PHYS_TO_KSEG0(addr + offset), minlen); 522 #ifdef BUS_DMA_DEBUG 523 printf("\n"); 524 #endif 525 offset = 0; 526 len -= minlen; 527 } 528 } 529 530 /* 531 * Common function for DMA-safe memory allocation. May be called 532 * by bus-specific DMA memory allocation functions. 533 */ 534 int 535 _bus_dmamem_alloc(t, size, alignment, boundary, segs, nsegs, rsegs, flags) 536 bus_dma_tag_t t; 537 bus_size_t size, alignment, boundary; 538 bus_dma_segment_t *segs; 539 int nsegs; 540 int *rsegs; 541 int flags; 542 { 543 544 return (_bus_dmamem_alloc_range(t, size, alignment, boundary, 545 segs, nsegs, rsegs, flags, avail_start, trunc_page(avail_end))); 546 } 547 548 /* 549 * Allocate physical memory from the given physical address range. 550 * Called by DMA-safe memory allocation methods. 551 */ 552 int 553 _bus_dmamem_alloc_range(t, size, alignment, boundary, segs, nsegs, rsegs, 554 flags, low, high) 555 bus_dma_tag_t t; 556 bus_size_t size, alignment, boundary; 557 bus_dma_segment_t *segs; 558 int nsegs; 559 int *rsegs; 560 int flags; 561 paddr_t low; 562 paddr_t high; 563 { 564 paddr_t curaddr, lastaddr; 565 struct vm_page *m; 566 struct pglist mlist; 567 int curseg, error; 568 569 /* Always round the size. */ 570 size = round_page(size); 571 572 high = avail_end - PAGE_SIZE; 573 574 /* 575 * Allocate pages from the VM system. 576 */ 577 error = uvm_pglistalloc(size, low, high, alignment, boundary, 578 &mlist, nsegs, (flags & BUS_DMA_NOWAIT) == 0); 579 if (error) 580 return (error); 581 582 /* 583 * Compute the location, size, and number of segments actually 584 * returned by the VM code. 585 */ 586 m = mlist.tqh_first; 587 curseg = 0; 588 lastaddr = segs[curseg]._ds_paddr = VM_PAGE_TO_PHYS(m); 589 segs[curseg].ds_addr = segs[curseg]._ds_paddr + t->dma_offset; 590 segs[curseg].ds_len = PAGE_SIZE; 591 m = m->pageq.tqe_next; 592 593 for (; m != NULL; m = m->pageq.tqe_next) { 594 curaddr = VM_PAGE_TO_PHYS(m); 595 #ifdef DIAGNOSTIC 596 if (curaddr < avail_start || curaddr >= high) { 597 printf("uvm_pglistalloc returned non-sensical" 598 " address 0x%llx\n", (long long)curaddr); 599 panic("_bus_dmamem_alloc_range"); 600 } 601 #endif 602 if (curaddr == (lastaddr + PAGE_SIZE)) 603 segs[curseg].ds_len += PAGE_SIZE; 604 else { 605 curseg++; 606 segs[curseg].ds_addr = curaddr + t->dma_offset; 607 segs[curseg].ds_len = PAGE_SIZE; 608 segs[curseg]._ds_paddr = curaddr; 609 } 610 lastaddr = curaddr; 611 } 612 613 *rsegs = curseg + 1; 614 615 return (0); 616 } 617 618 /* 619 * Common function for freeing DMA-safe memory. May be called by 620 * bus-specific DMA memory free functions. 621 */ 622 void 623 _bus_dmamem_free(t, segs, nsegs) 624 bus_dma_tag_t t; 625 bus_dma_segment_t *segs; 626 int nsegs; 627 { 628 struct vm_page *m; 629 bus_addr_t addr; 630 struct pglist mlist; 631 int curseg; 632 633 /* 634 * Build a list of pages to free back to the VM system. 635 */ 636 TAILQ_INIT(&mlist); 637 for (curseg = 0; curseg < nsegs; curseg++) { 638 for (addr = segs[curseg]._ds_paddr; 639 addr < (segs[curseg]._ds_paddr + segs[curseg].ds_len); 640 addr += PAGE_SIZE) { 641 m = PHYS_TO_VM_PAGE(addr); 642 TAILQ_INSERT_TAIL(&mlist, m, pageq); 643 } 644 } 645 646 uvm_pglistfree(&mlist); 647 } 648 649 /* 650 * Common function for mapping DMA-safe memory. May be called by 651 * bus-specific DMA memory map functions. 652 */ 653 int 654 _bus_dmamem_map(t, segs, nsegs, size, kvap, flags) 655 bus_dma_tag_t t; 656 bus_dma_segment_t *segs; 657 int nsegs; 658 size_t size; 659 caddr_t *kvap; 660 int flags; 661 { 662 vaddr_t va; 663 bus_addr_t addr; 664 int curseg; 665 666 /* 667 * If we're only mapping 1 segment, use KSEG0 or KSEG1, to avoid 668 * TLB thrashing. 669 */ 670 if (nsegs == 1) { 671 if (flags & BUS_DMA_COHERENT) 672 *kvap = (caddr_t)MIPS_PHYS_TO_KSEG1(segs[0]._ds_paddr); 673 else 674 *kvap = (caddr_t)MIPS_PHYS_TO_KSEG0(segs[0]._ds_paddr); 675 return (0); 676 } 677 678 size = round_page(size); 679 680 va = uvm_km_valloc(kernel_map, size); 681 682 if (va == 0) 683 return (ENOMEM); 684 685 *kvap = (caddr_t)va; 686 687 for (curseg = 0; curseg < nsegs; curseg++) { 688 segs[curseg]._ds_vaddr = va; 689 for (addr = segs[curseg]._ds_paddr; 690 addr < (segs[curseg]._ds_paddr + segs[curseg].ds_len); 691 addr += NBPG, va += NBPG, size -= NBPG) { 692 if (size == 0) 693 panic("_bus_dmamem_map: size botch"); 694 pmap_enter(pmap_kernel(), va, addr, 695 VM_PROT_READ | VM_PROT_WRITE, 696 VM_PROT_READ | VM_PROT_WRITE | PMAP_WIRED); 697 698 /* XXX Do something about COHERENT here. */ 699 } 700 } 701 pmap_update(pmap_kernel()); 702 703 return (0); 704 } 705 706 /* 707 * Common function for unmapping DMA-safe memory. May be called by 708 * bus-specific DMA memory unmapping functions. 709 */ 710 void 711 _bus_dmamem_unmap(t, kva, size) 712 bus_dma_tag_t t; 713 caddr_t kva; 714 size_t size; 715 { 716 717 #ifdef DIAGNOSTIC 718 if ((u_long)kva & PGOFSET) 719 panic("_bus_dmamem_unmap"); 720 #endif 721 722 /* 723 * Nothing to do if we mapped it with KSEG0 or KSEG1 (i.e. 724 * not in KSEG2). 725 */ 726 if (kva >= (caddr_t)MIPS_KSEG0_START && 727 kva < (caddr_t)MIPS_KSEG2_START) 728 return; 729 730 size = round_page(size); 731 uvm_km_free(kernel_map, (vaddr_t)kva, size); 732 } 733 734 /* 735 * Common functin for mmap(2)'ing DMA-safe memory. May be called by 736 * bus-specific DMA mmap(2)'ing functions. 737 */ 738 paddr_t 739 _bus_dmamem_mmap(t, segs, nsegs, off, prot, flags) 740 bus_dma_tag_t t; 741 bus_dma_segment_t *segs; 742 int nsegs; 743 off_t off; 744 int prot, flags; 745 { 746 int i; 747 748 for (i = 0; i < nsegs; i++) { 749 #ifdef DIAGNOSTIC 750 if (off & PGOFSET) 751 panic("_bus_dmamem_mmap: offset unaligned"); 752 if (segs[i]._ds_paddr & PGOFSET) 753 panic("_bus_dmamem_mmap: segment unaligned"); 754 if (segs[i].ds_len & PGOFSET) 755 panic("_bus_dmamem_mmap: segment size not multiple" 756 " of page size"); 757 #endif 758 if (off >= segs[i].ds_len) { 759 off -= segs[i].ds_len; 760 continue; 761 } 762 763 return (mips_btop(segs[i]._ds_paddr + off)); 764 } 765 766 /* Page not found. */ 767 return (-1); 768 } 769