1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/scsi/scsi.h> 28 #include <sys/vtrace.h> 29 30 31 #define A_TO_TRAN(ap) ((ap)->a_hba_tran) 32 #define P_TO_TRAN(pkt) ((pkt)->pkt_address.a_hba_tran) 33 #define P_TO_ADDR(pkt) (&((pkt)->pkt_address)) 34 35 /* 36 * Callback id 37 */ 38 uintptr_t scsi_callback_id = 0; 39 40 extern ddi_dma_attr_t scsi_alloc_attr; 41 42 struct buf * 43 scsi_alloc_consistent_buf(struct scsi_address *ap, 44 struct buf *in_bp, size_t datalen, uint_t bflags, 45 int (*callback)(caddr_t), caddr_t callback_arg) 46 { 47 dev_info_t *pdip; 48 struct buf *bp; 49 int kmflag; 50 size_t rlen; 51 52 TRACE_0(TR_FAC_SCSI_RES, TR_SCSI_ALLOC_CONSISTENT_BUF_START, 53 "scsi_alloc_consistent_buf_start"); 54 55 if (!in_bp) { 56 kmflag = (callback == SLEEP_FUNC) ? KM_SLEEP : KM_NOSLEEP; 57 if ((bp = getrbuf(kmflag)) == NULL) { 58 goto no_resource; 59 } 60 } else { 61 bp = in_bp; 62 63 /* we are establishing a new buffer memory association */ 64 bp->b_flags &= ~(B_PAGEIO | B_PHYS | B_REMAPPED | B_SHADOW); 65 bp->b_proc = NULL; 66 bp->b_pages = NULL; 67 bp->b_shadow = NULL; 68 } 69 70 /* limit bits that can be set by bflags argument */ 71 ASSERT(!(bflags & ~(B_READ | B_WRITE))); 72 bflags &= (B_READ | B_WRITE); 73 bp->b_un.b_addr = 0; 74 75 if (datalen) { 76 pdip = (A_TO_TRAN(ap))->tran_hba_dip; 77 78 /* 79 * use i_ddi_mem_alloc() for now until we have an interface to 80 * allocate memory for DMA which doesn't require a DMA handle. 81 * ddi_iopb_alloc() is obsolete and we want more flexibility in 82 * controlling the DMA address constraints. 83 */ 84 while (i_ddi_mem_alloc(pdip, &scsi_alloc_attr, datalen, 85 ((callback == SLEEP_FUNC) ? 1 : 0), 0, NULL, 86 &bp->b_un.b_addr, &rlen, NULL) != DDI_SUCCESS) { 87 if (callback == SLEEP_FUNC) { 88 delay(drv_usectohz(10000)); 89 } else { 90 if (!in_bp) 91 freerbuf(bp); 92 goto no_resource; 93 } 94 } 95 bp->b_flags |= bflags; 96 } 97 bp->b_bcount = datalen; 98 bp->b_resid = 0; 99 100 TRACE_0(TR_FAC_SCSI_RES, TR_SCSI_ALLOC_CONSISTENT_BUF_END, 101 "scsi_alloc_consistent_buf_end"); 102 return (bp); 103 104 no_resource: 105 106 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 107 ddi_set_callback(callback, callback_arg, 108 &scsi_callback_id); 109 } 110 TRACE_0(TR_FAC_SCSI_RES, 111 TR_SCSI_ALLOC_CONSISTENT_BUF_RETURN1_END, 112 "scsi_alloc_consistent_buf_end (return1)"); 113 return (NULL); 114 } 115 116 void 117 scsi_free_consistent_buf(struct buf *bp) 118 { 119 TRACE_0(TR_FAC_SCSI_RES, TR_SCSI_FREE_CONSISTENT_BUF_START, 120 "scsi_free_consistent_buf_start"); 121 if (!bp) 122 return; 123 if (bp->b_un.b_addr) 124 i_ddi_mem_free((caddr_t)bp->b_un.b_addr, NULL); 125 freerbuf(bp); 126 if (scsi_callback_id != 0) { 127 ddi_run_callback(&scsi_callback_id); 128 } 129 TRACE_0(TR_FAC_SCSI_RES, TR_SCSI_FREE_CONSISTENT_BUF_END, 130 "scsi_free_consistent_buf_end"); 131 } 132 133 void 134 scsi_dmafree_attr(struct scsi_pkt *pktp) 135 { 136 struct scsi_pkt_cache_wrapper *pktw = 137 (struct scsi_pkt_cache_wrapper *)pktp; 138 139 if (pktw->pcw_flags & PCW_BOUND) { 140 if (ddi_dma_unbind_handle(pktp->pkt_handle) != 141 DDI_SUCCESS) 142 cmn_err(CE_WARN, "scsi_dmafree_attr: " 143 "unbind handle failed"); 144 pktw->pcw_flags &= ~PCW_BOUND; 145 } 146 pktp->pkt_numcookies = 0; 147 pktw->pcw_totalwin = 0; 148 } 149 150 struct buf * 151 scsi_pkt2bp(struct scsi_pkt *pkt) 152 { 153 return (((struct scsi_pkt_cache_wrapper *)pkt)->pcw_bp); 154 } 155 156 int 157 scsi_dma_buf_bind_attr(struct scsi_pkt_cache_wrapper *pktw, 158 struct buf *bp, 159 int dma_flags, 160 int (*callback)(), 161 caddr_t arg) 162 { 163 struct scsi_pkt *pktp = &(pktw->pcw_pkt); 164 int status; 165 166 /* 167 * First time, need to establish the handle. 168 */ 169 170 ASSERT(pktp->pkt_numcookies == 0); 171 ASSERT(pktw->pcw_totalwin == 0); 172 173 status = ddi_dma_buf_bind_handle(pktp->pkt_handle, bp, dma_flags, 174 callback, arg, &pktw->pcw_cookie, 175 &pktp->pkt_numcookies); 176 177 switch (status) { 178 case DDI_DMA_MAPPED: 179 pktw->pcw_totalwin = 1; 180 break; 181 182 case DDI_DMA_PARTIAL_MAP: 183 /* enable first call to ddi_dma_getwin */ 184 if (ddi_dma_numwin(pktp->pkt_handle, 185 &pktw->pcw_totalwin) != DDI_SUCCESS) { 186 bp->b_error = 0; 187 return (0); 188 } 189 break; 190 191 case DDI_DMA_NORESOURCES: 192 bp->b_error = 0; 193 return (0); 194 195 case DDI_DMA_TOOBIG: 196 bioerror(bp, EINVAL); 197 return (0); 198 199 case DDI_DMA_NOMAPPING: 200 case DDI_DMA_INUSE: 201 default: 202 bioerror(bp, EFAULT); 203 return (0); 204 } 205 206 /* initialize the loop controls for scsi_dmaget_attr() */ 207 pktw->pcw_curwin = 0; 208 pktw->pcw_total_xfer = 0; 209 pktp->pkt_dma_flags = dma_flags; 210 return (1); 211 } 212 213 #if defined(_DMA_USES_PHYSADDR) 214 int 215 scsi_dmaget_attr(struct scsi_pkt_cache_wrapper *pktw) 216 { 217 struct scsi_pkt *pktp = &(pktw->pcw_pkt); 218 219 int status; 220 int num_segs = 0; 221 ddi_dma_impl_t *hp = (ddi_dma_impl_t *)pktp->pkt_handle; 222 ddi_dma_cookie_t *cp; 223 224 if (pktw->pcw_curwin != 0) { 225 ddi_dma_cookie_t cookie; 226 227 /* 228 * start the next window, and get its first cookie 229 */ 230 status = ddi_dma_getwin(pktp->pkt_handle, 231 pktw->pcw_curwin, &pktp->pkt_dma_offset, 232 &pktp->pkt_dma_len, &cookie, 233 &pktp->pkt_numcookies); 234 if (status != DDI_SUCCESS) 235 return (0); 236 } 237 238 /* 239 * start the Scatter/Gather loop 240 */ 241 cp = hp->dmai_cookie - 1; 242 pktp->pkt_dma_len = 0; 243 for (;;) { 244 245 /* take care of the loop-bookkeeping */ 246 pktp->pkt_dma_len += cp->dmac_size; 247 num_segs++; 248 /* 249 * if this was the last cookie in the current window 250 * set the loop controls start the next window and 251 * exit so the HBA can do this partial transfer 252 */ 253 if (num_segs >= pktp->pkt_numcookies) { 254 pktw->pcw_curwin++; 255 break; 256 } 257 258 cp++; 259 } 260 pktw->pcw_total_xfer += pktp->pkt_dma_len; 261 pktp->pkt_cookies = hp->dmai_cookie - 1; 262 hp->dmai_cookie = cp; 263 264 return (1); 265 } 266 #endif 267 268 void scsi_free_cache_pkt(struct scsi_address *, struct scsi_pkt *); 269 270 struct scsi_pkt * 271 scsi_init_cache_pkt(struct scsi_address *ap, struct scsi_pkt *in_pktp, 272 struct buf *bp, int cmdlen, int statuslen, int pplen, 273 int flags, int (*callback)(caddr_t), caddr_t callback_arg) 274 { 275 struct scsi_pkt_cache_wrapper *pktw; 276 scsi_hba_tran_t *tranp = ap->a_hba_tran; 277 int (*func)(caddr_t); 278 279 func = (callback == SLEEP_FUNC) ? SLEEP_FUNC : NULL_FUNC; 280 281 if (in_pktp == NULL) { 282 int kf; 283 284 if (callback == SLEEP_FUNC) 285 kf = KM_SLEEP; 286 else 287 kf = KM_NOSLEEP; 288 /* 289 * By using kmem_cache_alloc(), the layout of the 290 * scsi_pkt, scsi_pkt_cache_wrapper, hba private data, 291 * cdb, tgt driver private data, and status block is 292 * as below. 293 * 294 * This is a piece of contiguous memory starting from 295 * the first structure field scsi_pkt in the struct 296 * scsi_pkt_cache_wrapper, followed by the hba private 297 * data, pkt_cdbp, the tgt driver private data and 298 * pkt_scbp. 299 * 300 * |----------------------------|---------------------> 301 * | struct scsi_pkt | struct 302 * | ...... |scsi_pkt_cache_wrapper 303 * | pcw_flags | 304 * |----------------------------|<--------------------- 305 * | hba private data |tranp->tran_hba_len 306 * |----------------------------| 307 * | pkt_cdbp |DEFAULT_CDBLEN 308 * |----------------------------| 309 * | tgt private data |DEFAULT_PRIVLEN 310 * |----------------------------| 311 * | pkt_scbp |DEFAULT_SCBLEN 312 * |----------------------------| 313 * 314 * If the actual data length of the cdb, or the tgt 315 * driver private data, or the status block is bigger 316 * than the default data length, kmem_alloc() will be 317 * called to get extra space. 318 */ 319 pktw = kmem_cache_alloc(tranp->tran_pkt_cache_ptr, 320 kf); 321 if (pktw == NULL) 322 goto fail1; 323 324 pktw->pcw_flags = 0; 325 in_pktp = &(pktw->pcw_pkt); 326 in_pktp->pkt_address = *ap; 327 328 /* 329 * target drivers should initialize pkt_comp and 330 * pkt_time, but sometimes they don't so initialize 331 * them here to be safe. 332 */ 333 in_pktp->pkt_flags = 0; 334 in_pktp->pkt_time = 0; 335 in_pktp->pkt_resid = 0; 336 in_pktp->pkt_state = 0; 337 in_pktp->pkt_statistics = 0; 338 in_pktp->pkt_reason = 0; 339 in_pktp->pkt_dma_offset = 0; 340 in_pktp->pkt_dma_len = 0; 341 in_pktp->pkt_dma_flags = 0; 342 in_pktp->pkt_path_instance = 0; 343 ASSERT(in_pktp->pkt_numcookies == 0); 344 pktw->pcw_curwin = 0; 345 pktw->pcw_totalwin = 0; 346 pktw->pcw_total_xfer = 0; 347 348 in_pktp->pkt_cdblen = cmdlen; 349 if ((tranp->tran_hba_flags & SCSI_HBA_TRAN_CDB) && 350 (cmdlen > DEFAULT_CDBLEN)) { 351 pktw->pcw_flags |= PCW_NEED_EXT_CDB; 352 in_pktp->pkt_cdbp = kmem_alloc(cmdlen, kf); 353 if (in_pktp->pkt_cdbp == NULL) 354 goto fail2; 355 } 356 in_pktp->pkt_tgtlen = pplen; 357 if (pplen > DEFAULT_PRIVLEN) { 358 pktw->pcw_flags |= PCW_NEED_EXT_TGT; 359 in_pktp->pkt_private = kmem_alloc(pplen, kf); 360 if (in_pktp->pkt_private == NULL) 361 goto fail3; 362 } 363 in_pktp->pkt_scblen = statuslen; 364 if ((tranp->tran_hba_flags & SCSI_HBA_TRAN_SCB) && 365 (statuslen > DEFAULT_SCBLEN)) { 366 pktw->pcw_flags |= PCW_NEED_EXT_SCB; 367 in_pktp->pkt_scbp = kmem_alloc(statuslen, kf); 368 if (in_pktp->pkt_scbp == NULL) 369 goto fail4; 370 } 371 if ((*tranp->tran_setup_pkt) (in_pktp, 372 func, NULL) == -1) { 373 goto fail5; 374 } 375 if (cmdlen) 376 bzero((void *)in_pktp->pkt_cdbp, cmdlen); 377 if (pplen) 378 bzero((void *)in_pktp->pkt_private, pplen); 379 if (statuslen) 380 bzero((void *)in_pktp->pkt_scbp, statuslen); 381 } else 382 pktw = (struct scsi_pkt_cache_wrapper *)in_pktp; 383 384 if (bp && bp->b_bcount) { 385 386 int dma_flags = 0; 387 388 /* 389 * we need to transfer data, so we alloc dma resources 390 * for this packet 391 */ 392 /*CONSTCOND*/ 393 ASSERT(SLEEP_FUNC == DDI_DMA_SLEEP); 394 /*CONSTCOND*/ 395 ASSERT(NULL_FUNC == DDI_DMA_DONTWAIT); 396 397 #if defined(_DMA_USES_PHYSADDR) 398 /* 399 * with an IOMMU we map everything, so we don't 400 * need to bother with this 401 */ 402 if (tranp->tran_dma_attr.dma_attr_granular != 403 pktw->pcw_granular) { 404 405 ddi_dma_free_handle(&in_pktp->pkt_handle); 406 if (ddi_dma_alloc_handle(tranp->tran_hba_dip, 407 &tranp->tran_dma_attr, 408 func, NULL, 409 &in_pktp->pkt_handle) != DDI_SUCCESS) { 410 411 in_pktp->pkt_handle = NULL; 412 return (NULL); 413 } 414 pktw->pcw_granular = 415 tranp->tran_dma_attr.dma_attr_granular; 416 } 417 #endif 418 419 if (in_pktp->pkt_numcookies == 0) { 420 pktw->pcw_bp = bp; 421 /* 422 * set dma flags; the "read" case must be first 423 * since B_WRITE isn't always be set for writes. 424 */ 425 if (bp->b_flags & B_READ) { 426 dma_flags |= DDI_DMA_READ; 427 } else { 428 dma_flags |= DDI_DMA_WRITE; 429 } 430 if (flags & PKT_CONSISTENT) 431 dma_flags |= DDI_DMA_CONSISTENT; 432 if (flags & PKT_DMA_PARTIAL) 433 dma_flags |= DDI_DMA_PARTIAL; 434 435 #if defined(__sparc) 436 /* 437 * workaround for byte hole issue on psycho and 438 * schizo pre 2.1 439 */ 440 if ((bp->b_flags & B_READ) && ((bp->b_flags & 441 (B_PAGEIO|B_REMAPPED)) != B_PAGEIO) && 442 (((uintptr_t)bp->b_un.b_addr & 0x7) || 443 ((uintptr_t)bp->b_bcount & 0x7))) { 444 dma_flags |= DDI_DMA_CONSISTENT; 445 } 446 #endif 447 if (!scsi_dma_buf_bind_attr(pktw, bp, 448 dma_flags, callback, callback_arg)) { 449 return (NULL); 450 } else { 451 pktw->pcw_flags |= PCW_BOUND; 452 } 453 } 454 455 #if defined(_DMA_USES_PHYSADDR) 456 if (!scsi_dmaget_attr(pktw)) { 457 scsi_dmafree_attr(in_pktp); 458 goto fail5; 459 } 460 #else 461 in_pktp->pkt_cookies = &pktw->pcw_cookie; 462 in_pktp->pkt_dma_len = pktw->pcw_cookie.dmac_size; 463 pktw->pcw_total_xfer += in_pktp->pkt_dma_len; 464 #endif 465 ASSERT(in_pktp->pkt_numcookies <= 466 tranp->tran_dma_attr.dma_attr_sgllen); 467 ASSERT(pktw->pcw_total_xfer <= bp->b_bcount); 468 in_pktp->pkt_resid = bp->b_bcount - 469 pktw->pcw_total_xfer; 470 471 ASSERT((in_pktp->pkt_resid % pktw->pcw_granular) == 472 0); 473 } else { 474 /* !bp or no b_bcount */ 475 in_pktp->pkt_resid = 0; 476 } 477 return (in_pktp); 478 479 fail5: 480 if (pktw->pcw_flags & PCW_NEED_EXT_SCB) { 481 kmem_free(in_pktp->pkt_scbp, statuslen); 482 in_pktp->pkt_scbp = (opaque_t)((char *)in_pktp + 483 tranp->tran_hba_len + DEFAULT_PRIVLEN + 484 sizeof (struct scsi_pkt_cache_wrapper)); 485 if ((A_TO_TRAN(ap))->tran_hba_flags & SCSI_HBA_TRAN_CDB) 486 in_pktp->pkt_scbp = (opaque_t)((in_pktp->pkt_scbp) + 487 DEFAULT_CDBLEN); 488 in_pktp->pkt_scblen = 0; 489 } 490 fail4: 491 if (pktw->pcw_flags & PCW_NEED_EXT_TGT) { 492 kmem_free(in_pktp->pkt_private, pplen); 493 in_pktp->pkt_tgtlen = 0; 494 in_pktp->pkt_private = NULL; 495 } 496 fail3: 497 if (pktw->pcw_flags & PCW_NEED_EXT_CDB) { 498 kmem_free(in_pktp->pkt_cdbp, cmdlen); 499 in_pktp->pkt_cdbp = (opaque_t)((char *)in_pktp + 500 tranp->tran_hba_len + 501 sizeof (struct scsi_pkt_cache_wrapper)); 502 in_pktp->pkt_cdblen = 0; 503 } 504 pktw->pcw_flags &= 505 ~(PCW_NEED_EXT_CDB|PCW_NEED_EXT_TGT|PCW_NEED_EXT_SCB); 506 fail2: 507 kmem_cache_free(tranp->tran_pkt_cache_ptr, pktw); 508 fail1: 509 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 510 ddi_set_callback(callback, callback_arg, 511 &scsi_callback_id); 512 } 513 514 return (NULL); 515 } 516 517 void 518 scsi_free_cache_pkt(struct scsi_address *ap, struct scsi_pkt *pktp) 519 { 520 struct scsi_pkt_cache_wrapper *pktw; 521 522 (*A_TO_TRAN(ap)->tran_teardown_pkt)(pktp); 523 pktw = (struct scsi_pkt_cache_wrapper *)pktp; 524 if (pktw->pcw_flags & PCW_BOUND) 525 scsi_dmafree_attr(pktp); 526 527 /* 528 * if we allocated memory for anything that wouldn't fit, free 529 * the memory and restore the pointers 530 */ 531 if (pktw->pcw_flags & PCW_NEED_EXT_SCB) { 532 kmem_free(pktp->pkt_scbp, pktp->pkt_scblen); 533 pktp->pkt_scbp = (opaque_t)((char *)pktp + 534 (A_TO_TRAN(ap))->tran_hba_len + 535 DEFAULT_PRIVLEN + sizeof (struct scsi_pkt_cache_wrapper)); 536 if ((A_TO_TRAN(ap))->tran_hba_flags & SCSI_HBA_TRAN_CDB) 537 pktp->pkt_scbp = (opaque_t)((pktp->pkt_scbp) + 538 DEFAULT_CDBLEN); 539 pktp->pkt_scblen = 0; 540 } 541 if (pktw->pcw_flags & PCW_NEED_EXT_TGT) { 542 kmem_free(pktp->pkt_private, pktp->pkt_tgtlen); 543 pktp->pkt_tgtlen = 0; 544 pktp->pkt_private = NULL; 545 } 546 if (pktw->pcw_flags & PCW_NEED_EXT_CDB) { 547 kmem_free(pktp->pkt_cdbp, pktp->pkt_cdblen); 548 pktp->pkt_cdbp = (opaque_t)((char *)pktp + 549 (A_TO_TRAN(ap))->tran_hba_len + 550 sizeof (struct scsi_pkt_cache_wrapper)); 551 pktp->pkt_cdblen = 0; 552 } 553 pktw->pcw_flags &= 554 ~(PCW_NEED_EXT_CDB|PCW_NEED_EXT_TGT|PCW_NEED_EXT_SCB); 555 kmem_cache_free(A_TO_TRAN(ap)->tran_pkt_cache_ptr, pktw); 556 557 if (scsi_callback_id != 0) { 558 ddi_run_callback(&scsi_callback_id); 559 } 560 561 } 562 563 564 struct scsi_pkt * 565 scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *in_pktp, 566 struct buf *bp, int cmdlen, int statuslen, int pplen, 567 int flags, int (*callback)(caddr_t), caddr_t callback_arg) 568 { 569 struct scsi_pkt *pktp; 570 scsi_hba_tran_t *tranp = ap->a_hba_tran; 571 int (*func)(caddr_t); 572 573 TRACE_5(TR_FAC_SCSI_RES, TR_SCSI_INIT_PKT_START, 574 "scsi_init_pkt_start: addr %p in_pktp %p cmdlen %d statuslen %d pplen %d", 575 ap, in_pktp, cmdlen, statuslen, pplen); 576 577 #if defined(__i386) || defined(__amd64) 578 if (flags & PKT_CONSISTENT_OLD) { 579 flags &= ~PKT_CONSISTENT_OLD; 580 flags |= PKT_CONSISTENT; 581 } 582 #endif 583 584 func = (callback == SLEEP_FUNC) ? SLEEP_FUNC : NULL_FUNC; 585 586 pktp = (*tranp->tran_init_pkt) (ap, in_pktp, bp, cmdlen, 587 statuslen, pplen, flags, func, NULL); 588 if (pktp == NULL) { 589 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 590 ddi_set_callback(callback, callback_arg, 591 &scsi_callback_id); 592 } 593 } 594 595 TRACE_1(TR_FAC_SCSI_RES, TR_SCSI_INIT_PKT_END, 596 "scsi_init_pkt_end: pktp %p", pktp); 597 return (pktp); 598 } 599 600 void 601 scsi_destroy_pkt(struct scsi_pkt *pkt) 602 { 603 struct scsi_address *ap = P_TO_ADDR(pkt); 604 605 TRACE_1(TR_FAC_SCSI_RES, TR_SCSI_DESTROY_PKT_START, 606 "scsi_destroy_pkt_start: pkt %p", pkt); 607 608 (*A_TO_TRAN(ap)->tran_destroy_pkt)(ap, pkt); 609 610 if (scsi_callback_id != 0) { 611 ddi_run_callback(&scsi_callback_id); 612 } 613 614 TRACE_0(TR_FAC_SCSI_RES, TR_SCSI_DESTROY_PKT_END, 615 "scsi_destroy_pkt_end"); 616 } 617 618 619 /* 620 * Generic Resource Allocation Routines 621 */ 622 623 struct scsi_pkt * 624 scsi_resalloc(struct scsi_address *ap, int cmdlen, int statuslen, 625 opaque_t dmatoken, int (*callback)()) 626 { 627 register struct scsi_pkt *pkt; 628 register scsi_hba_tran_t *tranp = ap->a_hba_tran; 629 register int (*func)(caddr_t); 630 631 func = (callback == SLEEP_FUNC) ? SLEEP_FUNC : NULL_FUNC; 632 633 pkt = (*tranp->tran_init_pkt) (ap, NULL, (struct buf *)dmatoken, 634 cmdlen, statuslen, 0, 0, func, NULL); 635 if (pkt == NULL) { 636 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 637 ddi_set_callback(callback, NULL, &scsi_callback_id); 638 } 639 } 640 641 return (pkt); 642 } 643 644 struct scsi_pkt * 645 scsi_pktalloc(struct scsi_address *ap, int cmdlen, int statuslen, 646 int (*callback)()) 647 { 648 struct scsi_pkt *pkt; 649 struct scsi_hba_tran *tran = ap->a_hba_tran; 650 register int (*func)(caddr_t); 651 652 func = (callback == SLEEP_FUNC) ? SLEEP_FUNC : NULL_FUNC; 653 654 pkt = (*tran->tran_init_pkt) (ap, NULL, NULL, cmdlen, 655 statuslen, 0, 0, func, NULL); 656 if (pkt == NULL) { 657 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 658 ddi_set_callback(callback, NULL, &scsi_callback_id); 659 } 660 } 661 662 return (pkt); 663 } 664 665 struct scsi_pkt * 666 scsi_dmaget(struct scsi_pkt *pkt, opaque_t dmatoken, int (*callback)()) 667 { 668 struct scsi_pkt *new_pkt; 669 register int (*func)(caddr_t); 670 671 func = (callback == SLEEP_FUNC) ? SLEEP_FUNC : NULL_FUNC; 672 673 new_pkt = (*P_TO_TRAN(pkt)->tran_init_pkt) (&pkt->pkt_address, 674 pkt, (struct buf *)dmatoken, 675 0, 0, 0, 0, func, NULL); 676 ASSERT(new_pkt == pkt || new_pkt == NULL); 677 if (new_pkt == NULL) { 678 if (callback != NULL_FUNC && callback != SLEEP_FUNC) { 679 ddi_set_callback(callback, NULL, &scsi_callback_id); 680 } 681 } 682 683 return (new_pkt); 684 } 685 686 687 /* 688 * Generic Resource Deallocation Routines 689 */ 690 691 void 692 scsi_dmafree(struct scsi_pkt *pkt) 693 { 694 register struct scsi_address *ap = P_TO_ADDR(pkt); 695 696 (*A_TO_TRAN(ap)->tran_dmafree)(ap, pkt); 697 698 if (scsi_callback_id != 0) { 699 ddi_run_callback(&scsi_callback_id); 700 } 701 } 702 703 /*ARGSUSED*/ 704 void 705 scsi_cache_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 706 { 707 ASSERT(pkt->pkt_numcookies == 0 || 708 ((struct scsi_pkt_cache_wrapper *)pkt)->pcw_flags & PCW_BOUND); 709 ASSERT(pkt->pkt_handle != NULL); 710 scsi_dmafree_attr(pkt); 711 712 if (scsi_callback_id != 0) { 713 ddi_run_callback(&scsi_callback_id); 714 } 715 } 716 717 void 718 scsi_sync_pkt(struct scsi_pkt *pkt) 719 { 720 register struct scsi_address *ap = P_TO_ADDR(pkt); 721 722 if (pkt->pkt_state & STATE_XFERRED_DATA) 723 (*A_TO_TRAN(ap)->tran_sync_pkt)(ap, pkt); 724 } 725 726 /*ARGSUSED*/ 727 void 728 scsi_sync_cache_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 729 { 730 if (pkt->pkt_handle && 731 (pkt->pkt_dma_flags & (DDI_DMA_WRITE | DDI_DMA_READ))) { 732 (void) ddi_dma_sync(pkt->pkt_handle, 733 pkt->pkt_dma_offset, pkt->pkt_dma_len, 734 (pkt->pkt_dma_flags & DDI_DMA_WRITE) ? 735 DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU); 736 } 737 } 738 739 void 740 scsi_resfree(struct scsi_pkt *pkt) 741 { 742 register struct scsi_address *ap = P_TO_ADDR(pkt); 743 (*A_TO_TRAN(ap)->tran_destroy_pkt)(ap, pkt); 744 745 if (scsi_callback_id != 0) { 746 ddi_run_callback(&scsi_callback_id); 747 } 748 } 749