1 /* $NetBSD: isp_inline.h,v 1.24 2003/12/04 13:57:30 keihan 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 buf[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 (buf[0] = 0, amt = i = 0; i < 4; i++) {
181 buf[0] = 0;
182 SNPRINTF(buf, TBA, " ");
183 for (j = 0; j < (QENTRY_LEN >> 2); j++) {
184 SNPRINTF(buf, TBA, "%s %02x", buf, ptr[amt++] & 0xff);
185 }
186 isp_prt(isp, ISP_LOGALL, buf);
187 }
188 }
189
190 static INLINE void isp_print_bytes(struct ispsoftc *, char *, int, void *);
191
192 static INLINE void
193 isp_print_bytes(struct ispsoftc *isp, char *msg, int amt, void *arg)
194 {
195 char buf[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 buf[0] = 0;
203 while (off < amt) {
204 int j, to;
205 to = off;
206 for (j = 0; j < 16; j++) {
207 SNPRINTF(buf, 128, "%s %02x", buf, ptr[off++] & 0xff);
208 if (off == amt)
209 break;
210 }
211 isp_prt(isp, ISP_LOGALL, "0x%08x:%s", to, buf);
212 buf[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, sns_screq_t *dst)
753 {
754 int i, nw = (int) src->snscb_sblen;
755 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
756 for (i = 0; i < 4; i++) {
757 ISP_IOXPUT_16(isp, src->snscb_addr[i], &dst->snscb_addr[i]);
758 }
759 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
760 for (i = 0; i < nw; i++) {
761 ISP_IOXPUT_16(isp, src->snscb_data[i], &dst->snscb_data[i]);
762 }
763
764 }
765
766 static INLINE void
767 isp_put_gid_ft_request(struct ispsoftc *isp, sns_gid_ft_req_t *src,
768 sns_gid_ft_req_t *dst)
769 {
770 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
771 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
772 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
773 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
774 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
775 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
776 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
777 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
778 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
779 ISP_IOXPUT_16(isp, src->snscb_mword_div_2, &dst->snscb_mword_div_2);
780 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
781 ISP_IOXPUT_32(isp, src->snscb_fc4_type, &dst->snscb_fc4_type);
782 }
783
784 static INLINE void
785 isp_put_gxn_id_request(struct ispsoftc *isp, sns_gxn_id_req_t *src,
786 sns_gxn_id_req_t *dst)
787 {
788 ISP_IOXPUT_16(isp, src->snscb_rblen, &dst->snscb_rblen);
789 ISP_IOXPUT_16(isp, src->snscb_res0, &dst->snscb_res0);
790 ISP_IOXPUT_16(isp, src->snscb_addr[0], &dst->snscb_addr[0]);
791 ISP_IOXPUT_16(isp, src->snscb_addr[1], &dst->snscb_addr[1]);
792 ISP_IOXPUT_16(isp, src->snscb_addr[2], &dst->snscb_addr[2]);
793 ISP_IOXPUT_16(isp, src->snscb_addr[3], &dst->snscb_addr[3]);
794 ISP_IOXPUT_16(isp, src->snscb_sblen, &dst->snscb_sblen);
795 ISP_IOXPUT_16(isp, src->snscb_res1, &dst->snscb_res1);
796 ISP_IOXPUT_16(isp, src->snscb_cmd, &dst->snscb_cmd);
797 ISP_IOXPUT_16(isp, src->snscb_res2, &dst->snscb_res2);
798 ISP_IOXPUT_32(isp, src->snscb_res3, &dst->snscb_res3);
799 ISP_IOXPUT_32(isp, src->snscb_portid, &dst->snscb_portid);
800 }
801
802 /*
803 * Generic SNS response - not particularly useful since the per-command data
804 * isn't always 16 bit words.
805 */
806 static INLINE void
807 isp_get_sns_response(struct ispsoftc *isp, sns_scrsp_t *src,
808 sns_scrsp_t *dst, int nwords)
809 {
810 int i;
811 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
812 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
813 for (i = 0; i < 3; i++) {
814 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
815 dst->snscb_port_id[i]);
816 }
817 for (i = 0; i < 8; i++) {
818 ISP_IOXGET_8(isp, &src->snscb_portname[i],
819 dst->snscb_portname[i]);
820 }
821 for (i = 0; i < nwords; i++) {
822 ISP_IOXGET_16(isp, &src->snscb_data[i], dst->snscb_data[i]);
823 }
824 }
825
826 static INLINE void
827 isp_get_gid_ft_response(struct ispsoftc *isp, sns_gid_ft_rsp_t *src,
828 sns_gid_ft_rsp_t *dst, int nwords)
829 {
830 int i;
831 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
832 for (i = 0; i < nwords; i++) {
833 int j;
834 ISP_IOXGET_8(isp,
835 &src->snscb_ports[i].control,
836 dst->snscb_ports[i].control);
837 for (j = 0; j < 3; j++) {
838 ISP_IOXGET_8(isp,
839 &src->snscb_ports[i].portid[j],
840 dst->snscb_ports[i].portid[j]);
841 }
842 if (dst->snscb_ports[i].control & 0x80) {
843 break;
844 }
845 }
846 }
847
848 static INLINE void
849 isp_get_gxn_id_response(struct ispsoftc *isp, sns_gxn_id_rsp_t *src,
850 sns_gxn_id_rsp_t *dst)
851 {
852 int i;
853 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
854 for (i = 0; i < 8; i++)
855 ISP_IOXGET_8(isp, &src->snscb_wwn[i], dst->snscb_wwn[i]);
856 }
857
858 static INLINE void
859 isp_get_gff_id_response(struct ispsoftc *isp, sns_gff_id_rsp_t *src,
860 sns_gff_id_rsp_t *dst)
861 {
862 int i;
863 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
864 for (i = 0; i < 32; i++) {
865 ISP_IOXGET_32(isp, &src->snscb_fc4_features[i],
866 dst->snscb_fc4_features[i]);
867 }
868 }
869
870 static INLINE void
871 isp_get_ga_nxt_response(struct ispsoftc *isp, sns_ga_nxt_rsp_t *src,
872 sns_ga_nxt_rsp_t *dst)
873 {
874 int i;
875 isp_get_ct_hdr(isp, &src->snscb_cthdr, &dst->snscb_cthdr);
876 ISP_IOXGET_8(isp, &src->snscb_port_type, dst->snscb_port_type);
877 for (i = 0; i < 3; i++) {
878 ISP_IOXGET_8(isp, &src->snscb_port_id[i],
879 dst->snscb_port_id[i]);
880 }
881 for (i = 0; i < 8; i++) {
882 ISP_IOXGET_8(isp, &src->snscb_portname[i],
883 dst->snscb_portname[i]);
884 }
885 ISP_IOXGET_8(isp, &src->snscb_pnlen, dst->snscb_pnlen);
886 for (i = 0; i < 255; i++) {
887 ISP_IOXGET_8(isp, &src->snscb_pname[i], dst->snscb_pname[i]);
888 }
889 for (i = 0; i < 8; i++) {
890 ISP_IOXGET_8(isp, &src->snscb_nodename[i],
891 dst->snscb_nodename[i]);
892 }
893 ISP_IOXGET_8(isp, &src->snscb_nnlen, dst->snscb_nnlen);
894 for (i = 0; i < 255; i++) {
895 ISP_IOXGET_8(isp, &src->snscb_nname[i], dst->snscb_nname[i]);
896 }
897 for (i = 0; i < 8; i++) {
898 ISP_IOXGET_8(isp, &src->snscb_ipassoc[i],
899 dst->snscb_ipassoc[i]);
900 }
901 for (i = 0; i < 16; i++) {
902 ISP_IOXGET_8(isp, &src->snscb_ipaddr[i], dst->snscb_ipaddr[i]);
903 }
904 for (i = 0; i < 4; i++) {
905 ISP_IOXGET_8(isp, &src->snscb_svc_class[i],
906 dst->snscb_svc_class[i]);
907 }
908 for (i = 0; i < 32; i++) {
909 ISP_IOXGET_8(isp, &src->snscb_fc4_types[i],
910 dst->snscb_fc4_types[i]);
911 }
912 for (i = 0; i < 8; i++) {
913 ISP_IOXGET_8(isp, &src->snscb_fpname[i], dst->snscb_fpname[i]);
914 }
915 ISP_IOXGET_8(isp, &src->snscb_reserved, dst->snscb_reserved);
916 for (i = 0; i < 3; i++) {
917 ISP_IOXGET_8(isp, &src->snscb_hardaddr[i],
918 dst->snscb_hardaddr[i]);
919 }
920 }
921
922 #ifdef ISP_TARGET_MODE
923 static INLINE void
924 isp_put_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
925 {
926 int i;
927 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
928 ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
929 ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
930 if (ISP_IS_SBUS(isp)) {
931 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
932 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);
933 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_tgt);
934 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_cdblen);
935 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_scsi_status);
936 ISP_IOXPUT_8(isp, atsrc->at_scsi_status, &atdst->at_status);
937 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_type);
938 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_val);
939 } else {
940 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
941 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
942 ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_cdblen);
943 ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_tgt);
944 ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_status);
945 ISP_IOXPUT_8(isp, atsrc->at_scsi_status,
946 &atdst->at_scsi_status);
947 ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_val);
948 ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_type);
949 }
950 ISP_IOXPUT_32(isp, atsrc->at_flags, &atdst->at_flags);
951 for (i = 0; i < ATIO_CDBLEN; i++) {
952 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
953 }
954 for (i = 0; i < QLTM_SENSELEN; i++) {
955 ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
956 }
957 }
958
959 static INLINE void
960 isp_get_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
961 {
962 int i;
963 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
964 ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
965 ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
966 if (ISP_IS_SBUS(isp)) {
967 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
968 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);
969 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_tgt);
970 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_cdblen);
971 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_scsi_status);
972 ISP_IOXGET_8(isp, &atsrc->at_scsi_status, atdst->at_status);
973 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_type);
974 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_val);
975 } else {
976 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
977 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
978 ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_cdblen);
979 ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_tgt);
980 ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_status);
981 ISP_IOXGET_8(isp, &atsrc->at_scsi_status,
982 atdst->at_scsi_status);
983 ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_val);
984 ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_type);
985 }
986 ISP_IOXGET_32(isp, &atsrc->at_flags, atdst->at_flags);
987 for (i = 0; i < ATIO_CDBLEN; i++) {
988 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
989 }
990 for (i = 0; i < QLTM_SENSELEN; i++) {
991 ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
992 }
993 }
994
995 static INLINE void
996 isp_put_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
997 {
998 int i;
999 isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
1000 ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
1001 ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
1002 ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
1003 ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
1004 ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
1005 ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);
1006 ISP_IOXPUT_8(isp, atsrc->at_crn, &atdst->at_crn);
1007 ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes);
1008 ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags);
1009 ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes);
1010 for (i = 0; i < ATIO2_CDBLEN; i++) {
1011 ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
1012 }
1013 ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen);
1014 ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun);
1015 for (i = 0; i < 4; i++) {
1016 ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]);
1017 }
1018 for (i = 0; i < 6; i++) {
1019 ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
1020 &atdst->at_reserved2[i]);
1021 }
1022 ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
1023 }
1024
1025 static INLINE void
1026 isp_get_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
1027 {
1028 int i;
1029 isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
1030 ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
1031 ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
1032 ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
1033 ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
1034 ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
1035 ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);
1036 ISP_IOXGET_8(isp, &atsrc->at_crn, atdst->at_crn);
1037 ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes);
1038 ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags);
1039 ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes);
1040 for (i = 0; i < ATIO2_CDBLEN; i++) {
1041 ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
1042 }
1043 ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen);
1044 ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun);
1045 for (i = 0; i < 4; i++) {
1046 ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]);
1047 }
1048 for (i = 0; i < 6; i++) {
1049 ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
1050 atdst->at_reserved2[i]);
1051 }
1052 ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
1053 }
1054
1055 static INLINE void
1056 isp_put_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1057 {
1058 int i;
1059 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1060 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1061 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1062 if (ISP_IS_SBUS(isp)) {
1063 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
1064 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);
1065 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_reserved2);
1066 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_tgt);
1067 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_scsi_status);
1068 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, &ctdst->ct_status);
1069 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_val);
1070 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_type);
1071 } else {
1072 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1073 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1074 ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_tgt);
1075 ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_reserved2);
1076 ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status,
1077 &ctdst->ct_scsi_status);
1078 ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_status);
1079 ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_type);
1080 ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_val);
1081 }
1082 ISP_IOXPUT_32(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1083 ISP_IOXPUT_32(isp, ctsrc->ct_xfrlen, &ctdst->ct_xfrlen);
1084 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1085 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1086 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1087 for (i = 0; i < ISP_RQDSEG; i++) {
1088 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
1089 &ctdst->ct_dataseg[i].ds_base);
1090 ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
1091 &ctdst->ct_dataseg[i].ds_count);
1092 }
1093 }
1094
1095 static INLINE void
1096 isp_get_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
1097 {
1098 int i;
1099 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1100 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1101 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1102 if (ISP_IS_SBUS(isp)) {
1103 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
1104 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);
1105 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_tgt);
1106 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_reserved2);
1107 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_scsi_status);
1108 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, ctdst->ct_status);
1109 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_type);
1110 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_val);
1111 } else {
1112 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1113 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1114 ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_reserved2);
1115 ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_tgt);
1116 ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_status);
1117 ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status,
1118 ctdst->ct_scsi_status);
1119 ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_val);
1120 ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_type);
1121 }
1122 ISP_IOXGET_32(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1123 ISP_IOXGET_32(isp, &ctsrc->ct_xfrlen, ctdst->ct_xfrlen);
1124 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1125 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1126 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1127 for (i = 0; i < ISP_RQDSEG; i++) {
1128 ISP_IOXGET_32(isp,
1129 &ctsrc->ct_dataseg[i].ds_base,
1130 ctdst->ct_dataseg[i].ds_base);
1131 ISP_IOXGET_32(isp,
1132 &ctsrc->ct_dataseg[i].ds_count,
1133 ctdst->ct_dataseg[i].ds_count);
1134 }
1135 }
1136
1137 static INLINE void
1138 isp_put_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1139 {
1140 int i;
1141 isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1142 ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
1143 ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
1144 ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
1145 ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
1146 ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
1147 ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);
1148 ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
1149 ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
1150 ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
1151 ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff);
1152 if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
1153 ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved,
1154 &ctdst->rsp.m0._reserved);
1155 ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2,
1156 &ctdst->rsp.m0._reserved2);
1157 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status,
1158 &ctdst->rsp.m0.ct_scsi_status);
1159 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen,
1160 &ctdst->rsp.m0.ct_xfrlen);
1161 if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
1162 for (i = 0; i < ISP_RQDSEG_T2; i++) {
1163 ISP_IOXPUT_32(isp,
1164 ctsrc->rsp.m0.ct_dataseg[i].ds_base,
1165 &ctdst->rsp.m0.ct_dataseg[i].ds_base);
1166 ISP_IOXPUT_32(isp,
1167 ctsrc->rsp.m0.ct_dataseg[i].ds_count,
1168 &ctdst->rsp.m0.ct_dataseg[i].ds_count);
1169 }
1170 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
1171 for (i = 0; i < ISP_RQDSEG_T3; i++) {
1172 ISP_IOXPUT_32(isp,
1173 ctsrc->rsp.m0.ct_dataseg64[i].ds_base,
1174 &ctdst->rsp.m0.ct_dataseg64[i].ds_base);
1175 ISP_IOXPUT_32(isp,
1176 ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi,
1177 &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi);
1178 ISP_IOXPUT_32(isp,
1179 ctsrc->rsp.m0.ct_dataseg64[i].ds_count,
1180 &ctdst->rsp.m0.ct_dataseg64[i].ds_count);
1181 }
1182 } else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
1183 ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type,
1184 &ctdst->rsp.m0.ct_dslist.ds_type);
1185 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment,
1186 &ctdst->rsp.m0.ct_dslist.ds_segment);
1187 ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base,
1188 &ctdst->rsp.m0.ct_dslist.ds_base);
1189 }
1190 } else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
1191 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved,
1192 &ctdst->rsp.m1._reserved);
1193 ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2,
1194 &ctdst->rsp.m1._reserved2);
1195 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen,
1196 &ctdst->rsp.m1.ct_senselen);
1197 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status,
1198 &ctdst->rsp.m1.ct_scsi_status);
1199 ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen,
1200 &ctdst->rsp.m1.ct_resplen);
1201 for (i = 0; i < MAXRESPLEN; i++) {
1202 ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i],
1203 &ctdst->rsp.m1.ct_resp[i]);
1204 }
1205 } else {
1206 ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved,
1207 &ctdst->rsp.m2._reserved);
1208 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2,
1209 &ctdst->rsp.m2._reserved2);
1210 ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3,
1211 &ctdst->rsp.m2._reserved3);
1212 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen,
1213 &ctdst->rsp.m2.ct_datalen);
1214 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
1215 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
1216 ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
1217 &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
1218 }
1219 }
1220
1221 static INLINE void
1222 isp_get_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
1223 {
1224 isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
1225 ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
1226 ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
1227 ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
1228 ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
1229 ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
1230 ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
1231 ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
1232 ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
1233 ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
1234 ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
1235 ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
1236 }
1237
1238 static INLINE void
1239 isp_put_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1240 {
1241 int i;
1242 isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
1243 ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
1244 if (ISP_IS_SBUS(isp)) {
1245 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
1246 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_lun);
1247 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_tgt);
1248 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_ops);
1249 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_reserved2);
1250 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_status);
1251 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_in_count);
1252 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_cmd_count);
1253 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb7len);
1254 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb6len);
1255 } else {
1256 ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_lun);
1257 ISP_IOXPUT_8(isp, lesrc->le_rsvd, &ledst->le_rsvd);
1258 ISP_IOXPUT_8(isp, lesrc->le_ops, &ledst->le_ops);
1259 ISP_IOXPUT_8(isp, lesrc->le_tgt, &ledst->le_tgt);
1260 ISP_IOXPUT_8(isp, lesrc->le_status, &ledst->le_status);
1261 ISP_IOXPUT_8(isp, lesrc->le_reserved2, &ledst->le_reserved2);
1262 ISP_IOXPUT_8(isp, lesrc->le_cmd_count, &ledst->le_cmd_count);
1263 ISP_IOXPUT_8(isp, lesrc->le_in_count, &ledst->le_in_count);
1264 ISP_IOXPUT_8(isp, lesrc->le_cdb6len, &ledst->le_cdb6len);
1265 ISP_IOXPUT_8(isp, lesrc->le_cdb7len, &ledst->le_cdb7len);
1266 }
1267 ISP_IOXPUT_32(isp, lesrc->le_flags, &ledst->le_flags);
1268 ISP_IOXPUT_16(isp, lesrc->le_timeout, &ledst->le_timeout);
1269 for (i = 0; i < 20; i++) {
1270 ISP_IOXPUT_8(isp, lesrc->le_reserved3[i],
1271 &ledst->le_reserved3[i]);
1272 }
1273 }
1274
1275 static INLINE void
1276 isp_get_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
1277 {
1278 int i;
1279 isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
1280 ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
1281 if (ISP_IS_SBUS(isp)) {
1282 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
1283 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_lun);
1284 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_tgt);
1285 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_ops);
1286 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_reserved2);
1287 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_status);
1288 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_in_count);
1289 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_cmd_count);
1290 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb7len);
1291 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb6len);
1292 } else {
1293 ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_lun);
1294 ISP_IOXGET_8(isp, &lesrc->le_rsvd, ledst->le_rsvd);
1295 ISP_IOXGET_8(isp, &lesrc->le_ops, ledst->le_ops);
1296 ISP_IOXGET_8(isp, &lesrc->le_tgt, ledst->le_tgt);
1297 ISP_IOXGET_8(isp, &lesrc->le_status, ledst->le_status);
1298 ISP_IOXGET_8(isp, &lesrc->le_reserved2, ledst->le_reserved2);
1299 ISP_IOXGET_8(isp, &lesrc->le_cmd_count, ledst->le_cmd_count);
1300 ISP_IOXGET_8(isp, &lesrc->le_in_count, ledst->le_in_count);
1301 ISP_IOXGET_8(isp, &lesrc->le_cdb6len, ledst->le_cdb6len);
1302 ISP_IOXGET_8(isp, &lesrc->le_cdb7len, ledst->le_cdb7len);
1303 }
1304 ISP_IOXGET_32(isp, &lesrc->le_flags, ledst->le_flags);
1305 ISP_IOXGET_16(isp, &lesrc->le_timeout, ledst->le_timeout);
1306 for (i = 0; i < 20; i++) {
1307 ISP_IOXGET_8(isp, &lesrc->le_reserved3[i],
1308 ledst->le_reserved3[i]);
1309 }
1310 }
1311
1312 static INLINE void
1313 isp_put_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1314 {
1315 int i;
1316 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1317 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1318 if (ISP_IS_SBUS(isp)) {
1319 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
1320 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
1321 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);
1322 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_reserved2);
1323 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_rsvd2);
1324 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_status);
1325 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_type);
1326 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_val);
1327 } else {
1328 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1329 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1330 ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_reserved2);
1331 ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_tgt);
1332 ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_status);
1333 ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_rsvd2);
1334 ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_val);
1335 ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_type);
1336 }
1337 ISP_IOXPUT_32(isp, insrc->in_flags, &indst->in_flags);
1338 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1339 for (i = 0; i < IN_MSGLEN; i++) {
1340 ISP_IOXPUT_8(isp, insrc->in_msg[i], &indst->in_msg[i]);
1341 }
1342 for (i = 0; i < IN_RSVDLEN; i++) {
1343 ISP_IOXPUT_8(isp, insrc->in_reserved3[i],
1344 &indst->in_reserved3[i]);
1345 }
1346 for (i = 0; i < QLTM_SENSELEN; i++) {
1347 ISP_IOXPUT_8(isp, insrc->in_sense[i],
1348 &indst->in_sense[i]);
1349 }
1350 }
1351
1352 static INLINE void
1353 isp_get_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
1354 {
1355 int i;
1356 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1357 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1358 if (ISP_IS_SBUS(isp)) {
1359 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
1360 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
1361 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);
1362 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_reserved2);
1363 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_rsvd2);
1364 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_status);
1365 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_type);
1366 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_val);
1367 } else {
1368 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1369 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1370 ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_reserved2);
1371 ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_tgt);
1372 ISP_IOXGET_8(isp, &insrc->in_status, indst->in_status);
1373 ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_rsvd2);
1374 ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_val);
1375 ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_type);
1376 }
1377 ISP_IOXGET_32(isp, &insrc->in_flags, indst->in_flags);
1378 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1379 for (i = 0; i < IN_MSGLEN; i++) {
1380 ISP_IOXGET_8(isp, &insrc->in_msg[i], indst->in_msg[i]);
1381 }
1382 for (i = 0; i < IN_RSVDLEN; i++) {
1383 ISP_IOXGET_8(isp, &insrc->in_reserved3[i],
1384 indst->in_reserved3[i]);
1385 }
1386 for (i = 0; i < QLTM_SENSELEN; i++) {
1387 ISP_IOXGET_8(isp, &insrc->in_sense[i],
1388 indst->in_sense[i]);
1389 }
1390 }
1391
1392 static INLINE void
1393 isp_put_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1394 in_fcentry_t *indst)
1395 {
1396 isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
1397 ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
1398 ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
1399 ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
1400 ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
1401 ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
1402 ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
1403 ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
1404 ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
1405 }
1406
1407 static INLINE void
1408 isp_get_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
1409 in_fcentry_t *indst)
1410 {
1411 isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
1412 ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
1413 ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
1414 ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
1415 ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
1416 ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
1417 ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
1418 ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
1419 ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
1420 }
1421
1422 static INLINE void
1423 isp_put_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1424 {
1425 int i;
1426 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1427 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1428 if (ISP_IS_SBUS(isp)) {
1429 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
1430 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
1431 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);
1432 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_status);
1433 } else {
1434 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1435 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1436 ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_status);
1437 ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_event);
1438 }
1439 ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
1440 for (i = 0; i < NA_RSVDLEN; i++) {
1441 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1442 &nadst->na_reserved3[i]);
1443 }
1444 }
1445
1446 static INLINE void
1447 isp_get_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
1448 {
1449 int i;
1450 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1451 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1452 if (ISP_IS_SBUS(isp)) {
1453 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
1454 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
1455 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);
1456 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_status);
1457 } else {
1458 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1459 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1460 ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_status);
1461 ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_event);
1462 }
1463 ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
1464 for (i = 0; i < NA_RSVDLEN; i++) {
1465 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1466 nadst->na_reserved3[i]);
1467 }
1468 }
1469
1470 static INLINE void
1471 isp_put_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1472 na_fcentry_t *nadst)
1473 {
1474 int i;
1475 isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
1476 ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
1477 ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
1478 ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
1479 ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);
1480 ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
1481 ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
1482 ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
1483 ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
1484 ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
1485 for (i = 0; i < NA2_RSVDLEN; i++) {
1486 ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
1487 &nadst->na_reserved3[i]);
1488 }
1489 }
1490
1491 static INLINE void
1492 isp_get_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
1493 na_fcentry_t *nadst)
1494 {
1495 int i;
1496 isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
1497 ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
1498 ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
1499 ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
1500 ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);
1501 ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
1502 ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
1503 ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
1504 ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
1505 ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
1506 for (i = 0; i < NA2_RSVDLEN; i++) {
1507 ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
1508 nadst->na_reserved3[i]);
1509 }
1510 }
1511 #endif
1512 #endif /* _ISP_INLINE_H */
Cache object: c30fd3da457a8ef1a6069fc8fc4af75a
|