sys/dev/disk/isp/isp_inline.h

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