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