sys/dev/isp/isp_library.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  *  Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
   5  *  Copyright (c) 1997-2009 by Matthew Jacob
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions
  10  *  are met:
  11  *
  12  *  1. Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *  2. Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions and the following disclaimer in the
  16  *     documentation and/or other materials provided with the distribution.
  17  *
  18  *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  22  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  *  SUCH DAMAGE.
  29  *
  30  */
  31 /*
  32  * Qlogic Host Adapter Internal Library Functions
  33  */
  34 #ifdef  __NetBSD__
  35 #include <sys/cdefs.h>
  36 __KERNEL_RCSID(0, "$NetBSD$");
  37 #include <dev/ic/isp_netbsd.h>
  38 #endif
  39 #ifdef  __FreeBSD__
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42 #include <dev/isp/isp_freebsd.h>
  43 #endif
  44 #ifdef  __OpenBSD__
  45 #include <dev/ic/isp_openbsd.h>
  46 #endif
  47 #ifdef  __linux__
  48 #include "isp_linux.h"
  49 #endif
  50 #ifdef  __svr4__
  51 #include "isp_solaris.h"
  52 #endif
  53
  54 const char *isp_class3_roles[4] = {
  55     "None", "Target", "Initiator", "Target/Initiator"
  56 };
  57
  58 /*
  59  * Command shipping- finish off first queue entry and do dma mapping and additional segments as needed.
  60  *
  61  * Called with the first queue entry at least partially filled out.
  62  */
  63 int
  64 isp_send_cmd(ispsoftc_t *isp, void *fqe, void *segp, uint32_t nsegs, uint32_t totalcnt, isp_ddir_t ddir, ispds64_t *ecmd)
  65 {
  66         ispcontreq64_t crq;
  67         uint8_t type, nqe;
  68         uint32_t seg, seglim, nxt, nxtnxt, ddf;
  69         ispds64_t *dsp64 = NULL;
  70         void *qe0, *qe1;
  71
  72         qe0 = isp_getrqentry(isp);
  73         if (qe0 == NULL) {
  74                 return (CMD_EAGAIN);
  75         }
  76         nxt = ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp));
  77
  78         type = ((isphdr_t *)fqe)->rqs_entry_type;
  79         nqe = 1;
  80
  81         /*
  82          * If we have no data to transmit, just copy the first IOCB and start it up.
  83          */
  84         if (ddir == ISP_NOXFR) {
  85                 ddf = 0;
  86                 goto copy_and_sync;
  87         }
  88
  89         /*
  90          * First figure out how many pieces of data to transfer, what
  91          * kind and how many we can put into the first queue entry.
  92          */
  93         switch (type) {
  94         case RQSTYPE_T7RQS:
  95                 ddf = (ddir == ISP_TO_DEVICE)? FCP_CMND_DATA_WRITE : FCP_CMND_DATA_READ;
  96                 dsp64 = &((ispreqt7_t *)fqe)->req_dataseg;
  97                 seglim = 1;
  98                 break;
  99 #ifdef  ISP_TARGET_MODE
 100         case RQSTYPE_CTIO7:
 101                 dsp64 = &((ct7_entry_t *)fqe)->rsp.m0.ds;
 102                 seglim = 1;
 103                 break;
 104 #endif
 105         default:
 106                 return (CMD_COMPLETE);
 107         }
 108         if (seglim > nsegs)
 109                 seglim = nsegs;
 110         seg = 0;
 111         while (seg < seglim)
 112                 XS_GET_DMA64_SEG(dsp64++, segp, seg++);
 113
 114         /*
 115          * Second, start building additional continuation segments as needed.
 116          */
 117         while (seg < nsegs) {
 118                 nxtnxt = ISP_NXT_QENTRY(nxt, RQUEST_QUEUE_LEN(isp));
 119                 if (nxtnxt == isp->isp_reqodx) {
 120                         isp->isp_reqodx = ISP_READ(isp, BIU2400_REQOUTP);
 121                         if (nxtnxt == isp->isp_reqodx)
 122                                 return (CMD_EAGAIN);
 123                 }
 124                 qe1 = ISP_QUEUE_ENTRY(isp->isp_rquest, nxt);
 125                 nxt = nxtnxt;
 126
 127                 ISP_MEMZERO(&crq, QENTRY_LEN);
 128                 crq.req_header.rqs_entry_type = RQSTYPE_A64_CONT;
 129                 crq.req_header.rqs_entry_count = 1;
 130                 dsp64 = crq.req_dataseg;
 131
 132                 seglim = seg + ISP_CDSEG64;
 133                 if (seglim > nsegs)
 134                         seglim = nsegs;
 135                 while (seg < seglim)
 136                         XS_GET_DMA64_SEG(dsp64++, segp, seg++);
 137                 isp_put_cont64_req(isp, &crq, qe1);
 138                 if (isp->isp_dblev & ISP_LOGDEBUG1) {
 139                         isp_print_bytes(isp, "additional queue entry",
 140                             QENTRY_LEN, qe1);
 141                 }
 142                 nqe++;
 143         }
 144
 145 copy_and_sync:
 146         ((isphdr_t *)fqe)->rqs_entry_count = nqe;
 147         switch (type) {
 148         case RQSTYPE_T7RQS:
 149                 ((ispreqt7_t *)fqe)->req_alen_datadir = ddf;
 150                 ((ispreqt7_t *)fqe)->req_seg_count = nsegs;
 151                 ((ispreqt7_t *)fqe)->req_dl = totalcnt;
 152                 isp_put_request_t7(isp, fqe, qe0);
 153                 break;
 154 #ifdef  ISP_TARGET_MODE
 155         case RQSTYPE_CTIO7:
 156                 if (((ct7_entry_t *)fqe)->ct_flags & CT7_FLAG_MODE2) {
 157                         ((ct7_entry_t *)fqe)->ct_seg_count = 1;
 158                 } else {
 159                         ((ct7_entry_t *)fqe)->ct_seg_count = nsegs;
 160                 }
 161                 isp_put_ctio7(isp, fqe, qe0);
 162                 break;
 163 #endif
 164         default:
 165                 return (CMD_COMPLETE);
 166         }
 167         if (isp->isp_dblev & ISP_LOGDEBUG1) {
 168                 isp_print_bytes(isp, "first queue entry", QENTRY_LEN, qe0);
 169         }
 170         ISP_ADD_REQUEST(isp, nxt);
 171         return (CMD_QUEUED);
 172 }
 173
 174 uint32_t
 175 isp_allocate_handle(ispsoftc_t *isp, void *xs, int type)
 176 {
 177         isp_hdl_t *hdp;
 178
 179         hdp = isp->isp_xffree;
 180         if (hdp == NULL)
 181                 return (ISP_HANDLE_FREE);
 182         isp->isp_xffree = hdp->cmd;
 183         hdp->cmd = xs;
 184         hdp->handle = (hdp - isp->isp_xflist);
 185         hdp->handle |= (type << ISP_HANDLE_USAGE_SHIFT);
 186         hdp->handle |= (isp->isp_seqno++ << ISP_HANDLE_SEQ_SHIFT);
 187         return (hdp->handle);
 188 }
 189
 190 void *
 191 isp_find_xs(ispsoftc_t *isp, uint32_t handle)
 192 {
 193         if (!ISP_VALID_HANDLE(isp, handle)) {
 194                 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
 195                 return (NULL);
 196         }
 197         return (isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].cmd);
 198 }
 199
 200 uint32_t
 201 isp_find_handle(ispsoftc_t *isp, void *xs)
 202 {
 203         uint32_t i, foundhdl = ISP_HANDLE_FREE;
 204
 205         if (xs != NULL) {
 206                 for (i = 0; i < isp->isp_maxcmds; i++) {
 207                         if (isp->isp_xflist[i].cmd != xs) {
 208                                 continue;
 209                         }
 210                         foundhdl = isp->isp_xflist[i].handle;
 211                         break;
 212                 }
 213         }
 214         return (foundhdl);
 215 }
 216
 217 void
 218 isp_destroy_handle(ispsoftc_t *isp, uint32_t handle)
 219 {
 220         if (!ISP_VALID_HANDLE(isp, handle)) {
 221                 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
 222         } else {
 223                 isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].handle = ISP_HANDLE_FREE;
 224                 isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].cmd = isp->isp_xffree;
 225                 isp->isp_xffree = &isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)];
 226         }
 227 }
 228
 229 /*
 230  * Make sure we have space to put something on the request queue.
 231  * Return a pointer to that entry if we do. A side effect of this
 232  * function is to update the output index. The input index
 233  * stays the same.
 234  */
 235 void *
 236 isp_getrqentry(ispsoftc_t *isp)
 237 {
 238         uint32_t next;
 239
 240         next = ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp));
 241         if (next == isp->isp_reqodx) {
 242                 isp->isp_reqodx = ISP_READ(isp, BIU2400_REQOUTP);
 243                 if (next == isp->isp_reqodx)
 244                         return (NULL);
 245         }
 246         return (ISP_QUEUE_ENTRY(isp->isp_rquest, isp->isp_reqidx));
 247 }
 248
 249 #define TBA     (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
 250 void
 251 isp_print_qentry(ispsoftc_t *isp, const char *msg, int idx, void *arg)
 252 {
 253         char buf[TBA];
 254         int amt, i, j;
 255         uint8_t *ptr = arg;
 256
 257         isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx);
 258         for (buf[0] = 0, amt = i = 0; i < 4; i++) {
 259                 buf[0] = 0;
 260                 ISP_SNPRINTF(buf, TBA, "  ");
 261                 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
 262                         ISP_SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff);
 263                 }
 264                 isp_prt(isp, ISP_LOGALL, "%s", buf);
 265         }
 266 }
 267
 268 void
 269 isp_print_bytes(ispsoftc_t *isp, const char *msg, int amt, void *arg)
 270 {
 271         char buf[128];
 272         uint8_t *ptr = arg;
 273         int off;
 274
 275         if (msg)
 276                 isp_prt(isp, ISP_LOGALL, "%s:", msg);
 277         off = 0;
 278         buf[0] = 0;
 279         while (off < amt) {
 280                 int j, to;
 281                 to = off;
 282                 for (j = 0; j < 16; j++) {
 283                         ISP_SNPRINTF(buf, 128, "%s %02x", buf, ptr[off++] & 0xff);
 284                         if (off == amt) {
 285                                 break;
 286                         }
 287                 }
 288                 isp_prt(isp, ISP_LOGALL, "0x%08x:%s", to, buf);
 289                 buf[0] = 0;
 290         }
 291 }
 292
 293 /*
 294  * Do the common path to try and ensure that link is up, we've scanned
 295  * the fabric (if we're on a fabric), and that we've synchronized this
 296  * all with our own database and done the appropriate logins.
 297  *
 298  * We repeatedly check for firmware state and loop state after each
 299  * action because things may have changed while we were doing this.
 300  * Any failure or change of state causes us to return a nonzero value.
 301  *
 302  * We assume we enter here with any locks held.
 303  */
 304
 305 int
 306 isp_fc_runstate(ispsoftc_t *isp, int chan, int tval)
 307 {
 308         fcparam *fcp = FCPARAM(isp, chan);
 309         int res;
 310
 311 again:
 312         if (fcp->role == ISP_ROLE_NONE)
 313                 return (-1);
 314         res = isp_control(isp, ISPCTL_FCLINK_TEST, chan, tval);
 315         if (res > 0)
 316                 goto again;
 317         if (res < 0)
 318                 return (fcp->isp_loopstate);
 319         res = isp_control(isp, ISPCTL_SCAN_LOOP, chan);
 320         if (res > 0)
 321                 goto again;
 322         if (res < 0)
 323                 return (fcp->isp_loopstate);
 324         res = isp_control(isp, ISPCTL_SCAN_FABRIC, chan);
 325         if (res > 0)
 326                 goto again;
 327         if (res < 0)
 328                 return (fcp->isp_loopstate);
 329         res = isp_control(isp, ISPCTL_PDB_SYNC, chan);
 330         if (res > 0)
 331                 goto again;
 332         return (fcp->isp_loopstate);
 333 }
 334
 335 /*
 336  * Fibre Channel Support routines
 337  */
 338 void
 339 isp_dump_portdb(ispsoftc_t *isp, int chan)
 340 {
 341         fcparam *fcp = FCPARAM(isp, chan);
 342         int i;
 343
 344         for (i = 0; i < MAX_FC_TARG; i++) {
 345                 char buf1[64], buf2[64];
 346                 const char *dbs[8] = {
 347                         "NIL ",
 348                         "PROB",
 349                         "DEAD",
 350                         "CHGD",
 351                         "NEW ",
 352                         "PVLD",
 353                         "ZOMB",
 354                         "VLD "
 355                 };
 356                 fcportdb_t *lp = &fcp->portdb[i];
 357
 358                 if (lp->state == FC_PORTDB_STATE_NIL) {
 359                         continue;
 360                 }
 361                 isp_gen_role_str(buf1, sizeof (buf1), lp->prli_word3);
 362                 isp_gen_role_str(buf2, sizeof (buf2), lp->new_prli_word3);
 363                 isp_prt(isp, ISP_LOGALL, "Chan %d [%d]: hdl 0x%x %s %s 0x%06x =>%s 0x%06x; WWNN 0x%08x%08x WWPN 0x%08x%08x",
 364                     chan, i, lp->handle, dbs[lp->state], buf1, lp->portid, buf2, lp->new_portid,
 365                     (uint32_t) (lp->node_wwn >> 32), (uint32_t) (lp->node_wwn), (uint32_t) (lp->port_wwn >> 32), (uint32_t) (lp->port_wwn));
 366         }
 367 }
 368
 369 void
 370 isp_gen_role_str(char *buf, size_t len, uint16_t p3)
 371 {
 372         int nd = 0;
 373         buf[0] = '(';
 374         buf[1] = 0;
 375         if (p3 & PRLI_WD3_ENHANCED_DISCOVERY) {
 376                 nd++;
 377                 strlcat(buf, "EDisc", len);
 378         }
 379         if (p3 & PRLI_WD3_REC_SUPPORT) {
 380                 if (nd++) {
 381                         strlcat(buf, ",", len);
 382                 }
 383                 strlcat(buf, "REC", len);
 384         }
 385         if (p3 & PRLI_WD3_TASK_RETRY_IDENTIFICATION_REQUESTED) {
 386                 if (nd++) {
 387                         strlcat(buf, ",", len);
 388                 }
 389                 strlcat(buf, "RetryID", len);
 390         }
 391         if (p3 & PRLI_WD3_RETRY) {
 392                 if (nd++) {
 393                         strlcat(buf, ",", len);
 394                 }
 395                 strlcat(buf, "Retry", len);
 396         }
 397         if (p3 & PRLI_WD3_CONFIRMED_COMPLETION_ALLOWED) {
 398                 if (nd++) {
 399                         strlcat(buf, ",", len);
 400                 }
 401                 strlcat(buf, "CNFRM", len);
 402         }
 403         if (p3 & PRLI_WD3_DATA_OVERLAY_ALLOWED) {
 404                 if (nd++) {
 405                         strlcat(buf, ",", len);
 406                 }
 407                 strlcat(buf, "DOver", len);
 408         }
 409         if (p3 & PRLI_WD3_INITIATOR_FUNCTION) {
 410                 if (nd++) {
 411                         strlcat(buf, ",", len);
 412                 }
 413                 strlcat(buf, "INI", len);
 414         }
 415         if (p3 & PRLI_WD3_TARGET_FUNCTION) {
 416                 if (nd++) {
 417                         strlcat(buf, ",", len);
 418                 }
 419                 strlcat(buf, "TGT", len);
 420         }
 421         if (p3 & PRLI_WD3_READ_FCP_XFER_RDY_DISABLED) {
 422                 if (nd++) {
 423                         strlcat(buf, ",", len);
 424                 }
 425                 strlcat(buf, "RdXfrDis", len);
 426         }
 427         if (p3 & PRLI_WD3_WRITE_FCP_XFER_RDY_DISABLED) {
 428                 if (nd++) {
 429                         strlcat(buf, ",", len);
 430                 }
 431                 strlcat(buf, "XfrDis", len);
 432         }
 433         strlcat(buf, ")", len);
 434 }
 435
 436 const char *
 437 isp_fc_fw_statename(int state)
 438 {
 439         switch (state) {
 440         case FW_CONFIG_WAIT:    return "Config Wait";
 441         case FW_WAIT_LINK:      return "Wait Link";
 442         case FW_WAIT_LOGIN:     return "Wait Login";
 443         case FW_READY:          return "Ready";
 444         case FW_LOSS_OF_SYNC:   return "Loss Of Sync";
 445         case FW_ERROR:          return "Error";
 446         case FW_REINIT:         return "Re-Init";
 447         case FW_NON_PART:       return "Nonparticipating";
 448         default:                return "?????";
 449         }
 450 }
 451
 452 const char *
 453 isp_fc_loop_statename(int state)
 454 {
 455         switch (state) {
 456         case LOOP_NIL:                  return "NIL";
 457         case LOOP_HAVE_LINK:            return "Have Link";
 458         case LOOP_HAVE_ADDR:            return "Have Address";
 459         case LOOP_TESTING_LINK:         return "Testing Link";
 460         case LOOP_LTEST_DONE:           return "Link Test Done";
 461         case LOOP_SCANNING_LOOP:        return "Scanning Loop";
 462         case LOOP_LSCAN_DONE:           return "Loop Scan Done";
 463         case LOOP_SCANNING_FABRIC:      return "Scanning Fabric";
 464         case LOOP_FSCAN_DONE:           return "Fabric Scan Done";
 465         case LOOP_SYNCING_PDB:          return "Syncing PDB";
 466         case LOOP_READY:                return "Ready";
 467         default:                        return "?????";
 468         }
 469 }
 470
 471 const char *
 472 isp_fc_toponame(fcparam *fcp)
 473 {
 474
 475         if (fcp->isp_loopstate < LOOP_HAVE_ADDR) {
 476                 return "Unavailable";
 477         }
 478         switch (fcp->isp_topo) {
 479         case TOPO_NL_PORT:      return "Private Loop (NL_Port)";
 480         case TOPO_FL_PORT:      return "Public Loop (FL_Port)";
 481         case TOPO_N_PORT:       return "Point-to-Point (N_Port)";
 482         case TOPO_F_PORT:       return "Fabric (F_Port)";
 483         case TOPO_PTP_STUB:     return "Point-to-Point (no response)";
 484         default:                return "?????";
 485         }
 486 }
 487
 488 void
 489 isp_clear_commands(ispsoftc_t *isp)
 490 {
 491         uint32_t tmp;
 492         isp_hdl_t *hdp;
 493 #ifdef  ISP_TARGET_MODE
 494         isp_notify_t notify;
 495 #endif
 496
 497         for (tmp = 0; isp->isp_xflist && tmp < isp->isp_maxcmds; tmp++) {
 498
 499                 hdp = &isp->isp_xflist[tmp];
 500                 switch (ISP_H2HT(hdp->handle)) {
 501                 case ISP_HANDLE_INITIATOR: {
 502                         XS_T *xs = hdp->cmd;
 503                         if (XS_XFRLEN(xs)) {
 504                                 ISP_DMAFREE(isp, xs, hdp->handle);
 505                                 XS_SET_RESID(xs, XS_XFRLEN(xs));
 506                         } else {
 507                                 XS_SET_RESID(xs, 0);
 508                         }
 509                         isp_destroy_handle(isp, hdp->handle);
 510                         XS_SETERR(xs, HBA_BUSRESET);
 511                         isp_done(xs);
 512                         break;
 513                 }
 514 #ifdef  ISP_TARGET_MODE
 515                 case ISP_HANDLE_TARGET: {
 516                         ct7_entry_t ctio;
 517
 518                         ISP_DMAFREE(isp, hdp->cmd, hdp->handle);
 519                         ISP_MEMZERO(&ctio, sizeof(ct7_entry_t));
 520                         ctio.ct_syshandle = hdp->handle;
 521                         ctio.ct_nphdl = CT_HBA_RESET;
 522                         ctio.ct_header.rqs_entry_type = RQSTYPE_CTIO7;
 523                         isp_async(isp, ISPASYNC_TARGET_ACTION, &ctio);
 524                         break;
 525                 }
 526 #endif
 527                 case ISP_HANDLE_CTRL:
 528                         wakeup(hdp->cmd);
 529                         isp_destroy_handle(isp, hdp->handle);
 530                         break;
 531                 }
 532         }
 533 #ifdef  ISP_TARGET_MODE
 534         for (tmp = 0; tmp < isp->isp_nchan; tmp++) {
 535                 ISP_MEMZERO(&notify, sizeof (isp_notify_t));
 536                 notify.nt_ncode = NT_HBA_RESET;
 537                 notify.nt_hba = isp;
 538                 notify.nt_wwn = INI_ANY;
 539                 notify.nt_nphdl = NIL_HANDLE;
 540                 notify.nt_sid = PORT_ANY;
 541                 notify.nt_did = PORT_ANY;
 542                 notify.nt_tgt = TGT_ANY;
 543                 notify.nt_channel = tmp;
 544                 notify.nt_lun = LUN_ANY;
 545                 notify.nt_tagval = TAG_ANY;
 546                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 547         }
 548 #endif
 549 }
 550
 551 /*
 552  * Functions to move stuff to a form that the QLogic RISC engine understands
 553  * and functions to move stuff back to a form the processor understands.
 554  *
 555  * Each platform is required to provide the 8, 16 and 32 bit
 556  * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32})
 557  *
 558  * The assumption is that swizzling and unswizzling is mostly done 'in place'
 559  * (with a few exceptions for efficiency).
 560  */
 561
 562 /*
 563  * Swizzle/Copy Functions
 564  */
 565 void
 566 isp_put_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
 567 {
 568         ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type, &hpdst->rqs_entry_type);
 569         ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count, &hpdst->rqs_entry_count);
 570         ISP_IOXPUT_8(isp, hpsrc->rqs_seqno, &hpdst->rqs_seqno);
 571         ISP_IOXPUT_8(isp, hpsrc->rqs_flags, &hpdst->rqs_flags);
 572 }
 573
 574 void
 575 isp_get_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
 576 {
 577         ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type, hpdst->rqs_entry_type);
 578         ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count, hpdst->rqs_entry_count);
 579         ISP_IOXGET_8(isp, &hpsrc->rqs_seqno, hpdst->rqs_seqno);
 580         ISP_IOXGET_8(isp, &hpsrc->rqs_flags, hpdst->rqs_flags);
 581 }
 582
 583 int
 584 isp_get_response_type(ispsoftc_t *isp, isphdr_t *hp)
 585 {
 586         uint8_t type;
 587         ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
 588         return ((int)type);
 589 }
 590
 591 void
 592 isp_put_marker_24xx(ispsoftc_t *isp, isp_marker_24xx_t *src, isp_marker_24xx_t *dst)
 593 {
 594         int i;
 595         isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
 596         ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
 597         ISP_IOXPUT_16(isp, src->mrk_nphdl, &dst->mrk_nphdl);
 598         ISP_IOXPUT_8(isp, src->mrk_modifier, &dst->mrk_modifier);
 599         ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
 600         ISP_IOXPUT_8(isp, src->mrk_reserved1, &dst->mrk_reserved1);
 601         ISP_IOXPUT_8(isp, src->mrk_vphdl, &dst->mrk_vphdl);
 602         ISP_IOXPUT_8(isp, src->mrk_reserved2, &dst->mrk_reserved2);
 603         for (i = 0; i < nitems(src->mrk_lun); i++) {
 604                 ISP_IOXPUT_8(isp, src->mrk_lun[i], &dst->mrk_lun[i]);
 605         }
 606         for (i = 0; i < nitems(src->mrk_reserved3); i++) {
 607                 ISP_IOXPUT_8(isp, src->mrk_reserved3[i], &dst->mrk_reserved3[i]);
 608         }
 609 }
 610
 611 void
 612 isp_put_request_t7(ispsoftc_t *isp, ispreqt7_t *src, ispreqt7_t *dst)
 613 {
 614         int i;
 615         uint32_t *a, *b;
 616
 617         isp_put_hdr(isp, &src->req_header, &dst->req_header);
 618         ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
 619         ISP_IOXPUT_16(isp, src->req_nphdl, &dst->req_nphdl);
 620         ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
 621         ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
 622         ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
 623         a = (uint32_t *) src->req_lun;
 624         b = (uint32_t *) dst->req_lun;
 625         for (i = 0; i < (nitems(src->req_lun) >> 2); i++ ) {
 626                 *b++ = ISP_SWAP32(isp, *a++);
 627         }
 628         ISP_IOXPUT_8(isp, src->req_alen_datadir, &dst->req_alen_datadir);
 629         ISP_IOXPUT_8(isp, src->req_task_management, &dst->req_task_management);
 630         ISP_IOXPUT_8(isp, src->req_task_attribute, &dst->req_task_attribute);
 631         ISP_IOXPUT_8(isp, src->req_crn, &dst->req_crn);
 632         a = (uint32_t *) src->req_cdb;
 633         b = (uint32_t *) dst->req_cdb;
 634         for (i = 0; i < (nitems(src->req_cdb) >> 2); i++) {
 635                 *b++ = ISP_SWAP32(isp, *a++);
 636         }
 637         ISP_IOXPUT_32(isp, src->req_dl, &dst->req_dl);
 638         ISP_IOXPUT_16(isp, src->req_tidlo, &dst->req_tidlo);
 639         ISP_IOXPUT_8(isp, src->req_tidhi, &dst->req_tidhi);
 640         ISP_IOXPUT_8(isp, src->req_vpidx, &dst->req_vpidx);
 641         ISP_IOXPUT_32(isp, src->req_dataseg.ds_base, &dst->req_dataseg.ds_base);
 642         ISP_IOXPUT_32(isp, src->req_dataseg.ds_basehi, &dst->req_dataseg.ds_basehi);
 643         ISP_IOXPUT_32(isp, src->req_dataseg.ds_count, &dst->req_dataseg.ds_count);
 644 }
 645
 646 void
 647 isp_put_24xx_tmf(ispsoftc_t *isp, isp24xx_tmf_t *src, isp24xx_tmf_t *dst)
 648 {
 649         int i;
 650         uint32_t *a, *b;
 651
 652         isp_put_hdr(isp, &src->tmf_header, &dst->tmf_header);
 653         ISP_IOXPUT_32(isp, src->tmf_handle, &dst->tmf_handle);
 654         ISP_IOXPUT_16(isp, src->tmf_nphdl, &dst->tmf_nphdl);
 655         ISP_IOXPUT_16(isp, src->tmf_delay, &dst->tmf_delay);
 656         ISP_IOXPUT_16(isp, src->tmf_timeout, &dst->tmf_timeout);
 657         for (i = 0; i < nitems(src->tmf_reserved0); i++) {
 658                 ISP_IOXPUT_8(isp, src->tmf_reserved0[i], &dst->tmf_reserved0[i]);
 659         }
 660         a = (uint32_t *) src->tmf_lun;
 661         b = (uint32_t *) dst->tmf_lun;
 662         for (i = 0; i < (nitems(src->tmf_lun) >> 2); i++ ) {
 663                 *b++ = ISP_SWAP32(isp, *a++);
 664         }
 665         ISP_IOXPUT_32(isp, src->tmf_flags, &dst->tmf_flags);
 666         for (i = 0; i < nitems(src->tmf_reserved1); i++) {
 667                 ISP_IOXPUT_8(isp, src->tmf_reserved1[i], &dst->tmf_reserved1[i]);
 668         }
 669         ISP_IOXPUT_16(isp, src->tmf_tidlo, &dst->tmf_tidlo);
 670         ISP_IOXPUT_8(isp, src->tmf_tidhi, &dst->tmf_tidhi);
 671         ISP_IOXPUT_8(isp, src->tmf_vpidx, &dst->tmf_vpidx);
 672         for (i = 0; i < nitems(src->tmf_reserved2); i++) {
 673                 ISP_IOXPUT_8(isp, src->tmf_reserved2[i], &dst->tmf_reserved2[i]);
 674         }
 675 }
 676
 677 void
 678 isp_put_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
 679 {
 680         int i;
 681         isp_put_hdr(isp, &src->abrt_header, &dst->abrt_header);
 682         ISP_IOXPUT_32(isp, src->abrt_handle, &dst->abrt_handle);
 683         ISP_IOXPUT_16(isp, src->abrt_nphdl, &dst->abrt_nphdl);
 684         ISP_IOXPUT_16(isp, src->abrt_options, &dst->abrt_options);
 685         ISP_IOXPUT_32(isp, src->abrt_cmd_handle, &dst->abrt_cmd_handle);
 686         ISP_IOXPUT_16(isp, src->abrt_queue_number, &dst->abrt_queue_number);
 687         for (i = 0; i < nitems(src->abrt_reserved); i++) {
 688                 ISP_IOXPUT_8(isp, src->abrt_reserved[i], &dst->abrt_reserved[i]);
 689         }
 690         ISP_IOXPUT_16(isp, src->abrt_tidlo, &dst->abrt_tidlo);
 691         ISP_IOXPUT_8(isp, src->abrt_tidhi, &dst->abrt_tidhi);
 692         ISP_IOXPUT_8(isp, src->abrt_vpidx, &dst->abrt_vpidx);
 693         for (i = 0; i < nitems(src->abrt_reserved1); i++) {
 694                 ISP_IOXPUT_8(isp, src->abrt_reserved1[i], &dst->abrt_reserved1[i]);
 695         }
 696 }
 697
 698 void
 699 isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *src, ispcontreq64_t *dst)
 700 {
 701         int i;
 702         isp_put_hdr(isp, &src->req_header, &dst->req_header);
 703         for (i = 0; i < ISP_CDSEG64; i++) {
 704                 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
 705                 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi, &dst->req_dataseg[i].ds_basehi);
 706                 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
 707         }
 708 }
 709
 710 void
 711 isp_get_cont_response(ispsoftc_t *isp, ispstatus_cont_t *src, ispstatus_cont_t *dst)
 712 {
 713         int i;
 714         uint32_t *a, *b;
 715
 716         isp_get_hdr(isp, &src->req_header, &dst->req_header);
 717         a = (uint32_t *) src->req_sense_data;
 718         b = (uint32_t *) dst->req_sense_data;
 719         for (i = 0; i < (sizeof (src->req_sense_data) / sizeof (uint32_t)); i++)
 720                 ISP_IOZGET_32(isp, a++, *b++);
 721 }
 722
 723 void
 724 isp_get_24xx_response(ispsoftc_t *isp, isp24xx_statusreq_t *src, isp24xx_statusreq_t *dst)
 725 {
 726         int i;
 727         uint32_t *s, *d;
 728
 729         isp_get_hdr(isp, &src->req_header, &dst->req_header);
 730         ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
 731         ISP_IOXGET_16(isp, &src->req_completion_status, dst->req_completion_status);
 732         ISP_IOXGET_16(isp, &src->req_oxid, dst->req_oxid);
 733         ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
 734         ISP_IOXGET_16(isp, &src->req_reserved0, dst->req_reserved0);
 735         ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
 736         ISP_IOXGET_16(isp, &src->req_retry_delay, dst->req_retry_delay);
 737         ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
 738         ISP_IOXGET_32(isp, &src->req_fcp_residual, dst->req_fcp_residual);
 739         ISP_IOXGET_32(isp, &src->req_sense_len, dst->req_sense_len);
 740         ISP_IOXGET_32(isp, &src->req_response_len, dst->req_response_len);
 741         s = (uint32_t *)src->req_rsp_sense;
 742         d = (uint32_t *)dst->req_rsp_sense;
 743         for (i = 0; i < (nitems(src->req_rsp_sense) >> 2); i++) {
 744                 d[i] = ISP_SWAP32(isp, s[i]);
 745         }
 746 }
 747
 748 void
 749 isp_get_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
 750 {
 751         int i;
 752         isp_get_hdr(isp, &src->abrt_header, &dst->abrt_header);
 753         ISP_IOXGET_32(isp, &src->abrt_handle, dst->abrt_handle);
 754         ISP_IOXGET_16(isp, &src->abrt_nphdl, dst->abrt_nphdl);
 755         ISP_IOXGET_16(isp, &src->abrt_options, dst->abrt_options);
 756         ISP_IOXGET_32(isp, &src->abrt_cmd_handle, dst->abrt_cmd_handle);
 757         ISP_IOXGET_16(isp, &src->abrt_queue_number, dst->abrt_queue_number);
 758         for (i = 0; i < nitems(src->abrt_reserved); i++) {
 759                 ISP_IOXGET_8(isp, &src->abrt_reserved[i], dst->abrt_reserved[i]);
 760         }
 761         ISP_IOXGET_16(isp, &src->abrt_tidlo, dst->abrt_tidlo);
 762         ISP_IOXGET_8(isp, &src->abrt_tidhi, dst->abrt_tidhi);
 763         ISP_IOXGET_8(isp, &src->abrt_vpidx, dst->abrt_vpidx);
 764         for (i = 0; i < nitems(src->abrt_reserved1); i++) {
 765                 ISP_IOXGET_8(isp, &src->abrt_reserved1[i], dst->abrt_reserved1[i]);
 766         }
 767 }
 768
 769 void
 770 isp_put_icb_2400(ispsoftc_t *isp, isp_icb_2400_t *src, isp_icb_2400_t *dst)
 771 {
 772         int i;
 773         ISP_IOXPUT_16(isp, src->icb_version, &dst->icb_version);
 774         ISP_IOXPUT_16(isp, src->icb_reserved0, &dst->icb_reserved0);
 775         ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
 776         ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
 777         ISP_IOXPUT_16(isp, src->icb_xchgcnt, &dst->icb_xchgcnt);
 778         ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
 779         for (i = 0; i < 8; i++) {
 780                 ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
 781         }
 782         for (i = 0; i < 8; i++) {
 783                 ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
 784         }
 785         ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
 786         ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
 787         ISP_IOXPUT_16(isp, src->icb_retry_count, &dst->icb_retry_count);
 788         ISP_IOXPUT_16(isp, src->icb_priout, &dst->icb_priout);
 789         ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
 790         ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
 791         ISP_IOXPUT_16(isp, src->icb_ldn_nols, &dst->icb_ldn_nols);
 792         ISP_IOXPUT_16(isp, src->icb_prqstqlen, &dst->icb_prqstqlen);
 793         for (i = 0; i < 4; i++) {
 794                 ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
 795         }
 796         for (i = 0; i < 4; i++) {
 797                 ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
 798         }
 799         for (i = 0; i < 4; i++) {
 800                 ISP_IOXPUT_16(isp, src->icb_priaddr[i], &dst->icb_priaddr[i]);
 801         }
 802         ISP_IOXPUT_16(isp, src->icb_msixresp, &dst->icb_msixresp);
 803         ISP_IOXPUT_16(isp, src->icb_msixatio, &dst->icb_msixatio);
 804         for (i = 0; i < 2; i++) {
 805                 ISP_IOXPUT_16(isp, src->icb_reserved1[i], &dst->icb_reserved1[i]);
 806         }
 807         ISP_IOXPUT_16(isp, src->icb_atio_in, &dst->icb_atio_in);
 808         ISP_IOXPUT_16(isp, src->icb_atioqlen, &dst->icb_atioqlen);
 809         for (i = 0; i < 4; i++) {
 810                 ISP_IOXPUT_16(isp, src->icb_atioqaddr[i], &dst->icb_atioqaddr[i]);
 811         }
 812         ISP_IOXPUT_16(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
 813         ISP_IOXPUT_16(isp, src->icb_logintime, &dst->icb_logintime);
 814         ISP_IOXPUT_32(isp, src->icb_fwoptions1, &dst->icb_fwoptions1);
 815         ISP_IOXPUT_32(isp, src->icb_fwoptions2, &dst->icb_fwoptions2);
 816         ISP_IOXPUT_32(isp, src->icb_fwoptions3, &dst->icb_fwoptions3);
 817         ISP_IOXPUT_16(isp, src->icb_qos, &dst->icb_qos);
 818         for (i = 0; i < 3; i++)
 819                 ISP_IOXPUT_16(isp, src->icb_reserved2[i], &dst->icb_reserved2[i]);
 820         for (i = 0; i < 3; i++)
 821                 ISP_IOXPUT_16(isp, src->icb_enodemac[i], &dst->icb_enodemac[i]);
 822         ISP_IOXPUT_16(isp, src->icb_disctime, &dst->icb_disctime);
 823         for (i = 0; i < 4; i++)
 824                 ISP_IOXPUT_16(isp, src->icb_reserved3[i], &dst->icb_reserved3[i]);
 825 }
 826
 827 void
 828 isp_put_icb_2400_vpinfo(ispsoftc_t *isp, isp_icb_2400_vpinfo_t *src, isp_icb_2400_vpinfo_t *dst)
 829 {
 830         ISP_IOXPUT_16(isp, src->vp_count, &dst->vp_count);
 831         ISP_IOXPUT_16(isp, src->vp_global_options, &dst->vp_global_options);
 832 }
 833
 834 void
 835 isp_put_vp_port_info(ispsoftc_t *isp, vp_port_info_t *src, vp_port_info_t *dst)
 836 {
 837         int i;
 838         ISP_IOXPUT_16(isp, src->vp_port_status, &dst->vp_port_status);
 839         ISP_IOXPUT_8(isp, src->vp_port_options, &dst->vp_port_options);
 840         ISP_IOXPUT_8(isp, src->vp_port_loopid, &dst->vp_port_loopid);
 841         for (i = 0; i < 8; i++) {
 842                 ISP_IOXPUT_8(isp, src->vp_port_portname[i], &dst->vp_port_portname[i]);
 843         }
 844         for (i = 0; i < 8; i++) {
 845                 ISP_IOXPUT_8(isp, src->vp_port_nodename[i], &dst->vp_port_nodename[i]);
 846         }
 847         /* we never *put* portid_lo/portid_hi */
 848 }
 849
 850 void
 851 isp_get_vp_port_info(ispsoftc_t *isp, vp_port_info_t *src, vp_port_info_t *dst)
 852 {
 853         int i;
 854         ISP_IOXGET_16(isp, &src->vp_port_status, dst->vp_port_status);
 855         ISP_IOXGET_8(isp, &src->vp_port_options, dst->vp_port_options);
 856         ISP_IOXGET_8(isp, &src->vp_port_loopid, dst->vp_port_loopid);
 857         for (i = 0; i < nitems(src->vp_port_portname); i++) {
 858                 ISP_IOXGET_8(isp, &src->vp_port_portname[i], dst->vp_port_portname[i]);
 859         }
 860         for (i = 0; i < nitems(src->vp_port_nodename); i++) {
 861                 ISP_IOXGET_8(isp, &src->vp_port_nodename[i], dst->vp_port_nodename[i]);
 862         }
 863         ISP_IOXGET_16(isp, &src->vp_port_portid_lo, dst->vp_port_portid_lo);
 864         ISP_IOXGET_16(isp, &src->vp_port_portid_hi, dst->vp_port_portid_hi);
 865 }
 866
 867 void
 868 isp_put_vp_ctrl_info(ispsoftc_t *isp, vp_ctrl_info_t *src, vp_ctrl_info_t *dst)
 869 {
 870         int i;
 871         isp_put_hdr(isp, &src->vp_ctrl_hdr, &dst->vp_ctrl_hdr);
 872         ISP_IOXPUT_32(isp, src->vp_ctrl_handle, &dst->vp_ctrl_handle);
 873         ISP_IOXPUT_16(isp, src->vp_ctrl_index_fail, &dst->vp_ctrl_index_fail);
 874         ISP_IOXPUT_16(isp, src->vp_ctrl_status, &dst->vp_ctrl_status);
 875         ISP_IOXPUT_16(isp, src->vp_ctrl_command, &dst->vp_ctrl_command);
 876         ISP_IOXPUT_16(isp, src->vp_ctrl_vp_count, &dst->vp_ctrl_vp_count);
 877         for (i = 0; i < nitems(src->vp_ctrl_idmap); i++) {
 878                 ISP_IOXPUT_16(isp, src->vp_ctrl_idmap[i], &dst->vp_ctrl_idmap[i]);
 879         }
 880         for (i = 0; i < nitems(src->vp_ctrl_reserved); i++) {
 881                 ISP_IOXPUT_16(isp, src->vp_ctrl_reserved[i], &dst->vp_ctrl_reserved[i]);
 882         }
 883         ISP_IOXPUT_16(isp, src->vp_ctrl_fcf_index, &dst->vp_ctrl_fcf_index);
 884 }
 885
 886 void
 887 isp_get_vp_ctrl_info(ispsoftc_t *isp, vp_ctrl_info_t *src, vp_ctrl_info_t *dst)
 888 {
 889         int i;
 890         isp_get_hdr(isp, &src->vp_ctrl_hdr, &dst->vp_ctrl_hdr);
 891         ISP_IOXGET_32(isp, &src->vp_ctrl_handle, dst->vp_ctrl_handle);
 892         ISP_IOXGET_16(isp, &src->vp_ctrl_index_fail, dst->vp_ctrl_index_fail);
 893         ISP_IOXGET_16(isp, &src->vp_ctrl_status, dst->vp_ctrl_status);
 894         ISP_IOXGET_16(isp, &src->vp_ctrl_command, dst->vp_ctrl_command);
 895         ISP_IOXGET_16(isp, &src->vp_ctrl_vp_count, dst->vp_ctrl_vp_count);
 896         for (i = 0; i < nitems(src->vp_ctrl_idmap); i++) {
 897                 ISP_IOXGET_16(isp, &src->vp_ctrl_idmap[i], dst->vp_ctrl_idmap[i]);
 898         }
 899         for (i = 0; i < nitems(src->vp_ctrl_reserved); i++) {
 900                 ISP_IOXGET_16(isp, &src->vp_ctrl_reserved[i], dst->vp_ctrl_reserved[i]);
 901         }
 902         ISP_IOXGET_16(isp, &src->vp_ctrl_fcf_index, dst->vp_ctrl_fcf_index);
 903 }
 904
 905 void
 906 isp_put_vp_modify(ispsoftc_t *isp, vp_modify_t *src, vp_modify_t *dst)
 907 {
 908         int i, j;
 909         isp_put_hdr(isp, &src->vp_mod_hdr, &dst->vp_mod_hdr);
 910         ISP_IOXPUT_32(isp, src->vp_mod_hdl, &dst->vp_mod_hdl);
 911         ISP_IOXPUT_16(isp, src->vp_mod_reserved0, &dst->vp_mod_reserved0);
 912         ISP_IOXPUT_16(isp, src->vp_mod_status, &dst->vp_mod_status);
 913         ISP_IOXPUT_8(isp, src->vp_mod_cmd, &dst->vp_mod_cmd);
 914         ISP_IOXPUT_8(isp, src->vp_mod_cnt, &dst->vp_mod_cnt);
 915         ISP_IOXPUT_8(isp, src->vp_mod_idx0, &dst->vp_mod_idx0);
 916         ISP_IOXPUT_8(isp, src->vp_mod_idx1, &dst->vp_mod_idx1);
 917         for (i = 0; i < nitems(src->vp_mod_ports); i++) {
 918                 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].options, &dst->vp_mod_ports[i].options);
 919                 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].loopid, &dst->vp_mod_ports[i].loopid);
 920                 ISP_IOXPUT_16(isp, src->vp_mod_ports[i].reserved1, &dst->vp_mod_ports[i].reserved1);
 921                 for (j = 0; j < nitems(src->vp_mod_ports[i].wwpn); j++) {
 922                         ISP_IOXPUT_8(isp, src->vp_mod_ports[i].wwpn[j], &dst->vp_mod_ports[i].wwpn[j]);
 923                 }
 924                 for (j = 0; j < nitems(src->vp_mod_ports[i].wwnn); j++) {
 925                         ISP_IOXPUT_8(isp, src->vp_mod_ports[i].wwnn[j], &dst->vp_mod_ports[i].wwnn[j]);
 926                 }
 927         }
 928         for (i = 0; i < nitems(src->vp_mod_reserved2); i++) {
 929                 ISP_IOXPUT_8(isp, src->vp_mod_reserved2[i], &dst->vp_mod_reserved2[i]);
 930         }
 931 }
 932
 933 void
 934 isp_get_vp_modify(ispsoftc_t *isp, vp_modify_t *src, vp_modify_t *dst)
 935 {
 936         int i, j;
 937         isp_get_hdr(isp, &src->vp_mod_hdr, &dst->vp_mod_hdr);
 938         ISP_IOXGET_32(isp, &src->vp_mod_hdl, dst->vp_mod_hdl);
 939         ISP_IOXGET_16(isp, &src->vp_mod_reserved0, dst->vp_mod_reserved0);
 940         ISP_IOXGET_16(isp, &src->vp_mod_status, dst->vp_mod_status);
 941         ISP_IOXGET_8(isp, &src->vp_mod_cmd, dst->vp_mod_cmd);
 942         ISP_IOXGET_8(isp, &src->vp_mod_cnt, dst->vp_mod_cnt);
 943         ISP_IOXGET_8(isp, &src->vp_mod_idx0, dst->vp_mod_idx0);
 944         ISP_IOXGET_8(isp, &src->vp_mod_idx1, dst->vp_mod_idx1);
 945         for (i = 0; i < nitems(src->vp_mod_ports); i++) {
 946                 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].options, dst->vp_mod_ports[i].options);
 947                 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].loopid, dst->vp_mod_ports[i].loopid);
 948                 ISP_IOXGET_16(isp, &src->vp_mod_ports[i].reserved1, dst->vp_mod_ports[i].reserved1);
 949                 for (j = 0; j < nitems(src->vp_mod_ports[i].wwpn); j++) {
 950                         ISP_IOXGET_8(isp, &src->vp_mod_ports[i].wwpn[j], dst->vp_mod_ports[i].wwpn[j]);
 951                 }
 952                 for (j = 0; j < nitems(src->vp_mod_ports[i].wwnn); j++) {
 953                         ISP_IOXGET_8(isp, &src->vp_mod_ports[i].wwnn[j], dst->vp_mod_ports[i].wwnn[j]);
 954                 }
 955         }
 956         for (i = 0; i < nitems(src->vp_mod_reserved2); i++) {
 957                 ISP_IOXGET_8(isp, &src->vp_mod_reserved2[i], dst->vp_mod_reserved2[i]);
 958         }
 959 }
 960
 961 void
 962 isp_get_pdb_24xx(ispsoftc_t *isp, isp_pdb_24xx_t *src, isp_pdb_24xx_t *dst)
 963 {
 964         int i;
 965         ISP_IOXGET_16(isp, &src->pdb_flags, dst->pdb_flags);
 966         ISP_IOXGET_8(isp, &src->pdb_curstate, dst->pdb_curstate);
 967         ISP_IOXGET_8(isp, &src->pdb_laststate, dst->pdb_laststate);
 968         for (i = 0; i < 4; i++) {
 969                 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i], dst->pdb_hardaddr_bits[i]);
 970         }
 971         for (i = 0; i < 4; i++) {
 972                 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i], dst->pdb_portid_bits[i]);
 973         }
 974         ISP_IOXGET_16(isp, &src->pdb_retry_timer, dst->pdb_retry_timer);
 975         ISP_IOXGET_16(isp, &src->pdb_handle, dst->pdb_handle);
 976         ISP_IOXGET_16(isp, &src->pdb_rcv_dsize, dst->pdb_rcv_dsize);
 977         ISP_IOXGET_16(isp, &src->pdb_reserved0, dst->pdb_reserved0);
 978         ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
 979         ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
 980         for (i = 0; i < 8; i++) {
 981                 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
 982         }
 983         for (i = 0; i < 8; i++) {
 984                 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
 985         }
 986         for (i = 0; i < 24; i++) {
 987                 ISP_IOXGET_8(isp, &src->pdb_reserved1[i], dst->pdb_reserved1[i]);
 988         }
 989 }
 990
 991 void
 992 isp_get_pnhle_24xx(ispsoftc_t *isp, isp_pnhle_24xx_t *src, isp_pnhle_24xx_t *dst)
 993 {
 994
 995         ISP_IOXGET_16(isp, &src->pnhle_port_id_lo, dst->pnhle_port_id_lo);
 996         ISP_IOXGET_16(isp, &src->pnhle_port_id_hi, dst->pnhle_port_id_hi);
 997         ISP_IOXGET_16(isp, &src->pnhle_handle, dst->pnhle_handle);
 998         ISP_IOXGET_16(isp, &src->pnhle_reserved, dst->pnhle_reserved);
 999 }
