Deleted Added
sdiff udiff text old ( 155228 ) new ( 155704 )
full compact
isp_library.c (155228) isp_library.c (155704)
1/*-
2 * Qlogic Host Adapter Internal Library Functions
3 *
4 * Copyright (c) 1999-2006 by Matthew Jacob
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions

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

21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 */
1/*-
2 * Qlogic Host Adapter Internal Library Functions
3 *
4 * Copyright (c) 1999-2006 by Matthew Jacob
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions

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

21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 */
29#ifdef __FreeBSD__
29#include <sys/cdefs.h>
30#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/sys/dev/isp/isp_library.c 155228 2006-02-02 21:31:34Z mjacob $");
31__FBSDID("$FreeBSD: head/sys/dev/isp/isp_library.c 155704 2006-02-15 00:31:48Z mjacob $");
32#endif
33
34#ifdef __NetBSD__
35#include <dev/ic/isp_netbsd.h>
36#endif
37#ifdef __FreeBSD__
31#include <dev/isp/isp_freebsd.h>
38#include <dev/isp/isp_freebsd.h>
39#endif
40#ifdef __OpenBSD__
41#include <dev/ic/isp_openbsd.h>
42#endif
43#ifdef __linux__
44#include "isp_linux.h"
45#endif
46#ifdef __svr4__
47#include "isp_solaris.h"
48#endif
32
33int
49
50int
34isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int16_t *handlep)
51isp_save_xs(ispsoftc_t *isp, XS_T *xs, uint16_t *handlep)
35{
36 int i, j;
37
38 for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) {
39 if (isp->isp_xflist[j] == NULL) {
40 break;
41 }
42 if (++j == isp->isp_maxcmds) {
43 j = 0;
44 }
45 }
46 if (i == isp->isp_maxcmds) {
47 return (-1);
48 }
49 isp->isp_xflist[j] = xs;
50 *handlep = j+1;
51 if (++j == isp->isp_maxcmds)
52 j = 0;
52{
53 int i, j;
54
55 for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) {
56 if (isp->isp_xflist[j] == NULL) {
57 break;
58 }
59 if (++j == isp->isp_maxcmds) {
60 j = 0;
61 }
62 }
63 if (i == isp->isp_maxcmds) {
64 return (-1);
65 }
66 isp->isp_xflist[j] = xs;
67 *handlep = j+1;
68 if (++j == isp->isp_maxcmds)
69 j = 0;
53 isp->isp_lasthdls = (u_int16_t)j;
70 isp->isp_lasthdls = (uint16_t)j;
54 return (0);
55}
56
57XS_T *
71 return (0);
72}
73
74XS_T *
58isp_find_xs(struct ispsoftc *isp, u_int16_t handle)
75isp_find_xs(ispsoftc_t *isp, uint16_t handle)
59{
76{
60 if (handle < 1 || handle > (u_int16_t) isp->isp_maxcmds) {
77 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) {
61 return (NULL);
62 } else {
63 return (isp->isp_xflist[handle - 1]);
64 }
65}
66
78 return (NULL);
79 } else {
80 return (isp->isp_xflist[handle - 1]);
81 }
82}
83
67u_int16_t
68isp_find_handle(struct ispsoftc *isp, XS_T *xs)
84uint16_t
85isp_find_handle(ispsoftc_t *isp, XS_T *xs)
69{
70 int i;
71 if (xs != NULL) {
72 for (i = 0; i < isp->isp_maxcmds; i++) {
73 if (isp->isp_xflist[i] == xs) {
86{
87 int i;
88 if (xs != NULL) {
89 for (i = 0; i < isp->isp_maxcmds; i++) {
90 if (isp->isp_xflist[i] == xs) {
74 return ((u_int16_t) i+1);
91 return ((uint16_t) i+1);
75 }
76 }
77 }
78 return (0);
79}
80
81int
92 }
93 }
94 }
95 return (0);
96}
97
98int
82isp_handle_index(u_int16_t handle)
99isp_handle_index(uint16_t handle)
83{
84 return (handle-1);
85}
86
100{
101 return (handle-1);
102}
103
87u_int16_t
104uint16_t
88isp_index_handle(int index)
89{
90 return (index+1);
91}
92
93void
105isp_index_handle(int index)
106{
107 return (index+1);
108}
109
110void
94isp_destroy_handle(struct ispsoftc *isp, u_int16_t handle)
111isp_destroy_handle(ispsoftc_t *isp, uint16_t handle)
95{
112{
96 if (handle > 0 && handle <= (u_int16_t) isp->isp_maxcmds) {
113 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) {
97 isp->isp_xflist[handle - 1] = NULL;
98 }
99}
100
101int
114 isp->isp_xflist[handle - 1] = NULL;
115 }
116}
117
118int
102isp_getrqentry(struct ispsoftc *isp, u_int16_t *iptrp,
103 u_int16_t *optrp, void **resultp)
119isp_getrqentry(ispsoftc_t *isp, uint16_t *iptrp,
120 uint16_t *optrp, void **resultp)
104{
121{
105 volatile u_int16_t iptr, optr;
122 volatile uint16_t iptr, optr;
106
107 optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
108 iptr = isp->isp_reqidx;
109 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
110 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
111 if (iptr == optr) {
112 return (1);
113 }
114 if (optrp)
115 *optrp = optr;
116 if (iptrp)
117 *iptrp = iptr;
118 return (0);
119}
120
121#define TBA (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
122void
123
124 optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
125 iptr = isp->isp_reqidx;
126 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
127 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
128 if (iptr == optr) {
129 return (1);
130 }
131 if (optrp)
132 *optrp = optr;
133 if (iptrp)
134 *iptrp = iptr;
135 return (0);
136}
137
138#define TBA (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
139void
123isp_print_qentry(struct ispsoftc *isp, char *msg, int idx, void *arg)
140isp_print_qentry(ispsoftc_t *isp, char *msg, int idx, void *arg)
124{
125 char buf[TBA];
126 int amt, i, j;
141{
142 char buf[TBA];
143 int amt, i, j;
127 u_int8_t *ptr = arg;
144 uint8_t *ptr = arg;
128
129 isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx);
130 for (buf[0] = 0, amt = i = 0; i < 4; i++) {
131 buf[0] = 0;
132 SNPRINTF(buf, TBA, " ");
133 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
134 SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff);
135 }
136 isp_prt(isp, ISP_LOGALL, buf);
137 }
138}
139
140void
145
146 isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx);
147 for (buf[0] = 0, amt = i = 0; i < 4; i++) {
148 buf[0] = 0;
149 SNPRINTF(buf, TBA, " ");
150 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
151 SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff);
152 }
153 isp_prt(isp, ISP_LOGALL, buf);
154 }
155}
156
157void
141isp_print_bytes(struct ispsoftc *isp, char *msg, int amt, void *arg)
158isp_print_bytes(ispsoftc_t *isp, char *msg, int amt, void *arg)
142{
143 char buf[128];
159{
160 char buf[128];
144 u_int8_t *ptr = arg;
161 uint8_t *ptr = arg;
145 int off;
146
147 if (msg)
148 isp_prt(isp, ISP_LOGALL, "%s:", msg);
149 off = 0;
150 buf[0] = 0;
151 while (off < amt) {
152 int j, to;

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

173 * We honor HBA roles in that if we're not in Initiator mode, we don't
174 * attempt to sync up the database (that's for somebody else to do,
175 * if ever).
176 *
177 * We assume we enter here with any locks held.
178 */
179
180int
162 int off;
163
164 if (msg)
165 isp_prt(isp, ISP_LOGALL, "%s:", msg);
166 off = 0;
167 buf[0] = 0;
168 while (off < amt) {
169 int j, to;

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

190 * We honor HBA roles in that if we're not in Initiator mode, we don't
191 * attempt to sync up the database (that's for somebody else to do,
192 * if ever).
193 *
194 * We assume we enter here with any locks held.
195 */
196
197int
181isp_fc_runstate(struct ispsoftc *isp, int tval)
198isp_fc_runstate(ispsoftc_t *isp, int tval)
182{
183 fcparam *fcp;
184 int *tptr;
185
186 if (IS_SCSI(isp))
187 return (0);
188
189 tptr = tval? &tval : NULL;

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

224
225#define ISP_IS_SBUS(isp) \
226 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
227
228/*
229 * Swizzle/Copy Functions
230 */
231void
199{
200 fcparam *fcp;
201 int *tptr;
202
203 if (IS_SCSI(isp))
204 return (0);
205
206 tptr = tval? &tval : NULL;

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

241
242#define ISP_IS_SBUS(isp) \
243 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
244
245/*
246 * Swizzle/Copy Functions
247 */
248void
232isp_copy_out_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
249isp_copy_out_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
233{
234 if (ISP_IS_SBUS(isp)) {
235 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
236 &hpdst->rqs_entry_count);
237 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
238 &hpdst->rqs_entry_type);
239 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
240 &hpdst->rqs_flags);

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

248 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
249 &hpdst->rqs_seqno);
250 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
251 &hpdst->rqs_flags);
252 }
253}
254
255void
250{
251 if (ISP_IS_SBUS(isp)) {
252 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
253 &hpdst->rqs_entry_count);
254 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
255 &hpdst->rqs_entry_type);
256 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
257 &hpdst->rqs_flags);

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

