Deleted Added
sdiff udiff text old ( 160978 ) new ( 163899 )
full compact
isp_library.c (160978) isp_library.c (163899)
1/*-
2 * Copyright (c) 1999-2006 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 18 unchanged lines hidden (view full) ---

27/*
28 * Qlogic Host Adapter Internal Library Functions
29 */
30#ifdef __NetBSD__
31#include <dev/ic/isp_netbsd.h>
32#endif
33#ifdef __FreeBSD__
34#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1999-2006 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 18 unchanged lines hidden (view full) ---

27/*
28 * Qlogic Host Adapter Internal Library Functions
29 */
30#ifdef __NetBSD__
31#include <dev/ic/isp_netbsd.h>
32#endif
33#ifdef __FreeBSD__
34#include <sys/cdefs.h>
35__FBSDID("$FreeBSD: head/sys/dev/isp/isp_library.c 160978 2006-08-04 20:20:00Z mjacob $");
35__FBSDID("$FreeBSD: head/sys/dev/isp/isp_library.c 163899 2006-11-02 03:21:32Z mjacob $");
36#include <dev/isp/isp_freebsd.h>
37#endif
38#ifdef __OpenBSD__
39#include <dev/ic/isp_openbsd.h>
40#endif
41#ifdef __linux__
42#include "isp_linux.h"
43#endif
44#ifdef __svr4__
45#include "isp_solaris.h"
46#endif
47
48int
36#include <dev/isp/isp_freebsd.h>
37#endif
38#ifdef __OpenBSD__
39#include <dev/ic/isp_openbsd.h>
40#endif
41#ifdef __linux__
42#include "isp_linux.h"
43#endif
44#ifdef __svr4__
45#include "isp_solaris.h"
46#endif
47
48int
49isp_save_xs(ispsoftc_t *isp, XS_T *xs, uint16_t *handlep)
49isp_save_xs(ispsoftc_t *isp, XS_T *xs, uint32_t *handlep)
50{
50{
51 int i, j;
51 uint16_t i, j;
52
52
53 for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) {
53 for (j = isp->isp_lasthdls, i = 0; i < isp->isp_maxcmds; i++) {
54 if (isp->isp_xflist[j] == NULL) {
55 break;
56 }
57 if (++j == isp->isp_maxcmds) {
58 j = 0;
59 }
60 }
61 if (i == isp->isp_maxcmds) {
62 return (-1);
63 }
64 isp->isp_xflist[j] = xs;
65 *handlep = j+1;
54 if (isp->isp_xflist[j] == NULL) {
55 break;
56 }
57 if (++j == isp->isp_maxcmds) {
58 j = 0;
59 }
60 }
61 if (i == isp->isp_maxcmds) {
62 return (-1);
63 }
64 isp->isp_xflist[j] = xs;
65 *handlep = j+1;
66 if (++j == isp->isp_maxcmds)
66 if (++j == isp->isp_maxcmds) {
67 j = 0;
67 j = 0;
68 isp->isp_lasthdls = (uint16_t)j;
68 }
69 isp->isp_lasthdls = (uint32_t)j;
69 return (0);
70}
71
72XS_T *
70 return (0);
71}
72
73XS_T *
73isp_find_xs(ispsoftc_t *isp, uint16_t handle)
74isp_find_xs(ispsoftc_t *isp, uint32_t handle)
74{
75{
75 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) {
76 if (handle < 1 || handle > (uint32_t) isp->isp_maxcmds) {
76 return (NULL);
77 } else {
78 return (isp->isp_xflist[handle - 1]);
79 }
80}
81
77 return (NULL);
78 } else {
79 return (isp->isp_xflist[handle - 1]);
80 }
81}
82
82uint16_t
83uint32_t
83isp_find_handle(ispsoftc_t *isp, XS_T *xs)
84{
84isp_find_handle(ispsoftc_t *isp, XS_T *xs)
85{
85 int i;
86 uint16_t i;
86 if (xs != NULL) {
87 for (i = 0; i < isp->isp_maxcmds; i++) {
88 if (isp->isp_xflist[i] == xs) {
87 if (xs != NULL) {
88 for (i = 0; i < isp->isp_maxcmds; i++) {
89 if (isp->isp_xflist[i] == xs) {
89 return ((uint16_t) i+1);
90 return ((uint32_t) (i+1));
90 }
91 }
92 }
93 return (0);
94}
95
91 }
92 }
93 }
94 return (0);
95}
96
96int
97isp_handle_index(uint16_t handle)
97uint32_t
98isp_handle_index(uint32_t handle)
98{
99{
99 return (handle-1);
100 return (handle - 1);
100}
101
101}
102
102uint16_t
103isp_index_handle(int index)
104{
105 return (index+1);
106}
107
108void
103void
109isp_destroy_handle(ispsoftc_t *isp, uint16_t handle)
104isp_destroy_handle(ispsoftc_t *isp, uint32_t handle)
110{
105{
111 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) {
106 if (handle > 0 && handle <= (uint32_t) isp->isp_maxcmds) {
112 isp->isp_xflist[handle - 1] = NULL;
113 }
114}
115
116int
107 isp->isp_xflist[handle - 1] = NULL;
108 }
109}
110
111int
117isp_getrqentry(ispsoftc_t *isp, uint16_t *iptrp,
118 uint16_t *optrp, void **resultp)
112isp_getrqentry(ispsoftc_t *isp, uint32_t *iptrp,
113 uint32_t *optrp, void **resultp)
119{
114{
120 volatile uint16_t iptr, optr;
115 volatile uint32_t iptr, optr;
121
116
122 optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
117 optr = isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
123 iptr = isp->isp_reqidx;
124 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
125 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
126 if (iptr == optr) {
127 return (1);
128 }
129 if (optrp)
130 *optrp = optr;

--- 49 unchanged lines hidden (view full) ---

180 * Do the common path to try and ensure that link is up, we've scanned
181 * the fabric (if we're on a fabric), and that we've synchronized this
182 * all with our own database and done the appropriate logins.
183 *
184 * We repeatedly check for firmware state and loop state after each
185 * action because things may have changed while we were doing this.
186 * Any failure or change of state causes us to return a nonzero value.
187 *
118 iptr = isp->isp_reqidx;
119 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
120 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
121 if (iptr == optr) {
122 return (1);
123 }
124 if (optrp)
125 *optrp = optr;

--- 49 unchanged lines hidden (view full) ---

175 * Do the common path to try and ensure that link is up, we've scanned
176 * the fabric (if we're on a fabric), and that we've synchronized this
177 * all with our own database and done the appropriate logins.
178 *
179 * We repeatedly check for firmware state and loop state after each
180 * action because things may have changed while we were doing this.
181 * Any failure or change of state causes us to return a nonzero value.
182 *
188 * We honor HBA roles in that if we're not in Initiator mode, we don't
189 * attempt to sync up the database (that's for somebody else to do,
190 * if ever).
191 *
192 * We assume we enter here with any locks held.
193 */
194
195int
196isp_fc_runstate(ispsoftc_t *isp, int tval)
197{
198 fcparam *fcp;
199 int *tptr;
200
183 * We assume we enter here with any locks held.
184 */
185
186int
187isp_fc_runstate(ispsoftc_t *isp, int tval)
188{
189 fcparam *fcp;
190 int *tptr;
191
201 if (IS_SCSI(isp))
192 if (isp->isp_role == ISP_ROLE_NONE) {
202 return (0);
193 return (0);
203
204 tptr = &tval;
205 if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) {
206 return (-1);
207 }
208 fcp = FCPARAM(isp);
194 }
195 fcp = FCPARAM(isp);
209 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD)
210 return (-1);
211 if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) {
212 return (-1);
196 tptr = &tval;
197 if (fcp->isp_fwstate < FW_READY ||
198 fcp->isp_loopstate < LOOP_PDB_RCVD) {
199 if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) {
200 isp_prt(isp, ISP_LOGINFO,
201 "isp_fc_runstate: linktest failed");
202 return (-1);
203 }
204 if (fcp->isp_fwstate != FW_READY ||
205 fcp->isp_loopstate < LOOP_PDB_RCVD) {
206 isp_prt(isp, ISP_LOGINFO,
207 "isp_fc_runstate: f/w not ready");
208 return (-1);
209 }
213 }
210 }
214 if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) {
215 return (-1);
216 }
217 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
218 return (0);
219 }
211 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
212 return (0);
213 }
214 if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) {
215 isp_prt(isp, ISP_LOGINFO,
216 "isp_fc_runstate: scan loop fails");
217 return (LOOP_PDB_RCVD);
218 }
219 if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) {
220 isp_prt(isp, ISP_LOGINFO,
221 "isp_fc_runstate: scan fabric fails");
222 return (LOOP_LSCAN_DONE);
223 }
220 if (isp_control(isp, ISPCTL_PDB_SYNC, NULL) != 0) {
224 if (isp_control(isp, ISPCTL_PDB_SYNC, NULL) != 0) {
221 return (-1);
225 isp_prt(isp, ISP_LOGINFO, "isp_fc_runstate: pdb_sync fails");
226 return (LOOP_FSCAN_DONE);
222 }
223 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
227 }
228 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
229 isp_prt(isp, ISP_LOGINFO,
230 "isp_fc_runstate: f/w not ready again");
224 return (-1);
225 }
226 return (0);
227}
228
231 return (-1);
232 }
233 return (0);
234}
235
236void
237isp_shutdown(ispsoftc_t *isp)
238{
239 if (IS_FC(isp)) {
240 if (IS_24XX(isp)) {
241 ISP_WRITE(isp, BIU2400_ICR, 0);
242 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
243 } else {
244 ISP_WRITE(isp, BIU_ICR, 0);
245 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
246 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
247 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
248 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
249 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
250 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
251 }
252 } else {
253 ISP_WRITE(isp, BIU_ICR, 0);
254 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
255 }
256}
257
229/*
230 * Functions to move stuff to a form that the QLogic RISC engine understands
231 * and functions to move stuff back to a form the processor understands.
232 *
233 * Each platform is required to provide the 8, 16 and 32 bit
234 * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32})
235 *
236 * The assumption is that swizzling and unswizzling is mostly done 'in place'
237 * (with a few exceptions for efficiency).
238 */
239
240#define ISP_IS_SBUS(isp) \
241 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
242
258/*
259 * Functions to move stuff to a form that the QLogic RISC engine understands
260 * and functions to move stuff back to a form the processor understands.
261 *
262 * Each platform is required to provide the 8, 16 and 32 bit
263 * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32})
264 *
265 * The assumption is that swizzling and unswizzling is mostly done 'in place'
266 * (with a few exceptions for efficiency).
267 */
268
269#define ISP_IS_SBUS(isp) \
270 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
271
272#define ASIZE(x) (sizeof (x) / sizeof (x[0]))
243/*
244 * Swizzle/Copy Functions
245 */
246void
273/*
274 * Swizzle/Copy Functions
275 */
276void
247isp_copy_out_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
277isp_put_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
248{
249 if (ISP_IS_SBUS(isp)) {
250 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
251 &hpdst->rqs_entry_count);
252 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
253 &hpdst->rqs_entry_type);
254 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
255 &hpdst->rqs_flags);

--- 7 unchanged lines hidden (view full) ---

263 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
264 &hpdst->rqs_seqno);
265 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
266 &hpdst->rqs_flags);
267 }
268}
269
270void
278{
279 if (ISP_IS_SBUS(isp)) {
280 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
281 &hpdst->rqs_entry_count);
282 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
283 &hpdst->rqs_entry_type);
284 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
285 &hpdst->rqs_flags);

--- 7 unchanged lines hidden (view full) ---

293 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
294 &hpdst->rqs_seqno);
295 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
296 &hpdst->rqs_flags);
297 }
298}
299
300void
271isp_copy_in_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
301isp_get_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
272{
273 if (ISP_IS_SBUS(isp)) {
274 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
275 hpdst->rqs_entry_count);
276 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
277 hpdst->rqs_entry_type);
278 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
279 hpdst->rqs_flags);

--- 22 unchanged lines hidden (view full) ---

