xref: /freebsd/sys/dev/isp/isp_freebsd.h (revision 5c831a5bd61576cacb48b39f8eeb47b92707a355)
1 /* $FreeBSD$ */
2 /*-
3  * Qlogic ISP SCSI Host Adapter FreeBSD Wrapper Definitions
4  *
5  * Copyright (c) 1997-2008 by Matthew Jacob
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice immediately at the beginning of the file, without modification,
13  *    this list of conditions, and the following disclaimer.
14  * 2. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 #ifndef	_ISP_FREEBSD_H
30 #define	_ISP_FREEBSD_H
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/endian.h>
35 #include <sys/jail.h>
36 #include <sys/lock.h>
37 #include <sys/kernel.h>
38 #include <sys/queue.h>
39 #include <sys/malloc.h>
40 #include <sys/mutex.h>
41 #include <sys/condvar.h>
42 #include <sys/rman.h>
43 #include <sys/sysctl.h>
44 
45 #include <sys/proc.h>
46 #include <sys/bus.h>
47 #include <sys/taskqueue.h>
48 
49 #include <machine/bus.h>
50 #include <machine/cpu.h>
51 #include <machine/stdarg.h>
52 
53 #include <cam/cam.h>
54 #include <cam/cam_debug.h>
55 #include <cam/cam_ccb.h>
56 #include <cam/cam_sim.h>
57 #include <cam/cam_xpt.h>
58 #include <cam/cam_xpt_sim.h>
59 #include <cam/cam_debug.h>
60 #include <cam/scsi/scsi_all.h>
61 #include <cam/scsi/scsi_message.h>
62 
63 #include "opt_ddb.h"
64 #include "opt_isp.h"
65 
66 #define	ISP_PLATFORM_VERSION_MAJOR	7
67 #define	ISP_PLATFORM_VERSION_MINOR	10
68 
69 /*
70  * Efficiency- get rid of SBus code && tests unless we need them.
71  */
72 #ifdef __sparc64__
73 #define	ISP_SBUS_SUPPORTED	1
74 #else
75 #define	ISP_SBUS_SUPPORTED	0
76 #endif
77 
78 #define	ISP_IFLAGS	INTR_TYPE_CAM | INTR_ENTROPY | INTR_MPSAFE
79 
80 #define	N_XCMDS		64
81 #define	XCMD_SIZE	512
82 struct ispsoftc;
83 typedef union isp_ecmd {
84 	union isp_ecmd *	next;
85 	uint8_t			data[XCMD_SIZE];
86 } isp_ecmd_t;
87 isp_ecmd_t *	isp_get_ecmd(struct ispsoftc *);
88 void		isp_put_ecmd(struct ispsoftc *, isp_ecmd_t *);
89 
90 #ifdef	ISP_TARGET_MODE
91 #define	ATPDPSIZE	4096
92 #define	ATPDPHASHSIZE	32
93 #define	ATPDPHASH(x)	((((x) >> 24) ^ ((x) >> 16) ^ ((x) >> 8) ^ (x)) &  \
94 			    ((ATPDPHASHSIZE) - 1))
95 
96 #include <dev/isp/isp_target.h>
97 typedef struct atio_private_data {
98 	LIST_ENTRY(atio_private_data)	next;
99 	uint32_t	orig_datalen;
100 	uint32_t	bytes_xfered;
101 	uint32_t	bytes_in_transit;
102 	uint32_t	tag;		/* typically f/w RX_ID */
103 	lun_id_t	lun;
104 	uint32_t	nphdl;
105 	uint32_t	sid;
106 	uint32_t	did;
107 	uint16_t	rxid;	/* wire rxid */
108 	uint16_t	oxid;	/* wire oxid */
109 	uint16_t	word3;	/* PRLI word3 params */
110 	uint16_t	ctcnt;	/* number of CTIOs currently active */
111 	uint8_t		seqno;	/* CTIO sequence number */
112 	uint32_t
113 			srr_notify_rcvd	: 1,
114 			cdb0		: 8,
115 			sendst		: 1,
116 			dead		: 1,
117 			tattr		: 3,
118 			state		: 3;
119 	void *		ests;
120 	/*
121 	 * The current SRR notify copy
122 	 */
123 	uint8_t		srr[64];	/*  sb QENTRY_LEN, but order of definitions is wrong */
124 	void *		srr_ccb;
125 	uint32_t	nsrr;
126 } atio_private_data_t;
127 #define	ATPD_STATE_FREE			0
128 #define	ATPD_STATE_ATIO			1
129 #define	ATPD_STATE_CAM			2
130 #define	ATPD_STATE_CTIO			3
131 #define	ATPD_STATE_LAST_CTIO		4
132 #define	ATPD_STATE_PDON			5
133 
134 #define	ATPD_CCB_OUTSTANDING		16
135 
136 #define	ATPD_SEQ_MASK			0x7f
137 #define	ATPD_SEQ_NOTIFY_CAM		0x80
138 #define	ATPD_SET_SEQNO(hdrp, atp)	((isphdr_t *)hdrp)->rqs_seqno &= ~ATPD_SEQ_MASK, ((isphdr_t *)hdrp)->rqs_seqno |= (atp)->seqno
139 #define	ATPD_GET_SEQNO(hdrp)		(((isphdr_t *)hdrp)->rqs_seqno & ATPD_SEQ_MASK)
140 #define	ATPD_GET_NCAM(hdrp)		((((isphdr_t *)hdrp)->rqs_seqno & ATPD_SEQ_NOTIFY_CAM) != 0)
141 
142 typedef struct inot_private_data inot_private_data_t;
143 struct inot_private_data {
144 	STAILQ_ENTRY(inot_private_data)	next;
145 	isp_notify_t nt;
146 	uint8_t data[64];	/* sb QENTRY_LEN, but order of definitions is wrong */
147 	uint32_t tag_id, seq_id;
148 };
149 typedef struct isp_timed_notify_ack {
150 	void *isp;
151 	void *not;
152 	uint8_t data[64];	 /* sb QENTRY_LEN, but order of definitions is wrong */
153 	struct callout timer;
154 } isp_tna_t;
155 
156 STAILQ_HEAD(ntpdlist, inot_private_data);
157 typedef struct tstate {
158 	SLIST_ENTRY(tstate)	next;
159 	lun_id_t		ts_lun;
160 	struct ccb_hdr_slist	atios;
161 	struct ccb_hdr_slist	inots;
162 	struct ntpdlist		restart_queue;
163 } tstate_t;
164 
165 #define	LUN_HASH_SIZE		32
166 #define	LUN_HASH_FUNC(lun)	((lun) & (LUN_HASH_SIZE - 1))
167 
168 #endif
169 
170 /*
171  * Per command info.
172  */
173 struct isp_pcmd {
174 	struct isp_pcmd *	next;
175 	bus_dmamap_t 		dmap;		/* dma map for this command */
176 	struct callout		wdog;		/* watchdog timer */
177 	uint32_t		datalen;	/* data length for this command (target mode only) */
178 };
179 #define	ISP_PCMD(ccb)		(ccb)->ccb_h.spriv_ptr1
180 #define	PISP_PCMD(ccb)		((struct isp_pcmd *)ISP_PCMD(ccb))
181 
182 /*
183  * Per nexus info.
184  */
185 struct isp_nexus {
186 	uint64_t lun;			/* LUN for target */
187 	uint32_t tgt;			/* TGT for target */
188 	uint8_t crnseed;		/* next command reference number */
189 	struct isp_nexus *next;
190 };
191 #define	NEXUS_HASH_WIDTH	32
192 #define	INITIAL_NEXUS_COUNT	MAX_FC_TARG
193 #define	NEXUS_HASH(tgt, lun)	((tgt + lun) % NEXUS_HASH_WIDTH)
194 
195 /*
196  * Per channel information
197  */
198 SLIST_HEAD(tslist, tstate);
199 TAILQ_HEAD(isp_ccbq, ccb_hdr);
200 LIST_HEAD(atpdlist, atio_private_data);
201 
202 struct isp_fc {
203 	struct cam_sim *sim;
204 	struct cam_path *path;
205 	struct ispsoftc *isp;
206 	struct proc *kproc;
207 	bus_dmamap_t scmap;
208 	uint64_t def_wwpn;
209 	uint64_t def_wwnn;
210 	time_t loop_down_time;
211 	int loop_down_limit;
212 	int gone_device_time;
213 	/*
214 	 * Per target/lun info- just to keep a per-ITL nexus crn count
215 	 */
216 	struct isp_nexus *nexus_hash[NEXUS_HASH_WIDTH];
217 	struct isp_nexus *nexus_free_list;
218 	uint32_t
219 		simqfrozen	: 3,
220 		default_id	: 8,
221 		def_role	: 2,	/* default role */
222 		loop_seen_once	: 1,
223 		fcbsy		: 1,
224 		ready		: 1;
225 	struct callout gdt;	/* gone device timer */
226 	struct task gtask;
227 #ifdef	ISP_TARGET_MODE
228 	struct tslist		lun_hash[LUN_HASH_SIZE];
229 	struct isp_ccbq		waitq;		/* waiting CCBs */
230 	struct ntpdlist		ntfree;
231 	inot_private_data_t	ntpool[ATPDPSIZE];
232 	struct atpdlist		atfree;
233 	struct atpdlist		atused[ATPDPHASHSIZE];
234 	atio_private_data_t	atpool[ATPDPSIZE];
235 #if defined(DEBUG)
236 	unsigned int inject_lost_data_frame;
237 #endif
238 #endif
239 	int			num_threads;
240 };
241 
242 struct isp_spi {
243 	struct cam_sim *sim;
244 	struct cam_path *path;
245 	uint32_t
246 		simqfrozen	: 3,
247 		iid		: 4;
248 #ifdef	ISP_TARGET_MODE
249 	struct tslist		lun_hash[LUN_HASH_SIZE];
250 	struct isp_ccbq		waitq;		/* waiting CCBs */
251 	struct ntpdlist		ntfree;
252 	inot_private_data_t	ntpool[ATPDPSIZE];
253 	struct atpdlist		atfree;
254 	struct atpdlist		atused[ATPDPHASHSIZE];
255 	atio_private_data_t	atpool[ATPDPSIZE];
256 #endif
257 	int			num_threads;
258 };
259 
260 struct isposinfo {
261 	/*
262 	 * Linkage, locking, and identity
263 	 */
264 	struct mtx		lock;
265 	device_t		dev;
266 	struct cdev *		cdev;
267 	struct cam_devq *	devq;
268 
269 	/*
270 	 * Firmware pointer
271 	 */
272 	const struct firmware *	fw;
273 
274 	/*
275 	 * DMA related stuff
276 	 */
277 	struct resource *	regs;
278 	struct resource *	regs2;
279 	bus_dma_tag_t		dmat;
280 	bus_dma_tag_t		reqdmat;
281 	bus_dma_tag_t		respdmat;
282 	bus_dma_tag_t		atiodmat;
283 	bus_dma_tag_t		iocbdmat;
284 	bus_dma_tag_t		scdmat;
285 	bus_dmamap_t		reqmap;
286 	bus_dmamap_t		respmap;
287 	bus_dmamap_t		atiomap;
288 	bus_dmamap_t		iocbmap;
289 
290 	/*
291 	 * Command and transaction related related stuff
292 	 */
293 	struct isp_pcmd *	pcmd_pool;
294 	struct isp_pcmd *	pcmd_free;
295 
296 	int			mbox_sleeping;
297 	int			mbox_sleep_ok;
298 	int			mboxbsy;
299 	int			mboxcmd_done;
300 
301 	struct callout		tmo;	/* general timer */
302 
303 	/*
304 	 * misc- needs to be sorted better XXXXXX
305 	 */
306 	int			framesize;
307 	int			exec_throttle;
308 	int			cont_max;
309 
310 	bus_addr_t		ecmd_dma;
311 	isp_ecmd_t *		ecmd_base;
312 	isp_ecmd_t *		ecmd_free;
313 
314 	/*
315 	 * Per-type private storage...
316 	 */
317 	union {
318 		struct isp_fc *fc;
319 		struct isp_spi *spi;
320 		void *ptr;
321 	} pc;
322 
323 	int			is_exiting;
324 };
325 #define	ISP_FC_PC(isp, chan)	(&(isp)->isp_osinfo.pc.fc[(chan)])
326 #define	ISP_SPI_PC(isp, chan)	(&(isp)->isp_osinfo.pc.spi[(chan)])
327 #define	ISP_GET_PC(isp, chan, tag, rslt)		\
328 	if (IS_SCSI(isp)) {				\
329 		rslt = ISP_SPI_PC(isp, chan)-> tag;	\
330 	} else {					\
331 		rslt = ISP_FC_PC(isp, chan)-> tag;	\
332 	}
333 #define	ISP_GET_PC_ADDR(isp, chan, tag, rp)		\
334 	if (IS_SCSI(isp)) {				\
335 		rp = &ISP_SPI_PC(isp, chan)-> tag;	\
336 	} else {					\
337 		rp = &ISP_FC_PC(isp, chan)-> tag;	\
338 	}
339 #define	ISP_SET_PC(isp, chan, tag, val)			\
340 	if (IS_SCSI(isp)) {				\
341 		ISP_SPI_PC(isp, chan)-> tag = val;	\
342 	} else {					\
343 		ISP_FC_PC(isp, chan)-> tag = val;	\
344 	}
345 
346 #define	FCP_NEXT_CRN	isp_fcp_next_crn
347 #define	isp_lock	isp_osinfo.lock
348 #define	isp_regs	isp_osinfo.regs
349 #define	isp_regs2	isp_osinfo.regs2
350 
351 /*
352  * Locking macros...
353  */
354 #define	ISP_LOCK(isp)	mtx_lock(&(isp)->isp_lock)
355 #define	ISP_UNLOCK(isp)	mtx_unlock(&(isp)->isp_lock)
356 #define	ISP_ASSERT_LOCKED(isp)	mtx_assert(&(isp)->isp_lock, MA_OWNED)
357 
358 /*
359  * Required Macros/Defines
360  */
361 #define	ISP_FC_SCRLEN		0x1000
362 
363 #define	ISP_MEMZERO(a, b)	memset(a, 0, b)
364 #define	ISP_MEMCPY		memcpy
365 #define	ISP_SNPRINTF		snprintf
366 #define	ISP_DELAY(x)		DELAY(x)
367 #define	ISP_SLEEP(isp, x)	msleep_sbt(&(isp)->isp_osinfo.is_exiting, \
368     &(isp)->isp_lock, 0, "isp_sleep", (x) * SBT_1US, 0, 0)
369 
370 #define	ISP_MIN			imin
371 
372 #ifndef	DIAGNOSTIC
373 #define	ISP_INLINE		__inline
374 #else
375 #define	ISP_INLINE
376 #endif
377 
378 #define	NANOTIME_T		struct timespec
379 #define	GET_NANOTIME		nanotime
380 #define	GET_NANOSEC(x)		((x)->tv_sec * 1000000000 + (x)->tv_nsec)
381 #define	NANOTIME_SUB		isp_nanotime_sub
382 
383 #define	MAXISPREQUEST(isp)	((IS_FC(isp) || IS_ULTRA2(isp))? 1024 : 256)
384 
385 #define	MEMORYBARRIER(isp, type, offset, size, chan)		\
386 switch (type) {							\
387 case SYNC_REQUEST:						\
388 	bus_dmamap_sync(isp->isp_osinfo.reqdmat,		\
389 	   isp->isp_osinfo.reqmap, BUS_DMASYNC_PREWRITE);	\
390 	break;							\
391 case SYNC_RESULT:						\
392 	bus_dmamap_sync(isp->isp_osinfo.respdmat, 		\
393 	   isp->isp_osinfo.respmap, BUS_DMASYNC_POSTREAD);	\
394 	break;							\
395 case SYNC_SFORDEV:						\
396 {								\
397 	struct isp_fc *fc = ISP_FC_PC(isp, chan);		\
398 	bus_dmamap_sync(isp->isp_osinfo.scdmat, fc->scmap,	\
399 	   BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);		\
400 	break;							\
401 }								\
402 case SYNC_SFORCPU:						\
403 {								\
404 	struct isp_fc *fc = ISP_FC_PC(isp, chan);		\
405 	bus_dmamap_sync(isp->isp_osinfo.scdmat, fc->scmap,	\
406 	   BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);	\
407 	break;							\
408 }								\
409 case SYNC_REG:							\
410 	bus_barrier(isp->isp_osinfo.regs, offset, size,		\
411 	    BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE);	\
412 	break;							\
413 case SYNC_ATIOQ:						\
414 	bus_dmamap_sync(isp->isp_osinfo.atiodmat, 		\
415 	   isp->isp_osinfo.atiomap, BUS_DMASYNC_POSTREAD);	\
416 	break;							\
417 case SYNC_IFORDEV:						\
418 	bus_dmamap_sync(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap, \
419 	   BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);		\
420 	break;							\
421 case SYNC_IFORCPU:						\
422 	bus_dmamap_sync(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap, \
423 	   BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);	\
424 	break;							\
425 default:							\
426 	break;							\
427 }
428 
429 #define	MEMORYBARRIERW(isp, type, offset, size, chan)		\
430 switch (type) {							\
431 case SYNC_REQUEST:						\
432 	bus_dmamap_sync(isp->isp_osinfo.reqdmat,		\
433 	   isp->isp_osinfo.reqmap, BUS_DMASYNC_PREWRITE);	\
434 	break;							\
435 case SYNC_SFORDEV:						\
436 {								\
437 	struct isp_fc *fc = ISP_FC_PC(isp, chan);		\
438 	bus_dmamap_sync(isp->isp_osinfo.scdmat, fc->scmap,	\
439 	   BUS_DMASYNC_PREWRITE);				\
440 	break;							\
441 }								\
442 case SYNC_SFORCPU:						\
443 {								\
444 	struct isp_fc *fc = ISP_FC_PC(isp, chan);		\
445 	bus_dmamap_sync(isp->isp_osinfo.scdmat, fc->scmap,	\
446 	   BUS_DMASYNC_POSTWRITE);				\
447 	break;							\
448 }								\
449 case SYNC_REG:							\
450 	bus_barrier(isp->isp_osinfo.regs, offset, size,		\
451 	    BUS_SPACE_BARRIER_WRITE);				\
452 	break;							\
453 case SYNC_IFORDEV:						\
454 	bus_dmamap_sync(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap, \
455 	   BUS_DMASYNC_PREWRITE);				\
456 	break;							\
457 case SYNC_IFORCPU:						\
458 	bus_dmamap_sync(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap, \
459 	   BUS_DMASYNC_POSTWRITE);				\
460 	break;							\
461 default:							\
462 	break;							\
463 }
464 
465 #define	MBOX_ACQUIRE			isp_mbox_acquire
466 #define	MBOX_WAIT_COMPLETE		isp_mbox_wait_complete
467 #define	MBOX_NOTIFY_COMPLETE		isp_mbox_notify_done
468 #define	MBOX_RELEASE			isp_mbox_release
469 
470 #define	FC_SCRATCH_ACQUIRE		isp_fc_scratch_acquire
471 #define	FC_SCRATCH_RELEASE(isp, chan)	isp->isp_osinfo.pc.fc[chan].fcbsy = 0
472 
473 #ifndef	SCSI_GOOD
474 #define	SCSI_GOOD	SCSI_STATUS_OK
475 #endif
476 #ifndef	SCSI_CHECK
477 #define	SCSI_CHECK	SCSI_STATUS_CHECK_COND
478 #endif
479 #ifndef	SCSI_BUSY
480 #define	SCSI_BUSY	SCSI_STATUS_BUSY
481 #endif
482 #ifndef	SCSI_QFULL
483 #define	SCSI_QFULL	SCSI_STATUS_QUEUE_FULL
484 #endif
485 
486 #define	XS_T			struct ccb_scsiio
487 #define	XS_DMA_ADDR_T		bus_addr_t
488 #define XS_GET_DMA64_SEG(a, b, c)		\
489 {						\
490 	ispds64_t *d = a;			\
491 	bus_dma_segment_t *e = b;		\
492 	uint32_t f = c;				\
493 	e += f;					\
494         d->ds_base = DMA_LO32(e->ds_addr);	\
495         d->ds_basehi = DMA_HI32(e->ds_addr);	\
496         d->ds_count = e->ds_len;		\
497 }
498 #define XS_GET_DMA_SEG(a, b, c)			\
499 {						\
500 	ispds_t *d = a;				\
501 	bus_dma_segment_t *e = b;		\
502 	uint32_t f = c;				\
503 	e += f;					\
504         d->ds_base = DMA_LO32(e->ds_addr);	\
505         d->ds_count = e->ds_len;		\
506 }
507 #if (BUS_SPACE_MAXADDR > UINT32_MAX)
508 #define XS_NEED_DMA64_SEG(s, n)					\
509 	(((bus_dma_segment_t *)s)[n].ds_addr +			\
510 	    ((bus_dma_segment_t *)s)[n].ds_len > UINT32_MAX)
511 #else
512 #define XS_NEED_DMA64_SEG(s, n)	(0)
513 #endif
514 #define	XS_ISP(ccb)		cam_sim_softc(xpt_path_sim((ccb)->ccb_h.path))
515 #define	XS_CHANNEL(ccb)		cam_sim_bus(xpt_path_sim((ccb)->ccb_h.path))
516 #define	XS_TGT(ccb)		(ccb)->ccb_h.target_id
517 #define	XS_LUN(ccb)		(ccb)->ccb_h.target_lun
518 
519 #define	XS_CDBP(ccb)	\
520 	(((ccb)->ccb_h.flags & CAM_CDB_POINTER)? \
521 	 (ccb)->cdb_io.cdb_ptr : (ccb)->cdb_io.cdb_bytes)
522 
523 #define	XS_CDBLEN(ccb)		(ccb)->cdb_len
524 #define	XS_XFRLEN(ccb)		(ccb)->dxfer_len
525 #define	XS_TIME(ccb)	\
526 	(((ccb)->ccb_h.timeout > 0xffff * 1000 - 999) ? 0 : \
527 	  (((ccb)->ccb_h.timeout + 999) / 1000))
528 #define	XS_GET_RESID(ccb)	(ccb)->resid
529 #define	XS_SET_RESID(ccb, r)	(ccb)->resid = r
530 #define	XS_STSP(ccb)		(&(ccb)->scsi_status)
531 #define	XS_SNSP(ccb)		(&(ccb)->sense_data)
532 
533 #define	XS_TOT_SNSLEN(ccb)	ccb->sense_len
534 #define	XS_CUR_SNSLEN(ccb)	(ccb->sense_len - ccb->sense_resid)
535 
536 #define	XS_SNSKEY(ccb)		(scsi_get_sense_key(&(ccb)->sense_data, \
537 				 ccb->sense_len - ccb->sense_resid, 1))
538 
539 #define	XS_SNSASC(ccb)		(scsi_get_asc(&(ccb)->sense_data,	\
540 				 ccb->sense_len - ccb->sense_resid, 1))
541 
542 #define	XS_SNSASCQ(ccb)		(scsi_get_ascq(&(ccb)->sense_data,	\
543 				 ccb->sense_len - ccb->sense_resid, 1))
544 #define	XS_TAG_P(ccb)	\
545 	(((ccb)->ccb_h.flags & CAM_TAG_ACTION_VALID) && \
546 	 (ccb)->tag_action != CAM_TAG_ACTION_NONE)
547 
548 #define	XS_TAG_TYPE(ccb)	\
549 	((ccb->tag_action == MSG_SIMPLE_Q_TAG)? REQFLAG_STAG : \
550 	 ((ccb->tag_action == MSG_HEAD_OF_Q_TAG)? REQFLAG_HTAG : REQFLAG_OTAG))
551 
552 
553 #define	XS_SETERR(ccb, v)	(ccb)->ccb_h.status &= ~CAM_STATUS_MASK, \
554 				(ccb)->ccb_h.status |= v
555 
556 #	define	HBA_NOERROR		CAM_REQ_INPROG
557 #	define	HBA_BOTCH		CAM_UNREC_HBA_ERROR
558 #	define	HBA_CMDTIMEOUT		CAM_CMD_TIMEOUT
559 #	define	HBA_SELTIMEOUT		CAM_SEL_TIMEOUT
560 #	define	HBA_TGTBSY		CAM_SCSI_STATUS_ERROR
561 #	define	HBA_REQINVAL		CAM_REQ_INVALID
562 #	define	HBA_BUSRESET		CAM_SCSI_BUS_RESET
563 #	define	HBA_ABORTED		CAM_REQ_ABORTED
564 #	define	HBA_DATAOVR		CAM_DATA_RUN_ERR
565 #	define	HBA_ARQFAIL		CAM_AUTOSENSE_FAIL
566 
567 
568 #define	XS_ERR(ccb)		((ccb)->ccb_h.status & CAM_STATUS_MASK)
569 
570 #define	XS_NOERR(ccb)		(((ccb)->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG)
571 
572 #define	XS_INITERR(ccb)		XS_SETERR(ccb, CAM_REQ_INPROG), ccb->sense_resid = ccb->sense_len
573 
574 #define	XS_SAVE_SENSE(xs, sp, len)	do {				\
575 		uint32_t amt = min(len, (xs)->sense_len);		\
576 		memcpy(&(xs)->sense_data, sp, amt);			\
577 		(xs)->sense_resid = (xs)->sense_len - amt;		\
578 		(xs)->ccb_h.status |= CAM_AUTOSNS_VALID;		\
579 	} while (0)
580 
581 #define	XS_SENSE_APPEND(xs, sp, len)	do {				\
582 		uint8_t *ptr = (uint8_t *)(&(xs)->sense_data) +		\
583 		    ((xs)->sense_len - (xs)->sense_resid);		\
584 		uint32_t amt = min((len), (xs)->sense_resid);		\
585 		memcpy(ptr, sp, amt);					\
586 		(xs)->sense_resid -= amt;				\
587 	} while (0)
588 
589 #define	XS_SENSE_VALID(xs)	(((xs)->ccb_h.status & CAM_AUTOSNS_VALID) != 0)
590 
591 #define	DEFAULT_FRAMESIZE(isp)		isp->isp_osinfo.framesize
592 #define	DEFAULT_EXEC_THROTTLE(isp)	isp->isp_osinfo.exec_throttle
593 
594 #define	DEFAULT_ROLE(isp, chan)	\
595 	(IS_FC(isp)? ISP_FC_PC(isp, chan)->def_role : ISP_ROLE_INITIATOR)
596 
597 #define	DEFAULT_IID(isp, chan)		isp->isp_osinfo.pc.spi[chan].iid
598 
599 #define	DEFAULT_LOOPID(x, chan)		isp->isp_osinfo.pc.fc[chan].default_id
600 
601 #define DEFAULT_NODEWWN(isp, chan)  	isp_default_wwn(isp, chan, 0, 1)
602 #define DEFAULT_PORTWWN(isp, chan)  	isp_default_wwn(isp, chan, 0, 0)
603 #define ACTIVE_NODEWWN(isp, chan)   	isp_default_wwn(isp, chan, 1, 1)
604 #define ACTIVE_PORTWWN(isp, chan)   	isp_default_wwn(isp, chan, 1, 0)
605 
606 
607 #if	BYTE_ORDER == BIG_ENDIAN
608 #ifdef	ISP_SBUS_SUPPORTED
609 #define	ISP_IOXPUT_8(isp, s, d)		*(d) = s
610 #define	ISP_IOXPUT_16(isp, s, d)				\
611 	*(d) = (isp->isp_bustype == ISP_BT_SBUS)? s : bswap16(s)
612 #define	ISP_IOXPUT_32(isp, s, d)				\
613 	*(d) = (isp->isp_bustype == ISP_BT_SBUS)? s : bswap32(s)
614 #define	ISP_IOXGET_8(isp, s, d)		d = (*((uint8_t *)s))
615 #define	ISP_IOXGET_16(isp, s, d)				\
616 	d = (isp->isp_bustype == ISP_BT_SBUS)?			\
617 	*((uint16_t *)s) : bswap16(*((uint16_t *)s))
618 #define	ISP_IOXGET_32(isp, s, d)				\
619 	d = (isp->isp_bustype == ISP_BT_SBUS)?			\
620 	*((uint32_t *)s) : bswap32(*((uint32_t *)s))
621 
622 #else	/* ISP_SBUS_SUPPORTED */
623 #define	ISP_IOXPUT_8(isp, s, d)		*(d) = s
624 #define	ISP_IOXPUT_16(isp, s, d)	*(d) = bswap16(s)
625 #define	ISP_IOXPUT_32(isp, s, d)	*(d) = bswap32(s)
626 #define	ISP_IOXGET_8(isp, s, d)		d = (*((uint8_t *)s))
627 #define	ISP_IOXGET_16(isp, s, d)	d = bswap16(*((uint16_t *)s))
628 #define	ISP_IOXGET_32(isp, s, d)	d = bswap32(*((uint32_t *)s))
629 #endif
630 #define	ISP_SWIZZLE_NVRAM_WORD(isp, rp)	*rp = bswap16(*rp)
631 #define	ISP_SWIZZLE_NVRAM_LONG(isp, rp)	*rp = bswap32(*rp)
632 
633 #define	ISP_IOZGET_8(isp, s, d)		d = (*((uint8_t *)s))
634 #define	ISP_IOZGET_16(isp, s, d)	d = (*((uint16_t *)s))
635 #define	ISP_IOZGET_32(isp, s, d)	d = (*((uint32_t *)s))
636 #define	ISP_IOZPUT_8(isp, s, d)		*(d) = s
637 #define	ISP_IOZPUT_16(isp, s, d)	*(d) = s
638 #define	ISP_IOZPUT_32(isp, s, d)	*(d) = s
639 
640 
641 #else
642 #define	ISP_IOXPUT_8(isp, s, d)		*(d) = s
643 #define	ISP_IOXPUT_16(isp, s, d)	*(d) = s
644 #define	ISP_IOXPUT_32(isp, s, d)	*(d) = s
645 #define	ISP_IOXGET_8(isp, s, d)		d = *(s)
646 #define	ISP_IOXGET_16(isp, s, d)	d = *(s)
647 #define	ISP_IOXGET_32(isp, s, d)	d = *(s)
648 #define	ISP_SWIZZLE_NVRAM_WORD(isp, rp)
649 #define	ISP_SWIZZLE_NVRAM_LONG(isp, rp)
650 
651 #define	ISP_IOZPUT_8(isp, s, d)		*(d) = s
652 #define	ISP_IOZPUT_16(isp, s, d)	*(d) = bswap16(s)
653 #define	ISP_IOZPUT_32(isp, s, d)	*(d) = bswap32(s)
654 
655 #define	ISP_IOZGET_8(isp, s, d)		d = (*((uint8_t *)(s)))
656 #define	ISP_IOZGET_16(isp, s, d)	d = bswap16(*((uint16_t *)(s)))
657 #define	ISP_IOZGET_32(isp, s, d)	d = bswap32(*((uint32_t *)(s)))
658 
659 #endif
660 
661 #define	ISP_SWAP16(isp, s)	bswap16(s)
662 #define	ISP_SWAP32(isp, s)	bswap32(s)
663 
664 /*
665  * Includes of common header files
666  */
667 
668 #include <dev/isp/ispreg.h>
669 #include <dev/isp/ispvar.h>
670 #include <dev/isp/ispmbox.h>
671 
672 /*
673  * isp_osinfo definiitions && shorthand
674  */
675 #define	SIMQFRZ_RESOURCE	0x1
676 #define	SIMQFRZ_LOOPDOWN	0x2
677 #define	SIMQFRZ_TIMED		0x4
678 
679 #define	isp_dev		isp_osinfo.dev
680 
681 /*
682  * prototypes for isp_pci && isp_freebsd to share
683  */
684 extern int isp_attach(ispsoftc_t *);
685 extern int isp_detach(ispsoftc_t *);
686 extern uint64_t isp_default_wwn(ispsoftc_t *, int, int, int);
687 
688 /*
689  * driver global data
690  */
691 extern int isp_announced;
692 extern int isp_loop_down_limit;
693 extern int isp_gone_device_time;
694 extern int isp_quickboot_time;
695 
696 /*
697  * Platform private flags
698  */
699 
700 /*
701  * Platform Library Functions
702  */
703 void isp_prt(ispsoftc_t *, int level, const char *, ...) __printflike(3, 4);
704 void isp_xs_prt(ispsoftc_t *, XS_T *, int level, const char *, ...) __printflike(4, 5);
705 uint64_t isp_nanotime_sub(struct timespec *, struct timespec *);
706 int isp_mbox_acquire(ispsoftc_t *);
707 void isp_mbox_wait_complete(ispsoftc_t *, mbreg_t *);
708 void isp_mbox_notify_done(ispsoftc_t *);
709 void isp_mbox_release(ispsoftc_t *);
710 int isp_fc_scratch_acquire(ispsoftc_t *, int);
711 void isp_platform_intr(void *);
712 void isp_platform_intr_resp(void *);
713 void isp_platform_intr_atio(void *);
714 void isp_common_dmateardown(ispsoftc_t *, struct ccb_scsiio *, uint32_t);
715 void isp_fcp_reset_crn(ispsoftc_t *, int, uint32_t, int);
716 int isp_fcp_next_crn(ispsoftc_t *, uint8_t *, XS_T *);
717 
718 /*
719  * Platform Version specific defines
720  */
721 #define	ISP_PATH_PRT(i, l, p, ...)					\
722 	if ((l) == ISP_LOGALL || ((l)& (i)->isp_dblev) != 0) {		\
723                 xpt_print(p, __VA_ARGS__);				\
724         }
725 
726 /*
727  * Platform specific inline functions
728  */
729 
730 /*
731  * ISP General Library functions
732  */
733 
734 #include <dev/isp/isp_library.h>
735 
736 #endif	/* _ISP_FREEBSD_H */
737