265 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
266 &hpdst->rqs_seqno);
267 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
268 &hpdst->rqs_flags);
269 }
270}
271
272void
256isp_copy_in_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
273isp_copy_in_hdr(ispsoftc_t *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
257{
258 if (ISP_IS_SBUS(isp)) {
259 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
260 hpdst->rqs_entry_count);
261 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
262 hpdst->rqs_entry_type);
263 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
264 hpdst->rqs_flags);

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

272 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
273 hpdst->rqs_seqno);
274 ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
275 hpdst->rqs_flags);
276 }
277}
278
279int
274{
275 if (ISP_IS_SBUS(isp)) {
276 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
277 hpdst->rqs_entry_count);
278 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
279 hpdst->rqs_entry_type);
280 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
281 hpdst->rqs_flags);

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

289 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
290 hpdst->rqs_seqno);
291 ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
292 hpdst->rqs_flags);
293 }
294}
295
296int
280isp_get_response_type(struct ispsoftc *isp, isphdr_t *hp)
297isp_get_response_type(ispsoftc_t *isp, isphdr_t *hp)
281{
298{
282 u_int8_t type;
299 uint8_t type;
283 if (ISP_IS_SBUS(isp)) {
284 ISP_IOXGET_8(isp, &hp->rqs_entry_count, type);
285 } else {
286 ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
287 }
288 return ((int)type);
289}
290
291void
300 if (ISP_IS_SBUS(isp)) {
301 ISP_IOXGET_8(isp, &hp->rqs_entry_count, type);
302 } else {
303 ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
304 }
305 return ((int)type);
306}
307
308void
292isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
309isp_put_request(ispsoftc_t *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
293{
294 int i;
295 isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
296 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
297 if (ISP_IS_SBUS(isp)) {
298 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
299 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
300 } else {

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

312 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
313 &rqdst->req_dataseg[i].ds_base);
314 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
315 &rqdst->req_dataseg[i].ds_count);
316 }
317}
318
319void
310{
311 int i;
312 isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
313 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
314 if (ISP_IS_SBUS(isp)) {
315 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
316 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
317 } else {

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

329 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
330 &rqdst->req_dataseg[i].ds_base);
331 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
332 &rqdst->req_dataseg[i].ds_count);
333 }
334}
335
336void
320isp_put_request_t2(struct ispsoftc *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
337isp_put_request_t2(ispsoftc_t *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
321{
322 int i;
323 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
324 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
325 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
326 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
327 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
328 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);

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

337 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
338 &tqdst->req_dataseg[i].ds_base);
339 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
340 &tqdst->req_dataseg[i].ds_count);
341 }
342}
343
344void
338{
339 int i;
340 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
341 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
342 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
343 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
344 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
345 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);

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