302 }
303 return ((int)type);
304}
305
306void
307isp_put_request(ispsoftc_t *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
308{
309 int i;
302{
303 if (ISP_IS_SBUS(isp)) {
304 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
305 hpdst->rqs_entry_count);
306 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
307 hpdst->rqs_entry_type);
308 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
309 hpdst->rqs_flags);

--- 22 unchanged lines hidden (view full) ---

332 }
333 return ((int)type);
334}
335
336void
337isp_put_request(ispsoftc_t *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
338{
339 int i;
310 isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
340 isp_put_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
311 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
312 if (ISP_IS_SBUS(isp)) {
313 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
314 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
315 } else {
316 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn);
317 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target);
318 }
319 ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen);
320 ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
321 ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
322 ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
341 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
342 if (ISP_IS_SBUS(isp)) {
343 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
344 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
345 } else {
346 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn);
347 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target);
348 }
349 ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen);
350 ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
351 ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
352 ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
323 for (i = 0; i < 12; i++) {
353 for (i = 0; i < ASIZE(rqsrc->req_cdb); i++) {
324 ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
325 }
326 for (i = 0; i < ISP_RQDSEG; i++) {
327 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
328 &rqdst->req_dataseg[i].ds_base);
329 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
330 &rqdst->req_dataseg[i].ds_count);
331 }
332}
333
334void
354 ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
355 }
356 for (i = 0; i < ISP_RQDSEG; i++) {
357 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
358 &rqdst->req_dataseg[i].ds_base);
359 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
360 &rqdst->req_dataseg[i].ds_count);
361 }
362}
363
364void
335isp_put_request_t2(ispsoftc_t *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
365isp_put_marker(ispsoftc_t *isp, isp_marker_t *src, isp_marker_t *dst)
336{
337 int i;
366{
367 int i;
338 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
339 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
340 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
341 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
342 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
343 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
344 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
345 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
346 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
347 for (i = 0; i < 16; i++) {
348 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
368 isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
369 ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
370 if (ISP_IS_SBUS(isp)) {
371 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_target);
372 ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_reserved0);
373 } else {
374 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
375 ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_target);
349 }
376 }
350 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
377 ISP_IOXPUT_16(isp, src->mrk_modifier, &dst->mrk_modifier);
378 ISP_IOXPUT_16(isp, src->mrk_flags, &dst->mrk_flags);
379 ISP_IOXPUT_16(isp, src->mrk_lun, &dst->mrk_lun);
380 for (i = 0; i < ASIZE(src->mrk_reserved1); i++) {
381 ISP_IOXPUT_8(isp, src->mrk_reserved1[i],
382 &dst->mrk_reserved1[i]);
383 }
384}
385
386void
387isp_put_marker_24xx(ispsoftc_t *isp,
388 isp_marker_24xx_t *src, isp_marker_24xx_t *dst)
389{
390 int i;
391 isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
392 ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
393 ISP_IOXPUT_16(isp, src->mrk_nphdl, &dst->mrk_nphdl);
394 ISP_IOXPUT_8(isp, src->mrk_modifier, &dst->mrk_modifier);
395 ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
396 ISP_IOXPUT_8(isp, src->mrk_reserved1, &dst->mrk_reserved1);
397 ISP_IOXPUT_8(isp, src->mrk_vphdl, &dst->mrk_vphdl);
398 ISP_IOXPUT_8(isp, src->mrk_reserved2, &dst->mrk_reserved2);
399 for (i = 0; i < ASIZE(src->mrk_lun); i++) {
400 ISP_IOXPUT_8(isp, src->mrk_lun[i], &dst->mrk_lun[i]);
401 }
402 for (i = 0; i < ASIZE(src->mrk_reserved3); i++) {
403 ISP_IOXPUT_8(isp, src->mrk_reserved3[i],
404 &dst->mrk_reserved3[i]);
405 }
406}
407
408void
409isp_put_request_t2(ispsoftc_t *isp, ispreqt2_t *src, ispreqt2_t *dst)
410{
411 int i;
412 isp_put_hdr(isp, &src->req_header, &dst->req_header);
413 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
414 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
415 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
416 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
417 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
418 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
419 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
420 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
421 for (i = 0; i < ASIZE(src->req_cdb); i++) {
422 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
423 }
424 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
351 for (i = 0; i < ISP_RQDSEG_T2; i++) {
425 for (i = 0; i < ISP_RQDSEG_T2; i++) {
352 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
353 &tqdst->req_dataseg[i].ds_base);
354 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
355 &tqdst->req_dataseg[i].ds_count);
426 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
427 &dst->req_dataseg[i].ds_base);
428 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
429 &dst->req_dataseg[i].ds_count);
356 }
357}
358
359void
430 }
431}
432
433void
360isp_put_request_t2e(ispsoftc_t *isp, ispreqt2e_t *tqsrc, ispreqt2e_t *tqdst)
434isp_put_request_t2e(ispsoftc_t *isp, ispreqt2e_t *src, ispreqt2e_t *dst)
361{
362 int i;
435{
436 int i;
363 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
364 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
365 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
366 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
367 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
368 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
369 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
370 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
371 for (i = 0; i < 16; i++) {
372 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
437 isp_put_hdr(isp, &src->req_header, &dst->req_header);
438 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
439 ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
440 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
441 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
442 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
443 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
444 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
445 for (i = 0; i < ASIZE(src->req_cdb); i++) {
446 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
373 }
447 }
374 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
448 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
375 for (i = 0; i < ISP_RQDSEG_T2; i++) {
449 for (i = 0; i < ISP_RQDSEG_T2; i++) {
376 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
377 &tqdst->req_dataseg[i].ds_base);
378 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
379 &tqdst->req_dataseg[i].ds_count);
450 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
451 &dst->req_dataseg[i].ds_base);
452 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
453 &dst->req_dataseg[i].ds_count);
380 }
381}
382
383void
454 }
455}
456
457void
384isp_put_request_t3(ispsoftc_t *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
458isp_put_request_t3(ispsoftc_t *isp, ispreqt3_t *src, ispreqt3_t *dst)
385{
386 int i;
459{
460 int i;
387 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
388 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
389 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
390 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
391 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
392 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
393 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
394 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
395 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
396 for (i = 0; i < 16; i++) {
397 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
461 isp_put_hdr(isp, &src->req_header, &dst->req_header);
462 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
463 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
464 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
465 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
466 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
467 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
468 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
469 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
470 for (i = 0; i < ASIZE(src->req_cdb); i++) {
471 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
398 }
472 }
399 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
473 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
400 for (i = 0; i < ISP_RQDSEG_T3; i++) {
474 for (i = 0; i < ISP_RQDSEG_T3; i++) {
401 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
402 &tqdst->req_dataseg[i].ds_base);
403 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
404 &tqdst->req_dataseg[i].ds_basehi);
405 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
406 &tqdst->req_dataseg[i].ds_count);
475 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
476 &dst->req_dataseg[i].ds_base);
477 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
478 &dst->req_dataseg[i].ds_basehi);
479 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
480 &dst->req_dataseg[i].ds_count);
407 }
408}
409
410void
481 }
482}
483
484void
411isp_put_request_t3e(ispsoftc_t *isp, ispreqt3e_t *tqsrc, ispreqt3e_t *tqdst)
485isp_put_request_t3e(ispsoftc_t *isp, ispreqt3e_t *src, ispreqt3e_t *dst)
412{
413 int i;
486{
487 int i;
414 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
415 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
416 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
417 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
418 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
419 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
420 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
421 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
422 for (i = 0; i < 16; i++) {
423 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
488 isp_put_hdr(isp, &src->req_header, &dst->req_header);
489 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
490 ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
491 ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
492 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
493 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
494 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
495 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
496 for (i = 0; i < ASIZE(src->req_cdb); i++) {
497 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
424 }
498 }
425 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
499 ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
426 for (i = 0; i < ISP_RQDSEG_T3; i++) {
500 for (i = 0; i < ISP_RQDSEG_T3; i++) {
427 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
428 &tqdst->req_dataseg[i].ds_base);
429 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
430 &tqdst->req_dataseg[i].ds_basehi);
431 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
432 &tqdst->req_dataseg[i].ds_count);
501 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
502 &dst->req_dataseg[i].ds_base);
503 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
504 &dst->req_dataseg[i].ds_basehi);
505 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
506 &dst->req_dataseg[i].ds_count);
433 }
434}
435
436void
507 }
508}
509
510void
437isp_put_extended_request(ispsoftc_t *isp, ispextreq_t *xqsrc,
438 ispextreq_t *xqdst)
511isp_put_extended_request(ispsoftc_t *isp, ispextreq_t *src, ispextreq_t *dst)
439{
440 int i;
512{
513 int i;
441 isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
442 ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
514 isp_put_hdr(isp, &src->req_header, &dst->req_header);
515 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
443 if (ISP_IS_SBUS(isp)) {
516 if (ISP_IS_SBUS(isp)) {
444 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
445 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);
517 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_target);
518 ISP_IOXPUT_8(isp, src->req_target, &dst->req_lun_trn);
446 } else {
519 } else {
447 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_lun_trn);
448 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_target);
520 ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
521 ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
449 }
522 }
450 ISP_IOXPUT_16(isp, xqsrc->req_cdblen, &xqdst->req_cdblen);
451 ISP_IOXPUT_16(isp, xqsrc->req_flags, &xqdst->req_flags);
452 ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
453 ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
454 for (i = 0; i < 44; i++) {
455 ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
523 ISP_IOXPUT_16(isp, src->req_cdblen, &dst->req_cdblen);
524 ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
525 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
526 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
527 for (i = 0; i < ASIZE(src->req_cdb); i++) {
528 ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
456 }
457}
458
459void
529 }
530}
531
532void
460isp_put_cont_req(ispsoftc_t *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
533isp_put_request_t7(ispsoftc_t *isp, ispreqt7_t *src, ispreqt7_t *dst)
461{
462 int i;
534{
535 int i;
463 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
536 uint32_t *a, *b;
537
538 isp_put_hdr(isp, &src->req_header, &dst->req_header);
539 ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
540 ISP_IOXPUT_16(isp, src->req_nphdl, &dst->req_nphdl);
541 ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
542 ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
543 ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
544 a = (uint32_t *) src->req_lun;
545 b = (uint32_t *) dst->req_lun;
546 for (i = 0; i < (ASIZE(src->req_lun) >> 2); i++ ) {
547 ISP_IOZPUT_32(isp, *a++, b++);
548 }
549 ISP_IOXPUT_8(isp, src->req_alen_datadir, &dst->req_alen_datadir);
550 ISP_IOXPUT_8(isp, src->req_task_management, &dst->req_task_management);
551 ISP_IOXPUT_8(isp, src->req_task_attribute, &dst->req_task_attribute);
552 ISP_IOXPUT_8(isp, src->req_crn, &dst->req_crn);
553 a = (uint32_t *) src->req_cdb;
554 b = (uint32_t *) dst->req_cdb;
555 for (i = 0; i < (ASIZE(src->req_cdb) >> 2); i++ ) {
556 ISP_IOZPUT_32(isp, *a++, b++);
557 }
558 ISP_IOXPUT_32(isp, src->req_dl, &dst->req_dl);
559 ISP_IOXPUT_16(isp, src->req_tidlo, &dst->req_tidlo);
560 ISP_IOXPUT_8(isp, src->req_tidhi, &dst->req_tidhi);
561 ISP_IOXPUT_8(isp, src->req_vpidx, &dst->req_vpidx);
562 ISP_IOXPUT_32(isp, src->req_dataseg.ds_base,
563 &dst->req_dataseg.ds_base);
564 ISP_IOXPUT_32(isp, src->req_dataseg.ds_basehi,
565 &dst->req_dataseg.ds_basehi);
566 ISP_IOXPUT_32(isp, src->req_dataseg.ds_count,
567 &dst->req_dataseg.ds_count);
568}
569
570void
571isp_put_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
572{
573 int i;
574 isp_put_hdr(isp, &src->abrt_header, &dst->abrt_header);
575 ISP_IOXPUT_32(isp, src->abrt_handle, &dst->abrt_handle);
576 ISP_IOXPUT_16(isp, src->abrt_nphdl, &dst->abrt_nphdl);
577 ISP_IOXPUT_16(isp, src->abrt_options, &dst->abrt_options);
578 ISP_IOXPUT_32(isp, src->abrt_cmd_handle, &dst->abrt_cmd_handle);
579 for (i = 0; i < ASIZE(src->abrt_reserved); i++) {
580 ISP_IOXPUT_8(isp, src->abrt_reserved[i],
581 &dst->abrt_reserved[i]);
582 }
583 ISP_IOXPUT_16(isp, src->abrt_tidlo, &dst->abrt_tidlo);
584 ISP_IOXPUT_8(isp, src->abrt_tidhi, &dst->abrt_tidhi);
585 ISP_IOXPUT_8(isp, src->abrt_vpidx, &dst->abrt_vpidx);
586 for (i = 0; i < ASIZE(src->abrt_reserved1); i++) {
587 ISP_IOXPUT_8(isp, src->abrt_reserved1[i],
588 &dst->abrt_reserved1[i]);
589 }
590}
591
592void
593isp_put_cont_req(ispsoftc_t *isp, ispcontreq_t *src, ispcontreq_t *dst)
594{
595 int i;
596 isp_put_hdr(isp, &src->req_header, &dst->req_header);
464 for (i = 0; i < ISP_CDSEG; i++) {
597 for (i = 0; i < ISP_CDSEG; i++) {
465 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
466 &cqdst->req_dataseg[i].ds_base);
467 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
468 &cqdst->req_dataseg[i].ds_count);
598 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
599 &dst->req_dataseg[i].ds_base);
600 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
601 &dst->req_dataseg[i].ds_count);
469 }
470}
471
472void
602 }
603}
604
605void
473isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *cqsrc,
474 ispcontreq64_t *cqdst)
606isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *src, ispcontreq64_t *dst)
475{
476 int i;
607{
608 int i;
477 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
609 isp_put_hdr(isp, &src->req_header, &dst->req_header);
478 for (i = 0; i < ISP_CDSEG64; i++) {
610 for (i = 0; i < ISP_CDSEG64; i++) {
479 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
480 &cqdst->req_dataseg[i].ds_base);
481 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
482 &cqdst->req_dataseg[i].ds_basehi);
483 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
484 &cqdst->req_dataseg[i].ds_count);
611 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
612 &dst->req_dataseg[i].ds_base);
613 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
614 &dst->req_dataseg[i].ds_basehi);
615 ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
616 &dst->req_dataseg[i].ds_count);
485 }
486}
487
488void
617 }
618}
619
620void
489isp_get_response(ispsoftc_t *isp, ispstatusreq_t *spsrc,
490 ispstatusreq_t *spdst)
621isp_get_response(ispsoftc_t *isp, ispstatusreq_t *src, ispstatusreq_t *dst)
491{
492 int i;
622{
623 int i;
493 isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
494 ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
495 ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
496 ISP_IOXGET_16(isp, &spsrc->req_completion_status,
497 spdst->req_completion_status);
498 ISP_IOXGET_16(isp, &spsrc->req_state_flags, spdst->req_state_flags);
499 ISP_IOXGET_16(isp, &spsrc->req_status_flags, spdst->req_status_flags);
500 ISP_IOXGET_16(isp, &spsrc->req_time, spdst->req_time);
501 ISP_IOXGET_16(isp, &spsrc->req_sense_len, spdst->req_sense_len);
502 ISP_IOXGET_32(isp, &spsrc->req_resid, spdst->req_resid);
624 isp_get_hdr(isp, &src->req_header, &dst->req_header);
625 ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
626 ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
627 ISP_IOXGET_16(isp, &src->req_completion_status,
628 dst->req_completion_status);
629 ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
630 ISP_IOXGET_16(isp, &src->req_status_flags, dst->req_status_flags);
631 ISP_IOXGET_16(isp, &src->req_time, dst->req_time);
632 ISP_IOXGET_16(isp, &src->req_sense_len, dst->req_sense_len);
633 ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
503 for (i = 0; i < 8; i++) {
634 for (i = 0; i < 8; i++) {
504 ISP_IOXGET_8(isp, &spsrc->req_response[i],
505 spdst->req_response[i]);
635 ISP_IOXGET_8(isp, &src->req_response[i],
636 dst->req_response[i]);
506 }
507 for (i = 0; i < 32; i++) {
637 }
638 for (i = 0; i < 32; i++) {
508 ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
509 spdst->req_sense_data[i]);
639 ISP_IOXGET_8(isp, &src->req_sense_data[i],
640 dst->req_sense_data[i]);
510 }
511}
512
513void
641 }
642}
643
644void
514isp_get_response_x(ispsoftc_t *isp, ispstatus_cont_t *cpsrc,
515 ispstatus_cont_t *cpdst)
645isp_get_24xx_response(ispsoftc_t *isp, isp24xx_statusreq_t *src,
646 isp24xx_statusreq_t *dst)
516{
517 int i;
647{
648 int i;
518 isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
519 for (i = 0; i < 60; i++) {
520 ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
521 cpdst->req_sense_data[i]);
649 isp_get_hdr(isp, &src->req_header, &dst->req_header);
650 ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
651 ISP_IOXGET_16(isp, &src->req_completion_status,
652 dst->req_completion_status);
653 ISP_IOXGET_16(isp, &src->req_oxid, dst->req_oxid);
654 ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
655 ISP_IOXGET_16(isp, &src->req_reserved0, dst->req_reserved0);
656 ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
657 ISP_IOXGET_16(isp, &src->req_reserved1, dst->req_reserved1);
658 ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
659 ISP_IOXGET_32(isp, &src->req_fcp_residual, dst->req_fcp_residual);
660 ISP_IOXGET_32(isp, &src->req_sense_len, dst->req_sense_len);
661 ISP_IOXGET_32(isp, &src->req_response_len, dst->req_response_len);
662 for (i = 0; i < 28; i++) {
663 ISP_IOXGET_8(isp, &src->req_rsp_sense[i],
664 dst->req_rsp_sense[i]);
522 }
523}
524
525void
665 }
666}
667
668void
669isp_get_24xx_abrt(ispsoftc_t *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
670{
671 int i;
672 isp_get_hdr(isp, &src->abrt_header, &dst->abrt_header);
673 ISP_IOXGET_32(isp, &src->abrt_handle, dst->abrt_handle);
674 ISP_IOXGET_16(isp, &src->abrt_nphdl, dst->abrt_nphdl);
675 ISP_IOXGET_16(isp, &src->abrt_options, dst->abrt_options);
676 ISP_IOXGET_32(isp, &src->abrt_cmd_handle, dst->abrt_cmd_handle);
677 for (i = 0; i < ASIZE(&src->abrt_reserved); i++) {
678 ISP_IOXGET_8(isp, &src->abrt_reserved[i],
679 dst->abrt_reserved[i]);
680 }
681 ISP_IOXGET_16(isp, &src->abrt_tidlo, dst->abrt_tidlo);
682 ISP_IOXGET_8(isp, &src->abrt_tidhi, dst->abrt_tidhi);
683 ISP_IOXGET_8(isp, &src->abrt_vpidx, dst->abrt_vpidx);
684 for (i = 0; i < ASIZE(&src->abrt_reserved1); i++) {
685 ISP_IOXGET_8(isp, &src->abrt_reserved1[i],
686 dst->abrt_reserved1[i]);
687 }
688}
689
690
691void
526isp_get_rio2(ispsoftc_t *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
527{
528 int i;
692isp_get_rio2(ispsoftc_t *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
693{
694 int i;
529 isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
530 if (r2dst->req_header.rqs_seqno > 30)
695 isp_get_hdr(isp, &r2src->req_header, &r2dst->req_header);
696 if (r2dst->req_header.rqs_seqno > 30) {
531 r2dst->req_header.rqs_seqno = 30;
697 r2dst->req_header.rqs_seqno = 30;
698 }
532 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
533 ISP_IOXGET_16(isp, &r2src->req_handles[i],
534 r2dst->req_handles[i]);
535 }
536 while (i < 30) {
537 r2dst->req_handles[i++] = 0;
538 }
539}
540
541void
699 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
700 ISP_IOXGET_16(isp, &r2src->req_handles[i],
701 r2dst->req_handles[i]);
702 }
703 while (i < 30) {
704 r2dst->req_handles[i++] = 0;
705 }
706}
707
708void
542isp_put_icb(ispsoftc_t *isp, isp_icb_t *Is, isp_icb_t *Id)
709isp_put_icb(ispsoftc_t *isp, isp_icb_t *src, isp_icb_t *dst)
543{
544 int i;
545 if (ISP_IS_SBUS(isp)) {
710{
711 int i;
712 if (ISP_IS_SBUS(isp)) {
546 ISP_IOXPUT_8(isp, Is->icb_version, &Id->_reserved0);
547 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->icb_version);
713 ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_reserved0);
714 ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_version);
548 } else {
715 } else {
549 ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
550 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0);
716 ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_version);
717 ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_reserved0);
551 }
718 }
552 ISP_IOXPUT_16(isp, Is->icb_fwoptions, &Id->icb_fwoptions);
553 ISP_IOXPUT_16(isp, Is->icb_maxfrmlen, &Id->icb_maxfrmlen);
554 ISP_IOXPUT_16(isp, Is->icb_maxalloc, &Id->icb_maxalloc);
555 ISP_IOXPUT_16(isp, Is->icb_execthrottle, &Id->icb_execthrottle);
719 ISP_IOXPUT_16(isp, src->icb_fwoptions, &dst->icb_fwoptions);
720 ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
721 ISP_IOXPUT_16(isp, src->icb_maxalloc, &dst->icb_maxalloc);
722 ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
556 if (ISP_IS_SBUS(isp)) {
723 if (ISP_IS_SBUS(isp)) {
557 ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_delay);
558 ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_count);
724 ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_delay);
725 ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_count);
559 } else {
726 } else {
560 ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_count);
561 ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_delay);
727 ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_count);
728 ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_delay);
562 }
563 for (i = 0; i < 8; i++) {
729 }
730 for (i = 0; i < 8; i++) {
564 ISP_IOXPUT_8(isp, Is->icb_portname[i], &Id->icb_portname[i]);
731 ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
565 }
732 }
566 ISP_IOXPUT_16(isp, Is->icb_hardaddr, &Id->icb_hardaddr);
733 ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
567 if (ISP_IS_SBUS(isp)) {
734 if (ISP_IS_SBUS(isp)) {
568 ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_logintime);
569 ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_iqdevtype);
735 ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_logintime);
736 ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_iqdevtype);
570 } else {
737 } else {
571 ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_iqdevtype);
572 ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_logintime);
738 ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_iqdevtype);
739 ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_logintime);
573 }
574 for (i = 0; i < 8; i++) {
740 }
741 for (i = 0; i < 8; i++) {
575 ISP_IOXPUT_8(isp, Is->icb_nodename[i], &Id->icb_nodename[i]);
742 ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
576 }
743 }
577 ISP_IOXPUT_16(isp, Is->icb_rqstout, &Id->icb_rqstout);
578 ISP_IOXPUT_16(isp, Is->icb_rspnsin, &Id->icb_rspnsin);
579 ISP_IOXPUT_16(isp, Is->icb_rqstqlen, &Id->icb_rqstqlen);
580 ISP_IOXPUT_16(isp, Is->icb_rsltqlen, &Id->icb_rsltqlen);
744 ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
745 ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
746 ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
747 ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
581 for (i = 0; i < 4; i++) {
748 for (i = 0; i < 4; i++) {
582 ISP_IOXPUT_16(isp, Is->icb_rqstaddr[i], &Id->icb_rqstaddr[i]);
749 ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
583 }
584 for (i = 0; i < 4; i++) {
750 }
751 for (i = 0; i < 4; i++) {
585 ISP_IOXPUT_16(isp, Is->icb_respaddr[i], &Id->icb_respaddr[i]);
752 ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
586 }
753 }
587 ISP_IOXPUT_16(isp, Is->icb_lunenables, &Id->icb_lunenables);
754 ISP_IOXPUT_16(isp, src->icb_lunenables, &dst->icb_lunenables);
588 if (ISP_IS_SBUS(isp)) {
755 if (ISP_IS_SBUS(isp)) {
589 ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_icnt);
590 ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_ccnt);
756 ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_icnt);
757 ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_ccnt);
591 } else {
758 } else {
592 ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_ccnt);
593 ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_icnt);
759 ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_ccnt);
760 ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_icnt);
594 }
761 }
595 ISP_IOXPUT_16(isp, Is->icb_lunetimeout, &Id->icb_lunetimeout);
596 ISP_IOXPUT_16(isp, Is->icb_xfwoptions, &Id->icb_xfwoptions);
762 ISP_IOXPUT_16(isp, src->icb_lunetimeout, &dst->icb_lunetimeout);
763 ISP_IOXPUT_16(isp, src->icb_reserved1, &dst->icb_reserved1);
764 ISP_IOXPUT_16(isp, src->icb_xfwoptions, &dst->icb_xfwoptions);
597 if (ISP_IS_SBUS(isp)) {
765 if (ISP_IS_SBUS(isp)) {
598 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_idelaytimer);
599 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_racctimer);
766 ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_idelaytimer);
767 ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_racctimer);
600 } else {
768 } else {
601 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
602 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
769 ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_racctimer);
770 ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
603 }
771 }
604 ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
772 ISP_IOXPUT_16(isp, src->icb_zfwoptions, &dst->icb_zfwoptions);
605}
606
607void
773}
774
775void
608isp_get_pdb(ispsoftc_t *isp, isp_pdb_t *src, isp_pdb_t *dst)
776isp_put_icb_2400(ispsoftc_t *isp, isp_icb_2400_t *src, isp_icb_2400_t *dst)
609{
610 int i;
777{
778 int i;
779 ISP_IOXPUT_16(isp, src->icb_version, &dst->icb_version);
780 ISP_IOXPUT_16(isp, src->icb_reserved0, &dst->icb_reserved0);
781 ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
782 ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
783 ISP_IOXPUT_16(isp, src->icb_xchgcnt, &dst->icb_xchgcnt);
784 ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
785 for (i = 0; i < 8; i++) {
786 ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
787 }
788 for (i = 0; i < 8; i++) {
789 ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
790 }
791 ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
792 ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
793 ISP_IOXPUT_16(isp, src->icb_retry_count, &dst->icb_retry_count);
794 ISP_IOXPUT_16(isp, src->icb_priout, &dst->icb_priout);
795 ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
796 ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
797 ISP_IOXPUT_16(isp, src->icb_ldn_nols, &dst->icb_ldn_nols);
798 ISP_IOXPUT_16(isp, src->icb_prqstqlen, &dst->icb_prqstqlen);
799 for (i = 0; i < 4; i++) {
800 ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
801 }
802 for (i = 0; i < 4; i++) {
803 ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
804 }
805 for (i = 0; i < 4; i++) {
806 ISP_IOXPUT_16(isp, src->icb_priaddr[i], &dst->icb_priaddr[i]);
807 }
808 for (i = 0; i < 4; i++) {
809 ISP_IOXPUT_16(isp, src->icb_reserved1[i],
810 &dst->icb_reserved1[i]);
811 }
812 ISP_IOXPUT_16(isp, src->icb_atio_in, &dst->icb_atio_in);
813 ISP_IOXPUT_16(isp, src->icb_atioqlen, &dst->icb_atioqlen);
814 for (i = 0; i < 4; i++) {
815 ISP_IOXPUT_16(isp, src->icb_atioqaddr[i],
816 &dst->icb_atioqaddr[i]);
817 }
818 ISP_IOXPUT_16(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
819 ISP_IOXPUT_16(isp, src->icb_logintime, &dst->icb_logintime);
820 ISP_IOXPUT_32(isp, src->icb_fwoptions1, &dst->icb_fwoptions1);
821 ISP_IOXPUT_32(isp, src->icb_fwoptions2, &dst->icb_fwoptions2);
822 ISP_IOXPUT_32(isp, src->icb_fwoptions3, &dst->icb_fwoptions3);
823 for (i = 0; i < 12; i++) {
824 ISP_IOXPUT_16(isp, src->icb_reserved2[i],
825 &dst->icb_reserved2[i]);
826 }
827}
828
829void
830isp_get_pdb_21xx(ispsoftc_t *isp, isp_pdb_21xx_t *src, isp_pdb_21xx_t *dst)
831{
832 int i;
611 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
612 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
613 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
614 for (i = 0; i < 4; i++) {
615 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
616 dst->pdb_hardaddr_bits[i]);
617 }
618 for (i = 0; i < 4; i++) {

--- 34 unchanged lines hidden (view full) ---

653 ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len);
654 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
655 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
656 ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid);
657 ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr);
658 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
659}
660
833 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
834 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
835 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
836 for (i = 0; i < 4; i++) {
837 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
838 dst->pdb_hardaddr_bits[i]);
839 }
840 for (i = 0; i < 4; i++) {

--- 34 unchanged lines hidden (view full) ---

875 ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len);
876 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
877 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
878 ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid);
879 ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr);
880 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
881}
882
883void
884isp_get_pdb_24xx(ispsoftc_t *isp, isp_pdb_24xx_t *src, isp_pdb_24xx_t *dst)
885{
886 int i;
887 ISP_IOXGET_16(isp, &src->pdb_flags, dst->pdb_flags);
888 ISP_IOXGET_8(isp, &src->pdb_curstate, dst->pdb_curstate);
889 ISP_IOXGET_8(isp, &src->pdb_laststate, dst->pdb_laststate);
890 for (i = 0; i < 4; i++) {
891 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
892 dst->pdb_hardaddr_bits[i]);
893 }
894 for (i = 0; i < 4; i++) {
895 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i],
896 dst->pdb_portid_bits[i]);
897 }
898 ISP_IOXGET_16(isp, &src->pdb_retry_timer, dst->pdb_retry_timer);
899 ISP_IOXGET_16(isp, &src->pdb_handle, dst->pdb_handle);
900 ISP_IOXGET_16(isp, &src->pdb_rcv_dsize, dst->pdb_rcv_dsize);
901 ISP_IOXGET_16(isp, &src->pdb_reserved0, dst->pdb_reserved0);
902 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
903 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
904 for (i = 0; i < 8; i++) {
905 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
906 }
907 for (i = 0; i < 8; i++) {
908 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
909 }
910 for (i = 0; i < 24; i++) {
911 ISP_IOXGET_8(isp, &src->pdb_reserved1[i],
912 dst->pdb_reserved1[i]);
913 }
914}
661
662/*
915
916/*
663 * CT_HDR canonicalization- only needed for SNS responses
917 * PLOGI/LOGO IOCB canonicalization
664 */
918 */
919
665void
920void
666isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
921isp_get_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
667{
922{
668 ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
669 ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
670 ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
671 ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
672 ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
673 ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
674 ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);
675 ISP_IOXGET_8(isp, &src->ct_res0, dst->ct_res0);
676 ISP_IOXGET_16(isp, &src->ct_response, dst->ct_response);
677 dst->ct_response = (dst->ct_response << 8) | (dst->ct_response >> 8);
678 ISP_IOXGET_16(isp, &src->ct_resid, dst->ct_resid);
679 dst->ct_resid = (dst->ct_resid << 8) | (dst->ct_resid >> 8);
680 ISP_IOXGET_8(isp, &src->ct_res1, dst->ct_res1);
681 ISP_IOXGET_8(isp, &src->ct_reason, dst->ct_reason);
682 ISP_IOXGET_8(isp, &src->ct_explanation, dst->ct_explanation);
683 ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
923 int i;
924 isp_get_hdr(isp, &src->plogx_header, &dst->plogx_header);
925 ISP_IOXGET_32(isp, &src->plogx_handle, dst->plogx_handle);
926 ISP_IOXGET_16(isp, &src->plogx_status, dst->plogx_status);
927 ISP_IOXGET_16(isp, &src->plogx_nphdl, dst->plogx_nphdl);
928 ISP_IOXGET_16(isp, &src->plogx_flags, dst->plogx_flags);
929 ISP_IOXGET_16(isp, &src->plogx_vphdl, dst->plogx_vphdl);
930 ISP_IOXGET_16(isp, &src->plogx_portlo, dst->plogx_portlo);
931 ISP_IOXGET_16(isp, &src->plogx_rspsz_porthi, dst->plogx_rspsz_porthi);
932 for (i = 0; i < 11; i++) {
933 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].lo16,
934 dst->plogx_ioparm[i].lo16);
935 ISP_IOXGET_16(isp, &src->plogx_ioparm[i].hi16,
936 dst->plogx_ioparm[i].hi16);
937 }
684}
685
938}
939
940void
941isp_put_plogx(ispsoftc_t *isp, isp_plogx_t *src, isp_plogx_t *dst)
942{
943 int i;
944 isp_put_hdr(isp, &src->plogx_header, &dst->plogx_header);
945 ISP_IOXPUT_32(isp, src->plogx_handle, &dst->plogx_handle);
946 ISP_IOXPUT_16(isp, src->plogx_status, &dst->plogx_status);
947 ISP_IOXPUT_16(isp, src->plogx_nphdl, &dst->plogx_nphdl);
948 ISP_IOXPUT_16(isp, src->plogx_flags, &dst->plogx_flags);
949 ISP_IOXPUT_16(isp, src->plogx_vphdl, &dst->plogx_vphdl);
950 ISP_IOXPUT_16(isp, src->plogx_portlo, &dst->plogx_portlo);
951 ISP_IOXPUT_16(isp, src->plogx_rspsz_porthi, &dst->plogx_rspsz_porthi);
952 for (i = 0; i < 11; i++) {
953 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].lo16,
954 &dst->plogx_ioparm[i].lo16);
955 ISP_IOXPUT_16(isp, src->plogx_ioparm[i].hi16,
956 &dst->plogx_ioparm[i].hi16);
957 }
958}
959
686/*
960/*
961 * CT Passthru canonicalization
962 */
963void
964isp_get_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
965{
966 int i;
967
968 isp_get_hdr(isp, &src->ctp_header, &dst->ctp_header);
969 ISP_IOXGET_32(isp, &src->ctp_handle, dst->ctp_handle);
970 ISP_IOXGET_16(isp, &src->ctp_status, dst->ctp_status);
971 ISP_IOXGET_16(isp, &src->ctp_nphdl, dst->ctp_nphdl);
972 ISP_IOXGET_16(isp, &src->ctp_cmd_cnt, dst->ctp_cmd_cnt);
973 ISP_IOXGET_16(isp, &src->ctp_vpidx, dst->ctp_vpidx);
974 ISP_IOXGET_16(isp, &src->ctp_time, dst->ctp_time);
975 ISP_IOXGET_16(isp, &src->ctp_reserved0, dst->ctp_reserved0);
976 ISP_IOXGET_16(isp, &src->ctp_rsp_cnt, dst->ctp_rsp_cnt);
977 for (i = 0; i < 5; i++) {
978 ISP_IOXGET_16(isp, &src->ctp_reserved1[i],
979 dst->ctp_reserved1[i]);
980 }
981 ISP_IOXGET_32(isp, &src->ctp_rsp_bcnt, dst->ctp_rsp_bcnt);
982 ISP_IOXGET_32(isp, &src->ctp_cmd_bcnt, dst->ctp_cmd_bcnt);
983 for (i = 0; i < 2; i++) {
984 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_base,
985 dst->ctp_dataseg[i].ds_base);
986 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_basehi,
987 dst->ctp_dataseg[i].ds_basehi);
988 ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_count,
989 dst->ctp_dataseg[i].ds_count);
990 }
991}
992
993void
994isp_put_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
995{
996 int i;
997
998 isp_put_hdr(isp, &src->ctp_header, &dst->ctp_header);
999 ISP_IOXPUT_32(isp, src->ctp_handle, &dst->ctp_handle);
1000 ISP_IOXPUT_16(isp, src->ctp_status, &dst->ctp_status);
1001 ISP_IOXPUT_16(isp, src->ctp_nphdl, &dst->ctp_nphdl);
1002 ISP_IOXPUT_16(isp, src->ctp_cmd_cnt, &dst->ctp_cmd_cnt);
1003 ISP_IOXPUT_16(isp, src->ctp_vpidx, &dst->ctp_vpidx);
1004 ISP_IOXPUT_16(isp, src->ctp_time, &dst->ctp_time);
1005 ISP_IOXPUT_16(isp, src->ctp_reserved0, &dst->ctp_reserved0);
1006 ISP_IOXPUT_16(isp, src->ctp_rsp_cnt, &dst->ctp_rsp_cnt);
1007 for (i = 0; i < 5; i++) {
1008 ISP_IOXPUT_16(isp, src->ctp_reserved1[i],
1009 &dst->ctp_reserved1[i]);
1010 }
1011 ISP_IOXPUT_32(isp, src->ctp_rsp_bcnt, &dst->ctp_rsp_bcnt);
1012 ISP_IOXPUT_32(isp, src->ctp_cmd_bcnt, &dst->ctp_cmd_bcnt);
1013 for (i = 0; i < 2; i++) {
1014 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_base,
1015 &dst->ctp_dataseg[i].ds_base);
1016 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_basehi,
1017 &dst->ctp_dataseg[i].ds_basehi);
1018 ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_count,
1019 &dst->ctp_dataseg[i].ds_count);
1020 }
1021}
1022
1023/*
687 * Generic SNS request - not particularly useful since the per-command data
688 * isn't always 16 bit words.
689 */
690void
691isp_put_sns_request(ispsoftc_t *isp, sns_screq_t *src, sns_screq_t *dst)
692{
693 int i, nw = (int) src->snscb_sblen;
694 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);