1000
1001 /*
1002  * PLOGI/LOGO IOCB canonicalization
1003  */
1004
1005 void
1006 isp_get_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
1007 {
1008         int i;
1009         isp_get_hdr(isp, &src->plogx_header, &dst->plogx_header);
1010         ISP_IOXGET_32(isp, &src->plogx_handle, dst->plogx_handle);
1011         ISP_IOXGET_16(isp, &src->plogx_status, dst->plogx_status);
1012         ISP_IOXGET_16(isp, &src->plogx_nphdl, dst->plogx_nphdl);
1013         ISP_IOXGET_16(isp, &src->plogx_flags, dst->plogx_flags);
1014         ISP_IOXGET_16(isp, &src->plogx_vphdl, dst->plogx_vphdl);
1015         ISP_IOXGET_16(isp, &src->plogx_portlo, dst->plogx_portlo);
1016         ISP_IOXGET_16(isp, &src->plogx_rspsz_porthi, dst->plogx_rspsz_porthi);
1017         for (i = 0; i < 11; i++) {
1018                 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].lo16, dst->plogx_ioparm[i].lo16);
1019                 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].hi16, dst->plogx_ioparm[i].hi16);
1020         }
1021 }
1022
1023 void
1024 isp_put_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
1025 {
1026         int i;
1027         isp_put_hdr(isp, &src->plogx_header, &dst->plogx_header);
1028         ISP_IOXPUT_32(isp, src->plogx_handle, &dst->plogx_handle);
1029         ISP_IOXPUT_16(isp, src->plogx_status, &dst->plogx_status);
1030         ISP_IOXPUT_16(isp, src->plogx_nphdl, &dst->plogx_nphdl);
1031         ISP_IOXPUT_16(isp, src->plogx_flags, &dst->plogx_flags);
1032         ISP_IOXPUT_16(isp, src->plogx_vphdl, &dst->plogx_vphdl);
1033         ISP_IOXPUT_16(isp, src->plogx_portlo, &dst->plogx_portlo);
1034         ISP_IOXPUT_16(isp, src->plogx_rspsz_porthi, &dst->plogx_rspsz_porthi);
1035         for (i = 0; i < 11; i++) {
1036                 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].lo16, &dst->plogx_ioparm[i].lo16);
1037                 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].hi16, &dst->plogx_ioparm[i].hi16);
1038         }
1039 }
1040
1041 /*
1042  * Report ID canonicalization
1043  */
1044 void
1045 isp_get_ridacq(ispsoftc_t *isp, isp_ridacq_t *src, isp_ridacq_t *dst)
1046 {
1047         int i;
1048         isp_get_hdr(isp, &src->ridacq_hdr, &dst->ridacq_hdr);
1049         ISP_IOXGET_32(isp, &src->ridacq_handle, dst->ridacq_handle);
1050         ISP_IOXGET_8(isp, &src->ridacq_vp_acquired, dst->ridacq_vp_acquired);
1051         ISP_IOXGET_8(isp, &src->ridacq_vp_setup, dst->ridacq_vp_setup);
1052         ISP_IOXGET_8(isp, &src->ridacq_vp_index, dst->ridacq_vp_index);
1053         ISP_IOXGET_8(isp, &src->ridacq_vp_status, dst->ridacq_vp_status);
1054         ISP_IOXGET_16(isp, &src->ridacq_vp_port_lo, dst->ridacq_vp_port_lo);
1055         ISP_IOXGET_8(isp, &src->ridacq_vp_port_hi, dst->ridacq_vp_port_hi);
1056         ISP_IOXGET_8(isp, &src->ridacq_format, dst->ridacq_format);
1057         for (i = 0; i < sizeof (src->ridacq_map) / sizeof (src->ridacq_map[0]); i++) {
1058                 ISP_IOXGET_16(isp, &src->ridacq_map[i], dst->ridacq_map[i]);
1059         }
1060         for (i = 0; i < sizeof (src->ridacq_reserved1) / sizeof (src->ridacq_reserved1[0]); i++) {
1061                 ISP_IOXGET_16(isp, &src->ridacq_reserved1[i], dst->ridacq_reserved1[i]);
1062         }
1063 }
1064
1065
1066 /*
1067  * CT Passthru canonicalization
1068  */
1069 void
1070 isp_get_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
1071 {
1072         int i;
1073
1074         isp_get_hdr(isp, &src->ctp_header, &dst->ctp_header);
1075         ISP_IOXGET_32(isp, &src->ctp_handle, dst->ctp_handle);
1076         ISP_IOXGET_16(isp, &src->ctp_status, dst->ctp_status);
1077         ISP_IOXGET_16(isp, &src->ctp_nphdl, dst->ctp_nphdl);
1078         ISP_IOXGET_16(isp, &src->ctp_cmd_cnt, dst->ctp_cmd_cnt);
1079         ISP_IOXGET_8(isp, &src->ctp_vpidx, dst->ctp_vpidx);
1080         ISP_IOXGET_8(isp, &src->ctp_reserved0, dst->ctp_reserved0);
1081         ISP_IOXGET_16(isp, &src->ctp_time, dst->ctp_time);
1082         ISP_IOXGET_16(isp, &src->ctp_reserved1, dst->ctp_reserved1);
1083         ISP_IOXGET_16(isp, &src->ctp_rsp_cnt, dst->ctp_rsp_cnt);
1084         for (i = 0; i < 5; i++) {
1085                 ISP_IOXGET_16(isp, &src->ctp_reserved2[i], dst->ctp_reserved2[i]);
1086         }
1087         ISP_IOXGET_32(isp, &src->ctp_rsp_bcnt, dst->ctp_rsp_bcnt);
1088         ISP_IOXGET_32(isp, &src->ctp_cmd_bcnt, dst->ctp_cmd_bcnt);
1089         for (i = 0; i < 2; i++) {
1090                 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_base, dst->ctp_dataseg[i].ds_base);
1091                 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_basehi, dst->ctp_dataseg[i].ds_basehi);
1092                 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_count, dst->ctp_dataseg[i].ds_count);
1093         }
1094 }
1095
1096 void
1097 isp_put_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
1098 {
1099         int i;
1100
1101         isp_put_hdr(isp, &src->ctp_header, &dst->ctp_header);
1102         ISP_IOXPUT_32(isp, src->ctp_handle, &dst->ctp_handle);
1103         ISP_IOXPUT_16(isp, src->ctp_status, &dst->ctp_status);
1104         ISP_IOXPUT_16(isp, src->ctp_nphdl, &dst->ctp_nphdl);
1105         ISP_IOXPUT_16(isp, src->ctp_cmd_cnt, &dst->ctp_cmd_cnt);
1106         ISP_IOXPUT_8(isp, src->ctp_vpidx, &dst->ctp_vpidx);
1107         ISP_IOXPUT_8(isp, src->ctp_reserved0, &dst->ctp_reserved0);
1108         ISP_IOXPUT_16(isp, src->ctp_time, &dst->ctp_time);
1109         ISP_IOXPUT_16(isp, src->ctp_reserved1, &dst->ctp_reserved1);
1110         ISP_IOXPUT_16(isp, src->ctp_rsp_cnt, &dst->ctp_rsp_cnt);
1111         for (i = 0; i < 5; i++) {
1112                 ISP_IOXPUT_16(isp, src->ctp_reserved2[i], &dst->ctp_reserved2[i]);
1113         }
1114         ISP_IOXPUT_32(isp, src->ctp_rsp_bcnt, &dst->ctp_rsp_bcnt);
1115         ISP_IOXPUT_32(isp, src->ctp_cmd_bcnt, &dst->ctp_cmd_bcnt);
1116         for (i = 0; i < 2; i++) {
1117                 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_base, &dst->ctp_dataseg[i].ds_base);
1118                 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_basehi, &dst->ctp_dataseg[i].ds_basehi);
1119                 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_count, &dst->ctp_dataseg[i].ds_count);
1120         }
1121 }
1122
1123 void
1124 isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src, sns_gid_ft_req_t *dst)
1125 {
1126         ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1127         ISP_IOXPUT_16(isp, src->snscb_reserved0, &dst->snscb_reserved0);
1128         ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
1129         ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
1130         ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
1131         ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
1132         ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1133         ISP_IOXPUT_16(isp, src->snscb_reserved1, &dst->snscb_reserved1);
1134         ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
1135         ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
1136         ISP_IOXPUT_32(isp, src->snscb_reserved3, &dst->snscb_reserved3);
1137         ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
1138 }
1139
1140 void
1141 isp_get_gid_xx_response(ispsoftc_t *isp, sns_gid_xx_rsp_t *src, sns_gid_xx_rsp_t *dst, int nwords)
1142 {
1143         int i, j;
1144
1145         isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1146         for (i = 0; i < nwords; i++) {
1147                 ISP_IOZGET_8(isp, &src->snscb_ports[i].control,
1148                     dst->snscb_ports[i].control);
1149                 for (j = 0; j < 3; j++) {
1150                         ISP_IOZGET_8(isp, &src->snscb_ports[i].portid[j],
1151                             dst->snscb_ports[i].portid[j]);
1152                 }
1153                 if (dst->snscb_ports[i].control & 0x80)
1154                         break;
1155         }
1156 }
1157
1158 void
1159 isp_get_gxn_id_response(ispsoftc_t *isp, sns_gxn_id_rsp_t *src, sns_gxn_id_rsp_t *dst)
1160 {
1161         int i;
1162
1163         isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1164         for (i = 0; i < 8; i++)
1165                 ISP_IOZGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
1166 }
1167
1168 void
1169 isp_get_gft_id_response(ispsoftc_t *isp, sns_gft_id_rsp_t *src, sns_gft_id_rsp_t *dst)
1170 {
1171         int i;
1172
1173         isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1174         for (i = 0; i < 8; i++) {
1175                 ISP_IOZGET_32(isp, &src->snscb_fc4_types[i],
1176                     dst->snscb_fc4_types[i]);
1177         }
1178 }
1179
1180 void
1181 isp_get_gff_id_response(ispsoftc_t *isp, sns_gff_id_rsp_t *src, sns_gff_id_rsp_t *dst)
1182 {
1183         int i;
1184
1185         isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1186         for (i = 0; i < 32; i++) {
1187                 ISP_IOZGET_32(isp, &src->snscb_fc4_features[i],
1188                     dst->snscb_fc4_features[i]);
1189         }
1190 }
1191
1192 void
1193 isp_get_ga_nxt_response(ispsoftc_t *isp, sns_ga_nxt_rsp_t *src, sns_ga_nxt_rsp_t *dst)
1194 {
1195         int i;
1196         isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1197         ISP_IOZGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
1198         for (i = 0; i < 3; i++) {
1199                 ISP_IOZGET_8(isp, &src->snscb_port_id[i], dst->snscb_port_id[i]);
1200         }
1201         for (i = 0; i < 8; i++) {
1202                 ISP_IOZGET_8(isp, &src->snscb_portname[i], dst->snscb_portname[i]);
1203         }
1204         ISP_IOZGET_8(isp, &src->snscb_pnlen, dst->snscb_pnlen);
1205         for (i = 0; i < 255; i++) {
1206                 ISP_IOZGET_8(isp, &src->snscb_pname[i], dst->snscb_pname[i]);
1207         }
1208         for (i = 0; i < 8; i++) {
1209                 ISP_IOZGET_8(isp, &src->snscb_nodename[i], dst->snscb_nodename[i]);
1210         }
1211         ISP_IOZGET_8(isp, &src->snscb_nnlen, dst->snscb_nnlen);
1212         for (i = 0; i < 255; i++) {
1213                 ISP_IOZGET_8(isp, &src->snscb_nname[i], dst->snscb_nname[i]);
1214         }
1215         for (i = 0; i < 8; i++) {
1216                 ISP_IOZGET_8(isp, &src->snscb_ipassoc[i], dst->snscb_ipassoc[i]);
1217         }
1218         for (i = 0; i < 16; i++) {
1219                 ISP_IOZGET_8(isp, &src->snscb_ipaddr[i], dst->snscb_ipaddr[i]);
1220         }
1221         for (i = 0; i < 4; i++) {
1222                 ISP_IOZGET_8(isp, &src->snscb_svc_class[i], dst->snscb_svc_class[i]);
1223         }
1224         for (i = 0; i < 32; i++) {
1225                 ISP_IOZGET_8(isp, &src->snscb_fc4_types[i], dst->snscb_fc4_types[i]);
1226         }
1227         for (i = 0; i < 8; i++) {
1228                 ISP_IOZGET_8(isp, &src->snscb_fpname[i], dst->snscb_fpname[i]);
1229         }
1230         ISP_IOZGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
1231         for (i = 0; i < 3; i++) {
1232                 ISP_IOZGET_8(isp, &src->snscb_hardaddr[i], dst->snscb_hardaddr[i]);
1233         }
1234 }
1235
1236 /*
1237  * FC Structure Canonicalization
1238  */
1239
1240 void
1241 isp_get_fc_hdr(ispsoftc_t *isp, fc_hdr_t *src, fc_hdr_t *dst)
1242 {
1243         ISP_IOZGET_8(isp, &src->r_ctl, dst->r_ctl);
1244         ISP_IOZGET_8(isp, &src->d_id[0], dst->d_id[0]);
1245         ISP_IOZGET_8(isp, &src->d_id[1], dst->d_id[1]);
1246         ISP_IOZGET_8(isp, &src->d_id[2], dst->d_id[2]);
1247         ISP_IOZGET_8(isp, &src->cs_ctl, dst->cs_ctl);
1248         ISP_IOZGET_8(isp, &src->s_id[0], dst->s_id[0]);
1249         ISP_IOZGET_8(isp, &src->s_id[1], dst->s_id[1]);
1250         ISP_IOZGET_8(isp, &src->s_id[2], dst->s_id[2]);
1251         ISP_IOZGET_8(isp, &src->type, dst->type);
1252         ISP_IOZGET_8(isp, &src->f_ctl[0], dst->f_ctl[0]);
1253         ISP_IOZGET_8(isp, &src->f_ctl[1], dst->f_ctl[1]);
1254         ISP_IOZGET_8(isp, &src->f_ctl[2], dst->f_ctl[2]);
1255         ISP_IOZGET_8(isp, &src->seq_id, dst->seq_id);
1256         ISP_IOZGET_8(isp, &src->df_ctl, dst->df_ctl);
1257         ISP_IOZGET_16(isp, &src->seq_cnt, dst->seq_cnt);
1258         ISP_IOZGET_16(isp, &src->ox_id, dst->ox_id);
1259         ISP_IOZGET_16(isp, &src->rx_id, dst->rx_id);
1260         ISP_IOZGET_32(isp, &src->parameter, dst->parameter);
1261 }
1262
1263 void
1264 isp_put_fc_hdr(ispsoftc_t *isp, fc_hdr_t *src, fc_hdr_t *dst)
1265 {
1266         ISP_IOZPUT_8(isp, src->r_ctl, &dst->r_ctl);
1267         ISP_IOZPUT_8(isp, src->d_id[0], &dst->d_id[0]);
1268         ISP_IOZPUT_8(isp, src->d_id[1], &dst->d_id[1]);
1269         ISP_IOZPUT_8(isp, src->d_id[2], &dst->d_id[2]);
1270         ISP_IOZPUT_8(isp, src->cs_ctl, &dst->cs_ctl);
1271         ISP_IOZPUT_8(isp, src->s_id[0], &dst->s_id[0]);
1272         ISP_IOZPUT_8(isp, src->s_id[1], &dst->s_id[1]);
1273         ISP_IOZPUT_8(isp, src->s_id[2], &dst->s_id[2]);
1274         ISP_IOZPUT_8(isp, src->type, &dst->type);
1275         ISP_IOZPUT_8(isp, src->f_ctl[0], &dst->f_ctl[0]);
1276         ISP_IOZPUT_8(isp, src->f_ctl[1], &dst->f_ctl[1]);
1277         ISP_IOZPUT_8(isp, src->f_ctl[2], &dst->f_ctl[2]);
1278         ISP_IOZPUT_8(isp, src->seq_id, &dst->seq_id);
1279         ISP_IOZPUT_8(isp, src->df_ctl, &dst->df_ctl);
1280         ISP_IOZPUT_16(isp, src->seq_cnt, &dst->seq_cnt);
1281         ISP_IOZPUT_16(isp, src->ox_id, &dst->ox_id);
1282         ISP_IOZPUT_16(isp, src->rx_id, &dst->rx_id);
1283         ISP_IOZPUT_32(isp, src->parameter, &dst->parameter);
1284 }
1285
1286 void
1287 isp_get_fcp_cmnd_iu(ispsoftc_t *isp, fcp_cmnd_iu_t *src, fcp_cmnd_iu_t *dst)
1288 {
1289         int i;
1290
1291         for (i = 0; i < 8; i++) {
1292                 ISP_IOZGET_8(isp, &src->fcp_cmnd_lun[i], dst->fcp_cmnd_lun[i]);
1293         }
1294         ISP_IOZGET_8(isp, &src->fcp_cmnd_crn, dst->fcp_cmnd_crn);
1295         ISP_IOZGET_8(isp, &src->fcp_cmnd_task_attribute, dst->fcp_cmnd_task_attribute);
1296         ISP_IOZGET_8(isp, &src->fcp_cmnd_task_management, dst->fcp_cmnd_task_management);
1297         ISP_IOZGET_8(isp, &src->fcp_cmnd_alen_datadir, dst->fcp_cmnd_alen_datadir);
1298         for (i = 0; i < 16; i++) {
1299                 ISP_IOZGET_8(isp, &src->cdb_dl.sf.fcp_cmnd_cdb[i], dst->cdb_dl.sf.fcp_cmnd_cdb[i]);
1300         }
1301         ISP_IOZGET_32(isp, &src->cdb_dl.sf.fcp_cmnd_dl, dst->cdb_dl.sf.fcp_cmnd_dl);
1302 }
1303
1304 void
1305 isp_put_rft_id(ispsoftc_t *isp, rft_id_t *src, rft_id_t *dst)
1306 {
1307         int i;
1308         isp_put_ct_hdr(isp, &src->rftid_hdr, &dst->rftid_hdr);
1309         ISP_IOZPUT_8(isp, src->rftid_reserved, &dst->rftid_reserved);
1310         for (i = 0; i < 3; i++) {
1311                 ISP_IOZPUT_8(isp, src->rftid_portid[i], &dst->rftid_portid[i]);
1312         }
1313         for (i = 0; i < 8; i++) {
1314                 ISP_IOZPUT_32(isp, src->rftid_fc4types[i], &dst->rftid_fc4types[i]);
1315         }
1316 }
1317
1318 void
1319 isp_put_rspn_id(ispsoftc_t *isp, rspn_id_t *src, rspn_id_t *dst)
1320 {
1321 /*      int i;*/
1322         isp_put_ct_hdr(isp, &src->rspnid_hdr, &dst->rspnid_hdr);
1323         ISP_IOZPUT_8(isp, src->rspnid_reserved, &dst->rspnid_reserved);
1324         ISP_IOZPUT_8(isp, src->rspnid_length, &dst->rspnid_length);
1325 /*      for (i = 0; i < src->rspnid_length; i++)
1326                 ISP_IOZPUT_8(isp, src->rspnid_name[i], &dst->rspnid_name[i]);*/
1327 }
1328
1329 void
1330 isp_put_rff_id(ispsoftc_t *isp, rff_id_t *src, rff_id_t *dst)
1331 {
1332         int i;
1333
1334         isp_put_ct_hdr(isp, &src->rffid_hdr, &dst->rffid_hdr);
1335         ISP_IOZPUT_8(isp, src->rffid_reserved, &dst->rffid_reserved);
1336         for (i = 0; i < 3; i++)
1337                 ISP_IOZPUT_8(isp, src->rffid_portid[i], &dst->rffid_portid[i]);
1338         ISP_IOZPUT_16(isp, src->rffid_reserved2, &dst->rffid_reserved2);
1339         ISP_IOZPUT_8(isp, src->rffid_fc4features, &dst->rffid_fc4features);
1340         ISP_IOZPUT_8(isp, src->rffid_fc4type, &dst->rffid_fc4type);
1341 }
1342
1343 void
1344 isp_put_rsnn_nn(ispsoftc_t *isp, rsnn_nn_t *src, rsnn_nn_t *dst)
1345 {
1346         int i;
1347         isp_put_ct_hdr(isp, &src->rsnnnn_hdr, &dst->rsnnnn_hdr);
1348         for (i = 0; i < 8; i++)
1349                 ISP_IOZPUT_8(isp, src->rsnnnn_nodename[i], &dst->rsnnnn_nodename[i]);
1350         ISP_IOZPUT_8(isp, src->rsnnnn_length, &dst->rsnnnn_length);
1351 /*      for (i = 0; i < src->rsnnnn_length; i++)
1352                 ISP_IOZPUT_8(isp, src->rsnnnn_name[i], &dst->rsnnnn_name[i]);*/
1353 }
1354
1355 void
1356 isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1357 {
1358         ISP_IOZGET_8(isp, &src->ct_revision, dst->ct_revision);
1359         ISP_IOZGET_8(isp, &src->ct_in_id[0], dst->ct_in_id[0]);
1360         ISP_IOZGET_8(isp, &src->ct_in_id[1], dst->ct_in_id[1]);
1361         ISP_IOZGET_8(isp, &src->ct_in_id[2], dst->ct_in_id[2]);
1362         ISP_IOZGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
1363         ISP_IOZGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
1364         ISP_IOZGET_8(isp, &src->ct_options, dst->ct_options);
1365         ISP_IOZGET_8(isp, &src->ct_reserved0, dst->ct_reserved0);
1366         ISP_IOZGET_16(isp, &src->ct_cmd_resp, dst->ct_cmd_resp);
1367         ISP_IOZGET_16(isp, &src->ct_bcnt_resid, dst->ct_bcnt_resid);
1368         ISP_IOZGET_8(isp, &src->ct_reserved1, dst->ct_reserved1);
1369         ISP_IOZGET_8(isp, &src->ct_reason, dst->ct_reason);
1370         ISP_IOZGET_8(isp, &src->ct_explanation, dst->ct_explanation);
1371         ISP_IOZGET_8(isp, &src->ct_vunique, dst->ct_vunique);
1372 }
1373
1374 void
1375 isp_put_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1376 {
1377         ISP_IOZPUT_8(isp, src->ct_revision, &dst->ct_revision);
1378         ISP_IOZPUT_8(isp, src->ct_in_id[0], &dst->ct_in_id[0]);
1379         ISP_IOZPUT_8(isp, src->ct_in_id[1], &dst->ct_in_id[1]);
1380         ISP_IOZPUT_8(isp, src->ct_in_id[2], &dst->ct_in_id[2]);
1381         ISP_IOZPUT_8(isp, src->ct_fcs_type, &dst->ct_fcs_type);
1382         ISP_IOZPUT_8(isp, src->ct_fcs_subtype, &dst->ct_fcs_subtype);
1383         ISP_IOZPUT_8(isp, src->ct_options, &dst->ct_options);
1384         ISP_IOZPUT_8(isp, src->ct_reserved0, &dst->ct_reserved0);
1385         ISP_IOZPUT_16(isp, src->ct_cmd_resp, &dst->ct_cmd_resp);
1386         ISP_IOZPUT_16(isp, src->ct_bcnt_resid, &dst->ct_bcnt_resid);
1387         ISP_IOZPUT_8(isp, src->ct_reserved1, &dst->ct_reserved1);
1388         ISP_IOZPUT_8(isp, src->ct_reason, &dst->ct_reason);
1389         ISP_IOZPUT_8(isp, src->ct_explanation, &dst->ct_explanation);
1390         ISP_IOZPUT_8(isp, src->ct_vunique, &dst->ct_vunique);
1391 }
1392
1393 void
1394 isp_put_fcp_rsp_iu(ispsoftc_t *isp, fcp_rsp_iu_t *src, fcp_rsp_iu_t *dst)
1395 {
1396         int i;
1397         for (i = 0; i < ((sizeof (src->fcp_rsp_reserved))/(sizeof (src->fcp_rsp_reserved[0]))); i++) {
1398                 ISP_IOZPUT_8(isp, src->fcp_rsp_reserved[i], &dst->fcp_rsp_reserved[i]);
1399         }
1400         ISP_IOZPUT_16(isp, src->fcp_rsp_status_qualifier, &dst->fcp_rsp_status_qualifier);
1401         ISP_IOZPUT_8(isp, src->fcp_rsp_bits, &dst->fcp_rsp_bits);
1402         ISP_IOZPUT_8(isp, src->fcp_rsp_scsi_status, &dst->fcp_rsp_scsi_status);
1403         ISP_IOZPUT_32(isp, src->fcp_rsp_resid, &dst->fcp_rsp_resid);
1404         ISP_IOZPUT_32(isp, src->fcp_rsp_snslen, &dst->fcp_rsp_snslen);
1405         ISP_IOZPUT_32(isp, src->fcp_rsp_rsplen, &dst->fcp_rsp_rsplen);
1406 }
1407
1408 /*
1409  * Find port database entries
1410  */
1411 int
1412 isp_find_pdb_empty(ispsoftc_t *isp, int chan, fcportdb_t **lptr)
1413 {
1414         fcparam *fcp = FCPARAM(isp, chan);
1415         int i;
1416
1417         for (i = 0; i < MAX_FC_TARG; i++) {
1418                 fcportdb_t *lp = &fcp->portdb[i];
1419
1420                 if (lp->state == FC_PORTDB_STATE_NIL) {
1421                         *lptr = lp;
1422                         return (1);
1423                 }
1424         }
1425         return (0);
1426 }
1427
1428 int
1429 isp_find_pdb_by_wwpn(ispsoftc_t *isp, int chan, uint64_t wwpn, fcportdb_t **lptr)
1430 {
1431         fcparam *fcp = FCPARAM(isp, chan);
1432         int i;
1433
1434         for (i = 0; i < MAX_FC_TARG; i++) {
1435                 fcportdb_t *lp = &fcp->portdb[i];
1436
1437                 if (lp->state == FC_PORTDB_STATE_NIL)
1438                         continue;
1439                 if (lp->port_wwn == wwpn) {
1440                         *lptr = lp;
1441                         return (1);
1442                 }
1443         }
1444         return (0);
1445 }
1446
1447 int
1448 isp_find_pdb_by_handle(ispsoftc_t *isp, int chan, uint16_t handle,
1449     fcportdb_t **lptr)
1450 {
1451         fcparam *fcp = FCPARAM(isp, chan);
1452         int i;
1453
1454         for (i = 0; i < MAX_FC_TARG; i++) {
1455                 fcportdb_t *lp = &fcp->portdb[i];
1456
1457                 if (lp->state == FC_PORTDB_STATE_NIL)
1458                         continue;
1459                 if (lp->handle == handle) {
1460                         *lptr = lp;
1461                         return (1);
1462                 }
1463         }
1464         return (0);
1465 }
1466
1467 int
1468 isp_find_pdb_by_portid(ispsoftc_t *isp, int chan, uint32_t portid,
1469     fcportdb_t **lptr)
1470 {
1471         fcparam *fcp = FCPARAM(isp, chan);
1472         int i;
1473
1474         for (i = 0; i < MAX_FC_TARG; i++) {
1475                 fcportdb_t *lp = &fcp->portdb[i];
1476
1477                 if (lp->state == FC_PORTDB_STATE_NIL)
1478                         continue;
1479                 if (lp->portid == portid) {
1480                         *lptr = lp;
1481                         return (1);
1482                 }
1483         }
1484         return (0);
1485 }
1486
1487 #ifdef  ISP_TARGET_MODE
1488 void
1489 isp_find_chan_by_did(ispsoftc_t *isp, uint32_t did, uint16_t *cp)
1490 {
1491         uint16_t chan;
1492
1493         *cp = ISP_NOCHAN;
1494         for (chan = 0; chan < isp->isp_nchan; chan++) {
1495                 fcparam *fcp = FCPARAM(isp, chan);
1496                 if ((fcp->role & ISP_ROLE_TARGET) == 0 ||
1497                     fcp->isp_loopstate < LOOP_HAVE_ADDR) {
1498                         continue;
1499                 }
1500                 if (fcp->isp_portid == did) {
1501                         *cp = chan;
1502                         break;
1503                 }
1504         }
1505 }
1506
1507 /*
1508  * Add an initiator device to the port database
1509  */
1510 void
1511 isp_add_wwn_entry(ispsoftc_t *isp, int chan, uint64_t wwpn, uint64_t wwnn,
1512     uint16_t nphdl, uint32_t s_id, uint16_t prli_params)
1513 {
1514         char buf[64];
1515         fcparam *fcp;
1516         fcportdb_t *lp;
1517         int i, change;
1518
1519         fcp = FCPARAM(isp, chan);
1520         if (nphdl >= MAX_NPORT_HANDLE) {
1521                 isp_prt(isp, ISP_LOGTINFO|ISP_LOGWARN, "Chan %d WWPN 0x%016llx "
1522                     "PortID 0x%06x handle 0x%x -- bad handle",
1523                     chan, (unsigned long long) wwpn, s_id, nphdl);
1524                 return;
1525         }
1526
1527         /*
1528          * If valid record for requested handle already exists, update it
1529          * with new parameters.  Some cases of update can be suspicious,
1530          * so log them verbosely and dump the whole port database.
1531          */
1532         if ((VALID_INI(wwpn) && isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) ||
1533             (VALID_PORT(s_id) && isp_find_pdb_by_portid(isp, chan, s_id, &lp))) {
1534                 change = 0;
1535                 lp->new_portid = lp->portid;
1536                 lp->new_prli_word3 = lp->prli_word3;
1537                 if (VALID_PORT(s_id) && lp->portid != s_id) {
1538                         if (!VALID_PORT(lp->portid)) {
1539                                 isp_prt(isp, ISP_LOGTINFO,
1540                                     "Chan %d WWPN 0x%016llx handle 0x%x "
1541                                     "gets PortID 0x%06x",
1542                                     chan, (unsigned long long) lp->port_wwn,
1543                                     nphdl, s_id);
1544                         } else {
1545                                 isp_prt(isp, ISP_LOGTINFO|ISP_LOGWARN,
1546                                     "Chan %d WWPN 0x%016llx handle 0x%x "
1547                                     "changes PortID 0x%06x to 0x%06x",
1548                                     chan, (unsigned long long) lp->port_wwn,
1549                                     nphdl, lp->portid, s_id);
1550                                 if (isp->isp_dblev & (ISP_LOGTINFO|ISP_LOGWARN))
1551                                         isp_dump_portdb(isp, chan);
1552                         }
1553                         lp->new_portid = s_id;
1554                         change++;
1555                 }
1556                 if (VALID_INI(wwpn) && lp->port_wwn != wwpn) {
1557                         if (!VALID_INI(lp->port_wwn)) {
1558                                 isp_prt(isp, ISP_LOGTINFO,
1559                                     "Chan %d PortID 0x%06x handle 0x%x "
1560                                     "gets WWPN 0x%016llxx",
1561                                     chan, lp->portid, nphdl,
1562                                     (unsigned long long) wwpn);
1563                         } else if (lp->port_wwn != wwpn) {
1564                                 isp_prt(isp, ISP_LOGTINFO|ISP_LOGWARN,
1565                                     "Chan %d PortID 0x%06x handle 0x%x "
1566                                     "changes WWPN 0x%016llx to 0x%016llx",
1567                                     chan, lp->portid, nphdl,
1568                                     (unsigned long long) lp->port_wwn,
1569                                     (unsigned long long) wwpn);
1570                                 if (isp->isp_dblev & (ISP_LOGTINFO|ISP_LOGWARN))
1571                                         isp_dump_portdb(isp, chan);
1572                         }
1573                         lp->port_wwn = wwpn;
1574                         change++;
1575                 }
1576                 if (VALID_INI(wwnn) && lp->node_wwn != wwnn) {
1577                         if (!VALID_INI(lp->node_wwn)) {
1578                                 isp_prt(isp, ISP_LOGTINFO,
1579                                     "Chan %d PortID 0x%06x handle 0x%x "
1580                                     "gets WWNN 0x%016llxx",
1581                                     chan, lp->portid, nphdl,
1582                                     (unsigned long long) wwnn);
1583                         } else if (lp->port_wwn != wwnn) {
1584                                 isp_prt(isp, ISP_LOGTINFO,
1585                                     "Chan %d PortID 0x%06x handle 0x%x "
1586                                     "changes WWNN 0x%016llx to 0x%016llx",
1587                                     chan, lp->portid, nphdl,
1588                                     (unsigned long long) lp->node_wwn,
1589                                     (unsigned long long) wwnn);
1590                         }
1591                         lp->node_wwn = wwnn;
1592                         change++;
1593                 }
1594                 if (prli_params != 0 && lp->prli_word3 != prli_params) {
1595                         isp_gen_role_str(buf, sizeof (buf), prli_params);
1596                         isp_prt(isp, ISP_LOGTINFO|ISP_LOGCONFIG,
1597                             "Chan %d WWPN 0x%016llx PortID 0x%06x "
1598                             "handle 0x%x changes PRLI Word 3 %s",
1599                             chan, (unsigned long long) lp->port_wwn,
1600                             lp->portid, lp->handle, buf);
1601                         lp->new_prli_word3 = prli_params;
1602                         change++;
1603                 }
1604                 if (lp->handle != nphdl) {
1605                         isp_prt(isp, ISP_LOGTINFO|ISP_LOGCONFIG,
1606                             "Chan %d WWPN 0x%016llx PortID 0x%06x "
1607                             "changes handle 0x%x to 0x%x",
1608                             chan, (unsigned long long) lp->port_wwn,
1609                             lp->portid, lp->handle, nphdl);
1610                         lp->handle = nphdl;
1611                         change++;
1612                 }
1613                 lp->state = FC_PORTDB_STATE_VALID;
1614                 if (change) {
1615                         isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
1616                         lp->portid = lp->new_portid;
1617                         lp->prli_word3 = lp->new_prli_word3;
1618                 } else {
1619                         isp_prt(isp, ISP_LOGTINFO,
1620                             "Chan %d WWPN 0x%016llx PortID 0x%06x "
1621                             "handle 0x%x reentered",
1622                             chan, (unsigned long long) lp->port_wwn,
1623                             lp->portid, lp->handle);
1624                         isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
1625                 }
1626                 return;
1627         }
1628
1629         /* Search for room to insert new record. */
1630         for (i = 0; i < MAX_FC_TARG; i++) {
1631                 if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL)
1632                         break;
1633         }
1634         if (i >= MAX_FC_TARG) {
1635                 isp_prt(isp, ISP_LOGTINFO|ISP_LOGWARN,
1636                     "Chan %d WWPN 0x%016llx PortID 0x%06x handle 0x%x "
1637                     "-- no room in port database",
1638                     chan, (unsigned long long) wwpn, s_id, nphdl);
1639                 if (isp->isp_dblev & (ISP_LOGTINFO|ISP_LOGWARN))
1640                         isp_dump_portdb(isp, chan);
1641                 return;
1642         }
1643
1644         /* Insert new record and mark it valid. */
1645         lp = &fcp->portdb[i];
1646         ISP_MEMZERO(lp, sizeof (fcportdb_t));
1647         lp->handle = nphdl;
1648         lp->portid = s_id;
1649         lp->port_wwn = wwpn;
1650         lp->node_wwn = wwnn;
1651         lp->prli_word3 = (prli_params != 0) ? prli_params : PRLI_WD3_INITIATOR_FUNCTION;
1652         lp->state = FC_PORTDB_STATE_VALID;
1653
1654         isp_gen_role_str(buf, sizeof (buf), lp->prli_word3);
1655         isp_prt(isp, ISP_LOGTINFO, "Chan %d WWPN 0x%016llx "
1656             "PortID 0x%06x handle 0x%x vtgt %d %s added", chan,
1657             (unsigned long long) wwpn, s_id, nphdl, i, buf);
1658
1659         /* Notify above levels about new port arrival. */
1660         isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
1661 }
1662
1663 /*
1664  * Remove a target device to the port database
1665  */
1666 void
1667 isp_del_wwn_entry(ispsoftc_t *isp, int chan, uint64_t wwpn, uint16_t nphdl, uint32_t s_id)
1668 {
1669         fcparam *fcp;
1670         fcportdb_t *lp;
1671
1672         if (nphdl >= MAX_NPORT_HANDLE) {
1673                 isp_prt(isp, ISP_LOGWARN, "Chan %d WWPN 0x%016llx PortID 0x%06x bad handle 0x%x",
1674                     chan, (unsigned long long) wwpn, s_id, nphdl);
1675                 return;
1676         }
1677
1678         fcp = FCPARAM(isp, chan);
1679         if (isp_find_pdb_by_handle(isp, chan, nphdl, &lp) == 0) {
1680                 isp_prt(isp, ISP_LOGWARN, "Chan %d WWPN 0x%016llx PortID 0x%06x handle 0x%x cannot be found to be deleted",
1681                     chan, (unsigned long long) wwpn, s_id, nphdl);
1682                 isp_dump_portdb(isp, chan);
1683                 return;
1684         }
1685         isp_prt(isp, ISP_LOGTINFO, "Chan %d WWPN 0x%016llx PortID 0x%06x handle 0x%x vtgt %d deleted",
1686             chan, (unsigned long long) lp->port_wwn, lp->portid, nphdl, FC_PORTDB_TGT(isp, chan, lp));
1687         lp->state = FC_PORTDB_STATE_NIL;
1688
1689         /* Notify above levels about gone port. */
1690         isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
1691 }
1692
1693 void
1694 isp_del_all_wwn_entries(ispsoftc_t *isp, int chan)
1695 {
1696         fcparam *fcp;
1697         int i;
1698
1699         /*
1700          * Handle iterations over all channels via recursion
1701          */
1702         if (chan == ISP_NOCHAN) {
1703                 for (chan = 0; chan < isp->isp_nchan; chan++) {
1704                         isp_del_all_wwn_entries(isp, chan);
1705                 }
1706                 return;
1707         }
1708
1709         if (chan > isp->isp_nchan) {
1710                 return;
1711         }
1712
1713         fcp = FCPARAM(isp, chan);
1714         if (fcp == NULL) {
1715                 return;
1716         }
1717         for (i = 0; i < MAX_FC_TARG; i++) {
1718                 fcportdb_t *lp = &fcp->portdb[i];
1719
1720                 if (lp->state != FC_PORTDB_STATE_NIL)
1721                         isp_del_wwn_entry(isp, chan, lp->port_wwn, lp->handle, lp->portid);
1722         }
1723 }
1724
1725 void
1726 isp_del_wwn_entries(ispsoftc_t *isp, isp_notify_t *mp)
1727 {
1728         fcportdb_t *lp;
1729
1730         /*
1731          * Handle iterations over all channels via recursion
1732          */
1733         if (mp->nt_channel == ISP_NOCHAN) {
1734                 for (mp->nt_channel = 0; mp->nt_channel < isp->isp_nchan; mp->nt_channel++) {
1735                         isp_del_wwn_entries(isp, mp);
1736                 }
1737                 mp->nt_channel = ISP_NOCHAN;
1738                 return;
1739         }
1740
1741         /*
1742          * We have an entry which is only partially identified.
1743          *
1744          * It's only known by WWN, N-Port handle, or Port ID.
1745          * We need to find the actual entry so we can delete it.
1746          */
1747         if (mp->nt_nphdl != NIL_HANDLE) {
1748                 if (isp_find_pdb_by_handle(isp, mp->nt_channel, mp->nt_nphdl, &lp)) {
1749                         isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
1750                         return;
1751                 }
1752         }
1753         if (VALID_INI(mp->nt_wwn)) {
1754                 if (isp_find_pdb_by_wwpn(isp, mp->nt_channel, mp->nt_wwn, &lp)) {
1755                         isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
1756                         return;
1757                 }
1758         }
1759         if (VALID_PORT(mp->nt_sid)) {
1760                 if (isp_find_pdb_by_portid(isp, mp->nt_channel, mp->nt_sid, &lp)) {
1761                         isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
1762                         return;
1763                 }
1764         }
1765         isp_prt(isp, ISP_LOGWARN, "Chan %d unable to find entry to delete WWPN 0x%016jx PortID 0x%06x handle 0x%x",
1766             mp->nt_channel, mp->nt_wwn, mp->nt_sid, mp->nt_nphdl);
1767 }
1768
1769 void
1770 isp_get_atio7(ispsoftc_t *isp, at7_entry_t *src, at7_entry_t *dst)
1771 {
1772         ISP_IOXGET_8(isp, &src->at_type, dst->at_type);
1773         ISP_IOXGET_8(isp, &src->at_count, dst->at_count);
1774         ISP_IOXGET_16(isp, &src->at_ta_len, dst->at_ta_len);
1775         ISP_IOXGET_32(isp, &src->at_rxid, dst->at_rxid);
1776         isp_get_fc_hdr(isp, &src->at_hdr, &dst->at_hdr);
1777         isp_get_fcp_cmnd_iu(isp, &src->at_cmnd, &dst->at_cmnd);
1778 }
1779
1780 void
1781 isp_put_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
1782 {
1783         int i;
1784
1785         isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
1786         ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
1787         ISP_IOXPUT_16(isp, src->ct_nphdl, &dst->ct_nphdl);
1788         ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
1789         ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
1790         ISP_IOXPUT_8(isp, src->ct_vpidx, &dst->ct_vpidx);
1791         ISP_IOXPUT_8(isp, src->ct_xflags, &dst->ct_xflags);
1792         ISP_IOXPUT_16(isp, src->ct_iid_lo, &dst->ct_iid_lo);
1793         ISP_IOXPUT_8(isp, src->ct_iid_hi, &dst->ct_iid_hi);
1794         ISP_IOXPUT_8(isp, src->ct_reserved, &dst->ct_reserved);
1795         ISP_IOXPUT_32(isp, src->ct_rxid, &dst->ct_rxid);
1796         ISP_IOXPUT_16(isp, src->ct_senselen, &dst->ct_senselen);
1797         ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
1798         ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
1799         ISP_IOXPUT_16(isp, src->ct_oxid, &dst->ct_oxid);
1800         ISP_IOXPUT_16(isp, src->ct_scsi_status, &dst->ct_scsi_status);
1801         if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
1802                 ISP_IOXPUT_32(isp, src->rsp.m0.reloff, &dst->rsp.m0.reloff);
1803                 ISP_IOXPUT_32(isp, src->rsp.m0.reserved0, &dst->rsp.m0.reserved0);
1804                 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen, &dst->rsp.m0.ct_xfrlen);
1805                 ISP_IOXPUT_32(isp, src->rsp.m0.reserved1, &dst->rsp.m0.reserved1);
1806                 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_base, &dst->rsp.m0.ds.ds_base);
1807                 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_basehi, &dst->rsp.m0.ds.ds_basehi);
1808                 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_count, &dst->rsp.m0.ds.ds_count);
1809         } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
1810                 uint32_t *a, *b;
1811
1812                 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen, &dst->rsp.m1.ct_resplen);
1813                 ISP_IOXPUT_16(isp, src->rsp.m1.reserved, &dst->rsp.m1.reserved);
1814                 a = (uint32_t *) src->rsp.m1.ct_resp;
1815                 b = (uint32_t *) dst->rsp.m1.ct_resp;
1816                 for (i = 0; i < (nitems(src->rsp.m1.ct_resp) >> 2); i++) {
1817                         *b++ = ISP_SWAP32(isp, *a++);
1818                 }
1819         } else {
1820                 ISP_IOXPUT_32(isp, src->rsp.m2.reserved0, &dst->rsp.m2.reserved0);
1821                 ISP_IOXPUT_32(isp, src->rsp.m2.reserved1, &dst->rsp.m2.reserved1);
1822                 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen, &dst->rsp.m2.ct_datalen);
1823                 ISP_IOXPUT_32(isp, src->rsp.m2.reserved2, &dst->rsp.m2.reserved2);
1824                 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1825                 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
1826                 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1827         }
1828 }
1829
1830 void
1831 isp_get_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
1832 {
1833         int i;
1834
1835         isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
1836         ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
1837         ISP_IOXGET_16(isp, &src->ct_nphdl, dst->ct_nphdl);
1838         ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
1839         ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
1840         ISP_IOXGET_8(isp, &src->ct_vpidx, dst->ct_vpidx);
1841         ISP_IOXGET_8(isp, &src->ct_xflags, dst->ct_xflags);
1842         ISP_IOXGET_16(isp, &src->ct_iid_lo, dst->ct_iid_lo);
1843         ISP_IOXGET_8(isp, &src->ct_iid_hi, dst->ct_iid_hi);
1844         ISP_IOXGET_8(isp, &src->ct_reserved, dst->ct_reserved);
1845         ISP_IOXGET_32(isp, &src->ct_rxid, dst->ct_rxid);
1846         ISP_IOXGET_16(isp, &src->ct_senselen, dst->ct_senselen);
1847         ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
1848         ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
1849         ISP_IOXGET_16(isp, &src->ct_oxid, dst->ct_oxid);
1850         ISP_IOXGET_16(isp, &src->ct_scsi_status, dst->ct_scsi_status);
1851         if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
1852                 ISP_IOXGET_32(isp, &src->rsp.m0.reloff, dst->rsp.m0.reloff);
1853                 ISP_IOXGET_32(isp, &src->rsp.m0.reserved0, dst->rsp.m0.reserved0);
1854                 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen, dst->rsp.m0.ct_xfrlen);
1855                 ISP_IOXGET_32(isp, &src->rsp.m0.reserved1, dst->rsp.m0.reserved1);
1856                 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_base, dst->rsp.m0.ds.ds_base);
1857                 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_basehi, dst->rsp.m0.ds.ds_basehi);
1858                 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_count, dst->rsp.m0.ds.ds_count);
1859         } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
1860                 uint32_t *a, *b;
1861
1862                 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen, dst->rsp.m1.ct_resplen);
1863                 ISP_IOXGET_16(isp, &src->rsp.m1.reserved, dst->rsp.m1.reserved);
1864                 a = (uint32_t *) src->rsp.m1.ct_resp;
1865                 b = (uint32_t *) dst->rsp.m1.ct_resp;
1866                 for (i = 0; i < MAXRESPLEN_24XX; i++) {
1867                         ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i], dst->rsp.m1.ct_resp[i]);
1868                 }
1869                 for (i = 0; i < (nitems(src->rsp.m1.ct_resp) >> 2); i++) {
1870                         *b++ = ISP_SWAP32(isp, *a++);
1871                 }
1872         } else {
1873                 ISP_IOXGET_32(isp, &src->rsp.m2.reserved0, dst->rsp.m2.reserved0);
1874                 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen, dst->rsp.m2.ct_datalen);
1875                 ISP_IOXGET_32(isp, &src->rsp.m2.reserved1, dst->rsp.m2.reserved1);
1876                 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base, dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1877                 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi, dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
1878                 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count, dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1879         }
1880 }
1881
1882 void
1883 isp_put_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src, in_fcentry_24xx_t *dst)
1884 {
1885         int i;
1886
1887         isp_put_hdr(isp, &src->in_header, &dst->in_header);
1888         ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
1889         ISP_IOXPUT_16(isp, src->in_nphdl, &dst->in_nphdl);
1890         ISP_IOXPUT_16(isp, src->in_reserved1, &dst->in_reserved1);
1891         ISP_IOXPUT_16(isp, src->in_flags, &dst->in_flags);
1892         ISP_IOXPUT_16(isp, src->in_srr_rxid, &dst->in_srr_rxid);
1893         ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
1894         ISP_IOXPUT_8(isp, src->in_status_subcode, &dst->in_status_subcode);
1895         ISP_IOXPUT_8(isp, src->in_fwhandle, &dst->in_fwhandle);
1896         ISP_IOXPUT_32(isp, src->in_rxid, &dst->in_rxid);
1897         ISP_IOXPUT_16(isp, src->in_srr_reloff_hi, &dst->in_srr_reloff_hi);
1898         ISP_IOXPUT_16(isp, src->in_srr_reloff_lo, &dst->in_srr_reloff_lo);
1899         ISP_IOXPUT_16(isp, src->in_srr_iu, &dst->in_srr_iu);
1900         ISP_IOXPUT_16(isp, src->in_srr_oxid, &dst->in_srr_oxid);
1901         ISP_IOXPUT_16(isp, src->in_nport_id_hi, &dst->in_nport_id_hi);
1902         ISP_IOXPUT_8(isp, src->in_nport_id_lo, &dst->in_nport_id_lo);
1903         ISP_IOXPUT_8(isp, src->in_reserved3, &dst->in_reserved3);
1904         ISP_IOXPUT_16(isp, src->in_np_handle, &dst->in_np_handle);
1905         for (i = 0; i < nitems(src->in_reserved4); i++) {
1906                 ISP_IOXPUT_8(isp, src->in_reserved4[i], &dst->in_reserved4[i]);
1907         }
1908         ISP_IOXPUT_8(isp, src->in_reserved5, &dst->in_reserved5);
1909         ISP_IOXPUT_8(isp, src->in_vpidx, &dst->in_vpidx);
1910         ISP_IOXPUT_32(isp, src->in_reserved6, &dst->in_reserved6);
1911         ISP_IOXPUT_16(isp, src->in_portid_lo, &dst->in_portid_lo);
1912         ISP_IOXPUT_8(isp, src->in_portid_hi, &dst->in_portid_hi);
1913         ISP_IOXPUT_8(isp, src->in_reserved7, &dst->in_reserved7);
1914         ISP_IOXPUT_16(isp, src->in_reserved8, &dst->in_reserved8);
1915         ISP_IOXPUT_16(isp, src->in_oxid, &dst->in_oxid);
1916 }
1917
1918 void
1919 isp_get_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src, in_fcentry_24xx_t *dst)
1920 {
1921         int i;
1922
1923         isp_get_hdr(isp, &src->in_header, &dst->in_header);
1924         ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
1925         ISP_IOXGET_16(isp, &src->in_nphdl, dst->in_nphdl);
1926         ISP_IOXGET_16(isp, &src->in_reserved1, dst->in_reserved1);
1927         ISP_IOXGET_16(isp, &src->in_flags, dst->in_flags);
1928         ISP_IOXGET_16(isp, &src->in_srr_rxid, dst->in_srr_rxid);
1929         ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
1930         ISP_IOXGET_8(isp, &src->in_status_subcode, dst->in_status_subcode);
1931         ISP_IOXGET_8(isp, &src->in_fwhandle, dst->in_fwhandle);
1932         ISP_IOXGET_32(isp, &src->in_rxid, dst->in_rxid);
1933         ISP_IOXGET_16(isp, &src->in_srr_reloff_hi, dst->in_srr_reloff_hi);
1934         ISP_IOXGET_16(isp, &src->in_srr_reloff_lo, dst->in_srr_reloff_lo);
1935         ISP_IOXGET_16(isp, &src->in_srr_iu, dst->in_srr_iu);
1936         ISP_IOXGET_16(isp, &src->in_srr_oxid, dst->in_srr_oxid);
1937         ISP_IOXGET_16(isp, &src->in_nport_id_hi, dst->in_nport_id_hi);
1938         ISP_IOXGET_8(isp, &src->in_nport_id_lo, dst->in_nport_id_lo);
1939         ISP_IOXGET_8(isp, &src->in_reserved3, dst->in_reserved3);
1940         ISP_IOXGET_16(isp, &src->in_np_handle, dst->in_np_handle);
1941         for (i = 0; i < nitems(src->in_reserved4); i++) {
1942                 ISP_IOXGET_8(isp, &src->in_reserved4[i], dst->in_reserved4[i]);
1943         }
1944         ISP_IOXGET_8(isp, &src->in_reserved5, dst->in_reserved5);
1945         ISP_IOXGET_8(isp, &src->in_vpidx, dst->in_vpidx);
1946         ISP_IOXGET_32(isp, &src->in_reserved6, dst->in_reserved6);
1947         ISP_IOXGET_16(isp, &src->in_portid_lo, dst->in_portid_lo);
1948         ISP_IOXGET_8(isp, &src->in_portid_hi, dst->in_portid_hi);
1949         ISP_IOXGET_8(isp, &src->in_reserved7, dst->in_reserved7);
1950         ISP_IOXGET_16(isp, &src->in_reserved8, dst->in_reserved8);
1951         ISP_IOXGET_16(isp, &src->in_oxid, dst->in_oxid);
1952 }
1953
1954 void
1955 isp_put_notify_ack_24xx(ispsoftc_t *isp, na_fcentry_24xx_t *src, na_fcentry_24xx_t *dst)
1956 {
1957         int i;
1958
1959         isp_put_hdr(isp, &src->na_header, &dst->na_header);
1960         ISP_IOXPUT_32(isp, src->na_handle, &dst->na_handle);
1961         ISP_IOXPUT_16(isp, src->na_nphdl, &dst->na_nphdl);
1962         ISP_IOXPUT_16(isp, src->na_reserved1, &dst->na_reserved1);
1963         ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
1964         ISP_IOXPUT_16(isp, src->na_srr_rxid, &dst->na_srr_rxid);
1965         ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
1966         ISP_IOXPUT_8(isp, src->na_status_subcode, &dst->na_status_subcode);
1967         ISP_IOXPUT_8(isp, src->na_fwhandle, &dst->na_fwhandle);
1968         ISP_IOXPUT_32(isp, src->na_rxid, &dst->na_rxid);
1969         ISP_IOXPUT_16(isp, src->na_srr_reloff_hi, &dst->na_srr_reloff_hi);
1970         ISP_IOXPUT_16(isp, src->na_srr_reloff_lo, &dst->na_srr_reloff_lo);
1971         ISP_IOXPUT_16(isp, src->na_srr_iu, &dst->na_srr_iu);
1972         ISP_IOXPUT_16(isp, src->na_srr_flags, &dst->na_srr_flags);
1973         for (i = 0; i < 18; i++) {
1974                 ISP_IOXPUT_8(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
1975         }
1976         ISP_IOXPUT_8(isp, src->na_reserved4, &dst->na_reserved4);
1977         ISP_IOXPUT_8(isp, src->na_vpidx, &dst->na_vpidx);
1978         ISP_IOXPUT_8(isp, src->na_srr_reject_vunique, &dst->na_srr_reject_vunique);
1979         ISP_IOXPUT_8(isp, src->na_srr_reject_explanation, &dst->na_srr_reject_explanation);
1980         ISP_IOXPUT_8(isp, src->na_srr_reject_code, &dst->na_srr_reject_code);
1981         ISP_IOXPUT_8(isp, src->na_reserved5, &dst->na_reserved5);
1982         for (i = 0; i < 6; i++) {
1983                 ISP_IOXPUT_8(isp, src->na_reserved6[i], &dst->na_reserved6[i]);
1984         }
1985         ISP_IOXPUT_16(isp, src->na_oxid, &dst->na_oxid);
1986 }
1987
1988 void
1989 isp_get_notify_ack_24xx(ispsoftc_t *isp, na_fcentry_24xx_t *src, na_fcentry_24xx_t *dst)
1990 {
1991         int i;
1992
1993         isp_get_hdr(isp, &src->na_header, &dst->na_header);
1994         ISP_IOXGET_32(isp, &src->na_handle, dst->na_handle);
1995         ISP_IOXGET_16(isp, &src->na_nphdl, dst->na_nphdl);
1996         ISP_IOXGET_16(isp, &src->na_reserved1, dst->na_reserved1);
1997         ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
1998         ISP_IOXGET_16(isp, &src->na_srr_rxid, dst->na_srr_rxid);
1999         ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
2000         ISP_IOXGET_8(isp, &src->na_status_subcode, dst->na_status_subcode);
2001         ISP_IOXGET_8(isp, &src->na_fwhandle, dst->na_fwhandle);
2002         ISP_IOXGET_32(isp, &src->na_rxid, dst->na_rxid);
2003         ISP_IOXGET_16(isp, &src->na_srr_reloff_hi, dst->na_srr_reloff_hi);
2004         ISP_IOXGET_16(isp, &src->na_srr_reloff_lo, dst->na_srr_reloff_lo);
2005         ISP_IOXGET_16(isp, &src->na_srr_iu, dst->na_srr_iu);
2006         ISP_IOXGET_16(isp, &src->na_srr_flags, dst->na_srr_flags);
2007         for (i = 0; i < 18; i++) {
2008                 ISP_IOXGET_8(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
2009         }
2010         ISP_IOXGET_8(isp, &src->na_reserved4, dst->na_reserved4);
2011         ISP_IOXGET_8(isp, &src->na_vpidx, dst->na_vpidx);
2012         ISP_IOXGET_8(isp, &src->na_srr_reject_vunique, dst->na_srr_reject_vunique);
2013         ISP_IOXGET_8(isp, &src->na_srr_reject_explanation, dst->na_srr_reject_explanation);
2014         ISP_IOXGET_8(isp, &src->na_srr_reject_code, dst->na_srr_reject_code);
2015         ISP_IOXGET_8(isp, &src->na_reserved5, dst->na_reserved5);
2016         for (i = 0; i < 6; i++) {
2017                 ISP_IOXGET_8(isp, &src->na_reserved6[i], dst->na_reserved6[i]);
2018         }
2019         ISP_IOXGET_16(isp, &src->na_oxid, dst->na_oxid);
2020 }
2021
2022 void
2023 isp_get_abts(ispsoftc_t *isp, abts_t *src, abts_t *dst)
2024 {
2025         int i;
2026
2027         isp_get_hdr(isp, &src->abts_header, &dst->abts_header);
2028         for (i = 0; i < 6; i++) {
2029                 ISP_IOXGET_8(isp, &src->abts_reserved0[i], dst->abts_reserved0[i]);
2030         }
2031         ISP_IOXGET_16(isp, &src->abts_nphdl, dst->abts_nphdl);
2032         ISP_IOXGET_16(isp, &src->abts_reserved1, dst->abts_reserved1);
2033         ISP_IOXGET_16(isp, &src->abts_sof, dst->abts_sof);
2034         ISP_IOXGET_32(isp, &src->abts_rxid_abts, dst->abts_rxid_abts);
2035         ISP_IOXGET_16(isp, &src->abts_did_lo, dst->abts_did_lo);
2036         ISP_IOXGET_8(isp, &src->abts_did_hi, dst->abts_did_hi);
2037         ISP_IOXGET_8(isp, &src->abts_r_ctl, dst->abts_r_ctl);
2038         ISP_IOXGET_16(isp, &src->abts_sid_lo, dst->abts_sid_lo);
2039         ISP_IOXGET_8(isp, &src->abts_sid_hi, dst->abts_sid_hi);
2040         ISP_IOXGET_8(isp, &src->abts_cs_ctl, dst->abts_cs_ctl);
2041         ISP_IOXGET_16(isp, &src->abts_fs_ctl, dst->abts_fs_ctl);
2042         ISP_IOXGET_8(isp, &src->abts_f_ctl, dst->abts_f_ctl);
2043         ISP_IOXGET_8(isp, &src->abts_type, dst->abts_type);
2044         ISP_IOXGET_16(isp, &src->abts_seq_cnt, dst->abts_seq_cnt);
2045         ISP_IOXGET_8(isp, &src->abts_df_ctl, dst->abts_df_ctl);
2046         ISP_IOXGET_8(isp, &src->abts_seq_id, dst->abts_seq_id);
2047         ISP_IOXGET_16(isp, &src->abts_rx_id, dst->abts_rx_id);
2048         ISP_IOXGET_16(isp, &src->abts_ox_id, dst->abts_ox_id);
2049         ISP_IOXGET_32(isp, &src->abts_param, dst->abts_param);
2050         for (i = 0; i < 16; i++) {
2051                 ISP_IOXGET_8(isp, &src->abts_reserved2[i], dst->abts_reserved2[i]);
2052         }
2053         ISP_IOXGET_32(isp, &src->abts_rxid_task, dst->abts_rxid_task);
2054 }
2055
2056 void
2057 isp_put_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
2058 {
2059         int i;
2060
2061         isp_put_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
2062         ISP_IOXPUT_32(isp, src->abts_rsp_handle, &dst->abts_rsp_handle);
2063         ISP_IOXPUT_16(isp, src->abts_rsp_status, &dst->abts_rsp_status);
2064         ISP_IOXPUT_16(isp, src->abts_rsp_nphdl, &dst->abts_rsp_nphdl);
2065         ISP_IOXPUT_16(isp, src->abts_rsp_ctl_flags, &dst->abts_rsp_ctl_flags);
2066         ISP_IOXPUT_16(isp, src->abts_rsp_sof, &dst->abts_rsp_sof);
2067         ISP_IOXPUT_32(isp, src->abts_rsp_rxid_abts, &dst->abts_rsp_rxid_abts);
2068         ISP_IOXPUT_16(isp, src->abts_rsp_did_lo, &dst->abts_rsp_did_lo);
2069         ISP_IOXPUT_8(isp, src->abts_rsp_did_hi, &dst->abts_rsp_did_hi);
2070         ISP_IOXPUT_8(isp, src->abts_rsp_r_ctl, &dst->abts_rsp_r_ctl);
2071         ISP_IOXPUT_16(isp, src->abts_rsp_sid_lo, &dst->abts_rsp_sid_lo);
2072         ISP_IOXPUT_8(isp, src->abts_rsp_sid_hi, &dst->abts_rsp_sid_hi);
2073         ISP_IOXPUT_8(isp, src->abts_rsp_cs_ctl, &dst->abts_rsp_cs_ctl);
2074         ISP_IOXPUT_16(isp, src->abts_rsp_f_ctl_lo, &dst->abts_rsp_f_ctl_lo);
2075         ISP_IOXPUT_8(isp, src->abts_rsp_f_ctl_hi, &dst->abts_rsp_f_ctl_hi);
2076         ISP_IOXPUT_8(isp, src->abts_rsp_type, &dst->abts_rsp_type);
2077         ISP_IOXPUT_16(isp, src->abts_rsp_seq_cnt, &dst->abts_rsp_seq_cnt);
2078         ISP_IOXPUT_8(isp, src->abts_rsp_df_ctl, &dst->abts_rsp_df_ctl);
2079         ISP_IOXPUT_8(isp, src->abts_rsp_seq_id, &dst->abts_rsp_seq_id);
2080         ISP_IOXPUT_16(isp, src->abts_rsp_rx_id, &dst->abts_rsp_rx_id);
2081         ISP_IOXPUT_16(isp, src->abts_rsp_ox_id, &dst->abts_rsp_ox_id);
2082         ISP_IOXPUT_32(isp, src->abts_rsp_param, &dst->abts_rsp_param);
2083         if (src->abts_rsp_r_ctl == BA_ACC) {
2084                 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved, &dst->abts_rsp_payload.ba_acc.reserved);
2085                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.last_seq_id, &dst->abts_rsp_payload.ba_acc.last_seq_id);
2086                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.seq_id_valid, &dst->abts_rsp_payload.ba_acc.seq_id_valid);
2087                 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_rx_id, &dst->abts_rsp_payload.ba_acc.aborted_rx_id);
2088                 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_ox_id, &dst->abts_rsp_payload.ba_acc.aborted_ox_id);
2089                 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.high_seq_cnt, &dst->abts_rsp_payload.ba_acc.high_seq_cnt);
2090                 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.low_seq_cnt, &dst->abts_rsp_payload.ba_acc.low_seq_cnt);
2091                 for (i = 0; i < 4; i++) {
2092                         ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved2[i], &dst->abts_rsp_payload.ba_acc.reserved2[i]);
2093                 }
2094         } else if (src->abts_rsp_r_ctl == BA_RJT) {
2095                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.vendor_unique, &dst->abts_rsp_payload.ba_rjt.vendor_unique);
2096                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.explanation, &dst->abts_rsp_payload.ba_rjt.explanation);
2097                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reason, &dst->abts_rsp_payload.ba_rjt.reason);
2098                 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reserved, &dst->abts_rsp_payload.ba_rjt.reserved);
2099                 for (i = 0; i < 12; i++) {
2100                         ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_rjt.reserved2[i], &dst->abts_rsp_payload.ba_rjt.reserved2[i]);
2101                 }
2102         } else {
2103                 for (i = 0; i < 16; i++) {
2104                         ISP_IOXPUT_8(isp, src->abts_rsp_payload.reserved[i], &dst->abts_rsp_payload.reserved[i]);
2105                 }
2106         }
2107         ISP_IOXPUT_32(isp, src->abts_rsp_rxid_task, &dst->abts_rsp_rxid_task);
2108 }
2109
2110 void
2111 isp_get_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
2112 {
2113         int i;
2114
2115         isp_get_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
2116         ISP_IOXGET_32(isp, &src->abts_rsp_handle, dst->abts_rsp_handle);
2117         ISP_IOXGET_16(isp, &src->abts_rsp_status, dst->abts_rsp_status);
2118         ISP_IOXGET_16(isp, &src->abts_rsp_nphdl, dst->abts_rsp_nphdl);
2119         ISP_IOXGET_16(isp, &src->abts_rsp_ctl_flags, dst->abts_rsp_ctl_flags);
2120         ISP_IOXGET_16(isp, &src->abts_rsp_sof, dst->abts_rsp_sof);
2121         ISP_IOXGET_32(isp, &src->abts_rsp_rxid_abts, dst->abts_rsp_rxid_abts);
2122         ISP_IOXGET_16(isp, &src->abts_rsp_did_lo, dst->abts_rsp_did_lo);
2123         ISP_IOXGET_8(isp, &src->abts_rsp_did_hi, dst->abts_rsp_did_hi);
2124         ISP_IOXGET_8(isp, &src->abts_rsp_r_ctl, dst->abts_rsp_r_ctl);
2125         ISP_IOXGET_16(isp, &src->abts_rsp_sid_lo, dst->abts_rsp_sid_lo);
2126         ISP_IOXGET_8(isp, &src->abts_rsp_sid_hi, dst->abts_rsp_sid_hi);
2127         ISP_IOXGET_8(isp, &src->abts_rsp_cs_ctl, dst->abts_rsp_cs_ctl);
2128         ISP_IOXGET_16(isp, &src->abts_rsp_f_ctl_lo, dst->abts_rsp_f_ctl_lo);
2129         ISP_IOXGET_8(isp, &src->abts_rsp_f_ctl_hi, dst->abts_rsp_f_ctl_hi);
2130         ISP_IOXGET_8(isp, &src->abts_rsp_type, dst->abts_rsp_type);
2131         ISP_IOXGET_16(isp, &src->abts_rsp_seq_cnt, dst->abts_rsp_seq_cnt);
2132         ISP_IOXGET_8(isp, &src->abts_rsp_df_ctl, dst->abts_rsp_df_ctl);
2133         ISP_IOXGET_8(isp, &src->abts_rsp_seq_id, dst->abts_rsp_seq_id);
2134         ISP_IOXGET_16(isp, &src->abts_rsp_rx_id, dst->abts_rsp_rx_id);
2135         ISP_IOXGET_16(isp, &src->abts_rsp_ox_id, dst->abts_rsp_ox_id);
2136         ISP_IOXGET_32(isp, &src->abts_rsp_param, dst->abts_rsp_param);
2137         for (i = 0; i < 8; i++) {
2138                 ISP_IOXGET_8(isp, &src->abts_rsp_payload.rsp.reserved[i], dst->abts_rsp_payload.rsp.reserved[i]);
2139         }
2140         ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode1, dst->abts_rsp_payload.rsp.subcode1);
2141         ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode2, dst->abts_rsp_payload.rsp.subcode2);
2142         ISP_IOXGET_32(isp, &src->abts_rsp_rxid_task, dst->abts_rsp_rxid_task);
2143 }
2144 #endif  /* ISP_TARGET_MODE */
2145 /*
2146  * vim:ts=8:sw=8
2147  */