354 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
355 &tqdst->req_dataseg[i].ds_base);
356 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
357 &tqdst->req_dataseg[i].ds_count);
358 }
359}
360
361void
345isp_put_request_t2e(struct ispsoftc *isp, ispreqt2e_t *tqsrc, ispreqt2e_t *tqdst)
362isp_put_request_t2e(ispsoftc_t *isp, ispreqt2e_t *tqsrc, ispreqt2e_t *tqdst)
346{
347 int i;
348 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
349 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
350 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
351 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
352 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
353 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);

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

361 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
362 &tqdst->req_dataseg[i].ds_base);
363 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
364 &tqdst->req_dataseg[i].ds_count);
365 }
366}
367
368void
363{
364 int i;
365 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
366 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
367 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
368 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
369 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
370 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);

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

378 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
379 &tqdst->req_dataseg[i].ds_base);
380 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
381 &tqdst->req_dataseg[i].ds_count);
382 }
383}
384
385void
369isp_put_request_t3(struct ispsoftc *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
386isp_put_request_t3(ispsoftc_t *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
370{
371 int i;
372 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
373 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
374 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
375 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
376 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
377 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);

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

388 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
389 &tqdst->req_dataseg[i].ds_basehi);
390 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
391 &tqdst->req_dataseg[i].ds_count);
392 }
393}
394
395void
387{
388 int i;
389 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
390 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
391 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
392 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
393 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
394 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);

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

405 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
406 &tqdst->req_dataseg[i].ds_basehi);
407 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
408 &tqdst->req_dataseg[i].ds_count);
409 }
410}
411
412void
396isp_put_request_t3e(struct ispsoftc *isp, ispreqt3e_t *tqsrc, ispreqt3e_t *tqdst)
413isp_put_request_t3e(ispsoftc_t *isp, ispreqt3e_t *tqsrc, ispreqt3e_t *tqdst)
397{
398 int i;
399 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
400 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
401 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
402 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
403 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
404 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);

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

414 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
415 &tqdst->req_dataseg[i].ds_basehi);
416 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
417 &tqdst->req_dataseg[i].ds_count);
418 }
419}
420
421void
414{
415 int i;
416 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
417 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
418 ISP_IOXPUT_16(isp, tqsrc->req_target, &tqdst->req_target);
419 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
420 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
421 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);

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

431 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
432 &tqdst->req_dataseg[i].ds_basehi);
433 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
434 &tqdst->req_dataseg[i].ds_count);
435 }
436}
437
438void
422isp_put_extended_request(struct ispsoftc *isp, ispextreq_t *xqsrc,
439isp_put_extended_request(ispsoftc_t *isp, ispextreq_t *xqsrc,
423 ispextreq_t *xqdst)
424{
425 int i;
426 isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
427 ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
428 if (ISP_IS_SBUS(isp)) {
429 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
430 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);

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

437 ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
438 ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
439 for (i = 0; i < 44; i++) {
440 ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
441 }
442}
443
444void
440 ispextreq_t *xqdst)
441{
442 int i;
443 isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
444 ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
445 if (ISP_IS_SBUS(isp)) {
446 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
447 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);

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

454 ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
455 ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
456 for (i = 0; i < 44; i++) {
457 ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
458 }
459}
460
461void
445isp_put_cont_req(struct ispsoftc *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
462isp_put_cont_req(ispsoftc_t *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
446{
447 int i;
448 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
449 for (i = 0; i < ISP_CDSEG; i++) {
450 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
451 &cqdst->req_dataseg[i].ds_base);
452 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
453 &cqdst->req_dataseg[i].ds_count);
454 }
455}
456
457void
463{
464 int i;
465 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
466 for (i = 0; i < ISP_CDSEG; i++) {
467 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
468 &cqdst->req_dataseg[i].ds_base);
469 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
470 &cqdst->req_dataseg[i].ds_count);
471 }
472}
473
474void
458isp_put_cont64_req(struct ispsoftc *isp, ispcontreq64_t *cqsrc,
475isp_put_cont64_req(ispsoftc_t *isp, ispcontreq64_t *cqsrc,
459 ispcontreq64_t *cqdst)
460{
461 int i;
462 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
463 for (i = 0; i < ISP_CDSEG64; i++) {
464 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
465 &cqdst->req_dataseg[i].ds_base);
466 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
467 &cqdst->req_dataseg[i].ds_basehi);
468 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
469 &cqdst->req_dataseg[i].ds_count);
470 }
471}
472
473void
476 ispcontreq64_t *cqdst)
477{
478 int i;
479 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
480 for (i = 0; i < ISP_CDSEG64; i++) {
481 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
482 &cqdst->req_dataseg[i].ds_base);
483 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
484 &cqdst->req_dataseg[i].ds_basehi);
485 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
486 &cqdst->req_dataseg[i].ds_count);
487 }
488}
489
490void
474isp_get_response(struct ispsoftc *isp, ispstatusreq_t *spsrc,
491isp_get_response(ispsoftc_t *isp, ispstatusreq_t *spsrc,
475 ispstatusreq_t *spdst)
476{
477 int i;
478 isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
479 ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
480 ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
481 ISP_IOXGET_16(isp, &spsrc->req_completion_status,
482 spdst->req_completion_status);

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

491 }
492 for (i = 0; i < 32; i++) {
493 ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
494 spdst->req_sense_data[i]);
495 }
496}
497
498void
492 ispstatusreq_t *spdst)
493{
494 int i;
495 isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
496 ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
497 ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
498 ISP_IOXGET_16(isp, &spsrc->req_completion_status,
499 spdst->req_completion_status);

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

508 }
509 for (i = 0; i < 32; i++) {
510 ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
511 spdst->req_sense_data[i]);
512 }
513}
514
515void
499isp_get_response_x(struct ispsoftc *isp, ispstatus_cont_t *cpsrc,
516isp_get_response_x(ispsoftc_t *isp, ispstatus_cont_t *cpsrc,
500 ispstatus_cont_t *cpdst)
501{
502 int i;
503 isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
504 for (i = 0; i < 60; i++) {
505 ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
506 cpdst->req_sense_data[i]);
507 }
508}
509
510void
517 ispstatus_cont_t *cpdst)
518{
519 int i;
520 isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
521 for (i = 0; i < 60; i++) {
522 ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
523 cpdst->req_sense_data[i]);
524 }
525}
526
527void
511isp_get_rio2(struct ispsoftc *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
528isp_get_rio2(ispsoftc_t *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
512{
513 int i;
514 isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
515 if (r2dst->req_header.rqs_seqno > 30)
516 r2dst->req_header.rqs_seqno = 30;
517 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
518 ISP_IOXGET_16(isp, &r2src->req_handles[i],
519 r2dst->req_handles[i]);
520 }
521 while (i < 30) {
522 r2dst->req_handles[i++] = 0;
523 }
524}
525
526void
529{
530 int i;
531 isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
532 if (r2dst->req_header.rqs_seqno > 30)
533 r2dst->req_header.rqs_seqno = 30;
534 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
535 ISP_IOXGET_16(isp, &r2src->req_handles[i],
536 r2dst->req_handles[i]);
537 }
538 while (i < 30) {
539 r2dst->req_handles[i++] = 0;
540 }
541}
542
543void
527isp_put_icb(struct ispsoftc *isp, isp_icb_t *Is, isp_icb_t *Id)
544isp_put_icb(ispsoftc_t *isp, isp_icb_t *Is, isp_icb_t *Id)
528{
529 int i;
530 if (ISP_IS_SBUS(isp)) {
531 ISP_IOXPUT_8(isp, Is->icb_version, &Id->_reserved0);
532 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->icb_version);
533 } else {
534 ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
535 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0);

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

