1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2012 EMC Corp. 5 * All rights reserved. 6 * 7 * Copyright (c) 1997, 1998 Justin T. Gibbs. 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include "opt_bus.h" 36 37 #include <sys/param.h> 38 #include <sys/conf.h> 39 #include <sys/systm.h> 40 #include <sys/bio.h> 41 #include <sys/bus.h> 42 #include <sys/callout.h> 43 #include <sys/ktr.h> 44 #include <sys/mbuf.h> 45 #include <sys/memdesc.h> 46 #include <sys/proc.h> 47 #include <sys/uio.h> 48 49 #include <vm/vm.h> 50 #include <vm/vm_page.h> 51 #include <vm/vm_map.h> 52 #include <vm/pmap.h> 53 54 #include <cam/cam.h> 55 #include <cam/cam_ccb.h> 56 57 #include <opencrypto/cryptodev.h> 58 59 #include <machine/bus.h> 60 61 /* 62 * Load up data starting at offset within a region specified by a 63 * list of virtual address ranges until either length or the region 64 * are exhausted. 65 */ 66 static int 67 _bus_dmamap_load_vlist(bus_dma_tag_t dmat, bus_dmamap_t map, 68 bus_dma_segment_t *list, int sglist_cnt, struct pmap *pmap, int *nsegs, 69 int flags, size_t offset, size_t length) 70 { 71 int error; 72 73 error = 0; 74 for (; sglist_cnt > 0 && length != 0; sglist_cnt--, list++) { 75 char *addr; 76 size_t ds_len; 77 78 KASSERT((offset < list->ds_len), 79 ("Invalid mid-segment offset")); 80 addr = (char *)(uintptr_t)list->ds_addr + offset; 81 ds_len = list->ds_len - offset; 82 offset = 0; 83 if (ds_len > length) 84 ds_len = length; 85 length -= ds_len; 86 KASSERT((ds_len != 0), ("Segment length is zero")); 87 error = _bus_dmamap_load_buffer(dmat, map, addr, ds_len, pmap, 88 flags, NULL, nsegs); 89 if (error) 90 break; 91 } 92 return (error); 93 } 94 95 /* 96 * Load a list of physical addresses. 97 */ 98 static int 99 _bus_dmamap_load_plist(bus_dma_tag_t dmat, bus_dmamap_t map, 100 bus_dma_segment_t *list, int sglist_cnt, int *nsegs, int flags) 101 { 102 int error; 103 104 error = 0; 105 for (; sglist_cnt > 0; sglist_cnt--, list++) { 106 error = _bus_dmamap_load_phys(dmat, map, 107 (vm_paddr_t)list->ds_addr, list->ds_len, flags, NULL, 108 nsegs); 109 if (error) 110 break; 111 } 112 return (error); 113 } 114 115 /* 116 * Load an unmapped mbuf 117 */ 118 static int 119 _bus_dmamap_load_mbuf_epg(bus_dma_tag_t dmat, bus_dmamap_t map, 120 struct mbuf *m, bus_dma_segment_t *segs, int *nsegs, int flags) 121 { 122 int error, i, off, len, pglen, pgoff, seglen, segoff; 123 124 M_ASSERTEXTPG(m); 125 126 len = m->m_len; 127 error = 0; 128 129 /* Skip over any data removed from the front. */ 130 off = mtod(m, vm_offset_t); 131 132 if (m->m_epg_hdrlen != 0) { 133 if (off >= m->m_epg_hdrlen) { 134 off -= m->m_epg_hdrlen; 135 } else { 136 seglen = m->m_epg_hdrlen - off; 137 segoff = off; 138 seglen = min(seglen, len); 139 off = 0; 140 len -= seglen; 141 error = _bus_dmamap_load_buffer(dmat, map, 142 &m->m_epg_hdr[segoff], seglen, kernel_pmap, 143 flags, segs, nsegs); 144 } 145 } 146 pgoff = m->m_epg_1st_off; 147 for (i = 0; i < m->m_epg_npgs && error == 0 && len > 0; i++) { 148 pglen = m_epg_pagelen(m, i, pgoff); 149 if (off >= pglen) { 150 off -= pglen; 151 pgoff = 0; 152 continue; 153 } 154 seglen = pglen - off; 155 segoff = pgoff + off; 156 off = 0; 157 seglen = min(seglen, len); 158 len -= seglen; 159 error = _bus_dmamap_load_phys(dmat, map, 160 m->m_epg_pa[i] + segoff, seglen, flags, segs, nsegs); 161 pgoff = 0; 162 }; 163 if (len != 0 && error == 0) { 164 KASSERT((off + len) <= m->m_epg_trllen, 165 ("off + len > trail (%d + %d > %d)", off, len, 166 m->m_epg_trllen)); 167 error = _bus_dmamap_load_buffer(dmat, map, 168 &m->m_epg_trail[off], len, kernel_pmap, flags, segs, 169 nsegs); 170 } 171 return (error); 172 } 173 174 /* 175 * Load an mbuf chain. 176 */ 177 static int 178 _bus_dmamap_load_mbuf_sg(bus_dma_tag_t dmat, bus_dmamap_t map, 179 struct mbuf *m0, bus_dma_segment_t *segs, int *nsegs, int flags) 180 { 181 struct mbuf *m; 182 int error; 183 184 error = 0; 185 for (m = m0; m != NULL && error == 0; m = m->m_next) { 186 if (m->m_len > 0) { 187 if ((m->m_flags & M_EXTPG) != 0) 188 error = _bus_dmamap_load_mbuf_epg(dmat, 189 map, m, segs, nsegs, flags); 190 else 191 error = _bus_dmamap_load_buffer(dmat, map, 192 m->m_data, m->m_len, kernel_pmap, 193 flags | BUS_DMA_LOAD_MBUF, segs, nsegs); 194 } 195 } 196 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 197 __func__, dmat, flags, error, *nsegs); 198 return (error); 199 } 200 201 /* 202 * Load from block io. 203 */ 204 static int 205 _bus_dmamap_load_bio(bus_dma_tag_t dmat, bus_dmamap_t map, struct bio *bio, 206 int *nsegs, int flags) 207 { 208 209 if ((bio->bio_flags & BIO_VLIST) != 0) { 210 bus_dma_segment_t *segs = (bus_dma_segment_t *)bio->bio_data; 211 return (_bus_dmamap_load_vlist(dmat, map, segs, bio->bio_ma_n, 212 kernel_pmap, nsegs, flags, bio->bio_ma_offset, 213 bio->bio_bcount)); 214 } 215 216 if ((bio->bio_flags & BIO_UNMAPPED) != 0) 217 return (_bus_dmamap_load_ma(dmat, map, bio->bio_ma, 218 bio->bio_bcount, bio->bio_ma_offset, flags, NULL, nsegs)); 219 220 return (_bus_dmamap_load_buffer(dmat, map, bio->bio_data, 221 bio->bio_bcount, kernel_pmap, flags, NULL, nsegs)); 222 } 223 224 int 225 bus_dmamap_load_ma_triv(bus_dma_tag_t dmat, bus_dmamap_t map, 226 struct vm_page **ma, bus_size_t tlen, int ma_offs, int flags, 227 bus_dma_segment_t *segs, int *segp) 228 { 229 vm_paddr_t paddr; 230 bus_size_t len; 231 int error, i; 232 233 error = 0; 234 for (i = 0; tlen > 0; i++, tlen -= len) { 235 len = min(PAGE_SIZE - ma_offs, tlen); 236 paddr = VM_PAGE_TO_PHYS(ma[i]) + ma_offs; 237 error = _bus_dmamap_load_phys(dmat, map, paddr, len, 238 flags, segs, segp); 239 if (error != 0) 240 break; 241 ma_offs = 0; 242 } 243 return (error); 244 } 245 246 /* 247 * Load a cam control block. 248 */ 249 static int 250 _bus_dmamap_load_ccb(bus_dma_tag_t dmat, bus_dmamap_t map, union ccb *ccb, 251 int *nsegs, int flags) 252 { 253 struct ccb_hdr *ccb_h; 254 void *data_ptr; 255 int error; 256 uint32_t dxfer_len; 257 uint16_t sglist_cnt; 258 259 error = 0; 260 ccb_h = &ccb->ccb_h; 261 switch (ccb_h->func_code) { 262 case XPT_SCSI_IO: { 263 struct ccb_scsiio *csio; 264 265 csio = &ccb->csio; 266 data_ptr = csio->data_ptr; 267 dxfer_len = csio->dxfer_len; 268 sglist_cnt = csio->sglist_cnt; 269 break; 270 } 271 case XPT_CONT_TARGET_IO: { 272 struct ccb_scsiio *ctio; 273 274 ctio = &ccb->ctio; 275 data_ptr = ctio->data_ptr; 276 dxfer_len = ctio->dxfer_len; 277 sglist_cnt = ctio->sglist_cnt; 278 break; 279 } 280 case XPT_ATA_IO: { 281 struct ccb_ataio *ataio; 282 283 ataio = &ccb->ataio; 284 data_ptr = ataio->data_ptr; 285 dxfer_len = ataio->dxfer_len; 286 sglist_cnt = 0; 287 break; 288 } 289 case XPT_NVME_IO: 290 case XPT_NVME_ADMIN: { 291 struct ccb_nvmeio *nvmeio; 292 293 nvmeio = &ccb->nvmeio; 294 data_ptr = nvmeio->data_ptr; 295 dxfer_len = nvmeio->dxfer_len; 296 sglist_cnt = nvmeio->sglist_cnt; 297 break; 298 } 299 default: 300 panic("_bus_dmamap_load_ccb: Unsupported func code %d", 301 ccb_h->func_code); 302 } 303 304 switch ((ccb_h->flags & CAM_DATA_MASK)) { 305 case CAM_DATA_VADDR: 306 error = _bus_dmamap_load_buffer(dmat, map, data_ptr, dxfer_len, 307 kernel_pmap, flags, NULL, nsegs); 308 break; 309 case CAM_DATA_PADDR: 310 error = _bus_dmamap_load_phys(dmat, map, 311 (vm_paddr_t)(uintptr_t)data_ptr, dxfer_len, flags, NULL, 312 nsegs); 313 break; 314 case CAM_DATA_SG: 315 error = _bus_dmamap_load_vlist(dmat, map, 316 (bus_dma_segment_t *)data_ptr, sglist_cnt, kernel_pmap, 317 nsegs, flags, 0, dxfer_len); 318 break; 319 case CAM_DATA_SG_PADDR: 320 error = _bus_dmamap_load_plist(dmat, map, 321 (bus_dma_segment_t *)data_ptr, sglist_cnt, nsegs, flags); 322 break; 323 case CAM_DATA_BIO: 324 error = _bus_dmamap_load_bio(dmat, map, (struct bio *)data_ptr, 325 nsegs, flags); 326 break; 327 default: 328 panic("_bus_dmamap_load_ccb: flags 0x%X unimplemented", 329 ccb_h->flags); 330 } 331 return (error); 332 } 333 334 /* 335 * Load a uio. 336 */ 337 static int 338 _bus_dmamap_load_uio(bus_dma_tag_t dmat, bus_dmamap_t map, struct uio *uio, 339 int *nsegs, int flags) 340 { 341 bus_size_t resid; 342 bus_size_t minlen; 343 struct iovec *iov; 344 pmap_t pmap; 345 caddr_t addr; 346 int error, i; 347 348 if (uio->uio_segflg == UIO_USERSPACE) { 349 KASSERT(uio->uio_td != NULL, 350 ("bus_dmamap_load_uio: USERSPACE but no proc")); 351 pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace); 352 } else 353 pmap = kernel_pmap; 354 resid = uio->uio_resid; 355 iov = uio->uio_iov; 356 error = 0; 357 358 for (i = 0; i < uio->uio_iovcnt && resid != 0 && !error; i++) { 359 /* 360 * Now at the first iovec to load. Load each iovec 361 * until we have exhausted the residual count. 362 */ 363 364 addr = (caddr_t) iov[i].iov_base; 365 minlen = resid < iov[i].iov_len ? resid : iov[i].iov_len; 366 if (minlen > 0) { 367 error = _bus_dmamap_load_buffer(dmat, map, addr, 368 minlen, pmap, flags, NULL, nsegs); 369 resid -= minlen; 370 } 371 } 372 373 return (error); 374 } 375 376 /* 377 * Map the buffer buf into bus space using the dmamap map. 378 */ 379 int 380 bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf, 381 bus_size_t buflen, bus_dmamap_callback_t *callback, 382 void *callback_arg, int flags) 383 { 384 bus_dma_segment_t *segs; 385 struct memdesc mem; 386 int error; 387 int nsegs; 388 389 if ((flags & BUS_DMA_NOWAIT) == 0) { 390 mem = memdesc_vaddr(buf, buflen); 391 _bus_dmamap_waitok(dmat, map, &mem, callback, callback_arg); 392 } 393 394 nsegs = -1; 395 error = _bus_dmamap_load_buffer(dmat, map, buf, buflen, kernel_pmap, 396 flags, NULL, &nsegs); 397 nsegs++; 398 399 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 400 __func__, dmat, flags, error, nsegs); 401 402 if (error == EINPROGRESS) 403 return (error); 404 405 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 406 if (error) 407 (*callback)(callback_arg, segs, 0, error); 408 else 409 (*callback)(callback_arg, segs, nsegs, 0); 410 411 /* 412 * Return ENOMEM to the caller so that it can pass it up the stack. 413 * This error only happens when NOWAIT is set, so deferral is disabled. 414 */ 415 if (error == ENOMEM) 416 return (error); 417 418 return (0); 419 } 420 421 int 422 bus_dmamap_load_mbuf(bus_dma_tag_t dmat, bus_dmamap_t map, struct mbuf *m0, 423 bus_dmamap_callback2_t *callback, void *callback_arg, int flags) 424 { 425 bus_dma_segment_t *segs; 426 int nsegs, error; 427 428 M_ASSERTPKTHDR(m0); 429 430 flags |= BUS_DMA_NOWAIT; 431 nsegs = -1; 432 error = _bus_dmamap_load_mbuf_sg(dmat, map, m0, NULL, &nsegs, flags); 433 ++nsegs; 434 435 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 436 if (error) 437 (*callback)(callback_arg, segs, 0, 0, error); 438 else 439 (*callback)(callback_arg, segs, nsegs, m0->m_pkthdr.len, error); 440 441 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 442 __func__, dmat, flags, error, nsegs); 443 return (error); 444 } 445 446 int 447 bus_dmamap_load_mbuf_sg(bus_dma_tag_t dmat, bus_dmamap_t map, struct mbuf *m0, 448 bus_dma_segment_t *segs, int *nsegs, int flags) 449 { 450 int error; 451 452 flags |= BUS_DMA_NOWAIT; 453 *nsegs = -1; 454 error = _bus_dmamap_load_mbuf_sg(dmat, map, m0, segs, nsegs, flags); 455 ++*nsegs; 456 _bus_dmamap_complete(dmat, map, segs, *nsegs, error); 457 return (error); 458 } 459 460 int 461 bus_dmamap_load_uio(bus_dma_tag_t dmat, bus_dmamap_t map, struct uio *uio, 462 bus_dmamap_callback2_t *callback, void *callback_arg, int flags) 463 { 464 bus_dma_segment_t *segs; 465 int nsegs, error; 466 467 flags |= BUS_DMA_NOWAIT; 468 nsegs = -1; 469 error = _bus_dmamap_load_uio(dmat, map, uio, &nsegs, flags); 470 nsegs++; 471 472 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 473 if (error) 474 (*callback)(callback_arg, segs, 0, 0, error); 475 else 476 (*callback)(callback_arg, segs, nsegs, uio->uio_resid, error); 477 478 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 479 __func__, dmat, flags, error, nsegs); 480 return (error); 481 } 482 483 int 484 bus_dmamap_load_ccb(bus_dma_tag_t dmat, bus_dmamap_t map, union ccb *ccb, 485 bus_dmamap_callback_t *callback, void *callback_arg, 486 int flags) 487 { 488 bus_dma_segment_t *segs; 489 struct ccb_hdr *ccb_h; 490 struct memdesc mem; 491 int error; 492 int nsegs; 493 494 ccb_h = &ccb->ccb_h; 495 if ((ccb_h->flags & CAM_DIR_MASK) == CAM_DIR_NONE) { 496 callback(callback_arg, NULL, 0, 0); 497 return (0); 498 } 499 if ((flags & BUS_DMA_NOWAIT) == 0) { 500 mem = memdesc_ccb(ccb); 501 _bus_dmamap_waitok(dmat, map, &mem, callback, callback_arg); 502 } 503 nsegs = -1; 504 error = _bus_dmamap_load_ccb(dmat, map, ccb, &nsegs, flags); 505 nsegs++; 506 507 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 508 __func__, dmat, flags, error, nsegs); 509 510 if (error == EINPROGRESS) 511 return (error); 512 513 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 514 if (error) 515 (*callback)(callback_arg, segs, 0, error); 516 else 517 (*callback)(callback_arg, segs, nsegs, error); 518 /* 519 * Return ENOMEM to the caller so that it can pass it up the stack. 520 * This error only happens when NOWAIT is set, so deferral is disabled. 521 */ 522 if (error == ENOMEM) 523 return (error); 524 525 return (0); 526 } 527 528 int 529 bus_dmamap_load_bio(bus_dma_tag_t dmat, bus_dmamap_t map, struct bio *bio, 530 bus_dmamap_callback_t *callback, void *callback_arg, 531 int flags) 532 { 533 bus_dma_segment_t *segs; 534 struct memdesc mem; 535 int error; 536 int nsegs; 537 538 if ((flags & BUS_DMA_NOWAIT) == 0) { 539 mem = memdesc_bio(bio); 540 _bus_dmamap_waitok(dmat, map, &mem, callback, callback_arg); 541 } 542 nsegs = -1; 543 error = _bus_dmamap_load_bio(dmat, map, bio, &nsegs, flags); 544 nsegs++; 545 546 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 547 __func__, dmat, flags, error, nsegs); 548 549 if (error == EINPROGRESS) 550 return (error); 551 552 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 553 if (error) 554 (*callback)(callback_arg, segs, 0, error); 555 else 556 (*callback)(callback_arg, segs, nsegs, error); 557 /* 558 * Return ENOMEM to the caller so that it can pass it up the stack. 559 * This error only happens when NOWAIT is set, so deferral is disabled. 560 */ 561 if (error == ENOMEM) 562 return (error); 563 564 return (0); 565 } 566 567 int 568 bus_dmamap_load_mem(bus_dma_tag_t dmat, bus_dmamap_t map, 569 struct memdesc *mem, bus_dmamap_callback_t *callback, 570 void *callback_arg, int flags) 571 { 572 bus_dma_segment_t *segs; 573 int error; 574 int nsegs; 575 576 if ((flags & BUS_DMA_NOWAIT) == 0) 577 _bus_dmamap_waitok(dmat, map, mem, callback, callback_arg); 578 579 nsegs = -1; 580 error = 0; 581 switch (mem->md_type) { 582 case MEMDESC_VADDR: 583 error = _bus_dmamap_load_buffer(dmat, map, mem->u.md_vaddr, 584 mem->md_opaque, kernel_pmap, flags, NULL, &nsegs); 585 break; 586 case MEMDESC_PADDR: 587 error = _bus_dmamap_load_phys(dmat, map, mem->u.md_paddr, 588 mem->md_opaque, flags, NULL, &nsegs); 589 break; 590 case MEMDESC_VLIST: 591 error = _bus_dmamap_load_vlist(dmat, map, mem->u.md_list, 592 mem->md_opaque, kernel_pmap, &nsegs, flags, 0, SIZE_T_MAX); 593 break; 594 case MEMDESC_PLIST: 595 error = _bus_dmamap_load_plist(dmat, map, mem->u.md_list, 596 mem->md_opaque, &nsegs, flags); 597 break; 598 case MEMDESC_BIO: 599 error = _bus_dmamap_load_bio(dmat, map, mem->u.md_bio, 600 &nsegs, flags); 601 break; 602 case MEMDESC_UIO: 603 error = _bus_dmamap_load_uio(dmat, map, mem->u.md_uio, 604 &nsegs, flags); 605 break; 606 case MEMDESC_MBUF: 607 error = _bus_dmamap_load_mbuf_sg(dmat, map, mem->u.md_mbuf, 608 NULL, &nsegs, flags); 609 break; 610 case MEMDESC_CCB: 611 error = _bus_dmamap_load_ccb(dmat, map, mem->u.md_ccb, &nsegs, 612 flags); 613 break; 614 } 615 nsegs++; 616 617 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 618 __func__, dmat, flags, error, nsegs); 619 620 if (error == EINPROGRESS) 621 return (error); 622 623 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 624 if (error) 625 (*callback)(callback_arg, segs, 0, error); 626 else 627 (*callback)(callback_arg, segs, nsegs, 0); 628 629 /* 630 * Return ENOMEM to the caller so that it can pass it up the stack. 631 * This error only happens when NOWAIT is set, so deferral is disabled. 632 */ 633 if (error == ENOMEM) 634 return (error); 635 636 return (0); 637 } 638 639 int 640 bus_dmamap_load_crp_buffer(bus_dma_tag_t dmat, bus_dmamap_t map, 641 struct crypto_buffer *cb, bus_dmamap_callback_t *callback, 642 void *callback_arg, int flags) 643 { 644 bus_dma_segment_t *segs; 645 int error; 646 int nsegs; 647 648 flags |= BUS_DMA_NOWAIT; 649 nsegs = -1; 650 error = 0; 651 switch (cb->cb_type) { 652 case CRYPTO_BUF_CONTIG: 653 error = _bus_dmamap_load_buffer(dmat, map, cb->cb_buf, 654 cb->cb_buf_len, kernel_pmap, flags, NULL, &nsegs); 655 break; 656 case CRYPTO_BUF_MBUF: 657 error = _bus_dmamap_load_mbuf_sg(dmat, map, cb->cb_mbuf, 658 NULL, &nsegs, flags); 659 break; 660 case CRYPTO_BUF_UIO: 661 error = _bus_dmamap_load_uio(dmat, map, cb->cb_uio, &nsegs, 662 flags); 663 break; 664 default: 665 error = EINVAL; 666 } 667 nsegs++; 668 669 CTR5(KTR_BUSDMA, "%s: tag %p tag flags 0x%x error %d nsegs %d", 670 __func__, dmat, flags, error, nsegs); 671 672 if (error == EINPROGRESS) 673 return (error); 674 675 segs = _bus_dmamap_complete(dmat, map, NULL, nsegs, error); 676 if (error) 677 (*callback)(callback_arg, segs, 0, error); 678 else 679 (*callback)(callback_arg, segs, nsegs, 0); 680 681 /* 682 * Return ENOMEM to the caller so that it can pass it up the stack. 683 * This error only happens when NOWAIT is set, so deferral is disabled. 684 */ 685 if (error == ENOMEM) 686 return (error); 687 688 return (0); 689 } 690 691 int 692 bus_dmamap_load_crp(bus_dma_tag_t dmat, bus_dmamap_t map, struct cryptop *crp, 693 bus_dmamap_callback_t *callback, void *callback_arg, int flags) 694 { 695 return (bus_dmamap_load_crp_buffer(dmat, map, &crp->crp_buf, callback, 696 callback_arg, flags)); 697 } 698