--- 7 unchanged lines hidden (view full) ---

702
703}
704
705void
706isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src,
707 sns_gid_ft_req_t *dst)
708{
709 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1024 * Generic SNS request - not particularly useful since the per-command data
1025 * isn't always 16 bit words.
1026 */
1027void
1028isp_put_sns_request(ispsoftc_t *isp, sns_screq_t *src, sns_screq_t *dst)
1029{
1030 int i, nw = (int) src->snscb_sblen;
1031 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);

--- 7 unchanged lines hidden (view full) ---

1039
1040}
1041
1042void
1043isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src,
1044 sns_gid_ft_req_t *dst)
1045{
1046 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
710 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
1047 ISP_IOXPUT_16(isp, src->snscb_reserved0, &dst->snscb_reserved0);
711 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
712 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
713 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
714 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
715 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1048 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
1049 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
1050 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
1051 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
1052 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
716 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
1053 ISP_IOXPUT_16(isp, src->snscb_reserved1, &dst->snscb_reserved1);
717 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
718 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
1054 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
1055 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
719 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
1056 ISP_IOXPUT_32(isp, src->snscb_reserved3, &dst->snscb_reserved3);
720 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
721}
722
723void
724isp_put_gxn_id_request(ispsoftc_t *isp, sns_gxn_id_req_t *src,
725 sns_gxn_id_req_t *dst)
726{
727 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
1057 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
1058}
1059
1060void
1061isp_put_gxn_id_request(ispsoftc_t *isp, sns_gxn_id_req_t *src,
1062 sns_gxn_id_req_t *dst)
1063{
1064 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
728 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
1065 ISP_IOXPUT_16(isp, src->snscb_reserved0, &dst->snscb_reserved0);
729 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
730 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
731 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
732 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
733 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
1066 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
1067 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
1068 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
1069 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
1070 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
734 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
1071 ISP_IOXPUT_16(isp, src->snscb_reserved1, &dst->snscb_reserved1);
735 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
1072 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
736 ISP_IOXPUT_16(isp, src->snscb_res2, &dst->snscb_res2);
737 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
1073 ISP_IOXPUT_16(isp, src->snscb_reserved2, &dst->snscb_reserved2);
1074 ISP_IOXPUT_32(isp, src->snscb_reserved3, &dst->snscb_reserved3);
738 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
739}
740
741/*
742 * Generic SNS response - not particularly useful since the per-command data
743 * isn't always 16 bit words.
744 */
745void

--- 107 unchanged lines hidden (view full) ---

853 }
854 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
855 for (i = 0; i < 3; i++) {
856 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
857 dst->snscb_hardaddr[i]);
858 }
859}
860
1075 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
1076}
1077
1078/*
1079 * Generic SNS response - not particularly useful since the per-command data
1080 * isn't always 16 bit words.
1081 */
1082void

--- 107 unchanged lines hidden (view full) ---