585 } else {
586 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
587 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
588 }
589 ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
590}
591
592void
545{
546 int i;
547 if (ISP_IS_SBUS(isp)) {
548 ISP_IOXPUT_8(isp, Is->icb_version, &Id->_reserved0);
549 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->icb_version);
550 } else {
551 ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
552 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0);

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

602 } else {
603 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
604 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
605 }
606 ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
607}
608
609void
593isp_get_pdb(struct ispsoftc *isp, isp_pdb_t *src, isp_pdb_t *dst)
610isp_get_pdb(ispsoftc_t *isp, isp_pdb_t *src, isp_pdb_t *dst)
594{
595 int i;
596 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
597 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
598 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
599 for (i = 0; i < 4; i++) {
600 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
601 dst->pdb_hardaddr_bits[i]);

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

643 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
644}
645
646
647/*
648 * CT_HDR canonicalization- only needed for SNS responses
649 */
650void
611{
612 int i;
613 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
614 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
615 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
616 for (i = 0; i < 4; i++) {
617 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
618 dst->pdb_hardaddr_bits[i]);

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

660 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
661}
662
663
664/*
665 * CT_HDR canonicalization- only needed for SNS responses
666 */
667void
651isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
668isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *src, ct_hdr_t *dst)
652{
653 ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
654 ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
655 ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
656 ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
657 ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
658 ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
659 ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);

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

668 ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
669}
670
671/*
672 * Generic SNS request - not particularly useful since the per-command data
673 * isn't always 16 bit words.
674 */
675void
669{
670 ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
671 ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
672 ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
673 ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
674 ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
675 ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
676 ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);

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

685 ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
686}
687
688/*
689 * Generic SNS request - not particularly useful since the per-command data
690 * isn't always 16 bit words.
691 */
692void
676isp_put_sns_request(struct ispsoftc *isp, sns_screq_t *src, sns_screq_t *dst)
693isp_put_sns_request(ispsoftc_t *isp, sns_screq_t *src, sns_screq_t *dst)
677{
678 int i, nw = (int) src->snscb_sblen;
679 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
680 for (i = 0; i < 4; i++) {
681 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
682 }
683 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
684 for (i = 0; i < nw; i++) {
685 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
686 }
687
688}
689
690void
694{
695 int i, nw = (int) src->snscb_sblen;
696 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
697 for (i = 0; i < 4; i++) {
698 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
699 }
700 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
701 for (i = 0; i < nw; i++) {
702 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
703 }
704
705}
706
707void
691isp_put_gid_ft_request(struct ispsoftc *isp, sns_gid_ft_req_t *src,
708isp_put_gid_ft_request(ispsoftc_t *isp, sns_gid_ft_req_t *src,
692 sns_gid_ft_req_t *dst)
693{
694 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
695 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
696 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
697 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
698 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
699 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
700 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
701 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
702 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
703 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
704 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
705 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
706}
707
708void
709 sns_gid_ft_req_t *dst)
710{
711 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
712 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
713 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
714 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
715 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
716 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
717 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
718 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
719 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
720 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
721 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
722 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
723}
724
725void
709isp_put_gxn_id_request(struct ispsoftc *isp, sns_gxn_id_req_t *src,
726isp_put_gxn_id_request(ispsoftc_t *isp, sns_gxn_id_req_t *src,
710 sns_gxn_id_req_t *dst)
711{
712 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
713 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
714 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
715 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
716 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
717 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);

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

723 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
724}
725
726/*
727 * Generic SNS response - not particularly useful since the per-command data
728 * isn't always 16 bit words.
729 */
730void
727 sns_gxn_id_req_t *dst)
728{
729 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
730 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
731 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
732 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
733 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
734 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);

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

