?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rc.conf: Add and document the missing root_rw_mount=YES
[dragonfly.git] / sys / dev / disk / isp / isp_library.c
blobb82487bbe2cffbff03af46b079f605c11efa195f
1 /*-
2 * Copyright (c) 1997-2009 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: src/sys/dev/isp/isp_library.c,v 1.24 2011/02/14 21:50:51 marius Exp $
28 */
29 /*
30 * Qlogic Host Adapter Internal Library Functions
31 */
32 #include <dev/disk/isp/isp_freebsd.h>
33
34 const char *isp_class3_roles[4] = {
35 "None", "Target", "Initiator", "Target/Initiator"
36 };
37
38 /*
39 * Command shipping- finish off first queue entry and do dma mapping and additional segments as needed.
40 *
41 * Called with the first queue entry at least partially filled out.
42 */
43 int
44 isp_send_cmd(ispsoftc_t *isp, void *fqe, void *segp, uint32_t nsegs, uint32_t totalcnt, isp_ddir_t ddir)
45 {
46 uint8_t storage[QENTRY_LEN];
47 uint8_t type, nqe;
48 uint32_t seg, curseg, seglim, nxt, nxtnxt, ddf;
49 ispds_t *dsp = NULL;
50 ispds64_t *dsp64 = NULL;
51 void *qe0, *qe1;
52
53 qe0 = isp_getrqentry(isp);
54 if (qe0 == NULL) {
55 return (CMD_EAGAIN);
56 }
57 nxt = ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp));
58
59 type = ((isphdr_t *)fqe)->rqs_entry_type;
60 nqe = 1;
61
62 /*
63 * If we have no data to transmit, just copy the first IOCB and start it up.
64 */
65 if (ddir == ISP_NOXFR) {
66 if (type == RQSTYPE_T2RQS || type == RQSTYPE_T3RQS) {
67 ddf = CT2_NO_DATA;
68 } else {
69 ddf = 0;
70 }
71 goto copy_and_sync;
72 }
73
74 /*
75 * First figure out how many pieces of data to transfer and what kind and how many we can put into the first queue entry.
76 */
77 switch (type) {
78 case RQSTYPE_REQUEST:
79 ddf = (ddir == ISP_TO_DEVICE)? REQFLAG_DATA_OUT : REQFLAG_DATA_IN;
80 dsp = ((ispreq_t *)fqe)->req_dataseg;
81 seglim = ISP_RQDSEG;
82 break;
83 case RQSTYPE_CMDONLY:
84 ddf = (ddir == ISP_TO_DEVICE)? REQFLAG_DATA_OUT : REQFLAG_DATA_IN;
85 seglim = 0;
86 break;
87 case RQSTYPE_T2RQS:
88 ddf = (ddir == ISP_TO_DEVICE)? REQFLAG_DATA_OUT : REQFLAG_DATA_IN;
89 dsp = ((ispreqt2_t *)fqe)->req_dataseg;
90 seglim = ISP_RQDSEG_T2;
91 break;
92 case RQSTYPE_A64:
93 ddf = (ddir == ISP_TO_DEVICE)? REQFLAG_DATA_OUT : REQFLAG_DATA_IN;
94 dsp64 = ((ispreqt3_t *)fqe)->req_dataseg;
95 seglim = ISP_RQDSEG_T3;
96 break;
97 case RQSTYPE_T3RQS:
98 ddf = (ddir == ISP_TO_DEVICE)? REQFLAG_DATA_OUT : REQFLAG_DATA_IN;
99 dsp64 = ((ispreqt3_t *)fqe)->req_dataseg;
100 seglim = ISP_RQDSEG_T3;
101 break;
102 case RQSTYPE_T7RQS:
103 ddf = (ddir == ISP_TO_DEVICE)? FCP_CMND_DATA_WRITE : FCP_CMND_DATA_READ;
104 dsp64 = &((ispreqt7_t *)fqe)->req_dataseg;
105 seglim = 1;
106 break;
107 default:
108 return (CMD_COMPLETE);
109 }
110
111 if (seglim > nsegs) {
112 seglim = nsegs;
113 }
114
115 for (seg = curseg = 0; curseg < seglim; curseg++) {
116 if (dsp64) {
117 XS_GET_DMA64_SEG(dsp64++, segp, seg++);
118 } else {
119 XS_GET_DMA_SEG(dsp++, segp, seg++);
120 }
121 }
122
123
124 /*
125 * Second, start building additional continuation segments as needed.
126 */
127 while (seg < nsegs) {
128 nxtnxt = ISP_NXT_QENTRY(nxt, RQUEST_QUEUE_LEN(isp));
129 if (nxtnxt == isp->isp_reqodx) {
130 return (CMD_EAGAIN);
131 }
132 ISP_MEMZERO(storage, QENTRY_LEN);
133 qe1 = ISP_QUEUE_ENTRY(isp->isp_rquest, nxt);
134 nxt = nxtnxt;
135 if (dsp64) {
136 ispcontreq64_t *crq = (ispcontreq64_t *) storage;
137 seglim = ISP_CDSEG64;
138 crq->req_header.rqs_entry_type = RQSTYPE_A64_CONT;
139 crq->req_header.rqs_entry_count = 1;
140 dsp64 = crq->req_dataseg;
141 } else {
142 ispcontreq_t *crq = (ispcontreq_t *) storage;
143 seglim = ISP_CDSEG;
144 crq->req_header.rqs_entry_type = RQSTYPE_DATASEG;
145 crq->req_header.rqs_entry_count = 1;
146 dsp = crq->req_dataseg;
147 }
148 if (seg + seglim > nsegs) {
149 seglim = nsegs - seg;
150 }
151 for (curseg = 0; curseg < seglim; curseg++) {
152 if (dsp64) {
153 XS_GET_DMA64_SEG(dsp64++, segp, seg++);
154 } else {
155 XS_GET_DMA_SEG(dsp++, segp, seg++);
156 }
157 }
158 if (dsp64) {
159 isp_put_cont64_req(isp, (ispcontreq64_t *)storage, qe1);
160 } else {
161 isp_put_cont_req(isp, (ispcontreq_t *)storage, qe1);
162 }
163 if (isp->isp_dblev & ISP_LOGDEBUG1) {
164 isp_print_bytes(isp, "additional queue entry", QENTRY_LEN, storage);
165 }
166 nqe++;
167 }
168
169 copy_and_sync:
170 ((isphdr_t *)fqe)->rqs_entry_count = nqe;
171 switch (type) {
172 case RQSTYPE_REQUEST:
173 ((ispreq_t *)fqe)->req_flags |= ddf;
174 /*
175 * This is historical and not clear whether really needed.
176 */
177 if (nsegs == 0) {
178 nsegs = 1;
179 }
180 ((ispreq_t *)fqe)->req_seg_count = nsegs;
181 isp_put_request(isp, fqe, qe0);
182 break;
183 case RQSTYPE_CMDONLY:
184 ((ispreq_t *)fqe)->req_flags |= ddf;
185 /*
186 * This is historical and not clear whether really needed.
187 */
188 if (nsegs == 0) {
189 nsegs = 1;
190 }
191 ((ispextreq_t *)fqe)->req_seg_count = nsegs;
192 isp_put_extended_request(isp, fqe, qe0);
193 break;
194 case RQSTYPE_T2RQS:
195 ((ispreqt2_t *)fqe)->req_flags |= ddf;
196 ((ispreqt2_t *)fqe)->req_seg_count = nsegs;
197 ((ispreqt2_t *)fqe)->req_totalcnt = totalcnt;
198 if (ISP_CAP_2KLOGIN(isp)) {
199 isp_put_request_t2e(isp, fqe, qe0);
200 } else {
201 isp_put_request_t2(isp, fqe, qe0);
202 }
203 break;
204 case RQSTYPE_A64:
205 case RQSTYPE_T3RQS:
206 ((ispreqt3_t *)fqe)->req_flags |= ddf;
207 ((ispreqt3_t *)fqe)->req_seg_count = nsegs;
208 ((ispreqt3_t *)fqe)->req_totalcnt = totalcnt;
209 if (ISP_CAP_2KLOGIN(isp)) {
210 isp_put_request_t3e(isp, fqe, qe0);
211 } else {
212 isp_put_request_t3(isp, fqe, qe0);
213 }
214 break;
215 case RQSTYPE_T7RQS:
216 ((ispreqt7_t *)fqe)->req_alen_datadir = ddf;
217 ((ispreqt7_t *)fqe)->req_seg_count = nsegs;
218 ((ispreqt7_t *)fqe)->req_dl = totalcnt;
219 isp_put_request_t7(isp, fqe, qe0);
220 break;
221 default:
222 return (CMD_COMPLETE);
223 }
224 if (isp->isp_dblev & ISP_LOGDEBUG1) {
225 isp_print_bytes(isp, "first queue entry", QENTRY_LEN, fqe);
226 }
227 ISP_ADD_REQUEST(isp, nxt);
228 return (CMD_QUEUED);
229 }
230
231 int
232 isp_allocate_xs(ispsoftc_t *isp, XS_T *xs, uint32_t *handlep)
233 {
234 isp_hdl_t *hdp;
235
236 hdp = isp->isp_xffree;
237 if (hdp == NULL) {
238 return (-1);
239 }
240 isp->isp_xffree = hdp->cmd;
241 hdp->cmd = xs;
242 hdp->handle = (hdp - isp->isp_xflist);
243 hdp->handle |= (ISP_HANDLE_INITIATOR << ISP_HANDLE_USAGE_SHIFT);
244 hdp->handle |= (isp->isp_seqno++ << ISP_HANDLE_SEQ_SHIFT);
245 *handlep = hdp->handle;
246 return (0);
247 }
248
249 XS_T *
250 isp_find_xs(ispsoftc_t *isp, uint32_t handle)
251 {
252 if (!ISP_VALID_INI_HANDLE(isp, handle)) {
253 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
254 return (NULL);
255 }
256 return (isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].cmd);
257 }
258
259 uint32_t
260 isp_find_handle(ispsoftc_t *isp, XS_T *xs)
261 {
262 uint32_t i, foundhdl = ISP_HANDLE_FREE;
263
264 if (xs != NULL) {
265 for (i = 0; i < isp->isp_maxcmds; i++) {
266 if (isp->isp_xflist[i].cmd != xs) {
267 continue;
268 }
269 foundhdl = isp->isp_xflist[i].handle;
270 break;
271 }
272 }
273 return (foundhdl);
274 }
275
276 uint32_t
277 isp_handle_index(ispsoftc_t *isp, uint32_t handle)
278 {
279 if (!ISP_VALID_HANDLE(isp, handle)) {
280 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
281 return (ISP_BAD_HANDLE_INDEX);
282 } else {
283 return (handle & ISP_HANDLE_CMD_MASK);
284 }
285 }
286
287 void
288 isp_destroy_handle(ispsoftc_t *isp, uint32_t handle)
289 {
290 if (!ISP_VALID_INI_HANDLE(isp, handle)) {
291 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
292 } else {
293 isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].handle = ISP_HANDLE_FREE;
294 isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)].cmd = isp->isp_xffree;
295 isp->isp_xffree = &isp->isp_xflist[(handle & ISP_HANDLE_CMD_MASK)];
296 }
297 }
298
299 /*
300 * Make sure we have space to put something on the request queue.
301 * Return a pointer to that entry if we do. A side effect of this
302 * function is to update the output index. The input index
303 * stays the same.
304 */
305 void *
306 isp_getrqentry(ispsoftc_t *isp)
307 {
308 isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
309 if (ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp)) == isp->isp_reqodx) {
310 return (NULL);
311 }
312 return (ISP_QUEUE_ENTRY(isp->isp_rquest, isp->isp_reqidx));
313 }
314
315 #define TBA (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
316 void
317 isp_print_qentry(ispsoftc_t *isp, const char *msg, int idx, void *arg)
318 {
319 char buf[TBA];
320 int amt, i, j;
321 uint8_t *ptr = arg;
322
323 isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx);
324 for (buf[0] = 0, amt = i = 0; i < 4; i++) {
325 buf[0] = 0;
326 ISP_SNPRINTF(buf, TBA, " ");
327 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
328 ISP_SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff);
329 }
330 isp_prt(isp, ISP_LOGALL, "%s", buf);
331 }
332 }
333
334 void
335 isp_print_bytes(ispsoftc_t *isp, const char *msg, int amt, void *arg)
336 {
337 char buf[128];
338 uint8_t *ptr = arg;
339 int off;
340
341 if (msg)
342 isp_prt(isp, ISP_LOGALL, "%s:", msg);
343 off = 0;
344 buf[0] = 0;
345 while (off < amt) {
346 int j, to;
347 to = off;
348 for (j = 0; j < 16; j++) {
349 ISP_SNPRINTF(buf, 128, "%s %02x", buf, ptr[off++] & 0xff);
350 if (off == amt) {
351 break;
352 }
353 }
354 isp_prt(isp, ISP_LOGALL, "0x%08x:%s", to, buf);
355 buf[0] = 0;
356 }
357 }
358
359 /*
360 * Do the common path to try and ensure that link is up, we've scanned
361 * the fabric (if we're on a fabric), and that we've synchronized this
362 * all with our own database and done the appropriate logins.
363 *
364 * We repeatedly check for firmware state and loop state after each
365 * action because things may have changed while we were doing this.
366 * Any failure or change of state causes us to return a nonzero value.
367 *
368 * We assume we enter here with any locks held.
369 */
370
371 int
372 isp_fc_runstate(ispsoftc_t *isp, int chan, int tval)
373 {
374 fcparam *fcp;
375
376 fcp = FCPARAM(isp, chan);
377 if (fcp->role == ISP_ROLE_NONE) {
378 return (0);
379 }
380 if (fcp->isp_fwstate < FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD) {
381 if (isp_control(isp, ISPCTL_FCLINK_TEST, chan, tval) != 0) {
382 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: linktest failed for channel %d", chan);
383 return (-1);
384 }
385 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD) {
386 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: f/w not ready for channel %d", chan);
387 return (-1);
388 }
389 }
390
391 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
392 return (0);
393 }
394
395 if (isp_control(isp, ISPCTL_SCAN_LOOP, chan) != 0) {
396 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: scan loop fails on channel %d", chan);
397 return (LOOP_PDB_RCVD);
398 }
399 if (isp_control(isp, ISPCTL_SCAN_FABRIC, chan) != 0) {
400 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: scan fabric fails on channel %d", chan);
401 return (LOOP_LSCAN_DONE);
402 }
403 if (isp_control(isp, ISPCTL_PDB_SYNC, chan) != 0) {
404 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: pdb_sync fails on channel %d", chan);
405 return (LOOP_FSCAN_DONE);
406 }
407 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
408 isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: f/w not ready again on channel %d", chan);
409 return (-1);
410 }
411 return (0);
412 }
413
414 /*
415 * Fibre Channel Support routines
416 */
417 void
418 isp_dump_portdb(ispsoftc_t *isp, int chan)
419 {
420 fcparam *fcp = FCPARAM(isp, chan);
421 int i;
422
423 for (i = 0; i < MAX_FC_TARG; i++) {
424 char mb[4];
425 const char *dbs[8] = {
426 "NIL ",
427 "PROB",
428 "DEAD",
429 "CHGD",
430 "NEW ",
431 "PVLD",
432 "ZOMB",
433 "VLD "
434 };
435 const char *roles[4] = {
436 " UNK", " TGT", " INI", "TINI"
437 };
438 fcportdb_t *lp = &fcp->portdb[i];
439
440 if (lp->state == FC_PORTDB_STATE_NIL && lp->target_mode == 0) {
441 continue;
442 }
443 if (lp->dev_map_idx) {
444 ISP_SNPRINTF(mb, sizeof (mb), "%3d", ((int) lp->dev_map_idx) - 1);
445 } else {
446 ISP_SNPRINTF(mb, sizeof (mb), "---");
447 }
448 isp_prt(isp, ISP_LOGALL, "Chan %d [%d]: hdl 0x%x %s al%d tgt %s %s 0x%06x =>%s 0x%06x; WWNN 0x%08x%08x WWPN 0x%08x%08x",
449 chan, i, lp->handle, dbs[lp->state], lp->autologin, mb, roles[lp->roles], lp->portid, roles[lp->new_roles], lp->new_portid,
450 (uint32_t) (lp->node_wwn >> 32), (uint32_t) (lp->node_wwn), (uint32_t) (lp->port_wwn >> 32), (uint32_t) (lp->port_wwn));
451 }
452 }
453
454 const char *
455 isp_fc_fw_statename(int state)
456 {
457 switch (state) {
458 case FW_CONFIG_WAIT: return "Config Wait";
459 case FW_WAIT_AL_PA: return "Waiting for AL_PA";
460 case FW_WAIT_LOGIN: return "Wait Login";
461 case FW_READY: return "Ready";
462 case FW_LOSS_OF_SYNC: return "Loss Of Sync";
463 case FW_ERROR: return "Error";
464 case FW_REINIT: return "Re-Init";
465 case FW_NON_PART: return "Nonparticipating";
466 default: return "?????";
467 }
468 }
469
470 const char *
471 isp_fc_loop_statename(int state)
472 {
473 switch (state) {
474 case LOOP_NIL: return "NIL";
475 case LOOP_LIP_RCVD: return "LIP Received";
476 case LOOP_PDB_RCVD: return "PDB Received";
477 case LOOP_SCANNING_LOOP: return "Scanning";
478 case LOOP_LSCAN_DONE: return "Loop Scan Done";
479 case LOOP_SCANNING_FABRIC: return "Scanning Fabric";
480 case LOOP_FSCAN_DONE: return "Fabric Scan Done";
481 case LOOP_SYNCING_PDB: return "Syncing PDB";
482 case LOOP_READY: return "Ready";
483 default: return "?????";
484 }
485 }
486
487 const char *
488 isp_fc_toponame(fcparam *fcp)
489 {
490
491 if (fcp->isp_fwstate != FW_READY) {
492 return "Unavailable";
493 }
494 switch (fcp->isp_topo) {
495 case TOPO_NL_PORT: return "Private Loop";
496 case TOPO_FL_PORT: return "FL Port";
497 case TOPO_N_PORT: return "N-Port to N-Port";
498 case TOPO_F_PORT: return "F Port";
499 case TOPO_PTP_STUB: return "F Port (no FLOGI_ACC response)";
500 default: return "?????";
501 }
502 }
503
504 /*
505 * Change Roles
506 */
507 int
508 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
509 {
510 fcparam *fcp = FCPARAM(isp, chan);
511
512 if (chan >= isp->isp_nchan) {
513 isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
514 return (ENXIO);
515 }
516 if (chan == 0) {
517 #ifdef ISP_TARGET_MODE
518 isp_del_all_wwn_entries(isp, chan);
519 #endif
520 isp_clear_commands(isp);
521
522 isp_reset(isp, 0);
523 if (isp->isp_state != ISP_RESETSTATE) {
524 isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
525 return (EIO);
526 }
527 fcp->role = new_role;
528 isp_init(isp);
529 if (isp->isp_state != ISP_INITSTATE) {
530 isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
531 return (EIO);
532 }
533 isp->isp_state = ISP_RUNSTATE;
534 return (0);
535 } else if (ISP_CAP_MULTI_ID(isp)) {
536 mbreg_t mbs;
537 vp_modify_t *vp;
538 uint8_t qe[QENTRY_LEN], *scp;
539
540 ISP_MEMZERO(qe, QENTRY_LEN);
541 /* Acquire Scratch */
542
543 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
544 return (EBUSY);
545 }
546 scp = fcp->isp_scratch;
547
548 /*
549 * Build a VP MODIFY command in memory
550 */
551 vp = (vp_modify_t *) qe;
552 vp->vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
553 vp->vp_mod_hdr.rqs_entry_count = 1;
554 vp->vp_mod_cnt = 1;
555 vp->vp_mod_idx0 = chan;
556 vp->vp_mod_cmd = VP_MODIFY_ENA;
557 vp->vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED;
558 if (new_role & ISP_ROLE_INITIATOR) {
559 vp->vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
560 }
561 if ((new_role & ISP_ROLE_TARGET) == 0) {
562 vp->vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
563 }
564 MAKE_NODE_NAME_FROM_WWN(vp->vp_mod_ports[0].wwpn, fcp->isp_wwpn);
565 MAKE_NODE_NAME_FROM_WWN(vp->vp_mod_ports[0].wwnn, fcp->isp_wwnn);
566 isp_put_vp_modify(isp, vp, (vp_modify_t *) scp);
567
568 /*
569 * Build a EXEC IOCB A64 command that points to the VP MODIFY command
570 */
571 MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 0);
572 mbs.param[1] = QENTRY_LEN;
573 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
574 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
575 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
576 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
577 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, 2 * QENTRY_LEN, chan);
578 isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
579 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
580 FC_SCRATCH_RELEASE(isp, chan);
581 return (EIO);
582 }
583 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
584 isp_get_vp_modify(isp, (vp_modify_t *)&scp[QENTRY_LEN], vp);
585
586 #ifdef ISP_TARGET_MODE
587 isp_del_all_wwn_entries(isp, chan);
588 #endif
589 /*
590 * Release Scratch
591 */
592 FC_SCRATCH_RELEASE(isp, chan);
593
594 if (vp->vp_mod_status != VP_STS_OK) {
595 isp_prt(isp, ISP_LOGERR, "%s: VP_MODIFY of Chan %d failed with status %d", __func__, chan, vp->vp_mod_status);
596 return (EIO);
597 }
598 fcp->role = new_role;
599 return (0);
600 } else {
601 return (EINVAL);
602 }
603 }
604
605 void
606 isp_clear_commands(ispsoftc_t *isp)
607 {
608 uint32_t tmp;
609 isp_hdl_t *hdp;
610 #ifdef ISP_TARGET_MODE
611 isp_notify_t notify;
612 #endif
613
614 for (tmp = 0; isp->isp_xflist && tmp < isp->isp_maxcmds; tmp++) {
615 XS_T *xs;
616
617 hdp = &isp->isp_xflist[tmp];
618 if (hdp->handle == ISP_HANDLE_FREE) {
619 continue;
620 }
621 xs = hdp->cmd;
622 if (XS_XFRLEN(xs)) {
623 ISP_DMAFREE(isp, xs, hdp->handle);
624 XS_SET_RESID(xs, XS_XFRLEN(xs));
625 } else {
626 XS_SET_RESID(xs, 0);
627 }
628 hdp->handle = 0;
629 hdp->cmd = NULL;
630 XS_SETERR(xs, HBA_BUSRESET);
631 isp_done(xs);
632 }
633 #ifdef ISP_TARGET_MODE
634 for (tmp = 0; isp->isp_tgtlist && tmp < isp->isp_maxcmds; tmp++) {
635 uint8_t local[QENTRY_LEN];
636 hdp = &isp->isp_tgtlist[tmp];
637 if (hdp->handle == ISP_HANDLE_FREE) {
638 continue;
639 }
640 ISP_DMAFREE(isp, hdp->cmd, hdp->handle);
641 ISP_MEMZERO(local, QENTRY_LEN);
642 if (IS_24XX(isp)) {
643 ct7_entry_t *ctio = (ct7_entry_t *) local;
644 ctio->ct_syshandle = hdp->handle;
645 ctio->ct_nphdl = CT_HBA_RESET;
646 ctio->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
647 } else if (IS_FC(isp)) {
648 ct2_entry_t *ctio = (ct2_entry_t *) local;
649 ctio->ct_syshandle = hdp->handle;
650 ctio->ct_status = CT_HBA_RESET;
651 ctio->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
652 } else {
653 ct_entry_t *ctio = (ct_entry_t *) local;
654 ctio->ct_syshandle = hdp->handle;
655 ctio->ct_status = CT_HBA_RESET & 0xff;
656 ctio->ct_header.rqs_entry_type = RQSTYPE_CTIO;
657 }
658 isp_async(isp, ISPASYNC_TARGET_ACTION, local);
659 }
660 for (tmp = 0; tmp < isp->isp_nchan; tmp++) {
661 ISP_MEMZERO(&notify, sizeof (isp_notify_t));
662 notify.nt_ncode = NT_HBA_RESET;
663 notify.nt_hba = isp;
664 notify.nt_wwn = INI_ANY;
665 notify.nt_nphdl = NIL_HANDLE;
666 notify.nt_sid = PORT_ANY;
667 notify.nt_did = PORT_ANY;
668 notify.nt_tgt = TGT_ANY;
669 notify.nt_channel = tmp;
670 notify.nt_lun = LUN_ANY;
671 notify.nt_tagval = TAG_ANY;
672 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
673 }
674 #endif
675 }
676
677 void
678 isp_shutdown(ispsoftc_t *isp)
679 {
680 if (IS_FC(isp)) {
681 if (IS_24XX(isp)) {
682 ISP_WRITE(isp, BIU2400_ICR, 0);
683 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
684 } else {
685 ISP_WRITE(isp, BIU_ICR, 0);
686 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
687 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
688 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
689 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
690 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
691 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
692 }
693 } else {
694 ISP_WRITE(isp, BIU_ICR, 0);
695 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
696 }
697 }
698
699 /*
700 * Functions to move stuff to a form that the QLogic RISC engine understands
701 * and functions to move stuff back to a form the processor understands.
702 *
703 * Each platform is required to provide the 8, 16 and 32 bit
704 * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32})
705 *
706 * The assumption is that swizzling and unswizzling is mostly done 'in place'
707 * (with a few exceptions for efficiency).
708 */
709
710 #define ISP_IS_SBUS(isp) (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
711
712 #define ASIZE(x) (sizeof (x) / sizeof (x[0]))
713 /*
714 * Swizzle/Copy Functions
715 */
716 void
717 isp_put_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
718 {
719 if (ISP_IS_SBUS(isp)) {
720 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type, &hpdst->rqs_entry_count);
721 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count, &hpdst->rqs_entry_type);
722 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno, &hpdst->rqs_flags);
723 ISP_IOXPUT_8(isp, hpsrc->rqs_flags, &hpdst->rqs_seqno);
724 } else {
725 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type, &hpdst->rqs_entry_type);
726 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count, &hpdst->rqs_entry_count);
727 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno, &hpdst->rqs_seqno);
728 ISP_IOXPUT_8(isp, hpsrc->rqs_flags, &hpdst->rqs_flags);
729 }
730 }
731
732 void
733 isp_get_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
734 {
735 if (ISP_IS_SBUS(isp)) {
736 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type, hpdst->rqs_entry_count);
737 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count, hpdst->rqs_entry_type);
738 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno, hpdst->rqs_flags);
739 ISP_IOXGET_8(isp, &hpsrc->rqs_flags, hpdst->rqs_seqno);
740 } else {
741 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type, hpdst->rqs_entry_type);
742 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count, hpdst->rqs_entry_count);
743 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno, hpdst->rqs_seqno);
744 ISP_IOXGET_8(isp, &hpsrc->rqs_flags, hpdst->rqs_flags);
745 }
746 }
747
748 int
749 isp_get_response_type(ispsoftc_t *isp, isphdr_t *hp)
750 {
751 uint8_t type;
752 if (ISP_IS_SBUS(isp)) {
753 ISP_IOXGET_8(isp, &hp->rqs_entry_count, type);
754 } else {
755 ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
756 }
757 return ((int)type);
758 }
759
760 void
761 isp_put_request(ispsoftc_t *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
762 {
763 int i;
764 isp_put_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
765 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
766 if (ISP_IS_SBUS(isp)) {
767 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
768 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
769 } else {
770 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn);
771 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target);
772 }
773 ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen);
774 ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
775 ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
776 ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
777 for (i = 0; i < ASIZE(rqsrc->req_cdb); i++) {
778 ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
779 }
780 for (i = 0; i < ISP_RQDSEG; i++) {
781 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base, &rqdst->req_dataseg[i].ds_base);
782 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count, &rqdst->req_dataseg[i].ds_count);
783 }
784 }
785
786 void
787 isp_put_marker(ispsoftc_t *isp, isp_marker_t *src, isp_marker_t *dst)
788 {
789 int i;
790 isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
791 ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
792 if (ISP_IS_SBUS(isp)) {
793 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_target);
794 ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_reserved0);
795 } else {
796 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
797 ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_target);
798 }
799 ISP_IOXPUT_16(isp, src->mrk_modifier, &dst->mrk_modifier);
800 ISP_IOXPUT_16(isp, src->mrk_flags, &dst->mrk_flags);
801 ISP_IOXPUT_16(isp, src->mrk_lun, &dst->mrk_lun);
802 for (i = 0; i < ASIZE(src->mrk_reserved1); i++) {
803 ISP_IOXPUT_8(isp, src->mrk_reserved1[i], &dst->mrk_reserved1[i]);
804 }
805 }
806
807 void
808 isp_put_marker_24xx(ispsoftc_t *isp, isp_marker_24xx_t *src, isp_marker_24xx_t *dst)
809 {
810 int i;
811 isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
812 ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
813 ISP_IOXPUT_16(isp, src->mrk_nphdl, &dst->mrk_nphdl);
814 ISP_IOXPUT_8(isp, src->mrk_modifier, &dst->mrk_modifier);
815 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
816 ISP_IOXPUT_8(isp, src->mrk_reserved1, &dst->mrk_reserved1);
817 ISP_IOXPUT_8(isp, src->mrk_vphdl, &dst->mrk_vphdl);
818 ISP_IOXPUT_8(isp, src->mrk_reserved2, &dst->mrk_reserved2);
819 for (i = 0; i < ASIZE(src->mrk_lun); i++) {
820 ISP_IOXPUT_8(isp, src->mrk_lun[i], &dst->mrk_lun[i]);
821 }
822 for (i = 0; i < ASIZE(src->mrk_reserved3); i++) {
823 ISP_IOXPUT_8(isp, src->mrk_reserved3[i], &dst->mrk_reserved3[i]);
824 }
825 }
826
827 void
828 isp_put_request_t2(ispsoftc_t *isp, ispreqt2_t *src, ispreqt2_t *dst)
829 {
830 int i;
831 isp_put_hdr(isp, &src->req_header, &dst->req_header);
832 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
833 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
834 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
835 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
836 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
837 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
838 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
839 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
840 for (i = 0; i < ASIZE(src->req_cdb); i++) {
841 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
842 }
843 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
844 for (i = 0; i < ISP_RQDSEG_T2; i++) {
845 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
846 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
847 }
848 }
849
850 void
851 isp_put_request_t2e(ispsoftc_t *isp, ispreqt2e_t *src, ispreqt2e_t *dst)
852 {
853 int i;
854 isp_put_hdr(isp, &src->req_header, &dst->req_header);
855 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
856 ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
857 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
858 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
859 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
860 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
861 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
862 for (i = 0; i < ASIZE(src->req_cdb); i++) {
863 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
864 }
865 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
866 for (i = 0; i < ISP_RQDSEG_T2; i++) {
867 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
868 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
869 }
870 }
871
872 void
873 isp_put_request_t3(ispsoftc_t *isp, ispreqt3_t *src, ispreqt3_t *dst)
874 {
875 int i;
876 isp_put_hdr(isp, &src->req_header, &dst->req_header);
877 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
878 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
879 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
880 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
881 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
882 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
883 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
884 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
885 for (i = 0; i < ASIZE(src->req_cdb); i++) {
886 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
887 }
888 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
889 for (i = 0; i < ISP_RQDSEG_T3; i++) {
890 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
891 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi, &dst->req_dataseg[i].ds_basehi);
892 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
893 }
894 }
895
896 void
897 isp_put_request_t3e(ispsoftc_t *isp, ispreqt3e_t *src, ispreqt3e_t *dst)
898 {
899 int i;
900 isp_put_hdr(isp, &src->req_header, &dst->req_header);
901 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
902 ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
903 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
904 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
905 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
906 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
907 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
908 for (i = 0; i < ASIZE(src->req_cdb); i++) {
909 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
910 }
911 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
912 for (i = 0; i < ISP_RQDSEG_T3; i++) {
913 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
914 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi, &dst->req_dataseg[i].ds_basehi);
915 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
916 }
917 }
918
919 void
920 isp_put_extended_request(ispsoftc_t *isp, ispextreq_t *src, ispextreq_t *dst)
921 {
922 int i;
923 isp_put_hdr(isp, &src->req_header, &dst->req_header);
924 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
925 if (ISP_IS_SBUS(isp)) {
926 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_target);
927 ISP_IOXPUT_8(isp, src->req_target, &dst->req_lun_trn);
928 } else {
929 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
930 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
931 }
932 ISP_IOXPUT_16(isp, src->req_cdblen, &dst->req_cdblen);
933 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
934 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
935 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
936 for (i = 0; i < ASIZE(src->req_cdb); i++) {
937 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
938 }
939 }
940
941 void
942 isp_put_request_t7(ispsoftc_t *isp, ispreqt7_t *src, ispreqt7_t *dst)
943 {
944 int i;
945 uint32_t *a, *b;
946
947 isp_put_hdr(isp, &src->req_header, &dst->req_header);
948 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
949 ISP_IOXPUT_16(isp, src->req_nphdl, &dst->req_nphdl);
950 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
951 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
952 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
953 a = (uint32_t *) src->req_lun;
954 b = (uint32_t *) dst->req_lun;
955 for (i = 0; i < (ASIZE(src->req_lun) >> 2); i++ ) {
956 *b++ = ISP_SWAP32(isp, *a++);
957 }
958 ISP_IOXPUT_8(isp, src->req_alen_datadir, &dst->req_alen_datadir);
959 ISP_IOXPUT_8(isp, src->req_task_management, &dst->req_task_management);
960 ISP_IOXPUT_8(isp, src->req_task_attribute, &dst->req_task_attribute);
961 ISP_IOXPUT_8(isp, src->req_crn, &dst->req_crn);
962 a = (uint32_t *) src->req_cdb;
963 b = (uint32_t *) dst->req_cdb;
964 for (i = 0; i < (ASIZE(src->req_cdb) >> 2); i++) {
965 *b++ = ISP_SWAP32(isp, *a++);
966 }
967 ISP_IOXPUT_32(isp, src->req_dl, &dst->req_dl);
968 ISP_IOXPUT_16(isp, src->req_tidlo, &dst->req_tidlo);
969 ISP_IOXPUT_8(isp, src->req_tidhi, &dst->req_tidhi);
970 ISP_IOXPUT_8(isp, src->req_vpidx, &dst->req_vpidx);
971 ISP_IOXPUT_32(isp, src->req_dataseg.ds_base, &dst->req_dataseg.ds_base);
972 ISP_IOXPUT_32(isp, src->req_dataseg.ds_basehi, &dst->req_dataseg.ds_basehi);
973 ISP_IOXPUT_32(isp, src->req_dataseg.ds_count, &dst->req_dataseg.ds_count);
974 }
975
976 void
977 isp_put_24xx_tmf(ispsoftc_t *isp, isp24xx_tmf_t *src, isp24xx_tmf_t *dst)
978 {
979 int i;
980 uint32_t *a, *b;
981
982 isp_put_hdr(isp, &src->tmf_header, &dst->tmf_header);
983 ISP_IOXPUT_32(isp, src->tmf_handle, &dst->tmf_handle);
984 ISP_IOXPUT_16(isp, src->tmf_nphdl, &dst->tmf_nphdl);
985 ISP_IOXPUT_16(isp, src->tmf_delay, &dst->tmf_delay);
986 ISP_IOXPUT_16(isp, src->tmf_timeout, &dst->tmf_timeout);
987 for (i = 0; i < ASIZE(src->tmf_reserved0); i++) {
988 ISP_IOXPUT_8(isp, src->tmf_reserved0[i], &dst->tmf_reserved0[i]);
989 }
990 a = (uint32_t *) src->tmf_lun;
991 b = (uint32_t *) dst->tmf_lun;
992 for (i = 0; i < (ASIZE(src->tmf_lun) >> 2); i++ ) {
993 *b++ = ISP_SWAP32(isp, *a++);
994 }
995 ISP_IOXPUT_32(isp, src->tmf_flags, &dst->tmf_flags);
996 for (i = 0; i < ASIZE(src->tmf_reserved1); i++) {
997 ISP_IOXPUT_8(isp, src->tmf_reserved1[i], &dst->tmf_reserved1[i]);
998 }
999 ISP_IOXPUT_16(isp, src->tmf_tidlo, &dst->tmf_tidlo);
1000 ISP_IOXPUT_8(isp, src->tmf_tidhi, &dst->tmf_tidhi);
1001 ISP_IOXPUT_8(isp, src->tmf_vpidx, &dst->tmf_vpidx);
1002 for (i = 0; i < ASIZE(src->tmf_reserved2); i++) {
1003 ISP_IOXPUT_8(isp, src->tmf_reserved2[i], &dst->tmf_reserved2[i]);
1004 }
1005 }
1006
1007 void
1008 isp_put_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
1009 {
1010 int i;
1011 isp_put_hdr(isp, &src->abrt_header, &dst->abrt_header);
1012 ISP_IOXPUT_32(isp, src->abrt_handle, &dst->abrt_handle);
1013 ISP_IOXPUT_16(isp, src->abrt_nphdl, &dst->abrt_nphdl);
1014 ISP_IOXPUT_16(isp, src->abrt_options, &dst->abrt_options);
1015 ISP_IOXPUT_32(isp, src->abrt_cmd_handle, &dst->abrt_cmd_handle);
1016 for (i = 0; i < ASIZE(src->abrt_reserved); i++) {
1017 ISP_IOXPUT_8(isp, src->abrt_reserved[i], &dst->abrt_reserved[i]);
1018 }
1019 ISP_IOXPUT_16(isp, src->abrt_tidlo, &dst->abrt_tidlo);
1020 ISP_IOXPUT_8(isp, src->abrt_tidhi, &dst->abrt_tidhi);
1021 ISP_IOXPUT_8(isp, src->abrt_vpidx, &dst->abrt_vpidx);
1022 for (i = 0; i < ASIZE(src->abrt_reserved1); i++) {
1023 ISP_IOXPUT_8(isp, src->abrt_reserved1[i], &dst->abrt_reserved1[i]);
1024 }
1025 }
1026
1027 void
1028 isp_put_cont_req(ispsoftc_t *isp, ispcontreq_t *src, ispcontreq_t *dst)
1029 {
1030 int i;
1031 isp_put_hdr(isp, &src->req_header, &dst->req_header);
1032 for (i = 0; i < ISP_CDSEG; i++) {
1033 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
1034 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
1035 }
1036 }
1037
1038 void
1039 isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *src, ispcontreq64_t *dst)
1040 {
1041 int i;
1042 isp_put_hdr(isp, &src->req_header, &dst->req_header);
1043 for (i = 0; i < ISP_CDSEG64; i++) {
1044 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base, &dst->req_dataseg[i].ds_base);
1045 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi, &dst->req_dataseg[i].ds_basehi);
1046 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count, &dst->req_dataseg[i].ds_count);
1047 }
1048 }
1049
1050 void
1051 isp_get_response(ispsoftc_t *isp, ispstatusreq_t *src, ispstatusreq_t *dst)
1052 {
1053 int i;
1054 isp_get_hdr(isp, &src->req_header, &dst->req_header);
1055 ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
1056 ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
1057 ISP_IOXGET_16(isp, &src->req_completion_status, dst->req_completion_status);
1058 ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
1059 ISP_IOXGET_16(isp, &src->req_status_flags, dst->req_status_flags);
1060 ISP_IOXGET_16(isp, &src->req_time, dst->req_time);
1061 ISP_IOXGET_16(isp, &src->req_sense_len, dst->req_sense_len);
1062 ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
1063 for (i = 0; i < 8; i++) {
1064 ISP_IOXGET_8(isp, &src->req_response[i], dst->req_response[i]);
1065 }
1066 for (i = 0; i < 32; i++) {
1067 ISP_IOXGET_8(isp, &src->req_sense_data[i], dst->req_sense_data[i]);
1068 }
1069 }
1070
1071 void
1072 isp_get_24xx_response(ispsoftc_t *isp, isp24xx_statusreq_t *src, isp24xx_statusreq_t *dst)
1073 {
1074 int i;
1075 uint32_t *s, *d;
1076
1077 isp_get_hdr(isp, &src->req_header, &dst->req_header);
1078 ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
1079 ISP_IOXGET_16(isp, &src->req_completion_status, dst->req_completion_status);
1080 ISP_IOXGET_16(isp, &src->req_oxid, dst->req_oxid);
1081 ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
1082 ISP_IOXGET_16(isp, &src->req_reserved0, dst->req_reserved0);
1083 ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
1084 ISP_IOXGET_16(isp, &src->req_reserved1, dst->req_reserved1);
1085 ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
1086 ISP_IOXGET_32(isp, &src->req_fcp_residual, dst->req_fcp_residual);
1087 ISP_IOXGET_32(isp, &src->req_sense_len, dst->req_sense_len);
1088 ISP_IOXGET_32(isp, &src->req_response_len, dst->req_response_len);
1089 s = (uint32_t *)src->req_rsp_sense;
1090 d = (uint32_t *)dst->req_rsp_sense;
1091 for (i = 0; i < (ASIZE(src->req_rsp_sense) >> 2); i++) {
1092 d[i] = ISP_SWAP32(isp, s[i]);
1093 }
1094 }
1095
1096 void
1097 isp_get_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
1098 {
1099 int i;
1100 isp_get_hdr(isp, &src->abrt_header, &dst->abrt_header);
1101 ISP_IOXGET_32(isp, &src->abrt_handle, dst->abrt_handle);
1102 ISP_IOXGET_16(isp, &src->abrt_nphdl, dst->abrt_nphdl);
1103 ISP_IOXGET_16(isp, &src->abrt_options, dst->abrt_options);
1104 ISP_IOXGET_32(isp, &src->abrt_cmd_handle, dst->abrt_cmd_handle);
1105 for (i = 0; i < ASIZE(src->abrt_reserved); i++) {
1106 ISP_IOXGET_8(isp, &src->abrt_reserved[i], dst->abrt_reserved[i]);
1107 }
1108 ISP_IOXGET_16(isp, &src->abrt_tidlo, dst->abrt_tidlo);
1109 ISP_IOXGET_8(isp, &src->abrt_tidhi, dst->abrt_tidhi);
1110 ISP_IOXGET_8(isp, &src->abrt_vpidx, dst->abrt_vpidx);
1111 for (i = 0; i < ASIZE(src->abrt_reserved1); i++) {
1112 ISP_IOXGET_8(isp, &src->abrt_reserved1[i], dst->abrt_reserved1[i]);
1113 }
1114 }
1115
1116
1117 void
1118 isp_get_rio1(ispsoftc_t *isp, isp_rio1_t *r1src, isp_rio1_t *r1dst)
1119 {
1120 const int lim = sizeof (r1dst->req_handles) / sizeof (r1dst->req_handles[0]);
1121 int i;
1122 isp_get_hdr(isp, &r1src->req_header, &r1dst->req_header);
1123 if (r1dst->req_header.rqs_seqno > lim) {
1124 r1dst->req_header.rqs_seqno = lim;
1125 }
1126 for (i = 0; i < r1dst->req_header.rqs_seqno; i++) {
1127 ISP_IOXGET_32(isp, &r1src->req_handles[i], r1dst->req_handles[i]);
1128 }
1129 while (i < lim) {
1130 r1dst->req_handles[i++] = 0;
1131 }
1132 }
1133
1134 void
1135 isp_get_rio2(ispsoftc_t *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
1136 {
1137 const int lim = sizeof (r2dst->req_handles) / sizeof (r2dst->req_handles[0]);
1138 int i;
1139
1140 isp_get_hdr(isp, &r2src->req_header, &r2dst->req_header);
1141 if (r2dst->req_header.rqs_seqno > lim) {
1142 r2dst->req_header.rqs_seqno = lim;
1143 }
1144 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
1145 ISP_IOXGET_16(isp, &r2src->req_handles[i], r2dst->req_handles[i]);
1146 }
1147 while (i < lim) {
1148 r2dst->req_handles[i++] = 0;
1149 }
1150 }
1151
1152 void
1153 isp_put_icb(ispsoftc_t *isp, isp_icb_t *src, isp_icb_t *dst)
1154 {
1155 int i;
1156 if (ISP_IS_SBUS(isp)) {
1157 ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_reserved0);
1158 ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_version);
1159 } else {
1160 ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_version);
1161 ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_reserved0);
1162 }
1163 ISP_IOXPUT_16(isp, src->icb_fwoptions, &dst->icb_fwoptions);
1164 ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
1165 ISP_IOXPUT_16(isp, src->icb_maxalloc, &dst->icb_maxalloc);
1166 ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
1167 if (ISP_IS_SBUS(isp)) {
1168 ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_delay);
1169 ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_count);
1170 } else {
1171 ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_count);
1172 ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_delay);
1173 }
1174 for (i = 0; i < 8; i++) {
1175 ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
1176 }
1177 ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
1178 if (ISP_IS_SBUS(isp)) {
1179 ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_logintime);
1180 ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_iqdevtype);
1181 } else {
1182 ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_iqdevtype);
1183 ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_logintime);
1184 }
1185 for (i = 0; i < 8; i++) {
1186 ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
1187 }
1188 ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
1189 ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
1190 ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
1191 ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
1192 for (i = 0; i < 4; i++) {
1193 ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
1194 }
1195 for (i = 0; i < 4; i++) {
1196 ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
1197 }
1198 ISP_IOXPUT_16(isp, src->icb_lunenables, &dst->icb_lunenables);
1199 if (ISP_IS_SBUS(isp)) {
1200 ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_icnt);
1201 ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_ccnt);
1202 } else {
1203 ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_ccnt);
1204 ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_icnt);
1205 }
1206 ISP_IOXPUT_16(isp, src->icb_lunetimeout, &dst->icb_lunetimeout);
1207 ISP_IOXPUT_16(isp, src->icb_reserved1, &dst->icb_reserved1);
1208 ISP_IOXPUT_16(isp, src->icb_xfwoptions, &dst->icb_xfwoptions);
1209 if (ISP_IS_SBUS(isp)) {
1210 ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_idelaytimer);
1211 ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_racctimer);
1212 } else {
1213 ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_racctimer);
1214 ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
1215 }
1216 ISP_IOXPUT_16(isp, src->icb_zfwoptions, &dst->icb_zfwoptions);
1217 }
1218
1219 void
1220 isp_put_icb_2400(ispsoftc_t *isp, isp_icb_2400_t *src, isp_icb_2400_t *dst)
1221 {
1222 int i;
1223 ISP_IOXPUT_16(isp, src->icb_version, &dst->icb_version);
1224 ISP_IOXPUT_16(isp, src->icb_reserved0, &dst->icb_reserved0);
1225 ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
1226 ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
1227 ISP_IOXPUT_16(isp, src->icb_xchgcnt, &dst->icb_xchgcnt);
1228 ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
1229 for (i = 0; i < 8; i++) {
1230 ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
1231 }
1232 for (i = 0; i < 8; i++) {
1233 ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
1234 }
1235 ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
1236 ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
1237 ISP_IOXPUT_16(isp, src->icb_retry_count, &dst->icb_retry_count);
1238 ISP_IOXPUT_16(isp, src->icb_priout, &dst->icb_priout);
1239 ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
1240 ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
1241 ISP_IOXPUT_16(isp, src->icb_ldn_nols, &dst->icb_ldn_nols);
1242 ISP_IOXPUT_16(isp, src->icb_prqstqlen, &dst->icb_prqstqlen);
1243 for (i = 0; i < 4; i++) {
1244 ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
1245 }
1246 for (i = 0; i < 4; i++) {
1247 ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
1248 }
1249 for (i = 0; i < 4; i++) {
1250 ISP_IOXPUT_16(isp, src->icb_priaddr[i], &dst->icb_priaddr[i]);
1251 }
1252 for (i = 0; i < 4; i++) {
1253 ISP_IOXPUT_16(isp, src->icb_reserved1[i], &dst->icb_reserved1[i]);
1254 }
1255 ISP_IOXPUT_16(isp, src->icb_atio_in, &dst->icb_atio_in);
1256 ISP_IOXPUT_16(isp, src->icb_atioqlen, &dst->icb_atioqlen);
1257 for (i = 0; i < 4; i++) {
1258 ISP_IOXPUT_16(isp, src->icb_atioqaddr[i], &dst->icb_atioqaddr[i]);
1259 }
1260 ISP_IOXPUT_16(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
1261 ISP_IOXPUT_16(isp, src->icb_logintime, &dst->icb_logintime);
1262 ISP_IOXPUT_32(isp, src->icb_fwoptions1, &dst->icb_fwoptions1);
1263 ISP_IOXPUT_32(isp, src->icb_fwoptions2, &dst->icb_fwoptions2);
1264 ISP_IOXPUT_32(isp, src->icb_fwoptions3, &dst->icb_fwoptions3);
1265 for (i = 0; i < 12; i++) {
1266 ISP_IOXPUT_16(isp, src->icb_reserved2[i], &dst->icb_reserved2[i]);
1267 }
1268 }
1269
1270 void
1271 isp_put_icb_2400_vpinfo(ispsoftc_t *isp, isp_icb_2400_vpinfo_t *src, isp_icb_2400_vpinfo_t *dst)
1272 {
1273 ISP_IOXPUT_16(isp, src->vp_count, &dst->vp_count);
1274 ISP_IOXPUT_16(isp, src->vp_global_options, &dst->vp_global_options);
1275 }
1276
1277 void
1278 isp_put_vp_port_info(ispsoftc_t *isp, vp_port_info_t *src, vp_port_info_t *dst)
1279 {
1280 int i;
1281 ISP_IOXPUT_16(isp, src->vp_port_status, &dst->vp_port_status);
1282 ISP_IOXPUT_8(isp, src->vp_port_options, &dst->vp_port_options);
1283 ISP_IOXPUT_8(isp, src->vp_port_loopid, &dst->vp_port_loopid);
1284 for (i = 0; i < 8; i++) {
1285 ISP_IOXPUT_8(isp, src->vp_port_portname[i], &dst->vp_port_portname[i]);
1286 }
1287 for (i = 0; i < 8; i++) {
1288 ISP_IOXPUT_8(isp, src->vp_port_nodename[i], &dst->vp_port_nodename[i]);
1289 }
1290 /* we never *put* portid_lo/portid_hi */
1291 }
1292
1293 void
1294 isp_get_vp_port_info(ispsoftc_t *isp, vp_port_info_t *src, vp_port_info_t *dst)
1295 {
1296 int i;
1297 ISP_IOXGET_16(isp, &src->vp_port_status, dst->vp_port_status);
1298 ISP_IOXGET_8(isp, &src->vp_port_options, dst->vp_port_options);
1299 ISP_IOXGET_8(isp, &src->vp_port_loopid, dst->vp_port_loopid);
1300 for (i = 0; i < ASIZE(src->vp_port_portname); i++) {
1301 ISP_IOXGET_8(isp, &src->vp_port_portname[i], dst->vp_port_portname[i]);
1302 }
1303 for (i = 0; i < ASIZE(src->vp_port_nodename); i++) {
1304 ISP_IOXGET_8(isp, &src->vp_port_nodename[i], dst->vp_port_nodename[i]);
1305 }
1306 ISP_IOXGET_16(isp, &src->vp_port_portid_lo, dst->vp_port_portid_lo);
1307 ISP_IOXGET_16(isp, &src->vp_port_portid_hi, dst->vp_port_portid_hi);
1308 }
1309
1310 void
1311 isp_put_vp_ctrl_info(ispsoftc_t *isp, vp_ctrl_info_t *src, vp_ctrl_info_t *dst)
1312 {
1313 int i;
1314 isp_put_hdr(isp, &src->vp_ctrl_hdr, &dst->vp_ctrl_hdr);
1315 ISP_IOXPUT_32(isp, src->vp_ctrl_handle, &dst->vp_ctrl_handle);
1316 ISP_IOXPUT_16(isp, src->vp_ctrl_index_fail, &dst->vp_ctrl_index_fail);
1317 ISP_IOXPUT_16(isp, src->vp_ctrl_status, &dst->vp_ctrl_status);
1318 ISP_IOXPUT_16(isp, src->vp_ctrl_command, &dst->vp_ctrl_command);
1319 ISP_IOXPUT_16(isp, src->vp_ctrl_vp_count, &dst->vp_ctrl_vp_count);
1320 for (i = 0; i < ASIZE(src->vp_ctrl_idmap); i++) {
1321 ISP_IOXPUT_16(isp, src->vp_ctrl_idmap[i], &dst->vp_ctrl_idmap[i]);
1322 }
1323 for (i = 0; i < ASIZE(src->vp_ctrl_reserved); i++) {
1324 ISP_IOXPUT_8(isp, src->vp_ctrl_reserved[i], &dst->vp_ctrl_reserved[i]);
1325 }
1326 }
1327
1328 void
1329 isp_get_vp_ctrl_info(ispsoftc_t *isp, vp_ctrl_info_t *src, vp_ctrl_info_t *dst)
1330 {
1331 int i;
1332 isp_get_hdr(isp, &src->vp_ctrl_hdr, &dst->vp_ctrl_hdr);
1333 ISP_IOXGET_32(isp, &src->vp_ctrl_handle, dst->vp_ctrl_handle);
1334 ISP_IOXGET_16(isp, &src->vp_ctrl_index_fail, dst->vp_ctrl_index_fail);
1335 ISP_IOXGET_16(isp, &src->vp_ctrl_status, dst->vp_ctrl_status);
1336 ISP_IOXGET_16(isp, &src->vp_ctrl_command, dst->vp_ctrl_command);
1337 ISP_IOXGET_16(isp, &src->vp_ctrl_vp_count, dst->vp_ctrl_vp_count);
1338 for (i = 0; i < ASIZE(src->vp_ctrl_idmap); i++) {
1339 ISP_IOXGET_16(isp, &src->vp_ctrl_idmap[i], dst->vp_ctrl_idmap[i]);
1340 }
1341 for (i = 0; i < ASIZE(src->vp_ctrl_reserved); i++) {
1342 ISP_IOXGET_8(isp, &src->vp_ctrl_reserved[i], dst->vp_ctrl_reserved[i]);
1343 }
1344 }
1345
1346 void
1347 isp_put_vp_modify(ispsoftc_t *isp, vp_modify_t *src, vp_modify_t *dst)
1348 {
1349 int i, j;
1350 isp_put_hdr(isp, &src->vp_mod_hdr, &dst->vp_mod_hdr);
1351 ISP_IOXPUT_32(isp, src->vp_mod_hdl, &dst->vp_mod_hdl);
1352 ISP_IOXPUT_16(isp, src->vp_mod_reserved0, &dst->vp_mod_reserved0);
1353 ISP_IOXPUT_16(isp, src->vp_mod_status, &dst->vp_mod_status);
1354 ISP_IOXPUT_8(isp, src->vp_mod_cmd, &dst->vp_mod_cmd);
1355 ISP_IOXPUT_8(isp, src->vp_mod_cnt, &dst->vp_mod_cnt);
1356 ISP_IOXPUT_8(isp, src->vp_mod_idx0, &dst->vp_mod_idx0);
1357 ISP_IOXPUT_8(isp, src->vp_mod_idx1, &dst->vp_mod_idx1);
1358 for (i = 0; i < ASIZE(src->vp_mod_ports); i++) {
1359 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].options, &dst->vp_mod_ports[i].options);
1360 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].loopid, &dst->vp_mod_ports[i].loopid);
1361 ISP_IOXPUT_16(isp, src->vp_mod_ports[i].reserved1, &dst->vp_mod_ports[i].reserved1);
1362 for (j = 0; j < ASIZE(src->vp_mod_ports[i].wwpn); j++) {
1363 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].wwpn[j], &dst->vp_mod_ports[i].wwpn[j]);
1364 }
1365 for (j = 0; j < ASIZE(src->vp_mod_ports[i].wwnn); j++) {
1366 ISP_IOXPUT_8(isp, src->vp_mod_ports[i].wwnn[j], &dst->vp_mod_ports[i].wwnn[j]);
1367 }
1368 }
1369 for (i = 0; i < ASIZE(src->vp_mod_reserved2); i++) {
1370 ISP_IOXPUT_8(isp, src->vp_mod_reserved2[i], &dst->vp_mod_reserved2[i]);
1371 }
1372 }
1373
1374 void
1375 isp_get_vp_modify(ispsoftc_t *isp, vp_modify_t *src, vp_modify_t *dst)
1376 {
1377 int i, j;
1378 isp_get_hdr(isp, &src->vp_mod_hdr, &dst->vp_mod_hdr);
1379 ISP_IOXGET_32(isp, &src->vp_mod_hdl, dst->vp_mod_hdl);
1380 ISP_IOXGET_16(isp, &src->vp_mod_reserved0, dst->vp_mod_reserved0);
1381 ISP_IOXGET_16(isp, &src->vp_mod_status, dst->vp_mod_status);
1382 ISP_IOXGET_8(isp, &src->vp_mod_cmd, dst->vp_mod_cmd);
1383 ISP_IOXGET_8(isp, &src->vp_mod_cnt, dst->vp_mod_cnt);
1384 ISP_IOXGET_8(isp, &src->vp_mod_idx0, dst->vp_mod_idx0);
1385 ISP_IOXGET_8(isp, &src->vp_mod_idx1, dst->vp_mod_idx1);
1386 for (i = 0; i < ASIZE(src->vp_mod_ports); i++) {
1387 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].options, dst->vp_mod_ports[i].options);
1388 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].loopid, dst->vp_mod_ports[i].loopid);
1389 ISP_IOXGET_16(isp, &src->vp_mod_ports[i].reserved1, dst->vp_mod_ports[i].reserved1);
1390 for (j = 0; j < ASIZE(src->vp_mod_ports[i].wwpn); j++) {
1391 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].wwpn[j], dst->vp_mod_ports[i].wwpn[j]);
1392 }
1393 for (j = 0; j < ASIZE(src->vp_mod_ports[i].wwnn); j++) {
1394 ISP_IOXGET_8(isp, &src->vp_mod_ports[i].wwnn[j], dst->vp_mod_ports[i].wwnn[j]);
1395 }
1396 }
1397 for (i = 0; i < ASIZE(src->vp_mod_reserved2); i++) {
1398 ISP_IOXGET_8(isp, &src->vp_mod_reserved2[i], dst->vp_mod_reserved2[i]);
1399 }
1400 }
1401
1402 void
1403 isp_get_pdb_21xx(ispsoftc_t *isp, isp_pdb_21xx_t *src, isp_pdb_21xx_t *dst)
1404 {
1405 int i;
1406 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
1407 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
1408 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
1409 for (i = 0; i < 4; i++) {
1410 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i], dst->pdb_hardaddr_bits[i]);
1411 }
1412 for (i = 0; i < 4; i++) {
1413 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i], dst->pdb_portid_bits[i]);
1414 }
1415 for (i = 0; i < 8; i++) {
1416 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
1417 }
1418 for (i = 0; i < 8; i++) {
1419 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
1420 }
1421 ISP_IOXGET_16(isp, &src->pdb_execthrottle, dst->pdb_execthrottle);
1422 ISP_IOXGET_16(isp, &src->pdb_exec_count, dst->pdb_exec_count);
1423 ISP_IOXGET_8(isp, &src->pdb_retry_count, dst->pdb_retry_count);
1424 ISP_IOXGET_8(isp, &src->pdb_retry_delay, dst->pdb_retry_delay);
1425 ISP_IOXGET_16(isp, &src->pdb_resalloc, dst->pdb_resalloc);
1426 ISP_IOXGET_16(isp, &src->pdb_curalloc, dst->pdb_curalloc);
1427 ISP_IOXGET_16(isp, &src->pdb_qhead, dst->pdb_qhead);
1428 ISP_IOXGET_16(isp, &src->pdb_qtail, dst->pdb_qtail);
1429 ISP_IOXGET_16(isp, &src->pdb_tl_next, dst->pdb_tl_next);
1430 ISP_IOXGET_16(isp, &src->pdb_tl_last, dst->pdb_tl_last);
1431 ISP_IOXGET_16(isp, &src->pdb_features, dst->pdb_features);
1432 ISP_IOXGET_16(isp, &src->pdb_pconcurrnt, dst->pdb_pconcurrnt);
1433 ISP_IOXGET_16(isp, &src->pdb_roi, dst->pdb_roi);
1434 ISP_IOXGET_8(isp, &src->pdb_target, dst->pdb_target);
1435 ISP_IOXGET_8(isp, &src->pdb_initiator, dst->pdb_initiator);
1436 ISP_IOXGET_16(isp, &src->pdb_rdsiz, dst->pdb_rdsiz);
1437 ISP_IOXGET_16(isp, &src->pdb_ncseq, dst->pdb_ncseq);
1438 ISP_IOXGET_16(isp, &src->pdb_noseq, dst->pdb_noseq);
1439 ISP_IOXGET_16(isp, &src->pdb_labrtflg, dst->pdb_labrtflg);
1440 ISP_IOXGET_16(isp, &src->pdb_lstopflg, dst->pdb_lstopflg);
1441 ISP_IOXGET_16(isp, &src->pdb_sqhead, dst->pdb_sqhead);
1442 ISP_IOXGET_16(isp, &src->pdb_sqtail, dst->pdb_sqtail);
1443 ISP_IOXGET_16(isp, &src->pdb_ptimer, dst->pdb_ptimer);
1444 ISP_IOXGET_16(isp, &src->pdb_nxt_seqid, dst->pdb_nxt_seqid);
1445 ISP_IOXGET_16(isp, &src->pdb_fcount, dst->pdb_fcount);
1446 ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len);
1447 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
1448 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
1449 ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid);
1450 ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr);
1451 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
1452 }
1453
1454 void
1455 isp_get_pdb_24xx(ispsoftc_t *isp, isp_pdb_24xx_t *src, isp_pdb_24xx_t *dst)
1456 {
1457 int i;
1458 ISP_IOXGET_16(isp, &src->pdb_flags, dst->pdb_flags);
1459 ISP_IOXGET_8(isp, &src->pdb_curstate, dst->pdb_curstate);
1460 ISP_IOXGET_8(isp, &src->pdb_laststate, dst->pdb_laststate);
1461 for (i = 0; i < 4; i++) {
1462 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i], dst->pdb_hardaddr_bits[i]);
1463 }
1464 for (i = 0; i < 4; i++) {
1465 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i], dst->pdb_portid_bits[i]);
1466 }
1467 ISP_IOXGET_16(isp, &src->pdb_retry_timer, dst->pdb_retry_timer);
1468 ISP_IOXGET_16(isp, &src->pdb_handle, dst->pdb_handle);
1469 ISP_IOXGET_16(isp, &src->pdb_rcv_dsize, dst->pdb_rcv_dsize);
1470 ISP_IOXGET_16(isp, &src->pdb_reserved0, dst->pdb_reserved0);
1471 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
1472 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
1473 for (i = 0; i < 8; i++) {
1474 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
1475 }
1476 for (i = 0; i < 8; i++) {
1477 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
1478 }
1479 for (i = 0; i < 24; i++) {
1480 ISP_IOXGET_8(isp, &src->pdb_reserved1[i], dst->pdb_reserved1[i]);
1481 }
1482 }
1483
1484 /*
1485 * PLOGI/LOGO IOCB canonicalization
1486 */
1487
1488 void
1489 isp_get_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
1490 {
1491 int i;
1492 isp_get_hdr(isp, &src->plogx_header, &dst->plogx_header);
1493 ISP_IOXGET_32(isp, &src->plogx_handle, dst->plogx_handle);
1494 ISP_IOXGET_16(isp, &src->plogx_status, dst->plogx_status);
1495 ISP_IOXGET_16(isp, &src->plogx_nphdl, dst->plogx_nphdl);
1496 ISP_IOXGET_16(isp, &src->plogx_flags, dst->plogx_flags);
1497 ISP_IOXGET_16(isp, &src->plogx_vphdl, dst->plogx_vphdl);
1498 ISP_IOXGET_16(isp, &src->plogx_portlo, dst->plogx_portlo);
1499 ISP_IOXGET_16(isp, &src->plogx_rspsz_porthi, dst->plogx_rspsz_porthi);
1500 for (i = 0; i < 11; i++) {
1501 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].lo16, dst->plogx_ioparm[i].lo16);
1502 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].hi16, dst->plogx_ioparm[i].hi16);
1503 }
1504 }
1505
1506 void
1507 isp_put_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
1508 {
1509 int i;
1510 isp_put_hdr(isp, &src->plogx_header, &dst->plogx_header);
1511 ISP_IOXPUT_32(isp, src->plogx_handle, &dst->plogx_handle);
1512 ISP_IOXPUT_16(isp, src->plogx_status, &dst->plogx_status);
1513 ISP_IOXPUT_16(isp, src->plogx_nphdl, &dst->plogx_nphdl);
1514 ISP_IOXPUT_16(isp, src->plogx_flags, &dst->plogx_flags);
1515 ISP_IOXPUT_16(isp, src->plogx_vphdl, &dst->plogx_vphdl);
1516 ISP_IOXPUT_16(isp, src->plogx_portlo, &dst->plogx_portlo);
1517 ISP_IOXPUT_16(isp, src->plogx_rspsz_porthi, &dst->plogx_rspsz_porthi);
1518 for (i = 0; i < 11; i++) {
1519 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].lo16, &dst->plogx_ioparm[i].lo16);
1520 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].hi16, &dst->plogx_ioparm[i].hi16);
1521 }
1522 }
1523
1524 /*
1525 * Report ID canonicalization
1526 */
1527 void
1528 isp_get_ridacq(ispsoftc_t *isp, isp_ridacq_t *src, isp_ridacq_t *dst)
1529 {
1530 int i;
1531 isp_get_hdr(isp, &src->ridacq_hdr, &dst->ridacq_hdr);
1532 ISP_IOXGET_32(isp, &src->ridacq_handle, dst->ridacq_handle);
1533 ISP_IOXGET_16(isp, &src->ridacq_vp_port_lo, dst->ridacq_vp_port_lo);
1534 ISP_IOXGET_8(isp, &src->ridacq_vp_port_hi, dst->ridacq_vp_port_hi);
1535 ISP_IOXGET_8(isp, &src->ridacq_format, dst->ridacq_format);
1536 for (i = 0; i < sizeof (src->ridacq_map) / sizeof (src->ridacq_map[0]); i++) {
1537 ISP_IOXGET_16(isp, &src->ridacq_map[i], dst->ridacq_map[i]);
1538 }
1539 for (i = 0; i < sizeof (src->ridacq_reserved1) / sizeof (src->ridacq_reserved1[0]); i++) {
1540 ISP_IOXGET_16(isp, &src->ridacq_reserved1[i], dst->ridacq_reserved1[i]);
1541 }
1542 if (dst->ridacq_format == 0) {
1543 ISP_IOXGET_8(isp, &src->un.type0.ridacq_vp_acquired, dst->un.type0.ridacq_vp_acquired);
1544 ISP_IOXGET_8(isp, &src->un.type0.ridacq_vp_setup, dst->un.type0.ridacq_vp_setup);
1545 ISP_IOXGET_16(isp, &src->un.type0.ridacq_reserved0, dst->un.type0.ridacq_reserved0);
1546 } else if (dst->ridacq_format == 1) {
1547 ISP_IOXGET_16(isp, &src->un.type1.ridacq_vp_count, dst->un.type1.ridacq_vp_count);
1548 ISP_IOXGET_8(isp, &src->un.type1.ridacq_vp_index, dst->un.type1.ridacq_vp_index);
1549 ISP_IOXGET_8(isp, &src->un.type1.ridacq_vp_status, dst->un.type1.ridacq_vp_status);
1550 } else {
1551 ISP_MEMZERO(&dst->un, sizeof (dst->un));
1552 }
1553 }
1554
1555
1556 /*
1557 * CT Passthru canonicalization
1558 */
1559 void
1560 isp_get_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
1561 {
1562 int i;
1563
1564 isp_get_hdr(isp, &src->ctp_header, &dst->ctp_header);
1565 ISP_IOXGET_32(isp, &src->ctp_handle, dst->ctp_handle);
1566 ISP_IOXGET_16(isp, &src->ctp_status, dst->ctp_status);
1567 ISP_IOXGET_16(isp, &src->ctp_nphdl, dst->ctp_nphdl);
1568 ISP_IOXGET_16(isp, &src->ctp_cmd_cnt, dst->ctp_cmd_cnt);
1569 ISP_IOXGET_8(isp, &src->ctp_vpidx, dst->ctp_vpidx);
1570 ISP_IOXGET_8(isp, &src->ctp_reserved0, dst->ctp_reserved0);
1571 ISP_IOXGET_16(isp, &src->ctp_time, dst->ctp_time);
1572 ISP_IOXGET_16(isp, &src->ctp_reserved1, dst->ctp_reserved1);
1573 ISP_IOXGET_16(isp, &src->ctp_rsp_cnt, dst->ctp_rsp_cnt);
1574 for (i = 0; i < 5; i++) {
1575 ISP_IOXGET_16(isp, &src->ctp_reserved2[i], dst->ctp_reserved2[i]);
1576 }
1577 ISP_IOXGET_32(isp, &src->ctp_rsp_bcnt, dst->ctp_rsp_bcnt);
1578 ISP_IOXGET_32(isp, &src->ctp_cmd_bcnt, dst->ctp_cmd_bcnt);
1579 for (i = 0; i < 2; i++) {
1580 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_base, dst->ctp_dataseg[i].ds_base);
1581 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_basehi, dst->ctp_dataseg[i].ds_basehi);
1582 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_count, dst->ctp_dataseg[i].ds_count);
1583 }
1584 }
1585
1586 void
1587 isp_get_ms(ispsoftc_t *isp, isp_ms_t *src, isp_ms_t *dst)
1588 {
1589 int i;
1590
1591 isp_get_hdr(isp, &src->ms_header, &dst->ms_header);
1592 ISP_IOXGET_32(isp, &src->ms_handle, dst->ms_handle);
1593 ISP_IOXGET_16(isp, &src->ms_nphdl, dst->ms_nphdl);
1594 ISP_IOXGET_16(isp, &src->ms_status, dst->ms_status);
1595 ISP_IOXGET_16(isp, &src->ms_flags, dst->ms_flags);
1596 ISP_IOXGET_16(isp, &src->ms_reserved1, dst->ms_reserved1);
1597 ISP_IOXGET_16(isp, &src->ms_time, dst->ms_time);
1598 ISP_IOXGET_16(isp, &src->ms_cmd_cnt, dst->ms_cmd_cnt);
1599 ISP_IOXGET_16(isp, &src->ms_tot_cnt, dst->ms_tot_cnt);
1600 ISP_IOXGET_8(isp, &src->ms_type, dst->ms_type);
1601 ISP_IOXGET_8(isp, &src->ms_r_ctl, dst->ms_r_ctl);
1602 ISP_IOXGET_16(isp, &src->ms_rxid, dst->ms_rxid);
1603 ISP_IOXGET_16(isp, &src->ms_reserved2, dst->ms_reserved2);
1604 ISP_IOXGET_32(isp, &src->ms_rsp_bcnt, dst->ms_rsp_bcnt);
1605 ISP_IOXGET_32(isp, &src->ms_cmd_bcnt, dst->ms_cmd_bcnt);
1606 for (i = 0; i < 2; i++) {
1607 ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_base, dst->ms_dataseg[i].ds_base);
1608 ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_basehi, dst->ms_dataseg[i].ds_basehi);
1609 ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_count, dst->ms_dataseg[i].ds_count);
1610 }
1611 }
1612
1613 void
1614 isp_put_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
1615 {
1616 int i;
1617
1618 isp_put_hdr(isp, &src->ctp_header, &dst->ctp_header);
1619 ISP_IOXPUT_32(isp, src->ctp_handle, &dst->ctp_handle);
1620 ISP_IOXPUT_16(isp, src->ctp_status, &dst->ctp_status);
1621 ISP_IOXPUT_16(isp, src->ctp_nphdl, &dst->ctp_nphdl);
1622 ISP_IOXPUT_16(isp, src->ctp_cmd_cnt, &dst->ctp_cmd_cnt);
1623 ISP_IOXPUT_8(isp, src->ctp_vpidx, &dst->ctp_vpidx);
1624 ISP_IOXPUT_8(isp, src->ctp_reserved0, &dst->ctp_reserved0);
1625 ISP_IOXPUT_16(isp, src->ctp_time, &dst->ctp_time);
1626 ISP_IOXPUT_16(isp, src->ctp_reserved1, &dst->ctp_reserved1);
1627 ISP_IOXPUT_16(isp, src->ctp_rsp_cnt, &dst->ctp_rsp_cnt);
1628 for (i = 0; i < 5; i++) {
1629 ISP_IOXPUT_16(isp, src->ctp_reserved2[i], &dst->ctp_reserved2[i]);
1630 }
1631 ISP_IOXPUT_32(isp, src->ctp_rsp_bcnt, &dst->ctp_rsp_bcnt);
1632 ISP_IOXPUT_32(isp, src->ctp_cmd_bcnt, &dst->ctp_cmd_bcnt);
1633 for (i = 0; i < 2; i++) {
1634 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_base, &dst->ctp_dataseg[i].ds_base);
1635 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_basehi, &dst->ctp_dataseg[i].ds_basehi);
1636 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_count, &dst->ctp_dataseg[i].ds_count);
1637 }
1638 }
1639
1640 void
1641 isp_put_ms(ispsoftc_t *isp, isp_ms_t *src, isp_ms_t *dst)
1642 {
1643 int i;
1644
1645 isp_put_hdr(isp, &src->ms_header, &dst->ms_header);
1646 ISP_IOXPUT_32(isp, src->ms_handle, &dst->ms_handle);
1647 ISP_IOXPUT_16(isp, src->ms_nphdl, &dst->ms_nphdl);
1648 ISP_IOXPUT_16(isp, src->ms_status, &dst->ms_status);
1649 ISP_IOXPUT_16(isp, src->ms_flags, &dst->ms_flags);
1650 ISP_IOXPUT_16(isp, src->ms_reserved1, &dst->ms_reserved1);
1651 ISP_IOXPUT_16(isp, src->ms_time, &dst->ms_time);
1652 ISP_IOXPUT_16(isp, src->ms_cmd_cnt, &dst->ms_cmd_cnt);
1653 ISP_IOXPUT_16(isp, src->ms_tot_cnt, &dst->ms_tot_cnt);
1654 ISP_IOXPUT_8(isp, src->ms_type, &dst->ms_type);
1655 ISP_IOXPUT_8(isp, src->ms_r_ctl, &dst->ms_r_ctl);
1656 ISP_IOXPUT_16(isp, src->ms_rxid, &dst->ms_rxid);
1657 ISP_IOXPUT_16(isp, src->ms_reserved2, &dst->ms_reserved2);
1658 ISP_IOXPUT_32(isp, src->ms_rsp_bcnt, &dst->ms_rsp_bcnt);
1659 ISP_IOXPUT_32(isp, src->ms_cmd_bcnt, &dst->ms_cmd_bcnt);
1660 for (i = 0; i < 2; i++) {
1661 ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_base, &dst->ms_dataseg[i].ds_base);
1662 ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_basehi, &dst->ms_dataseg[i].ds_basehi);
1663 ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_count, &dst->ms_dataseg[i].ds_count);
1664 }
1665 }
1666
1667 /*
1668 * Generic SNS request - not particularly useful since the per-command data
1669 * isn't always 16 bit words.
1670 */
1671 void
1672 isp_put_sns_request(ispsoftc_t *isp, sns_screq_t *src, sns_screq_t *dst)
1673 {
1674 int i, nw = (int) src->snscb_sblen;
1675 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1676 for (i = 0; i < 4; i++) {
1677 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
1678 }
1679 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1680 for (i = 0; i < nw; i++) {
1681 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
1682 }
1683 }
1684
1685 void
1686 isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src, sns_gid_ft_req_t *dst)
1687 {
1688 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1689 ISP_IOXPUT_16(isp, src->snscb_reserved0, &dst->snscb_reserved0);
1690 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
1691 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
1692 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
1693 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
1694 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1695 ISP_IOXPUT_16(isp, src->snscb_reserved1, &dst->snscb_reserved1);
1696 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
1697 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
1698 ISP_IOXPUT_32(isp, src->snscb_reserved3, &dst->snscb_reserved3);
1699 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
1700 }
1701
1702 void
1703 isp_put_gxn_id_request(ispsoftc_t *isp, sns_gxn_id_req_t *src, sns_gxn_id_req_t *dst)
1704 {
1705 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1706 ISP_IOXPUT_16(isp, src->snscb_reserved0, &dst->snscb_reserved0);
1707 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
1708 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
1709 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
1710 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
1711 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1712 ISP_IOXPUT_16(isp, src->snscb_reserved1, &dst->snscb_reserved1);
1713 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
1714 ISP_IOXPUT_16(isp, src->snscb_reserved2, &dst->snscb_reserved2);
1715 ISP_IOXPUT_32(isp, src->snscb_reserved3, &dst->snscb_reserved3);
1716 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
1717 }
1718
1719 /*
1720 * Generic SNS response - not particularly useful since the per-command data
1721 * isn't always 16 bit words.
1722 */
1723 void
1724 isp_get_sns_response(ispsoftc_t *isp, sns_scrsp_t *src, sns_scrsp_t *dst, int nwords)
1725 {
1726 int i;
1727 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1728 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
1729 for (i = 0; i < 3; i++) {
1730 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
1731 dst->snscb_port_id[i]);
1732 }
1733 for (i = 0; i < 8; i++) {
1734 ISP_IOXGET_8(isp, &src->snscb_portname[i],
1735 dst->snscb_portname[i]);
1736 }
1737 for (i = 0; i < nwords; i++) {
1738 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]);
1739 }
1740 }
1741
1742 void
1743 isp_get_gid_ft_response(ispsoftc_t *isp, sns_gid_ft_rsp_t *src, sns_gid_ft_rsp_t *dst, int nwords)
1744 {
1745 int i;
1746 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1747 for (i = 0; i < nwords; i++) {
1748 int j;
1749 ISP_IOXGET_8(isp, &src->snscb_ports[i].control, dst->snscb_ports[i].control);
1750 for (j = 0; j < 3; j++) {
1751 ISP_IOXGET_8(isp, &src->snscb_ports[i].portid[j], dst->snscb_ports[i].portid[j]);
1752 }
1753 if (dst->snscb_ports[i].control & 0x80) {
1754 break;
1755 }
1756 }
1757 }
1758
1759 void
1760 isp_get_gxn_id_response(ispsoftc_t *isp, sns_gxn_id_rsp_t *src, sns_gxn_id_rsp_t *dst)
1761 {
1762 int i;
1763 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1764 for (i = 0; i < 8; i++) {
1765 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
1766 }
1767 }
1768
1769 void
1770 isp_get_gff_id_response(ispsoftc_t *isp, sns_gff_id_rsp_t *src, sns_gff_id_rsp_t *dst)
1771 {
1772 int i;
1773 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1774 for (i = 0; i < 32; i++) {
1775 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i], dst->snscb_fc4_features[i]);
1776 }
1777 }
1778
1779 void
1780 isp_get_ga_nxt_response(ispsoftc_t *isp, sns_ga_nxt_rsp_t *src, sns_ga_nxt_rsp_t *dst)
1781 {
1782 int i;
1783 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
1784 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
1785 for (i = 0; i < 3; i++) {
1786 ISP_IOXGET_8(isp, &src->snscb_port_id[i], dst->snscb_port_id[i]);
1787 }
1788 for (i = 0; i < 8; i++) {
1789 ISP_IOXGET_8(isp, &src->snscb_portname[i], dst->snscb_portname[i]);
1790 }
1791 ISP_IOXGET_8(isp, &src->snscb_pnlen, dst->snscb_pnlen);
1792 for (i = 0; i < 255; i++) {
1793 ISP_IOXGET_8(isp, &src->snscb_pname[i], dst->snscb_pname[i]);
1794 }
1795 for (i = 0; i < 8; i++) {
1796 ISP_IOXGET_8(isp, &src->snscb_nodename[i], dst->snscb_nodename[i]);
1797 }
1798 ISP_IOXGET_8(isp, &src->snscb_nnlen, dst->snscb_nnlen);
1799 for (i = 0; i < 255; i++) {
1800 ISP_IOXGET_8(isp, &src->snscb_nname[i], dst->snscb_nname[i]);
1801 }
1802 for (i = 0; i < 8; i++) {
1803 ISP_IOXGET_8(isp, &src->snscb_ipassoc[i], dst->snscb_ipassoc[i]);
1804 }
1805 for (i = 0; i < 16; i++) {
1806 ISP_IOXGET_8(isp, &src->snscb_ipaddr[i], dst->snscb_ipaddr[i]);
1807 }
1808 for (i = 0; i < 4; i++) {
1809 ISP_IOXGET_8(isp, &src->snscb_svc_class[i], dst->snscb_svc_class[i]);
1810 }
1811 for (i = 0; i < 32; i++) {
1812 ISP_IOXGET_8(isp, &src->snscb_fc4_types[i], dst->snscb_fc4_types[i]);
1813 }
1814 for (i = 0; i < 8; i++) {
1815 ISP_IOXGET_8(isp, &src->snscb_fpname[i], dst->snscb_fpname[i]);
1816 }
1817 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
1818 for (i = 0; i < 3; i++) {
1819 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i], dst->snscb_hardaddr[i]);
1820 }
1821 }
1822
1823 void
1824 isp_get_els(ispsoftc_t *isp, els_t *src, els_t *dst)
1825 {
1826 int i;
1827
1828 isp_get_hdr(isp, &src->els_hdr, &dst->els_hdr);
1829 ISP_IOXGET_32(isp, &src->els_handle, dst->els_handle);
1830 ISP_IOXGET_16(isp, &src->els_status, dst->els_status);
1831 ISP_IOXGET_16(isp, &src->els_nphdl, dst->els_nphdl);
1832 ISP_IOXGET_16(isp, &src->els_xmit_dsd_count, dst->els_xmit_dsd_count);
1833 ISP_IOXGET_8(isp, &src->els_vphdl, dst->els_vphdl);
1834 ISP_IOXGET_8(isp, &src->els_sof, dst->els_sof);
1835 ISP_IOXGET_32(isp, &src->els_rxid, dst->els_rxid);
1836 ISP_IOXGET_16(isp, &src->els_recv_dsd_count, dst->els_recv_dsd_count);
1837 ISP_IOXGET_8(isp, &src->els_opcode, dst->els_opcode);
1838 ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved1);
1839 ISP_IOXGET_8(isp, &src->els_did_lo, dst->els_did_lo);
1840 ISP_IOXGET_8(isp, &src->els_did_mid, dst->els_did_mid);
1841 ISP_IOXGET_8(isp, &src->els_did_hi, dst->els_did_hi);
1842 ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved2);
1843 ISP_IOXGET_16(isp, &src->els_reserved3, dst->els_reserved3);
1844 ISP_IOXGET_16(isp, &src->els_ctl_flags, dst->els_ctl_flags);
1845 ISP_IOXGET_32(isp, &src->els_bytecnt, dst->els_bytecnt);
1846 ISP_IOXGET_32(isp, &src->els_subcode1, dst->els_subcode1);
1847 ISP_IOXGET_32(isp, &src->els_subcode2, dst->els_subcode2);
1848 for (i = 0; i < 20; i++) {
1849 ISP_IOXGET_8(isp, &src->els_reserved4[i], dst->els_reserved4[i]);
1850 }
1851 }
1852
1853 void
1854 isp_put_els(ispsoftc_t *isp, els_t *src, els_t *dst)
1855 {
1856 isp_put_hdr(isp, &src->els_hdr, &dst->els_hdr);
1857 ISP_IOXPUT_32(isp, src->els_handle, &dst->els_handle);
1858 ISP_IOXPUT_16(isp, src->els_status, &dst->els_status);
1859 ISP_IOXPUT_16(isp, src->els_nphdl, &dst->els_nphdl);
1860 ISP_IOXPUT_16(isp, src->els_xmit_dsd_count, &dst->els_xmit_dsd_count);
1861 ISP_IOXPUT_8(isp, src->els_vphdl, &dst->els_vphdl);
1862 ISP_IOXPUT_8(isp, src->els_sof, &dst->els_sof);
1863 ISP_IOXPUT_32(isp, src->els_rxid, &dst->els_rxid);
1864 ISP_IOXPUT_16(isp, src->els_recv_dsd_count, &dst->els_recv_dsd_count);
1865 ISP_IOXPUT_8(isp, src->els_opcode, &dst->els_opcode);
1866 ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved1);
1867 ISP_IOXPUT_8(isp, src->els_did_lo, &dst->els_did_lo);
1868 ISP_IOXPUT_8(isp, src->els_did_mid, &dst->els_did_mid);
1869 ISP_IOXPUT_8(isp, src->els_did_hi, &dst->els_did_hi);
1870 ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved2);
1871 ISP_IOXPUT_16(isp, src->els_reserved3, &dst->els_reserved3);
1872 ISP_IOXPUT_16(isp, src->els_ctl_flags, &dst->els_ctl_flags);
1873 ISP_IOXPUT_32(isp, src->els_recv_bytecnt, &dst->els_recv_bytecnt);
1874 ISP_IOXPUT_32(isp, src->els_xmit_bytecnt, &dst->els_xmit_bytecnt);
1875 ISP_IOXPUT_32(isp, src->els_xmit_dsd_length, &dst->els_xmit_dsd_length);
1876 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a1500, &dst->els_xmit_dsd_a1500);
1877 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a3116, &dst->els_xmit_dsd_a3116);
1878 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a4732, &dst->els_xmit_dsd_a4732);
1879 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a6348, &dst->els_xmit_dsd_a6348);
1880 ISP_IOXPUT_32(isp, src->els_recv_dsd_length, &dst->els_recv_dsd_length);
1881 ISP_IOXPUT_16(isp, src->els_recv_dsd_a1500, &dst->els_recv_dsd_a1500);
1882 ISP_IOXPUT_16(isp, src->els_recv_dsd_a3116, &dst->els_recv_dsd_a3116);
1883 ISP_IOXPUT_16(isp, src->els_recv_dsd_a4732, &dst->els_recv_dsd_a4732);
1884 ISP_IOXPUT_16(isp, src->els_recv_dsd_a6348, &dst->els_recv_dsd_a6348);
1885 }
1886
1887 /*
1888 * FC Structure Canonicalization
1889 */
1890
1891 void
1892 isp_get_fc_hdr(ispsoftc_t *isp, fc_hdr_t *src, fc_hdr_t *dst)
1893 {
1894 ISP_IOZGET_8(isp, &src->r_ctl, dst->r_ctl);
1895 ISP_IOZGET_8(isp, &src->d_id[0], dst->d_id[0]);
1896 ISP_IOZGET_8(isp, &src->d_id[1], dst->d_id[1]);
1897 ISP_IOZGET_8(isp, &src->d_id[2], dst->d_id[2]);
1898 ISP_IOZGET_8(isp, &src->cs_ctl, dst->cs_ctl);
1899 ISP_IOZGET_8(isp, &src->s_id[0], dst->s_id[0]);
1900 ISP_IOZGET_8(isp, &src->s_id[1], dst->s_id[1]);
1901 ISP_IOZGET_8(isp, &src->s_id[2], dst->s_id[2]);
1902 ISP_IOZGET_8(isp, &src->type, dst->type);
1903 ISP_IOZGET_8(isp, &src->f_ctl[0], dst->f_ctl[0]);
1904 ISP_IOZGET_8(isp, &src->f_ctl[1], dst->f_ctl[1]);
1905 ISP_IOZGET_8(isp, &src->f_ctl[2], dst->f_ctl[2]);
1906 ISP_IOZGET_8(isp, &src->seq_id, dst->seq_id);
1907 ISP_IOZGET_8(isp, &src->df_ctl, dst->df_ctl);
1908 ISP_IOZGET_16(isp, &src->seq_cnt, dst->seq_cnt);
1909 ISP_IOZGET_16(isp, &src->ox_id, dst->ox_id);
1910 ISP_IOZGET_16(isp, &src->rx_id, dst->rx_id);
1911 ISP_IOZGET_32(isp, &src->parameter, dst->parameter);
1912 }
1913
1914 void
1915 isp_get_fcp_cmnd_iu(ispsoftc_t *isp, fcp_cmnd_iu_t *src, fcp_cmnd_iu_t *dst)
1916 {
1917 int i;
1918
1919 for (i = 0; i < 8; i++) {
1920 ISP_IOZGET_8(isp, &src->fcp_cmnd_lun[i], dst->fcp_cmnd_lun[i]);
1921 }
1922 ISP_IOZGET_8(isp, &src->fcp_cmnd_crn, dst->fcp_cmnd_crn);
1923 ISP_IOZGET_8(isp, &src->fcp_cmnd_task_attribute, dst->fcp_cmnd_task_attribute);
1924 ISP_IOZGET_8(isp, &src->fcp_cmnd_task_management, dst->fcp_cmnd_task_management);
1925 ISP_IOZGET_8(isp, &src->fcp_cmnd_alen_datadir, dst->fcp_cmnd_alen_datadir);
1926 for (i = 0; i < 16; i++) {
1927 ISP_IOZGET_8(isp, &src->cdb_dl.sf.fcp_cmnd_cdb[i], dst->cdb_dl.sf.fcp_cmnd_cdb[i]);
1928 }
1929 ISP_IOZGET_32(isp, &src->cdb_dl.sf.fcp_cmnd_dl, dst->cdb_dl.sf.fcp_cmnd_dl);
1930 }
1931
1932 void
1933 isp_put_rft_id(ispsoftc_t *isp, rft_id_t *src, rft_id_t *dst)
1934 {
1935 int i;
1936 isp_put_ct_hdr(isp, &src->rftid_hdr, &dst->rftid_hdr);
1937 ISP_IOZPUT_8(isp, src->rftid_reserved, &dst->rftid_reserved);
1938 for (i = 0; i < 3; i++) {
1939 ISP_IOZPUT_8(isp, src->rftid_portid[i], &dst->rftid_portid[i]);
1940 }
1941 for (i = 0; i < 8; i++) {
1942 ISP_IOZPUT_32(isp, src->rftid_fc4types[i], &dst->rftid_fc4types[i]);
1943 }
1944 }
1945
1946 void
1947 isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1948 {
1949 ISP_IOZGET_8(isp, &src->ct_revision, dst->ct_revision);
1950 ISP_IOZGET_8(isp, &src->ct_in_id[0], dst->ct_in_id[0]);
1951 ISP_IOZGET_8(isp, &src->ct_in_id[1], dst->ct_in_id[1]);
1952 ISP_IOZGET_8(isp, &src->ct_in_id[2], dst->ct_in_id[2]);
1953 ISP_IOZGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
1954 ISP_IOZGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
1955 ISP_IOZGET_8(isp, &src->ct_options, dst->ct_options);
1956 ISP_IOZGET_8(isp, &src->ct_reserved0, dst->ct_reserved0);
1957 ISP_IOZGET_16(isp, &src->ct_cmd_resp, dst->ct_cmd_resp);
1958 ISP_IOZGET_16(isp, &src->ct_bcnt_resid, dst->ct_bcnt_resid);
1959 ISP_IOZGET_8(isp, &src->ct_reserved1, dst->ct_reserved1);
1960 ISP_IOZGET_8(isp, &src->ct_reason, dst->ct_reason);
1961 ISP_IOZGET_8(isp, &src->ct_explanation, dst->ct_explanation);
1962 ISP_IOZGET_8(isp, &src->ct_vunique, dst->ct_vunique);
1963 }
1964
1965 void
1966 isp_put_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1967 {
1968 ISP_IOZPUT_8(isp, src->ct_revision, &dst->ct_revision);
1969 ISP_IOZPUT_8(isp, src->ct_in_id[0], &dst->ct_in_id[0]);
1970 ISP_IOZPUT_8(isp, src->ct_in_id[1], &dst->ct_in_id[1]);
1971 ISP_IOZPUT_8(isp, src->ct_in_id[2], &dst->ct_in_id[2]);
1972 ISP_IOZPUT_8(isp, src->ct_fcs_type, &dst->ct_fcs_type);
1973 ISP_IOZPUT_8(isp, src->ct_fcs_subtype, &dst->ct_fcs_subtype);
1974 ISP_IOZPUT_8(isp, src->ct_options, &dst->ct_options);
1975 ISP_IOZPUT_8(isp, src->ct_reserved0, &dst->ct_reserved0);
1976 ISP_IOZPUT_16(isp, src->ct_cmd_resp, &dst->ct_cmd_resp);
1977 ISP_IOZPUT_16(isp, src->ct_bcnt_resid, &dst->ct_bcnt_resid);
1978 ISP_IOZPUT_8(isp, src->ct_reserved1, &dst->ct_reserved1);
1979 ISP_IOZPUT_8(isp, src->ct_reason, &dst->ct_reason);
1980 ISP_IOZPUT_8(isp, src->ct_explanation, &dst->ct_explanation);
1981 ISP_IOZPUT_8(isp, src->ct_vunique, &dst->ct_vunique);
1982 }
1983
1984 #ifdef ISP_TARGET_MODE
1985
1986 /*
1987 * Command shipping- finish off first queue entry and do dma mapping and
1988 * additional segments as needed.
1989 *
1990 * Called with the first queue entry at least partially filled out.
1991 */
1992 int
1993 isp_send_tgt_cmd(ispsoftc_t *isp, void *fqe, void *segp, uint32_t nsegs, uint32_t totalcnt, isp_ddir_t ddir, void *snsptr, uint32_t snslen)
1994 {
1995 uint8_t storage[QENTRY_LEN], storage2[QENTRY_LEN];
1996 uint8_t type, nqe;
1997 uint32_t seg, curseg, seglim, nxt, nxtnxt;
1998 ispds_t *dsp = NULL;
1999 ispds64_t *dsp64 = NULL;
2000 void *qe0, *qe1, *sqe = NULL;
2001
2002 qe0 = isp_getrqentry(isp);
2003 if (qe0 == NULL) {
2004 return (CMD_EAGAIN);
2005 }
2006 nxt = ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp));
2007
2008 type = ((isphdr_t *)fqe)->rqs_entry_type;
2009 nqe = 1;
2010 seglim = 0;
2011
2012 /*
2013 * If we have no data to transmit, just copy the first IOCB and start it up.
2014 */
2015 if (ddir != ISP_NOXFR) {
2016 /*
2017 * First, figure out how many pieces of data to transfer and what kind and how many we can put into the first queue entry.
2018 */
2019 switch (type) {
2020 case RQSTYPE_CTIO:
2021 dsp = ((ct_entry_t *)fqe)->ct_dataseg;
2022 seglim = ISP_RQDSEG;
2023 break;
2024 case RQSTYPE_CTIO2:
2025 case RQSTYPE_CTIO3:
2026 {
2027 ct2_entry_t *ct = fqe, *ct2 = (ct2_entry_t *) storage2;
2028 uint16_t swd = ct->rsp.m0.ct_scsi_status & 0xff;
2029
2030 if ((ct->ct_flags & CT2_SENDSTATUS) && (swd || ct->ct_resid)) {
2031 memcpy(ct2, ct, QENTRY_LEN);
2032 /*
2033 * Clear fields from first CTIO2 that now need to be cleared
2034 */
2035 ct->ct_header.rqs_seqno = 0;
2036 ct->ct_flags &= ~(CT2_SENDSTATUS|CT2_CCINCR|CT2_FASTPOST);
2037 ct->ct_resid = 0;
2038 ct->ct_syshandle = 0;
2039 ct->rsp.m0.ct_scsi_status = 0;
2040
2041 /*
2042 * Reset fields in the second CTIO2 as appropriate.
2043 */
2044 ct2->ct_flags &= ~(CT2_FLAG_MMASK|CT2_DATAMASK|CT2_FASTPOST);
2045 ct2->ct_flags |= CT2_NO_DATA|CT2_FLAG_MODE1;
2046 ct2->ct_seg_count = 0;
2047 ct2->ct_reloff = 0;
2048 memset(&ct2->rsp, 0, sizeof (ct2->rsp));
2049 if (swd == SCSI_CHECK && snsptr && snslen) {
2050 ct2->rsp.m1.ct_senselen = min(snslen, MAXRESPLEN);
2051 memcpy(ct2->rsp.m1.ct_resp, snsptr, ct2->rsp.m1.ct_senselen);
2052 swd |= CT2_SNSLEN_VALID;
2053 }
2054 if (ct2->ct_resid > 0) {
2055 swd |= CT2_DATA_UNDER;
2056 } else if (ct2->ct_resid < 0) {
2057 swd |= CT2_DATA_OVER;
2058 }
2059 ct2->rsp.m1.ct_scsi_status = swd;
2060 sqe = storage2;
2061 }
2062 if (type == RQSTYPE_CTIO2) {
2063 dsp = ct->rsp.m0.u.ct_dataseg;
2064 seglim = ISP_RQDSEG_T2;
2065 } else {
2066 dsp64 = ct->rsp.m0.u.ct_dataseg64;
2067 seglim = ISP_RQDSEG_T3;
2068 }
2069 break;
2070 }
2071 case RQSTYPE_CTIO7:
2072 {
2073 ct7_entry_t *ct = fqe, *ct2 = (ct7_entry_t *)storage2;
2074 uint16_t swd = ct->ct_scsi_status & 0xff;
2075
2076 dsp64 = &ct->rsp.m0.ds;
2077 seglim = 1;
2078 if ((ct->ct_flags & CT7_SENDSTATUS) && (swd || ct->ct_resid)) {
2079 memcpy(ct2, ct, sizeof (ct7_entry_t));
2080
2081 /*
2082 * Clear fields from first CTIO7 that now need to be cleared
2083 */
2084 ct->ct_header.rqs_seqno = 0;
2085 ct->ct_flags &= ~CT7_SENDSTATUS;
2086 ct->ct_resid = 0;
2087 ct->ct_syshandle = 0;
2088 ct->ct_scsi_status = 0;
2089
2090 /*
2091 * Reset fields in the second CTIO7 as appropriate.
2092 */
2093 ct2->ct_flags &= ~(CT7_FLAG_MMASK|CT7_DATAMASK);
2094 ct2->ct_flags |= CT7_NO_DATA|CT7_NO_DATA|CT7_FLAG_MODE1;
2095 ct2->ct_seg_count = 0;
2096 memset(&ct2->rsp, 0, sizeof (ct2->rsp));
2097 if (swd == SCSI_CHECK && snsptr && snslen) {
2098 ct2->rsp.m1.ct_resplen = min(snslen, MAXRESPLEN_24XX);
2099 memcpy(ct2->rsp.m1.ct_resp, snsptr, ct2->rsp.m1.ct_resplen);
2100 swd |= (FCP_SNSLEN_VALID << 8);
2101 }
2102 if (ct2->ct_resid < 0) {
2103 swd |= (FCP_RESID_OVERFLOW << 8);
2104 } else if (ct2->ct_resid > 0) {
2105 swd |= (FCP_RESID_UNDERFLOW << 8);
2106 }
2107 ct2->ct_scsi_status = swd;
2108 sqe = storage2;
2109 }
2110 break;
2111 }
2112 default:
2113 return (CMD_COMPLETE);
2114 }
2115 }
2116
2117 /*
2118 * Fill out the data transfer stuff in the first queue entry
2119 */
2120 if (seglim > nsegs) {
2121 seglim = nsegs;
2122 }
2123
2124 for (seg = curseg = 0; curseg < seglim; curseg++) {
2125 if (dsp64) {
2126 XS_GET_DMA64_SEG(dsp64++, segp, seg++);
2127 } else {
2128 XS_GET_DMA_SEG(dsp++, segp, seg++);
2129 }
2130 }
2131
2132 /*
2133 * First, if we are sending status with data and we have a non-zero
2134 * status or non-zero residual, we have to make a synthetic extra CTIO
2135 * that contains the status that we'll ship separately (FC cards only).
2136 */
2137
2138 /*
2139 * Second, start building additional continuation segments as needed.
2140 */
2141 while (seg < nsegs) {
2142 nxtnxt = ISP_NXT_QENTRY(nxt, RQUEST_QUEUE_LEN(isp));
2143 if (nxtnxt == isp->isp_reqodx) {
2144 return (CMD_EAGAIN);
2145 }
2146 ISP_MEMZERO(storage, QENTRY_LEN);
2147 qe1 = ISP_QUEUE_ENTRY(isp->isp_rquest, nxt);
2148 nxt = nxtnxt;
2149 if (dsp64) {
2150 ispcontreq64_t *crq = (ispcontreq64_t *) storage;
2151 seglim = ISP_CDSEG64;
2152 crq->req_header.rqs_entry_type = RQSTYPE_A64_CONT;
2153 crq->req_header.rqs_entry_count = 1;
2154 dsp64 = crq->req_dataseg;
2155 } else {
2156 ispcontreq_t *crq = (ispcontreq_t *) storage;
2157 seglim = ISP_CDSEG;
2158 crq->req_header.rqs_entry_type = RQSTYPE_DATASEG;
2159 crq->req_header.rqs_entry_count = 1;
2160 dsp = crq->req_dataseg;
2161 }
2162 if (seg + seglim > nsegs) {
2163 seglim = nsegs - seg;
2164 }
2165 for (curseg = 0; curseg < seglim; curseg++) {
2166 if (dsp64) {
2167 XS_GET_DMA64_SEG(dsp64++, segp, seg++);
2168 } else {
2169 XS_GET_DMA_SEG(dsp++, segp, seg++);
2170 }
2171 }
2172 if (dsp64) {
2173 isp_put_cont64_req(isp, (ispcontreq64_t *)storage, qe1);
2174 } else {
2175 isp_put_cont_req(isp, (ispcontreq_t *)storage, qe1);
2176 }
2177 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
2178 isp_print_bytes(isp, "additional queue entry", QENTRY_LEN, storage);
2179 }
2180 nqe++;
2181 }
2182
2183 /*
2184 * If we have a synthetic queue entry to complete things, do it here.
2185 */
2186 if (sqe) {
2187 nxtnxt = ISP_NXT_QENTRY(nxt, RQUEST_QUEUE_LEN(isp));
2188 if (nxtnxt == isp->isp_reqodx) {
2189 return (CMD_EAGAIN);
2190 }
2191 qe1 = ISP_QUEUE_ENTRY(isp->isp_rquest, nxt);
2192 nxt = nxtnxt;
2193 if (type == RQSTYPE_CTIO7) {
2194 isp_put_ctio7(isp, sqe, qe1);
2195 } else {
2196 isp_put_ctio2(isp, sqe, qe1);
2197 }
2198 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
2199 isp_print_bytes(isp, "synthetic final queue entry", QENTRY_LEN, storage2);
2200 }
2201 }
2202
2203 ((isphdr_t *)fqe)->rqs_entry_count = nqe;
2204 switch (type) {
2205 case RQSTYPE_CTIO:
2206 ((ct_entry_t *)fqe)->ct_seg_count = nsegs;
2207 isp_put_ctio(isp, fqe, qe0);
2208 break;
2209 case RQSTYPE_CTIO2:
2210 case RQSTYPE_CTIO3:
2211 ((ct2_entry_t *)fqe)->ct_seg_count = nsegs;
2212 if (ISP_CAP_2KLOGIN(isp)) {
2213 isp_put_ctio2e(isp, fqe, qe0);
2214 } else {
2215 isp_put_ctio2(isp, fqe, qe0);
2216 }
2217 break;
2218 case RQSTYPE_CTIO7:
2219 ((ct7_entry_t *)fqe)->ct_seg_count = nsegs;
2220 isp_put_ctio7(isp, fqe, qe0);
2221 break;
2222 default:
2223 return (CMD_COMPLETE);
2224 }
2225 if (isp->isp_dblev & ISP_LOGTDEBUG1) {
2226 isp_print_bytes(isp, "first queue entry", QENTRY_LEN, fqe);
2227 }
2228 ISP_ADD_REQUEST(isp, nxt);
2229 return (CMD_QUEUED);
2230 }
2231
2232 int
2233 isp_allocate_xs_tgt(ispsoftc_t *isp, void *xs, uint32_t *handlep)
2234 {
2235 isp_hdl_t *hdp;
2236
2237 hdp = isp->isp_tgtfree;
2238 if (hdp == NULL) {
2239 return (-1);
2240 }
2241 isp->isp_tgtfree = hdp->cmd;
2242 hdp->cmd = xs;
2243 hdp->handle = (hdp - isp->isp_tgtlist);
2244 hdp->handle |= (ISP_HANDLE_TARGET << ISP_HANDLE_USAGE_SHIFT);
2245 /*
2246 * Target handles for SCSI cards are only 16 bits, so
2247 * sequence number protection will be ommitted.
2248 */
2249 if (IS_FC(isp)) {
2250 hdp->handle |= (isp->isp_seqno++ << ISP_HANDLE_SEQ_SHIFT);
2251 }
2252 *handlep = hdp->handle;
2253 return (0);
2254 }
2255
2256 void *
2257 isp_find_xs_tgt(ispsoftc_t *isp, uint32_t handle)
2258 {
2259 if (!ISP_VALID_TGT_HANDLE(isp, handle)) {
2260 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
2261 return (NULL);
2262 }
2263 return (isp->isp_tgtlist[(handle & ISP_HANDLE_CMD_MASK)].cmd);
2264 }
2265
2266 uint32_t
2267 isp_find_tgt_handle(ispsoftc_t *isp, void *xs)
2268 {
2269 uint32_t i, foundhdl = ISP_HANDLE_FREE;
2270
2271 if (xs != NULL) {
2272 for (i = 0; i < isp->isp_maxcmds; i++) {
2273 if (isp->isp_tgtlist[i].cmd != xs) {
2274 continue;
2275 }
2276 foundhdl = isp->isp_tgtlist[i].handle;
2277 break;
2278 }
2279 }
2280 return (foundhdl);
2281 }
2282
2283 void
2284 isp_destroy_tgt_handle(ispsoftc_t *isp, uint32_t handle)
2285 {
2286 if (!ISP_VALID_TGT_HANDLE(isp, handle)) {
2287 isp_prt(isp, ISP_LOGERR, "%s: bad handle 0x%x", __func__, handle);
2288 } else {
2289 isp->isp_tgtlist[(handle & ISP_HANDLE_CMD_MASK)].handle = ISP_HANDLE_FREE;
2290 isp->isp_tgtlist[(handle & ISP_HANDLE_CMD_MASK)].cmd = isp->isp_tgtfree;
2291 isp->isp_tgtfree = &isp->isp_tgtlist[(handle & ISP_HANDLE_CMD_MASK)];
2292 }
2293 }
2294
2295 /*
2296 * Find target mode entries
2297 */
2298 int
2299 isp_find_pdb_by_wwn(ispsoftc_t *isp, int chan, uint64_t wwn, fcportdb_t **lptr)
2300 {
2301 fcparam *fcp;
2302 int i;
2303
2304 if (chan < isp->isp_nchan) {
2305 fcp = FCPARAM(isp, chan);
2306 for (i = 0; i < MAX_FC_TARG; i++) {
2307 fcportdb_t *lp = &fcp->portdb[i];
2308
2309 if (lp->target_mode == 0) {
2310 continue;
2311 }
2312 if (lp->port_wwn == wwn) {
2313 *lptr = lp;
2314 return (1);
2315 }
2316 }
2317 }
2318 return (0);
2319 }
2320
2321 int
2322 isp_find_pdb_by_loopid(ispsoftc_t *isp, int chan, uint32_t loopid, fcportdb_t **lptr)
2323 {
2324 fcparam *fcp;
2325 int i;
2326
2327 if (chan < isp->isp_nchan) {
2328 fcp = FCPARAM(isp, chan);
2329 for (i = 0; i < MAX_FC_TARG; i++) {
2330 fcportdb_t *lp = &fcp->portdb[i];
2331
2332 if (lp->target_mode == 0) {
2333 continue;
2334 }
2335 if (lp->handle == loopid) {
2336 *lptr = lp;
2337 return (1);
2338 }
2339 }
2340 }
2341 return (0);
2342 }
2343
2344 int
2345 isp_find_pdb_by_sid(ispsoftc_t *isp, int chan, uint32_t sid, fcportdb_t **lptr)
2346 {
2347 fcparam *fcp;
2348 int i;
2349
2350 if (chan >= isp->isp_nchan) {
2351 return (0);
2352 }
2353
2354 fcp = FCPARAM(isp, chan);
2355 for (i = 0; i < MAX_FC_TARG; i++) {
2356 fcportdb_t *lp = &fcp->portdb[i];
2357
2358 if (lp->target_mode == 0) {
2359 continue;
2360 }
2361 if (lp->portid == sid) {
2362 *lptr = lp;
2363 return (1);
2364 }
2365 }
2366 return (0);
2367 }
2368
2369 void
2370 isp_find_chan_by_did(ispsoftc_t *isp, uint32_t did, uint16_t *cp)
2371 {
2372 uint16_t chan;
2373
2374 *cp = ISP_NOCHAN;
2375 for (chan = 0; chan < isp->isp_nchan; chan++) {
2376 fcparam *fcp = FCPARAM(isp, chan);
2377 if ((fcp->role & ISP_ROLE_TARGET) == 0 || fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD) {
2378 continue;
2379 }
2380 if (fcp->isp_portid == did) {
2381 *cp = chan;
2382 break;
2383 }
2384 }
2385 }
2386
2387 /*
2388 * Add an initiator device to the port database
2389 */
2390 void
2391 isp_add_wwn_entry(ispsoftc_t *isp, int chan, uint64_t ini, uint16_t nphdl, uint32_t s_id)
2392 {
2393 fcparam *fcp;
2394 fcportdb_t *lp;
2395 isp_notify_t nt;
2396 int i;
2397
2398 fcp = FCPARAM(isp, chan);
2399
2400 if (nphdl >= MAX_NPORT_HANDLE) {
2401 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d IID 0x%016llx bad N-Port handle 0x%04x Port ID 0x%06x",
2402 __func__, chan, (unsigned long long) ini, nphdl, s_id);
2403 return;
2404 }
2405
2406 lp = NULL;
2407 if (fcp->isp_tgt_map[nphdl]) {
2408 lp = &fcp->portdb[fcp->isp_tgt_map[nphdl] - 1];
2409 } else {
2410 /*
2411 * Make sure the addition of a new target mode entry doesn't duplicate entries
2412 * with the same N-Port handles, the same portids or the same Port WWN.
2413 */
2414 for (i = 0; i < MAX_FC_TARG; i++) {
2415 lp = &fcp->portdb[i];
2416 if (lp->target_mode == 0) {
2417 lp = NULL;
2418 continue;
2419 }
2420 if (lp->handle == nphdl) {
2421 break;
2422 }
2423 if (s_id != PORT_ANY && lp->portid == s_id) {
2424 break;
2425 }
2426 if (VALID_INI(ini) && lp->port_wwn == ini) {
2427 break;
2428 }
2429 lp = NULL;
2430 }
2431
2432 }
2433
2434 if (lp) {
2435 int something = 0;
2436 if (lp->handle != nphdl) {
2437 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d attempt to re-enter N-port handle 0x%04x IID 0x%016llx Port ID 0x%06x finds IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x",
2438 __func__, chan, nphdl, (unsigned long long)ini, s_id, (unsigned long long) lp->port_wwn, lp->handle, lp->portid);
2439 isp_dump_portdb(isp, chan);
2440 return;
2441 }
2442 if (s_id != PORT_NONE) {
2443 if (lp->portid == PORT_NONE) {
2444 lp->portid = s_id;
2445 isp_prt(isp, ISP_LOGTINFO, "%s: Chan %d N-port handle 0x%04x gets Port ID 0x%06x", __func__, chan, nphdl, s_id);
2446 something++;
2447 } else if (lp->portid != s_id) {
2448 isp_prt(isp, ISP_LOGTINFO, "%s: Chan %d N-port handle 0x%04x tries to change Port ID 0x%06x to 0x%06x", __func__, chan, nphdl,
2449 lp->portid, s_id);
2450 isp_dump_portdb(isp, chan);
2451 return;
2452 }
2453 }
2454 if (VALID_INI(ini)) {
2455 if (!VALID_INI(lp->port_wwn)) {
2456 lp->port_wwn = ini;
2457 isp_prt(isp, ISP_LOGTINFO, "%s: Chan %d N-port handle 0x%04x gets WWN 0x%016llxx", __func__, chan, nphdl, (unsigned long long) ini);
2458 something++;
2459 } else if (lp->port_wwn != ini) {
2460 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d N-port handle 0x%04x tries to change WWN 0x%016llx to 0x%016llx", __func__, chan, nphdl,
2461 (unsigned long long) lp->port_wwn, (unsigned long long) ini);
2462 isp_dump_portdb(isp, chan);
2463 return;
2464 }
2465 }
2466
2467 if (!something) {
2468 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x reentered", __func__, chan,
2469 (unsigned long long) lp->port_wwn, lp->handle, lp->portid);
2470 }
2471 return;
2472 }
2473
2474 /*
2475 * Find a new spot
2476 */
2477 for (i = MAX_FC_TARG - 1; i >= 0; i--) {
2478 if (fcp->portdb[i].target_mode == 1) {
2479 continue;
2480 }
2481 if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL) {
2482 break;
2483 }
2484 }
2485 if (i < 0) {
2486 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x- no room in port database",
2487 __func__, chan, (unsigned long long) ini, nphdl, s_id);
2488 return;
2489 }
2490
2491 lp = &fcp->portdb[i];
2492 ISP_MEMZERO(lp, sizeof (fcportdb_t));
2493 lp->target_mode = 1;
2494 lp->handle = nphdl;
2495 lp->portid = s_id;
2496 lp->port_wwn = ini;
2497 fcp->isp_tgt_map[nphdl] = i + 1;
2498
2499 isp_prt(isp, ISP_LOGTINFO, "%s: Chan %d IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x vtgt %d added", __func__, chan, (unsigned long long) ini, nphdl, s_id, fcp->isp_tgt_map[nphdl] - 1);
2500
2501 ISP_MEMZERO(&nt, sizeof (nt));
2502 nt.nt_hba = isp;
2503 nt.nt_wwn = ini;
2504 nt.nt_tgt = FCPARAM(isp, chan)->isp_wwpn;
2505 nt.nt_sid = s_id;
2506 nt.nt_did = FCPARAM(isp, chan)->isp_portid;
2507 nt.nt_nphdl = nphdl;
2508 nt.nt_channel = chan;
2509 nt.nt_ncode = NT_ARRIVED;
2510 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &nt);
2511 }
2512
2513 /*
2514 * Remove a target device to the port database
2515 */
2516 void
2517 isp_del_wwn_entry(ispsoftc_t *isp, int chan, uint64_t ini, uint16_t nphdl, uint32_t s_id)
2518 {
2519 fcparam *fcp;
2520 isp_notify_t nt;
2521 fcportdb_t *lp;
2522
2523 if (nphdl >= MAX_NPORT_HANDLE) {
2524 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d IID 0x%016llx bad N-Port handle 0x%04x Port ID 0x%06x",
2525 __func__, chan, (unsigned long long) ini, nphdl, s_id);
2526 return;
2527 }
2528
2529 fcp = FCPARAM(isp, chan);
2530 if (fcp->isp_tgt_map[nphdl] == 0) {
2531 lp = NULL;
2532 } else {
2533 lp = &fcp->portdb[fcp->isp_tgt_map[nphdl] - 1];
2534 if (lp->target_mode == 0) {
2535 lp = NULL;
2536 }
2537 }
2538 if (lp == NULL) {
2539 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x cannot be found to be cleared",
2540 __func__, chan, (unsigned long long) ini, nphdl, s_id);
2541 isp_dump_portdb(isp, chan);
2542 return;
2543 }
2544 isp_prt(isp, ISP_LOGTINFO, "%s: Chan %d IID 0x%016llx N-Port Handle 0x%04x Port ID 0x%06x vtgt %d cleared",
2545 __func__, chan, (unsigned long long) lp->port_wwn, nphdl, lp->portid, fcp->isp_tgt_map[nphdl] - 1);
2546 fcp->isp_tgt_map[nphdl] = 0;
2547
2548 ISP_MEMZERO(&nt, sizeof (nt));
2549 nt.nt_hba = isp;
2550 nt.nt_wwn = lp->port_wwn;
2551 nt.nt_tgt = FCPARAM(isp, chan)->isp_wwpn;
2552 nt.nt_sid = lp->portid;
2553 nt.nt_did = FCPARAM(isp, chan)->isp_portid;
2554 nt.nt_nphdl = nphdl;
2555 nt.nt_channel = chan;
2556 nt.nt_ncode = NT_DEPARTED;
2557 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &nt);
2558 }
2559
2560 void
2561 isp_del_all_wwn_entries(ispsoftc_t *isp, int chan)
2562 {
2563 fcparam *fcp;
2564 int i;
2565
2566 if (!IS_FC(isp)) {
2567 return;
2568 }
2569
2570 /*
2571 * Handle iterations over all channels via recursion
2572 */
2573 if (chan == ISP_NOCHAN) {
2574 for (chan = 0; chan < isp->isp_nchan; chan++) {
2575 isp_del_all_wwn_entries(isp, chan);
2576 }
2577 return;
2578 }
2579
2580 if (chan > isp->isp_nchan) {
2581 return;
2582 }
2583
2584 fcp = FCPARAM(isp, chan);
2585 if (fcp == NULL) {
2586 return;
2587 }
2588 for (i = 0; i < MAX_NPORT_HANDLE; i++) {
2589 if (fcp->isp_tgt_map[i]) {
2590 fcportdb_t *lp = &fcp->portdb[fcp->isp_tgt_map[i] - 1];
2591 isp_del_wwn_entry(isp, chan, lp->port_wwn, lp->handle, lp->portid);
2592 }
2593 }
2594 }
2595
2596 void
2597 isp_del_wwn_entries(ispsoftc_t *isp, isp_notify_t *mp)
2598 {
2599 fcportdb_t *lp;
2600
2601 /*
2602 * Handle iterations over all channels via recursion
2603 */
2604 if (mp->nt_channel == ISP_NOCHAN) {
2605 for (mp->nt_channel = 0; mp->nt_channel < isp->isp_nchan; mp->nt_channel++) {
2606 isp_del_wwn_entries(isp, mp);
2607 }
2608 mp->nt_channel = ISP_NOCHAN;
2609 return;
2610 }
2611
2612 /*
2613 * We have an entry which is only partially identified.
2614 *
2615 * It's only known by WWN, N-Port handle, or Port ID.
2616 * We need to find the actual entry so we can delete it.
2617 */
2618 if (mp->nt_nphdl != NIL_HANDLE) {
2619 if (isp_find_pdb_by_loopid(isp, mp->nt_channel, mp->nt_nphdl, &lp)) {
2620 isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
2621 return;
2622 }
2623 }
2624 if (mp->nt_wwn != INI_ANY) {
2625 if (isp_find_pdb_by_wwn(isp, mp->nt_channel, mp->nt_wwn, &lp)) {
2626 isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
2627 return;
2628 }
2629 }
2630 if (mp->nt_sid != PORT_ANY && mp->nt_sid != PORT_NONE) {
2631 if (isp_find_pdb_by_sid(isp, mp->nt_channel, mp->nt_sid, &lp)) {
2632 isp_del_wwn_entry(isp, mp->nt_channel, lp->port_wwn, lp->handle, lp->portid);
2633 return;
2634 }
2635 }
2636 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d unable to find entry to delete N-port handle 0x%04x initiator WWN 0x%016llx Port ID 0x%06x", __func__,
2637 mp->nt_channel, mp->nt_nphdl, (unsigned long long) mp->nt_wwn, mp->nt_sid);
2638 }
2639
2640 void
2641 isp_put_atio(ispsoftc_t *isp, at_entry_t *src, at_entry_t *dst)
2642 {
2643 int i;
2644 isp_put_hdr(isp, &src->at_header, &dst->at_header);
2645 ISP_IOXPUT_16(isp, src->at_reserved, &dst->at_reserved);
2646 ISP_IOXPUT_16(isp, src->at_handle, &dst->at_handle);
2647 if (ISP_IS_SBUS(isp)) {
2648 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_iid);
2649 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_lun);
2650 ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_tgt);
2651 ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_cdblen);
2652 ISP_IOXPUT_8(isp, src->at_status, &dst->at_scsi_status);
2653 ISP_IOXPUT_8(isp, src->at_scsi_status, &dst->at_status);
2654 ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_type);
2655 ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_val);
2656 } else {
2657 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
2658 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
2659 ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_cdblen);
2660 ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_tgt);
2661 ISP_IOXPUT_8(isp, src->at_status, &dst->at_status);
2662 ISP_IOXPUT_8(isp, src->at_scsi_status, &dst->at_scsi_status);
2663 ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_val);
2664 ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_type);
2665 }
2666 ISP_IOXPUT_32(isp, src->at_flags, &dst->at_flags);
2667 for (i = 0; i < ATIO_CDBLEN; i++) {
2668 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
2669 }
2670 for (i = 0; i < QLTM_SENSELEN; i++) {
2671 ISP_IOXPUT_8(isp, src->at_sense[i], &dst->at_sense[i]);
2672 }
2673 }
2674
2675 void
2676 isp_get_atio(ispsoftc_t *isp, at_entry_t *src, at_entry_t *dst)
2677 {
2678 int i;
2679 isp_get_hdr(isp, &src->at_header, &dst->at_header);
2680 ISP_IOXGET_16(isp, &src->at_reserved, dst->at_reserved);
2681 ISP_IOXGET_16(isp, &src->at_handle, dst->at_handle);
2682 if (ISP_IS_SBUS(isp)) {
2683 ISP_IOXGET_8(isp, &src->at_lun, dst->at_iid);
2684 ISP_IOXGET_8(isp, &src->at_iid, dst->at_lun);
2685 ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_tgt);
2686 ISP_IOXGET_8(isp, &src->at_tgt, dst->at_cdblen);
2687 ISP_IOXGET_8(isp, &src->at_status, dst->at_scsi_status);
2688 ISP_IOXGET_8(isp, &src->at_scsi_status, dst->at_status);
2689 ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_type);
2690 ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_val);
2691 } else {
2692 ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
2693 ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
2694 ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_cdblen);
2695 ISP_IOXGET_8(isp, &src->at_tgt, dst->at_tgt);
2696 ISP_IOXGET_8(isp, &src->at_status, dst->at_status);
2697 ISP_IOXGET_8(isp, &src->at_scsi_status, dst->at_scsi_status);
2698 ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_val);
2699 ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_type);
2700 }
2701 ISP_IOXGET_32(isp, &src->at_flags, dst->at_flags);
2702 for (i = 0; i < ATIO_CDBLEN; i++) {
2703 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
2704 }
2705 for (i = 0; i < QLTM_SENSELEN; i++) {
2706 ISP_IOXGET_8(isp, &src->at_sense[i], dst->at_sense[i]);
2707 }
2708 }
2709
2710 void
2711 isp_put_atio2(ispsoftc_t *isp, at2_entry_t *src, at2_entry_t *dst)
2712 {
2713 int i;
2714 isp_put_hdr(isp, &src->at_header, &dst->at_header);
2715 ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
2716 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
2717 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
2718 ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
2719 ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
2720 ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
2721 ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
2722 ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
2723 ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
2724 ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
2725 for (i = 0; i < ATIO2_CDBLEN; i++) {
2726 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
2727 }
2728 ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
2729 ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
2730 for (i = 0; i < 4; i++) {
2731 ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
2732 }
2733 for (i = 0; i < 6; i++) {
2734 ISP_IOXPUT_16(isp, src->at_reserved2[i], &dst->at_reserved2[i]);
2735 }
2736 ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
2737 }
2738
2739 void
2740 isp_put_atio2e(ispsoftc_t *isp, at2e_entry_t *src, at2e_entry_t *dst)
2741 {
2742 int i;
2743 isp_put_hdr(isp, &src->at_header, &dst->at_header);
2744 ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
2745 ISP_IOXPUT_16(isp, src->at_iid, &dst->at_iid);
2746 ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
2747 ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
2748 ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
2749 ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
2750 ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
2751 ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
2752 ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
2753 for (i = 0; i < ATIO2_CDBLEN; i++) {
2754 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
2755 }
2756 ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
2757 ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
2758 for (i = 0; i < 4; i++) {
2759 ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
2760 }
2761 for (i = 0; i < 6; i++) {
2762 ISP_IOXPUT_16(isp, src->at_reserved2[i], &dst->at_reserved2[i]);
2763 }
2764 ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
2765 }
2766
2767 void
2768 isp_get_atio2(ispsoftc_t *isp, at2_entry_t *src, at2_entry_t *dst)
2769 {
2770 int i;
2771 isp_get_hdr(isp, &src->at_header, &dst->at_header);
2772 ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
2773 ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
2774 ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
2775 ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
2776 ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
2777 ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
2778 ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
2779 ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
2780 ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
2781 ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
2782 for (i = 0; i < ATIO2_CDBLEN; i++) {
2783 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
2784 }
2785 ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
2786 ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
2787 for (i = 0; i < 4; i++) {
2788 ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
2789 }
2790 for (i = 0; i < 6; i++) {
2791 ISP_IOXGET_16(isp, &src->at_reserved2[i], dst->at_reserved2[i]);
2792 }
2793 ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
2794 }
2795
2796 void
2797 isp_get_atio2e(ispsoftc_t *isp, at2e_entry_t *src, at2e_entry_t *dst)
2798 {
2799 int i;
2800 isp_get_hdr(isp, &src->at_header, &dst->at_header);
2801 ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
2802 ISP_IOXGET_16(isp, &src->at_iid, dst->at_iid);
2803 ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
2804 ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
2805 ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
2806 ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
2807 ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
2808 ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
2809 ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
2810 for (i = 0; i < ATIO2_CDBLEN; i++) {
2811 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
2812 }
2813 ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
2814 ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
2815 for (i = 0; i < 4; i++) {
2816 ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
2817 }
2818 for (i = 0; i < 6; i++) {
2819 ISP_IOXGET_16(isp, &src->at_reserved2[i], dst->at_reserved2[i]);
2820 }
2821 ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
2822 }
2823
2824 void
2825 isp_get_atio7(ispsoftc_t *isp, at7_entry_t *src, at7_entry_t *dst)
2826 {
2827 ISP_IOXGET_8(isp, &src->at_type, dst->at_type);
2828 ISP_IOXGET_8(isp, &src->at_count, dst->at_count);
2829 ISP_IOXGET_16(isp, &src->at_ta_len, dst->at_ta_len);
2830 ISP_IOXGET_32(isp, &src->at_rxid, dst->at_rxid);
2831 isp_get_fc_hdr(isp, &src->at_hdr, &dst->at_hdr);
2832 isp_get_fcp_cmnd_iu(isp, &src->at_cmnd, &dst->at_cmnd);
2833 }
2834
2835 void
2836 isp_put_ctio(ispsoftc_t *isp, ct_entry_t *src, ct_entry_t *dst)
2837 {
2838 int i;
2839 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
2840 ISP_IOXPUT_16(isp, src->ct_syshandle, &dst->ct_syshandle);
2841 ISP_IOXPUT_16(isp, src->ct_fwhandle, &dst->ct_fwhandle);
2842 if (ISP_IS_SBUS(isp)) {
2843 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_lun);
2844 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_iid);
2845 ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_reserved2);
2846 ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_tgt);
2847 ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_scsi_status);
2848 ISP_IOXPUT_8(isp, src->ct_scsi_status, &dst->ct_status);
2849 ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_val);
2850 ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_type);
2851 } else {
2852 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
2853 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
2854 ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_tgt);
2855 ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_reserved2);
2856 ISP_IOXPUT_8(isp, src->ct_scsi_status,
2857 &dst->ct_scsi_status);
2858 ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_status);
2859 ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_type);
2860 ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_val);
2861 }
2862 ISP_IOXPUT_32(isp, src->ct_flags, &dst->ct_flags);
2863 ISP_IOXPUT_32(isp, src->ct_xfrlen, &dst->ct_xfrlen);
2864 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
2865 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
2866 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
2867 for (i = 0; i < ISP_RQDSEG; i++) {
2868 ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_base, &dst->ct_dataseg[i].ds_base);
2869 ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_count, &dst->ct_dataseg[i].ds_count);
2870 }
2871 }
2872
2873 void
2874 isp_get_ctio(ispsoftc_t *isp, ct_entry_t *src, ct_entry_t *dst)
2875 {
2876 int i;
2877 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
2878 ISP_IOXGET_16(isp, &src->ct_syshandle, dst->ct_syshandle);
2879 ISP_IOXGET_16(isp, &src->ct_fwhandle, dst->ct_fwhandle);
2880 if (ISP_IS_SBUS(isp)) {
2881 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_iid);
2882 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_lun);
2883 ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_tgt);
2884 ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_reserved2);
2885 ISP_IOXGET_8(isp, &src->ct_status, dst->ct_scsi_status);
2886 ISP_IOXGET_8(isp, &src->ct_scsi_status, dst->ct_status);
2887 ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_type);
2888 ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_val);
2889 } else {
2890 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
2891 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
2892 ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_reserved2);
2893 ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_tgt);
2894 ISP_IOXGET_8(isp, &src->ct_status, dst->ct_status);
2895 ISP_IOXGET_8(isp, &src->ct_scsi_status, dst->ct_scsi_status);
2896 ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_val);
2897 ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_type);
2898 }
2899 ISP_IOXGET_32(isp, &src->ct_flags, dst->ct_flags);
2900 ISP_IOXGET_32(isp, &src->ct_xfrlen, dst->ct_xfrlen);
2901 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
2902 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
2903 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
2904 for (i = 0; i < ISP_RQDSEG; i++) {
2905 ISP_IOXGET_32(isp, &src->ct_dataseg[i].ds_base, dst->ct_dataseg[i].ds_base);
2906 ISP_IOXGET_32(isp, &src->ct_dataseg[i].ds_count, dst->ct_dataseg[i].ds_count);
2907 }
2908 }
2909
2910 void
2911 isp_put_ctio2(ispsoftc_t *isp, ct2_entry_t *src, ct2_entry_t *dst)
2912 {
2913 int i;
2914 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
2915 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
2916 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
2917 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
2918 ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
2919 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
2920 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
2921 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
2922 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
2923 ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
2924 if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
2925 ISP_IOXPUT_32(isp, src->rsp.m0._reserved, &dst->rsp.m0._reserved);
2926 ISP_IOXPUT_16(isp, src->rsp.m0._reserved2, &dst->rsp.m0._reserved2);
2927 ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status, &dst->rsp.m0.ct_scsi_status);
2928 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen, &dst->rsp.m0.ct_xfrlen);
2929 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
2930 for (i = 0; i < ISP_RQDSEG_T2; i++) {
2931 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg[i].ds_base, &dst->rsp.m0.u.ct_dataseg[i].ds_base);
2932 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg[i].ds_count, &dst->rsp.m0.u.ct_dataseg[i].ds_count);
2933 }
2934 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
2935 for (i = 0; i < ISP_RQDSEG_T3; i++) {
2936 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_base, &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
2937 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_basehi, &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
2938 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_count, &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
2939 }
2940 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
2941 ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type, &dst->rsp.m0.u.ct_dslist.ds_type); ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment,
2942 &dst->rsp.m0.u.ct_dslist.ds_segment);
2943 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base, &dst->rsp.m0.u.ct_dslist.ds_base);
2944 }
2945 } else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
2946 ISP_IOXPUT_16(isp, src->rsp.m1._reserved, &dst->rsp.m1._reserved);
2947 ISP_IOXPUT_16(isp, src->rsp.m1._reserved2, &dst->rsp.m1._reserved2);
2948 ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen, &dst->rsp.m1.ct_senselen);
2949 ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status, &dst->rsp.m1.ct_scsi_status);
2950 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen, &dst->rsp.m1.ct_resplen);
2951 for (i = 0; i < MAXRESPLEN; i++) {
2952 ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i], &dst->rsp.m1.ct_resp[i]);
2953 }
2954 } else {
2955 ISP_IOXPUT_32(isp, src->rsp.m2._reserved, &dst->rsp.m2._reserved);
2956 ISP_IOXPUT_16(isp, src->rsp.m2._reserved2, &dst->rsp.m2._reserved2);
2957 ISP_IOXPUT_16(isp, src->rsp.m2._reserved3, &dst->rsp.m2._reserved3);
2958 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen, &dst->rsp.m2.ct_datalen);
2959 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
2960 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
2961 }
2962 }
2963
2964 void
2965 isp_put_ctio2e(ispsoftc_t *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
2966 {
2967 int i;
2968 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
2969 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
2970 ISP_IOXPUT_16(isp, src->ct_iid, &dst->ct_iid);
2971 ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
2972 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
2973 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
2974 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
2975 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
2976 ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
2977 if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
2978 ISP_IOXPUT_32(isp, src->rsp.m0._reserved, &dst->rsp.m0._reserved);
2979 ISP_IOXPUT_16(isp, src->rsp.m0._reserved2, &dst->rsp.m0._reserved2);
2980 ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status, &dst->rsp.m0.ct_scsi_status);
2981 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen, &dst->rsp.m0.ct_xfrlen);
2982 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
2983 for (i = 0; i < ISP_RQDSEG_T2; i++) {
2984 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg[i].ds_base, &dst->rsp.m0.u.ct_dataseg[i].ds_base);
2985 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg[i].ds_count, &dst->rsp.m0.u.ct_dataseg[i].ds_count);
2986 }
2987 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
2988 for (i = 0; i < ISP_RQDSEG_T3; i++) {
2989 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_base, &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
2990 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_basehi, &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
2991 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dataseg64[i].ds_count, &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
2992 }
2993 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
2994 ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type, &dst->rsp.m0.u.ct_dslist.ds_type);
2995 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment, &dst->rsp.m0.u.ct_dslist.ds_segment);
2996 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base, &dst->rsp.m0.u.ct_dslist.ds_base);
2997 }
2998 } else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
2999 ISP_IOXPUT_16(isp, src->rsp.m1._reserved, &dst->rsp.m1._reserved);
3000 ISP_IOXPUT_16(isp, src->rsp.m1._reserved2, &dst->rsp.m1._reserved2);
3001 ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen, &dst->rsp.m1.ct_senselen);
3002 ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status, &dst->rsp.m1.ct_scsi_status);
3003 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen, &dst->rsp.m1.ct_resplen);
3004 for (i = 0; i < MAXRESPLEN; i++) {
3005 ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i], &dst->rsp.m1.ct_resp[i]);
3006 }
3007 } else {
3008 ISP_IOXPUT_32(isp, src->rsp.m2._reserved, &dst->rsp.m2._reserved);
3009 ISP_IOXPUT_16(isp, src->rsp.m2._reserved2, &dst->rsp.m2._reserved2);
3010 ISP_IOXPUT_16(isp, src->rsp.m2._reserved3, &dst->rsp.m2._reserved3);
3011 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen, &dst->rsp.m2.ct_datalen);
3012 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
3013 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
3014 }
3015 }
3016
3017 void
3018 isp_put_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
3019 {
3020 int i;
3021
3022 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
3023 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
3024 ISP_IOXPUT_16(isp, src->ct_nphdl, &dst->ct_nphdl);
3025 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
3026 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
3027 ISP_IOXPUT_8(isp, src->ct_vpidx, &dst->ct_vpidx);
3028 ISP_IOXPUT_8(isp, src->ct_xflags, &dst->ct_xflags);
3029 ISP_IOXPUT_16(isp, src->ct_iid_lo, &dst->ct_iid_lo);
3030 ISP_IOXPUT_8(isp, src->ct_iid_hi, &dst->ct_iid_hi);
3031 ISP_IOXPUT_8(isp, src->ct_reserved, &dst->ct_reserved);
3032 ISP_IOXPUT_32(isp, src->ct_rxid, &dst->ct_rxid);
3033 ISP_IOXPUT_16(isp, src->ct_senselen, &dst->ct_senselen);
3034 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
3035 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
3036 ISP_IOXPUT_16(isp, src->ct_oxid, &dst->ct_oxid);
3037 ISP_IOXPUT_16(isp, src->ct_scsi_status, &dst->ct_scsi_status);
3038 if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
3039 ISP_IOXPUT_32(isp, src->rsp.m0.reloff, &dst->rsp.m0.reloff);
3040 ISP_IOXPUT_32(isp, src->rsp.m0.reserved0, &dst->rsp.m0.reserved0);
3041 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen, &dst->rsp.m0.ct_xfrlen);
3042 ISP_IOXPUT_32(isp, src->rsp.m0.reserved1, &dst->rsp.m0.reserved1);
3043 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_base, &dst->rsp.m0.ds.ds_base);
3044 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_basehi, &dst->rsp.m0.ds.ds_basehi);
3045 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_count, &dst->rsp.m0.ds.ds_count);
3046 } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
3047 uint32_t *a, *b;
3048
3049 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen, &dst->rsp.m1.ct_resplen);
3050 ISP_IOXPUT_16(isp, src->rsp.m1.reserved, &dst->rsp.m1.reserved);
3051 a = (uint32_t *) src->rsp.m1.ct_resp;
3052 b = (uint32_t *) dst->rsp.m1.ct_resp;
3053 for (i = 0; i < (ASIZE(src->rsp.m1.ct_resp) >> 2); i++) {
3054 *b++ = ISP_SWAP32(isp, *a++);
3055 }
3056 } else {
3057 ISP_IOXPUT_32(isp, src->rsp.m2.reserved0, &dst->rsp.m2.reserved0);
3058 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen, &dst->rsp.m2.ct_datalen);
3059 ISP_IOXPUT_32(isp, src->rsp.m2.reserved1, &dst->rsp.m2.reserved1);
3060 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
3061 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
3062 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count, &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
3063 }
3064 }
3065
3066
3067 void
3068 isp_get_ctio2(ispsoftc_t *isp, ct2_entry_t *src, ct2_entry_t *dst)
3069 {
3070 int i;
3071
3072 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
3073 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
3074 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
3075 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
3076 ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
3077 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
3078 ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
3079 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
3080 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
3081 ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
3082 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
3083 if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
3084 ISP_IOXGET_32(isp, &src->rsp.m0._reserved, dst->rsp.m0._reserved);
3085 ISP_IOXGET_16(isp, &src->rsp.m0._reserved2, dst->rsp.m0._reserved2);
3086 ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status, dst->rsp.m0.ct_scsi_status);
3087 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen, dst->rsp.m0.ct_xfrlen);
3088 if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
3089 for (i = 0; i < ISP_RQDSEG_T2; i++) {
3090 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg[i].ds_base, dst->rsp.m0.u.ct_dataseg[i].ds_base);
3091 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg[i].ds_count, dst->rsp.m0.u.ct_dataseg[i].ds_count);
3092 }
3093 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
3094 for (i = 0; i < ISP_RQDSEG_T3; i++) {
3095 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_base, dst->rsp.m0.u.ct_dataseg64[i].ds_base);
3096 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_basehi, dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
3097 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_count, dst->rsp.m0.u.ct_dataseg64[i].ds_count);
3098 }
3099 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
3100 ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type, dst->rsp.m0.u.ct_dslist.ds_type);
3101 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment, dst->rsp.m0.u.ct_dslist.ds_segment);
3102 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base, dst->rsp.m0.u.ct_dslist.ds_base);
3103 }
3104 } else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
3105 ISP_IOXGET_16(isp, &src->rsp.m1._reserved, dst->rsp.m1._reserved);
3106 ISP_IOXGET_16(isp, &src->rsp.m1._reserved2, dst->rsp.m1._reserved2);
3107 ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen, dst->rsp.m1.ct_senselen);
3108 ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status, dst->rsp.m1.ct_scsi_status);
3109 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen, dst->rsp.m1.ct_resplen);
3110 for (i = 0; i < MAXRESPLEN; i++) {
3111 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i], dst->rsp.m1.ct_resp[i]);
3112 }
3113 } else {
3114 ISP_IOXGET_32(isp, &src->rsp.m2._reserved, dst->rsp.m2._reserved);
3115 ISP_IOXGET_16(isp, &src->rsp.m2._reserved2, dst->rsp.m2._reserved2);
3116 ISP_IOXGET_16(isp, &src->rsp.m2._reserved3, dst->rsp.m2._reserved3);
3117 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen, dst->rsp.m2.ct_datalen);
3118 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base, dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
3119 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count, dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
3120 }
3121 }
3122
3123 void
3124 isp_get_ctio2e(ispsoftc_t *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
3125 {
3126 int i;
3127
3128 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
3129 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
3130 ISP_IOXGET_16(isp, &src->ct_iid, dst->ct_iid);
3131 ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
3132 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
3133 ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
3134 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
3135 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
3136 ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
3137 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
3138 if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
3139 ISP_IOXGET_32(isp, &src->rsp.m0._reserved, dst->rsp.m0._reserved);
3140 ISP_IOXGET_16(isp, &src->rsp.m0._reserved2, dst->rsp.m0._reserved2);
3141 ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status, dst->rsp.m0.ct_scsi_status);
3142 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen, dst->rsp.m0.ct_xfrlen);
3143 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
3144 for (i = 0; i < ISP_RQDSEG_T2; i++) {
3145 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg[i].ds_base, dst->rsp.m0.u.ct_dataseg[i].ds_base);
3146 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg[i].ds_count, dst->rsp.m0.u.ct_dataseg[i].ds_count);
3147 }
3148 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
3149 for (i = 0; i < ISP_RQDSEG_T3; i++) {
3150 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_base, dst->rsp.m0.u.ct_dataseg64[i].ds_base);
3151 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_basehi, dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
3152 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dataseg64[i].ds_count, dst->rsp.m0.u.ct_dataseg64[i].ds_count);
3153 }
3154 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
3155 ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type, dst->rsp.m0.u.ct_dslist.ds_type);
3156 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment, dst->rsp.m0.u.ct_dslist.ds_segment);
3157 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base, dst->rsp.m0.u.ct_dslist.ds_base);
3158 }
3159 } else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
3160 ISP_IOXGET_16(isp, &src->rsp.m1._reserved, dst->rsp.m1._reserved);
3161 ISP_IOXGET_16(isp, &src->rsp.m1._reserved2, dst->rsp.m1._reserved2);
3162 ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen, dst->rsp.m1.ct_senselen);
3163 ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status, dst->rsp.m1.ct_scsi_status);
3164 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen, dst->rsp.m1.ct_resplen);
3165 for (i = 0; i < MAXRESPLEN; i++) {
3166 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i], dst->rsp.m1.ct_resp[i]);
3167 }
3168 } else {
3169 ISP_IOXGET_32(isp, &src->rsp.m2._reserved, dst->rsp.m2._reserved);
3170 ISP_IOXGET_16(isp, &src->rsp.m2._reserved2, dst->rsp.m2._reserved2);
3171 ISP_IOXGET_16(isp, &src->rsp.m2._reserved3, dst->rsp.m2._reserved3);
3172 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen, dst->rsp.m2.ct_datalen);
3173 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base, dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
3174 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count, dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
3175 }
3176 }
3177
3178 void
3179 isp_get_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
3180 {
3181 int i;
3182
3183 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
3184 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
3185 ISP_IOXGET_16(isp, &src->ct_nphdl, dst->ct_nphdl);
3186 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
3187 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
3188 ISP_IOXGET_8(isp, &src->ct_vpidx, dst->ct_vpidx);
3189 ISP_IOXGET_8(isp, &src->ct_xflags, dst->ct_xflags);
3190 ISP_IOXGET_16(isp, &src->ct_iid_lo, dst->ct_iid_lo);
3191 ISP_IOXGET_8(isp, &src->ct_iid_hi, dst->ct_iid_hi);
3192 ISP_IOXGET_8(isp, &src->ct_reserved, dst->ct_reserved);
3193 ISP_IOXGET_32(isp, &src->ct_rxid, dst->ct_rxid);
3194 ISP_IOXGET_16(isp, &src->ct_senselen, dst->ct_senselen);
3195 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
3196 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
3197 ISP_IOXGET_16(isp, &src->ct_oxid, dst->ct_oxid);
3198 ISP_IOXGET_16(isp, &src->ct_scsi_status, dst->ct_scsi_status);
3199 if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
3200 ISP_IOXGET_32(isp, &src->rsp.m0.reloff, dst->rsp.m0.reloff);
3201 ISP_IOXGET_32(isp, &src->rsp.m0.reserved0, dst->rsp.m0.reserved0);
3202 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen, dst->rsp.m0.ct_xfrlen);
3203 ISP_IOXGET_32(isp, &src->rsp.m0.reserved1, dst->rsp.m0.reserved1);
3204 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_base, dst->rsp.m0.ds.ds_base);
3205 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_basehi, dst->rsp.m0.ds.ds_basehi);
3206 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_count, dst->rsp.m0.ds.ds_count);
3207 } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
3208 uint32_t *a, *b;
3209
3210 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen, dst->rsp.m1.ct_resplen);
3211 ISP_IOXGET_16(isp, &src->rsp.m1.reserved, dst->rsp.m1.reserved);
3212 a = (uint32_t *) src->rsp.m1.ct_resp;
3213 b = (uint32_t *) dst->rsp.m1.ct_resp;
3214 for (i = 0; i < MAXRESPLEN_24XX; i++) {
3215 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i], dst->rsp.m1.ct_resp[i]);
3216 }
3217 for (i = 0; i < (ASIZE(src->rsp.m1.ct_resp) >> 2); i++) {
3218 *b++ = ISP_SWAP32(isp, *a++);
3219 }
3220 } else {
3221 ISP_IOXGET_32(isp, &src->rsp.m2.reserved0, dst->rsp.m2.reserved0);
3222 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen, dst->rsp.m2.ct_datalen);
3223 ISP_IOXGET_32(isp, &src->rsp.m2.reserved1, dst->rsp.m2.reserved1);
3224 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base, dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
3225 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi, dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
3226 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count, dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
3227 }
3228 }
3229
3230 void
3231 isp_put_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
3232 {
3233 int i;
3234 isp_put_hdr(isp, &lesrc->le_header, &ledst->le_header);
3235 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
3236 if (ISP_IS_SBUS(isp)) {
3237 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
3238 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
3239 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);
3240 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops);
3241 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2);
3242 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status);
3243 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_in_count);
3244 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_cmd_count);
3245 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb7len);
3246 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb6len);
3247 } else {
3248 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_lun);
3249 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_rsvd);
3250 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_ops);
3251 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_tgt);
3252 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_status);
3253 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_reserved2);
3254 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_cmd_count);
3255 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_in_count);
3256 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb6len);
3257 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb7len);
3258 }
3259 ISP_IOXPUT_32(isp, lesrc->le_flags, &ledst->le_flags);
3260 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout);
3261 for (i = 0; i < 20; i++) {
3262 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i], &ledst->le_reserved3[i]);
3263 }
3264 }
3265
3266 void
3267 isp_get_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
3268 {
3269 int i;
3270 isp_get_hdr(isp, &lesrc->le_header, &ledst->le_header);
3271 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
3272 if (ISP_IS_SBUS(isp)) {
3273 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
3274 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
3275 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);
3276 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops);
3277 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2);
3278 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status);
3279 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_in_count);
3280 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_cmd_count);
3281 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb7len);
3282 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb6len);
3283 } else {
3284 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_lun);
3285 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_rsvd);
3286 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_ops);
3287 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_tgt);
3288 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_status);
3289 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_reserved2);
3290 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_cmd_count);
3291 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_in_count);
3292 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb6len);
3293 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb7len);
3294 }
3295 ISP_IOXGET_32(isp, &lesrc->le_flags, ledst->le_flags);
3296 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
3297 for (i = 0; i < 20; i++) {
3298 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i], ledst->le_reserved3[i]);
3299 }
3300 }
3301
3302 void
3303 isp_put_notify(ispsoftc_t *isp, in_entry_t *src, in_entry_t *dst)
3304 {
3305 int i;
3306 isp_put_hdr(isp, &src->in_header, &dst->in_header);
3307 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
3308 if (ISP_IS_SBUS(isp)) {
3309 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_iid);
3310 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_lun);
3311 ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_tgt);
3312 ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_reserved2);
3313 ISP_IOXPUT_8(isp, src->in_status, &dst->in_rsvd2);
3314 ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_status);
3315 ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_type);
3316 ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_val);
3317 } else {
3318 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
3319 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
3320 ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_reserved2);
3321 ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_tgt);
3322 ISP_IOXPUT_8(isp, src->in_status, &dst->in_status);
3323 ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_rsvd2);
3324 ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_val);
3325 ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_type);
3326 }
3327 ISP_IOXPUT_32(isp, src->in_flags, &dst->in_flags);
3328 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
3329 for (i = 0; i < IN_MSGLEN; i++) {
3330 ISP_IOXPUT_8(isp, src->in_msg[i], &dst->in_msg[i]);
3331 }
3332 for (i = 0; i < IN_RSVDLEN; i++) {
3333 ISP_IOXPUT_8(isp, src->in_reserved3[i], &dst->in_reserved3[i]);
3334 }
3335 for (i = 0; i < QLTM_SENSELEN; i++) {
3336 ISP_IOXPUT_8(isp, src->in_sense[i], &dst->in_sense[i]);
3337 }
3338 }
3339
3340 void
3341 isp_get_notify(ispsoftc_t *isp, in_entry_t *src, in_entry_t *dst)
3342 {
3343 int i;
3344 isp_get_hdr(isp, &src->in_header, &dst->in_header);
3345 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
3346 if (ISP_IS_SBUS(isp)) {
3347 ISP_IOXGET_8(isp, &src->in_lun, dst->in_iid);
3348 ISP_IOXGET_8(isp, &src->in_iid, dst->in_lun);
3349 ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_tgt);
3350 ISP_IOXGET_8(isp, &src->in_tgt, dst->in_reserved2);
3351 ISP_IOXGET_8(isp, &src->in_status, dst->in_rsvd2);
3352 ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_status);
3353 ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_type);
3354 ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_val);
3355 } else {
3356 ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
3357 ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
3358 ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_reserved2);
3359 ISP_IOXGET_8(isp, &src->in_tgt, dst->in_tgt);
3360 ISP_IOXGET_8(isp, &src->in_status, dst->in_status);
3361 ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_rsvd2);
3362 ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_val);
3363 ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_type);
3364 }
3365 ISP_IOXGET_32(isp, &src->in_flags, dst->in_flags);
3366 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
3367 for (i = 0; i < IN_MSGLEN; i++) {
3368 ISP_IOXGET_8(isp, &src->in_msg[i], dst->in_msg[i]);
3369 }
3370 for (i = 0; i < IN_RSVDLEN; i++) {
3371 ISP_IOXGET_8(isp, &src->in_reserved3[i], dst->in_reserved3[i]);
3372 }
3373 for (i = 0; i < QLTM_SENSELEN; i++) {
3374 ISP_IOXGET_8(isp, &src->in_sense[i], dst->in_sense[i]);
3375 }
3376 }
3377
3378 void
3379 isp_put_notify_fc(ispsoftc_t *isp, in_fcentry_t *src, in_fcentry_t *dst)
3380 {
3381 isp_put_hdr(isp, &src->in_header, &dst->in_header);
3382 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
3383 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
3384 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
3385 ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
3386 ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
3387 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
3388 ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
3389 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
3390 }
3391
3392 void
3393 isp_put_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *src, in_fcentry_e_t *dst)
3394 {
3395 isp_put_hdr(isp, &src->in_header, &dst->in_header);
3396 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
3397 ISP_IOXPUT_16(isp, src->in_iid, &dst->in_iid);
3398 ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
3399 ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
3400 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
3401 ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
3402 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
3403 }
3404
3405 void
3406 isp_put_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src, in_fcentry_24xx_t *dst)
3407 {
3408 int i;
3409
3410 isp_put_hdr(isp, &src->in_header, &dst->in_header);
3411 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
3412 ISP_IOXPUT_16(isp, src->in_nphdl, &dst->in_nphdl);
3413 ISP_IOXPUT_16(isp, src->in_reserved1, &dst->in_reserved1);
3414 ISP_IOXPUT_16(isp, src->in_flags, &dst->in_flags);
3415 ISP_IOXPUT_16(isp, src->in_srr_rxid, &dst->in_srr_rxid);
3416 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
3417 ISP_IOXPUT_8(isp, src->in_status_subcode, &dst->in_status_subcode);
3418 ISP_IOXPUT_16(isp, src->in_reserved2, &dst->in_reserved2);
3419 ISP_IOXPUT_32(isp, src->in_rxid, &dst->in_rxid);
3420 ISP_IOXPUT_16(isp, src->in_srr_reloff_hi, &dst->in_srr_reloff_hi);
3421 ISP_IOXPUT_16(isp, src->in_srr_reloff_lo, &dst->in_srr_reloff_lo);
3422 ISP_IOXPUT_16(isp, src->in_srr_iu, &dst->in_srr_iu);
3423 ISP_IOXPUT_16(isp, src->in_srr_oxid, &dst->in_srr_oxid);
3424 ISP_IOXPUT_16(isp, src->in_nport_id_hi, &dst->in_nport_id_hi);
3425 ISP_IOXPUT_8(isp, src->in_nport_id_lo, &dst->in_nport_id_lo);
3426 ISP_IOXPUT_8(isp, src->in_reserved3, &dst->in_reserved3);
3427 ISP_IOXPUT_16(isp, src->in_np_handle, &dst->in_np_handle);
3428 for (i = 0; i < ASIZE(src->in_reserved4); i++) {
3429 ISP_IOXPUT_8(isp, src->in_reserved4[i], &dst->in_reserved4[i]);
3430 }
3431 ISP_IOXPUT_8(isp, src->in_reserved5, &dst->in_reserved5);
3432 ISP_IOXPUT_8(isp, src->in_vpidx, &dst->in_vpidx);
3433 ISP_IOXPUT_32(isp, src->in_reserved6, &dst->in_reserved6);
3434 ISP_IOXPUT_16(isp, src->in_portid_lo, &dst->in_portid_lo);
3435 ISP_IOXPUT_8(isp, src->in_portid_hi, &dst->in_portid_hi);
3436 ISP_IOXPUT_8(isp, src->in_reserved7, &dst->in_reserved7);
3437 ISP_IOXPUT_16(isp, src->in_reserved8, &dst->in_reserved8);
3438 ISP_IOXPUT_16(isp, src->in_oxid, &dst->in_oxid);
3439 }
3440
3441 void
3442 isp_get_notify_fc(ispsoftc_t *isp, in_fcentry_t *src, in_fcentry_t *dst)
3443 {
3444 isp_get_hdr(isp, &src->in_header, &dst->in_header);
3445 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
3446 ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
3447 ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
3448 ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
3449 ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
3450 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
3451 ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
3452 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
3453 }
3454
3455 void
3456 isp_get_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *src, in_fcentry_e_t *dst)
3457 {
3458 isp_get_hdr(isp, &src->in_header, &dst->in_header);
3459 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
3460 ISP_IOXGET_16(isp, &src->in_iid, dst->in_iid);
3461 ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
3462 ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
3463 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
3464 ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
3465 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
3466 }
3467
3468 void
3469 isp_get_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src, in_fcentry_24xx_t *dst)
3470 {
3471 int i;
3472
3473 isp_get_hdr(isp, &src->in_header, &dst->in_header);
3474 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
3475 ISP_IOXGET_16(isp, &src->in_nphdl, dst->in_nphdl);
3476 ISP_IOXGET_16(isp, &src->in_reserved1, dst->in_reserved1);
3477 ISP_IOXGET_16(isp, &src->in_flags, dst->in_flags);
3478 ISP_IOXGET_16(isp, &src->in_srr_rxid, dst->in_srr_rxid);
3479 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
3480 ISP_IOXGET_8(isp, &src->in_status_subcode, dst->in_status_subcode);
3481 ISP_IOXGET_16(isp, &src->in_reserved2, dst->in_reserved2);
3482 ISP_IOXGET_32(isp, &src->in_rxid, dst->in_rxid);
3483 ISP_IOXGET_16(isp, &src->in_srr_reloff_hi, dst->in_srr_reloff_hi);
3484 ISP_IOXGET_16(isp, &src->in_srr_reloff_lo, dst->in_srr_reloff_lo);
3485 ISP_IOXGET_16(isp, &src->in_srr_iu, dst->in_srr_iu);
3486 ISP_IOXGET_16(isp, &src->in_srr_oxid, dst->in_srr_oxid);
3487 ISP_IOXGET_16(isp, &src->in_nport_id_hi, dst->in_nport_id_hi);
3488 ISP_IOXGET_8(isp, &src->in_nport_id_lo, dst->in_nport_id_lo);
3489 ISP_IOXGET_8(isp, &src->in_reserved3, dst->in_reserved3);
3490 ISP_IOXGET_16(isp, &src->in_np_handle, dst->in_np_handle);
3491 for (i = 0; i < ASIZE(src->in_reserved4); i++) {
3492 ISP_IOXGET_8(isp, &src->in_reserved4[i], dst->in_reserved4[i]);
3493 }
3494 ISP_IOXGET_8(isp, &src->in_reserved5, dst->in_reserved5);
3495 ISP_IOXGET_8(isp, &src->in_vpidx, dst->in_vpidx);
3496 ISP_IOXGET_32(isp, &src->in_reserved6, dst->in_reserved6);
3497 ISP_IOXGET_16(isp, &src->in_portid_lo, dst->in_portid_lo);
3498 ISP_IOXGET_8(isp, &src->in_portid_hi, dst->in_portid_hi);
3499 ISP_IOXGET_8(isp, &src->in_reserved7, dst->in_reserved7);
3500 ISP_IOXGET_16(isp, &src->in_reserved8, dst->in_reserved8);
3501 ISP_IOXGET_16(isp, &src->in_oxid, dst->in_oxid);
3502 }
3503
3504 void
3505 isp_put_notify_ack(ispsoftc_t *isp, na_entry_t *src, na_entry_t *dst)
3506 {
3507 int i;
3508 isp_put_hdr(isp, &src->na_header, &dst->na_header);
3509 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
3510 if (ISP_IS_SBUS(isp)) {
3511 ISP_IOXPUT_8(isp, src->na_lun, &dst->na_iid);
3512 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_lun);
3513 ISP_IOXPUT_8(isp, src->na_status, &dst->na_event);
3514 ISP_IOXPUT_8(isp, src->na_event, &dst->na_status);
3515 } else {
3516 ISP_IOXPUT_8(isp, src->na_lun, &dst->na_lun);
3517 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
3518 ISP_IOXPUT_8(isp, src->na_status, &dst->na_status);
3519 ISP_IOXPUT_8(isp, src->na_event, &dst->na_event);
3520 }
3521 ISP_IOXPUT_32(isp, src->na_flags, &dst->na_flags);
3522 for (i = 0; i < NA_RSVDLEN; i++) {
3523 ISP_IOXPUT_16(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
3524 }
3525 }
3526
3527 void
3528 isp_get_notify_ack(ispsoftc_t *isp, na_entry_t *src, na_entry_t *dst)
3529 {
3530 int i;
3531 isp_get_hdr(isp, &src->na_header, &dst->na_header);
3532 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
3533 if (ISP_IS_SBUS(isp)) {
3534 ISP_IOXGET_8(isp, &src->na_lun, dst->na_iid);
3535 ISP_IOXGET_8(isp, &src->na_iid, dst->na_lun);
3536 ISP_IOXGET_8(isp, &src->na_status, dst->na_event);
3537 ISP_IOXGET_8(isp, &src->na_event, dst->na_status);
3538 } else {
3539 ISP_IOXGET_8(isp, &src->na_lun, dst->na_lun);
3540 ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
3541 ISP_IOXGET_8(isp, &src->na_status, dst->na_status);
3542 ISP_IOXGET_8(isp, &src->na_event, dst->na_event);
3543 }
3544 ISP_IOXGET_32(isp, &src->na_flags, dst->na_flags);
3545 for (i = 0; i < NA_RSVDLEN; i++) {
3546 ISP_IOXGET_16(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
3547 }
3548 }
3549
3550 void
3551 isp_put_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *src, na_fcentry_t *dst)
3552 {
3553 int i;
3554 isp_put_hdr(isp, &src->na_header, &dst->na_header);
3555 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
3556 ISP_IOXPUT_8(isp, src->na_reserved1, &dst->na_reserved1);
3557 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
3558 ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
3559 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
3560 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
3561 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
3562 ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
3563 ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
3564 for (i = 0; i < NA2_RSVDLEN; i++) {
3565 ISP_IOXPUT_16(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
3566 }
3567 }
3568
3569 void
3570 isp_put_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *src, na_fcentry_e_t *dst)
3571 {
3572 int i;
3573 isp_put_hdr(isp, &src->na_header, &dst->na_header);
3574 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
3575 ISP_IOXPUT_16(isp, src->na_iid, &dst->na_iid);
3576 ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
3577 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
3578 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
3579 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
3580 ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
3581 ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
3582 for (i = 0; i < NA2_RSVDLEN; i++) {
3583 ISP_IOXPUT_16(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
3584 }
3585 }
3586
3587 void
3588 isp_put_notify_24xx_ack(ispsoftc_t *isp, na_fcentry_24xx_t *src, na_fcentry_24xx_t *dst)
3589 {
3590 int i;
3591
3592 isp_put_hdr(isp, &src->na_header, &dst->na_header);
3593 ISP_IOXPUT_32(isp, src->na_handle, &dst->na_handle);
3594 ISP_IOXPUT_16(isp, src->na_nphdl, &dst->na_nphdl);
3595 ISP_IOXPUT_16(isp, src->na_reserved1, &dst->na_reserved1);
3596 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
3597 ISP_IOXPUT_16(isp, src->na_srr_rxid, &dst->na_srr_rxid);
3598 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
3599 ISP_IOXPUT_8(isp, src->na_status_subcode, &dst->na_status_subcode);
3600 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
3601 ISP_IOXPUT_32(isp, src->na_rxid, &dst->na_rxid);
3602 ISP_IOXPUT_16(isp, src->na_srr_reloff_hi, &dst->na_srr_reloff_hi);
3603 ISP_IOXPUT_16(isp, src->na_srr_reloff_lo, &dst->na_srr_reloff_lo);
3604 ISP_IOXPUT_16(isp, src->na_srr_iu, &dst->na_srr_iu);
3605 ISP_IOXPUT_16(isp, src->na_srr_flags, &dst->na_srr_flags);
3606 for (i = 0; i < 18; i++) {
3607 ISP_IOXPUT_8(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
3608 }
3609 ISP_IOXPUT_8(isp, src->na_reserved4, &dst->na_reserved4);
3610 ISP_IOXPUT_8(isp, src->na_vpidx, &dst->na_vpidx);
3611 ISP_IOXPUT_8(isp, src->na_srr_reject_vunique, &dst->na_srr_reject_vunique);
3612 ISP_IOXPUT_8(isp, src->na_srr_reject_explanation, &dst->na_srr_reject_explanation);
3613 ISP_IOXPUT_8(isp, src->na_srr_reject_code, &dst->na_srr_reject_code);
3614 ISP_IOXPUT_8(isp, src->na_reserved5, &dst->na_reserved5);
3615 for (i = 0; i < 6; i++) {
3616 ISP_IOXPUT_8(isp, src->na_reserved6[i], &dst->na_reserved6[i]);
3617 }
3618 ISP_IOXPUT_16(isp, src->na_oxid, &dst->na_oxid);
3619 }
3620
3621 void
3622 isp_get_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *src, na_fcentry_t *dst)
3623 {
3624 int i;
3625 isp_get_hdr(isp, &src->na_header, &dst->na_header);
3626 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
3627 ISP_IOXGET_8(isp, &src->na_reserved1, dst->na_reserved1);
3628 ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
3629 ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
3630 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
3631 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
3632 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
3633 ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
3634 ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
3635 for (i = 0; i < NA2_RSVDLEN; i++) {
3636 ISP_IOXGET_16(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
3637 }
3638 }
3639
3640 void
3641 isp_get_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *src, na_fcentry_e_t *dst)
3642 {
3643 int i;
3644 isp_get_hdr(isp, &src->na_header, &dst->na_header);
3645 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
3646 ISP_IOXGET_16(isp, &src->na_iid, dst->na_iid);
3647 ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
3648 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
3649 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
3650 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
3651 ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
3652 ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
3653 for (i = 0; i < NA2_RSVDLEN; i++) {
3654 ISP_IOXGET_16(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
3655 }
3656 }
3657
3658 void
3659 isp_get_notify_ack_24xx(ispsoftc_t *isp, na_fcentry_24xx_t *src, na_fcentry_24xx_t *dst)
3660 {
3661 int i;
3662
3663 isp_get_hdr(isp, &src->na_header, &dst->na_header);
3664 ISP_IOXGET_32(isp, &src->na_handle, dst->na_handle);
3665 ISP_IOXGET_16(isp, &src->na_nphdl, dst->na_nphdl);
3666 ISP_IOXGET_16(isp, &src->na_reserved1, dst->na_reserved1);
3667 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
3668 ISP_IOXGET_16(isp, &src->na_srr_rxid, dst->na_srr_rxid);
3669 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
3670 ISP_IOXGET_8(isp, &src->na_status_subcode, dst->na_status_subcode);
3671 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
3672 ISP_IOXGET_32(isp, &src->na_rxid, dst->na_rxid);
3673 ISP_IOXGET_16(isp, &src->na_srr_reloff_hi, dst->na_srr_reloff_hi);
3674 ISP_IOXGET_16(isp, &src->na_srr_reloff_lo, dst->na_srr_reloff_lo);
3675 ISP_IOXGET_16(isp, &src->na_srr_iu, dst->na_srr_iu);
3676 ISP_IOXGET_16(isp, &src->na_srr_flags, dst->na_srr_flags);
3677 for (i = 0; i < 18; i++) {
3678 ISP_IOXGET_8(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
3679 }
3680 ISP_IOXGET_8(isp, &src->na_reserved4, dst->na_reserved4);
3681 ISP_IOXGET_8(isp, &src->na_vpidx, dst->na_vpidx);
3682 ISP_IOXGET_8(isp, &src->na_srr_reject_vunique, dst->na_srr_reject_vunique);
3683 ISP_IOXGET_8(isp, &src->na_srr_reject_explanation, dst->na_srr_reject_explanation);
3684 ISP_IOXGET_8(isp, &src->na_srr_reject_code, dst->na_srr_reject_code);
3685 ISP_IOXGET_8(isp, &src->na_reserved5, dst->na_reserved5);
3686 for (i = 0; i < 6; i++) {
3687 ISP_IOXGET_8(isp, &src->na_reserved6[i], dst->na_reserved6[i]);
3688 }
3689 ISP_IOXGET_16(isp, &src->na_oxid, dst->na_oxid);
3690 }
3691
3692 void
3693 isp_get_abts(ispsoftc_t *isp, abts_t *src, abts_t *dst)
3694 {
3695 int i;
3696
3697 isp_get_hdr(isp, &src->abts_header, &dst->abts_header);
3698 for (i = 0; i < 6; i++) {
3699 ISP_IOXGET_8(isp, &src->abts_reserved0[i], dst->abts_reserved0[i]);
3700 }
3701 ISP_IOXGET_16(isp, &src->abts_nphdl, dst->abts_nphdl);
3702 ISP_IOXGET_16(isp, &src->abts_reserved1, dst->abts_reserved1);
3703 ISP_IOXGET_16(isp, &src->abts_sof, dst->abts_sof);
3704 ISP_IOXGET_32(isp, &src->abts_rxid_abts, dst->abts_rxid_abts);
3705 ISP_IOXGET_16(isp, &src->abts_did_lo, dst->abts_did_lo);
3706 ISP_IOXGET_8(isp, &src->abts_did_hi, dst->abts_did_hi);
3707 ISP_IOXGET_8(isp, &src->abts_r_ctl, dst->abts_r_ctl);
3708 ISP_IOXGET_16(isp, &src->abts_sid_lo, dst->abts_sid_lo);
3709 ISP_IOXGET_8(isp, &src->abts_sid_hi, dst->abts_sid_hi);
3710 ISP_IOXGET_8(isp, &src->abts_cs_ctl, dst->abts_cs_ctl);
3711 ISP_IOXGET_16(isp, &src->abts_fs_ctl, dst->abts_fs_ctl);
3712 ISP_IOXGET_8(isp, &src->abts_f_ctl, dst->abts_f_ctl);
3713 ISP_IOXGET_8(isp, &src->abts_type, dst->abts_type);
3714 ISP_IOXGET_16(isp, &src->abts_seq_cnt, dst->abts_seq_cnt);
3715 ISP_IOXGET_8(isp, &src->abts_df_ctl, dst->abts_df_ctl);
3716 ISP_IOXGET_8(isp, &src->abts_seq_id, dst->abts_seq_id);
3717 ISP_IOXGET_16(isp, &src->abts_rx_id, dst->abts_rx_id);
3718 ISP_IOXGET_16(isp, &src->abts_ox_id, dst->abts_ox_id);
3719 ISP_IOXGET_32(isp, &src->abts_param, dst->abts_param);
3720 for (i = 0; i < 16; i++) {
3721 ISP_IOXGET_8(isp, &src->abts_reserved2[i], dst->abts_reserved2[i]);
3722 }
3723 ISP_IOXGET_32(isp, &src->abts_rxid_task, dst->abts_rxid_task);
3724 }
3725
3726 void
3727 isp_put_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
3728 {
3729 int i;
3730
3731 isp_put_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
3732 ISP_IOXPUT_32(isp, src->abts_rsp_handle, &dst->abts_rsp_handle);
3733 ISP_IOXPUT_16(isp, src->abts_rsp_status, &dst->abts_rsp_status);
3734 ISP_IOXPUT_16(isp, src->abts_rsp_nphdl, &dst->abts_rsp_nphdl);
3735 ISP_IOXPUT_16(isp, src->abts_rsp_ctl_flags, &dst->abts_rsp_ctl_flags);
3736 ISP_IOXPUT_16(isp, src->abts_rsp_sof, &dst->abts_rsp_sof);
3737 ISP_IOXPUT_32(isp, src->abts_rsp_rxid_abts, &dst->abts_rsp_rxid_abts);
3738 ISP_IOXPUT_16(isp, src->abts_rsp_did_lo, &dst->abts_rsp_did_lo);
3739 ISP_IOXPUT_8(isp, src->abts_rsp_did_hi, &dst->abts_rsp_did_hi);
3740 ISP_IOXPUT_8(isp, src->abts_rsp_r_ctl, &dst->abts_rsp_r_ctl);
3741 ISP_IOXPUT_16(isp, src->abts_rsp_sid_lo, &dst->abts_rsp_sid_lo);
3742 ISP_IOXPUT_8(isp, src->abts_rsp_sid_hi, &dst->abts_rsp_sid_hi);
3743 ISP_IOXPUT_8(isp, src->abts_rsp_cs_ctl, &dst->abts_rsp_cs_ctl);
3744 ISP_IOXPUT_16(isp, src->abts_rsp_f_ctl_lo, &dst->abts_rsp_f_ctl_lo);
3745 ISP_IOXPUT_8(isp, src->abts_rsp_f_ctl_hi, &dst->abts_rsp_f_ctl_hi);
3746 ISP_IOXPUT_8(isp, src->abts_rsp_type, &dst->abts_rsp_type);
3747 ISP_IOXPUT_16(isp, src->abts_rsp_seq_cnt, &dst->abts_rsp_seq_cnt);
3748 ISP_IOXPUT_8(isp, src->abts_rsp_df_ctl, &dst->abts_rsp_df_ctl);
3749 ISP_IOXPUT_8(isp, src->abts_rsp_seq_id, &dst->abts_rsp_seq_id);
3750 ISP_IOXPUT_16(isp, src->abts_rsp_rx_id, &dst->abts_rsp_rx_id);
3751 ISP_IOXPUT_16(isp, src->abts_rsp_ox_id, &dst->abts_rsp_ox_id);
3752 ISP_IOXPUT_32(isp, src->abts_rsp_param, &dst->abts_rsp_param);
3753 if (src->abts_rsp_r_ctl == BA_ACC) {
3754 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved, &dst->abts_rsp_payload.ba_acc.reserved);
3755 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.last_seq_id, &dst->abts_rsp_payload.ba_acc.last_seq_id);
3756 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.seq_id_valid, &dst->abts_rsp_payload.ba_acc.seq_id_valid);
3757 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_rx_id, &dst->abts_rsp_payload.ba_acc.aborted_rx_id);
3758 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_ox_id, &dst->abts_rsp_payload.ba_acc.aborted_ox_id);
3759 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.high_seq_cnt, &dst->abts_rsp_payload.ba_acc.high_seq_cnt);
3760 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.low_seq_cnt, &dst->abts_rsp_payload.ba_acc.low_seq_cnt);
3761 for (i = 0; i < 4; i++) {
3762 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved2[i], &dst->abts_rsp_payload.ba_acc.reserved2[i]);
3763 }
3764 } else if (src->abts_rsp_r_ctl == BA_RJT) {
3765 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.vendor_unique, &dst->abts_rsp_payload.ba_rjt.vendor_unique);
3766 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.explanation, &dst->abts_rsp_payload.ba_rjt.explanation);
3767 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reason, &dst->abts_rsp_payload.ba_rjt.reason);
3768 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reserved, &dst->abts_rsp_payload.ba_rjt.reserved);
3769 for (i = 0; i < 12; i++) {
3770 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_rjt.reserved2[i], &dst->abts_rsp_payload.ba_rjt.reserved2[i]);
3771 }
3772 } else {
3773 for (i = 0; i < 16; i++) {
3774 ISP_IOXPUT_8(isp, src->abts_rsp_payload.reserved[i], &dst->abts_rsp_payload.reserved[i]);
3775 }
3776 }
3777 ISP_IOXPUT_32(isp, src->abts_rsp_rxid_task, &dst->abts_rsp_rxid_task);
3778 }
3779
3780 void
3781 isp_get_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
3782 {
3783 int i;
3784
3785 isp_get_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
3786 ISP_IOXGET_32(isp, &src->abts_rsp_handle, dst->abts_rsp_handle);
3787 ISP_IOXGET_16(isp, &src->abts_rsp_status, dst->abts_rsp_status);
3788 ISP_IOXGET_16(isp, &src->abts_rsp_nphdl, dst->abts_rsp_nphdl);
3789 ISP_IOXGET_16(isp, &src->abts_rsp_ctl_flags, dst->abts_rsp_ctl_flags);
3790 ISP_IOXGET_16(isp, &src->abts_rsp_sof, dst->abts_rsp_sof);
3791 ISP_IOXGET_32(isp, &src->abts_rsp_rxid_abts, dst->abts_rsp_rxid_abts);
3792 ISP_IOXGET_16(isp, &src->abts_rsp_did_lo, dst->abts_rsp_did_lo);
3793 ISP_IOXGET_8(isp, &src->abts_rsp_did_hi, dst->abts_rsp_did_hi);
3794 ISP_IOXGET_8(isp, &src->abts_rsp_r_ctl, dst->abts_rsp_r_ctl);
3795 ISP_IOXGET_16(isp, &src->abts_rsp_sid_lo, dst->abts_rsp_sid_lo);
3796 ISP_IOXGET_8(isp, &src->abts_rsp_sid_hi, dst->abts_rsp_sid_hi);
3797 ISP_IOXGET_8(isp, &src->abts_rsp_cs_ctl, dst->abts_rsp_cs_ctl);
3798 ISP_IOXGET_16(isp, &src->abts_rsp_f_ctl_lo, dst->abts_rsp_f_ctl_lo);
3799 ISP_IOXGET_8(isp, &src->abts_rsp_f_ctl_hi, dst->abts_rsp_f_ctl_hi);
3800 ISP_IOXGET_8(isp, &src->abts_rsp_type, dst->abts_rsp_type);
3801 ISP_IOXGET_16(isp, &src->abts_rsp_seq_cnt, dst->abts_rsp_seq_cnt);
3802 ISP_IOXGET_8(isp, &src->abts_rsp_df_ctl, dst->abts_rsp_df_ctl);
3803 ISP_IOXGET_8(isp, &src->abts_rsp_seq_id, dst->abts_rsp_seq_id);
3804 ISP_IOXGET_16(isp, &src->abts_rsp_rx_id, dst->abts_rsp_rx_id);
3805 ISP_IOXGET_16(isp, &src->abts_rsp_ox_id, dst->abts_rsp_ox_id);
3806 ISP_IOXGET_32(isp, &src->abts_rsp_param, dst->abts_rsp_param);
3807 for (i = 0; i < 8; i++) {
3808 ISP_IOXGET_8(isp, &src->abts_rsp_payload.rsp.reserved[i], dst->abts_rsp_payload.rsp.reserved[i]);
3809 }
3810 ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode1, dst->abts_rsp_payload.rsp.subcode1);
3811 ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode2, dst->abts_rsp_payload.rsp.subcode2);
3812 ISP_IOXGET_32(isp, &src->abts_rsp_rxid_task, dst->abts_rsp_rxid_task);
3813 }
3814 #endif /* ISP_TARGET_MODE */
3815 /*
3816 * vim:ts=8:sw=8
3817 */
DragonFly BSD