1190 }
1191 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
1192 for (i = 0; i < 3; i++) {
1193 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
1194 dst->snscb_hardaddr[i]);
1195 }
1196}
1197
861#ifdef ISP_TARGET_MODE
1198void
1199isp_get_els(ispsoftc_t *isp, els_t *src, els_t *dst)
1200{
1201 int i;
862
1202
1203 isp_get_hdr(isp, &src->els_hdr, &dst->els_hdr);
1204 ISP_IOXGET_32(isp, &src->els_handle, dst->els_handle);
1205 ISP_IOXGET_16(isp, &src->els_status, dst->els_status);
1206 ISP_IOXGET_16(isp, &src->els_nphdl, dst->els_nphdl);
1207 ISP_IOXGET_16(isp, &src->els_xmit_dsd_count, dst->els_xmit_dsd_count);
1208 ISP_IOXGET_8(isp, &src->els_vphdl, dst->els_vphdl);
1209 ISP_IOXGET_8(isp, &src->els_sof, dst->els_sof);
1210 ISP_IOXGET_32(isp, &src->els_rxid, dst->els_rxid);
1211 ISP_IOXGET_16(isp, &src->els_recv_dsd_count, dst->els_recv_dsd_count);
1212 ISP_IOXGET_8(isp, &src->els_opcode, dst->els_opcode);
1213 ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved1);
1214 ISP_IOXGET_8(isp, &src->els_did_lo, dst->els_did_lo);
1215 ISP_IOXGET_8(isp, &src->els_did_mid, dst->els_did_mid);
1216 ISP_IOXGET_8(isp, &src->els_did_hi, dst->els_did_hi);
1217 ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved2);
1218 ISP_IOXGET_16(isp, &src->els_reserved3, dst->els_reserved3);
1219 ISP_IOXGET_16(isp, &src->els_ctl_flags, dst->els_ctl_flags);
1220 ISP_IOXGET_32(isp, &src->els_bytecnt, dst->els_bytecnt);
1221 ISP_IOXGET_32(isp, &src->els_subcode1, dst->els_subcode1);
1222 ISP_IOXGET_32(isp, &src->els_subcode2, dst->els_subcode2);
1223 for (i = 0; i < 20; i++) {
1224 ISP_IOXGET_8(isp, &src->els_reserved4[i],
1225 dst->els_reserved4[i]);
1226 }
1227}
1228
1229void
1230isp_put_els(ispsoftc_t *isp, els_t *src, els_t *dst)
1231{
1232 isp_put_hdr(isp, &src->els_hdr, &dst->els_hdr);
1233 ISP_IOXPUT_32(isp, src->els_handle, &dst->els_handle);
1234 ISP_IOXPUT_16(isp, src->els_status, &dst->els_status);
1235 ISP_IOXPUT_16(isp, src->els_nphdl, &dst->els_nphdl);
1236 ISP_IOXPUT_16(isp, src->els_xmit_dsd_count, &dst->els_xmit_dsd_count);
1237 ISP_IOXPUT_8(isp, src->els_vphdl, &dst->els_vphdl);
1238 ISP_IOXPUT_8(isp, src->els_sof, &dst->els_sof);
1239 ISP_IOXPUT_32(isp, src->els_rxid, &dst->els_rxid);
1240 ISP_IOXPUT_16(isp, src->els_recv_dsd_count, &dst->els_recv_dsd_count);
1241 ISP_IOXPUT_8(isp, src->els_opcode, &dst->els_opcode);
1242 ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved1);
1243 ISP_IOXPUT_8(isp, src->els_did_lo, &dst->els_did_lo);
1244 ISP_IOXPUT_8(isp, src->els_did_mid, &dst->els_did_mid);
1245 ISP_IOXPUT_8(isp, src->els_did_hi, &dst->els_did_hi);
1246 ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved2);
1247 ISP_IOXPUT_16(isp, src->els_reserved3, &dst->els_reserved3);
1248 ISP_IOXPUT_16(isp, src->els_ctl_flags, &dst->els_ctl_flags);
1249 ISP_IOXPUT_32(isp, src->els_recv_bytecnt, &dst->els_recv_bytecnt);
1250 ISP_IOXPUT_32(isp, src->els_xmit_bytecnt, &dst->els_xmit_bytecnt);
1251 ISP_IOXPUT_32(isp, src->els_xmit_dsd_length, &dst->els_xmit_dsd_length);
1252 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a1500, &dst->els_xmit_dsd_a1500);
1253 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a3116, &dst->els_xmit_dsd_a3116);
1254 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a4732, &dst->els_xmit_dsd_a4732);
1255 ISP_IOXPUT_16(isp, src->els_xmit_dsd_a6348, &dst->els_xmit_dsd_a6348);
1256 ISP_IOXPUT_32(isp, src->els_recv_dsd_length, &dst->els_recv_dsd_length);
1257 ISP_IOXPUT_16(isp, src->els_recv_dsd_a1500, &dst->els_recv_dsd_a1500);
1258 ISP_IOXPUT_16(isp, src->els_recv_dsd_a3116, &dst->els_recv_dsd_a3116);
1259 ISP_IOXPUT_16(isp, src->els_recv_dsd_a4732, &dst->els_recv_dsd_a4732);
1260 ISP_IOXPUT_16(isp, src->els_recv_dsd_a6348, &dst->els_recv_dsd_a6348);
1261}
1262
1263/*
1264 * FC Structure Canonicalization
1265 */
1266
1267void
1268isp_get_fc_hdr(ispsoftc_t *isp, fc_hdr_t *src, fc_hdr_t *dst)
1269{
1270 ISP_IOZGET_8(isp, &src->r_ctl, dst->r_ctl);
1271 ISP_IOZGET_8(isp, &src->d_id[0], dst->d_id[0]);
1272 ISP_IOZGET_8(isp, &src->d_id[1], dst->d_id[1]);
1273 ISP_IOZGET_8(isp, &src->d_id[2], dst->d_id[2]);
1274 ISP_IOZGET_8(isp, &src->cs_ctl, dst->cs_ctl);
1275 ISP_IOZGET_8(isp, &src->s_id[0], dst->s_id[0]);
1276 ISP_IOZGET_8(isp, &src->s_id[1], dst->s_id[1]);
1277 ISP_IOZGET_8(isp, &src->s_id[2], dst->s_id[2]);
1278 ISP_IOZGET_8(isp, &src->type, dst->type);
1279 ISP_IOZGET_8(isp, &src->f_ctl, dst->f_ctl);
1280 ISP_IOZGET_8(isp, &src->seq_id, dst->seq_id);
1281 ISP_IOZGET_8(isp, &src->df_ctl, dst->df_ctl);
1282 ISP_IOZGET_16(isp, &src->seq_cnt, dst->seq_cnt);
1283 /* XXX SOMETHING WAS AND STILL CONTINUES WRONG HERE XXX */
1284#if 0
1285 ISP_IOZGET_16(isp, &src->ox_id, dst->ox_id);
1286 ISP_IOZGET_16(isp, &src->rx_id, dst->rx_id);
1287#else
1288 ISP_IOZGET_32(isp, &src->ox_id, dst->parameter);
1289 dst->ox_id = dst->parameter;
1290 dst->rx_id = dst->parameter >> 16;
1291#endif
1292 ISP_IOZGET_32(isp, &src->parameter, dst->parameter);
1293}
1294
1295void
1296isp_get_fcp_cmnd_iu(ispsoftc_t *isp, fcp_cmnd_iu_t *src, fcp_cmnd_iu_t *dst)
1297{
1298 int i;
1299
1300 for (i = 0; i < 8; i++) {
1301 ISP_IOZGET_8(isp, &src->fcp_cmnd_lun[i], dst->fcp_cmnd_lun[i]);
1302 }
1303 ISP_IOZGET_8(isp, &src->fcp_cmnd_crn, dst->fcp_cmnd_crn);
1304 ISP_IOZGET_8(isp, &src->fcp_cmnd_task_attribute,
1305 dst->fcp_cmnd_task_attribute);
1306 ISP_IOZGET_8(isp, &src->fcp_cmnd_task_management,
1307 dst->fcp_cmnd_task_management);
1308 ISP_IOZGET_8(isp, &src->fcp_cmnd_alen_datadir,
1309 dst->fcp_cmnd_alen_datadir);
1310 for (i = 0; i < 16; i++) {
1311 ISP_IOZGET_8(isp, &src->cdb_dl.sf.fcp_cmnd_cdb[i],
1312 dst->cdb_dl.sf.fcp_cmnd_cdb[i]);
1313 }
1314 ISP_IOZGET_32(isp, &src->cdb_dl.sf.fcp_cmnd_dl,
1315 dst->cdb_dl.sf.fcp_cmnd_dl);
1316}
1317
1318void
1319isp_put_rft_id(ispsoftc_t *isp, rft_id_t *src, rft_id_t *dst)
1320{
1321 int i;
1322 isp_put_ct_hdr(isp, &src->rftid_hdr, &dst->rftid_hdr);
1323 ISP_IOZPUT_8(isp, src->rftid_reserved, &dst->rftid_reserved);
1324 for (i = 0; i < 3; i++) {
1325 ISP_IOZPUT_8(isp, src->rftid_portid[i], &dst->rftid_portid[i]);
1326 }
1327 for (i = 0; i < 8; i++) {
1328 ISP_IOZPUT_32(isp, src->rftid_fc4types[i],
1329 &dst->rftid_fc4types[i]);
1330 }
1331}
1332
1333void
1334isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1335{
1336 ISP_IOZGET_8(isp, &src->ct_revision, dst->ct_revision);
1337 ISP_IOZGET_8(isp, &src->ct_in_id[0], dst->ct_in_id[0]);
1338 ISP_IOZGET_8(isp, &src->ct_in_id[1], dst->ct_in_id[1]);
1339 ISP_IOZGET_8(isp, &src->ct_in_id[2], dst->ct_in_id[2]);
1340 ISP_IOZGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
1341 ISP_IOZGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
1342 ISP_IOZGET_8(isp, &src->ct_options, dst->ct_options);
1343 ISP_IOZGET_8(isp, &src->ct_reserved0, dst->ct_reserved0);
1344 ISP_IOZGET_16(isp, &src->ct_cmd_resp, dst->ct_cmd_resp);
1345 ISP_IOZGET_16(isp, &src->ct_bcnt_resid, dst->ct_bcnt_resid);
1346 ISP_IOZGET_8(isp, &src->ct_reserved1, dst->ct_reserved1);
1347 ISP_IOZGET_8(isp, &src->ct_reason, dst->ct_reason);
1348 ISP_IOZGET_8(isp, &src->ct_explanation, dst->ct_explanation);
1349 ISP_IOZGET_8(isp, &src->ct_vunique, dst->ct_vunique);
1350}
1351
1352void
1353isp_put_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
1354{
1355 ISP_IOZPUT_8(isp, src->ct_revision, &dst->ct_revision);
1356 ISP_IOZPUT_8(isp, src->ct_in_id[0], &dst->ct_in_id[0]);
1357 ISP_IOZPUT_8(isp, src->ct_in_id[1], &dst->ct_in_id[1]);
1358 ISP_IOZPUT_8(isp, src->ct_in_id[2], &dst->ct_in_id[2]);
1359 ISP_IOZPUT_8(isp, src->ct_fcs_type, &dst->ct_fcs_type);
1360 ISP_IOZPUT_8(isp, src->ct_fcs_subtype, &dst->ct_fcs_subtype);
1361 ISP_IOZPUT_8(isp, src->ct_options, &dst->ct_options);
1362 ISP_IOZPUT_8(isp, src->ct_reserved0, &dst->ct_reserved0);
1363 ISP_IOZPUT_16(isp, src->ct_cmd_resp, &dst->ct_cmd_resp);
1364 ISP_IOZPUT_16(isp, src->ct_bcnt_resid, &dst->ct_bcnt_resid);
1365 ISP_IOZPUT_8(isp, src->ct_reserved1, &dst->ct_reserved1);
1366 ISP_IOZPUT_8(isp, src->ct_reason, &dst->ct_reason);
1367 ISP_IOZPUT_8(isp, src->ct_explanation, &dst->ct_explanation);
1368 ISP_IOZPUT_8(isp, src->ct_vunique, &dst->ct_vunique);
1369}
1370
1371#ifdef ISP_TARGET_MODE
863int
1372int
864isp_save_xs_tgt(ispsoftc_t *isp, void *xs, uint16_t *handlep)
1373isp_save_xs_tgt(ispsoftc_t *isp, void *xs, uint32_t *handlep)
865{
866 int i;
867
868 for (i = 0; i < (int) isp->isp_maxcmds; i++) {
869 if (isp->isp_tgtlist[i] == NULL) {
870 break;
871 }
872 }
873 if (i == isp->isp_maxcmds) {
874 return (-1);
875 }
876 isp->isp_tgtlist[i] = xs;
1374{
1375 int i;
1376
1377 for (i = 0; i < (int) isp->isp_maxcmds; i++) {
1378 if (isp->isp_tgtlist[i] == NULL) {
1379 break;
1380 }
1381 }
1382 if (i == isp->isp_maxcmds) {
1383 return (-1);
1384 }
1385 isp->isp_tgtlist[i] = xs;
877 *handlep = i+1;
1386 *handlep = (i+1) | 0x8000;
878 return (0);
879}
880
881void *
1387 return (0);
1388}
1389
1390void *
882isp_find_xs_tgt(ispsoftc_t *isp, uint16_t handle)
1391isp_find_xs_tgt(ispsoftc_t *isp, uint32_t handle)
883{
1392{
884 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) {
1393 if (handle == 0 || (handle & 0x8000) == 0 ||
1394 (handle & 0x7fff) > isp->isp_maxcmds) {
1395 isp_prt(isp, ISP_LOGERR, "bad handle in isp_find_xs_tgt");
885 return (NULL);
886 } else {
1396 return (NULL);
1397 } else {
887 return (isp->isp_tgtlist[handle - 1]);
1398 return (isp->isp_tgtlist[(handle & 0x7fff) - 1]);
888 }
889}
890
1399 }
1400}
1401
891uint16_t
1402uint32_t
892isp_find_tgt_handle(ispsoftc_t *isp, void *xs)
893{
894 int i;
895 if (xs != NULL) {
896 for (i = 0; i < isp->isp_maxcmds; i++) {
897 if (isp->isp_tgtlist[i] == xs) {
1403isp_find_tgt_handle(ispsoftc_t *isp, void *xs)
1404{
1405 int i;
1406 if (xs != NULL) {
1407 for (i = 0; i < isp->isp_maxcmds; i++) {
1408 if (isp->isp_tgtlist[i] == xs) {
898 return ((uint16_t) i+1);
1409 return ((i+1) & 0x7fff);
899 }
900 }
901 }
902 return (0);
903}
904
905void
1410 }
1411 }
1412 }
1413 return (0);
1414}
1415
1416void
906isp_destroy_tgt_handle(ispsoftc_t *isp, uint16_t handle)
1417isp_destroy_tgt_handle(ispsoftc_t *isp, uint32_t handle)
907{
1418{
908 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) {
909 isp->isp_tgtlist[handle - 1] = NULL;
1419 if (handle == 0 || (handle & 0x8000) == 0 ||
1420 (handle & 0x7fff) > isp->isp_maxcmds) {
1421 isp_prt(isp, ISP_LOGERR,
1422 "bad handle in isp_destroy_tgt_handle");
1423 } else {
1424 isp->isp_tgtlist[(handle & 0x7fff) - 1] = NULL;
910 }
911}
1425 }
1426}
1427
912void
1428void
913isp_put_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst)
1429isp_put_atio(ispsoftc_t *isp, at_entry_t *src, at_entry_t *dst)
914{
915 int i;
1430{
1431 int i;
916 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
917 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
918 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
1432 isp_put_hdr(isp, &src->at_header, &dst->at_header);
1433 ISP_IOXPUT_16(isp, src->at_reserved, &dst->at_reserved);
1434 ISP_IOXPUT_16(isp, src->at_handle, &dst->at_handle);
919 if (ISP_IS_SBUS(isp)) {
1435 if (ISP_IS_SBUS(isp)) {
920 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
921 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);
922 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_tgt);
923 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_cdblen);
924 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_scsi_status);
925 ISP_IOXPUT_8(isp, atsrc->at_scsi_status, &atdst->at_status);
926 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_type);
927 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_val);
1436 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_iid);
1437 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_lun);
1438 ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_tgt);
1439 ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_cdblen);
1440 ISP_IOXPUT_8(isp, src->at_status, &dst->at_scsi_status);
1441 ISP_IOXPUT_8(isp, src->at_scsi_status, &dst->at_status);
1442 ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_type);
1443 ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_val);
928 } else {
1444 } else {
929 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
930 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
931 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_cdblen);
932 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_tgt);
933 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_status);
934 ISP_IOXPUT_8(isp, atsrc->at_scsi_status,
935 &atdst->at_scsi_status);
936 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_val);
937 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_type);
1445 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
1446 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
1447 ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_cdblen);
1448 ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_tgt);
1449 ISP_IOXPUT_8(isp, src->at_status, &dst->at_status);
1450 ISP_IOXPUT_8(isp, src->at_scsi_status,
1451 &dst->at_scsi_status);
1452 ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_val);
1453 ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_type);
938 }
1454 }
939 ISP_IOXPUT_32(isp, atsrc->at_flags, &atdst->at_flags);
1455 ISP_IOXPUT_32(isp, src->at_flags, &dst->at_flags);
940 for (i = 0; i < ATIO_CDBLEN; i++) {
1456 for (i = 0; i < ATIO_CDBLEN; i++) {
941 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
1457 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
942 }
943 for (i = 0; i < QLTM_SENSELEN; i++) {
1458 }
1459 for (i = 0; i < QLTM_SENSELEN; i++) {
944 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
1460 ISP_IOXPUT_8(isp, src->at_sense[i], &dst->at_sense[i]);
945 }
946}
947
948void
1461 }
1462}
1463
1464void
949isp_get_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst)
1465isp_get_atio(ispsoftc_t *isp, at_entry_t *src, at_entry_t *dst)
950{
951 int i;
1466{
1467 int i;
952 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
953 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
954 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
1468 isp_get_hdr(isp, &src->at_header, &dst->at_header);
1469 ISP_IOXGET_16(isp, &src->at_reserved, dst->at_reserved);
1470 ISP_IOXGET_16(isp, &src->at_handle, dst->at_handle);
955 if (ISP_IS_SBUS(isp)) {
1471 if (ISP_IS_SBUS(isp)) {
956 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
957 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);
958 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_tgt);
959 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_cdblen);
960 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_scsi_status);
961 ISP_IOXGET_8(isp, &atsrc->at_scsi_status, atdst->at_status);
962 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_type);
963 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_val);
1472 ISP_IOXGET_8(isp, &src->at_lun, dst->at_iid);
1473 ISP_IOXGET_8(isp, &src->at_iid, dst->at_lun);
1474 ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_tgt);
1475 ISP_IOXGET_8(isp, &src->at_tgt, dst->at_cdblen);
1476 ISP_IOXGET_8(isp, &src->at_status, dst->at_scsi_status);
1477 ISP_IOXGET_8(isp, &src->at_scsi_status, dst->at_status);
1478 ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_type);
1479 ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_val);
964 } else {
1480 } else {
965 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
966 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
967 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_cdblen);
968 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_tgt);
969 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_status);
970 ISP_IOXGET_8(isp, &atsrc->at_scsi_status,
971 atdst->at_scsi_status);
972 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_val);
973 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_type);
1481 ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
1482 ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
1483 ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_cdblen);
1484 ISP_IOXGET_8(isp, &src->at_tgt, dst->at_tgt);
1485 ISP_IOXGET_8(isp, &src->at_status, dst->at_status);
1486 ISP_IOXGET_8(isp, &src->at_scsi_status,
1487 dst->at_scsi_status);
1488 ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_val);
1489 ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_type);
974 }
1490 }
975 ISP_IOXGET_32(isp, &atsrc->at_flags, atdst->at_flags);
1491 ISP_IOXGET_32(isp, &src->at_flags, dst->at_flags);
976 for (i = 0; i < ATIO_CDBLEN; i++) {
1492 for (i = 0; i < ATIO_CDBLEN; i++) {
977 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
1493 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
978 }
979 for (i = 0; i < QLTM_SENSELEN; i++) {
1494 }
1495 for (i = 0; i < QLTM_SENSELEN; i++) {
980 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
1496 ISP_IOXGET_8(isp, &src->at_sense[i], dst->at_sense[i]);
981 }
982}
983
984void
1497 }
1498}
1499
1500void
985isp_put_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1501isp_put_atio2(ispsoftc_t *isp, at2_entry_t *src, at2_entry_t *dst)
986{
987 int i;
1502{
1503 int i;
988 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
989 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
990 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
991 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
992 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
993 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
994 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);
995 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn);
996 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes);
997 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags);
998 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes);
1504 isp_put_hdr(isp, &src->at_header, &dst->at_header);
1505 ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
1506 ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
1507 ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
1508 ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
1509 ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
1510 ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
1511 ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
1512 ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
1513 ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
1514 ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
999 for (i = 0; i < ATIO2_CDBLEN; i++) {
1515 for (i = 0; i < ATIO2_CDBLEN; i++) {
1000 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
1516 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
1001 }
1517 }
1002 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen);
1003 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun);
1518 ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
1519 ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
1004 for (i = 0; i < 4; i++) {
1520 for (i = 0; i < 4; i++) {
1005 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]);
1521 ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
1006 }
1007 for (i = 0; i < 6; i++) {
1522 }
1523 for (i = 0; i < 6; i++) {
1008 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1009 &atdst->at_reserved2[i]);
1524 ISP_IOXPUT_16(isp, src->at_reserved2[i],
1525 &dst->at_reserved2[i]);
1010 }
1526 }
1011 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1527 ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
1012}
1013
1014void
1528}
1529
1530void
1015isp_put_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1531isp_put_atio2e(ispsoftc_t *isp, at2e_entry_t *src, at2e_entry_t *dst)
1016{
1017 int i;
1532{
1533 int i;
1018 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
1019 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
1020 ISP_IOXPUT_16(isp, atsrc->at_iid, &atdst->at_iid);
1021 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
1022 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
1023 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);
1024 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn);
1025 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes);
1026 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags);
1027 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes);
1534 isp_put_hdr(isp, &src->at_header, &dst->at_header);
1535 ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
1536 ISP_IOXPUT_16(isp, src->at_iid, &dst->at_iid);
1537 ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
1538 ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
1539 ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
1540 ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
1541 ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
1542 ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
1543 ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
1028 for (i = 0; i < ATIO2_CDBLEN; i++) {
1544 for (i = 0; i < ATIO2_CDBLEN; i++) {
1029 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
1545 ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
1030 }
1546 }
1031 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen);
1032 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun);
1547 ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
1548 ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
1033 for (i = 0; i < 4; i++) {
1549 for (i = 0; i < 4; i++) {
1034 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]);
1550 ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
1035 }
1036 for (i = 0; i < 6; i++) {
1551 }
1552 for (i = 0; i < 6; i++) {
1037 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1038 &atdst->at_reserved2[i]);
1553 ISP_IOXPUT_16(isp, src->at_reserved2[i],
1554 &dst->at_reserved2[i]);
1039 }
1555 }
1040 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1556 ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
1041}
1042
1043void
1557}
1558
1559void
1044isp_get_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1560isp_get_atio2(ispsoftc_t *isp, at2_entry_t *src, at2_entry_t *dst)
1045{
1046 int i;
1561{
1562 int i;
1047 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1048 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1049 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
1050 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
1051 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1052 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1053 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);
1054 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn);
1055 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes);
1056 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags);
1057 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes);
1563 isp_get_hdr(isp, &src->at_header, &dst->at_header);
1564 ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
1565 ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
1566 ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
1567 ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
1568 ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
1569 ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
1570 ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
1571 ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
1572 ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
1573 ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
1058 for (i = 0; i < ATIO2_CDBLEN; i++) {
1574 for (i = 0; i < ATIO2_CDBLEN; i++) {
1059 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
1575 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
1060 }
1576 }
1061 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen);
1062 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun);
1577 ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
1578 ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
1063 for (i = 0; i < 4; i++) {
1579 for (i = 0; i < 4; i++) {
1064 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]);
1580 ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
1065 }
1066 for (i = 0; i < 6; i++) {
1581 }
1582 for (i = 0; i < 6; i++) {
1067 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1068 atdst->at_reserved2[i]);
1583 ISP_IOXGET_16(isp, &src->at_reserved2[i],
1584 dst->at_reserved2[i]);
1069 }
1585 }
1070 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1586 ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
1071}
1072
1073void
1587}
1588
1589void
1074isp_get_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1590isp_get_atio2e(ispsoftc_t *isp, at2e_entry_t *src, at2e_entry_t *dst)
1075{
1076 int i;
1591{
1592 int i;
1077 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1078 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1079 ISP_IOXGET_16(isp, &atsrc->at_iid, atdst->at_iid);
1080 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1081 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1082 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);
1083 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn);
1084 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes);
1085 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags);
1086 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes);
1593 isp_get_hdr(isp, &src->at_header, &dst->at_header);
1594 ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
1595 ISP_IOXGET_16(isp, &src->at_iid, dst->at_iid);
1596 ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
1597 ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
1598 ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
1599 ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
1600 ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
1601 ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
1602 ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
1087 for (i = 0; i < ATIO2_CDBLEN; i++) {
1603 for (i = 0; i < ATIO2_CDBLEN; i++) {
1088 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
1604 ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
1089 }
1605 }
1090 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen);
1091 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun);
1606 ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
1607 ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
1092 for (i = 0; i < 4; i++) {
1608 for (i = 0; i < 4; i++) {
1093 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]);
1609 ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
1094 }
1095 for (i = 0; i < 6; i++) {
1610 }
1611 for (i = 0; i < 6; i++) {
1096 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1097 atdst->at_reserved2[i]);
1612 ISP_IOXGET_16(isp, &src->at_reserved2[i],
1613 dst->at_reserved2[i]);
1098 }
1614 }
1099 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1615 ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
1100}
1101
1102void
1616}
1617
1618void
1103isp_put_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1619isp_get_atio7(ispsoftc_t *isp, at7_entry_t *src, at7_entry_t *dst)
1104{
1620{
1621 ISP_IOXGET_8(isp, &src->at_type, dst->at_type);
1622 ISP_IOXGET_8(isp, &src->at_count, dst->at_count);
1623 ISP_IOXGET_16(isp, &src->at_ta_len, dst->at_ta_len);
1624 ISP_IOXGET_32(isp, &src->at_rxid, dst->at_rxid);
1625 isp_get_fc_hdr(isp, &src->at_hdr, &dst->at_hdr);
1626 isp_get_fcp_cmnd_iu(isp, &src->at_cmnd, &dst->at_cmnd);
1627}
1628
1629void
1630isp_put_ctio(ispsoftc_t *isp, ct_entry_t *src, ct_entry_t *dst)
1631{
1105 int i;
1632 int i;
1106 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1107 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1108 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1633 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
1634 ISP_IOXPUT_16(isp, src->ct_syshandle, &dst->ct_syshandle);
1635 ISP_IOXPUT_16(isp, src->ct_fwhandle, &dst->ct_fwhandle);
1109 if (ISP_IS_SBUS(isp)) {
1636 if (ISP_IS_SBUS(isp)) {
1110 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
1111 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);
1112 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_reserved2);
1113 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_tgt);
1114 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_scsi_status);
1115 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, &ctdst->ct_status);
1116 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_val);
1117 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_type);
1637 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_lun);
1638 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_iid);
1639 ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_reserved2);
1640 ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_tgt);
1641 ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_scsi_status);
1642 ISP_IOXPUT_8(isp, src->ct_scsi_status, &dst->ct_status);
1643 ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_val);
1644 ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_type);
1118 } else {
1645 } else {
1119 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1120 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1121 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_tgt);
1122 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_reserved2);
1123 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status,
1124 &ctdst->ct_scsi_status);
1125 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_status);
1126 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_type);
1127 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_val);
1646 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
1647 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
1648 ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_tgt);
1649 ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_reserved2);
1650 ISP_IOXPUT_8(isp, src->ct_scsi_status,
1651 &dst->ct_scsi_status);
1652 ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_status);
1653 ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_type);
1654 ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_val);
1128 }
1655 }
1129 ISP_IOXPUT_32(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1130 ISP_IOXPUT_32(isp, ctsrc->ct_xfrlen, &ctdst->ct_xfrlen);
1131 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1132 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1133 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1656 ISP_IOXPUT_32(isp, src->ct_flags, &dst->ct_flags);
1657 ISP_IOXPUT_32(isp, src->ct_xfrlen, &dst->ct_xfrlen);
1658 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
1659 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
1660 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
1134 for (i = 0; i < ISP_RQDSEG; i++) {
1661 for (i = 0; i < ISP_RQDSEG; i++) {
1135 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
1136 &ctdst->ct_dataseg[i].ds_base);
1137 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
1138 &ctdst->ct_dataseg[i].ds_count);
1662 ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_base,
1663 &dst->ct_dataseg[i].ds_base);
1664 ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_count,
1665 &dst->ct_dataseg[i].ds_count);
1139 }
1140}
1141
1142void
1666 }
1667}
1668
1669void
1143isp_get_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1670isp_get_ctio(ispsoftc_t *isp, ct_entry_t *src, ct_entry_t *dst)
1144{
1145 int i;
1671{
1672 int i;
1146 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1147 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1148 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1673 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
1674 ISP_IOXGET_16(isp, &src->ct_syshandle, dst->ct_syshandle);
1675 ISP_IOXGET_16(isp, &src->ct_fwhandle, dst->ct_fwhandle);
1149 if (ISP_IS_SBUS(isp)) {
1676 if (ISP_IS_SBUS(isp)) {
1150 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
1151 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);
1152 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_tgt);
1153 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_reserved2);
1154 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_scsi_status);
1155 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, ctdst->ct_status);
1156 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_type);
1157 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_val);
1677 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_iid);
1678 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_lun);
1679 ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_tgt);
1680 ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_reserved2);
1681 ISP_IOXGET_8(isp, &src->ct_status, dst->ct_scsi_status);
1682 ISP_IOXGET_8(isp, &src->ct_scsi_status, dst->ct_status);
1683 ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_type);
1684 ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_val);
1158 } else {
1685 } else {
1159 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1160 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1161 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_reserved2);
1162 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_tgt);
1163 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_status);
1164 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status,
1165 ctdst->ct_scsi_status);
1166 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_val);
1167 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_type);
1686 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
1687 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
1688 ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_reserved2);
1689 ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_tgt);
1690 ISP_IOXGET_8(isp, &src->ct_status, dst->ct_status);
1691 ISP_IOXGET_8(isp, &src->ct_scsi_status,
1692 dst->ct_scsi_status);
1693 ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_val);
1694 ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_type);
1168 }
1695 }
1169 ISP_IOXGET_32(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1170 ISP_IOXGET_32(isp, &ctsrc->ct_xfrlen, ctdst->ct_xfrlen);
1171 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1172 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1173 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1696 ISP_IOXGET_32(isp, &src->ct_flags, dst->ct_flags);
1697 ISP_IOXGET_32(isp, &src->ct_xfrlen, dst->ct_xfrlen);
1698 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
1699 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
1700 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
1174 for (i = 0; i < ISP_RQDSEG; i++) {
1175 ISP_IOXGET_32(isp,
1701 for (i = 0; i < ISP_RQDSEG; i++) {
1702 ISP_IOXGET_32(isp,
1176 &ctsrc->ct_dataseg[i].ds_base,
1177 ctdst->ct_dataseg[i].ds_base);
1703 &src->ct_dataseg[i].ds_base,
1704 dst->ct_dataseg[i].ds_base);
1178 ISP_IOXGET_32(isp,
1705 ISP_IOXGET_32(isp,
1179 &ctsrc->ct_dataseg[i].ds_count,
1180 ctdst->ct_dataseg[i].ds_count);
1706 &src->ct_dataseg[i].ds_count,
1707 dst->ct_dataseg[i].ds_count);
1181 }
1182}
1183
1184void
1708 }
1709}
1710
1711void
1185isp_put_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1712isp_put_ctio2(ispsoftc_t *isp, ct2_entry_t *src, ct2_entry_t *dst)
1186{
1187 int i;
1713{
1714 int i;
1188 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1189 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1190 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1191 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1192 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1193 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1194 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1195 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1196 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1197 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1198 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff);
1199 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1200 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved,
1201 &ctdst->rsp.m0._reserved);
1202 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2,
1203 &ctdst->rsp.m0._reserved2);
1204 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status,
1205 &ctdst->rsp.m0.ct_scsi_status);
1206 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen,
1207 &ctdst->rsp.m0.ct_xfrlen);
1208 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1715 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
1716 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
1717 ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
1718 ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
1719 ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
1720 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
1721 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
1722 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
1723 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
1724 ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
1725 if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1726 ISP_IOXPUT_32(isp, src->rsp.m0._reserved,
1727 &dst->rsp.m0._reserved);
1728 ISP_IOXPUT_16(isp, src->rsp.m0._reserved2,
1729 &dst->rsp.m0._reserved2);
1730 ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status,
1731 &dst->rsp.m0.ct_scsi_status);
1732 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
1733 &dst->rsp.m0.ct_xfrlen);
1734 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1209 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1210 ISP_IOXPUT_32(isp,
1735 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1736 ISP_IOXPUT_32(isp,
1211 ctsrc->rsp.m0.ct_dataseg[i].ds_base,
1212 &ctdst->rsp.m0.ct_dataseg[i].ds_base);
1737 src->rsp.m0.u.ct_dataseg[i].ds_base,
1738 &dst->rsp.m0.u.ct_dataseg[i].ds_base);
1213 ISP_IOXPUT_32(isp,
1739 ISP_IOXPUT_32(isp,
1214 ctsrc->rsp.m0.ct_dataseg[i].ds_count,
1215 &ctdst->rsp.m0.ct_dataseg[i].ds_count);
1740 src->rsp.m0.u.ct_dataseg[i].ds_count,
1741 &dst->rsp.m0.u.ct_dataseg[i].ds_count);
1216 }
1742 }
1217 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1743 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1218 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1219 ISP_IOXPUT_32(isp,
1744 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1745 ISP_IOXPUT_32(isp,
1220 ctsrc->rsp.m0.ct_dataseg64[i].ds_base,
1221 &ctdst->rsp.m0.ct_dataseg64[i].ds_base);
1746 src->rsp.m0.u.ct_dataseg64[i].ds_base,
1747 &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
1222 ISP_IOXPUT_32(isp,
1748 ISP_IOXPUT_32(isp,
1223 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi,
1224 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi);
1749 src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
1750 &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
1225 ISP_IOXPUT_32(isp,
1751 ISP_IOXPUT_32(isp,
1226 ctsrc->rsp.m0.ct_dataseg64[i].ds_count,
1227 &ctdst->rsp.m0.ct_dataseg64[i].ds_count);
1752 src->rsp.m0.u.ct_dataseg64[i].ds_count,
1753 &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
1228 }
1754 }
1229 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1230 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type,
1231 &ctdst->rsp.m0.ct_dslist.ds_type);
1232 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment,
1233 &ctdst->rsp.m0.ct_dslist.ds_segment);
1234 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base,
1235 &ctdst->rsp.m0.ct_dslist.ds_base);
1755 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1756 ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type,
1757 &dst->rsp.m0.u.ct_dslist.ds_type);
1758 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment,
1759 &dst->rsp.m0.u.ct_dslist.ds_segment);
1760 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base,
1761 &dst->rsp.m0.u.ct_dslist.ds_base);
1236 }
1762 }
1237 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1238 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved,
1239 &ctdst->rsp.m1._reserved);
1240 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2,
1241 &ctdst->rsp.m1._reserved2);
1242 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen,
1243 &ctdst->rsp.m1.ct_senselen);
1244 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status,
1245 &ctdst->rsp.m1.ct_scsi_status);
1246 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen,
1247 &ctdst->rsp.m1.ct_resplen);
1763 } else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1764 ISP_IOXPUT_16(isp, src->rsp.m1._reserved,
1765 &dst->rsp.m1._reserved);
1766 ISP_IOXPUT_16(isp, src->rsp.m1._reserved2,
1767 &dst->rsp.m1._reserved2);
1768 ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen,
1769 &dst->rsp.m1.ct_senselen);
1770 ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status,
1771 &dst->rsp.m1.ct_scsi_status);
1772 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
1773 &dst->rsp.m1.ct_resplen);
1248 for (i = 0; i < MAXRESPLEN; i++) {
1774 for (i = 0; i < MAXRESPLEN; i++) {
1249 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i],
1250 &ctdst->rsp.m1.ct_resp[i]);
1775 ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
1776 &dst->rsp.m1.ct_resp[i]);
1251 }
1252 } else {
1777 }
1778 } else {
1253 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved,
1254 &ctdst->rsp.m2._reserved);
1255 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2,
1256 &ctdst->rsp.m2._reserved2);
1257 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3,
1258 &ctdst->rsp.m2._reserved3);
1259 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen,
1260 &ctdst->rsp.m2.ct_datalen);
1261 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1262 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1263 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1264 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1779 ISP_IOXPUT_32(isp, src->rsp.m2._reserved,
1780 &dst->rsp.m2._reserved);
1781 ISP_IOXPUT_16(isp, src->rsp.m2._reserved2,
1782 &dst->rsp.m2._reserved2);
1783 ISP_IOXPUT_16(isp, src->rsp.m2._reserved3,
1784 &dst->rsp.m2._reserved3);
1785 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
1786 &dst->rsp.m2.ct_datalen);
1787 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1788 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1789 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1790 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1265 }
1266}
1267
1268void
1791 }
1792}
1793
1794void
1269isp_put_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1795isp_put_ctio2e(ispsoftc_t *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
1270{
1271 int i;
1796{
1797 int i;
1272 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1273 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1274 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1275 ISP_IOXPUT_16(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1276 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1277 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1278 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1279 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1280 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1281 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff);
1282 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1283 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved,
1284 &ctdst->rsp.m0._reserved);
1285 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2,
1286 &ctdst->rsp.m0._reserved2);
1287 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status,
1288 &ctdst->rsp.m0.ct_scsi_status);
1289 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen,
1290 &ctdst->rsp.m0.ct_xfrlen);
1291 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1798 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
1799 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
1800 ISP_IOXPUT_16(isp, src->ct_iid, &dst->ct_iid);
1801 ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
1802 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
1803 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
1804 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
1805 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
1806 ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
1807 if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1808 ISP_IOXPUT_32(isp, src->rsp.m0._reserved,
1809 &dst->rsp.m0._reserved);
1810 ISP_IOXPUT_16(isp, src->rsp.m0._reserved2,
1811 &dst->rsp.m0._reserved2);
1812 ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status,
1813 &dst->rsp.m0.ct_scsi_status);
1814 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
1815 &dst->rsp.m0.ct_xfrlen);
1816 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1292 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1293 ISP_IOXPUT_32(isp,
1817 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1818 ISP_IOXPUT_32(isp,
1294 ctsrc->rsp.m0.ct_dataseg[i].ds_base,
1295 &ctdst->rsp.m0.ct_dataseg[i].ds_base);
1819 src->rsp.m0.u.ct_dataseg[i].ds_base,
1820 &dst->rsp.m0.u.ct_dataseg[i].ds_base);
1296 ISP_IOXPUT_32(isp,
1821 ISP_IOXPUT_32(isp,
1297 ctsrc->rsp.m0.ct_dataseg[i].ds_count,
1298 &ctdst->rsp.m0.ct_dataseg[i].ds_count);
1822 src->rsp.m0.u.ct_dataseg[i].ds_count,
1823 &dst->rsp.m0.u.ct_dataseg[i].ds_count);
1299 }
1824 }
1300 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1825 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1301 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1302 ISP_IOXPUT_32(isp,
1826 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1827 ISP_IOXPUT_32(isp,
1303 ctsrc->rsp.m0.ct_dataseg64[i].ds_base,
1304 &ctdst->rsp.m0.ct_dataseg64[i].ds_base);
1828 src->rsp.m0.u.ct_dataseg64[i].ds_base,
1829 &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
1305 ISP_IOXPUT_32(isp,
1830 ISP_IOXPUT_32(isp,
1306 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi,
1307 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi);
1831 src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
1832 &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
1308 ISP_IOXPUT_32(isp,
1833 ISP_IOXPUT_32(isp,
1309 ctsrc->rsp.m0.ct_dataseg64[i].ds_count,
1310 &ctdst->rsp.m0.ct_dataseg64[i].ds_count);
1834 src->rsp.m0.u.ct_dataseg64[i].ds_count,
1835 &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
1311 }
1836 }
1312 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1313 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type,
1314 &ctdst->rsp.m0.ct_dslist.ds_type);
1315 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment,
1316 &ctdst->rsp.m0.ct_dslist.ds_segment);
1317 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base,
1318 &ctdst->rsp.m0.ct_dslist.ds_base);
1837 } else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1838 ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type,
1839 &dst->rsp.m0.u.ct_dslist.ds_type);
1840 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment,
1841 &dst->rsp.m0.u.ct_dslist.ds_segment);
1842 ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base,
1843 &dst->rsp.m0.u.ct_dslist.ds_base);
1319 }
1844 }
1320 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1321 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved,
1322 &ctdst->rsp.m1._reserved);
1323 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2,
1324 &ctdst->rsp.m1._reserved2);
1325 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen,
1326 &ctdst->rsp.m1.ct_senselen);
1327 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status,
1328 &ctdst->rsp.m1.ct_scsi_status);
1329 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen,
1330 &ctdst->rsp.m1.ct_resplen);
1845 } else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1846 ISP_IOXPUT_16(isp, src->rsp.m1._reserved,
1847 &dst->rsp.m1._reserved);
1848 ISP_IOXPUT_16(isp, src->rsp.m1._reserved2,
1849 &dst->rsp.m1._reserved2);
1850 ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen,
1851 &dst->rsp.m1.ct_senselen);
1852 ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status,
1853 &dst->rsp.m1.ct_scsi_status);
1854 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
1855 &dst->rsp.m1.ct_resplen);
1331 for (i = 0; i < MAXRESPLEN; i++) {
1856 for (i = 0; i < MAXRESPLEN; i++) {
1332 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i],
1333 &ctdst->rsp.m1.ct_resp[i]);
1857 ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
1858 &dst->rsp.m1.ct_resp[i]);
1334 }
1335 } else {
1859 }
1860 } else {
1336 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved,
1337 &ctdst->rsp.m2._reserved);
1338 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2,
1339 &ctdst->rsp.m2._reserved2);
1340 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3,
1341 &ctdst->rsp.m2._reserved3);
1342 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen,
1343 &ctdst->rsp.m2.ct_datalen);
1344 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1345 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1346 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1347 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1861 ISP_IOXPUT_32(isp, src->rsp.m2._reserved,
1862 &dst->rsp.m2._reserved);
1863 ISP_IOXPUT_16(isp, src->rsp.m2._reserved2,
1864 &dst->rsp.m2._reserved2);
1865 ISP_IOXPUT_16(isp, src->rsp.m2._reserved3,
1866 &dst->rsp.m2._reserved3);
1867 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
1868 &dst->rsp.m2.ct_datalen);
1869 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1870 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1871 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1872 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1348 }
1349}
1350
1351void
1873 }
1874}
1875
1876void
1352isp_get_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1877isp_put_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
1353{
1878{
1354 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1355 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1356 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1357 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1358 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1359 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1360 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1361 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1362 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1363 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1364 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1365 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1879 int i;
1880
1881 isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
1882 ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
1883 ISP_IOXPUT_16(isp, src->ct_nphdl, &dst->ct_nphdl);
1884 ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
1885 ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
1886 ISP_IOXPUT_8(isp, src->ct_vpindex, &dst->ct_vpindex);
1887 ISP_IOXPUT_8(isp, src->ct_xflags, &dst->ct_xflags);
1888 ISP_IOXPUT_16(isp, src->ct_iid_lo, &dst->ct_iid_lo);
1889 ISP_IOXPUT_8(isp, src->ct_iid_hi, &dst->ct_iid_hi);
1890 ISP_IOXPUT_8(isp, src->ct_reserved, &dst->ct_reserved);
1891 ISP_IOXPUT_32(isp, src->ct_rxid, &dst->ct_rxid);
1892 ISP_IOXPUT_16(isp, src->ct_senselen, &dst->ct_senselen);
1893 ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
1894 ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
1895 ISP_IOXPUT_16(isp, src->ct_oxid, &dst->ct_oxid);
1896 ISP_IOXPUT_16(isp, src->ct_scsi_status, &dst->ct_scsi_status);
1897 if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
1898 ISP_IOXPUT_32(isp, src->rsp.m0.reloff, &dst->rsp.m0.reloff);
1899 ISP_IOXPUT_32(isp, src->rsp.m0.reserved0,
1900 &dst->rsp.m0.reserved0);
1901 ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
1902 &dst->rsp.m0.ct_xfrlen);
1903 ISP_IOXPUT_32(isp, src->rsp.m0.reserved1,
1904 &dst->rsp.m0.reserved1);
1905 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_base,
1906 &dst->rsp.m0.ds.ds_base);
1907 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_basehi,
1908 &dst->rsp.m0.ds.ds_basehi);
1909 ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_count,
1910 &dst->rsp.m0.ds.ds_count);
1911 } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
1912 ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
1913 &dst->rsp.m1.ct_resplen);
1914 ISP_IOXPUT_16(isp, src->rsp.m1.reserved, &dst->rsp.m1.reserved);
1915 for (i = 0; i < MAXRESPLEN_24XX; i++) {
1916 ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
1917 &dst->rsp.m1.ct_resp[i]);
1918 }
1919 } else {
1920 ISP_IOXPUT_32(isp, src->rsp.m2.reserved0,
1921 &dst->rsp.m2.reserved0);
1922 ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
1923 &dst->rsp.m2.ct_datalen);
1924 ISP_IOXPUT_32(isp, src->rsp.m2.reserved1,
1925 &dst->rsp.m2.reserved1);
1926 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1927 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1928 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi,
1929 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
1930 ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1931 &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1932 }
1366}
1367
1933}
1934
1935
1368void
1936void
1369isp_get_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1937isp_get_ctio2(ispsoftc_t *isp, ct2_entry_t *src, ct2_entry_t *dst)
1370{
1938{
1371 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1372 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1373 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1374 ISP_IOXGET_16(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1375 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1376 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1377 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1378 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1379 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1380 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1381 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1939 int i;
1940
1941 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
1942 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
1943 ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
1944 ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
1945 ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
1946 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
1947 ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
1948 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
1949 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
1950 ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
1951 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
1952 if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1953 ISP_IOXGET_32(isp, &src->rsp.m0._reserved,
1954 dst->rsp.m0._reserved);
1955 ISP_IOXGET_16(isp, &src->rsp.m0._reserved2,
1956 dst->rsp.m0._reserved2);
1957 ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status,
1958 dst->rsp.m0.ct_scsi_status);
1959 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
1960 dst->rsp.m0.ct_xfrlen);
1961 if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1962 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1963 ISP_IOXGET_32(isp,
1964 &src->rsp.m0.u.ct_dataseg[i].ds_base,
1965 dst->rsp.m0.u.ct_dataseg[i].ds_base);
1966 ISP_IOXGET_32(isp,
1967 &src->rsp.m0.u.ct_dataseg[i].ds_count,
1968 dst->rsp.m0.u.ct_dataseg[i].ds_count);
1969 }
1970 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1971 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1972 ISP_IOXGET_32(isp,
1973 &src->rsp.m0.u.ct_dataseg64[i].ds_base,
1974 dst->rsp.m0.u.ct_dataseg64[i].ds_base);
1975 ISP_IOXGET_32(isp,
1976 &src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
1977 dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
1978 ISP_IOXGET_32(isp,
1979 &src->rsp.m0.u.ct_dataseg64[i].ds_count,
1980 dst->rsp.m0.u.ct_dataseg64[i].ds_count);
1981 }
1982 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1983 ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type,
1984 dst->rsp.m0.u.ct_dslist.ds_type);
1985 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment,
1986 dst->rsp.m0.u.ct_dslist.ds_segment);
1987 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base,
1988 dst->rsp.m0.u.ct_dslist.ds_base);
1989 }
1990 } else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1991 ISP_IOXGET_16(isp, &src->rsp.m1._reserved,
1992 dst->rsp.m1._reserved);
1993 ISP_IOXGET_16(isp, &src->rsp.m1._reserved2,
1994 dst->rsp.m1._reserved2);
1995 ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen,
1996 dst->rsp.m1.ct_senselen);
1997 ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status,
1998 dst->rsp.m1.ct_scsi_status);
1999 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
2000 dst->rsp.m1.ct_resplen);
2001 for (i = 0; i < MAXRESPLEN; i++) {
2002 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
2003 dst->rsp.m1.ct_resp[i]);
2004 }
2005 } else {
2006 ISP_IOXGET_32(isp, &src->rsp.m2._reserved,
2007 dst->rsp.m2._reserved);
2008 ISP_IOXGET_16(isp, &src->rsp.m2._reserved2,
2009 dst->rsp.m2._reserved2);
2010 ISP_IOXGET_16(isp, &src->rsp.m2._reserved3,
2011 dst->rsp.m2._reserved3);
2012 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
2013 dst->rsp.m2.ct_datalen);
2014 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
2015 dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
2016 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
2017 dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
2018 }
1382}
1383
1384void
2019}
2020
2021void
2022isp_get_ctio2e(ispsoftc_t *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
2023{
2024 int i;
2025
2026 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
2027 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
2028 ISP_IOXGET_16(isp, &src->ct_iid, dst->ct_iid);
2029 ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
2030 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
2031 ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
2032 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
2033 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
2034 ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
2035 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
2036 if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
2037 ISP_IOXGET_32(isp, &src->rsp.m0._reserved,
2038 dst->rsp.m0._reserved);
2039 ISP_IOXGET_16(isp, &src->rsp.m0._reserved2,
2040 dst->rsp.m0._reserved2);
2041 ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status,
2042 dst->rsp.m0.ct_scsi_status);
2043 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
2044 dst->rsp.m0.ct_xfrlen);
2045 if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
2046 for (i = 0; i < ISP_RQDSEG_T2; i++) {
2047 ISP_IOXGET_32(isp,
2048 &src->rsp.m0.u.ct_dataseg[i].ds_base,
2049 dst->rsp.m0.u.ct_dataseg[i].ds_base);
2050 ISP_IOXGET_32(isp,
2051 &src->rsp.m0.u.ct_dataseg[i].ds_count,
2052 dst->rsp.m0.u.ct_dataseg[i].ds_count);
2053 }
2054 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
2055 for (i = 0; i < ISP_RQDSEG_T3; i++) {
2056 ISP_IOXGET_32(isp,
2057 &src->rsp.m0.u.ct_dataseg64[i].ds_base,
2058 dst->rsp.m0.u.ct_dataseg64[i].ds_base);
2059 ISP_IOXGET_32(isp,
2060 &src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
2061 dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
2062 ISP_IOXGET_32(isp,
2063 &src->rsp.m0.u.ct_dataseg64[i].ds_count,
2064 dst->rsp.m0.u.ct_dataseg64[i].ds_count);
2065 }
2066 } else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
2067 ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type,
2068 dst->rsp.m0.u.ct_dslist.ds_type);
2069 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment,
2070 dst->rsp.m0.u.ct_dslist.ds_segment);
2071 ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base,
2072 dst->rsp.m0.u.ct_dslist.ds_base);
2073 }
2074 } else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
2075 ISP_IOXGET_16(isp, &src->rsp.m1._reserved,
2076 dst->rsp.m1._reserved);
2077 ISP_IOXGET_16(isp, &src->rsp.m1._reserved2,
2078 dst->rsp.m1._reserved2);
2079 ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen,
2080 dst->rsp.m1.ct_senselen);
2081 ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status,
2082 dst->rsp.m1.ct_scsi_status);
2083 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
2084 dst->rsp.m1.ct_resplen);
2085 for (i = 0; i < MAXRESPLEN; i++) {
2086 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
2087 dst->rsp.m1.ct_resp[i]);
2088 }
2089 } else {
2090 ISP_IOXGET_32(isp, &src->rsp.m2._reserved,
2091 dst->rsp.m2._reserved);
2092 ISP_IOXGET_16(isp, &src->rsp.m2._reserved2,
2093 dst->rsp.m2._reserved2);
2094 ISP_IOXGET_16(isp, &src->rsp.m2._reserved3,
2095 dst->rsp.m2._reserved3);
2096 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
2097 dst->rsp.m2.ct_datalen);
2098 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
2099 dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
2100 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
2101 dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
2102 }
2103}
2104
2105void
2106isp_get_ctio7(ispsoftc_t *isp, ct7_entry_t *src, ct7_entry_t *dst)
2107{
2108 int i;
2109
2110 isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
2111 ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
2112 ISP_IOXGET_16(isp, &src->ct_nphdl, dst->ct_nphdl);
2113 ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
2114 ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
2115 ISP_IOXGET_8(isp, &src->ct_vpindex, dst->ct_vpindex);
2116 ISP_IOXGET_8(isp, &src->ct_xflags, dst->ct_xflags);
2117 ISP_IOXGET_16(isp, &src->ct_iid_lo, dst->ct_iid_lo);
2118 ISP_IOXGET_8(isp, &src->ct_iid_hi, dst->ct_iid_hi);
2119 ISP_IOXGET_8(isp, &src->ct_reserved, dst->ct_reserved);
2120 ISP_IOXGET_32(isp, &src->ct_rxid, dst->ct_rxid);
2121 ISP_IOXGET_16(isp, &src->ct_senselen, dst->ct_senselen);
2122 ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
2123 ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
2124 ISP_IOXGET_16(isp, &src->ct_oxid, dst->ct_oxid);
2125 ISP_IOXGET_16(isp, &src->ct_scsi_status, dst->ct_scsi_status);
2126 if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
2127 ISP_IOXGET_32(isp, &src->rsp.m0.reloff, dst->rsp.m0.reloff);
2128 ISP_IOXGET_32(isp, &src->rsp.m0.reserved0,
2129 dst->rsp.m0.reserved0);
2130 ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
2131 dst->rsp.m0.ct_xfrlen);
2132 ISP_IOXGET_32(isp, &src->rsp.m0.reserved1,
2133 dst->rsp.m0.reserved1);
2134 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_base,
2135 dst->rsp.m0.ds.ds_base);
2136 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_basehi,
2137 dst->rsp.m0.ds.ds_basehi);
2138 ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_count,
2139 dst->rsp.m0.ds.ds_count);
2140 } else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
2141 ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
2142 dst->rsp.m1.ct_resplen);
2143 ISP_IOXGET_16(isp, &src->rsp.m1.reserved, dst->rsp.m1.reserved);
2144 for (i = 0; i < MAXRESPLEN_24XX; i++) {
2145 ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
2146 dst->rsp.m1.ct_resp[i]);
2147 }
2148 } else {
2149 ISP_IOXGET_32(isp, &src->rsp.m2.reserved0,
2150 dst->rsp.m2.reserved0);
2151 ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
2152 dst->rsp.m2.ct_datalen);
2153 ISP_IOXGET_32(isp, &src->rsp.m2.reserved1,
2154 dst->rsp.m2.reserved1);
2155 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
2156 dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
2157 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi,
2158 dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
2159 ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
2160 dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
2161 }
2162}
2163
2164void
1385isp_put_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1386{
1387 int i;
2165isp_put_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
2166{
2167 int i;
1388 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
2168 isp_put_hdr(isp, &lesrc->le_header, &ledst->le_header);
1389 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
1390 if (ISP_IS_SBUS(isp)) {
1391 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
1392 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
1393 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);
1394 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops);
1395 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2);
1396 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status);