740 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
741}
742
743/*
744 * Generic SNS response - not particularly useful since the per-command data
745 * isn't always 16 bit words.
746 */
747void
731isp_get_sns_response(struct ispsoftc *isp, sns_scrsp_t *src,
748isp_get_sns_response(ispsoftc_t *isp, sns_scrsp_t *src,
732 sns_scrsp_t *dst, int nwords)
733{
734 int i;
735 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
736 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
737 for (i = 0; i < 3; i++) {
738 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
739 dst->snscb_port_id[i]);
740 }
741 for (i = 0; i < 8; i++) {
742 ISP_IOXGET_8(isp, &src->snscb_portname[i],
743 dst->snscb_portname[i]);
744 }
745 for (i = 0; i < nwords; i++) {
746 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]);
747 }
748}
749
750void
749 sns_scrsp_t *dst, int nwords)
750{
751 int i;
752 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
753 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
754 for (i = 0; i < 3; i++) {
755 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
756 dst->snscb_port_id[i]);
757 }
758 for (i = 0; i < 8; i++) {
759 ISP_IOXGET_8(isp, &src->snscb_portname[i],
760 dst->snscb_portname[i]);
761 }
762 for (i = 0; i < nwords; i++) {
763 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]);
764 }
765}
766
767void
751isp_get_gid_ft_response(struct ispsoftc *isp, sns_gid_ft_rsp_t *src,
768isp_get_gid_ft_response(ispsoftc_t *isp, sns_gid_ft_rsp_t *src,
752 sns_gid_ft_rsp_t *dst, int nwords)
753{
754 int i;
755 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
756 for (i = 0; i < nwords; i++) {
757 int j;
758 ISP_IOXGET_8(isp,
759 &src->snscb_ports[i].control,

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

765 }
766 if (dst->snscb_ports[i].control & 0x80) {
767 break;
768 }
769 }
770}
771
772void
769 sns_gid_ft_rsp_t *dst, int nwords)
770{
771 int i;
772 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
773 for (i = 0; i < nwords; i++) {
774 int j;
775 ISP_IOXGET_8(isp,
776 &src->snscb_ports[i].control,

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

782 }
783 if (dst->snscb_ports[i].control & 0x80) {
784 break;
785 }
786 }
787}
788
789void
773isp_get_gxn_id_response(struct ispsoftc *isp, sns_gxn_id_rsp_t *src,
790isp_get_gxn_id_response(ispsoftc_t *isp, sns_gxn_id_rsp_t *src,
774 sns_gxn_id_rsp_t *dst)
775{
776 int i;
777 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
778 for (i = 0; i < 8; i++)
779 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
780}
781
782void
791 sns_gxn_id_rsp_t *dst)
792{
793 int i;
794 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
795 for (i = 0; i < 8; i++)
796 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
797}
798
799void
783isp_get_gff_id_response(struct ispsoftc *isp, sns_gff_id_rsp_t *src,
800isp_get_gff_id_response(ispsoftc_t *isp, sns_gff_id_rsp_t *src,
784 sns_gff_id_rsp_t *dst)
785{
786 int i;
787 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
788 for (i = 0; i < 32; i++) {
789 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i],
790 dst->snscb_fc4_features[i]);
791 }
792}
793
794void
801 sns_gff_id_rsp_t *dst)
802{
803 int i;
804 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
805 for (i = 0; i < 32; i++) {
806 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i],
807 dst->snscb_fc4_features[i]);
808 }
809}
810
811void
795isp_get_ga_nxt_response(struct ispsoftc *isp, sns_ga_nxt_rsp_t *src,
812isp_get_ga_nxt_response(ispsoftc_t *isp, sns_ga_nxt_rsp_t *src,
796 sns_ga_nxt_rsp_t *dst)
797{
798 int i;
799 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
800 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
801 for (i = 0; i < 3; i++) {
802 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
803 dst->snscb_port_id[i]);

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

841 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
842 dst->snscb_hardaddr[i]);
843 }
844}
845
846#ifdef ISP_TARGET_MODE
847
848int
813 sns_ga_nxt_rsp_t *dst)
814{
815 int i;
816 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
817 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
818 for (i = 0; i < 3; i++) {
819 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
820 dst->snscb_port_id[i]);

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

858 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
859 dst->snscb_hardaddr[i]);
860 }
861}
862
863#ifdef ISP_TARGET_MODE
864
865int
849isp_save_xs_tgt(struct ispsoftc *isp, void *xs, u_int16_t *handlep)
866isp_save_xs_tgt(ispsoftc_t *isp, void *xs, uint16_t *handlep)
850{
851 int i;
852
853 for (i = 0; i < (int) isp->isp_maxcmds; i++) {
854 if (isp->isp_tgtlist[i] == NULL) {
855 break;
856 }
857 }
858 if (i == isp->isp_maxcmds) {
859 return (-1);
860 }
861 isp->isp_tgtlist[i] = xs;
862 *handlep = i+1;
863 return (0);
864}
865
866void *
867{
868 int i;
869
870 for (i = 0; i < (int) isp->isp_maxcmds; i++) {
871 if (isp->isp_tgtlist[i] == NULL) {
872 break;
873 }
874 }
875 if (i == isp->isp_maxcmds) {
876 return (-1);
877 }
878 isp->isp_tgtlist[i] = xs;
879 *handlep = i+1;
880 return (0);
881}
882
883void *
867isp_find_xs_tgt(struct ispsoftc *isp, u_int16_t handle)
884isp_find_xs_tgt(ispsoftc_t *isp, uint16_t handle)
868{
885{
869 if (handle < 1 || handle > (u_int16_t) isp->isp_maxcmds) {
886 if (handle < 1 || handle > (uint16_t) isp->isp_maxcmds) {
870 return (NULL);
871 } else {
872 return (isp->isp_tgtlist[handle - 1]);
873 }
874}
875
887 return (NULL);
888 } else {
889 return (isp->isp_tgtlist[handle - 1]);
890 }
891}
892
876u_int16_t
877isp_find_tgt_handle(struct ispsoftc *isp, void *xs)
893uint16_t
894isp_find_tgt_handle(ispsoftc_t *isp, void *xs)
878{
879 int i;
880 if (xs != NULL) {
881 for (i = 0; i < isp->isp_maxcmds; i++) {
882 if (isp->isp_tgtlist[i] == xs) {
895{
896 int i;
897 if (xs != NULL) {
898 for (i = 0; i < isp->isp_maxcmds; i++) {
899 if (isp->isp_tgtlist[i] == xs) {
883 return ((u_int16_t) i+1);
900 return ((uint16_t) i+1);
884 }
885 }
886 }
887 return (0);
888}
889
890void
901 }
902 }
903 }
904 return (0);
905}
906
907void
891isp_destroy_tgt_handle(struct ispsoftc *isp, u_int16_t handle)
908isp_destroy_tgt_handle(ispsoftc_t *isp, uint16_t handle)
892{
909{
893 if (handle > 0 && handle <= (u_int16_t) isp->isp_maxcmds) {
910 if (handle > 0 && handle <= (uint16_t) isp->isp_maxcmds) {
894 isp->isp_tgtlist[handle - 1] = NULL;
895 }
896}
897void
911 isp->isp_tgtlist[handle - 1] = NULL;
912 }
913}
914void
898isp_put_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
915isp_put_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst)
899{
900 int i;
901 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
902 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
903 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
904 if (ISP_IS_SBUS(isp)) {
905 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
906 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);

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

926 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
927 }
928 for (i = 0; i < QLTM_SENSELEN; i++) {
929 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
930 }
931}
932
933void
916{
917 int i;
918 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
919 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
920 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
921 if (ISP_IS_SBUS(isp)) {
922 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
923 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);

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

943 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
944 }
945 for (i = 0; i < QLTM_SENSELEN; i++) {
946 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
947 }
948}
949
950void
934isp_get_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
951isp_get_atio(ispsoftc_t *isp, at_entry_t *atsrc, at_entry_t *atdst)
935{
936 int i;
937 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
938 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
939 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
940 if (ISP_IS_SBUS(isp)) {
941 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
942 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);

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

962 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
963 }
964 for (i = 0; i < QLTM_SENSELEN; i++) {
965 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
966 }
967}
968
969void
952{
953 int i;
954 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
955 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
956 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
957 if (ISP_IS_SBUS(isp)) {
958 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
959 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);

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

979 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
980 }
981 for (i = 0; i < QLTM_SENSELEN; i++) {
982 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
983 }
984}
985
986void
970isp_put_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
987isp_put_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
971{
972 int i;
973 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
974 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
975 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
976 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
977 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
978 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);

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

