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