--- 20 unchanged lines hidden (view full) ---

1417 &ledst->le_reserved3[i]);
1418 }
1419}
1420
1421void
1422isp_get_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1423{
1424 int i;
2169 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
2170 if (ISP_IS_SBUS(isp)) {
2171 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
2172 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
2173 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);
2174 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops);
2175 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2);
2176 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status);

--- 20 unchanged lines hidden (view full) ---

2197 &ledst->le_reserved3[i]);
2198 }
2199}
2200
2201void
2202isp_get_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
2203{
2204 int i;
1425 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
2205 isp_get_hdr(isp, &lesrc->le_header, &ledst->le_header);
1426 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
1427 if (ISP_IS_SBUS(isp)) {
1428 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
1429 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
1430 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);
1431 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops);
1432 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2);
1433 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status);

--- 17 unchanged lines hidden (view full) ---

1451 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
1452 for (i = 0; i < 20; i++) {
1453 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
1454 ledst->le_reserved3[i]);
1455 }
1456}
1457
1458void
2206 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
2207 if (ISP_IS_SBUS(isp)) {
2208 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
2209 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
2210 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);
2211 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops);
2212 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2);
2213 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status);

--- 17 unchanged lines hidden (view full) ---

2231 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
2232 for (i = 0; i < 20; i++) {
2233 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
2234 ledst->le_reserved3[i]);
2235 }
2236}
2237
2238void
1459isp_put_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst)
2239isp_put_notify(ispsoftc_t *isp, in_entry_t *src, in_entry_t *dst)
1460{
1461 int i;
2240{
2241 int i;
1462 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1463 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
2242 isp_put_hdr(isp, &src->in_header, &dst->in_header);
2243 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
1464 if (ISP_IS_SBUS(isp)) {
2244 if (ISP_IS_SBUS(isp)) {
1465 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
1466 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
1467 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);
1468 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_reserved2);
1469 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_rsvd2);
1470 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_status);
1471 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_type);
1472 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_val);
2245 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_iid);
2246 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_lun);
2247 ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_tgt);
2248 ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_reserved2);
2249 ISP_IOXPUT_8(isp, src->in_status, &dst->in_rsvd2);
2250 ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_status);
2251 ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_type);
2252 ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_val);
1473 } else {
2253 } else {
1474 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1475 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1476 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_reserved2);
1477 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_tgt);
1478 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_status);
1479 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_rsvd2);
1480 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_val);
1481 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_type);
2254 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
2255 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
2256 ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_reserved2);
2257 ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_tgt);
2258 ISP_IOXPUT_8(isp, src->in_status, &dst->in_status);
2259 ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_rsvd2);
2260 ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_val);
2261 ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_type);
1482 }
2262 }
1483 ISP_IOXPUT_32(isp, insrc->in_flags, &indst->in_flags);
1484 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
2263 ISP_IOXPUT_32(isp, src->in_flags, &dst->in_flags);
2264 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
1485 for (i = 0; i < IN_MSGLEN; i++) {
2265 for (i = 0; i < IN_MSGLEN; i++) {
1486 ISP_IOXPUT_8(isp, insrc->in_msg[i], &indst->in_msg[i]);
2266 ISP_IOXPUT_8(isp, src->in_msg[i], &dst->in_msg[i]);
1487 }
1488 for (i = 0; i < IN_RSVDLEN; i++) {
2267 }
2268 for (i = 0; i < IN_RSVDLEN; i++) {
1489 ISP_IOXPUT_8(isp, insrc->in_reserved3[i],
1490 &indst->in_reserved3[i]);
2269 ISP_IOXPUT_8(isp, src->in_reserved3[i],
2270 &dst->in_reserved3[i]);
1491 }
1492 for (i = 0; i < QLTM_SENSELEN; i++) {
2271 }
2272 for (i = 0; i < QLTM_SENSELEN; i++) {
1493 ISP_IOXPUT_8(isp, insrc->in_sense[i],
1494 &indst->in_sense[i]);
2273 ISP_IOXPUT_8(isp, src->in_sense[i],
2274 &dst->in_sense[i]);
1495 }
1496}
1497
1498void
2275 }
2276}
2277
2278void
1499isp_get_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst)
2279isp_get_notify(ispsoftc_t *isp, in_entry_t *src, in_entry_t *dst)
1500{
1501 int i;
2280{
2281 int i;
1502 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1503 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
2282 isp_get_hdr(isp, &src->in_header, &dst->in_header);
2283 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
1504 if (ISP_IS_SBUS(isp)) {
2284 if (ISP_IS_SBUS(isp)) {
1505 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
1506 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
1507 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);
1508 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_reserved2);
1509 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_rsvd2);
1510 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_status);
1511 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_type);
1512 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_val);
2285 ISP_IOXGET_8(isp, &src->in_lun, dst->in_iid);
2286 ISP_IOXGET_8(isp, &src->in_iid, dst->in_lun);
2287 ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_tgt);
2288 ISP_IOXGET_8(isp, &src->in_tgt, dst->in_reserved2);
2289 ISP_IOXGET_8(isp, &src->in_status, dst->in_rsvd2);
2290 ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_status);
2291 ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_type);
2292 ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_val);
1513 } else {
2293 } else {
1514 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1515 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1516 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_reserved2);
1517 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_tgt);
1518 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_status);
1519 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_rsvd2);
1520 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_val);
1521 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_type);
2294 ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
2295 ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
2296 ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_reserved2);
2297 ISP_IOXGET_8(isp, &src->in_tgt, dst->in_tgt);
2298 ISP_IOXGET_8(isp, &src->in_status, dst->in_status);
2299 ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_rsvd2);
2300 ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_val);
2301 ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_type);
1522 }
2302 }
1523 ISP_IOXGET_32(isp, &insrc->in_flags, indst->in_flags);
1524 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
2303 ISP_IOXGET_32(isp, &src->in_flags, dst->in_flags);
2304 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
1525 for (i = 0; i < IN_MSGLEN; i++) {
2305 for (i = 0; i < IN_MSGLEN; i++) {
1526 ISP_IOXGET_8(isp, &insrc->in_msg[i], indst->in_msg[i]);
2306 ISP_IOXGET_8(isp, &src->in_msg[i], dst->in_msg[i]);
1527 }
1528 for (i = 0; i < IN_RSVDLEN; i++) {
2307 }
2308 for (i = 0; i < IN_RSVDLEN; i++) {
1529 ISP_IOXGET_8(isp, &insrc->in_reserved3[i],
1530 indst->in_reserved3[i]);
2309 ISP_IOXGET_8(isp, &src->in_reserved3[i],
2310 dst->in_reserved3[i]);
1531 }
1532 for (i = 0; i < QLTM_SENSELEN; i++) {
2311 }
2312 for (i = 0; i < QLTM_SENSELEN; i++) {
1533 ISP_IOXGET_8(isp, &insrc->in_sense[i],
1534 indst->in_sense[i]);
2313 ISP_IOXGET_8(isp, &src->in_sense[i],
2314 dst->in_sense[i]);
1535 }
1536}
1537
1538void
2315 }
2316}
2317
2318void
1539isp_put_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc,
1540 in_fcentry_t *indst)
2319isp_put_notify_fc(ispsoftc_t *isp, in_fcentry_t *src,
2320 in_fcentry_t *dst)
1541{
2321{
1542 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1543 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1544 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1545 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1546 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1547 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1548 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1549 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1550 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
2322 isp_put_hdr(isp, &src->in_header, &dst->in_header);
2323 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
2324 ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
2325 ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
2326 ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
2327 ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
2328 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
2329 ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
2330 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
1551}
1552
1553void
2331}
2332
2333void
1554isp_put_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc,
1555 in_fcentry_e_t *indst)
2334isp_put_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *src,
2335 in_fcentry_e_t *dst)
1556{
2336{
1557 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1558 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1559 ISP_IOXPUT_16(isp, insrc->in_iid, &indst->in_iid);
1560 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1561 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1562 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1563 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1564 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
2337 isp_put_hdr(isp, &src->in_header, &dst->in_header);
2338 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
2339 ISP_IOXPUT_16(isp, src->in_iid, &dst->in_iid);
2340 ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
2341 ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
2342 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
2343 ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
2344 ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
1565}
1566
1567void
2345}
2346
2347void
1568isp_get_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc,
1569 in_fcentry_t *indst)
2348isp_put_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src,
2349 in_fcentry_24xx_t *dst)
1570{
2350{
1571 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1572 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1573 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1574 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1575 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1576 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1577 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1578 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1579 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
2351 int i;
2352
2353 isp_put_hdr(isp, &src->in_header, &dst->in_header);
2354 ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
2355 ISP_IOXPUT_16(isp, src->in_nphdl, &dst->in_nphdl);
2356 ISP_IOXPUT_16(isp, src->in_reserved1, &dst->in_reserved1);
2357 ISP_IOXPUT_16(isp, src->in_flags, &dst->in_flags);
2358 ISP_IOXPUT_16(isp, src->in_srr_rxid, &dst->in_srr_rxid);
2359 ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
2360 ISP_IOXPUT_8(isp, src->in_status_subcode, &dst->in_status_subcode);
2361 ISP_IOXPUT_16(isp, src->in_reserved2, &dst->in_reserved2);
2362 ISP_IOXPUT_32(isp, src->in_rxid, &dst->in_rxid);
2363 ISP_IOXPUT_16(isp, src->in_srr_reloff_hi, &dst->in_srr_reloff_hi);
2364 ISP_IOXPUT_16(isp, src->in_srr_reloff_lo, &dst->in_srr_reloff_lo);
2365 ISP_IOXPUT_16(isp, src->in_srr_iu, &dst->in_srr_iu);
2366 ISP_IOXPUT_16(isp, src->in_srr_oxid, &dst->in_srr_oxid);
2367 for (i = 0; i < 18; i++) {
2368 ISP_IOXPUT_8(isp, src->in_reserved3[i], &dst->in_reserved3[i]);
2369 }
2370 ISP_IOXPUT_8(isp, src->in_reserved4, &dst->in_reserved4);
2371 ISP_IOXPUT_8(isp, src->in_vpindex, &dst->in_vpindex);
2372 ISP_IOXPUT_32(isp, src->in_reserved5, &dst->in_reserved5);
2373 ISP_IOXPUT_16(isp, src->in_portid_lo, &dst->in_portid_lo);
2374 ISP_IOXPUT_8(isp, src->in_portid_hi, &dst->in_portid_hi);
2375 ISP_IOXPUT_8(isp, src->in_reserved6, &dst->in_reserved6);
2376 ISP_IOXPUT_16(isp, src->in_reserved7, &dst->in_reserved7);
2377 ISP_IOXPUT_16(isp, src->in_oxid, &dst->in_oxid);
1580}
1581
1582void
2378}
2379
2380void
1583isp_get_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc,
1584 in_fcentry_e_t *indst)
2381isp_get_notify_fc(ispsoftc_t *isp, in_fcentry_t *src,
2382 in_fcentry_t *dst)
1585{
2383{
1586 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1587 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1588 ISP_IOXGET_16(isp, &insrc->in_iid, indst->in_iid);
1589 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1590 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1591 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1592 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1593 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
2384 isp_get_hdr(isp, &src->in_header, &dst->in_header);
2385 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
2386 ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
2387 ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
2388 ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
2389 ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
2390 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
2391 ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
2392 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
1594}
1595
1596void
2393}
2394
2395void
1597isp_put_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst)
2396isp_get_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *src,
2397 in_fcentry_e_t *dst)
1598{
2398{
2399 isp_get_hdr(isp, &src->in_header, &dst->in_header);
2400 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
2401 ISP_IOXGET_16(isp, &src->in_iid, dst->in_iid);
2402 ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
2403 ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
2404 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
2405 ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
2406 ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
2407}
2408
2409void
2410isp_get_notify_24xx(ispsoftc_t *isp, in_fcentry_24xx_t *src,
2411 in_fcentry_24xx_t *dst)
2412{
1599 int i;
2413 int i;
1600 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1601 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
2414
2415 isp_get_hdr(isp, &src->in_header, &dst->in_header);
2416 ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
2417 ISP_IOXGET_16(isp, &src->in_nphdl, dst->in_nphdl);
2418 ISP_IOXGET_16(isp, &src->in_reserved1, dst->in_reserved1);
2419 ISP_IOXGET_16(isp, &src->in_flags, dst->in_flags);
2420 ISP_IOXGET_16(isp, &src->in_srr_rxid, dst->in_srr_rxid);
2421 ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
2422 ISP_IOXGET_8(isp, &src->in_status_subcode, dst->in_status_subcode);
2423 ISP_IOXGET_16(isp, &src->in_reserved2, dst->in_reserved2);
2424 ISP_IOXGET_32(isp, &src->in_rxid, dst->in_rxid);
2425 ISP_IOXGET_16(isp, &src->in_srr_reloff_hi, dst->in_srr_reloff_hi);
2426 ISP_IOXGET_16(isp, &src->in_srr_reloff_lo, dst->in_srr_reloff_lo);
2427 ISP_IOXGET_16(isp, &src->in_srr_iu, dst->in_srr_iu);
2428 ISP_IOXGET_16(isp, &src->in_srr_oxid, dst->in_srr_oxid);
2429 for (i = 0; i < 18; i++) {
2430 ISP_IOXGET_8(isp, &src->in_reserved3[i], dst->in_reserved3[i]);
2431 }
2432 ISP_IOXGET_8(isp, &src->in_reserved4, dst->in_reserved4);
2433 ISP_IOXGET_8(isp, &src->in_vpindex, dst->in_vpindex);
2434 ISP_IOXGET_32(isp, &src->in_reserved5, dst->in_reserved5);
2435 ISP_IOXGET_16(isp, &src->in_portid_lo, dst->in_portid_lo);
2436 ISP_IOXGET_8(isp, &src->in_portid_hi, dst->in_portid_hi);
2437 ISP_IOXGET_8(isp, &src->in_reserved6, dst->in_reserved6);
2438 ISP_IOXGET_16(isp, &src->in_reserved7, dst->in_reserved7);
2439 ISP_IOXGET_16(isp, &src->in_oxid, dst->in_oxid);
2440}
2441
2442void
2443isp_put_notify_ack(ispsoftc_t *isp, na_entry_t *src, na_entry_t *dst)
2444{
2445 int i;
2446 isp_put_hdr(isp, &src->na_header, &dst->na_header);
2447 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
1602 if (ISP_IS_SBUS(isp)) {
2448 if (ISP_IS_SBUS(isp)) {
1603 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
1604 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
1605 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);
1606 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_status);
2449 ISP_IOXPUT_8(isp, src->na_lun, &dst->na_iid);
2450 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_lun);
2451 ISP_IOXPUT_8(isp, src->na_status, &dst->na_event);
2452 ISP_IOXPUT_8(isp, src->na_event, &dst->na_status);
1607 } else {
2453 } else {
1608 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1609 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1610 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_status);
1611 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_event);
2454 ISP_IOXPUT_8(isp, src->na_lun, &dst->na_lun);
2455 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
2456 ISP_IOXPUT_8(isp, src->na_status, &dst->na_status);
2457 ISP_IOXPUT_8(isp, src->na_event, &dst->na_event);
1612 }
2458 }
1613 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
2459 ISP_IOXPUT_32(isp, src->na_flags, &dst->na_flags);
1614 for (i = 0; i < NA_RSVDLEN; i++) {
2460 for (i = 0; i < NA_RSVDLEN; i++) {
1615 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1616 &nadst->na_reserved3[i]);
2461 ISP_IOXPUT_16(isp, src->na_reserved3[i],
2462 &dst->na_reserved3[i]);
1617 }
1618}
1619
1620void
2463 }
2464}
2465
2466void
1621isp_get_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst)
2467isp_get_notify_ack(ispsoftc_t *isp, na_entry_t *src, na_entry_t *dst)
1622{
1623 int i;
2468{
2469 int i;
1624 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1625 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
2470 isp_get_hdr(isp, &src->na_header, &dst->na_header);
2471 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
1626 if (ISP_IS_SBUS(isp)) {
2472 if (ISP_IS_SBUS(isp)) {
1627 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
1628 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
1629 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);
1630 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_status);
2473 ISP_IOXGET_8(isp, &src->na_lun, dst->na_iid);
2474 ISP_IOXGET_8(isp, &src->na_iid, dst->na_lun);
2475 ISP_IOXGET_8(isp, &src->na_status, dst->na_event);
2476 ISP_IOXGET_8(isp, &src->na_event, dst->na_status);
1631 } else {
2477 } else {
1632 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1633 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1634 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_status);
1635 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_event);
2478 ISP_IOXGET_8(isp, &src->na_lun, dst->na_lun);
2479 ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
2480 ISP_IOXGET_8(isp, &src->na_status, dst->na_status);
2481 ISP_IOXGET_8(isp, &src->na_event, dst->na_event);
1636 }
2482 }
1637 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
2483 ISP_IOXGET_32(isp, &src->na_flags, dst->na_flags);
1638 for (i = 0; i < NA_RSVDLEN; i++) {
2484 for (i = 0; i < NA_RSVDLEN; i++) {
1639 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1640 nadst->na_reserved3[i]);
2485 ISP_IOXGET_16(isp, &src->na_reserved3[i],
2486 dst->na_reserved3[i]);
1641 }
1642}
1643
1644void
2487 }
2488}
2489
2490void
1645isp_put_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc,
1646 na_fcentry_t *nadst)
2491isp_put_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *src,
2492 na_fcentry_t *dst)
1647{
1648 int i;
2493{
2494 int i;
1649 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1650 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1651 ISP_IOXPUT_8(isp, nasrc->na_reserved1, &nadst->na_reserved1);
1652 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1653 ISP_IOXPUT_16(isp, nasrc->na_response, &nadst->na_response);
1654 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1655 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1656 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1657 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1658 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
2495 isp_put_hdr(isp, &src->na_header, &dst->na_header);
2496 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
2497 ISP_IOXPUT_8(isp, src->na_reserved1, &dst->na_reserved1);
2498 ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
2499 ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
2500 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
2501 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
2502 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
2503 ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
2504 ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
1659 for (i = 0; i < NA2_RSVDLEN; i++) {
2505 for (i = 0; i < NA2_RSVDLEN; i++) {
1660 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1661 &nadst->na_reserved3[i]);
2506 ISP_IOXPUT_16(isp, src->na_reserved3[i],
2507 &dst->na_reserved3[i]);
1662 }
1663}
1664
1665void
2508 }
2509}
2510
2511void
1666isp_put_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc,
1667 na_fcentry_e_t *nadst)
2512isp_put_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *src,
2513 na_fcentry_e_t *dst)
1668{
1669 int i;
2514{
2515 int i;
1670 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1671 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1672 ISP_IOXPUT_16(isp, nasrc->na_iid, &nadst->na_iid);
1673 ISP_IOXPUT_16(isp, nasrc->na_response, &nadst->na_response);
1674 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1675 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1676 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1677 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1678 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
2516 isp_put_hdr(isp, &src->na_header, &dst->na_header);
2517 ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
2518 ISP_IOXPUT_16(isp, src->na_iid, &dst->na_iid);
2519 ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
2520 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
2521 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
2522 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
2523 ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
2524 ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
1679 for (i = 0; i < NA2_RSVDLEN; i++) {
2525 for (i = 0; i < NA2_RSVDLEN; i++) {
1680 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1681 &nadst->na_reserved3[i]);
2526 ISP_IOXPUT_16(isp, src->na_reserved3[i],
2527 &dst->na_reserved3[i]);
1682 }
1683}
1684
1685void
2528 }
2529}
2530
2531void
1686isp_get_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc,
1687 na_fcentry_t *nadst)
2532isp_put_notify_24xx_ack(ispsoftc_t *isp, na_fcentry_24xx_t *src,
2533 na_fcentry_24xx_t *dst)
1688{
1689 int i;
2534{
2535 int i;
1690 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1691 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1692 ISP_IOXGET_8(isp, &nasrc->na_reserved1, nadst->na_reserved1);
1693 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1694 ISP_IOXGET_16(isp, &nasrc->na_response, nadst->na_response);
1695 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1696 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1697 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1698 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1699 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
2536
2537 isp_put_hdr(isp, &src->na_header, &dst->na_header);
2538 ISP_IOXPUT_32(isp, src->na_handle, &dst->na_handle);
2539 ISP_IOXPUT_16(isp, src->na_nphdl, &dst->na_nphdl);
2540 ISP_IOXPUT_16(isp, src->na_reserved1, &dst->na_reserved1);
2541 ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
2542 ISP_IOXPUT_16(isp, src->na_srr_rxid, &dst->na_srr_rxid);
2543 ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
2544 ISP_IOXPUT_8(isp, src->na_status_subcode, &dst->na_status_subcode);
2545 ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
2546 ISP_IOXPUT_32(isp, src->na_rxid, &dst->na_rxid);
2547 ISP_IOXPUT_16(isp, src->na_srr_reloff_hi, &dst->na_srr_reloff_hi);
2548 ISP_IOXPUT_16(isp, src->na_srr_reloff_lo, &dst->na_srr_reloff_lo);
2549 ISP_IOXPUT_16(isp, src->na_srr_iu, &dst->na_srr_iu);
2550 ISP_IOXPUT_16(isp, src->na_srr_flags, &dst->na_srr_flags);
2551 for (i = 0; i < 18; i++) {
2552 ISP_IOXPUT_8(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
2553 }
2554 ISP_IOXPUT_8(isp, src->na_reserved4, &dst->na_reserved4);
2555 ISP_IOXPUT_8(isp, src->na_vpindex, &dst->na_vpindex);
2556 ISP_IOXPUT_8(isp, src->na_srr_reject_vunique,
2557 &dst->na_srr_reject_vunique);
2558 ISP_IOXPUT_8(isp, src->na_srr_reject_explanation,
2559 &dst->na_srr_reject_explanation);
2560 ISP_IOXPUT_8(isp, src->na_srr_reject_code, &dst->na_srr_reject_code);
2561 ISP_IOXPUT_8(isp, src->na_reserved5, &dst->na_reserved5);
2562 for (i = 0; i < 6; i++) {
2563 ISP_IOXPUT_8(isp, src->na_reserved6[i], &dst->na_reserved6[i]);
2564 }
2565 ISP_IOXPUT_16(isp, src->na_oxid, &dst->na_oxid);
2566}
2567
2568void
2569isp_get_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *src,
2570 na_fcentry_t *dst)
2571{
2572 int i;
2573 isp_get_hdr(isp, &src->na_header, &dst->na_header);
2574 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
2575 ISP_IOXGET_8(isp, &src->na_reserved1, dst->na_reserved1);
2576 ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
2577 ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
2578 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
2579 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
2580 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
2581 ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
2582 ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
1700 for (i = 0; i < NA2_RSVDLEN; i++) {
2583 for (i = 0; i < NA2_RSVDLEN; i++) {
1701 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1702 nadst->na_reserved3[i]);
2584 ISP_IOXGET_16(isp, &src->na_reserved3[i],
2585 dst->na_reserved3[i]);
1703 }
1704}
1705
1706void
2586 }
2587}
2588
2589void
1707isp_get_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc,
1708 na_fcentry_e_t *nadst)
2590isp_get_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *src,
2591 na_fcentry_e_t *dst)
1709{
1710 int i;
2592{
2593 int i;
1711 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1712 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1713 ISP_IOXGET_16(isp, &nasrc->na_iid, nadst->na_iid);
1714 ISP_IOXGET_16(isp, &nasrc->na_response, nadst->na_response);
1715 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1716 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1717 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1718 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1719 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
2594 isp_get_hdr(isp, &src->na_header, &dst->na_header);
2595 ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
2596 ISP_IOXGET_16(isp, &src->na_iid, dst->na_iid);
2597 ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
2598 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
2599 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
2600 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
2601 ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
2602 ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
1720 for (i = 0; i < NA2_RSVDLEN; i++) {
2603 for (i = 0; i < NA2_RSVDLEN; i++) {
1721 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1722 nadst->na_reserved3[i]);
2604 ISP_IOXGET_16(isp, &src->na_reserved3[i],
2605 dst->na_reserved3[i]);
1723 }
1724}
2606 }
2607}
2608
2609void
2610isp_get_notify_ack_24xx(ispsoftc_t *isp, na_fcentry_24xx_t *src,
2611 na_fcentry_24xx_t *dst)
2612{
2613 int i;
2614
2615 isp_get_hdr(isp, &src->na_header, &dst->na_header);
2616 ISP_IOXGET_32(isp, &src->na_handle, dst->na_handle);
2617 ISP_IOXGET_16(isp, &src->na_nphdl, dst->na_nphdl);
2618 ISP_IOXGET_16(isp, &src->na_reserved1, dst->na_reserved1);
2619 ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
2620 ISP_IOXGET_16(isp, &src->na_srr_rxid, dst->na_srr_rxid);
2621 ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
2622 ISP_IOXGET_8(isp, &src->na_status_subcode, dst->na_status_subcode);
2623 ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
2624 ISP_IOXGET_32(isp, &src->na_rxid, dst->na_rxid);
2625 ISP_IOXGET_16(isp, &src->na_srr_reloff_hi, dst->na_srr_reloff_hi);
2626 ISP_IOXGET_16(isp, &src->na_srr_reloff_lo, dst->na_srr_reloff_lo);
2627 ISP_IOXGET_16(isp, &src->na_srr_iu, dst->na_srr_iu);
2628 ISP_IOXGET_16(isp, &src->na_srr_flags, dst->na_srr_flags);
2629 for (i = 0; i < 18; i++) {
2630 ISP_IOXGET_8(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
2631 }
2632 ISP_IOXGET_8(isp, &src->na_reserved4, dst->na_reserved4);
2633 ISP_IOXGET_8(isp, &src->na_vpindex, dst->na_vpindex);
2634 ISP_IOXGET_8(isp, &src->na_srr_reject_vunique,
2635 dst->na_srr_reject_vunique);
2636 ISP_IOXGET_8(isp, &src->na_srr_reject_explanation,
2637 dst->na_srr_reject_explanation);
2638 ISP_IOXGET_8(isp, &src->na_srr_reject_code, dst->na_srr_reject_code);
2639 ISP_IOXGET_8(isp, &src->na_reserved5, dst->na_reserved5);
2640 for (i = 0; i < 6; i++) {
2641 ISP_IOXGET_8(isp, &src->na_reserved6[i], dst->na_reserved6[i]);
2642 }
2643 ISP_IOXGET_16(isp, &src->na_oxid, dst->na_oxid);
2644}
2645
2646void
2647isp_get_abts(ispsoftc_t *isp, abts_t *src, abts_t *dst)
2648{
2649 int i;
2650
2651 isp_get_hdr(isp, &src->abts_header, &dst->abts_header);
2652 for (i = 0; i < 6; i++) {
2653 ISP_IOXGET_8(isp, &src->abts_reserved0[i],
2654 dst->abts_reserved0[i]);
2655 }
2656 ISP_IOXGET_16(isp, &src->abts_nphdl, dst->abts_nphdl);
2657 ISP_IOXGET_16(isp, &src->abts_reserved1, dst->abts_reserved1);
2658 ISP_IOXGET_16(isp, &src->abts_sof, dst->abts_sof);
2659 ISP_IOXGET_32(isp, &src->abts_rxid_abts, dst->abts_rxid_abts);
2660 ISP_IOXGET_16(isp, &src->abts_did_lo, dst->abts_did_lo);
2661 ISP_IOXGET_8(isp, &src->abts_did_hi, dst->abts_did_hi);
2662 ISP_IOXGET_8(isp, &src->abts_r_ctl, dst->abts_r_ctl);
2663 ISP_IOXGET_16(isp, &src->abts_sid_lo, dst->abts_sid_lo);
2664 ISP_IOXGET_8(isp, &src->abts_sid_hi, dst->abts_sid_hi);
2665 ISP_IOXGET_8(isp, &src->abts_cs_ctl, dst->abts_cs_ctl);
2666 ISP_IOXGET_16(isp, &src->abts_fs_ctl, dst->abts_fs_ctl);
2667 ISP_IOXGET_8(isp, &src->abts_f_ctl, dst->abts_f_ctl);
2668 ISP_IOXGET_8(isp, &src->abts_type, dst->abts_type);
2669 ISP_IOXGET_16(isp, &src->abts_seq_cnt, dst->abts_seq_cnt);
2670 ISP_IOXGET_8(isp, &src->abts_df_ctl, dst->abts_df_ctl);
2671 ISP_IOXGET_8(isp, &src->abts_seq_id, dst->abts_seq_id);
2672 ISP_IOXGET_16(isp, &src->abts_rx_id, dst->abts_rx_id);
2673 ISP_IOXGET_16(isp, &src->abts_ox_id, dst->abts_ox_id);
2674 ISP_IOXGET_32(isp, &src->abts_param, dst->abts_param);
2675 for (i = 0; i < 16; i++) {
2676 ISP_IOXGET_8(isp, &src->abts_reserved2[i],
2677 dst->abts_reserved2[i]);
2678 }
2679 ISP_IOXGET_32(isp, &src->abts_rxid_task, dst->abts_rxid_task);
2680}
2681
2682void
2683isp_put_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
2684{
2685 int i;
2686
2687 isp_put_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
2688 ISP_IOXPUT_32(isp, src->abts_rsp_handle, &dst->abts_rsp_handle);
2689 ISP_IOXPUT_16(isp, src->abts_rsp_status, &dst->abts_rsp_status);
2690 ISP_IOXPUT_16(isp, src->abts_rsp_nphdl, &dst->abts_rsp_nphdl);
2691 ISP_IOXPUT_16(isp, src->abts_rsp_ctl_flags, &dst->abts_rsp_ctl_flags);
2692 ISP_IOXPUT_16(isp, src->abts_rsp_sof, &dst->abts_rsp_sof);
2693 ISP_IOXPUT_32(isp, src->abts_rsp_rxid_abts, &dst->abts_rsp_rxid_abts);
2694 ISP_IOXPUT_16(isp, src->abts_rsp_did_lo, &dst->abts_rsp_did_lo);
2695 ISP_IOXPUT_8(isp, src->abts_rsp_did_hi, &dst->abts_rsp_did_hi);
2696 ISP_IOXPUT_8(isp, src->abts_rsp_r_ctl, &dst->abts_rsp_r_ctl);
2697 ISP_IOXPUT_16(isp, src->abts_rsp_sid_lo, &dst->abts_rsp_sid_lo);
2698 ISP_IOXPUT_8(isp, src->abts_rsp_sid_hi, &dst->abts_rsp_sid_hi);
2699 ISP_IOXPUT_8(isp, src->abts_rsp_cs_ctl, &dst->abts_rsp_cs_ctl);
2700 ISP_IOXPUT_16(isp, src->abts_rsp_f_ctl_lo, &dst->abts_rsp_f_ctl_lo);
2701 ISP_IOXPUT_8(isp, src->abts_rsp_f_ctl_hi, &dst->abts_rsp_f_ctl_hi);
2702 ISP_IOXPUT_8(isp, src->abts_rsp_type, &dst->abts_rsp_type);
2703 ISP_IOXPUT_16(isp, src->abts_rsp_seq_cnt, &dst->abts_rsp_seq_cnt);
2704 ISP_IOXPUT_8(isp, src->abts_rsp_df_ctl, &dst->abts_rsp_df_ctl);
2705 ISP_IOXPUT_8(isp, src->abts_rsp_seq_id, &dst->abts_rsp_seq_id);
2706 ISP_IOXPUT_16(isp, src->abts_rsp_rx_id, &dst->abts_rsp_rx_id);
2707 ISP_IOXPUT_16(isp, src->abts_rsp_ox_id, &dst->abts_rsp_ox_id);
2708 ISP_IOXPUT_32(isp, src->abts_rsp_param, &dst->abts_rsp_param);
2709 if (src->abts_rsp_r_ctl == BA_ACC) {
2710 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved,
2711 &dst->abts_rsp_payload.ba_acc.reserved);
2712 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.last_seq_id,
2713 &dst->abts_rsp_payload.ba_acc.last_seq_id);
2714 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.seq_id_valid,
2715 &dst->abts_rsp_payload.ba_acc.seq_id_valid);
2716 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_rx_id,
2717 &dst->abts_rsp_payload.ba_acc.aborted_rx_id);
2718 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_ox_id,
2719 &dst->abts_rsp_payload.ba_acc.aborted_ox_id);
2720 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.high_seq_cnt,
2721 &dst->abts_rsp_payload.ba_acc.high_seq_cnt);
2722 ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.low_seq_cnt,
2723 &dst->abts_rsp_payload.ba_acc.low_seq_cnt);
2724 for (i = 0; i < 4; i++) {
2725 ISP_IOXPUT_16(isp,
2726 src->abts_rsp_payload.ba_acc.reserved2[i],
2727 &dst->abts_rsp_payload.ba_acc.reserved2[i]);
2728 }
2729 } else if (src->abts_rsp_r_ctl == BA_RJT) {
2730 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.vendor_unique,
2731 &dst->abts_rsp_payload.ba_rjt.vendor_unique);
2732 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.explanation,
2733 &dst->abts_rsp_payload.ba_rjt.explanation);
2734 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reason,
2735 &dst->abts_rsp_payload.ba_rjt.reason);
2736 ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reserved,
2737 &dst->abts_rsp_payload.ba_rjt.reserved);
2738 for (i = 0; i < 12; i++) {
2739 ISP_IOXPUT_16(isp,
2740 src->abts_rsp_payload.ba_rjt.reserved2[i],
2741 &dst->abts_rsp_payload.ba_rjt.reserved2[i]);
2742 }
2743 } else {
2744 for (i = 0; i < 16; i++) {
2745 ISP_IOXPUT_8(isp, src->abts_rsp_payload.reserved[i],
2746 &dst->abts_rsp_payload.reserved[i]);
2747 }
2748 }
2749 ISP_IOXPUT_32(isp, src->abts_rsp_rxid_task, &dst->abts_rsp_rxid_task);
2750}
2751
2752void
2753isp_get_abts_rsp(ispsoftc_t *isp, abts_rsp_t *src, abts_rsp_t *dst)
2754{
2755 int i;
2756
2757 isp_get_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
2758 ISP_IOXGET_32(isp, &src->abts_rsp_handle, dst->abts_rsp_handle);
2759 ISP_IOXGET_16(isp, &src->abts_rsp_status, dst->abts_rsp_status);
2760 ISP_IOXGET_16(isp, &src->abts_rsp_nphdl, dst->abts_rsp_nphdl);
2761 ISP_IOXGET_16(isp, &src->abts_rsp_ctl_flags, dst->abts_rsp_ctl_flags);
2762 ISP_IOXGET_16(isp, &src->abts_rsp_sof, dst->abts_rsp_sof);
2763 ISP_IOXGET_32(isp, &src->abts_rsp_rxid_abts, dst->abts_rsp_rxid_abts);
2764 ISP_IOXGET_16(isp, &src->abts_rsp_did_lo, dst->abts_rsp_did_lo);
2765 ISP_IOXGET_8(isp, &src->abts_rsp_did_hi, dst->abts_rsp_did_hi);
2766 ISP_IOXGET_8(isp, &src->abts_rsp_r_ctl, dst->abts_rsp_r_ctl);
2767 ISP_IOXGET_16(isp, &src->abts_rsp_sid_lo, dst->abts_rsp_sid_lo);
2768 ISP_IOXGET_8(isp, &src->abts_rsp_sid_hi, dst->abts_rsp_sid_hi);
2769 ISP_IOXGET_8(isp, &src->abts_rsp_cs_ctl, dst->abts_rsp_cs_ctl);
2770 ISP_IOXGET_16(isp, &src->abts_rsp_f_ctl_lo, dst->abts_rsp_f_ctl_lo);
2771 ISP_IOXGET_8(isp, &src->abts_rsp_f_ctl_hi, dst->abts_rsp_f_ctl_hi);
2772 ISP_IOXGET_8(isp, &src->abts_rsp_type, dst->abts_rsp_type);
2773 ISP_IOXGET_16(isp, &src->abts_rsp_seq_cnt, dst->abts_rsp_seq_cnt);
2774 ISP_IOXGET_8(isp, &src->abts_rsp_df_ctl, dst->abts_rsp_df_ctl);
2775 ISP_IOXGET_8(isp, &src->abts_rsp_seq_id, dst->abts_rsp_seq_id);
2776 ISP_IOXGET_16(isp, &src->abts_rsp_rx_id, dst->abts_rsp_rx_id);
2777 ISP_IOXGET_16(isp, &src->abts_rsp_ox_id, dst->abts_rsp_ox_id);
2778 ISP_IOXGET_32(isp, &src->abts_rsp_param, dst->abts_rsp_param);
2779 for (i = 0; i < 8; i++) {
2780 ISP_IOXGET_8(isp, &src->abts_rsp_payload.rsp.reserved[i],
2781 dst->abts_rsp_payload.rsp.reserved[i]);
2782 }
2783 ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode1,
2784 dst->abts_rsp_payload.rsp.subcode1);
2785 ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode2,
2786 dst->abts_rsp_payload.rsp.subcode2);
2787 ISP_IOXGET_32(isp, &src->abts_rsp_rxid_task, dst->abts_rsp_rxid_task);
2788}
1725#endif /* ISP_TARGET_MODE */
2789#endif /* ISP_TARGET_MODE */
2790/*
2791 * vim:ts=8:sw=8
2792 */