992 for (i = 0; i < 6; i++) {
993 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
994 &atdst->at_reserved2[i]);
995 }
996 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
997}
998
999void
988{
989 int i;
990 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
991 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
992 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
993 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
994 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
995 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);

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

1009 for (i = 0; i < 6; i++) {
1010 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1011 &atdst->at_reserved2[i]);
1012 }
1013 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1014}
1015
1016void
1000isp_put_atio2e(struct ispsoftc *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1017isp_put_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1001{
1002 int i;
1003 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
1004 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
1005 ISP_IOXPUT_16(isp, atsrc->at_iid, &atdst->at_iid);
1006 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
1007 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
1008 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);

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

1021 for (i = 0; i < 6; i++) {
1022 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1023 &atdst->at_reserved2[i]);
1024 }
1025 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1026}
1027
1028void
1018{
1019 int i;
1020 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
1021 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
1022 ISP_IOXPUT_16(isp, atsrc->at_iid, &atdst->at_iid);
1023 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
1024 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
1025 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);

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

1038 for (i = 0; i < 6; i++) {
1039 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1040 &atdst->at_reserved2[i]);
1041 }
1042 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1043}
1044
1045void
1029isp_get_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1046isp_get_atio2(ispsoftc_t *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1030{
1031 int i;
1032 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1033 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1034 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
1035 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
1036 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1037 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);

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

1051 for (i = 0; i < 6; i++) {
1052 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1053 atdst->at_reserved2[i]);
1054 }
1055 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1056}
1057
1058void
1047{
1048 int i;
1049 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1050 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1051 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
1052 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
1053 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1054 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);

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

1068 for (i = 0; i < 6; i++) {
1069 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1070 atdst->at_reserved2[i]);
1071 }
1072 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1073}
1074
1075void
1059isp_get_atio2e(struct ispsoftc *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1076isp_get_atio2e(ispsoftc_t *isp, at2e_entry_t *atsrc, at2e_entry_t *atdst)
1060{
1061 int i;
1062 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1063 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1064 ISP_IOXGET_16(isp, &atsrc->at_iid, atdst->at_iid);
1065 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1066 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1067 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);

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

1080 for (i = 0; i < 6; i++) {
1081 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1082 atdst->at_reserved2[i]);
1083 }
1084 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1085}
1086
1087void
1077{
1078 int i;
1079 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1080 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1081 ISP_IOXGET_16(isp, &atsrc->at_iid, atdst->at_iid);
1082 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1083 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1084 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);

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

1097 for (i = 0; i < 6; i++) {
1098 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1099 atdst->at_reserved2[i]);
1100 }
1101 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1102}
1103
1104void
1088isp_put_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1105isp_put_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1089{
1090 int i;
1091 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1092 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1093 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1094 if (ISP_IS_SBUS(isp)) {
1095 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
1096 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);

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

1120 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
1121 &ctdst->ct_dataseg[i].ds_base);
1122 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
1123 &ctdst->ct_dataseg[i].ds_count);
1124 }
1125}
1126
1127void
1106{
1107 int i;
1108 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1109 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1110 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1111 if (ISP_IS_SBUS(isp)) {
1112 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
1113 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);

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

1137 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
1138 &ctdst->ct_dataseg[i].ds_base);
1139 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
1140 &ctdst->ct_dataseg[i].ds_count);
1141 }
1142}
1143
1144void
1128isp_get_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1145isp_get_ctio(ispsoftc_t *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1129{
1130 int i;
1131 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1132 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1133 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1134 if (ISP_IS_SBUS(isp)) {
1135 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
1136 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);

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

1162 ctdst->ct_dataseg[i].ds_base);
1163 ISP_IOXGET_32(isp,
1164 &ctsrc->ct_dataseg[i].ds_count,
1165 ctdst->ct_dataseg[i].ds_count);
1166 }
1167}
1168
1169void
1146{
1147 int i;
1148 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1149 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1150 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1151 if (ISP_IS_SBUS(isp)) {
1152 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
1153 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);

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

1179 ctdst->ct_dataseg[i].ds_base);
1180 ISP_IOXGET_32(isp,
1181 &ctsrc->ct_dataseg[i].ds_count,
1182 ctdst->ct_dataseg[i].ds_count);
1183 }
1184}
1185
1186void
1170isp_put_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1187isp_put_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1171{
1172 int i;
1173 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1174 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1175 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1176 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1177 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1178 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);

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

