xref: /freebsd/sys/dev/isp/ispvar.h (revision 32100375a661c1e16588ddfa7b90ca8d26cb9786)
1 /* $FreeBSD$ */
2 /*-
3  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4  *
5  *  Copyright (c) 2009-2018 Alexander Motin <mav@FreeBSD.org>
6  *  Copyright (c) 1997-2009 by Matthew Jacob
7  *  All rights reserved.
8  *
9  *  Redistribution and use in source and binary forms, with or without
10  *  modification, are permitted provided that the following conditions
11  *  are met:
12  *
13  *  1. Redistributions of source code must retain the above copyright
14  *     notice, this list of conditions and the following disclaimer.
15  *  2. Redistributions in binary form must reproduce the above copyright
16  *     notice, this list of conditions and the following disclaimer in the
17  *     documentation and/or other materials provided with the distribution.
18  *
19  *  THIS SOFTWARE IS PROVIDED BY 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 AUTHOR OR CONTRIBUTORS BE LIABLE
23  *  FOR 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 /*
33  * Soft Definitions for for Qlogic ISP SCSI adapters.
34  */
35 
36 #ifndef	_ISPVAR_H
37 #define	_ISPVAR_H
38 
39 #if defined(__NetBSD__) || defined(__OpenBSD__)
40 #include <dev/ic/isp_stds.h>
41 #include <dev/ic/ispmbox.h>
42 #endif
43 #ifdef	__FreeBSD__
44 #include <dev/isp/isp_stds.h>
45 #include <dev/isp/ispmbox.h>
46 #endif
47 #ifdef	__linux__
48 #include "isp_stds.h"
49 #include "ispmbox.h"
50 #endif
51 #ifdef	__svr4__
52 #include "isp_stds.h"
53 #include "ispmbox.h"
54 #endif
55 
56 #define	ISP_CORE_VERSION_MAJOR	7
57 #define	ISP_CORE_VERSION_MINOR	0
58 
59 /*
60  * Vector for bus specific code to provide specific services.
61  */
62 typedef struct ispsoftc ispsoftc_t;
63 struct ispmdvec {
64 	void		(*dv_run_isr) (ispsoftc_t *);
65 	uint32_t	(*dv_rd_reg) (ispsoftc_t *, int);
66 	void		(*dv_wr_reg) (ispsoftc_t *, int, uint32_t);
67 	int		(*dv_mbxdma) (ispsoftc_t *);
68 	int		(*dv_dmaset) (ispsoftc_t *, XS_T *, void *);
69 	void		(*dv_dmaclr) (ispsoftc_t *, XS_T *, uint32_t);
70 	int		(*dv_irqsetup) (ispsoftc_t *);
71 	void		(*dv_dregs) (ispsoftc_t *, const char *);
72 	const void *	dv_ispfw;	/* ptr to f/w */
73 	uint16_t	dv_conf1;
74 	uint16_t	dv_clock;	/* clock frequency */
75 };
76 
77 /*
78  * Overall parameters
79  */
80 #define	MAX_TARGETS		16
81 #ifndef	MAX_FC_TARG
82 #define	MAX_FC_TARG		1024
83 #endif
84 #define	ISP_MAX_TARGETS(isp)	(IS_FC(isp)? MAX_FC_TARG : MAX_TARGETS)
85 #define	ISP_MAX_LUNS(isp)	(isp)->isp_maxluns
86 #define	ISP_MAX_IRQS		3
87 
88 /*
89  * Macros to access ISP registers through bus specific layers-
90  * mostly wrappers to vector through the mdvec structure.
91  */
92 #define	ISP_RUN_ISR(isp)	\
93 	(*(isp)->isp_mdvec->dv_run_isr)(isp)
94 
95 #define	ISP_READ(isp, reg)	\
96 	(*(isp)->isp_mdvec->dv_rd_reg)((isp), (reg))
97 
98 #define	ISP_WRITE(isp, reg, val)	\
99 	(*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), (val))
100 
101 #define	ISP_MBOXDMASETUP(isp)	\
102 	(*(isp)->isp_mdvec->dv_mbxdma)((isp))
103 
104 #define	ISP_DMASETUP(isp, xs, req)	\
105 	(*(isp)->isp_mdvec->dv_dmaset)((isp), (xs), (req))
106 
107 #define	ISP_DMAFREE(isp, xs, hndl)		\
108 	if ((isp)->isp_mdvec->dv_dmaclr)	\
109 	    (*(isp)->isp_mdvec->dv_dmaclr)((isp), (xs), (hndl))
110 
111 #define	ISP_IRQSETUP(isp)	\
112 	(((isp)->isp_mdvec->dv_irqsetup) ? (*(isp)->isp_mdvec->dv_irqsetup)(isp) : 0)
113 #define	ISP_DUMPREGS(isp, m)	\
114 	if ((isp)->isp_mdvec->dv_dregs) (*(isp)->isp_mdvec->dv_dregs)((isp),(m))
115 
116 #define	ISP_SETBITS(isp, reg, val)	\
117  (*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), ISP_READ((isp), (reg)) | (val))
118 
119 #define	ISP_CLRBITS(isp, reg, val)	\
120  (*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), ISP_READ((isp), (reg)) & ~(val))
121 
122 /*
123  * The MEMORYBARRIER macro is defined per platform (to provide synchronization
124  * on Request and Response Queues, Scratch DMA areas, and Registers)
125  *
126  * Defined Memory Barrier Synchronization Types
127  */
128 #define	SYNC_REQUEST	0	/* request queue synchronization */
129 #define	SYNC_RESULT	1	/* result queue synchronization */
130 #define	SYNC_SFORDEV	2	/* scratch, sync for ISP */
131 #define	SYNC_SFORCPU	3	/* scratch, sync for CPU */
132 #define	SYNC_REG	4	/* for registers */
133 #define	SYNC_ATIOQ	5	/* atio result queue (24xx) */
134 #define	SYNC_IFORDEV	6	/* synchrounous IOCB, sync for ISP */
135 #define	SYNC_IFORCPU	7	/* synchrounous IOCB, sync for CPU */
136 
137 /*
138  * Request/Response Queue defines and macros.
139  * The maximum is defined per platform (and can be based on board type).
140  */
141 /* This is the size of a queue entry (request and response) */
142 #define	QENTRY_LEN			64
143 /* Both request and result queue length must be a power of two */
144 #define	RQUEST_QUEUE_LEN(x)		MAXISPREQUEST(x)
145 #ifdef	ISP_TARGET_MODE
146 #define	RESULT_QUEUE_LEN(x)		MAXISPREQUEST(x)
147 #else
148 #define	RESULT_QUEUE_LEN(x)		\
149 	(((MAXISPREQUEST(x) >> 2) < 64)? 64 : MAXISPREQUEST(x) >> 2)
150 #endif
151 #define	ISP_QUEUE_ENTRY(q, idx)		(((uint8_t *)q) + ((idx) * QENTRY_LEN))
152 #define	ISP_QUEUE_SIZE(n)		((n) * QENTRY_LEN)
153 #define	ISP_NXT_QENTRY(idx, qlen)	(((idx) + 1) & ((qlen)-1))
154 #define	ISP_QFREE(in, out, qlen)	\
155 	((in == out)? (qlen - 1) : ((in > out)? \
156 	((qlen - 1) - (in - out)) : (out - in - 1)))
157 #define	ISP_QAVAIL(isp)	\
158 	ISP_QFREE(isp->isp_reqidx, isp->isp_reqodx, RQUEST_QUEUE_LEN(isp))
159 
160 #define	ISP_ADD_REQUEST(isp, nxti)						\
161 	MEMORYBARRIER(isp, SYNC_REQUEST, isp->isp_reqidx, QENTRY_LEN, -1);	\
162 	ISP_WRITE(isp, isp->isp_rqstinrp, nxti);				\
163 	isp->isp_reqidx = nxti
164 
165 #define	ISP_SYNC_REQUEST(isp)								\
166 	MEMORYBARRIER(isp, SYNC_REQUEST, isp->isp_reqidx, QENTRY_LEN, -1);		\
167 	isp->isp_reqidx = ISP_NXT_QENTRY(isp->isp_reqidx, RQUEST_QUEUE_LEN(isp));	\
168 	ISP_WRITE(isp, isp->isp_rqstinrp, isp->isp_reqidx)
169 
170 /*
171  * SCSI Specific Host Adapter Parameters- per bus, per target
172  */
173 typedef struct {
174 	uint32_t 				: 8,
175 			update			: 1,
176 			sendmarker		: 1,
177 			isp_req_ack_active_neg	: 1,
178 			isp_data_line_active_neg: 1,
179 			isp_cmd_dma_burst_enable: 1,
180 			isp_data_dma_burst_enabl: 1,
181 			isp_fifo_threshold	: 3,
182 			isp_ptisp		: 1,
183 			isp_ultramode		: 1,
184 			isp_diffmode		: 1,
185 			isp_lvdmode		: 1,
186 			isp_fast_mttr		: 1,	/* fast sram */
187 			isp_initiator_id	: 4,
188 			isp_async_data_setup	: 4;
189 	uint16_t	isp_selection_timeout;
190 	uint16_t	isp_max_queue_depth;
191 	uint8_t		isp_tag_aging;
192 	uint8_t		isp_bus_reset_delay;
193 	uint8_t		isp_retry_count;
194 	uint8_t		isp_retry_delay;
195 	struct {
196 		uint32_t
197 			exc_throttle	:	8,
198 					:	1,
199 			dev_enable	:	1,	/* ignored */
200 			dev_update	:	1,
201 			dev_refresh	:	1,
202 			actv_offset	:	4,
203 			goal_offset	:	4,
204 			nvrm_offset	:	4;
205 		uint8_t		actv_period;	/* current sync period */
206 		uint8_t		goal_period;	/* goal sync period */
207 		uint8_t		nvrm_period;	/* nvram sync period */
208 		uint16_t	actv_flags;	/* current device flags */
209 		uint16_t	goal_flags;	/* goal device flags */
210 		uint16_t	nvrm_flags;	/* nvram device flags */
211 	} isp_devparam[MAX_TARGETS];
212 } sdparam;
213 
214 /*
215  * Device Flags
216  */
217 #define	DPARM_DISC	0x8000
218 #define	DPARM_PARITY	0x4000
219 #define	DPARM_WIDE	0x2000
220 #define	DPARM_SYNC	0x1000
221 #define	DPARM_TQING	0x0800
222 #define	DPARM_ARQ	0x0400
223 #define	DPARM_QFRZ	0x0200
224 #define	DPARM_RENEG	0x0100
225 #define	DPARM_NARROW	0x0080
226 #define	DPARM_ASYNC	0x0040
227 #define	DPARM_PPR	0x0020
228 #define	DPARM_DEFAULT	(0xFF00 & ~DPARM_QFRZ)
229 #define	DPARM_SAFE_DFLT	(DPARM_DEFAULT & ~(DPARM_WIDE|DPARM_SYNC|DPARM_TQING))
230 
231 /* technically, not really correct, as they need to be rated based upon clock */
232 #define	ISP_80M_SYNCPARMS	0x0c09
233 #define	ISP_40M_SYNCPARMS	0x0c0a
234 #define	ISP_20M_SYNCPARMS	0x0c0c
235 #define	ISP_20M_SYNCPARMS_1040	0x080c
236 #define	ISP_10M_SYNCPARMS	0x0c19
237 #define	ISP_08M_SYNCPARMS	0x0c25
238 #define	ISP_05M_SYNCPARMS	0x0c32
239 #define	ISP_04M_SYNCPARMS	0x0c41
240 
241 /*
242  * Fibre Channel Specifics
243  */
244 /* These are for non-2K Login Firmware cards */
245 #define	FL_ID			0x7e	/* FL_Port Special ID */
246 #define	SNS_ID			0x80	/* SNS Server Special ID */
247 #define	NPH_MAX			0xfe
248 
249 /* These are for 2K Login Firmware cards */
250 #define	NPH_RESERVED		0x7F0	/* begin of reserved N-port handles */
251 #define	NPH_MGT_ID		0x7FA	/* Management Server Special ID */
252 #define	NPH_SNS_ID		0x7FC	/* SNS Server Special ID */
253 #define	NPH_FABRIC_CTLR		0x7FD	/* Fabric Controller (0xFFFFFD) */
254 #define	NPH_FL_ID		0x7FE	/* F Port Special ID (0xFFFFFE) */
255 #define	NPH_IP_BCST		0x7FF	/* IP Broadcast Special ID (0xFFFFFF) */
256 #define	NPH_MAX_2K		0x800
257 
258 /*
259  * "Unassigned" handle to be used internally
260  */
261 #define	NIL_HANDLE		0xffff
262 
263 /*
264  * Limit for devices on an arbitrated loop.
265  */
266 #define	LOCAL_LOOP_LIM		126
267 
268 /*
269  * Limit for (2K login) N-port handle amounts
270  */
271 #define	MAX_NPORT_HANDLE	2048
272 
273 /*
274  * Special Constants
275  */
276 #define	INI_NONE    		((uint64_t) 0)
277 #define	ISP_NOCHAN		0xff
278 
279 /*
280  * Special Port IDs
281  */
282 #define	MANAGEMENT_PORT_ID	0xFFFFFA
283 #define	SNS_PORT_ID		0xFFFFFC
284 #define	FABRIC_PORT_ID		0xFFFFFE
285 #define	PORT_ANY		0xFFFFFF
286 #define	PORT_NONE		0
287 #define	VALID_PORT(port)	(port != PORT_NONE && port != PORT_ANY)
288 #define	DOMAIN_CONTROLLER_BASE	0xFFFC00
289 #define	DOMAIN_CONTROLLER_END	0xFFFCFF
290 
291 /*
292  * Command Handles
293  *
294  * Most QLogic initiator or target have 32 bit handles associated with them.
295  * We want to have a quick way to index back and forth between a local SCSI
296  * command context and what the firmware is passing back to us. We also
297  * want to avoid working on stale information. This structure handles both
298  * at the expense of some local memory.
299  *
300  * The handle is architected thusly:
301  *
302  *	0 means "free handle"
303  *	bits  0..12 index commands
304  *	bits 13..15 bits index usage
305  *	bits 16..31 contain a rolling sequence
306  *
307  *
308  */
309 typedef struct {
310 	void *		cmd;	/* associated command context */
311 	uint32_t	handle;	/* handle associated with this command */
312 } isp_hdl_t;
313 #define	ISP_HANDLE_FREE		0x00000000
314 #define	ISP_HANDLE_CMD_MASK	0x00001fff
315 #define	ISP_HANDLE_USAGE_MASK	0x0000e000
316 #define	ISP_HANDLE_USAGE_SHIFT	13
317 #define	ISP_H2HT(hdl)	((hdl & ISP_HANDLE_USAGE_MASK) >> ISP_HANDLE_USAGE_SHIFT)
318 #	define	ISP_HANDLE_NONE		0
319 #	define	ISP_HANDLE_INITIATOR	1
320 #	define	ISP_HANDLE_TARGET	2
321 #	define	ISP_HANDLE_CTRL		3
322 #define	ISP_HANDLE_SEQ_MASK	0xffff0000
323 #define	ISP_HANDLE_SEQ_SHIFT	16
324 #define	ISP_H2SEQ(hdl)	((hdl & ISP_HANDLE_SEQ_MASK) >> ISP_HANDLE_SEQ_SHIFT)
325 #define	ISP_VALID_HANDLE(c, hdl)	\
326 	((ISP_H2HT(hdl) == ISP_HANDLE_INITIATOR || \
327 	  ISP_H2HT(hdl) == ISP_HANDLE_TARGET || \
328 	  ISP_H2HT(hdl) == ISP_HANDLE_CTRL) && \
329 	 ((hdl) & ISP_HANDLE_CMD_MASK) < (c)->isp_maxcmds && \
330 	 (hdl) == ((c)->isp_xflist[(hdl) & ISP_HANDLE_CMD_MASK].handle))
331 #define	ISP_BAD_HANDLE_INDEX	0xffffffff
332 
333 
334 /*
335  * FC Port Database entry.
336  *
337  * It has a handle that the f/w uses to address commands to a device.
338  * This handle's value may be assigned by the firmware (e.g., for local loop
339  * devices) or by the driver (e.g., for fabric devices).
340  *
341  * It has a state. If the state if VALID, that means that we've logged into
342  * the device.
343  *
344  * Local loop devices the firmware automatically performs PLOGI on for us
345  * (which is why that handle is imposed upon us). Fabric devices we assign
346  * a handle to and perform the PLOGI on.
347  *
348  * When a PORT DATABASE CHANGED asynchronous event occurs, we mark all VALID
349  * entries as PROBATIONAL. This allows us, if policy says to, just keep track
350  * of devices whose handles change but are otherwise the same device (and
351  * thus keep 'target' constant).
352  *
353  * In any case, we search all possible local loop handles. For each one that
354  * has a port database entity returned, we search for any PROBATIONAL entry
355  * that matches it and update as appropriate. Otherwise, as a new entry, we
356  * find room for it in the Port Database. We *try* and use the handle as the
357  * index to put it into the Database, but that's just an optimization. We mark
358  * the entry VALID and make sure that the target index is updated and correct.
359  *
360  * When we get done searching the local loop, we then search similarly for
361  * a list of devices we've gotten from the fabric name controller (if we're
362  * on a fabric). VALID marking is also done similarly.
363  *
364  * When all of this is done, we can march through the database and clean up
365  * any entry that is still PROBATIONAL (these represent devices which have
366  * departed). Then we're done and can resume normal operations.
367  *
368  * Negative invariants that we try and test for are:
369  *
370  *  + There can never be two non-NIL entries with the same { Port, Node } WWN
371  *    duples.
372  *
373  *  + There can never be two non-NIL entries with the same handle.
374  */
375 typedef struct {
376 	/*
377 	 * This is the handle that the firmware needs in order for us to
378 	 * send commands to the device. For pre-24XX cards, this would be
379 	 * the 'loopid'.
380 	 */
381 	uint16_t	handle;
382 
383 	/*
384 	 * PRLI word 0 contains the Establish Image Pair bit, which is
385 	 * important for knowing when to reset the CRN.
386 	 *
387 	 * PRLI word 3 parameters contains role as well as other things.
388 	 *
389 	 * The state is the current state of this entry.
390 	 *
391 	 * The is_target is the current state of target on this port.
392 	 *
393 	 * The is_initiator is the current state of initiator on this port.
394 	 *
395 	 * Portid is obvious, as are node && port WWNs. The new_role and
396 	 * new_portid is for when we are pending a change.
397 	 */
398 	uint16_t	prli_word0;		/* PRLI parameters */
399 	uint16_t	prli_word3;		/* PRLI parameters */
400 	uint16_t	new_prli_word0;		/* Incoming new PRLI parameters */
401 	uint16_t	new_prli_word3;		/* Incoming new PRLI parameters */
402 	uint16_t			: 12,
403 			probational	: 1,
404 			state		: 3;
405 	uint32_t			: 6,
406 			is_target	: 1,
407 			is_initiator	: 1,
408 			portid		: 24;
409 	uint32_t
410 					: 8,
411 			new_portid	: 24;
412 	uint64_t	node_wwn;
413 	uint64_t	port_wwn;
414 	uint32_t	gone_timer;
415 } fcportdb_t;
416 
417 #define	FC_PORTDB_STATE_NIL		0	/* Empty DB slot */
418 #define	FC_PORTDB_STATE_DEAD		1	/* Was valid, but no more. */
419 #define	FC_PORTDB_STATE_CHANGED		2	/* Was valid, but changed. */
420 #define	FC_PORTDB_STATE_NEW		3	/* Logged in, not announced. */
421 #define	FC_PORTDB_STATE_ZOMBIE		4	/* Invalid, but announced. */
422 #define	FC_PORTDB_STATE_VALID		5	/* Valid */
423 
424 #define	FC_PORTDB_TGT(isp, bus, pdb)		(int)(lp - FCPARAM(isp, bus)->portdb)
425 
426 /*
427  * FC card specific information
428  *
429  * This structure is replicated across multiple channels for multi-id
430  * capapble chipsets, with some entities different on a per-channel basis.
431  */
432 
433 typedef struct {
434 	int			isp_gbspeed;		/* Connection speed */
435 	int			isp_linkstate;		/* Link state */
436 	int			isp_fwstate;		/* ISP F/W state */
437 	int			isp_loopstate;		/* Loop State */
438 	int			isp_topo;		/* Connection Type */
439 
440 	uint32_t				: 4,
441 				fctape_enabled	: 1,
442 				sendmarker	: 1,
443 				role		: 2,
444 				isp_portid	: 24;	/* S_ID */
445 
446 	uint16_t		isp_fwoptions;
447 	uint16_t		isp_xfwoptions;
448 	uint16_t		isp_zfwoptions;
449 	uint16_t		isp_loopid;		/* hard loop id */
450 	uint16_t		isp_sns_hdl;		/* N-port handle for SNS */
451 	uint16_t		isp_lasthdl;		/* only valid for channel 0 */
452 	uint16_t		isp_maxalloc;
453 	uint16_t		isp_fabric_params;
454 	uint16_t		isp_login_hdl;		/* Logging in handle */
455 	uint8_t			isp_retry_delay;
456 	uint8_t			isp_retry_count;
457 	int			isp_use_gft_id;		/* Use GFT_ID */
458 	int			isp_use_gff_id;		/* Use GFF_ID */
459 
460 	/*
461 	 * Current active WWNN/WWPN
462 	 */
463 	uint64_t		isp_wwnn;
464 	uint64_t		isp_wwpn;
465 
466 	/*
467 	 * NVRAM WWNN/WWPN
468 	 */
469 	uint64_t		isp_wwnn_nvram;
470 	uint64_t		isp_wwpn_nvram;
471 
472 	/*
473 	 * Our Port Data Base
474 	 */
475 	fcportdb_t		portdb[MAX_FC_TARG];
476 
477 	/*
478 	 * Scratch DMA mapped in area to fetch Port Database stuff, etc.
479 	 */
480 	void *			isp_scratch;
481 	XS_DMA_ADDR_T		isp_scdma;
482 
483 	uint8_t			isp_scanscratch[ISP_FC_SCRLEN];
484 } fcparam;
485 
486 #define	FW_CONFIG_WAIT		0
487 #define	FW_WAIT_LINK		1
488 #define	FW_WAIT_LOGIN		2
489 #define	FW_READY		3
490 #define	FW_LOSS_OF_SYNC		4
491 #define	FW_ERROR		5
492 #define	FW_REINIT		6
493 #define	FW_NON_PART		7
494 
495 #define	LOOP_NIL		0
496 #define	LOOP_HAVE_LINK		1
497 #define	LOOP_HAVE_ADDR		2
498 #define	LOOP_TESTING_LINK	3
499 #define	LOOP_LTEST_DONE		4
500 #define	LOOP_SCANNING_LOOP	5
501 #define	LOOP_LSCAN_DONE		6
502 #define	LOOP_SCANNING_FABRIC	7
503 #define	LOOP_FSCAN_DONE		8
504 #define	LOOP_SYNCING_PDB	9
505 #define	LOOP_READY		10
506 
507 #define	TOPO_NL_PORT		0
508 #define	TOPO_FL_PORT		1
509 #define	TOPO_N_PORT		2
510 #define	TOPO_F_PORT		3
511 #define	TOPO_PTP_STUB		4
512 
513 #define TOPO_IS_FABRIC(x)	((x) == TOPO_FL_PORT || (x) == TOPO_F_PORT)
514 
515 #define FCP_AL_DA_ALL		0xFF
516 #define FCP_AL_PA(fcp) ((uint8_t)(fcp->isp_portid))
517 #define FCP_IS_DEST_ALPD(fcp, alpd) (FCP_AL_PA((fcp)) == FCP_AL_DA_ALL || FCP_AL_PA((fcp)) == alpd)
518 
519 /*
520  * Soft Structure per host adapter
521  */
522 struct ispsoftc {
523 	/*
524 	 * Platform (OS) specific data
525 	 */
526 	struct isposinfo	isp_osinfo;
527 
528 	/*
529 	 * Pointer to bus specific functions and data
530 	 */
531 	struct ispmdvec *	isp_mdvec;
532 
533 	/*
534 	 * (Mostly) nonvolatile state. Board specific parameters
535 	 * may contain some volatile state (e.g., current loop state).
536 	 */
537 
538 	void * 			isp_param;	/* type specific */
539 	uint64_t		isp_fwattr;	/* firmware attributes */
540 	uint16_t		isp_fwrev[3];	/* Loaded F/W revision */
541 	uint16_t		isp_maxcmds;	/* max possible I/O cmds */
542 	uint8_t			isp_type;	/* HBA Chip Type */
543 	uint8_t			isp_revision;	/* HBA Chip H/W Revision */
544 	uint8_t			isp_nirq;	/* number of IRQs */
545 	uint16_t		isp_nchan;	/* number of channels */
546 	uint32_t		isp_maxluns;	/* maximum luns supported */
547 
548 	uint32_t		isp_clock	: 8,	/* input clock */
549 						: 5,
550 				isp_port	: 1,	/* 23XX/24XX only */
551 				isp_bustype	: 1,	/* SBus or PCI */
552 				isp_loaded_fw	: 1,	/* loaded firmware */
553 				isp_dblev	: 16;	/* debug log mask */
554 
555 
556 	uint32_t		isp_confopts;	/* config options */
557 
558 	uint32_t		isp_rqstinrp;	/* register for REQINP */
559 	uint32_t		isp_rqstoutrp;	/* register for REQOUTP */
560 	uint32_t		isp_respinrp;	/* register for RESINP */
561 	uint32_t		isp_respoutrp;	/* register for RESOUTP */
562 
563 	/*
564 	 * Volatile state
565 	 */
566 
567 	volatile u_int		isp_mboxbsy;	/* mailbox command active */
568 	volatile u_int		isp_state;
569 	volatile mbreg_t	isp_curmbx;	/* currently active mailbox command */
570 	volatile uint32_t	isp_reqodx;	/* index of last ISP pickup */
571 	volatile uint32_t	isp_reqidx;	/* index of next request */
572 	volatile uint32_t	isp_residx;	/* index of last ISP write */
573 	volatile uint32_t	isp_resodx;	/* index of next result */
574 	volatile uint32_t	isp_atioodx;	/* index of next ATIO */
575 	volatile uint32_t	isp_obits;	/* mailbox command output */
576 	volatile uint32_t	isp_serno;	/* rolling serial number */
577 	volatile uint16_t	isp_mboxtmp[MAX_MAILBOX];
578 	volatile uint16_t	isp_lastmbxcmd;	/* last mbox command sent */
579 	volatile uint16_t	isp_seqno;	/* running sequence number */
580 
581 	/*
582 	 * Active commands are stored here, indexed by handle functions.
583 	 */
584 	isp_hdl_t		*isp_xflist;
585 	isp_hdl_t		*isp_xffree;
586 
587 	/*
588 	 * DMA mapped in area for synchronous IOCB requests.
589 	 */
590 	void *			isp_iocb;
591 	XS_DMA_ADDR_T		isp_iocb_dma;
592 
593 	/*
594 	 * request/result queue pointers and DMA handles for them.
595 	 */
596 	void *			isp_rquest;
597 	void *			isp_result;
598 	XS_DMA_ADDR_T		isp_rquest_dma;
599 	XS_DMA_ADDR_T		isp_result_dma;
600 #ifdef	ISP_TARGET_MODE
601 	/* for 24XX only */
602 	void *			isp_atioq;
603 	XS_DMA_ADDR_T		isp_atioq_dma;
604 #endif
605 };
606 
607 #define	SDPARAM(isp, chan)	(&((sdparam *)(isp)->isp_param)[(chan)])
608 #define	FCPARAM(isp, chan)	(&((fcparam *)(isp)->isp_param)[(chan)])
609 
610 #define	ISP_SET_SENDMARKER(isp, chan, val)	\
611     if (IS_FC(isp)) {				\
612 	FCPARAM(isp, chan)->sendmarker = val;	\
613     } else {					\
614 	SDPARAM(isp, chan)->sendmarker = val;	\
615     }
616 
617 #define	ISP_TST_SENDMARKER(isp, chan)		\
618     (IS_FC(isp)?				\
619 	FCPARAM(isp, chan)->sendmarker != 0 :	\
620 	SDPARAM(isp, chan)->sendmarker != 0)
621 
622 /*
623  * ISP Driver Run States
624  */
625 #define	ISP_NILSTATE	0
626 #define	ISP_CRASHED	1
627 #define	ISP_RESETSTATE	2
628 #define	ISP_INITSTATE	3
629 #define	ISP_RUNSTATE	4
630 
631 /*
632  * ISP Runtime Configuration Options
633  */
634 #define	ISP_CFG_FULL_DUPLEX	0x01	/* Full Duplex (Fibre Channel only) */
635 #define	ISP_CFG_PORT_PREF	0x0e	/* Mask for Port Prefs (all FC except 2100) */
636 #define	ISP_CFG_PORT_DEF	0x00	/* prefer connection type from NVRAM */
637 #define	ISP_CFG_LPORT_ONLY	0x02	/* insist on {N/F}L-Port connection */
638 #define	ISP_CFG_NPORT_ONLY	0x04	/* insist on {N/F}-Port connection */
639 #define	ISP_CFG_LPORT		0x06	/* prefer {N/F}L-Port connection */
640 #define	ISP_CFG_NPORT		0x08	/* prefer {N/F}-Port connection */
641 #define	ISP_CFG_1GB		0x10	/* force 1Gb connection (23XX only) */
642 #define	ISP_CFG_2GB		0x20	/* force 2Gb connection (23XX only) */
643 #define	ISP_CFG_NORELOAD	0x80	/* don't download f/w */
644 #define	ISP_CFG_NONVRAM		0x40	/* ignore NVRAM */
645 #define	ISP_CFG_NOFCTAPE	0x100	/* disable FC-Tape */
646 #define	ISP_CFG_FCTAPE		0x200	/* enable FC-Tape */
647 #define	ISP_CFG_OWNFSZ		0x400	/* override NVRAM frame size */
648 #define	ISP_CFG_OWNLOOPID	0x800	/* override NVRAM loopid */
649 #define	ISP_CFG_OWNEXCTHROTTLE	0x1000	/* override NVRAM execution throttle */
650 #define	ISP_CFG_4GB		0x2000	/* force 4Gb connection (24XX only) */
651 #define	ISP_CFG_8GB		0x4000	/* force 8Gb connection (25XX only) */
652 #define	ISP_CFG_16GB		0x8000	/* force 16Gb connection (26XX only) */
653 #define	ISP_CFG_32GB		0x10000	/* force 32Gb connection (27XX only) */
654 
655 /*
656  * For each channel, the outer layers should know what role that channel
657  * will take: ISP_ROLE_NONE, ISP_ROLE_INITIATOR, ISP_ROLE_TARGET,
658  * ISP_ROLE_BOTH.
659  *
660  * If you set ISP_ROLE_NONE, the cards will be reset, new firmware loaded,
661  * NVRAM read, and defaults set, but any further initialization (e.g.
662  * INITIALIZE CONTROL BLOCK commands for 2X00 cards) won't be done.
663  *
664  * If INITIATOR MODE isn't set, attempts to run commands will be stopped
665  * at isp_start and completed with the equivalent of SELECTION TIMEOUT.
666  *
667  * If TARGET MODE is set, it doesn't mean that the rest of target mode support
668  * needs to be enabled, or will even work. What happens with the 2X00 cards
669  * here is that if you have enabled it with TARGET MODE as part of the ICB
670  * options, but you haven't given the f/w any ram resources for ATIOs or
671  * Immediate Notifies, the f/w just handles what it can and you never see
672  * anything. Basically, it sends a single byte of data (the first byte,
673  * which you can set as part of the INITIALIZE CONTROL BLOCK command) for
674  * INQUIRY, and sends back QUEUE FULL status for any other command.
675  *
676  */
677 #define	ISP_ROLE_NONE		0x0
678 #define	ISP_ROLE_TARGET		0x1
679 #define	ISP_ROLE_INITIATOR	0x2
680 #define	ISP_ROLE_BOTH		(ISP_ROLE_TARGET|ISP_ROLE_INITIATOR)
681 #define	ISP_ROLE_EITHER		ISP_ROLE_BOTH
682 #ifndef	ISP_DEFAULT_ROLES
683 /*
684  * Counterintuitively, we prefer to default to role 'none'
685  * if we are enable target mode support. This gives us the
686  * maximum flexibility as to which port will do what.
687  */
688 #ifdef	ISP_TARGET_MODE
689 #define	ISP_DEFAULT_ROLES	ISP_ROLE_NONE
690 #else
691 #define	ISP_DEFAULT_ROLES	ISP_ROLE_INITIATOR
692 #endif
693 #endif
694 
695 
696 /*
697  * Firmware related defines
698  */
699 #define	ISP_CODE_ORG			0x1000	/* default f/w code start */
700 #define	ISP_CODE_ORG_2300		0x0800	/* ..except for 2300s */
701 #define	ISP_CODE_ORG_2400		0x100000 /* ..and 2400s */
702 #define	ISP_FW_REV(maj, min, mic)	((maj << 24) | (min << 16) | mic)
703 #define	ISP_FW_MAJOR(code)		((code >> 24) & 0xff)
704 #define	ISP_FW_MINOR(code)		((code >> 16) & 0xff)
705 #define	ISP_FW_MICRO(code)		((code >>  8) & 0xff)
706 #define	ISP_FW_REVX(xp)			((xp[0]<<24) | (xp[1] << 16) | xp[2])
707 #define	ISP_FW_MAJORX(xp)		(xp[0])
708 #define	ISP_FW_MINORX(xp)		(xp[1])
709 #define	ISP_FW_MICROX(xp)		(xp[2])
710 #define	ISP_FW_NEWER_THAN(i, major, minor, micro)		\
711  (ISP_FW_REVX((i)->isp_fwrev) > ISP_FW_REV(major, minor, micro))
712 #define	ISP_FW_OLDER_THAN(i, major, minor, micro)		\
713  (ISP_FW_REVX((i)->isp_fwrev) < ISP_FW_REV(major, minor, micro))
714 
715 /*
716  * Bus (implementation) types
717  */
718 #define	ISP_BT_PCI		0	/* PCI Implementations */
719 #define	ISP_BT_SBUS		1	/* SBus Implementations */
720 
721 /*
722  * If we have not otherwise defined SBus support away make sure
723  * it is defined here such that the code is included as default
724  */
725 #ifndef	ISP_SBUS_SUPPORTED
726 #define	ISP_SBUS_SUPPORTED	1
727 #endif
728 
729 /*
730  * Chip Types
731  */
732 #define	ISP_HA_SCSI		0xf
733 #define	ISP_HA_SCSI_UNKNOWN	0x1
734 #define	ISP_HA_SCSI_1020	0x2
735 #define	ISP_HA_SCSI_1020A	0x3
736 #define	ISP_HA_SCSI_1040	0x4
737 #define	ISP_HA_SCSI_1040A	0x5
738 #define	ISP_HA_SCSI_1040B	0x6
739 #define	ISP_HA_SCSI_1040C	0x7
740 #define	ISP_HA_SCSI_1240	0x8
741 #define	ISP_HA_SCSI_1080	0x9
742 #define	ISP_HA_SCSI_1280	0xa
743 #define	ISP_HA_SCSI_10160	0xb
744 #define	ISP_HA_SCSI_12160	0xc
745 #define	ISP_HA_FC		0xf0
746 #define	ISP_HA_FC_2100		0x10
747 #define	ISP_HA_FC_2200		0x20
748 #define	ISP_HA_FC_2300		0x30
749 #define	ISP_HA_FC_2312		0x40
750 #define	ISP_HA_FC_2322		0x50
751 #define	ISP_HA_FC_2400		0x60
752 #define	ISP_HA_FC_2500		0x70
753 #define	ISP_HA_FC_2600		0x80
754 #define	ISP_HA_FC_2700		0x90
755 
756 #define	IS_SCSI(isp)	(isp->isp_type & ISP_HA_SCSI)
757 #define	IS_1020(isp)	(isp->isp_type < ISP_HA_SCSI_1240)
758 #define	IS_1240(isp)	(isp->isp_type == ISP_HA_SCSI_1240)
759 #define	IS_1080(isp)	(isp->isp_type == ISP_HA_SCSI_1080)
760 #define	IS_1280(isp)	(isp->isp_type == ISP_HA_SCSI_1280)
761 #define	IS_10160(isp)	(isp->isp_type == ISP_HA_SCSI_10160)
762 #define	IS_12160(isp)	(isp->isp_type == ISP_HA_SCSI_12160)
763 
764 #define	IS_12X0(isp)	(IS_1240(isp) || IS_1280(isp))
765 #define	IS_1X160(isp)	(IS_10160(isp) || IS_12160(isp))
766 #define	IS_DUALBUS(isp)	(IS_12X0(isp) || IS_12160(isp))
767 #define	IS_ULTRA2(isp)	(IS_1080(isp) || IS_1280(isp) || IS_1X160(isp))
768 #define	IS_ULTRA3(isp)	(IS_1X160(isp))
769 
770 #define	IS_FC(isp)	((isp)->isp_type & ISP_HA_FC)
771 #define	IS_2100(isp)	((isp)->isp_type == ISP_HA_FC_2100)
772 #define	IS_2200(isp)	((isp)->isp_type == ISP_HA_FC_2200)
773 #define	IS_23XX(isp)	((isp)->isp_type >= ISP_HA_FC_2300 && \
774 				(isp)->isp_type < ISP_HA_FC_2400)
775 #define	IS_2300(isp)	((isp)->isp_type == ISP_HA_FC_2300)
776 #define	IS_2312(isp)	((isp)->isp_type == ISP_HA_FC_2312)
777 #define	IS_2322(isp)	((isp)->isp_type == ISP_HA_FC_2322)
778 #define	IS_24XX(isp)	((isp)->isp_type >= ISP_HA_FC_2400)
779 #define	IS_25XX(isp)	((isp)->isp_type >= ISP_HA_FC_2500)
780 #define	IS_26XX(isp)	((isp)->isp_type >= ISP_HA_FC_2600)
781 #define	IS_27XX(isp)	((isp)->isp_type >= ISP_HA_FC_2700)
782 
783 /*
784  * DMA related macros
785  */
786 #define	DMA_WD3(x)	(((uint16_t)(((uint64_t)x) >> 48)) & 0xffff)
787 #define	DMA_WD2(x)	(((uint16_t)(((uint64_t)x) >> 32)) & 0xffff)
788 #define	DMA_WD1(x)	((uint16_t)((x) >> 16) & 0xffff)
789 #define	DMA_WD0(x)	((uint16_t)((x) & 0xffff))
790 
791 #define	DMA_LO32(x)	((uint32_t) (x))
792 #define	DMA_HI32(x)	((uint32_t)(((uint64_t)x) >> 32))
793 
794 /*
795  * Core System Function Prototypes
796  */
797 
798 /*
799  * Reset Hardware. Totally. Assumes that you'll follow this with a call to isp_init.
800  */
801 void isp_reset(ispsoftc_t *, int);
802 
803 /*
804  * Initialize Hardware to known state
805  */
806 void isp_init(ispsoftc_t *);
807 
808 /*
809  * Reset the ISP and call completion for any orphaned commands.
810  */
811 int isp_reinit(ispsoftc_t *, int);
812 
813 /*
814  * Shutdown hardware after use.
815  */
816 void isp_shutdown(ispsoftc_t *);
817 
818 /*
819  * Internal Interrupt Service Routine
820  */
821 #ifdef	ISP_TARGET_MODE
822 void isp_intr_atioq(ispsoftc_t *);
823 #endif
824 void isp_intr_async(ispsoftc_t *, uint16_t event);
825 void isp_intr_mbox(ispsoftc_t *, uint16_t mbox0);
826 void isp_intr_respq(ispsoftc_t *);
827 
828 
829 /*
830  * Command Entry Point- Platform Dependent layers call into this
831  */
832 int isp_start(XS_T *);
833 
834 /* these values are what isp_start returns */
835 #define	CMD_COMPLETE	101	/* command completed */
836 #define	CMD_EAGAIN	102	/* busy- maybe retry later */
837 #define	CMD_QUEUED	103	/* command has been queued for execution */
838 #define	CMD_RQLATER 	104	/* requeue this command later */
839 
840 /*
841  * Command Completion Point- Core layers call out from this with completed cmds
842  */
843 void isp_done(XS_T *);
844 
845 /*
846  * Platform Dependent to External to Internal Control Function
847  *
848  * Assumes locks are held on entry. You should note that with many of
849  * these commands locks may be released while this function is called.
850  *
851  * ... ISPCTL_RESET_BUS, int channel);
852  *        Reset BUS on this channel
853  * ... ISPCTL_RESET_DEV, int channel, int target);
854  *        Reset Device on this channel at this target.
855  * ... ISPCTL_ABORT_CMD, XS_T *xs);
856  *        Abort active transaction described by xs.
857  * ... IPCTL_UPDATE_PARAMS);
858  *        Update any operating parameters (speed, etc.)
859  * ... ISPCTL_FCLINK_TEST, int channel);
860  *        Test FC link status on this channel
861  * ... ISPCTL_SCAN_LOOP, int channel);
862  *        Scan local loop on this channel
863  * ... ISPCTL_SCAN_FABRIC, int channel);
864  *        Scan fabric on this channel
865  * ... ISPCTL_PDB_SYNC, int channel);
866  *        Synchronize port database on this channel
867  * ... ISPCTL_SEND_LIP, int channel);
868  *        Send a LIP on this channel
869  * ... ISPCTL_GET_NAMES, int channel, int np, uint64_t *wwnn, uint64_t *wwpn)
870  *        Get a WWNN/WWPN for this N-port handle on this channel
871  * ... ISPCTL_RUN_MBOXCMD, mbreg_t *mbp)
872  *        Run this mailbox command
873  * ... ISPCTL_GET_PDB, int channel, int nphandle, isp_pdb_t *pdb)
874  *        Get PDB on this channel for this N-port handle
875  * ... ISPCTL_PLOGX, isp_plcmd_t *)
876  *        Performa a port login/logout
877  * ... ISPCTL_CHANGE_ROLE, int channel, int role);
878  *        Change role of specified channel
879  *
880  * ISPCTL_PDB_SYNC is somewhat misnamed. It actually is the final step, in
881  * order, of ISPCTL_FCLINK_TEST, ISPCTL_SCAN_LOOP, and ISPCTL_SCAN_FABRIC.
882  * The main purpose of ISPCTL_PDB_SYNC is to complete management of logging
883  * and logging out of fabric devices (if one is on a fabric) and then marking
884  * the 'loop state' as being ready to now be used for sending commands to
885  * devices.
886  */
887 typedef enum {
888 	ISPCTL_RESET_BUS,
889 	ISPCTL_RESET_DEV,
890 	ISPCTL_ABORT_CMD,
891 	ISPCTL_UPDATE_PARAMS,
892 	ISPCTL_FCLINK_TEST,
893 	ISPCTL_SCAN_FABRIC,
894 	ISPCTL_SCAN_LOOP,
895 	ISPCTL_PDB_SYNC,
896 	ISPCTL_SEND_LIP,
897 	ISPCTL_GET_NAMES,
898 	ISPCTL_RUN_MBOXCMD,
899 	ISPCTL_GET_PDB,
900 	ISPCTL_PLOGX,
901 	ISPCTL_CHANGE_ROLE
902 } ispctl_t;
903 int isp_control(ispsoftc_t *, ispctl_t, ...);
904 
905 /*
906  * Platform Dependent to Internal to External Control Function
907  */
908 
909 typedef enum {
910 	ISPASYNC_NEW_TGT_PARAMS,	/* SPI New Target Parameters */
911 	ISPASYNC_BUS_RESET,		/* All Bus Was Reset */
912 	ISPASYNC_LOOP_DOWN,		/* FC Loop Down */
913 	ISPASYNC_LOOP_UP,		/* FC Loop Up */
914 	ISPASYNC_LIP,			/* FC LIP Received */
915 	ISPASYNC_LOOP_RESET,		/* FC Loop Reset Received */
916 	ISPASYNC_CHANGE_NOTIFY,		/* FC Change Notification */
917 	ISPASYNC_DEV_ARRIVED,		/* FC Device Arrived */
918 	ISPASYNC_DEV_CHANGED,		/* FC Device Changed */
919 	ISPASYNC_DEV_STAYED,		/* FC Device Stayed */
920 	ISPASYNC_DEV_GONE,		/* FC Device Departure */
921 	ISPASYNC_TARGET_NOTIFY,		/* All target async notification */
922 	ISPASYNC_TARGET_NOTIFY_ACK,	/* All target notify ack required */
923 	ISPASYNC_TARGET_ACTION,		/* All target action requested */
924 	ISPASYNC_FW_CRASH,		/* All Firmware has crashed */
925 	ISPASYNC_FW_RESTARTED		/* All Firmware has been restarted */
926 } ispasync_t;
927 void isp_async(ispsoftc_t *, ispasync_t, ...);
928 
929 #define	ISPASYNC_CHANGE_PDB	0
930 #define	ISPASYNC_CHANGE_SNS	1
931 #define	ISPASYNC_CHANGE_OTHER	2
932 
933 /*
934  * Platform Dependent Error and Debug Printout
935  *
936  * Two required functions for each platform must be provided:
937  *
938  *    void isp_prt(ispsoftc_t *, int level, const char *, ...)
939  *    void isp_xs_prt(ispsoftc_t *, XS_T *, int level, const char *, ...)
940  *
941  * but due to compiler differences on different platforms this won't be
942  * formally defined here. Instead, they go in each platform definition file.
943  */
944 
945 #define	ISP_LOGALL	0x0	/* log always */
946 #define	ISP_LOGCONFIG	0x1	/* log configuration messages */
947 #define	ISP_LOGINFO	0x2	/* log informational messages */
948 #define	ISP_LOGWARN	0x4	/* log warning messages */
949 #define	ISP_LOGERR	0x8	/* log error messages */
950 #define	ISP_LOGDEBUG0	0x10	/* log simple debug messages */
951 #define	ISP_LOGDEBUG1	0x20	/* log intermediate debug messages */
952 #define	ISP_LOGDEBUG2	0x40	/* log most debug messages */
953 #define	ISP_LOGDEBUG3	0x80	/* log high frequency debug messages */
954 #define	ISP_LOG_SANCFG	0x100	/* log SAN configuration */
955 #define	ISP_LOG_CWARN	0x200	/* log SCSI command "warnings" (e.g., check conditions) */
956 #define	ISP_LOG_WARN1	0x400	/* log WARNS we might be interested at some time */
957 #define	ISP_LOGTINFO	0x1000	/* log informational messages (target mode) */
958 #define	ISP_LOGTDEBUG0	0x2000	/* log simple debug messages (target mode) */
959 #define	ISP_LOGTDEBUG1	0x4000	/* log intermediate debug messages (target) */
960 #define	ISP_LOGTDEBUG2	0x8000	/* log all debug messages (target) */
961 
962 /*
963  * Each Platform provides it's own isposinfo substructure of the ispsoftc
964  * defined above.
965  *
966  * Each platform must also provide the following macros/defines:
967  *
968  *
969  *	ISP_FC_SCRLEN				FC scratch area DMA length
970  *
971  *	ISP_MEMZERO(dst, src)			platform zeroing function
972  *	ISP_MEMCPY(dst, src, count)		platform copying function
973  *	ISP_SNPRINTF(buf, bufsize, fmt, ...)	snprintf
974  *	ISP_DELAY(usecs)			microsecond spindelay function
975  *	ISP_SLEEP(isp, usecs)			microsecond sleep function
976  *
977  *	ISP_INLINE				___inline or not- depending on how
978  *						good your debugger is
979  *	ISP_MIN					shorthand for ((a) < (b))? (a) : (b)
980  *
981  *	NANOTIME_T				nanosecond time type
982  *
983  *	GET_NANOTIME(NANOTIME_T *)		get current nanotime.
984  *
985  *	GET_NANOSEC(NANOTIME_T *)		get uint64_t from NANOTIME_T
986  *
987  *	NANOTIME_SUB(NANOTIME_T *, NANOTIME_T *)
988  *						subtract two NANOTIME_T values
989  *
990  *	MAXISPREQUEST(ispsoftc_t *)		maximum request queue size
991  *						for this particular board type
992  *
993  *	MEMORYBARRIER(ispsoftc_t *, barrier_type, offset, size, chan)
994  *
995  *		Function/Macro the provides memory synchronization on
996  *		various objects so that the ISP's and the system's view
997  *		of the same object is consistent.
998  *
999  *	MBOX_ACQUIRE(ispsoftc_t *)		acquire lock on mailbox regs
1000  *	MBOX_WAIT_COMPLETE(ispsoftc_t *, mbreg_t *) wait for cmd to be done
1001  *	MBOX_NOTIFY_COMPLETE(ispsoftc_t *)	notification of mbox cmd donee
1002  *	MBOX_RELEASE(ispsoftc_t *)		release lock on mailbox regs
1003  *
1004  *	FC_SCRATCH_ACQUIRE(ispsoftc_t *, chan)	acquire lock on FC scratch area
1005  *						return -1 if you cannot
1006  *	FC_SCRATCH_RELEASE(ispsoftc_t *, chan)	acquire lock on FC scratch area
1007  *
1008  *	FCP_NEXT_CRN(ispsoftc_t *, XS_T *, rslt, channel, target, lun)	generate the next command reference number. XS_T * may be null.
1009  *
1010  *	SCSI_GOOD	SCSI 'Good' Status
1011  *	SCSI_CHECK	SCSI 'Check Condition' Status
1012  *	SCSI_BUSY	SCSI 'Busy' Status
1013  *	SCSI_QFULL	SCSI 'Queue Full' Status
1014  *
1015  *	XS_T			Platform SCSI transaction type (i.e., command for HBA)
1016  *	XS_DMA_ADDR_T		Platform PCI DMA Address Type
1017  *	XS_GET_DMA_SEG(..)	Get 32 bit dma segment list value
1018  *	XS_GET_DMA64_SEG(..)	Get 64 bit dma segment list value
1019  *	XS_NEED_DMA64_SEG(..)	dma segment needs 64 bit storage
1020  *	XS_ISP(xs)		gets an instance out of an XS_T
1021  *	XS_CHANNEL(xs)		gets the channel (bus # for DUALBUS cards) ""
1022  *	XS_TGT(xs)		gets the target ""
1023  *	XS_LUN(xs)		gets the lun ""
1024  *	XS_CDBP(xs)		gets a pointer to the scsi CDB ""
1025  *	XS_CDBLEN(xs)		gets the CDB's length ""
1026  *	XS_XFRLEN(xs)		gets the associated data transfer length ""
1027  *	XS_TIME(xs)		gets the time (in seconds) for this command
1028  *	XS_GET_RESID(xs)	gets the current residual count
1029  *	XS_GET_RESID(xs, resid)	sets the current residual count
1030  *	XS_STSP(xs)		gets a pointer to the SCSI status byte ""
1031  *	XS_SNSP(xs)		gets a pointer to the associate sense data
1032  *	XS_TOT_SNSLEN(xs)	gets the total length of sense data storage
1033  *	XS_CUR_SNSLEN(xs)	gets the currently used length of sense data storage
1034  *	XS_SNSKEY(xs)		dereferences XS_SNSP to get the current stored Sense Key
1035  *	XS_SNSASC(xs)		dereferences XS_SNSP to get the current stored Additional Sense Code
1036  *	XS_SNSASCQ(xs)		dereferences XS_SNSP to get the current stored Additional Sense Code Qualifier
1037  *	XS_TAG_P(xs)		predicate of whether this command should be tagged
1038  *	XS_TAG_TYPE(xs)		which type of tag to use
1039  *	XS_SETERR(xs)		set error state
1040  *
1041  *		HBA_NOERROR	command has no erros
1042  *		HBA_BOTCH	hba botched something
1043  *		HBA_CMDTIMEOUT	command timed out
1044  *		HBA_SELTIMEOUT	selection timed out (also port logouts for FC)
1045  *		HBA_TGTBSY	target returned a BUSY status
1046  *		HBA_BUSRESET	bus reset destroyed command
1047  *		HBA_ABORTED	command was aborted (by request)
1048  *		HBA_DATAOVR	a data overrun was detected
1049  *		HBA_ARQFAIL	Automatic Request Sense failed
1050  *
1051  *	XS_ERR(xs)	return current error state
1052  *	XS_NOERR(xs)	there is no error currently set
1053  *	XS_INITERR(xs)	initialize error state
1054  *
1055  *	XS_SAVE_SENSE(xs, sp, len)	save sense data
1056  *	XS_APPEND_SENSE(xs, sp, len)	append more sense data
1057  *
1058  *	XS_SENSE_VALID(xs)		indicates whether sense is valid
1059  *
1060  *	DEFAULT_FRAMESIZE(ispsoftc_t *)		Default Frame Size
1061  *	DEFAULT_EXEC_THROTTLE(ispsoftc_t *)	Default Execution Throttle
1062  *
1063  *	DEFAULT_ROLE(ispsoftc_t *, int)		Get Default Role for a channel
1064  *	DEFAULT_IID(ispsoftc_t *, int)		Default SCSI initiator ID
1065  *	DEFAULT_LOOPID(ispsoftc_t *, int)	Default FC Loop ID
1066  *
1067  *		These establish reasonable defaults for each platform.
1068  * 		These must be available independent of card NVRAM and are
1069  *		to be used should NVRAM not be readable.
1070  *
1071  *	DEFAULT_NODEWWN(ispsoftc_t *, chan)	Default FC Node WWN to use
1072  *	DEFAULT_PORTWWN(ispsoftc_t *, chan)	Default FC Port WWN to use
1073  *
1074  *		These defines are hooks to allow the setting of node and
1075  *		port WWNs when NVRAM cannot be read or is to be overriden.
1076  *
1077  *	ACTIVE_NODEWWN(ispsoftc_t *, chan)	FC Node WWN to use
1078  *	ACTIVE_PORTWWN(ispsoftc_t *, chan)	FC Port WWN to use
1079  *
1080  *		After NVRAM is read, these will be invoked to get the
1081  *		node and port WWNs that will actually be used for this
1082  *		channel.
1083  *
1084  *
1085  *	ISP_IOXPUT_8(ispsoftc_t *, uint8_t srcval, uint8_t *dstptr)
1086  *	ISP_IOXPUT_16(ispsoftc_t *, uint16_t srcval, uint16_t *dstptr)
1087  *	ISP_IOXPUT_32(ispsoftc_t *, uint32_t srcval, uint32_t *dstptr)
1088  *
1089  *	ISP_IOXGET_8(ispsoftc_t *, uint8_t *srcptr, uint8_t dstrval)
1090  *	ISP_IOXGET_16(ispsoftc_t *, uint16_t *srcptr, uint16_t dstrval)
1091  *	ISP_IOXGET_32(ispsoftc_t *, uint32_t *srcptr, uint32_t dstrval)
1092  *
1093  *	ISP_SWIZZLE_NVRAM_WORD(ispsoftc_t *, uint16_t *)
1094  *	ISP_SWIZZLE_NVRAM_LONG(ispsoftc_t *, uint32_t *)
1095  *	ISP_SWAP16(ispsoftc_t *, uint16_t srcval)
1096  *	ISP_SWAP32(ispsoftc_t *, uint32_t srcval)
1097  */
1098 
1099 #ifdef	ISP_TARGET_MODE
1100 /*
1101  * The functions below are for the publicly available
1102  * target mode functions that are internal to the Qlogic driver.
1103  */
1104 
1105 /*
1106  * This function handles new response queue entry appropriate for target mode.
1107  */
1108 int isp_target_notify(ispsoftc_t *, void *, uint32_t *);
1109 
1110 /*
1111  * This function externalizes the ability to acknowledge an Immediate Notify request.
1112  */
1113 int isp_notify_ack(ispsoftc_t *, void *);
1114 
1115 /*
1116  * This function externalized acknowledging (success/fail) an ABTS frame
1117  */
1118 int isp_acknak_abts(ispsoftc_t *, void *, int);
1119 
1120 /*
1121  * General request queue 'put' routine for target mode entries.
1122  */
1123 int isp_target_put_entry(ispsoftc_t *isp, void *);
1124 
1125 /*
1126  * General routine to put back an ATIO entry-
1127  * used for replenishing f/w resource counts.
1128  * The argument is a pointer to a source ATIO
1129  * or ATIO2.
1130  */
1131 int isp_target_put_atio(ispsoftc_t *, void *);
1132 
1133 /*
1134  * General routine to send a final CTIO for a command- used mostly for
1135  * local responses.
1136  */
1137 int isp_endcmd(ispsoftc_t *, ...);
1138 #define	ECMD_SVALID	0x100
1139 #define	ECMD_RVALID	0x200
1140 #define	ECMD_TERMINATE	0x400
1141 
1142 /*
1143  * Handle an asynchronous event
1144  */
1145 void isp_target_async(ispsoftc_t *, int, int);
1146 #endif
1147 #endif	/* _ISPVAR_H */
1148