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