1 /* $NetBSD: isp_inline.h,v 1.29 2006/11/16 01:32:51 christos Exp $ */
2 /*
3 * This driver, which is contained in NetBSD in the files:
4 *
5 * sys/dev/ic/isp.c
6 * sys/dev/ic/isp_inline.h
7 * sys/dev/ic/isp_netbsd.c
8 * sys/dev/ic/isp_netbsd.h
9 * sys/dev/ic/isp_target.c
10 * sys/dev/ic/isp_target.h
11 * sys/dev/ic/isp_tpublic.h
12 * sys/dev/ic/ispmbox.h
13 * sys/dev/ic/ispreg.h
14 * sys/dev/ic/ispvar.h
15 * sys/microcode/isp/asm_sbus.h
16 * sys/microcode/isp/asm_1040.h
17 * sys/microcode/isp/asm_1080.h
18 * sys/microcode/isp/asm_12160.h
19 * sys/microcode/isp/asm_2100.h
20 * sys/microcode/isp/asm_2200.h
21 * sys/pci/isp_pci.c
22 * sys/sbus/isp_sbus.c
23 *
24 * Is being actively maintained by Matthew Jacob (mjacob@NetBSD.org).
25 * This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris,
26 * Linux versions. This tends to be an interesting maintenance problem.
27 *
28 * Please coordinate with Matthew Jacob on changes you wish to make here.
29 */
30 /*
31 * Copyright (C) 1999 National Aeronautics & Space Administration
32 * All rights reserved.
33 *
34 * Redistribution and use in source and binary forms, with or without
35 * modification, are permitted provided that the following conditions
36 * are met:
37 * 1. Redistributions of source code must retain the above copyright
38 * notice, this list of conditions and the following disclaimer.
39 * 2. Redistributions in binary form must reproduce the above copyright
40 * notice, this list of conditions and the following disclaimer in the
41 * documentation and/or other materials provided with the distribution.
42 * 3. The name of the author may not be used to endorse or promote products
43 * derived from this software without specific prior written permission
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
46 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
48 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
49 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
50 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
51 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
52 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
53 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
54 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55 */
56 /*
57 * Qlogic HBA inline functions.
58 * mjacob@nas.nasa.gov.
59 */
60 #ifndef _ISP_INLINE_H
61 #define _ISP_INLINE_H
62
63 /*
64 * Handle Functions.
65 * For each outstanding command there will be a non-zero handle.
66 * There will be at most isp_maxcmds handles, and isp_lasthdls
67 * will be a seed for the last handled allocated.
68 */
69
70 static INLINE int isp_save_xs(struct ispsoftc *, XS_T *, u_int16_t *);
71 static INLINE XS_T *isp_find_xs(struct ispsoftc *, u_int16_t);
72 static INLINE u_int16_t isp_find_handle(struct ispsoftc *, XS_T *);
73 static INLINE int isp_handle_index(u_int16_t);
74 static INLINE void isp_destroy_handle(struct ispsoftc *, u_int16_t);
75 static INLINE void isp_remove_handle(struct ispsoftc *, XS_T *);
76
77 static INLINE int
78 isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int16_t *handlep)
79 {
80 int i, j;
81
82 for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) {
83 if (isp->isp_xflist[j] == NULL) {
84 break;
85 }
86 if (++j == isp->isp_maxcmds) {
87 j = 0;
88 }
89 }
90 if (i == isp->isp_maxcmds) {
91 return (-1);
92 }
93 isp->isp_xflist[j] = xs;
94 *handlep = j+1;
95 if (++j == isp->isp_maxcmds)
96 j = 0;
97 isp->isp_lasthdls = (u_int16_t)j;
98 return (0);
99 }
100
101 static INLINE XS_T *
102 isp_find_xs(struct ispsoftc *isp, u_int16_t handle)
103 {
104 if (handle < 1 || handle > (u_int16_t) isp->isp_maxcmds) {
105 return (NULL);
106 } else {
107 return (isp->isp_xflist[handle - 1]);
108 }
109 }
110
111 static INLINE u_int16_t
112 isp_find_handle(struct ispsoftc *isp, XS_T *xs)
113 {
114 int i;
115 if (xs != NULL) {
116 for (i = 0; i < isp->isp_maxcmds; i++) {
117 if (isp->isp_xflist[i] == xs) {
118 return ((u_int16_t) i+1);
119 }
120 }
121 }
122 return (0);
123 }
124
125 static INLINE int
126 isp_handle_index(u_int16_t handle)
127 {
128 return (handle-1);
129 }
130
131 static INLINE void
132 isp_destroy_handle(struct ispsoftc *isp, u_int16_t handle)
133 {
134 if (handle > 0 && handle <= (u_int16_t) isp->isp_maxcmds) {
135 isp->isp_xflist[isp_handle_index(handle)] = NULL;
136 }
137 }
138
139 static INLINE void
140 isp_remove_handle(struct ispsoftc *isp, XS_T *xs)
141 {
142 isp_destroy_handle(isp, isp_find_handle(isp, xs));
143 }
144
145 static INLINE int
146 isp_getrqentry(struct ispsoftc *, u_int16_t *, u_int16_t *, void **);
147
148 static INLINE int
149 isp_getrqentry(struct ispsoftc *isp, u_int16_t *iptrp,
150 u_int16_t *optrp, void **resultp)
151 {
152 volatile u_int16_t iptr, optr;
153
154 optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
155 iptr = isp->isp_reqidx;
156 *resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
157 iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
158 if (iptr == optr) {
159 return (1);
160 }
161 if (optrp)
162 *optrp = optr;
163 if (iptrp)
164 *iptrp = iptr;
165 return (0);
166 }
167
168 static INLINE void isp_print_qentry (struct ispsoftc *, char *, int, void *);
169
170
171 #define TBA (4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
172 static INLINE void
173 isp_print_qentry(struct ispsoftc *isp, char *msg, int idx, void *arg)
174 {
175 char tbuf[TBA];
176 int amt, i, j;
177 u_int8_t *ptr = arg;
178
179 isp_prt(isp, ISP_LOGALL, "%s index %d=>", msg, idx);
180 for (tbuf[0] = 0, amt = i = 0; i < 4; i++) {
181 tbuf[0] = 0;
182 SNPRINTF(tbuf, TBA, " ");
183 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
184 SNPRINTF(tbuf, TBA, "%s %02x", tbuf, ptr[amt++] & 0xff);
185 }
186 isp_prt(isp, ISP_LOGALL, tbuf);
187 }
188 }
189
190 static INLINE void isp_print_bytes(struct ispsoftc *, const char *, int, void *);
191
192 static INLINE void
193 isp_print_bytes(struct ispsoftc *isp, const char *msg, int amt, void *arg)
194 {
195 char tbuf[128];
196 u_int8_t *ptr = arg;
197 int off;
198
199 if (msg)
200 isp_prt(isp, ISP_LOGALL, "%s:", msg);
201 off = 0;
202 tbuf[0] = 0;
203 while (off < amt) {
204 int j, to;
205 to = off;
206 for (j = 0; j < 16; j++) {
207 SNPRINTF(tbuf, 128, "%s %02x", tbuf, ptr[off++] & 0xff);
208 if (off == amt)
209 break;
210 }
211 isp_prt(isp, ISP_LOGALL, "0x%08x:%s", to, tbuf);
212 tbuf[0] = 0;
213 }
214 }
215
216 /*
217 * Do the common path to try and ensure that link is up, we've scanned
218 * the fabric (if we're on a fabric), and that we've synchronized this
219 * all with our own database and done the appropriate logins.
220 *
221 * We repeatedly check for firmware state and loop state after each
222 * action because things may have changed while we were doing this.
223 * Any failure or change of state causes us to return a nonzero value.
224 *
225 * We honor HBA roles in that if we're not in Initiator mode, we don't
226 * attempt to sync up the database (that's for somebody else to do,
227 * if ever).
228 *
229 * We assume we enter here with any locks held.
230 */
231
232 static INLINE int isp_fc_runstate(struct ispsoftc *, int);
233
234 static INLINE int
235 isp_fc_runstate(struct ispsoftc *isp, int tval)
236 {
237 fcparam *fcp;
238 int *tptr;
239
240 if (IS_SCSI(isp))
241 return (0);
242
243 tptr = tval? &tval : NULL;
244 if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) {
245 return (-1);
246 }
247 fcp = FCPARAM(isp);
248 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD)
249 return (-1);
250 if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) {
251 return (-1);
252 }
253 if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) {
254 return (-1);
255 }
256 if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
257 return (0);
258 }
259 if (isp_control(isp, ISPCTL_PDB_SYNC, NULL) != 0) {
260 return (-1);
261 }
262 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
263 return (-1);
264 }
265 return (0);
266 }
267
268 /*
269 * Functions to move stuff to a form that the QLogic RISC engine understands
270 * and functions to move stuff back to a form the processor understands.
271 *
272 * Each platform is required to provide the 8, 16 and 32 bit
273 * swizzle and unswizzle macros (ISP_IOX{PUT|GET}_{8,16,32})
274 *
275 * The assumption is that swizzling and unswizzling is mostly done 'in place'
276 * (with a few exceptions for efficiency).
277 */
278
279 static INLINE void isp_copy_out_hdr(struct ispsoftc *, isphdr_t *, isphdr_t *);
280 static INLINE void isp_copy_in_hdr(struct ispsoftc *, isphdr_t *, isphdr_t *);
281 static INLINE int isp_get_response_type(struct ispsoftc *, isphdr_t *);
282
283 static INLINE void
284 isp_put_request(struct ispsoftc *, ispreq_t *, ispreq_t *);
285 static INLINE void
286 isp_put_request_t2(struct ispsoftc *, ispreqt2_t *, ispreqt2_t *);
287 static INLINE void
288 isp_put_request_t3(struct ispsoftc *, ispreqt3_t *, ispreqt3_t *);
289 static INLINE void
290 isp_put_extended_request(struct ispsoftc *, ispextreq_t *, ispextreq_t *);
291 static INLINE void
292 isp_put_cont_req(struct ispsoftc *, ispcontreq_t *, ispcontreq_t *);
293 static INLINE void
294 isp_put_cont64_req(struct ispsoftc *, ispcontreq64_t *, ispcontreq64_t *);
295 static INLINE void
296 isp_get_response(struct ispsoftc *, ispstatusreq_t *, ispstatusreq_t *);
297 static INLINE void
298 isp_get_response_x(struct ispsoftc *, ispstatus_cont_t *, ispstatus_cont_t *);
299 static INLINE void
300 isp_get_rio2(struct ispsoftc *, isp_rio2_t *, isp_rio2_t *);
301 static INLINE void
302 isp_put_icb(struct ispsoftc *, isp_icb_t *, isp_icb_t *);
303 static INLINE void
304 isp_get_pdb(struct ispsoftc *, isp_pdb_t *, isp_pdb_t *);
305 static INLINE void
306 isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *, ct_hdr_t *);
307 static INLINE void
308 isp_put_sns_request(struct ispsoftc *, sns_screq_t *, sns_screq_t *);
309 static INLINE void
310 isp_put_gid_ft_request(struct ispsoftc *, sns_gid_ft_req_t *,
311 sns_gid_ft_req_t *);
312 static INLINE void
313 isp_put_gxn_id_request(struct ispsoftc *, sns_gxn_id_req_t *,
314 sns_gxn_id_req_t *);
315 static INLINE void
316 isp_get_sns_response(struct ispsoftc *, sns_scrsp_t *, sns_scrsp_t *, int);
317 static INLINE void
318 isp_get_gid_ft_response(struct ispsoftc *, sns_gid_ft_rsp_t *,
319 sns_gid_ft_rsp_t *, int);
320 static INLINE void
321 isp_get_gxn_id_response(struct ispsoftc *, sns_gxn_id_rsp_t *,
322 sns_gxn_id_rsp_t *);
323 static INLINE void
324 isp_get_gff_id_response(struct ispsoftc *, sns_gff_id_rsp_t *,
325 sns_gff_id_rsp_t *);
326 static INLINE void
327 isp_get_ga_nxt_response(struct ispsoftc *, sns_ga_nxt_rsp_t *,
328 sns_ga_nxt_rsp_t *);
329 #ifdef ISP_TARGET_MODE
330 #ifndef _ISP_TARGET_H
331 #include "isp_target.h"
332 #endif
333 static INLINE void
334 isp_put_atio(struct ispsoftc *, at_entry_t *, at_entry_t *);
335 static INLINE void
336 isp_get_atio(struct ispsoftc *, at_entry_t *, at_entry_t *);
337 static INLINE void
338 isp_put_atio2(struct ispsoftc *, at2_entry_t *, at2_entry_t *);
339 static INLINE void
340 isp_get_atio2(struct ispsoftc *, at2_entry_t *, at2_entry_t *);
341 static INLINE void
342 isp_put_ctio(struct ispsoftc *, ct_entry_t *, ct_entry_t *);
343 static INLINE void
344 isp_get_ctio(struct ispsoftc *, ct_entry_t *, ct_entry_t *);
345 static INLINE void
346 isp_put_ctio2(struct ispsoftc *, ct2_entry_t *, ct2_entry_t *);
347 static INLINE void
348 isp_get_ctio2(struct ispsoftc *, ct2_entry_t *, ct2_entry_t *);
349 static INLINE void
350 isp_put_enable_lun(struct ispsoftc *, lun_entry_t *, lun_entry_t *);
351 static INLINE void
352 isp_get_enable_lun(struct ispsoftc *, lun_entry_t *, lun_entry_t *);
353 static INLINE void
354 isp_put_notify(struct ispsoftc *, in_entry_t *, in_entry_t *);
355 static INLINE void
356 isp_get_notify(struct ispsoftc *, in_entry_t *, in_entry_t *);
357 static INLINE void
358 isp_put_notify_fc(struct ispsoftc *, in_fcentry_t *, in_fcentry_t *);
359 static INLINE void
360 isp_get_notify_fc(struct ispsoftc *, in_fcentry_t *, in_fcentry_t *);
361 static INLINE void
362 isp_put_notify_ack(struct ispsoftc *, na_entry_t *, na_entry_t *);
363 static INLINE void
364 isp_get_notify_ack(struct ispsoftc *, na_entry_t *, na_entry_t *);
365 static INLINE void
366 isp_put_notify_ack_fc(struct ispsoftc *, na_fcentry_t *, na_fcentry_t *);
367 static INLINE void
368 isp_get_notify_ack_fc(struct ispsoftc *, na_fcentry_t *, na_fcentry_t *);
369 #endif
370
371 #define ISP_IS_SBUS(isp) \
372 (ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
373
374 /*
375 * Swizzle/Copy Functions
376 */
377 static INLINE void
378 isp_copy_out_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
379 {
380 if (ISP_IS_SBUS(isp)) {
381 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
382 &hpdst->rqs_entry_count);
383 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
384 &hpdst->rqs_entry_type);
385 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
386 &hpdst->rqs_flags);
387 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
388 &hpdst->rqs_seqno);
389 } else {
390 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
391 &hpdst->rqs_entry_type);
392 ISP_IOXPUT_8(isp, hpsrc->rqs_entry_count,
393 &hpdst->rqs_entry_count);
394 ISP_IOXPUT_8(isp, hpsrc->rqs_seqno,
395 &hpdst->rqs_seqno);
396 ISP_IOXPUT_8(isp, hpsrc->rqs_flags,
397 &hpdst->rqs_flags);
398 }
399 }
400
401 static INLINE void
402 isp_copy_in_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
403 {
404 if (ISP_IS_SBUS(isp)) {
405 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
406 hpdst->rqs_entry_count);
407 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
408 hpdst->rqs_entry_type);
409 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
410 hpdst->rqs_flags);
411 ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
412 hpdst->rqs_seqno);
413 } else {
414 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
415 hpdst->rqs_entry_type);
416 ISP_IOXGET_8(isp, &hpsrc->rqs_entry_count,
417 hpdst->rqs_entry_count);
418 ISP_IOXGET_8(isp, &hpsrc->rqs_seqno,
419 hpdst->rqs_seqno);
420 ISP_IOXGET_8(isp, &hpsrc->rqs_flags,
421 hpdst->rqs_flags);
422 }
423 }
424
425 static INLINE int
426 isp_get_response_type(struct ispsoftc *isp, isphdr_t *hp)
427 {
428 u_int8_t type;
429 if (ISP_IS_SBUS(isp)) {
430 ISP_IOXGET_8(isp, &hp->rqs_entry_count, type);
431 } else {
432 ISP_IOXGET_8(isp, &hp->rqs_entry_type, type);
433 }
434 return ((int)type);
435 }
436
437 static INLINE void
438 isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
439 {
440 int i;
441 isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
442 ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
443 if (ISP_IS_SBUS(isp)) {
444 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
445 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_lun_trn);
446 } else {
447 ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_lun_trn);
448 ISP_IOXPUT_8(isp, rqsrc->req_target, &rqdst->req_target);
449 }
450 ISP_IOXPUT_16(isp, rqsrc->req_cdblen, &rqdst->req_cdblen);
451 ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
452 ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
453 ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
454 for (i = 0; i < 12; i++) {
455 ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
456 }
457 for (i = 0; i < ISP_RQDSEG; i++) {
458 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_base,
459 &rqdst->req_dataseg[i].ds_base);
460 ISP_IOXPUT_32(isp, rqsrc->req_dataseg[i].ds_count,
461 &rqdst->req_dataseg[i].ds_count);
462 }
463 }
464
465 static INLINE void
466 isp_put_request_t2(struct ispsoftc *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
467 {
468 int i;
469 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
470 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
471 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
472 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
473 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
474 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
475 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
476 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
477 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
478 for (i = 0; i < 16; i++) {
479 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
480 }
481 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
482 for (i = 0; i < ISP_RQDSEG_T2; i++) {
483 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
484 &tqdst->req_dataseg[i].ds_base);
485 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
486 &tqdst->req_dataseg[i].ds_count);
487 }
488 }
489
490 static INLINE void
491 isp_put_request_t3(struct ispsoftc *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
492 {
493 int i;
494 isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
495 ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
496 ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
497 ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
498 ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
499 ISP_IOXPUT_16(isp, tqsrc->req_flags, &tqdst->req_flags);
500 ISP_IOXPUT_16(isp, tqsrc->_res2, &tqdst->_res2);
501 ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
502 ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
503 for (i = 0; i < 16; i++) {
504 ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
505 }
506 ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
507 for (i = 0; i < ISP_RQDSEG_T3; i++) {
508 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
509 &tqdst->req_dataseg[i].ds_base);
510 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
511 &tqdst->req_dataseg[i].ds_basehi);
512 ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
513 &tqdst->req_dataseg[i].ds_count);
514 }
515 }
516
517 static INLINE void
518 isp_put_extended_request(struct ispsoftc *isp, ispextreq_t *xqsrc,
519 ispextreq_t *xqdst)
520 {
521 int i;
522 isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
523 ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
524 if (ISP_IS_SBUS(isp)) {
525 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
526 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);
527 } else {
528 ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_lun_trn);
529 ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_target);
530 }
531 ISP_IOXPUT_16(isp, xqsrc->req_cdblen, &xqdst->req_cdblen);
532 ISP_IOXPUT_16(isp, xqsrc->req_flags, &xqdst->req_flags);
533 ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
534 ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
535 for (i = 0; i < 44; i++) {
536 ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
537 }
538 }
539
540 static INLINE void
541 isp_put_cont_req(struct ispsoftc *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
542 {
543 int i;
544 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
545 for (i = 0; i < ISP_CDSEG; i++) {
546 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
547 &cqdst->req_dataseg[i].ds_base);
548 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
549 &cqdst->req_dataseg[i].ds_count);
550 }
551 }
552
553 static INLINE void
554 isp_put_cont64_req(struct ispsoftc *isp, ispcontreq64_t *cqsrc,
555 ispcontreq64_t *cqdst)
556 {
557 int i;
558 isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
559 for (i = 0; i < ISP_CDSEG64; i++) {
560 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
561 &cqdst->req_dataseg[i].ds_base);
562 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
563 &cqdst->req_dataseg[i].ds_basehi);
564 ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
565 &cqdst->req_dataseg[i].ds_count);
566 }
567 }
568
569 static INLINE void
570 isp_get_response(struct ispsoftc *isp, ispstatusreq_t *spsrc,
571 ispstatusreq_t *spdst)
572 {
573 int i;
574 isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
575 ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
576 ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
577 ISP_IOXGET_16(isp, &spsrc->req_completion_status,
578 spdst->req_completion_status);
579 ISP_IOXGET_16(isp, &spsrc->req_state_flags, spdst->req_state_flags);
580 ISP_IOXGET_16(isp, &spsrc->req_status_flags, spdst->req_status_flags);
581 ISP_IOXGET_16(isp, &spsrc->req_time, spdst->req_time);
582 ISP_IOXGET_16(isp, &spsrc->req_sense_len, spdst->req_sense_len);
583 ISP_IOXGET_32(isp, &spsrc->req_resid, spdst->req_resid);
584 for (i = 0; i < 8; i++) {
585 ISP_IOXGET_8(isp, &spsrc->req_response[i],
586 spdst->req_response[i]);
587 }
588 for (i = 0; i < 32; i++) {
589 ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
590 spdst->req_sense_data[i]);
591 }
592 }
593
594 static INLINE void
595 isp_get_response_x(struct ispsoftc *isp, ispstatus_cont_t *cpsrc,
596 ispstatus_cont_t *cpdst)
597 {
598 int i;
599 isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
600 for (i = 0; i < 60; i++) {
601 ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
602 cpdst->req_sense_data[i]);
603 }
604 }
605
606 static INLINE void
607 isp_get_rio2(struct ispsoftc *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
608 {
609 int i;
610 isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
611 if (r2dst->req_header.rqs_seqno > 30)
612 r2dst->req_header.rqs_seqno = 30;
613 for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
614 ISP_IOXGET_16(isp, &r2src->req_handles[i],
615 r2dst->req_handles[i]);
616 }
617 while (i < 30) {
618 r2dst->req_handles[i++] = 0;
619 }
620 }
621
622 static INLINE void
623 isp_put_icb(struct ispsoftc *isp, isp_icb_t *Is, isp_icb_t *Id)
624 {
625 int i;
626 ISP_SWAP8(Is->icb_version, Is->_reserved0);
627 ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
628 ISP_IOXPUT_8(isp, Is->_reserved0, &Id->_reserved0);
629 ISP_IOXPUT_16(isp, Is->icb_fwoptions, &Id->icb_fwoptions);
630 ISP_IOXPUT_16(isp, Is->icb_maxfrmlen, &Id->icb_maxfrmlen);
631 ISP_IOXPUT_16(isp, Is->icb_maxalloc, &Id->icb_maxalloc);
632 ISP_IOXPUT_16(isp, Is->icb_execthrottle, &Id->icb_execthrottle);
633 ISP_SWAP8(Is->icb_retry_count, Is->icb_retry_delay);
634 ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_count);
635 ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_delay);
636 for (i = 0; i < 8; i++) {
637 ISP_IOXPUT_8(isp, Is->icb_portname[i], &Id->icb_portname[i]);
638 }
639 ISP_IOXPUT_16(isp, Is->icb_hardaddr, &Id->icb_hardaddr);
640 ISP_SWAP8(Is->icb_iqdevtype, Is->icb_logintime);
641 ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_iqdevtype);
642 ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_logintime);
643 for (i = 0; i < 8; i++) {
644 ISP_IOXPUT_8(isp, Is->icb_nodename[i], &Id->icb_nodename[i]);
645 }
646 ISP_IOXPUT_16(isp, Is->icb_rqstout, &Id->icb_rqstout);
647 ISP_IOXPUT_16(isp, Is->icb_rspnsin, &Id->icb_rspnsin);
648 ISP_IOXPUT_16(isp, Is->icb_rqstqlen, &Id->icb_rqstqlen);
649 ISP_IOXPUT_16(isp, Is->icb_rsltqlen, &Id->icb_rsltqlen);
650 for (i = 0; i < 4; i++) {
651 ISP_IOXPUT_16(isp, Is->icb_rqstaddr[i], &Id->icb_rqstaddr[i]);
652 }
653 for (i = 0; i < 4; i++) {
654 ISP_IOXPUT_16(isp, Is->icb_respaddr[i], &Id->icb_respaddr[i]);
655 }
656 ISP_IOXPUT_16(isp, Is->icb_lunenables, &Id->icb_lunenables);
657 ISP_SWAP8(Is->icb_ccnt, Is->icb_icnt);
658 ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_ccnt);
659 ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_icnt);
660 ISP_IOXPUT_16(isp, Is->icb_lunetimeout, &Id->icb_lunetimeout);
661 ISP_IOXPUT_16(isp, Is->icb_xfwoptions, &Id->icb_xfwoptions);
662 ISP_SWAP8(Is->icb_racctimer, Is->icb_idelaytimer);
663 ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
664 ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
665 ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
666 }
667
668 static INLINE void
669 isp_get_pdb(struct ispsoftc *isp, isp_pdb_t *src, isp_pdb_t *dst)
670 {
671 int i;
672 ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
673 ISP_IOXGET_8(isp, &src->pdb_mstate, dst->pdb_mstate);
674 ISP_IOXGET_8(isp, &src->pdb_sstate, dst->pdb_sstate);
675 for (i = 0; i < 4; i++) {
676 ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
677 dst->pdb_hardaddr_bits[i]);
678 }
679 for (i = 0; i < 4; i++) {
680 ISP_IOXGET_8(isp, &src->pdb_portid_bits[i],
681 dst->pdb_portid_bits[i]);
682 }
683 for (i = 0; i < 8; i++) {
684 ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
685 }
686 for (i = 0; i < 8; i++) {
687 ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
688 }
689 ISP_IOXGET_16(isp, &src->pdb_execthrottle, dst->pdb_execthrottle);
690 ISP_IOXGET_16(isp, &src->pdb_exec_count, dst->pdb_exec_count);
691 ISP_IOXGET_8(isp, &src->pdb_retry_count, dst->pdb_retry_count);
692 ISP_IOXGET_8(isp, &src->pdb_retry_delay, dst->pdb_retry_delay);
693 ISP_IOXGET_16(isp, &src->pdb_resalloc, dst->pdb_resalloc);
694 ISP_IOXGET_16(isp, &src->pdb_curalloc, dst->pdb_curalloc);
695 ISP_IOXGET_16(isp, &src->pdb_qhead, dst->pdb_qhead);
696 ISP_IOXGET_16(isp, &src->pdb_qtail, dst->pdb_qtail);
697 ISP_IOXGET_16(isp, &src->pdb_tl_next, dst->pdb_tl_next);
698 ISP_IOXGET_16(isp, &src->pdb_tl_last, dst->pdb_tl_last);
699 ISP_IOXGET_16(isp, &src->pdb_features, dst->pdb_features);
700 ISP_IOXGET_16(isp, &src->pdb_pconcurrnt, dst->pdb_pconcurrnt);
701 ISP_IOXGET_16(isp, &src->pdb_roi, dst->pdb_roi);
702 ISP_IOXGET_8(isp, &src->pdb_target, dst->pdb_target);
703 ISP_IOXGET_8(isp, &src->pdb_initiator, dst->pdb_initiator);
704 ISP_IOXGET_16(isp, &src->pdb_rdsiz, dst->pdb_rdsiz);
705 ISP_IOXGET_16(isp, &src->pdb_ncseq, dst->pdb_ncseq);
706 ISP_IOXGET_16(isp, &src->pdb_noseq, dst->pdb_noseq);
707 ISP_IOXGET_16(isp, &src->pdb_labrtflg, dst->pdb_labrtflg);
708 ISP_IOXGET_16(isp, &src->pdb_lstopflg, dst->pdb_lstopflg);
709 ISP_IOXGET_16(isp, &src->pdb_sqhead, dst->pdb_sqhead);
710 ISP_IOXGET_16(isp, &src->pdb_sqtail, dst->pdb_sqtail);
711 ISP_IOXGET_16(isp, &src->pdb_ptimer, dst->pdb_ptimer);
712 ISP_IOXGET_16(isp, &src->pdb_nxt_seqid, dst->pdb_nxt_seqid);
713 ISP_IOXGET_16(isp, &src->pdb_fcount, dst->pdb_fcount);
714 ISP_IOXGET_16(isp, &src->pdb_prli_len, dst->pdb_prli_len);
715 ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
716 ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
717 ISP_IOXGET_16(isp, &src->pdb_loopid, dst->pdb_loopid);
718 ISP_IOXGET_16(isp, &src->pdb_il_ptr, dst->pdb_il_ptr);
719 ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
720 }
721
722
723 /*
724 * CT_HDR canonicalization- only needed for SNS responses
725 */
726 static INLINE void
727 isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
728 {
729 ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
730 ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
731 ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
732 ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
733 ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
734 ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
735 ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);
736 ISP_IOXGET_8(isp, &src->ct_res0, dst->ct_res0);
737 ISP_IOXGET_16(isp, &src->ct_response, dst->ct_response);
738 dst->ct_response = (dst->ct_response << 8) | (dst->ct_response >> 8);
739 ISP_IOXGET_16(isp, &src->ct_resid, dst->ct_resid);
740 dst->ct_resid = (dst->ct_resid << 8) | (dst->ct_resid >> 8);
741 ISP_IOXGET_8(isp, &src->ct_res1, dst->ct_res1);
742 ISP_IOXGET_8(isp, &src->ct_reason, dst->ct_reason);
743 ISP_IOXGET_8(isp, &src->ct_explanation, dst->ct_explanation);
744 ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
745 }
746
747 /*
748 * Generic SNS request - not particularly useful since the per-command data
749 * isn't always 16 bit words.
750 */
751 static INLINE void
752 isp_put_sns_request(struct ispsoftc *isp, sns_screq_t *src,
753 sns_screq_t *dst)
754 {
755 int i, nw = (int) src->snscb_sblen;
756 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
757 for (i = 0; i < 4; i++) {
758 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
759 }
760 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
761 for (i = 0; i < nw; i++) {
762 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
763 }
764
765 }
766
767 static INLINE void
768 isp_put_gid_ft_request(struct ispsoftc *isp, sns_gid_ft_req_t *src,
769 sns_gid_ft_req_t *dst)
770 {
771 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
772 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
773 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
774 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
775 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
776 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
777 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
778 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
779 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
780 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
781 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
782 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
783 }
784
785 static INLINE void
786 isp_put_gxn_id_request(struct ispsoftc *isp, sns_gxn_id_req_t *src,
787 sns_gxn_id_req_t *dst)
788 {
789 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
790 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
791 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
792 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
793 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
794 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
795 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
796 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
797 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
798 ISP_IOXPUT_16(isp, src->snscb_res2, &dst->snscb_res2);
799 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
800 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
801 }
802
803 /*
804 * Generic SNS response - not particularly useful since the per-command data
805 * isn't always 16 bit words.
806 */
807 static INLINE void
808 isp_get_sns_response(struct ispsoftc *isp, sns_scrsp_t *src,
809 sns_scrsp_t *dst, int nwords)
810 {
811 int i;
812 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
813 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
814 for (i = 0; i < 3; i++) {
815 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
816 dst->snscb_port_id[i]);
817 }
818 for (i = 0; i < 8; i++) {
819 ISP_IOXGET_8(isp, &src->snscb_portname[i],
820 dst->snscb_portname[i]);
821 }
822 for (i = 0; i < nwords; i++) {
823 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]);
824 }
825 }
826
827 static INLINE void
828 isp_get_gid_ft_response(struct ispsoftc *isp, sns_gid_ft_rsp_t *src,
829 sns_gid_ft_rsp_t *dst, int nwords)
830 {
831 int i;
832 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
833 for (i = 0; i < nwords; i++) {
834 int j;
835 ISP_IOXGET_8(isp,
836 &src->snscb_ports[i].control,
837 dst->snscb_ports[i].control);
838 for (j = 0; j < 3; j++) {
839 ISP_IOXGET_8(isp,
840 &src->snscb_ports[i].portid[j],
841 dst->snscb_ports[i].portid[j]);
842 }
843 if (dst->snscb_ports[i].control & 0x80) {
844 break;
845 }
846 }
847 }
848
849 static INLINE void
850 isp_get_gxn_id_response(struct ispsoftc *isp, sns_gxn_id_rsp_t *src,
851 sns_gxn_id_rsp_t *dst)
852 {
853 int i;
854 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
855 for (i = 0; i < 8; i++)
856 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
857 }
858
859 static INLINE void
860 isp_get_gff_id_response(struct ispsoftc *isp, sns_gff_id_rsp_t *src,
861 sns_gff_id_rsp_t *dst)
862 {
863 int i;
864 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
865 for (i = 0; i < 32; i++) {
866 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i],
867 dst->snscb_fc4_features[i]);
868 }
869 }
870
871 static INLINE void
872 isp_get_ga_nxt_response(struct ispsoftc *isp, sns_ga_nxt_rsp_t *src,
873 sns_ga_nxt_rsp_t *dst)
874 {
875 int i;
876 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
877 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
878 for (i = 0; i < 3; i++) {
879 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
880 dst->snscb_port_id[i]);
881 }
882 for (i = 0; i < 8; i++) {
883 ISP_IOXGET_8(isp, &src->snscb_portname[i],
884 dst->snscb_portname[i]);
885 }
886 ISP_IOXGET_8(isp, &src->snscb_pnlen, dst->snscb_pnlen);
887 for (i = 0; i < 255; i++) {
888 ISP_IOXGET_8(isp, &src->snscb_pname[i], dst->snscb_pname[i]);
889 }
890 for (i = 0; i < 8; i++) {
891 ISP_IOXGET_8(isp, &src->snscb_nodename[i],
892 dst->snscb_nodename[i]);
893 }
894 ISP_IOXGET_8(isp, &src->snscb_nnlen, dst->snscb_nnlen);
895 for (i = 0; i < 255; i++) {
896 ISP_IOXGET_8(isp, &src->snscb_nname[i], dst->snscb_nname[i]);
897 }
898 for (i = 0; i < 8; i++) {
899 ISP_IOXGET_8(isp, &src->snscb_ipassoc[i],
900 dst->snscb_ipassoc[i]);
901 }
902 for (i = 0; i < 16; i++) {
903 ISP_IOXGET_8(isp, &src->snscb_ipaddr[i], dst->snscb_ipaddr[i]);
904 }
905 for (i = 0; i < 4; i++) {
906 ISP_IOXGET_8(isp, &src->snscb_svc_class[i],
907 dst->snscb_svc_class[i]);
908 }
909 for (i = 0; i < 32; i++) {
910 ISP_IOXGET_8(isp, &src->snscb_fc4_types[i],
911 dst->snscb_fc4_types[i]);
912 }
913 for (i = 0; i < 8; i++) {
914 ISP_IOXGET_8(isp, &src->snscb_fpname[i], dst->snscb_fpname[i]);
915 }
916 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
917 for (i = 0; i < 3; i++) {
918 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
919 dst->snscb_hardaddr[i]);
920 }
921 }
922
923 #ifdef ISP_TARGET_MODE
924 static INLINE void
925 isp_put_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
926 {
927 int i;
928 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
929 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
930 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
931 if (ISP_IS_SBUS(isp)) {
932 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
933 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);
934 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_tgt);
935 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_cdblen);
936 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_scsi_status);
937 ISP_IOXPUT_8(isp, atsrc->at_scsi_status, &atdst->at_status);
938 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_type);
939 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_val);
940 } else {
941 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
942 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
943 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_cdblen);
944 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_tgt);
945 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_status);
946 ISP_IOXPUT_8(isp, atsrc->at_scsi_status,
947 &atdst->at_scsi_status);
948 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_val);
949 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_type);
950 }
951 ISP_IOXPUT_32(isp, atsrc->at_flags, &atdst->at_flags);
952 for (i = 0; i < ATIO_CDBLEN; i++) {
953 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
954 }
955 for (i = 0; i < QLTM_SENSELEN; i++) {
956 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
957 }
958 }
959
960 static INLINE void
961 isp_get_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
962 {
963 int i;
964 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
965 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
966 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
967 if (ISP_IS_SBUS(isp)) {
968 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
969 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);
970 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_tgt);
971 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_cdblen);
972 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_scsi_status);
973 ISP_IOXGET_8(isp, &atsrc->at_scsi_status, atdst->at_status);
974 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_type);
975 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_val);
976 } else {
977 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
978 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
979 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_cdblen);
980 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_tgt);
981 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_status);
982 ISP_IOXGET_8(isp, &atsrc->at_scsi_status,
983 atdst->at_scsi_status);
984 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_val);
985 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_type);
986 }
987 ISP_IOXGET_32(isp, &atsrc->at_flags, atdst->at_flags);
988 for (i = 0; i < ATIO_CDBLEN; i++) {
989 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
990 }
991 for (i = 0; i < QLTM_SENSELEN; i++) {
992 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
993 }
994 }
995
996 static INLINE void
997 isp_put_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
998 {
999 int i;
1000 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
1001 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
1002 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
1003 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
1004 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
1005 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
1006 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);
1007 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn);
1008 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes);
1009 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags);
1010 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes);
1011 for (i = 0; i < ATIO2_CDBLEN; i++) {
1012 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
1013 }
1014 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen);
1015 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun);
1016 for (i = 0; i < 4; i++) {
1017 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]);
1018 }
1019 for (i = 0; i < 6; i++) {
1020 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1021 &atdst->at_reserved2[i]);
1022 }
1023 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1024 }
1025
1026 static INLINE void
1027 isp_get_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1028 {
1029 int i;
1030 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1031 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1032 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
1033 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
1034 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1035 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1036 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);
1037 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn);
1038 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes);
1039 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags);
1040 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes);
1041 for (i = 0; i < ATIO2_CDBLEN; i++) {
1042 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
1043 }
1044 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen);
1045 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun);
1046 for (i = 0; i < 4; i++) {
1047 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]);
1048 }
1049 for (i = 0; i < 6; i++) {
1050 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1051 atdst->at_reserved2[i]);
1052 }
1053 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1054 }
1055
1056 static INLINE void
1057 isp_put_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1058 {
1059 int i;
1060 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1061 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1062 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1063 if (ISP_IS_SBUS(isp)) {
1064 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
1065 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);
1066 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_reserved2);
1067 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_tgt);
1068 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_scsi_status);
1069 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, &ctdst->ct_status);
1070 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_val);
1071 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_type);
1072 } else {
1073 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1074 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1075 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_tgt);
1076 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_reserved2);
1077 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status,
1078 &ctdst->ct_scsi_status);
1079 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_status);
1080 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_type);
1081 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_val);
1082 }
1083 ISP_IOXPUT_32(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1084 ISP_IOXPUT_32(isp, ctsrc->ct_xfrlen, &ctdst->ct_xfrlen);
1085 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1086 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1087 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1088 for (i = 0; i < ISP_RQDSEG; i++) {
1089 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
1090 &ctdst->ct_dataseg[i].ds_base);
1091 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
1092 &ctdst->ct_dataseg[i].ds_count);
1093 }
1094 }
1095
1096 static INLINE void
1097 isp_get_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1098 {
1099 int i;
1100 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1101 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1102 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1103 if (ISP_IS_SBUS(isp)) {
1104 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
1105 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);
1106 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_tgt);
1107 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_reserved2);
1108 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_scsi_status);
1109 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, ctdst->ct_status);
1110 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_type);
1111 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_val);
1112 } else {
1113 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1114 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1115 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_reserved2);
1116 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_tgt);
1117 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_status);
1118 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status,
1119 ctdst->ct_scsi_status);
1120 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_val);
1121 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_type);
1122 }
1123 ISP_IOXGET_32(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1124 ISP_IOXGET_32(isp, &ctsrc->ct_xfrlen, ctdst->ct_xfrlen);
1125 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1126 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1127 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1128 for (i = 0; i < ISP_RQDSEG; i++) {
1129 ISP_IOXGET_32(isp,
1130 &ctsrc->ct_dataseg[i].ds_base,
1131 ctdst->ct_dataseg[i].ds_base);
1132 ISP_IOXGET_32(isp,
1133 &ctsrc->ct_dataseg[i].ds_count,
1134 ctdst->ct_dataseg[i].ds_count);
1135 }
1136 }
1137
1138 static INLINE void
1139 isp_put_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1140 {
1141 int i;
1142 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1143 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1144 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1145 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1146 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1147 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1148 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1149 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1150 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1151 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1152 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff);
1153 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1154 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved,
1155 &ctdst->rsp.m0._reserved);
1156 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2,
1157 &ctdst->rsp.m0._reserved2);
1158 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status,
1159 &ctdst->rsp.m0.ct_scsi_status);
1160 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen,
1161 &ctdst->rsp.m0.ct_xfrlen);
1162 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1163 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1164 ISP_IOXPUT_32(isp,
1165 ctsrc->rsp.m0.ct_dataseg[i].ds_base,
1166 &ctdst->rsp.m0.ct_dataseg[i].ds_base);
1167 ISP_IOXPUT_32(isp,
1168 ctsrc->rsp.m0.ct_dataseg[i].ds_count,
1169 &ctdst->rsp.m0.ct_dataseg[i].ds_count);
1170 }
1171 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1172 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1173 ISP_IOXPUT_32(isp,
1174 ctsrc->rsp.m0.ct_dataseg64[i].ds_base,
1175 &ctdst->rsp.m0.ct_dataseg64[i].ds_base);
1176 ISP_IOXPUT_32(isp,
1177 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi,
1178 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi);
1179 ISP_IOXPUT_32(isp,
1180 ctsrc->rsp.m0.ct_dataseg64[i].ds_count,
1181 &ctdst->rsp.m0.ct_dataseg64[i].ds_count);
1182 }
1183 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1184 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type,
1185 &ctdst->rsp.m0.ct_dslist.ds_type);
1186 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment,
1187 &ctdst->rsp.m0.ct_dslist.ds_segment);
1188 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base,
1189 &ctdst->rsp.m0.ct_dslist.ds_base);
1190 }
1191 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1192 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved,
1193 &ctdst->rsp.m1._reserved);
1194 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2,
1195 &ctdst->rsp.m1._reserved2);
1196 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen,
1197 &ctdst->rsp.m1.ct_senselen);
1198 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status,
1199 &ctdst->rsp.m1.ct_scsi_status);
1200 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen,
1201 &ctdst->rsp.m1.ct_resplen);
1202 for (i = 0; i < MAXRESPLEN; i++) {
1203 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i],
1204 &ctdst->rsp.m1.ct_resp[i]);
1205 }
1206 } else {
1207 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved,
1208 &ctdst->rsp.m2._reserved);
1209 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2,
1210 &ctdst->rsp.m2._reserved2);
1211 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3,
1212 &ctdst->rsp.m2._reserved3);
1213 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen,
1214 &ctdst->rsp.m2.ct_datalen);
1215 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1216 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1217 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1218 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1219 }
1220 }
1221
1222 static INLINE void
1223 isp_get_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1224 {
1225 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1226 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1227 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1228 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1229 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1230 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1231 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1232 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1233 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1234 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1235 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1236 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1237 }
1238
1239 static INLINE void
1240 isp_put_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1241 {
1242 int i;
1243 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
1244 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
1245 if (ISP_IS_SBUS(isp)) {
1246 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
1247 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
1248 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);
1249 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops);
1250 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2);
1251 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status);
1252 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_in_count);
1253 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_cmd_count);
1254 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb7len);
1255 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb6len);
1256 } else {
1257 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_lun);
1258 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_rsvd);
1259 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_ops);
1260 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_tgt);
1261 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_status);
1262 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_reserved2);
1263 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_cmd_count);
1264 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_in_count);
1265 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb6len);
1266 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb7len);
1267 }
1268 ISP_IOXPUT_32(isp, lesrc->le_flags, &ledst->le_flags);
1269 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout);
1270 for (i = 0; i < 20; i++) {
1271 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i],
1272 &ledst->le_reserved3[i]);
1273 }
1274 }
1275
1276 static INLINE void
1277 isp_get_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1278 {
1279 int i;
1280 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
1281 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
1282 if (ISP_IS_SBUS(isp)) {
1283 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
1284 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
1285 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);
1286 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops);
1287 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2);
1288 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status);
1289 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_in_count);
1290 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_cmd_count);
1291 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb7len);
1292 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb6len);
1293 } else {
1294 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_lun);
1295 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_rsvd);
1296 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_ops);
1297 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_tgt);
1298 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_status);
1299 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_reserved2);
1300 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_cmd_count);
1301 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_in_count);
1302 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb6len);
1303 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb7len);
1304 }
1305 ISP_IOXGET_32(isp, &lesrc->le_flags, ledst->le_flags);
1306 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
1307 for (i = 0; i < 20; i++) {
1308 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
1309 ledst->le_reserved3[i]);
1310 }
1311 }
1312
1313 static INLINE void
1314 isp_put_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1315 {
1316 int i;
1317 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1318 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1319 if (ISP_IS_SBUS(isp)) {
1320 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
1321 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
1322 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);
1323 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_reserved2);
1324 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_rsvd2);
1325 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_status);
1326 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_type);
1327 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_val);
1328 } else {
1329 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1330 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1331 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_reserved2);
1332 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_tgt);
1333 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_status);
1334 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_rsvd2);
1335 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_val);
1336 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_type);
1337 }
1338 ISP_IOXPUT_32(isp, insrc->in_flags, &indst->in_flags);
1339 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1340 for (i = 0; i < IN_MSGLEN; i++) {
1341 ISP_IOXPUT_8(isp, insrc->in_msg[i], &indst->in_msg[i]);
1342 }
1343 for (i = 0; i < IN_RSVDLEN; i++) {
1344 ISP_IOXPUT_8(isp, insrc->in_reserved3[i],
1345 &indst->in_reserved3[i]);
1346 }
1347 for (i = 0; i < QLTM_SENSELEN; i++) {
1348 ISP_IOXPUT_8(isp, insrc->in_sense[i],
1349 &indst->in_sense[i]);
1350 }
1351 }
1352
1353 static INLINE void
1354 isp_get_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1355 {
1356 int i;
1357 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1358 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1359 if (ISP_IS_SBUS(isp)) {
1360 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
1361 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
1362 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);
1363 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_reserved2);
1364 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_rsvd2);
1365 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_status);
1366 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_type);
1367 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_val);
1368 } else {
1369 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1370 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1371 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_reserved2);
1372 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_tgt);
1373 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_status);
1374 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_rsvd2);
1375 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_val);
1376 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_type);
1377 }
1378 ISP_IOXGET_32(isp, &insrc->in_flags, indst->in_flags);
1379 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1380 for (i = 0; i < IN_MSGLEN; i++) {
1381 ISP_IOXGET_8(isp, &insrc->in_msg[i], indst->in_msg[i]);
1382 }
1383 for (i = 0; i < IN_RSVDLEN; i++) {
1384 ISP_IOXGET_8(isp, &insrc->in_reserved3[i],
1385 indst->in_reserved3[i]);
1386 }
1387 for (i = 0; i < QLTM_SENSELEN; i++) {
1388 ISP_IOXGET_8(isp, &insrc->in_sense[i],
1389 indst->in_sense[i]);
1390 }
1391 }
1392
1393 static INLINE void
1394 isp_put_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1395 in_fcentry_t *indst)
1396 {
1397 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1398 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1399 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1400 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1401 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1402 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1403 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1404 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1405 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1406 }
1407
1408 static INLINE void
1409 isp_get_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1410 in_fcentry_t *indst)
1411 {
1412 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1413 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1414 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1415 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1416 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1417 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1418 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1419 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1420 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1421 }
1422
1423 static INLINE void
1424 isp_put_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1425 {
1426 int i;
1427 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1428 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1429 if (ISP_IS_SBUS(isp)) {
1430 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
1431 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
1432 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);
1433 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_status);
1434 } else {
1435 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1436 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1437 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_status);
1438 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_event);
1439 }
1440 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
1441 for (i = 0; i < NA_RSVDLEN; i++) {
1442 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1443 &nadst->na_reserved3[i]);
1444 }
1445 }
1446
1447 static INLINE void
1448 isp_get_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1449 {
1450 int i;
1451 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1452 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1453 if (ISP_IS_SBUS(isp)) {
1454 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
1455 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
1456 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);
1457 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_status);
1458 } else {
1459 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1460 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1461 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_status);
1462 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_event);
1463 }
1464 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
1465 for (i = 0; i < NA_RSVDLEN; i++) {
1466 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1467 nadst->na_reserved3[i]);
1468 }
1469 }
1470
1471 static INLINE void
1472 isp_put_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1473 na_fcentry_t *nadst)
1474 {
1475 int i;
1476 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1477 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1478 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1479 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1480 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);
1481 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1482 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1483 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1484 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1485 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1486 for (i = 0; i < NA2_RSVDLEN; i++) {
1487 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1488 &nadst->na_reserved3[i]);
1489 }
1490 }
1491
1492 static INLINE void
1493 isp_get_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1494 na_fcentry_t *nadst)
1495 {
1496 int i;
1497 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1498 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1499 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1500 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1501 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);
1502 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1503 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1504 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1505 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1506 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1507 for (i = 0; i < NA2_RSVDLEN; i++) {
1508 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1509 nadst->na_reserved3[i]);
1510 }
1511 }
1512 #endif
1513 #endif /* _ISP_INLINE_H */
Cache object: 4f252461d7d88578f8c4d532f51049b3
|