1246 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1247 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1248 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1249 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1250 }
1251}
1252
1253void
1188{
1189 int i;
1190 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1191 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1192 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1193 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1194 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1195 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);

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

1263 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1264 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1265 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1266 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1267 }
1268}
1269
1270void
1254isp_put_ctio2e(struct ispsoftc *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1271isp_put_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1255{
1256 int i;
1257 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1258 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1259 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1260 ISP_IOXPUT_16(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1261 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1262 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);

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

1329 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1330 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1331 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1332 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1333 }
1334}
1335
1336void
1272{
1273 int i;
1274 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1275 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1276 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1277 ISP_IOXPUT_16(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1278 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1279 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);

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

1346 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1347 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1348 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1349 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1350 }
1351}
1352
1353void
1337isp_get_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1354isp_get_ctio2(ispsoftc_t *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1338{
1339 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1340 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1341 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1342 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1343 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1344 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1345 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1346 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1347 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1348 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1349 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1350 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1351}
1352
1353void
1355{
1356 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1357 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1358 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1359 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1360 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1361 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1362 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1363 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1364 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1365 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1366 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1367 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1368}
1369
1370void
1354isp_get_ctio2e(struct ispsoftc *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1371isp_get_ctio2e(ispsoftc_t *isp, ct2e_entry_t *ctsrc, ct2e_entry_t *ctdst)
1355{
1356 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1357 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1358 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1359 ISP_IOXGET_16(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1360 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1361 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1362 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1363 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1364 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1365 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1366 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1367}
1368
1369void
1372{
1373 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1374 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1375 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1376 ISP_IOXGET_16(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1377 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1378 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1379 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1380 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1381 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1382 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1383 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1384}
1385
1386void
1370isp_put_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1387isp_put_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1371{
1372 int i;
1373 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
1374 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
1375 if (ISP_IS_SBUS(isp)) {
1376 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
1377 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
1378 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);

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

1399 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout);
1400 for (i = 0; i < 20; i++) {
1401 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i],
1402 &ledst->le_reserved3[i]);
1403 }
1404}
1405
1406void
1388{
1389 int i;
1390 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
1391 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
1392 if (ISP_IS_SBUS(isp)) {
1393 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
1394 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
1395 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);

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

1416 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout);
1417 for (i = 0; i < 20; i++) {
1418 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i],
1419 &ledst->le_reserved3[i]);
1420 }
1421}
1422
1423void
1407isp_get_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1424isp_get_enable_lun(ispsoftc_t *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1408{
1409 int i;
1410 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
1411 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
1412 if (ISP_IS_SBUS(isp)) {
1413 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
1414 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
1415 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);

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

1436 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
1437 for (i = 0; i < 20; i++) {
1438 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
1439 ledst->le_reserved3[i]);
1440 }
1441}
1442
1443void
1425{
1426 int i;
1427 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
1428 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
1429 if (ISP_IS_SBUS(isp)) {
1430 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
1431 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
1432 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);

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

1453 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
1454 for (i = 0; i < 20; i++) {
1455 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
1456 ledst->le_reserved3[i]);
1457 }
1458}
1459
1460void
1444isp_put_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1461isp_put_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst)
1445{
1446 int i;
1447 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1448 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1449 if (ISP_IS_SBUS(isp)) {
1450 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
1451 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
1452 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);

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

1476 }
1477 for (i = 0; i < QLTM_SENSELEN; i++) {
1478 ISP_IOXPUT_8(isp, insrc->in_sense[i],
1479 &indst->in_sense[i]);
1480 }
1481}
1482
1483void
1462{
1463 int i;
1464 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1465 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1466 if (ISP_IS_SBUS(isp)) {
1467 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
1468 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
1469 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);

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

1493 }
1494 for (i = 0; i < QLTM_SENSELEN; i++) {
1495 ISP_IOXPUT_8(isp, insrc->in_sense[i],
1496 &indst->in_sense[i]);
1497 }
1498}
1499
1500void
1484isp_get_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1501isp_get_notify(ispsoftc_t *isp, in_entry_t *insrc, in_entry_t *indst)
1485{
1486 int i;
1487 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1488 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1489 if (ISP_IS_SBUS(isp)) {
1490 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
1491 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
1492 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);

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

1516 }
1517 for (i = 0; i < QLTM_SENSELEN; i++) {
1518 ISP_IOXGET_8(isp, &insrc->in_sense[i],
1519 indst->in_sense[i]);
1520 }
1521}
1522
1523void
1502{
1503 int i;
1504 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1505 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1506 if (ISP_IS_SBUS(isp)) {
1507 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
1508 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
1509 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);

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

1533 }
1534 for (i = 0; i < QLTM_SENSELEN; i++) {
1535 ISP_IOXGET_8(isp, &insrc->in_sense[i],
1536 indst->in_sense[i]);
1537 }
1538}
1539
1540void
1524isp_put_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1541isp_put_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc,
1525 in_fcentry_t *indst)
1526{
1527 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1528 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1529 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1530 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1531 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1532 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1533 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1534 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1535 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1536}
1537
1538void
1542 in_fcentry_t *indst)
1543{
1544 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1545 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1546 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1547 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1548 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1549 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1550 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1551 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1552 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1553}
1554
1555void
1539isp_put_notify_fc_e(struct ispsoftc *isp, in_fcentry_e_t *insrc,
1556isp_put_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc,
1540 in_fcentry_e_t *indst)
1541{
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_16(isp, insrc->in_iid, &indst->in_iid);
1545 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1546 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1547 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1548 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1549 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1550}
1551
1552void
1557 in_fcentry_e_t *indst)
1558{
1559 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1560 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1561 ISP_IOXPUT_16(isp, insrc->in_iid, &indst->in_iid);
1562 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1563 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1564 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1565 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1566 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1567}
1568
1569void
1553isp_get_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1570isp_get_notify_fc(ispsoftc_t *isp, in_fcentry_t *insrc,
1554 in_fcentry_t *indst)
1555{
1556 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1557 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1558 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1559 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1560 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1561 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1562 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1563 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1564 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1565}
1566
1567void
1571 in_fcentry_t *indst)
1572{
1573 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1574 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1575 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1576 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1577 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1578 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1579 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1580 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1581 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1582}
1583
1584void
1568isp_get_notify_fc_e(struct ispsoftc *isp, in_fcentry_e_t *insrc,
1585isp_get_notify_fc_e(ispsoftc_t *isp, in_fcentry_e_t *insrc,
1569 in_fcentry_e_t *indst)
1570{
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_16(isp, &insrc->in_iid, indst->in_iid);
1574 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1575 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1576 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1577 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1578 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1579}
1580
1581void
1586 in_fcentry_e_t *indst)
1587{
1588 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1589 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1590 ISP_IOXGET_16(isp, &insrc->in_iid, indst->in_iid);
1591 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1592 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1593 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1594 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1595 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1596}
1597
1598void
1582isp_put_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1599isp_put_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst)
1583{
1584 int i;
1585 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1586 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1587 if (ISP_IS_SBUS(isp)) {
1588 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
1589 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
1590 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);

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

1598 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
1599 for (i = 0; i < NA_RSVDLEN; i++) {
1600 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1601 &nadst->na_reserved3[i]);
1602 }
1603}
1604
1605void
1600{
1601 int i;
1602 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1603 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1604 if (ISP_IS_SBUS(isp)) {
1605 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
1606 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
1607 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);

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

1615 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
1616 for (i = 0; i < NA_RSVDLEN; i++) {
1617 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1618 &nadst->na_reserved3[i]);
1619 }
1620}
1621
1622void
1606isp_get_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1623isp_get_notify_ack(ispsoftc_t *isp, na_entry_t *nasrc, na_entry_t *nadst)
1607{
1608 int i;
1609 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1610 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1611 if (ISP_IS_SBUS(isp)) {
1612 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
1613 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
1614 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);

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

1622 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
1623 for (i = 0; i < NA_RSVDLEN; i++) {
1624 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1625 nadst->na_reserved3[i]);
1626 }
1627}
1628
1629void
1624{
1625 int i;
1626 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1627 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1628 if (ISP_IS_SBUS(isp)) {
1629 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
1630 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
1631 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);

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

1639 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
1640 for (i = 0; i < NA_RSVDLEN; i++) {
1641 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1642 nadst->na_reserved3[i]);
1643 }
1644}
1645
1646void
1630isp_put_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1647isp_put_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc,
1631 na_fcentry_t *nadst)
1632{
1633 int i;
1634 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1635 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1636 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1637 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1638 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);

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

