The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/isp_inline.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: c30fd3da457a8ef1a6069fc8fc4af75a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.