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