1 /*- 2 * Copyright (c) 1999-2006 by Matthew Jacob 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice immediately at the beginning of the file, without modification, 10 * this list of conditions, and the following disclaimer. 11 * 2. The name of the author may not be used to endorse or promote products 12 * derived from this software without specific prior written permission. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 18 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 */ 27 /* 28 * Qlogic Host Adapter Internal Library Functions 29 */ 30 #ifdef __NetBSD__ 31 #include <dev/ic/isp_netbsd.h> 32 #endif 33 #ifdef __FreeBSD__ 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 #include <dev/isp/isp_freebsd.h> 37 #endif 38 #ifdef __OpenBSD__ 39 #include <dev/ic/isp_openbsd.h> 40 #endif 41 #ifdef __linux__ 42 #include "isp_linux.h" 43 #endif 44 #ifdef __svr4__ 45 #include "isp_solaris.h" 46 #endif 47 48 int 49 isp_save_xs(ispsoftc_t *isp, XS_T *xs, uint16_t *handlep) 50 { 51 int i, j; 52 53 for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) { 54 if (isp->isp_xflist[j] == NULL) { 55 break; 56 } 57 if (++j == isp->isp_maxcmds) { 58 j = 0; 59 } 60 } 61 if (i == isp->isp_maxcmds) { 62 return (-1); 63 } 64 isp->isp_xflist[j] = xs; 65 *handlep = j+1; 66 if (++j == isp->isp_maxcmds) 67 j = 0; 68 isp->isp_lasthdls = (uint16_t)j; 69 return (0); 70 } 71 72 XS_T * 73 isp_find_xs(ispsoftc_t *isp, uint16_t handle) 74 { 75 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) { 76 return (NULL); 77 } else { 78 return (isp->isp_xflist[handle - 1]); 79 } 80 } 81 82 uint16_t 83 isp_find_handle(ispsoftc_t *isp, XS_T *xs) 84 { 85 int i; 86 if (xs != NULL) { 87 for (i = 0; i < isp->isp_maxcmds; i++) { 88 if (isp->isp_xflist[i] == xs) { 89 return ((uint16_t) i+1); 90 } 91 } 92 } 93 return (0); 94 } 95 96 int 97 isp_handle_index(uint16_t handle) 98 { 99 return (handle-1); 100 } 101 102 uint16_t 103 isp_index_handle(int index) 104 { 105 return (index+1); 106 } 107 108 void 109 isp_destroy_handle(ispsoftc_t *isp, uint16_t handle) 110 { 111 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) { 112 isp->isp_xflist[handle - 1] = NULL; 113 } 114 } 115 116 int 117 isp_getrqentry(ispsoftc_t *isp, uint16_t *iptrp, 118 uint16_t *optrp, void **resultp) 119 { 120 volatile uint16_t iptr, optr; 121 122 optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp); 123 iptr = isp->isp_reqidx; 124 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); 125 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp)); 126 if (iptr == optr) { 127 return (1); 128 } 129 if (optrp) 130 *optrp = optr; 131 if (iptrp) 132 *iptrp = iptr; 133 return (0); 134 } 135 136 #define TBA (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1) 137 void 138 isp_print_qentry(ispsoftc_t *isp, char *msg, int idx, void *arg) 139 { 140 char buf[TBA]; 141 int amt, i, j; 142 uint8_t *ptr = arg; 143 144 isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx); 145 for (buf[0] = 0, amt = i = 0; i < 4; i++) { 146 buf[0] = 0; 147 SNPRINTF(buf, TBA, " "); 148 for (j = 0; j < (QENTRY_LEN >> 2); j++) { 149 SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff); 150 } 151 isp_prt(isp, ISP_LOGALL, buf); 152 } 153 } 154 155 void 156 isp_print_bytes(ispsoftc_t *isp, char *msg, int amt, void *arg) 157 { 158 char buf[128]; 159 uint8_t *ptr = arg; 160 int off; 161 162 if (msg) 163 isp_prt(isp, ISP_LOGALL, "%s:", msg); 164 off = 0; 165 buf[0] = 0; 166 while (off < amt) { 167 int j, to; 168 to = off; 169 for (j = 0; j < 16; j++) { 170 SNPRINTF(buf, 128, "%s %02x", buf, ptr[off++] & 0xff); 171 if (off == amt) 172 break; 173 } 174 isp_prt(isp, ISP_LOGALL, "0x%08x:%s", to, buf); 175 buf[0] = 0; 176 } 177 } 178 179 /* 180 * Do the common path to try and ensure that link is up, we've scanned 181 * the fabric (if we're on a fabric), and that we've synchronized this 182 * all with our own database and done the appropriate logins. 183 * 184 * We repeatedly check for firmware state and loop state after each 185 * action because things may have changed while we were doing this. 186 * Any failure or change of state causes us to return a nonzero value. 187 * 188 * We honor HBA roles in that if we're not in Initiator mode, we don't 189 * attempt to sync up the database (that's for somebody else to do, 190 * if ever). 191 * 192 * We assume we enter here with any locks held. 193 */ 194 195 int 196 isp_fc_runstate(ispsoftc_t *isp, int tval) 197 { 198 fcparam *fcp; 199 int *tptr; 200 201 if (IS_SCSI(isp)) 202 return (0); 203 204 tptr = &tval; 205 if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) { 206 return (-1); 207 } 208 fcp = FCPARAM(isp); 209 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD) 210 return (-1); 211 if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) { 212 return (-1); 213 } 214 if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) { 215 return (-1); 216 } 217 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) { 218 return (0); 219 } 220 if (isp_control(isp, ISPCTL_PDB_SYNC, NULL) != 0) { 221 return (-1); 222 } 223 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) { 224 return (-1); 225 } 226 return (0); 227 } 228 229 /* 230 * Functions to move stuff to a form that the QLogic RISC engine understands 231 * and functions to move stuff back to a form the processor understands. 232 * 233 * Each platform is required to provide the 8, 16 and 32 bit 234 * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32}) 235 * 236 * The assumption is that swizzling and unswizzling is mostly done 'in place' 237 * (with a few exceptions for efficiency). 238 */ 239 240 #define ISP_IS_SBUS(isp) \ 241 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS) 242 243 /* 244 * Swizzle/Copy Functions 245 */ 246 void 247 isp_copy_out_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst) 248 { 249 if (ISP_IS_SBUS(isp)) { 250 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type, 251 &hpdst->rqs_entry_count); 252 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count, 253 &hpdst->rqs_entry_type); 254 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno, 255 &hpdst->rqs_flags); 256 ISP_IOXPUT_8(isp, hpsrc->rqs_flags, 257 &hpdst->rqs_seqno); 258 } else { 259 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type, 260 &hpdst->rqs_entry_type); 261 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count, 262 &hpdst->rqs_entry_count); 263 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno, 264 &hpdst->rqs_seqno); 265 ISP_IOXPUT_8(isp, hpsrc->rqs_flags, 266 &hpdst->rqs_flags); 267 } 268 } 269 270 void 271 isp_copy_in_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst) 272 { 273 if (ISP_IS_SBUS(isp)) { 274 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type, 275 hpdst->rqs_entry_count); 276 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count, 277 hpdst->rqs_entry_type); 278 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno, 279 hpdst->rqs_flags); 280 ISP_IOXGET_8(isp, &hpsrc->rqs_flags, 281 hpdst->rqs_seqno); 282 } else { 283 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type, 284 hpdst->rqs_entry_type); 285 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count, 286 hpdst->rqs_entry_count); 287 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno, 288 hpdst->rqs_seqno); 289 ISP_IOXGET_8(isp, &hpsrc->rqs_flags, 290 hpdst->rqs_flags); 291 } 292 } 293 294 int 295 isp_get_response_type(ispsoftc_t *isp, isphdr_t *hp) 296 { 297 uint8_t type; 298 if (ISP_IS_SBUS(isp)) { 299 ISP_IOXGET_8(isp, &hp->rqs_entry_count, type); 300 } else { 301 ISP_IOXGET_8(isp, &hp->rqs_entry_type, type); 302 } 303 return ((int)type); 304 } 305 306 void 307 isp_put_request(ispsoftc_t *isp, ispreq_t *rqsrc, ispreq_t *rqdst) 308 { 309 int i; 310 isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header); 311 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle); 312 if (ISP_IS_SBUS(isp)) { 313 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target); 314 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn); 315 } else { 316 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn); 317 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target); 318 } 319 ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen); 320 ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags); 321 ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time); 322 ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count); 323 for (i = 0; i < 12; i++) { 324 ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]); 325 } 326 for (i = 0; i < ISP_RQDSEG; i++) { 327 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base, 328 &rqdst->req_dataseg[i].ds_base); 329 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count, 330 &rqdst->req_dataseg[i].ds_count); 331 } 332 } 333 334 void 335 isp_put_request_t2(ispsoftc_t *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst) 336 { 337 int i; 338 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header); 339 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle); 340 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn); 341 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target); 342 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun); 343 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags); 344 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2); 345 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time); 346 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count); 347 for (i = 0; i < 16; i++) { 348 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]); 349 } 350 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt); 351 for (i = 0; i < ISP_RQDSEG_T2; i++) { 352 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base, 353 &tqdst->req_dataseg[i].ds_base); 354 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count, 355 &tqdst->req_dataseg[i].ds_count); 356 } 357 } 358 359 void 360 isp_put_request_t2e(ispsoftc_t *isp, ispreqt2e_t *tqsrc, ispreqt2e_t *tqdst) 361 { 362 int i; 363 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header); 364 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle); 365 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target); 366 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun); 367 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags); 368 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2); 369 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time); 370 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count); 371 for (i = 0; i < 16; i++) { 372 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]); 373 } 374 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt); 375 for (i = 0; i < ISP_RQDSEG_T2; i++) { 376 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base, 377 &tqdst->req_dataseg[i].ds_base); 378 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count, 379 &tqdst->req_dataseg[i].ds_count); 380 } 381 } 382 383 void 384 isp_put_request_t3(ispsoftc_t *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst) 385 { 386 int i; 387 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header); 388 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle); 389 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn); 390 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target); 391 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun); 392 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags); 393 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2); 394 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time); 395 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count); 396 for (i = 0; i < 16; i++) { 397 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]); 398 } 399 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt); 400 for (i = 0; i < ISP_RQDSEG_T3; i++) { 401 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base, 402 &tqdst->req_dataseg[i].ds_base); 403 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi, 404 &tqdst->req_dataseg[i].ds_basehi); 405 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count, 406 &tqdst->req_dataseg[i].ds_count); 407 } 408 } 409 410 void 411 isp_put_request_t3e(ispsoftc_t *isp, ispreqt3e_t *tqsrc, ispreqt3e_t *tqdst) 412 { 413 int i; 414 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header); 415 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle); 416 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target); 417 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun); 418 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags); 419 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2); 420 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time); 421 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count); 422 for (i = 0; i < 16; i++) { 423 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]); 424 } 425 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt); 426 for (i = 0; i < ISP_RQDSEG_T3; i++) { 427 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base, 428 &tqdst->req_dataseg[i].ds_base); 429 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi, 430 &tqdst->req_dataseg[i].ds_basehi); 431 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count, 432 &tqdst->req_dataseg[i].ds_count); 433 } 434 } 435 436 void 437 isp_put_extended_request(ispsoftc_t *isp, ispextreq_t *xqsrc, 438 ispextreq_t *xqdst) 439 { 440 int i; 441 isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header); 442 ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle); 443 if (ISP_IS_SBUS(isp)) { 444 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target); 445 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn); 446 } else { 447 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_lun_trn); 448 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_target); 449 } 450 ISP_IOXPUT_16(isp, xqsrc->req_cdblen, &xqdst->req_cdblen); 451 ISP_IOXPUT_16(isp, xqsrc->req_flags, &xqdst->req_flags); 452 ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time); 453 ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count); 454 for (i = 0; i < 44; i++) { 455 ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]); 456 } 457 } 458 459 void 460 isp_put_cont_req(ispsoftc_t *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst) 461 { 462 int i; 463 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header); 464 for (i = 0; i < ISP_CDSEG; i++) { 465 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base, 466 &cqdst->req_dataseg[i].ds_base); 467 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count, 468 &cqdst->req_dataseg[i].ds_count); 469 } 470 } 471 472 void 473 isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *cqsrc, 474 ispcontreq64_t *cqdst) 475 { 476 int i; 477 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header); 478 for (i = 0; i < ISP_CDSEG64; i++) { 479 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base, 480 &cqdst->req_dataseg[i].ds_base); 481 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi, 482 &cqdst->req_dataseg[i].ds_basehi); 483 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count, 484 &cqdst->req_dataseg[i].ds_count); 485 } 486 } 487 488 void 489 isp_get_response(ispsoftc_t *isp, ispstatusreq_t *spsrc, 490 ispstatusreq_t *spdst) 491 { 492 int i; 493 isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header); 494 ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle); 495 ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status); 496 ISP_IOXGET_16(isp, &spsrc->req_completion_status, 497 spdst->req_completion_status); 498 ISP_IOXGET_16(isp, &spsrc->req_state_flags, spdst->req_state_flags); 499 ISP_IOXGET_16(isp, &spsrc->req_status_flags, spdst->req_status_flags); 500 ISP_IOXGET_16(isp, &spsrc->req_time, spdst->req_time); 501 ISP_IOXGET_16(isp, &spsrc->req_sense_len, spdst->req_sense_len); 502 ISP_IOXGET_32(isp, &spsrc->req_resid, spdst->req_resid); 503 for (i = 0; i < 8; i++) { 504 ISP_IOXGET_8(isp, &spsrc->req_response[i], 505 spdst->req_response[i]); 506 } 507 for (i = 0; i < 32; i++) { 508 ISP_IOXGET_8(isp, &spsrc->req_sense_data[i], 509 spdst->req_sense_data[i]); 510 } 511 } 512 513 void 514 isp_get_response_x(ispsoftc_t *isp, ispstatus_cont_t *cpsrc, 515 ispstatus_cont_t *cpdst) 516 { 517 int i; 518 isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header); 519 for (i = 0; i < 60; i++) { 520 ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i], 521 cpdst->req_sense_data[i]); 522 } 523 } 524 525 void 526 isp_get_rio2(ispsoftc_t *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst) 527 { 528 int i; 529 isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header); 530 if (r2dst->req_header.rqs_seqno > 30) 531 r2dst->req_header.rqs_seqno = 30; 532 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) { 533 ISP_IOXGET_16(isp, &r2src->req_handles[i], 534 r2dst->req_handles[i]); 535 } 536 while (i < 30) { 537 r2dst->req_handles[i++] = 0; 538 } 539 } 540 541 void 542 isp_put_icb(ispsoftc_t *isp, isp_icb_t *Is, isp_icb_t *Id) 543 { 544 int i; 545 if (ISP_IS_SBUS(isp)) { 546 ISP_IOXPUT_8(isp, Is->icb_version, &Id->_reserved0); 547 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->icb_version); 548 } else { 549 ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version); 550 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0); 551 } 552 ISP_IOXPUT_16(isp, Is->icb_fwoptions, &Id->icb_fwoptions); 553 ISP_IOXPUT_16(isp, Is->icb_maxfrmlen, &Id->icb_maxfrmlen); 554 ISP_IOXPUT_16(isp, Is->icb_maxalloc, &Id->icb_maxalloc); 555 ISP_IOXPUT_16(isp, Is->icb_execthrottle, &Id->icb_execthrottle); 556 if (ISP_IS_SBUS(isp)) { 557 ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_delay); 558 ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_count); 559 } else { 560 ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_count); 561 ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_delay); 562 } 563 for (i = 0; i < 8; i++) { 564 ISP_IOXPUT_8(isp, Is->icb_portname[i], &Id->icb_portname[i]); 565 } 566 ISP_IOXPUT_16(isp, Is->icb_hardaddr, &Id->icb_hardaddr); 567 if (ISP_IS_SBUS(isp)) { 568 ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_logintime); 569 ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_iqdevtype); 570 } else { 571 ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_iqdevtype); 572 ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_logintime); 573 } 574 for (i = 0; i < 8; i++) { 575 ISP_IOXPUT_8(isp, Is->icb_nodename[i], &Id->icb_nodename[i]); 576 } 577 ISP_IOXPUT_16(isp, Is->icb_rqstout, &Id->icb_rqstout); 578 ISP_IOXPUT_16(isp, Is->icb_rspnsin, &Id->icb_rspnsin); 579 ISP_IOXPUT_16(isp, Is->icb_rqstqlen, &Id->icb_rqstqlen); 580 ISP_IOXPUT_16(isp, Is->icb_rsltqlen, &Id->icb_rsltqlen); 581 for (i = 0; i < 4; i++) { 582 ISP_IOXPUT_16(isp, Is->icb_rqstaddr[i], &Id->icb_rqstaddr[i]); 583 } 584 for (i = 0; i < 4; i++) { 585 ISP_IOXPUT_16(isp, Is->icb_respaddr[i], &Id->icb_respaddr[i]); 586 } 587 ISP_IOXPUT_16(isp, Is->icb_lunenables, &Id->icb_lunenables); 588 if (ISP_IS_SBUS(isp)) { 589 ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_icnt); 590 ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_ccnt); 591 } else { 592 ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_ccnt); 593 ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_icnt); 594 } 595 ISP_IOXPUT_16(isp, Is->icb_lunetimeout, &Id->icb_lunetimeout); 596 ISP_IOXPUT_16(isp, Is->icb_xfwoptions, &Id->icb_xfwoptions); 597 if (ISP_IS_SBUS(isp)) { 598 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_idelaytimer); 599 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_racctimer); 600 } else { 601 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer); 602 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer); 603 } 604 ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions); 605 } 606 607 void 608 isp_get_pdb(ispsoftc_t *isp, isp_pdb_t *src, isp_pdb_t *dst) 609 { 610 int i; 611 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options); 612 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate); 613 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate); 614 for (i = 0; i < 4; i++) { 615 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i], 616 dst->pdb_hardaddr_bits[i]); 617 } 618 for (i = 0; i < 4; i++) { 619 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i], 620 dst->pdb_portid_bits[i]); 621 } 622 for (i = 0; i < 8; i++) { 623 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]); 624 } 625 for (i = 0; i < 8; i++) { 626 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]); 627 } 628 ISP_IOXGET_16(isp, &src->pdb_execthrottle, dst->pdb_execthrottle); 629 ISP_IOXGET_16(isp, &src->pdb_exec_count, dst->pdb_exec_count); 630 ISP_IOXGET_8(isp, &src->pdb_retry_count, dst->pdb_retry_count); 631 ISP_IOXGET_8(isp, &src->pdb_retry_delay, dst->pdb_retry_delay); 632 ISP_IOXGET_16(isp, &src->pdb_resalloc, dst->pdb_resalloc); 633 ISP_IOXGET_16(isp, &src->pdb_curalloc, dst->pdb_curalloc); 634 ISP_IOXGET_16(isp, &src->pdb_qhead, dst->pdb_qhead); 635 ISP_IOXGET_16(isp, &src->pdb_qtail, dst->pdb_qtail); 636 ISP_IOXGET_16(isp, &src->pdb_tl_next, dst->pdb_tl_next); 637 ISP_IOXGET_16(isp, &src->pdb_tl_last, dst->pdb_tl_last); 638 ISP_IOXGET_16(isp, &src->pdb_features, dst->pdb_features); 639 ISP_IOXGET_16(isp, &src->pdb_pconcurrnt, dst->pdb_pconcurrnt); 640 ISP_IOXGET_16(isp, &src->pdb_roi, dst->pdb_roi); 641 ISP_IOXGET_8(isp, &src->pdb_target, dst->pdb_target); 642 ISP_IOXGET_8(isp, &src->pdb_initiator, dst->pdb_initiator); 643 ISP_IOXGET_16(isp, &src->pdb_rdsiz, dst->pdb_rdsiz); 644 ISP_IOXGET_16(isp, &src->pdb_ncseq, dst->pdb_ncseq); 645 ISP_IOXGET_16(isp, &src->pdb_noseq, dst->pdb_noseq); 646 ISP_IOXGET_16(isp, &src->pdb_labrtflg, dst->pdb_labrtflg); 647 ISP_IOXGET_16(isp, &src->pdb_lstopflg, dst->pdb_lstopflg); 648 ISP_IOXGET_16(isp, &src->pdb_sqhead, dst->pdb_sqhead); 649 ISP_IOXGET_16(isp, &src->pdb_sqtail, dst->pdb_sqtail); 650 ISP_IOXGET_16(isp, &src->pdb_ptimer, dst->pdb_ptimer); 651 ISP_IOXGET_16(isp, &src->pdb_nxt_seqid, dst->pdb_nxt_seqid); 652 ISP_IOXGET_16(isp, &src->pdb_fcount, dst->pdb_fcount); 653 ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len); 654 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0); 655 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3); 656 ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid); 657 ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr); 658 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr); 659 } 660 661 662 /* 663 * CT_HDR canonicalization- only needed for SNS responses 664 */ 665 void 666 isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst) 667 { 668 ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision); 669 ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]); 670 ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]); 671 ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]); 672 ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type); 673 ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype); 674 ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options); 675 ISP_IOXGET_8(isp, &src->ct_res0, dst->ct_res0); 676 ISP_IOXGET_16(isp, &src->ct_response, dst->ct_response); 677 dst->ct_response = (dst->ct_response << 8) | (dst->ct_response >> 8); 678 ISP_IOXGET_16(isp, &src->ct_resid, dst->ct_resid); 679 dst->ct_resid = (dst->ct_resid << 8) | (dst->ct_resid >> 8); 680 ISP_IOXGET_8(isp, &src->ct_res1, dst->ct_res1); 681 ISP_IOXGET_8(isp, &src->ct_reason, dst->ct_reason); 682 ISP_IOXGET_8(isp, &src->ct_explanation, dst->ct_explanation); 683 ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique); 684 } 685 686 /* 687 * Generic SNS request - not particularly useful since the per-command data 688 * isn't always 16 bit words. 689 */ 690 void 691 isp_put_sns_request(ispsoftc_t *isp, sns_screq_t *src, sns_screq_t *dst) 692 { 693 int i, nw = (int) src->snscb_sblen; 694 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen); 695 for (i = 0; i < 4; i++) { 696 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]); 697 } 698 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen); 699 for (i = 0; i < nw; i++) { 700 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]); 701 } 702 703 } 704 705 void 706 isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src, 707 sns_gid_ft_req_t *dst) 708 { 709 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen); 710 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0); 711 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]); 712 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]); 713 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]); 714 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]); 715 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen); 716 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1); 717 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd); 718 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2); 719 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3); 720 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type); 721 } 722 723 void 724 isp_put_gxn_id_request(ispsoftc_t *isp, sns_gxn_id_req_t *src, 725 sns_gxn_id_req_t *dst) 726 { 727 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen); 728 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0); 729 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]); 730 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]); 731 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]); 732 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]); 733 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen); 734 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1); 735 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd); 736 ISP_IOXPUT_16(isp, src->snscb_res2, &dst->snscb_res2); 737 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3); 738 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid); 739 } 740 741 /* 742 * Generic SNS response - not particularly useful since the per-command data 743 * isn't always 16 bit words. 744 */ 745 void 746 isp_get_sns_response(ispsoftc_t *isp, sns_scrsp_t *src, 747 sns_scrsp_t *dst, int nwords) 748 { 749 int i; 750 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr); 751 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type); 752 for (i = 0; i < 3; i++) { 753 ISP_IOXGET_8(isp, &src->snscb_port_id[i], 754 dst->snscb_port_id[i]); 755 } 756 for (i = 0; i < 8; i++) { 757 ISP_IOXGET_8(isp, &src->snscb_portname[i], 758 dst->snscb_portname[i]); 759 } 760 for (i = 0; i < nwords; i++) { 761 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]); 762 } 763 } 764 765 void 766 isp_get_gid_ft_response(ispsoftc_t *isp, sns_gid_ft_rsp_t *src, 767 sns_gid_ft_rsp_t *dst, int nwords) 768 { 769 int i; 770 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr); 771 for (i = 0; i < nwords; i++) { 772 int j; 773 ISP_IOXGET_8(isp, 774 &src->snscb_ports[i].control, 775 dst->snscb_ports[i].control); 776 for (j = 0; j < 3; j++) { 777 ISP_IOXGET_8(isp, 778 &src->snscb_ports[i].portid[j], 779 dst->snscb_ports[i].portid[j]); 780 } 781 if (dst->snscb_ports[i].control & 0x80) { 782 break; 783 } 784 } 785 } 786 787 void 788 isp_get_gxn_id_response(ispsoftc_t *isp, sns_gxn_id_rsp_t *src, 789 sns_gxn_id_rsp_t *dst) 790 { 791 int i; 792 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr); 793 for (i = 0; i < 8; i++) 794 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]); 795 } 796 797 void 798 isp_get_gff_id_response(ispsoftc_t *isp, sns_gff_id_rsp_t *src, 799 sns_gff_id_rsp_t *dst) 800 { 801 int i; 802 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr); 803 for (i = 0; i < 32; i++) { 804 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i], 805 dst->snscb_fc4_features[i]); 806 } 807 } 808 809 void 810 isp_get_ga_nxt_response(ispsoftc_t *isp, sns_ga_nxt_rsp_t *src, 811 sns_ga_nxt_rsp_t *dst) 812 { 813 int i; 814 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr); 815 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type); 816 for (i = 0; i < 3; i++) { 817 ISP_IOXGET_8(isp, &src->snscb_port_id[i], 818 dst->snscb_port_id[i]); 819 } 820 for (i = 0; i < 8; i++) { 821 ISP_IOXGET_8(isp, &src->snscb_portname[i], 822 dst->snscb_portname[i]); 823 } 824 ISP_IOXGET_8(isp, &src->snscb_pnlen, dst->snscb_pnlen); 825 for (i = 0; i < 255; i++) { 826 ISP_IOXGET_8(isp, &src->snscb_pname[i], dst->snscb_pname[i]); 827 } 828 for (i = 0; i < 8; i++) { 829 ISP_IOXGET_8(isp, &src->snscb_nodename[i], 830 dst->snscb_nodename[i]); 831 } 832 ISP_IOXGET_8(isp, &src->snscb_nnlen, dst->snscb_nnlen); 833 for (i = 0; i < 255; i++) { 834 ISP_IOXGET_8(isp, &src->snscb_nname[i], dst->snscb_nname[i]); 835 } 836 for (i = 0; i < 8; i++) { 837 ISP_IOXGET_8(isp, &src->snscb_ipassoc[i], 838 dst->snscb_ipassoc[i]); 839 } 840 for (i = 0; i < 16; i++) { 841 ISP_IOXGET_8(isp, &src->snscb_ipaddr[i], dst->snscb_ipaddr[i]); 842 } 843 for (i = 0; i < 4; i++) { 844 ISP_IOXGET_8(isp, &src->snscb_svc_class[i], 845 dst->snscb_svc_class[i]); 846 } 847 for (i = 0; i < 32; i++) { 848 ISP_IOXGET_8(isp, &src->snscb_fc4_types[i], 849 dst->snscb_fc4_types[i]); 850 } 851 for (i = 0; i < 8; i++) { 852 ISP_IOXGET_8(isp, &src->snscb_fpname[i], dst->snscb_fpname[i]); 853 } 854 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved); 855 for (i = 0; i < 3; i++) { 856 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i], 857 dst->snscb_hardaddr[i]); 858 } 859 } 860 861 #ifdef ISP_TARGET_MODE 862 863 int 864 isp_save_xs_tgt(ispsoftc_t *isp, void *xs, uint16_t *handlep) 865 { 866 int i; 867 868 for (i = 0; i < (int) isp->isp_maxcmds; i++) { 869 if (isp->isp_tgtlist[i] == NULL) { 870 break; 871 } 872 } 873 if (i == isp->isp_maxcmds) { 874 return (-1); 875 } 876 isp->isp_tgtlist[i] = xs; 877 *handlep = i+1; 878 return (0); 879 } 880 881 void * 882 isp_find_xs_tgt(ispsoftc_t *isp, uint16_t handle) 883 { 884 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) { 885 return (NULL); 886 } else { 887 return (isp->isp_tgtlist[handle - 1]); 888 } 889 } 890 891 uint16_t 892 isp_find_tgt_handle(ispsoftc_t *isp, void *xs) 893 { 894 int i; 895 if (xs != NULL) { 896 for (i = 0; i < isp->isp_maxcmds; i++) { 897 if (isp->isp_tgtlist[i] == xs) { 898 return ((uint16_t) i+1); 899 } 900 } 901 } 902 return (0); 903 } 904 905 void 906 isp_destroy_tgt_handle(ispsoftc_t *isp, uint16_t handle) 907 { 908 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) { 909 isp->isp_tgtlist[handle - 1] = NULL; 910 } 911 } 912 void 913 isp_put_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst) 914 { 915 int i; 916 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header); 917 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved); 918 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle); 919 if (ISP_IS_SBUS(isp)) { 920 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid); 921 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun); 922 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_tgt); 923 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_cdblen); 924 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_scsi_status); 925 ISP_IOXPUT_8(isp, atsrc->at_scsi_status, &atdst->at_status); 926 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_type); 927 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_val); 928 } else { 929 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun); 930 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid); 931 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_cdblen); 932 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_tgt); 933 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_status); 934 ISP_IOXPUT_8(isp, atsrc->at_scsi_status, 935 &atdst->at_scsi_status); 936 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_val); 937 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_type); 938 } 939 ISP_IOXPUT_32(isp, atsrc->at_flags, &atdst->at_flags); 940 for (i = 0; i < ATIO_CDBLEN; i++) { 941 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]); 942 } 943 for (i = 0; i < QLTM_SENSELEN; i++) { 944 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]); 945 } 946 } 947 948 void 949 isp_get_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst) 950 { 951 int i; 952 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header); 953 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved); 954 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle); 955 if (ISP_IS_SBUS(isp)) { 956 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid); 957 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun); 958 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_tgt); 959 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_cdblen); 960 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_scsi_status); 961 ISP_IOXGET_8(isp, &atsrc->at_scsi_status, atdst->at_status); 962 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_type); 963 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_val); 964 } else { 965 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun); 966 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid); 967 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_cdblen); 968 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_tgt); 969 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_status); 970 ISP_IOXGET_8(isp, &atsrc->at_scsi_status, 971 atdst->at_scsi_status); 972 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_val); 973 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_type); 974 } 975 ISP_IOXGET_32(isp, &atsrc->at_flags, atdst->at_flags); 976 for (i = 0; i < ATIO_CDBLEN; i++) { 977 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]); 978 } 979 for (i = 0; i < QLTM_SENSELEN; i++) { 980 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]); 981 } 982 } 983 984 void 985 isp_put_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst) 986 { 987 int i; 988 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header); 989 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved); 990 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun); 991 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid); 992 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid); 993 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags); 994 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status); 995 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn); 996 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes); 997 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags); 998 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes); 999 for (i = 0; i < ATIO2_CDBLEN; i++) { 1000 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]); 1001 } 1002 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen); 1003 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun); 1004 for (i = 0; i < 4; i++) { 1005 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]); 1006 } 1007 for (i = 0; i < 6; i++) { 1008 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i], 1009 &atdst->at_reserved2[i]); 1010 } 1011 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid); 1012 } 1013 1014 void 1015 isp_put_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst) 1016 { 1017 int i; 1018 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header); 1019 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved); 1020 ISP_IOXPUT_16(isp, atsrc->at_iid, &atdst->at_iid); 1021 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid); 1022 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags); 1023 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status); 1024 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn); 1025 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes); 1026 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags); 1027 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes); 1028 for (i = 0; i < ATIO2_CDBLEN; i++) { 1029 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]); 1030 } 1031 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen); 1032 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun); 1033 for (i = 0; i < 4; i++) { 1034 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]); 1035 } 1036 for (i = 0; i < 6; i++) { 1037 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i], 1038 &atdst->at_reserved2[i]); 1039 } 1040 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid); 1041 } 1042 1043 void 1044 isp_get_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst) 1045 { 1046 int i; 1047 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header); 1048 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved); 1049 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun); 1050 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid); 1051 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid); 1052 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags); 1053 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status); 1054 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn); 1055 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes); 1056 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags); 1057 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes); 1058 for (i = 0; i < ATIO2_CDBLEN; i++) { 1059 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]); 1060 } 1061 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen); 1062 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun); 1063 for (i = 0; i < 4; i++) { 1064 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]); 1065 } 1066 for (i = 0; i < 6; i++) { 1067 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i], 1068 atdst->at_reserved2[i]); 1069 } 1070 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid); 1071 } 1072 1073 void 1074 isp_get_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst) 1075 { 1076 int i; 1077 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header); 1078 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved); 1079 ISP_IOXGET_16(isp, &atsrc->at_iid, atdst->at_iid); 1080 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid); 1081 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags); 1082 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status); 1083 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn); 1084 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes); 1085 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags); 1086 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes); 1087 for (i = 0; i < ATIO2_CDBLEN; i++) { 1088 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]); 1089 } 1090 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen); 1091 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun); 1092 for (i = 0; i < 4; i++) { 1093 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]); 1094 } 1095 for (i = 0; i < 6; i++) { 1096 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i], 1097 atdst->at_reserved2[i]); 1098 } 1099 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid); 1100 } 1101 1102 void 1103 isp_put_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst) 1104 { 1105 int i; 1106 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1107 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved); 1108 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle); 1109 if (ISP_IS_SBUS(isp)) { 1110 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun); 1111 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid); 1112 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_reserved2); 1113 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_tgt); 1114 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_scsi_status); 1115 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, &ctdst->ct_status); 1116 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_val); 1117 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_type); 1118 } else { 1119 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid); 1120 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun); 1121 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_tgt); 1122 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_reserved2); 1123 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, 1124 &ctdst->ct_scsi_status); 1125 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_status); 1126 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_type); 1127 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_val); 1128 } 1129 ISP_IOXPUT_32(isp, ctsrc->ct_flags, &ctdst->ct_flags); 1130 ISP_IOXPUT_32(isp, ctsrc->ct_xfrlen, &ctdst->ct_xfrlen); 1131 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid); 1132 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout); 1133 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count); 1134 for (i = 0; i < ISP_RQDSEG; i++) { 1135 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base, 1136 &ctdst->ct_dataseg[i].ds_base); 1137 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count, 1138 &ctdst->ct_dataseg[i].ds_count); 1139 } 1140 } 1141 1142 void 1143 isp_get_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst) 1144 { 1145 int i; 1146 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1147 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved); 1148 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle); 1149 if (ISP_IS_SBUS(isp)) { 1150 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid); 1151 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun); 1152 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_tgt); 1153 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_reserved2); 1154 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_scsi_status); 1155 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, ctdst->ct_status); 1156 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_type); 1157 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_val); 1158 } else { 1159 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun); 1160 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid); 1161 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_reserved2); 1162 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_tgt); 1163 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_status); 1164 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, 1165 ctdst->ct_scsi_status); 1166 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_val); 1167 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_type); 1168 } 1169 ISP_IOXGET_32(isp, &ctsrc->ct_flags, ctdst->ct_flags); 1170 ISP_IOXGET_32(isp, &ctsrc->ct_xfrlen, ctdst->ct_xfrlen); 1171 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid); 1172 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout); 1173 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count); 1174 for (i = 0; i < ISP_RQDSEG; i++) { 1175 ISP_IOXGET_32(isp, 1176 &ctsrc->ct_dataseg[i].ds_base, 1177 ctdst->ct_dataseg[i].ds_base); 1178 ISP_IOXGET_32(isp, 1179 &ctsrc->ct_dataseg[i].ds_count, 1180 ctdst->ct_dataseg[i].ds_count); 1181 } 1182 } 1183 1184 void 1185 isp_put_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst) 1186 { 1187 int i; 1188 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1189 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved); 1190 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle); 1191 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun); 1192 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid); 1193 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid); 1194 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags); 1195 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout); 1196 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count); 1197 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid); 1198 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff); 1199 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) { 1200 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved, 1201 &ctdst->rsp.m0._reserved); 1202 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2, 1203 &ctdst->rsp.m0._reserved2); 1204 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status, 1205 &ctdst->rsp.m0.ct_scsi_status); 1206 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen, 1207 &ctdst->rsp.m0.ct_xfrlen); 1208 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) { 1209 for (i = 0; i < ISP_RQDSEG_T2; i++) { 1210 ISP_IOXPUT_32(isp, 1211 ctsrc->rsp.m0.ct_dataseg[i].ds_base, 1212 &ctdst->rsp.m0.ct_dataseg[i].ds_base); 1213 ISP_IOXPUT_32(isp, 1214 ctsrc->rsp.m0.ct_dataseg[i].ds_count, 1215 &ctdst->rsp.m0.ct_dataseg[i].ds_count); 1216 } 1217 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) { 1218 for (i = 0; i < ISP_RQDSEG_T3; i++) { 1219 ISP_IOXPUT_32(isp, 1220 ctsrc->rsp.m0.ct_dataseg64[i].ds_base, 1221 &ctdst->rsp.m0.ct_dataseg64[i].ds_base); 1222 ISP_IOXPUT_32(isp, 1223 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi, 1224 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi); 1225 ISP_IOXPUT_32(isp, 1226 ctsrc->rsp.m0.ct_dataseg64[i].ds_count, 1227 &ctdst->rsp.m0.ct_dataseg64[i].ds_count); 1228 } 1229 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) { 1230 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type, 1231 &ctdst->rsp.m0.ct_dslist.ds_type); 1232 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment, 1233 &ctdst->rsp.m0.ct_dslist.ds_segment); 1234 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base, 1235 &ctdst->rsp.m0.ct_dslist.ds_base); 1236 } 1237 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) { 1238 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved, 1239 &ctdst->rsp.m1._reserved); 1240 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2, 1241 &ctdst->rsp.m1._reserved2); 1242 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen, 1243 &ctdst->rsp.m1.ct_senselen); 1244 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status, 1245 &ctdst->rsp.m1.ct_scsi_status); 1246 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen, 1247 &ctdst->rsp.m1.ct_resplen); 1248 for (i = 0; i < MAXRESPLEN; i++) { 1249 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i], 1250 &ctdst->rsp.m1.ct_resp[i]); 1251 } 1252 } else { 1253 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved, 1254 &ctdst->rsp.m2._reserved); 1255 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2, 1256 &ctdst->rsp.m2._reserved2); 1257 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3, 1258 &ctdst->rsp.m2._reserved3); 1259 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen, 1260 &ctdst->rsp.m2.ct_datalen); 1261 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base, 1262 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base); 1263 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count, 1264 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count); 1265 } 1266 } 1267 1268 void 1269 isp_put_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst) 1270 { 1271 int i; 1272 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1273 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved); 1274 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle); 1275 ISP_IOXPUT_16(isp, ctsrc->ct_iid, &ctdst->ct_iid); 1276 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid); 1277 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags); 1278 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout); 1279 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count); 1280 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid); 1281 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff); 1282 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) { 1283 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved, 1284 &ctdst->rsp.m0._reserved); 1285 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2, 1286 &ctdst->rsp.m0._reserved2); 1287 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status, 1288 &ctdst->rsp.m0.ct_scsi_status); 1289 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen, 1290 &ctdst->rsp.m0.ct_xfrlen); 1291 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) { 1292 for (i = 0; i < ISP_RQDSEG_T2; i++) { 1293 ISP_IOXPUT_32(isp, 1294 ctsrc->rsp.m0.ct_dataseg[i].ds_base, 1295 &ctdst->rsp.m0.ct_dataseg[i].ds_base); 1296 ISP_IOXPUT_32(isp, 1297 ctsrc->rsp.m0.ct_dataseg[i].ds_count, 1298 &ctdst->rsp.m0.ct_dataseg[i].ds_count); 1299 } 1300 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) { 1301 for (i = 0; i < ISP_RQDSEG_T3; i++) { 1302 ISP_IOXPUT_32(isp, 1303 ctsrc->rsp.m0.ct_dataseg64[i].ds_base, 1304 &ctdst->rsp.m0.ct_dataseg64[i].ds_base); 1305 ISP_IOXPUT_32(isp, 1306 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi, 1307 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi); 1308 ISP_IOXPUT_32(isp, 1309 ctsrc->rsp.m0.ct_dataseg64[i].ds_count, 1310 &ctdst->rsp.m0.ct_dataseg64[i].ds_count); 1311 } 1312 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) { 1313 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type, 1314 &ctdst->rsp.m0.ct_dslist.ds_type); 1315 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment, 1316 &ctdst->rsp.m0.ct_dslist.ds_segment); 1317 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base, 1318 &ctdst->rsp.m0.ct_dslist.ds_base); 1319 } 1320 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) { 1321 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved, 1322 &ctdst->rsp.m1._reserved); 1323 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2, 1324 &ctdst->rsp.m1._reserved2); 1325 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen, 1326 &ctdst->rsp.m1.ct_senselen); 1327 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status, 1328 &ctdst->rsp.m1.ct_scsi_status); 1329 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen, 1330 &ctdst->rsp.m1.ct_resplen); 1331 for (i = 0; i < MAXRESPLEN; i++) { 1332 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i], 1333 &ctdst->rsp.m1.ct_resp[i]); 1334 } 1335 } else { 1336 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved, 1337 &ctdst->rsp.m2._reserved); 1338 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2, 1339 &ctdst->rsp.m2._reserved2); 1340 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3, 1341 &ctdst->rsp.m2._reserved3); 1342 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen, 1343 &ctdst->rsp.m2.ct_datalen); 1344 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base, 1345 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base); 1346 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count, 1347 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count); 1348 } 1349 } 1350 1351 void 1352 isp_get_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst) 1353 { 1354 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1355 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved); 1356 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle); 1357 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun); 1358 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid); 1359 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid); 1360 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags); 1361 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status); 1362 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout); 1363 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count); 1364 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff); 1365 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid); 1366 } 1367 1368 void 1369 isp_get_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst) 1370 { 1371 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header); 1372 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved); 1373 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle); 1374 ISP_IOXGET_16(isp, &ctsrc->ct_iid, ctdst->ct_iid); 1375 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid); 1376 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags); 1377 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status); 1378 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout); 1379 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count); 1380 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff); 1381 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid); 1382 } 1383 1384 void 1385 isp_put_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst) 1386 { 1387 int i; 1388 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header); 1389 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved); 1390 if (ISP_IS_SBUS(isp)) { 1391 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd); 1392 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun); 1393 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt); 1394 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops); 1395 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2); 1396 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status); 1397 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_in_count); 1398 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_cmd_count); 1399 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb7len); 1400 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb6len); 1401 } else { 1402 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_lun); 1403 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_rsvd); 1404 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_ops); 1405 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_tgt); 1406 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_status); 1407 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_reserved2); 1408 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_cmd_count); 1409 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_in_count); 1410 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb6len); 1411 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb7len); 1412 } 1413 ISP_IOXPUT_32(isp, lesrc->le_flags, &ledst->le_flags); 1414 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout); 1415 for (i = 0; i < 20; i++) { 1416 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i], 1417 &ledst->le_reserved3[i]); 1418 } 1419 } 1420 1421 void 1422 isp_get_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst) 1423 { 1424 int i; 1425 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header); 1426 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved); 1427 if (ISP_IS_SBUS(isp)) { 1428 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd); 1429 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun); 1430 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt); 1431 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops); 1432 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2); 1433 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status); 1434 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_in_count); 1435 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_cmd_count); 1436 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb7len); 1437 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb6len); 1438 } else { 1439 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_lun); 1440 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_rsvd); 1441 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_ops); 1442 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_tgt); 1443 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_status); 1444 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_reserved2); 1445 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_cmd_count); 1446 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_in_count); 1447 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb6len); 1448 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb7len); 1449 } 1450 ISP_IOXGET_32(isp, &lesrc->le_flags, ledst->le_flags); 1451 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout); 1452 for (i = 0; i < 20; i++) { 1453 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i], 1454 ledst->le_reserved3[i]); 1455 } 1456 } 1457 1458 void 1459 isp_put_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst) 1460 { 1461 int i; 1462 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header); 1463 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved); 1464 if (ISP_IS_SBUS(isp)) { 1465 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid); 1466 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun); 1467 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt); 1468 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_reserved2); 1469 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_rsvd2); 1470 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_status); 1471 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_type); 1472 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_val); 1473 } else { 1474 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun); 1475 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid); 1476 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_reserved2); 1477 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_tgt); 1478 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_status); 1479 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_rsvd2); 1480 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_val); 1481 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_type); 1482 } 1483 ISP_IOXPUT_32(isp, insrc->in_flags, &indst->in_flags); 1484 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid); 1485 for (i = 0; i < IN_MSGLEN; i++) { 1486 ISP_IOXPUT_8(isp, insrc->in_msg[i], &indst->in_msg[i]); 1487 } 1488 for (i = 0; i < IN_RSVDLEN; i++) { 1489 ISP_IOXPUT_8(isp, insrc->in_reserved3[i], 1490 &indst->in_reserved3[i]); 1491 } 1492 for (i = 0; i < QLTM_SENSELEN; i++) { 1493 ISP_IOXPUT_8(isp, insrc->in_sense[i], 1494 &indst->in_sense[i]); 1495 } 1496 } 1497 1498 void 1499 isp_get_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst) 1500 { 1501 int i; 1502 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header); 1503 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved); 1504 if (ISP_IS_SBUS(isp)) { 1505 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid); 1506 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun); 1507 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt); 1508 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_reserved2); 1509 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_rsvd2); 1510 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_status); 1511 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_type); 1512 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_val); 1513 } else { 1514 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun); 1515 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid); 1516 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_reserved2); 1517 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_tgt); 1518 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_status); 1519 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_rsvd2); 1520 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_val); 1521 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_type); 1522 } 1523 ISP_IOXGET_32(isp, &insrc->in_flags, indst->in_flags); 1524 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid); 1525 for (i = 0; i < IN_MSGLEN; i++) { 1526 ISP_IOXGET_8(isp, &insrc->in_msg[i], indst->in_msg[i]); 1527 } 1528 for (i = 0; i < IN_RSVDLEN; i++) { 1529 ISP_IOXGET_8(isp, &insrc->in_reserved3[i], 1530 indst->in_reserved3[i]); 1531 } 1532 for (i = 0; i < QLTM_SENSELEN; i++) { 1533 ISP_IOXGET_8(isp, &insrc->in_sense[i], 1534 indst->in_sense[i]); 1535 } 1536 } 1537 1538 void 1539 isp_put_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc, 1540 in_fcentry_t *indst) 1541 { 1542 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header); 1543 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved); 1544 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun); 1545 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid); 1546 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun); 1547 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2); 1548 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status); 1549 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags); 1550 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid); 1551 } 1552 1553 void 1554 isp_put_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc, 1555 in_fcentry_e_t *indst) 1556 { 1557 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header); 1558 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved); 1559 ISP_IOXPUT_16(isp, insrc->in_iid, &indst->in_iid); 1560 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun); 1561 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2); 1562 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status); 1563 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags); 1564 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid); 1565 } 1566 1567 void 1568 isp_get_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc, 1569 in_fcentry_t *indst) 1570 { 1571 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header); 1572 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved); 1573 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun); 1574 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid); 1575 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun); 1576 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2); 1577 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status); 1578 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags); 1579 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid); 1580 } 1581 1582 void 1583 isp_get_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc, 1584 in_fcentry_e_t *indst) 1585 { 1586 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header); 1587 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved); 1588 ISP_IOXGET_16(isp, &insrc->in_iid, indst->in_iid); 1589 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun); 1590 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2); 1591 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status); 1592 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags); 1593 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid); 1594 } 1595 1596 void 1597 isp_put_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst) 1598 { 1599 int i; 1600 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header); 1601 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved); 1602 if (ISP_IS_SBUS(isp)) { 1603 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid); 1604 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun); 1605 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event); 1606 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_status); 1607 } else { 1608 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun); 1609 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid); 1610 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_status); 1611 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_event); 1612 } 1613 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags); 1614 for (i = 0; i < NA_RSVDLEN; i++) { 1615 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i], 1616 &nadst->na_reserved3[i]); 1617 } 1618 } 1619 1620 void 1621 isp_get_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst) 1622 { 1623 int i; 1624 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header); 1625 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved); 1626 if (ISP_IS_SBUS(isp)) { 1627 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid); 1628 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun); 1629 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event); 1630 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_status); 1631 } else { 1632 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun); 1633 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid); 1634 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_status); 1635 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_event); 1636 } 1637 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags); 1638 for (i = 0; i < NA_RSVDLEN; i++) { 1639 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i], 1640 nadst->na_reserved3[i]); 1641 } 1642 } 1643 1644 void 1645 isp_put_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc, 1646 na_fcentry_t *nadst) 1647 { 1648 int i; 1649 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header); 1650 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved); 1651 ISP_IOXPUT_8(isp, nasrc->na_reserved1, &nadst->na_reserved1); 1652 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid); 1653 ISP_IOXPUT_16(isp, nasrc->na_response, &nadst->na_response); 1654 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags); 1655 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2); 1656 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status); 1657 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags); 1658 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid); 1659 for (i = 0; i < NA2_RSVDLEN; i++) { 1660 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i], 1661 &nadst->na_reserved3[i]); 1662 } 1663 } 1664 1665 void 1666 isp_put_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc, 1667 na_fcentry_e_t *nadst) 1668 { 1669 int i; 1670 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header); 1671 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved); 1672 ISP_IOXPUT_16(isp, nasrc->na_iid, &nadst->na_iid); 1673 ISP_IOXPUT_16(isp, nasrc->na_response, &nadst->na_response); 1674 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags); 1675 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2); 1676 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status); 1677 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags); 1678 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid); 1679 for (i = 0; i < NA2_RSVDLEN; i++) { 1680 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i], 1681 &nadst->na_reserved3[i]); 1682 } 1683 } 1684 1685 void 1686 isp_get_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc, 1687 na_fcentry_t *nadst) 1688 { 1689 int i; 1690 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header); 1691 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved); 1692 ISP_IOXGET_8(isp, &nasrc->na_reserved1, nadst->na_reserved1); 1693 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid); 1694 ISP_IOXGET_16(isp, &nasrc->na_response, nadst->na_response); 1695 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags); 1696 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2); 1697 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status); 1698 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags); 1699 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid); 1700 for (i = 0; i < NA2_RSVDLEN; i++) { 1701 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i], 1702 nadst->na_reserved3[i]); 1703 } 1704 } 1705 1706 void 1707 isp_get_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc, 1708 na_fcentry_e_t *nadst) 1709 { 1710 int i; 1711 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header); 1712 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved); 1713 ISP_IOXGET_16(isp, &nasrc->na_iid, nadst->na_iid); 1714 ISP_IOXGET_16(isp, &nasrc->na_response, nadst->na_response); 1715 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags); 1716 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2); 1717 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status); 1718 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags); 1719 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid); 1720 for (i = 0; i < NA2_RSVDLEN; i++) { 1721 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i], 1722 nadst->na_reserved3[i]); 1723 } 1724 } 1725 #endif /* ISP_TARGET_MODE */ 1726