1643 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1644 for (i = 0; i < NA2_RSVDLEN; i++) {
1645 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1646 &nadst->na_reserved3[i]);
1647 }
1648}
1649
1650void
1648 na_fcentry_t *nadst)
1649{
1650 int i;
1651 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1652 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1653 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1654 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1655 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);

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

1660 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1661 for (i = 0; i < NA2_RSVDLEN; i++) {
1662 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1663 &nadst->na_reserved3[i]);
1664 }
1665}
1666
1667void
1651isp_put_notify_ack_fc_e(struct ispsoftc *isp, na_fcentry_e_t *nasrc,
1668isp_put_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc,
1652 na_fcentry_e_t *nadst)
1653{
1654 int i;
1655 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1656 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1657 ISP_IOXPUT_16(isp, nasrc->na_iid, &nadst->na_iid);
1658 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);
1659 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1660 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1661 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1662 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1663 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1664 for (i = 0; i < NA2_RSVDLEN; i++) {
1665 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1666 &nadst->na_reserved3[i]);
1667 }
1668}
1669
1670void
1669 na_fcentry_e_t *nadst)
1670{
1671 int i;
1672 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1673 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1674 ISP_IOXPUT_16(isp, nasrc->na_iid, &nadst->na_iid);
1675 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);
1676 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1677 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1678 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1679 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1680 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1681 for (i = 0; i < NA2_RSVDLEN; i++) {
1682 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1683 &nadst->na_reserved3[i]);
1684 }
1685}
1686
1687void
1671isp_get_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1688isp_get_notify_ack_fc(ispsoftc_t *isp, na_fcentry_t *nasrc,
1672 na_fcentry_t *nadst)
1673{
1674 int i;
1675 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1676 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1677 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1678 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1679 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);

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

1684 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1685 for (i = 0; i < NA2_RSVDLEN; i++) {
1686 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1687 nadst->na_reserved3[i]);
1688 }
1689}
1690
1691void
1689 na_fcentry_t *nadst)
1690{
1691 int i;
1692 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1693 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1694 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1695 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1696 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);

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

1701 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1702 for (i = 0; i < NA2_RSVDLEN; i++) {
1703 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1704 nadst->na_reserved3[i]);
1705 }
1706}
1707
1708void
1692isp_get_notify_ack_fc_e(struct ispsoftc *isp, na_fcentry_e_t *nasrc,
1709isp_get_notify_ack_fc_e(ispsoftc_t *isp, na_fcentry_e_t *nasrc,
1693 na_fcentry_e_t *nadst)
1694{
1695 int i;
1696 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1697 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1698 ISP_IOXGET_16(isp, &nasrc->na_iid, nadst->na_iid);
1699 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);
1700 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1701 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1702 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1703 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1704 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1705 for (i = 0; i < NA2_RSVDLEN; i++) {
1706 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1707 nadst->na_reserved3[i]);
1708 }
1709}
1710#endif /* ISP_TARGET_MODE */
1710 na_fcentry_e_t *nadst)
1711{
1712 int i;
1713 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1714 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1715 ISP_IOXGET_16(isp, &nasrc->na_iid, nadst->na_iid);
1716 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);
1717 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1718 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1719 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1720 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1721 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1722 for (i = 0; i < NA2_RSVDLEN; i++) {
1723 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1724 nadst->na_reserved3[i]);
1725 }
1726}
1727#endif /* ISP_TARGET_MODE */