xref: /titanic_52/usr/src/uts/sun/io/scsi/adapters/sf.c (revision 5c5f137104b2d56181283389fa902220f2023809)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright (c) 2011 Bayard G. Bell. All rights reserved.
25  */
26 
27 /*
28  * sf - Solaris Fibre Channel driver
29  *
30  * This module implements some of the Fibre Channel FC-4 layer, converting
31  * from FC frames to SCSI and back.  (Note: no sequence management is done
32  * here, though.)
33  */
34 
35 #if defined(lint) && !defined(DEBUG)
36 #define	DEBUG	1
37 #endif
38 
39 /*
40  * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
41  * Need to use the ugly RAID LUN mappings in FCP Annex D
42  * to prevent SCSA from barfing.  This *REALLY* needs to
43  * be addressed by the standards committee.
44  */
45 #define	RAID_LUNS	1
46 
47 #ifdef DEBUG
48 static int sfdebug = 0;
49 #include <sys/debug.h>
50 
51 #define	SF_DEBUG(level, args) \
52 	if (sfdebug >= (level)) sf_log args
53 #else
54 #define	SF_DEBUG(level, args)
55 #endif
56 
57 static int sf_bus_config_debug = 0;
58 
59 #include <sys/scsi/scsi.h>
60 #include <sys/fc4/fcal.h>
61 #include <sys/fc4/fcp.h>
62 #include <sys/fc4/fcal_linkapp.h>
63 #include <sys/socal_cq_defs.h>
64 #include <sys/fc4/fcal_transport.h>
65 #include <sys/fc4/fcio.h>
66 #include <sys/scsi/adapters/sfvar.h>
67 #include <sys/scsi/impl/scsi_reset_notify.h>
68 #include <sys/stat.h>
69 #include <sys/varargs.h>
70 #include <sys/var.h>
71 #include <sys/thread.h>
72 #include <sys/proc.h>
73 #include <sys/kstat.h>
74 #include <sys/devctl.h>
75 #include <sys/scsi/targets/ses.h>
76 #include <sys/callb.h>
77 #include <sys/sysmacros.h>
78 
79 static int sf_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
80 static int sf_attach(dev_info_t *, ddi_attach_cmd_t);
81 static int sf_detach(dev_info_t *, ddi_detach_cmd_t);
82 static void sf_softstate_unlink(struct sf *);
83 static int sf_scsi_bus_config(dev_info_t *parent, uint_t flag,
84     ddi_bus_config_op_t op, void *arg, dev_info_t **childp);
85 static int sf_scsi_bus_unconfig(dev_info_t *parent, uint_t flag,
86     ddi_bus_config_op_t op, void *arg);
87 static int sf_scsi_tgt_init(dev_info_t *, dev_info_t *,
88     scsi_hba_tran_t *, struct scsi_device *);
89 static void sf_scsi_tgt_free(dev_info_t *, dev_info_t *,
90     scsi_hba_tran_t *, struct scsi_device *);
91 static int sf_pkt_alloc_extern(struct sf *, struct sf_pkt *,
92     int, int, int);
93 static void sf_pkt_destroy_extern(struct sf *, struct sf_pkt *);
94 static struct scsi_pkt *sf_scsi_init_pkt(struct scsi_address *,
95     struct scsi_pkt *, struct buf *, int, int, int, int, int (*)(), caddr_t);
96 static void sf_scsi_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
97 static void sf_scsi_dmafree(struct scsi_address *, struct scsi_pkt *);
98 static void sf_scsi_sync_pkt(struct scsi_address *, struct scsi_pkt *);
99 static int sf_scsi_reset_notify(struct scsi_address *, int,
100     void (*)(caddr_t), caddr_t);
101 static int sf_scsi_get_name(struct scsi_device *, char *, int);
102 static int sf_scsi_get_bus_addr(struct scsi_device *, char *, int);
103 static int sf_add_cr_pool(struct sf *);
104 static int sf_cr_alloc(struct sf *, struct sf_pkt *, int (*)());
105 static void sf_cr_free(struct sf_cr_pool *, struct sf_pkt *);
106 static void sf_crpool_free(struct sf *);
107 static int sf_kmem_cache_constructor(void *, void *, int);
108 static void sf_kmem_cache_destructor(void *, void *);
109 static void sf_statec_callback(void *, int);
110 static int sf_login(struct sf *, uchar_t, uchar_t, uint_t, int);
111 static int sf_els_transport(struct sf *, struct sf_els_hdr *);
112 static void sf_els_callback(struct fcal_packet *);
113 static int sf_do_prli(struct sf *, struct sf_els_hdr *, struct la_els_logi *);
114 static int sf_do_adisc(struct sf *, struct sf_els_hdr *);
115 static int sf_do_reportlun(struct sf *, struct sf_els_hdr *,
116     struct sf_target *);
117 static void sf_reportlun_callback(struct fcal_packet *);
118 static int sf_do_inquiry(struct sf *, struct sf_els_hdr *,
119     struct sf_target *);
120 static void sf_inq_callback(struct fcal_packet *);
121 static struct fcal_packet *sf_els_alloc(struct sf *, uchar_t, int, int,
122     int, caddr_t *, caddr_t *);
123 static void sf_els_free(struct fcal_packet *);
124 static struct sf_target *sf_create_target(struct sf *,
125     struct sf_els_hdr *, int, int64_t);
126 #ifdef RAID_LUNS
127 static struct sf_target *sf_lookup_target(struct sf *, uchar_t *, int);
128 #else
129 static struct sf_target *sf_lookup_target(struct sf *, uchar_t *, int64_t);
130 #endif
131 static void sf_finish_init(struct sf *, int);
132 static void sf_offline_target(struct sf *, struct sf_target *);
133 static void sf_create_devinfo(struct sf *, struct sf_target *, int);
134 static int sf_create_props(dev_info_t *, struct sf_target *, int);
135 static int sf_commoncap(struct scsi_address *, char *, int, int, int);
136 static int sf_getcap(struct scsi_address *, char *, int);
137 static int sf_setcap(struct scsi_address *, char *, int, int);
138 static int sf_abort(struct scsi_address *, struct scsi_pkt *);
139 static int sf_reset(struct scsi_address *, int);
140 static void sf_abort_all(struct sf *, struct sf_target *, int, int, int);
141 static int sf_start(struct scsi_address *, struct scsi_pkt *);
142 static int sf_start_internal(struct sf *, struct sf_pkt *);
143 static void sf_fill_ids(struct sf *, struct sf_pkt *, struct sf_target *);
144 static int sf_prepare_pkt(struct sf *, struct sf_pkt *, struct sf_target *);
145 static int sf_dopoll(struct sf *, struct sf_pkt *);
146 static void sf_cmd_callback(struct fcal_packet *);
147 static void sf_throttle(struct sf *);
148 static void sf_watch(void *);
149 static void sf_throttle_start(struct sf *);
150 static void sf_check_targets(struct sf *);
151 static void sf_check_reset_delay(void *);
152 static int sf_target_timeout(struct sf *, struct sf_pkt *);
153 static void sf_force_lip(struct sf *);
154 static void sf_unsol_els_callback(void *, soc_response_t *, caddr_t);
155 static struct sf_els_hdr *sf_els_timeout(struct sf *, struct sf_els_hdr *);
156 /*PRINTFLIKE3*/
157 static void sf_log(struct sf *, int, const char *, ...);
158 static int sf_kstat_update(kstat_t *, int);
159 static int sf_open(dev_t *, int, int, cred_t *);
160 static int sf_close(dev_t, int, int, cred_t *);
161 static int sf_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
162 static struct sf_target *sf_get_target_from_dip(struct sf *, dev_info_t *);
163 static int sf_bus_get_eventcookie(dev_info_t *, dev_info_t *, char *,
164     ddi_eventcookie_t *);
165 static int sf_bus_add_eventcall(dev_info_t *, dev_info_t *,
166     ddi_eventcookie_t, void (*)(), void *, ddi_callback_id_t *cb_id);
167 static int sf_bus_remove_eventcall(dev_info_t *devi, ddi_callback_id_t cb_id);
168 static int sf_bus_post_event(dev_info_t *, dev_info_t *,
169     ddi_eventcookie_t, void *);
170 
171 static void sf_hp_daemon(void *);
172 
173 /*
174  * this is required to be able to supply a control node
175  * where ioctls can be executed
176  */
177 struct cb_ops sf_cb_ops = {
178 	sf_open,			/* open */
179 	sf_close,			/* close */
180 	nodev,				/* strategy */
181 	nodev,				/* print */
182 	nodev,				/* dump */
183 	nodev,				/* read */
184 	nodev,				/* write */
185 	sf_ioctl,			/* ioctl */
186 	nodev,				/* devmap */
187 	nodev,				/* mmap */
188 	nodev,				/* segmap */
189 	nochpoll,			/* poll */
190 	ddi_prop_op,			/* cb_prop_op */
191 	0,				/* streamtab  */
192 	D_MP | D_NEW | D_HOTPLUG	/* driver flags */
193 
194 };
195 
196 /*
197  * autoconfiguration routines.
198  */
199 static struct dev_ops sf_ops = {
200 	DEVO_REV,		/* devo_rev, */
201 	0,			/* refcnt  */
202 	sf_info,		/* info */
203 	nulldev,		/* identify */
204 	nulldev,		/* probe */
205 	sf_attach,		/* attach */
206 	sf_detach,		/* detach */
207 	nodev,			/* reset */
208 	&sf_cb_ops,		/* driver operations */
209 	NULL,			/* bus operations */
210 	NULL,			/* power management */
211 	ddi_quiesce_not_supported,	/* devo_quiesce */
212 };
213 
214 #define	SF_NAME	"FC-AL FCP Nexus Driver"	/* Name of the module. */
215 static	char	sf_version[] = "1.72 08/19/2008"; /* version of the module */
216 
217 static struct modldrv modldrv = {
218 	&mod_driverops, /* Type of module. This one is a driver */
219 	SF_NAME,
220 	&sf_ops,	/* driver ops */
221 };
222 
223 static struct modlinkage modlinkage = {
224 	MODREV_1, (void *)&modldrv, NULL
225 };
226 
227 /* XXXXXX The following is here to handle broken targets -- remove it later */
228 static int sf_reportlun_forever = 0;
229 /* XXXXXX */
230 static int sf_lip_on_plogo = 0;
231 static int sf_els_retries = SF_ELS_RETRIES;
232 static struct sf *sf_head = NULL;
233 static int sf_target_scan_cnt = 4;
234 static int sf_pkt_scan_cnt = 5;
235 static int sf_pool_scan_cnt = 1800;
236 static void *sf_state = NULL;
237 static int sf_watchdog_init = 0;
238 static int sf_watchdog_time = 0;
239 static int sf_watchdog_timeout = 1;
240 static int sf_watchdog_tick;
241 static int sf_watch_running = 0;
242 static timeout_id_t sf_watchdog_id;
243 static timeout_id_t sf_reset_timeout_id;
244 static int sf_max_targets = SF_MAX_TARGETS;
245 static kmutex_t sf_global_mutex;
246 static int sf_core = 0;
247 int *sf_token = NULL; /* Must not be static or lint complains. */
248 static kcondvar_t sf_watch_cv;
249 extern pri_t minclsyspri;
250 static ddi_eventcookie_t	sf_insert_eid;
251 static ddi_eventcookie_t	sf_remove_eid;
252 
253 static ndi_event_definition_t	sf_event_defs[] = {
254 { SF_EVENT_TAG_INSERT, FCAL_INSERT_EVENT, EPL_KERNEL, 0 },
255 { SF_EVENT_TAG_REMOVE, FCAL_REMOVE_EVENT, EPL_INTERRUPT, 0 }
256 };
257 
258 #define	SF_N_NDI_EVENTS	\
259 	(sizeof (sf_event_defs) / sizeof (ndi_event_definition_t))
260 
261 #ifdef DEBUG
262 static int sf_lip_flag = 1;		/* bool: to allow LIPs */
263 static int sf_reset_flag = 1;		/* bool: to allow reset after LIP */
264 static int sf_abort_flag = 0;		/* bool: to do just one abort */
265 #endif
266 
267 extern int64_t ddi_get_lbolt64(void);
268 
269 /*
270  * for converting between target number (switch) and hard address/AL_PA
271  */
272 static uchar_t sf_switch_to_alpa[] = {
273 	0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda, 0xd9, 0xd6,
274 	0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce, 0xcd, 0xcc, 0xcb, 0xca,
275 	0xc9, 0xc7, 0xc6, 0xc5, 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5,
276 	0xb4, 0xb3, 0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
277 	0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b, 0x98, 0x97,
278 	0x90, 0x8f, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7c, 0x7a, 0x79,
279 	0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b,
280 	0x6a, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
281 	0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a,
282 	0x49, 0x47, 0x46, 0x45, 0x43, 0x3c, 0x3a, 0x39, 0x36, 0x35,
283 	0x34, 0x33, 0x32, 0x31, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29,
284 	0x27, 0x26, 0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
285 	0x10, 0x0f, 0x08, 0x04, 0x02, 0x01
286 };
287 
288 static uchar_t sf_alpa_to_switch[] = {
289 	0x00, 0x7d, 0x7c, 0x00, 0x7b, 0x00, 0x00, 0x00, 0x7a, 0x00,
290 	0x00, 0x00, 0x00, 0x00, 0x00, 0x79, 0x78, 0x00, 0x00, 0x00,
291 	0x00, 0x00, 0x00, 0x77, 0x76, 0x00, 0x00, 0x75, 0x00, 0x74,
292 	0x73, 0x72, 0x00, 0x00, 0x00, 0x71, 0x00, 0x70, 0x6f, 0x6e,
293 	0x00, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0x00, 0x00, 0x67,
294 	0x66, 0x65, 0x64, 0x63, 0x62, 0x00, 0x00, 0x61, 0x60, 0x00,
295 	0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x00, 0x5d,
296 	0x5c, 0x5b, 0x00, 0x5a, 0x59, 0x58, 0x57, 0x56, 0x55, 0x00,
297 	0x00, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4f, 0x00, 0x00, 0x4e,
298 	0x4d, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4b,
299 	0x00, 0x4a, 0x49, 0x48, 0x00, 0x47, 0x46, 0x45, 0x44, 0x43,
300 	0x42, 0x00, 0x00, 0x41, 0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0x00,
301 	0x00, 0x3b, 0x3a, 0x00, 0x39, 0x00, 0x00, 0x00, 0x38, 0x37,
302 	0x36, 0x00, 0x35, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00,
303 	0x00, 0x00, 0x00, 0x33, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00,
304 	0x00, 0x31, 0x30, 0x00, 0x00, 0x2f, 0x00, 0x2e, 0x2d, 0x2c,
305 	0x00, 0x00, 0x00, 0x2b, 0x00, 0x2a, 0x29, 0x28, 0x00, 0x27,
306 	0x26, 0x25, 0x24, 0x23, 0x22, 0x00, 0x00, 0x21, 0x20, 0x1f,
307 	0x1e, 0x1d, 0x1c, 0x00, 0x00, 0x1b, 0x1a, 0x00, 0x19, 0x00,
308 	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x17, 0x16, 0x15,
309 	0x00, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x00, 0x00, 0x0e,
310 	0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x00, 0x00, 0x08, 0x07, 0x00,
311 	0x06, 0x00, 0x00, 0x00, 0x05, 0x04, 0x03, 0x00, 0x02, 0x00,
312 	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
313 };
314 
315 /*
316  * these macros call the proper transport-layer function given
317  * a particular transport
318  */
319 #define	soc_transport(a, b, c, d) (*a->fcal_ops->fcal_transport)(b, c, d)
320 #define	soc_transport_poll(a, b, c, d)\
321 	(*a->fcal_ops->fcal_transport_poll)(b, c, d)
322 #define	soc_get_lilp_map(a, b, c, d, e)\
323 	(*a->fcal_ops->fcal_lilp_map)(b, c, d, e)
324 #define	soc_force_lip(a, b, c, d, e)\
325 	(*a->fcal_ops->fcal_force_lip)(b, c, d, e)
326 #define	soc_abort(a, b, c, d, e)\
327 	(*a->fcal_ops->fcal_abort_cmd)(b, c, d, e)
328 #define	soc_force_reset(a, b, c, d)\
329 	(*a->fcal_ops->fcal_force_reset)(b, c, d)
330 #define	soc_add_ulp(a, b, c, d, e, f, g, h)\
331 	(*a->fcal_ops->fcal_add_ulp)(b, c, d, e, f, g, h)
332 #define	soc_remove_ulp(a, b, c, d, e)\
333 	(*a->fcal_ops->fcal_remove_ulp)(b, c, d, e)
334 #define	soc_take_core(a, b) (*a->fcal_ops->fcal_take_core)(b)
335 
336 
337 /* power management property defines (should be in a common include file?) */
338 #define	PM_HARDWARE_STATE_PROP		"pm-hardware-state"
339 #define	PM_NEEDS_SUSPEND_RESUME		"needs-suspend-resume"
340 
341 
342 /* node properties */
343 #define	NODE_WWN_PROP			"node-wwn"
344 #define	PORT_WWN_PROP			"port-wwn"
345 #define	LIP_CNT_PROP			"lip-count"
346 #define	TARGET_PROP			"target"
347 #define	LUN_PROP			"lun"
348 
349 
350 /*
351  * initialize this driver and install this module
352  */
353 int
354 _init(void)
355 {
356 	int	i;
357 
358 	i = ddi_soft_state_init(&sf_state, sizeof (struct sf),
359 	    SF_INIT_ITEMS);
360 	if (i != 0)
361 		return (i);
362 
363 	if ((i = scsi_hba_init(&modlinkage)) != 0) {
364 		ddi_soft_state_fini(&sf_state);
365 		return (i);
366 	}
367 
368 	mutex_init(&sf_global_mutex, NULL, MUTEX_DRIVER, NULL);
369 	sf_watch_running = 0;
370 	cv_init(&sf_watch_cv, NULL, CV_DRIVER, NULL);
371 
372 	if ((i = mod_install(&modlinkage)) != 0) {
373 		mutex_destroy(&sf_global_mutex);
374 		cv_destroy(&sf_watch_cv);
375 		scsi_hba_fini(&modlinkage);
376 		ddi_soft_state_fini(&sf_state);
377 		return (i);
378 	}
379 
380 	return (i);
381 }
382 
383 
384 /*
385  * remove this driver module from the system
386  */
387 int
388 _fini(void)
389 {
390 	int	i;
391 
392 	if ((i = mod_remove(&modlinkage)) == 0) {
393 		scsi_hba_fini(&modlinkage);
394 		mutex_destroy(&sf_global_mutex);
395 		cv_destroy(&sf_watch_cv);
396 		ddi_soft_state_fini(&sf_state);
397 	}
398 	return (i);
399 }
400 
401 
402 int
403 _info(struct modinfo *modinfop)
404 {
405 	return (mod_info(&modlinkage, modinfop));
406 }
407 
408 /*
409  * Given the device number return the devinfo pointer or instance
410  */
411 /*ARGSUSED*/
412 static int
413 sf_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
414 {
415 	int		instance = SF_MINOR2INST(getminor((dev_t)arg));
416 	struct sf	*sf;
417 
418 	switch (infocmd) {
419 	case DDI_INFO_DEVT2DEVINFO:
420 		sf = ddi_get_soft_state(sf_state, instance);
421 		if (sf != NULL)
422 			*result = sf->sf_dip;
423 		else {
424 			*result = NULL;
425 			return (DDI_FAILURE);
426 		}
427 		break;
428 
429 	case DDI_INFO_DEVT2INSTANCE:
430 		*result = (void *)(uintptr_t)instance;
431 		break;
432 	default:
433 		return (DDI_FAILURE);
434 	}
435 	return (DDI_SUCCESS);
436 }
437 
438 /*
439  * either attach or resume this driver
440  */
441 static int
442 sf_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
443 {
444 	int instance;
445 	int mutex_initted = FALSE;
446 	uint_t ccount;
447 	size_t i, real_size;
448 	struct fcal_transport *handle;
449 	char buf[64];
450 	struct sf *sf, *tsf;
451 	scsi_hba_tran_t *tran = NULL;
452 	int	handle_bound = FALSE;
453 	kthread_t *tp;
454 
455 
456 	switch ((int)cmd) {
457 
458 	case DDI_RESUME:
459 
460 		/*
461 		 * we've previously been SF_STATE_OFFLINEd by a DDI_SUSPEND,
462 		 * so time to undo that and get going again by forcing a
463 		 * lip
464 		 */
465 
466 		instance = ddi_get_instance(dip);
467 
468 		sf = ddi_get_soft_state(sf_state, instance);
469 		SF_DEBUG(2, (sf, CE_CONT,
470 		    "sf_attach: DDI_RESUME for sf%d\n", instance));
471 		if (sf == NULL) {
472 			cmn_err(CE_WARN, "sf%d: bad soft state", instance);
473 			return (DDI_FAILURE);
474 		}
475 
476 		/*
477 		 * clear suspended flag so that normal operations can resume
478 		 */
479 		mutex_enter(&sf->sf_mutex);
480 		sf->sf_state &= ~SF_STATE_SUSPENDED;
481 		mutex_exit(&sf->sf_mutex);
482 
483 		/*
484 		 * force a login by setting our state to offline
485 		 */
486 		sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
487 		sf->sf_state = SF_STATE_OFFLINE;
488 
489 		/*
490 		 * call transport routine to register state change and
491 		 * ELS callback routines (to register us as a ULP)
492 		 */
493 		soc_add_ulp(sf->sf_sochandle, sf->sf_socp,
494 		    sf->sf_sochandle->fcal_portno, TYPE_SCSI_FCP,
495 		    sf_statec_callback, sf_unsol_els_callback, NULL, sf);
496 
497 		/*
498 		 * call transport routine to force loop initialization
499 		 */
500 		(void) soc_force_lip(sf->sf_sochandle, sf->sf_socp,
501 		    sf->sf_sochandle->fcal_portno, 0, FCAL_NO_LIP);
502 
503 		/*
504 		 * increment watchdog init flag, setting watchdog timeout
505 		 * if we are the first (since somebody has to do it)
506 		 */
507 		mutex_enter(&sf_global_mutex);
508 		if (!sf_watchdog_init++) {
509 			mutex_exit(&sf_global_mutex);
510 			sf_watchdog_id = timeout(sf_watch,
511 			    (caddr_t)0, sf_watchdog_tick);
512 		} else {
513 			mutex_exit(&sf_global_mutex);
514 		}
515 
516 		return (DDI_SUCCESS);
517 
518 	case DDI_ATTACH:
519 
520 		/*
521 		 * this instance attaching for the first time
522 		 */
523 
524 		instance = ddi_get_instance(dip);
525 
526 		if (ddi_soft_state_zalloc(sf_state, instance) !=
527 		    DDI_SUCCESS) {
528 			cmn_err(CE_WARN, "sf%d: failed to allocate soft state",
529 			    instance);
530 			return (DDI_FAILURE);
531 		}
532 
533 		sf = ddi_get_soft_state(sf_state, instance);
534 		SF_DEBUG(4, (sf, CE_CONT,
535 		    "sf_attach: DDI_ATTACH for sf%d\n", instance));
536 		if (sf == NULL) {
537 			/* this shouldn't happen since we just allocated it */
538 			cmn_err(CE_WARN, "sf%d: bad soft state", instance);
539 			return (DDI_FAILURE);
540 		}
541 
542 		/*
543 		 * from this point on, if there's an error, we must de-allocate
544 		 * soft state before returning DDI_FAILURE
545 		 */
546 
547 		if ((handle = ddi_get_parent_data(dip)) == NULL) {
548 			cmn_err(CE_WARN,
549 			    "sf%d: failed to obtain transport handle",
550 			    instance);
551 			goto fail;
552 		}
553 
554 		/* fill in our soft state structure */
555 		sf->sf_dip = dip;
556 		sf->sf_state = SF_STATE_INIT;
557 		sf->sf_throttle = handle->fcal_cmdmax;
558 		sf->sf_sochandle = handle;
559 		sf->sf_socp = handle->fcal_handle;
560 		sf->sf_check_n_close = 0;
561 
562 		/* create a command/response buffer pool for this instance */
563 		if (sf_add_cr_pool(sf) != DDI_SUCCESS) {
564 			cmn_err(CE_WARN,
565 			    "sf%d: failed to allocate command/response pool",
566 			    instance);
567 			goto fail;
568 		}
569 
570 		/* create a a cache for this instance */
571 		(void) sprintf(buf, "sf%d_cache", instance);
572 		sf->sf_pkt_cache = kmem_cache_create(buf,
573 		    sizeof (fcal_packet_t) + sizeof (struct sf_pkt) +
574 		    scsi_pkt_size(), 8,
575 		    sf_kmem_cache_constructor, sf_kmem_cache_destructor,
576 		    NULL, NULL, NULL, 0);
577 		if (sf->sf_pkt_cache == NULL) {
578 			cmn_err(CE_WARN, "sf%d: failed to allocate kmem cache",
579 			    instance);
580 			goto fail;
581 		}
582 
583 		/* set up a handle and allocate memory for DMA */
584 		if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->
585 		    fcal_dmaattr, DDI_DMA_DONTWAIT, NULL, &sf->
586 		    sf_lilp_dmahandle) != DDI_SUCCESS) {
587 			cmn_err(CE_WARN,
588 			    "sf%d: failed to allocate dma handle for lilp map",
589 			    instance);
590 			goto fail;
591 		}
592 		i = sizeof (struct fcal_lilp_map) + 1;
593 		if (ddi_dma_mem_alloc(sf->sf_lilp_dmahandle,
594 		    i, sf->sf_sochandle->
595 		    fcal_accattr, DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
596 		    (caddr_t *)&sf->sf_lilp_map, &real_size,
597 		    &sf->sf_lilp_acchandle) != DDI_SUCCESS) {
598 			cmn_err(CE_WARN, "sf%d: failed to allocate lilp map",
599 			    instance);
600 			goto fail;
601 		}
602 		if (real_size < i) {
603 			/* no error message ??? */
604 			goto fail;		/* trouble allocating memory */
605 		}
606 
607 		/*
608 		 * set up the address for the DMA transfers (getting a cookie)
609 		 */
610 		if (ddi_dma_addr_bind_handle(sf->sf_lilp_dmahandle, NULL,
611 		    (caddr_t)sf->sf_lilp_map, real_size,
612 		    DDI_DMA_READ | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL,
613 		    &sf->sf_lilp_dmacookie, &ccount) != DDI_DMA_MAPPED) {
614 			cmn_err(CE_WARN,
615 			    "sf%d: failed to bind dma handle for lilp map",
616 			    instance);
617 			goto fail;
618 		}
619 		handle_bound = TRUE;
620 		/* ensure only one cookie was allocated */
621 		if (ccount != 1) {
622 			goto fail;
623 		}
624 
625 		/* ensure LILP map and DMA cookie addresses are even?? */
626 		sf->sf_lilp_map = (struct fcal_lilp_map *)(((uintptr_t)sf->
627 		    sf_lilp_map + 1) & ~1);
628 		sf->sf_lilp_dmacookie.dmac_address = (sf->
629 		    sf_lilp_dmacookie.dmac_address + 1) & ~1;
630 
631 		/* set up all of our mutexes and condition variables */
632 		mutex_init(&sf->sf_mutex, NULL, MUTEX_DRIVER, NULL);
633 		mutex_init(&sf->sf_cmd_mutex, NULL, MUTEX_DRIVER, NULL);
634 		mutex_init(&sf->sf_cr_mutex, NULL, MUTEX_DRIVER, NULL);
635 		mutex_init(&sf->sf_hp_daemon_mutex, NULL, MUTEX_DRIVER, NULL);
636 		cv_init(&sf->sf_cr_cv, NULL, CV_DRIVER, NULL);
637 		cv_init(&sf->sf_hp_daemon_cv, NULL, CV_DRIVER, NULL);
638 
639 		mutex_initted = TRUE;
640 
641 		/* create our devctl minor node */
642 		if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
643 		    SF_INST2DEVCTL_MINOR(instance),
644 		    DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
645 			cmn_err(CE_WARN, "sf%d: ddi_create_minor_node failed"
646 			    " for devctl", instance);
647 			goto fail;
648 		}
649 
650 		/* create fc minor node */
651 		if (ddi_create_minor_node(dip, "fc", S_IFCHR,
652 		    SF_INST2FC_MINOR(instance), DDI_NT_FC_ATTACHMENT_POINT,
653 		    0) != DDI_SUCCESS) {
654 			cmn_err(CE_WARN, "sf%d: ddi_create_minor_node failed"
655 			    " for fc", instance);
656 			goto fail;
657 		}
658 		/* allocate a SCSI transport structure */
659 		tran = scsi_hba_tran_alloc(dip, 0);
660 		if (tran == NULL) {
661 			/* remove all minor nodes created */
662 			ddi_remove_minor_node(dip, NULL);
663 			cmn_err(CE_WARN, "sf%d: scsi_hba_tran_alloc failed",
664 			    instance);
665 			goto fail;
666 		}
667 
668 		/* Indicate that we are 'sizeof (scsi_*(9S))' clean. */
669 		scsi_size_clean(dip);		/* SCSI_SIZE_CLEAN_VERIFY ok */
670 
671 		/* save ptr to new transport structure and fill it in */
672 		sf->sf_tran = tran;
673 
674 		tran->tran_hba_private		= sf;
675 		tran->tran_tgt_private		= NULL;
676 		tran->tran_tgt_init		= sf_scsi_tgt_init;
677 		tran->tran_tgt_probe		= NULL;
678 		tran->tran_tgt_free		= sf_scsi_tgt_free;
679 
680 		tran->tran_start		= sf_start;
681 		tran->tran_abort		= sf_abort;
682 		tran->tran_reset		= sf_reset;
683 		tran->tran_getcap		= sf_getcap;
684 		tran->tran_setcap		= sf_setcap;
685 		tran->tran_init_pkt		= sf_scsi_init_pkt;
686 		tran->tran_destroy_pkt		= sf_scsi_destroy_pkt;
687 		tran->tran_dmafree		= sf_scsi_dmafree;
688 		tran->tran_sync_pkt		= sf_scsi_sync_pkt;
689 		tran->tran_reset_notify		= sf_scsi_reset_notify;
690 
691 		/*
692 		 * register event notification routines with scsa
693 		 */
694 		tran->tran_get_eventcookie	= sf_bus_get_eventcookie;
695 		tran->tran_add_eventcall	= sf_bus_add_eventcall;
696 		tran->tran_remove_eventcall	= sf_bus_remove_eventcall;
697 		tran->tran_post_event		= sf_bus_post_event;
698 
699 		/*
700 		 * register bus configure/unconfigure
701 		 */
702 		tran->tran_bus_config		= sf_scsi_bus_config;
703 		tran->tran_bus_unconfig		= sf_scsi_bus_unconfig;
704 
705 		/*
706 		 * allocate an ndi event handle
707 		 */
708 		sf->sf_event_defs = (ndi_event_definition_t *)
709 		    kmem_zalloc(sizeof (sf_event_defs), KM_SLEEP);
710 
711 		bcopy(sf_event_defs, sf->sf_event_defs,
712 		    sizeof (sf_event_defs));
713 
714 		(void) ndi_event_alloc_hdl(dip, NULL,
715 		    &sf->sf_event_hdl, NDI_SLEEP);
716 
717 		sf->sf_events.ndi_events_version = NDI_EVENTS_REV1;
718 		sf->sf_events.ndi_n_events = SF_N_NDI_EVENTS;
719 		sf->sf_events.ndi_event_defs = sf->sf_event_defs;
720 
721 		if (ndi_event_bind_set(sf->sf_event_hdl,
722 		    &sf->sf_events, NDI_SLEEP) != NDI_SUCCESS) {
723 			goto fail;
724 		}
725 
726 		tran->tran_get_name		= sf_scsi_get_name;
727 		tran->tran_get_bus_addr		= sf_scsi_get_bus_addr;
728 
729 		/* setup and attach SCSI hba transport */
730 		if (scsi_hba_attach_setup(dip, sf->sf_sochandle->
731 		    fcal_dmaattr, tran, SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) {
732 			cmn_err(CE_WARN, "sf%d: scsi_hba_attach_setup failed",
733 			    instance);
734 			goto fail;
735 		}
736 
737 		/* set up kstats */
738 		if ((sf->sf_ksp = kstat_create("sf", instance, "statistics",
739 		    "controller", KSTAT_TYPE_RAW, sizeof (struct sf_stats),
740 		    KSTAT_FLAG_VIRTUAL)) == NULL) {
741 			cmn_err(CE_WARN, "sf%d: failed to create kstat",
742 			    instance);
743 		} else {
744 			sf->sf_stats.version = 2;
745 			(void) sprintf(sf->sf_stats.drvr_name,
746 			"%s: %s", SF_NAME, sf_version);
747 			sf->sf_ksp->ks_data = (void *)&sf->sf_stats;
748 			sf->sf_ksp->ks_private = sf;
749 			sf->sf_ksp->ks_update = sf_kstat_update;
750 			kstat_install(sf->sf_ksp);
751 		}
752 
753 		/* create the hotplug thread */
754 		mutex_enter(&sf->sf_hp_daemon_mutex);
755 		tp = thread_create(NULL, 0,
756 		    (void (*)())sf_hp_daemon, sf, 0, &p0, TS_RUN, minclsyspri);
757 		sf->sf_hp_tid = tp->t_did;
758 		mutex_exit(&sf->sf_hp_daemon_mutex);
759 
760 		/* add this soft state instance to the head of the list */
761 		mutex_enter(&sf_global_mutex);
762 		sf->sf_next = sf_head;
763 		tsf = sf_head;
764 		sf_head = sf;
765 
766 		/*
767 		 * find entry in list that has the same FC-AL handle (if any)
768 		 */
769 		while (tsf != NULL) {
770 			if (tsf->sf_socp == sf->sf_socp) {
771 				break;		/* found matching entry */
772 			}
773 			tsf = tsf->sf_next;
774 		}
775 
776 		if (tsf != NULL) {
777 			/* if we found a matching entry keep track of it */
778 			sf->sf_sibling = tsf;
779 		}
780 
781 		/*
782 		 * increment watchdog init flag, setting watchdog timeout
783 		 * if we are the first (since somebody has to do it)
784 		 */
785 		if (!sf_watchdog_init++) {
786 			mutex_exit(&sf_global_mutex);
787 			sf_watchdog_tick = sf_watchdog_timeout *
788 			    drv_usectohz(1000000);
789 			sf_watchdog_id = timeout(sf_watch,
790 			    NULL, sf_watchdog_tick);
791 		} else {
792 			mutex_exit(&sf_global_mutex);
793 		}
794 
795 		if (tsf != NULL) {
796 			/*
797 			 * set up matching entry to be our sibling
798 			 */
799 			mutex_enter(&tsf->sf_mutex);
800 			tsf->sf_sibling = sf;
801 			mutex_exit(&tsf->sf_mutex);
802 		}
803 
804 		/*
805 		 * create this property so that PM code knows we want
806 		 * to be suspended at PM time
807 		 */
808 		(void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
809 		    PM_HARDWARE_STATE_PROP, PM_NEEDS_SUSPEND_RESUME);
810 
811 		/* log the fact that we have a new device */
812 		ddi_report_dev(dip);
813 
814 		/*
815 		 * force a login by setting our state to offline
816 		 */
817 		sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
818 		sf->sf_state = SF_STATE_OFFLINE;
819 
820 		/*
821 		 * call transport routine to register state change and
822 		 * ELS callback routines (to register us as a ULP)
823 		 */
824 		soc_add_ulp(sf->sf_sochandle, sf->sf_socp,
825 		    sf->sf_sochandle->fcal_portno, TYPE_SCSI_FCP,
826 		    sf_statec_callback, sf_unsol_els_callback, NULL, sf);
827 
828 		/*
829 		 * call transport routine to force loop initialization
830 		 */
831 		(void) soc_force_lip(sf->sf_sochandle, sf->sf_socp,
832 		    sf->sf_sochandle->fcal_portno, 0, FCAL_NO_LIP);
833 		sf->sf_reset_time = ddi_get_lbolt64();
834 		return (DDI_SUCCESS);
835 
836 	default:
837 		return (DDI_FAILURE);
838 	}
839 
840 fail:
841 	cmn_err(CE_WARN, "sf%d: failed to attach", instance);
842 
843 	/*
844 	 * Unbind and free event set
845 	 */
846 	if (sf->sf_event_hdl) {
847 		(void) ndi_event_unbind_set(sf->sf_event_hdl,
848 		    &sf->sf_events, NDI_SLEEP);
849 		(void) ndi_event_free_hdl(sf->sf_event_hdl);
850 	}
851 
852 	if (sf->sf_event_defs) {
853 		kmem_free(sf->sf_event_defs, sizeof (sf_event_defs));
854 	}
855 
856 	if (sf->sf_tran != NULL) {
857 		scsi_hba_tran_free(sf->sf_tran);
858 	}
859 	while (sf->sf_cr_pool != NULL) {
860 		sf_crpool_free(sf);
861 	}
862 	if (sf->sf_lilp_dmahandle != NULL) {
863 		if (handle_bound) {
864 			(void) ddi_dma_unbind_handle(sf->sf_lilp_dmahandle);
865 		}
866 		ddi_dma_free_handle(&sf->sf_lilp_dmahandle);
867 	}
868 	if (sf->sf_pkt_cache != NULL) {
869 		kmem_cache_destroy(sf->sf_pkt_cache);
870 	}
871 	if (sf->sf_lilp_map != NULL) {
872 		ddi_dma_mem_free(&sf->sf_lilp_acchandle);
873 	}
874 	if (sf->sf_ksp != NULL) {
875 		kstat_delete(sf->sf_ksp);
876 	}
877 	if (mutex_initted) {
878 		mutex_destroy(&sf->sf_mutex);
879 		mutex_destroy(&sf->sf_cmd_mutex);
880 		mutex_destroy(&sf->sf_cr_mutex);
881 		mutex_destroy(&sf->sf_hp_daemon_mutex);
882 		cv_destroy(&sf->sf_cr_cv);
883 		cv_destroy(&sf->sf_hp_daemon_cv);
884 	}
885 	mutex_enter(&sf_global_mutex);
886 
887 	/*
888 	 * kill off the watchdog if we are the last instance
889 	 */
890 	if (!--sf_watchdog_init) {
891 		timeout_id_t tid = sf_watchdog_id;
892 		mutex_exit(&sf_global_mutex);
893 		(void) untimeout(tid);
894 	} else {
895 		mutex_exit(&sf_global_mutex);
896 	}
897 
898 	ddi_soft_state_free(sf_state, instance);
899 
900 	if (tran != NULL) {
901 		/* remove all minor nodes */
902 		ddi_remove_minor_node(dip, NULL);
903 	}
904 
905 	return (DDI_FAILURE);
906 }
907 
908 
909 /* ARGSUSED */
910 static int
911 sf_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
912 {
913 	struct sf		*sf;
914 	int			instance;
915 	int			i;
916 	struct sf_target	*target;
917 	timeout_id_t		tid;
918 
919 
920 
921 	/* NO OTHER THREADS ARE RUNNING */
922 
923 	instance = ddi_get_instance(dip);
924 
925 	if ((sf = ddi_get_soft_state(sf_state, instance)) == NULL) {
926 		cmn_err(CE_WARN, "sf_detach, sf%d: bad soft state", instance);
927 		return (DDI_FAILURE);
928 	}
929 
930 	switch (cmd) {
931 
932 	case DDI_SUSPEND:
933 		/*
934 		 * suspend our instance
935 		 */
936 
937 		SF_DEBUG(2, (sf, CE_CONT,
938 		    "sf_detach: DDI_SUSPEND for sf%d\n", instance));
939 		/*
940 		 * There is a race condition in socal where while doing
941 		 * callbacks if a ULP removes it self from the callback list
942 		 * the for loop in socal may panic as cblist is junk and
943 		 * while trying to get cblist->next the system will panic.
944 		 */
945 
946 		/* call transport to remove our unregister our callbacks */
947 		soc_remove_ulp(sf->sf_sochandle, sf->sf_socp,
948 		    sf->sf_sochandle->fcal_portno, TYPE_SCSI_FCP, sf);
949 
950 		/*
951 		 * begin process of clearing outstanding commands
952 		 * by issuing a lip
953 		 */
954 		sf_force_lip(sf);
955 
956 		/*
957 		 * toggle the device OFFLINE in order to cause
958 		 * outstanding commands to drain
959 		 */
960 		mutex_enter(&sf->sf_mutex);
961 		sf->sf_lip_cnt++;
962 		sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
963 		sf->sf_state = (SF_STATE_OFFLINE | SF_STATE_SUSPENDED);
964 		for (i = 0; i < sf_max_targets; i++) {
965 			target = sf->sf_targets[i];
966 			if (target != NULL) {
967 				struct sf_target *ntarget;
968 
969 				mutex_enter(&target->sft_mutex);
970 				if (!(target->sft_state & SF_TARGET_OFFLINE)) {
971 					target->sft_state |=
972 					    (SF_TARGET_BUSY | SF_TARGET_MARK);
973 				}
974 				/* do this for all LUNs as well */
975 				for (ntarget = target->sft_next_lun;
976 				    ntarget;
977 				    ntarget = ntarget->sft_next_lun) {
978 					mutex_enter(&ntarget->sft_mutex);
979 					if (!(ntarget->sft_state &
980 					    SF_TARGET_OFFLINE)) {
981 						ntarget->sft_state |=
982 						    (SF_TARGET_BUSY |
983 						    SF_TARGET_MARK);
984 					}
985 					mutex_exit(&ntarget->sft_mutex);
986 				}
987 				mutex_exit(&target->sft_mutex);
988 			}
989 		}
990 		mutex_exit(&sf->sf_mutex);
991 		mutex_enter(&sf_global_mutex);
992 
993 		/*
994 		 * kill off the watchdog if we are the last instance
995 		 */
996 		if (!--sf_watchdog_init) {
997 			tid = sf_watchdog_id;
998 			mutex_exit(&sf_global_mutex);
999 			(void) untimeout(tid);
1000 		} else {
1001 			mutex_exit(&sf_global_mutex);
1002 		}
1003 
1004 		return (DDI_SUCCESS);
1005 
1006 	case DDI_DETACH:
1007 		/*
1008 		 * detach this instance
1009 		 */
1010 
1011 		SF_DEBUG(2, (sf, CE_CONT,
1012 		    "sf_detach: DDI_DETACH for sf%d\n", instance));
1013 
1014 		/* remove this "sf" from the list of sf softstates */
1015 		sf_softstate_unlink(sf);
1016 
1017 		/*
1018 		 * prior to taking any DDI_DETACH actions, toggle the
1019 		 * device OFFLINE in order to cause outstanding
1020 		 * commands to drain
1021 		 */
1022 		mutex_enter(&sf->sf_mutex);
1023 		sf->sf_lip_cnt++;
1024 		sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
1025 		sf->sf_state = SF_STATE_OFFLINE;
1026 		for (i = 0; i < sf_max_targets; i++) {
1027 			target = sf->sf_targets[i];
1028 			if (target != NULL) {
1029 				struct sf_target *ntarget;
1030 
1031 				mutex_enter(&target->sft_mutex);
1032 				if (!(target->sft_state & SF_TARGET_OFFLINE)) {
1033 					target->sft_state |=
1034 					    (SF_TARGET_BUSY | SF_TARGET_MARK);
1035 				}
1036 				for (ntarget = target->sft_next_lun;
1037 				    ntarget;
1038 				    ntarget = ntarget->sft_next_lun) {
1039 					mutex_enter(&ntarget->sft_mutex);
1040 					if (!(ntarget->sft_state &
1041 					    SF_TARGET_OFFLINE)) {
1042 						ntarget->sft_state |=
1043 						    (SF_TARGET_BUSY |
1044 						    SF_TARGET_MARK);
1045 					}
1046 					mutex_exit(&ntarget->sft_mutex);
1047 				}
1048 				mutex_exit(&target->sft_mutex);
1049 			}
1050 		}
1051 		mutex_exit(&sf->sf_mutex);
1052 
1053 		/* call transport to remove and unregister our callbacks */
1054 		soc_remove_ulp(sf->sf_sochandle, sf->sf_socp,
1055 		    sf->sf_sochandle->fcal_portno, TYPE_SCSI_FCP, sf);
1056 
1057 		/*
1058 		 * kill off the watchdog if we are the last instance
1059 		 */
1060 		mutex_enter(&sf_global_mutex);
1061 		if (!--sf_watchdog_init) {
1062 			tid = sf_watchdog_id;
1063 			mutex_exit(&sf_global_mutex);
1064 			(void) untimeout(tid);
1065 		} else {
1066 			mutex_exit(&sf_global_mutex);
1067 		}
1068 
1069 		/* signal sf_hp_daemon() to exit and wait for exit */
1070 		mutex_enter(&sf->sf_hp_daemon_mutex);
1071 		ASSERT(sf->sf_hp_tid);
1072 		sf->sf_hp_exit = 1;		/* flag exit */
1073 		cv_signal(&sf->sf_hp_daemon_cv);
1074 		mutex_exit(&sf->sf_hp_daemon_mutex);
1075 		thread_join(sf->sf_hp_tid);	/* wait for hotplug to exit */
1076 
1077 		/*
1078 		 * Unbind and free event set
1079 		 */
1080 		if (sf->sf_event_hdl) {
1081 			(void) ndi_event_unbind_set(sf->sf_event_hdl,
1082 			    &sf->sf_events, NDI_SLEEP);
1083 			(void) ndi_event_free_hdl(sf->sf_event_hdl);
1084 		}
1085 
1086 		if (sf->sf_event_defs) {
1087 			kmem_free(sf->sf_event_defs, sizeof (sf_event_defs));
1088 		}
1089 
1090 		/* detach this instance of the HBA driver */
1091 		(void) scsi_hba_detach(dip);
1092 		scsi_hba_tran_free(sf->sf_tran);
1093 
1094 		/* deallocate/unbind DMA handle for lilp map */
1095 		if (sf->sf_lilp_map != NULL) {
1096 			(void) ddi_dma_unbind_handle(sf->sf_lilp_dmahandle);
1097 			if (sf->sf_lilp_dmahandle != NULL) {
1098 				ddi_dma_free_handle(&sf->sf_lilp_dmahandle);
1099 			}
1100 			ddi_dma_mem_free(&sf->sf_lilp_acchandle);
1101 		}
1102 
1103 		/*
1104 		 * the kmem cache must be destroyed before free'ing
1105 		 * up the crpools
1106 		 *
1107 		 * our finagle of "ntot" and "nfree"
1108 		 * causes an ASSERT failure in "sf_cr_free()"
1109 		 * if the kmem cache is free'd after invoking
1110 		 * "sf_crpool_free()".
1111 		 */
1112 		kmem_cache_destroy(sf->sf_pkt_cache);
1113 
1114 		SF_DEBUG(2, (sf, CE_CONT,
1115 		    "sf_detach: sf_crpool_free() for instance 0x%x\n",
1116 		    instance));
1117 		while (sf->sf_cr_pool != NULL) {
1118 			/*
1119 			 * set ntot to nfree for this particular entry
1120 			 *
1121 			 * this causes sf_crpool_free() to update
1122 			 * the cr_pool list when deallocating this entry
1123 			 */
1124 			sf->sf_cr_pool->ntot = sf->sf_cr_pool->nfree;
1125 			sf_crpool_free(sf);
1126 		}
1127 
1128 		/*
1129 		 * now that the cr_pool's are gone it's safe
1130 		 * to destroy all softstate mutex's and cv's
1131 		 */
1132 		mutex_destroy(&sf->sf_mutex);
1133 		mutex_destroy(&sf->sf_cmd_mutex);
1134 		mutex_destroy(&sf->sf_cr_mutex);
1135 		mutex_destroy(&sf->sf_hp_daemon_mutex);
1136 		cv_destroy(&sf->sf_cr_cv);
1137 		cv_destroy(&sf->sf_hp_daemon_cv);
1138 
1139 		/* remove all minor nodes from the device tree */
1140 		ddi_remove_minor_node(dip, NULL);
1141 
1142 		/* remove properties created during attach() */
1143 		ddi_prop_remove_all(dip);
1144 
1145 		/* remove kstat's if present */
1146 		if (sf->sf_ksp != NULL) {
1147 			kstat_delete(sf->sf_ksp);
1148 		}
1149 
1150 		SF_DEBUG(2, (sf, CE_CONT,
1151 		    "sf_detach: ddi_soft_state_free() for instance 0x%x\n",
1152 		    instance));
1153 		ddi_soft_state_free(sf_state, instance);
1154 		return (DDI_SUCCESS);
1155 
1156 	default:
1157 		SF_DEBUG(2, (sf, CE_CONT, "sf_detach: sf%d unknown cmd %x\n",
1158 		    instance, (int)cmd));
1159 		return (DDI_FAILURE);
1160 	}
1161 }
1162 
1163 
1164 /*
1165  * sf_softstate_unlink() - remove an sf instance from the list of softstates
1166  */
1167 static void
1168 sf_softstate_unlink(struct sf *sf)
1169 {
1170 	struct sf	*sf_ptr;
1171 	struct sf	*sf_found_sibling;
1172 	struct sf	*sf_reposition = NULL;
1173 
1174 
1175 	mutex_enter(&sf_global_mutex);
1176 	while (sf_watch_running) {
1177 		/* Busy working the list -- wait */
1178 		cv_wait(&sf_watch_cv, &sf_global_mutex);
1179 	}
1180 	if ((sf_found_sibling = sf->sf_sibling) != NULL) {
1181 		/*
1182 		 * we have a sibling so NULL out its reference to us
1183 		 */
1184 		mutex_enter(&sf_found_sibling->sf_mutex);
1185 		sf_found_sibling->sf_sibling = NULL;
1186 		mutex_exit(&sf_found_sibling->sf_mutex);
1187 	}
1188 
1189 	/* remove our instance from the global list */
1190 	if (sf == sf_head) {
1191 		/* we were at at head of the list */
1192 		sf_head = sf->sf_next;
1193 	} else {
1194 		/* find us in the list */
1195 		for (sf_ptr = sf_head;
1196 		    sf_ptr != NULL;
1197 		    sf_ptr = sf_ptr->sf_next) {
1198 			if (sf_ptr == sf) {
1199 				break;
1200 			}
1201 			/* remember this place */
1202 			sf_reposition = sf_ptr;
1203 		}
1204 		ASSERT(sf_ptr == sf);
1205 		ASSERT(sf_reposition != NULL);
1206 
1207 		sf_reposition->sf_next = sf_ptr->sf_next;
1208 	}
1209 	mutex_exit(&sf_global_mutex);
1210 }
1211 
1212 
1213 static int
1214 sf_scsi_bus_config(dev_info_t *parent, uint_t flag,
1215     ddi_bus_config_op_t op, void *arg, dev_info_t **childp)
1216 {
1217 	int64_t		reset_delay;
1218 	struct sf	*sf;
1219 
1220 	sf = ddi_get_soft_state(sf_state, ddi_get_instance(parent));
1221 	ASSERT(sf);
1222 
1223 	reset_delay = (int64_t)(USEC_TO_TICK(SF_INIT_WAIT_TIMEOUT)) -
1224 	    (ddi_get_lbolt64() - sf->sf_reset_time);
1225 	if (reset_delay < 0)
1226 		reset_delay = 0;
1227 
1228 	if (sf_bus_config_debug)
1229 		flag |= NDI_DEVI_DEBUG;
1230 
1231 	return (ndi_busop_bus_config(parent, flag, op,
1232 	    arg, childp, (clock_t)reset_delay));
1233 }
1234 
1235 static int
1236 sf_scsi_bus_unconfig(dev_info_t *parent, uint_t flag,
1237     ddi_bus_config_op_t op, void *arg)
1238 {
1239 	if (sf_bus_config_debug)
1240 		flag |= NDI_DEVI_DEBUG;
1241 
1242 	return (ndi_busop_bus_unconfig(parent, flag, op, arg));
1243 }
1244 
1245 
1246 /*
1247  * called by transport to initialize a SCSI target
1248  */
1249 /* ARGSUSED */
1250 static int
1251 sf_scsi_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1252     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1253 {
1254 #ifdef RAID_LUNS
1255 	int lun;
1256 #else
1257 	int64_t lun;
1258 #endif
1259 	struct sf_target *target;
1260 	struct sf *sf = (struct sf *)hba_tran->tran_hba_private;
1261 	int i, t_len;
1262 	unsigned int lip_cnt;
1263 	unsigned char wwn[FC_WWN_SIZE];
1264 
1265 
1266 	/* get and validate our SCSI target ID */
1267 	i = sd->sd_address.a_target;
1268 	if (i >= sf_max_targets) {
1269 		return (DDI_NOT_WELL_FORMED);
1270 	}
1271 
1272 	/* get our port WWN property */
1273 	t_len = sizeof (wwn);
1274 	if (ddi_prop_op(DDI_DEV_T_ANY, tgt_dip, PROP_LEN_AND_VAL_BUF,
1275 	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, PORT_WWN_PROP,
1276 	    (caddr_t)&wwn, &t_len) != DDI_SUCCESS) {
1277 		/* no port WWN property - ignore the OBP stub node */
1278 		return (DDI_NOT_WELL_FORMED);
1279 	}
1280 
1281 	/* get our LIP count property */
1282 	t_len = sizeof (lip_cnt);
1283 	if (ddi_prop_op(DDI_DEV_T_ANY, tgt_dip, PROP_LEN_AND_VAL_BUF,
1284 	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, LIP_CNT_PROP,
1285 	    (caddr_t)&lip_cnt, &t_len) != DDI_SUCCESS) {
1286 		return (DDI_FAILURE);
1287 	}
1288 	/* and our LUN property */
1289 	t_len = sizeof (lun);
1290 	if (ddi_prop_op(DDI_DEV_T_ANY, tgt_dip, PROP_LEN_AND_VAL_BUF,
1291 	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "lun",
1292 	    (caddr_t)&lun, &t_len) != DDI_SUCCESS) {
1293 		return (DDI_FAILURE);
1294 	}
1295 
1296 	/* find the target structure for this instance */
1297 	mutex_enter(&sf->sf_mutex);
1298 	if ((target = sf_lookup_target(sf, wwn, lun)) == NULL) {
1299 		mutex_exit(&sf->sf_mutex);
1300 		return (DDI_FAILURE);
1301 	}
1302 
1303 	mutex_enter(&target->sft_mutex);
1304 	if ((sf->sf_lip_cnt == lip_cnt) && !(target->sft_state
1305 	    & SF_TARGET_INIT_DONE)) {
1306 		/*
1307 		 * set links between HBA transport and target structures
1308 		 * and set done flag
1309 		 */
1310 		hba_tran->tran_tgt_private = target;
1311 		target->sft_tran = hba_tran;
1312 		target->sft_state |= SF_TARGET_INIT_DONE;
1313 	} else {
1314 		/* already initialized ?? */
1315 		mutex_exit(&target->sft_mutex);
1316 		mutex_exit(&sf->sf_mutex);
1317 		return (DDI_FAILURE);
1318 	}
1319 	mutex_exit(&target->sft_mutex);
1320 	mutex_exit(&sf->sf_mutex);
1321 
1322 	return (DDI_SUCCESS);
1323 }
1324 
1325 
1326 /*
1327  * called by transport to free a target
1328  */
1329 /* ARGSUSED */
1330 static void
1331 sf_scsi_tgt_free(dev_info_t *hba_dip, dev_info_t *tgt_dip,
1332     scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
1333 {
1334 	struct sf_target *target = hba_tran->tran_tgt_private;
1335 
1336 	if (target != NULL) {
1337 		mutex_enter(&target->sft_mutex);
1338 		target->sft_tran = NULL;
1339 		target->sft_state &= ~SF_TARGET_INIT_DONE;
1340 		mutex_exit(&target->sft_mutex);
1341 	}
1342 }
1343 
1344 
1345 /*
1346  * allocator for non-std size cdb/pkt_private/status -- return TRUE iff
1347  * success, else return FALSE
1348  */
1349 /*ARGSUSED*/
1350 static int
1351 sf_pkt_alloc_extern(struct sf *sf, struct sf_pkt *cmd,
1352     int tgtlen, int statuslen, int kf)
1353 {
1354 	caddr_t scbp, tgt;
1355 	int failure = FALSE;
1356 	struct scsi_pkt *pkt = CMD2PKT(cmd);
1357 
1358 
1359 	tgt = scbp = NULL;
1360 
1361 	if (tgtlen > PKT_PRIV_LEN) {
1362 		if ((tgt = kmem_zalloc(tgtlen, kf)) == NULL) {
1363 			failure = TRUE;
1364 		} else {
1365 			cmd->cmd_flags |= CFLAG_PRIVEXTERN;
1366 			pkt->pkt_private = tgt;
1367 		}
1368 	}
1369 	if (statuslen > EXTCMDS_STATUS_SIZE) {
1370 		if ((scbp = kmem_zalloc((size_t)statuslen, kf)) == NULL) {
1371 			failure = TRUE;
1372 		} else {
1373 			cmd->cmd_flags |= CFLAG_SCBEXTERN;
1374 			pkt->pkt_scbp = (opaque_t)scbp;
1375 		}
1376 	}
1377 	if (failure) {
1378 		sf_pkt_destroy_extern(sf, cmd);
1379 	}
1380 	return (failure);
1381 }
1382 
1383 
1384 /*
1385  * deallocator for non-std size cdb/pkt_private/status
1386  */
1387 static void
1388 sf_pkt_destroy_extern(struct sf *sf, struct sf_pkt *cmd)
1389 {
1390 	struct scsi_pkt *pkt = CMD2PKT(cmd);
1391 
1392 	if (cmd->cmd_flags & CFLAG_FREE) {
1393 		cmn_err(CE_PANIC,
1394 		    "sf_scsi_impl_pktfree: freeing free packet");
1395 		_NOTE(NOT_REACHED)
1396 		/* NOTREACHED */
1397 	}
1398 	if (cmd->cmd_flags & CFLAG_SCBEXTERN) {
1399 		kmem_free((caddr_t)pkt->pkt_scbp,
1400 		    (size_t)cmd->cmd_scblen);
1401 	}
1402 	if (cmd->cmd_flags & CFLAG_PRIVEXTERN) {
1403 		kmem_free((caddr_t)pkt->pkt_private,
1404 		    (size_t)cmd->cmd_privlen);
1405 	}
1406 
1407 	cmd->cmd_flags = CFLAG_FREE;
1408 	kmem_cache_free(sf->sf_pkt_cache, (void *)cmd);
1409 }
1410 
1411 
1412 /*
1413  * create or initialize a SCSI packet -- called internally and
1414  * by the transport
1415  */
1416 static struct scsi_pkt *
1417 sf_scsi_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt,
1418     struct buf *bp, int cmdlen, int statuslen, int tgtlen,
1419     int flags, int (*callback)(), caddr_t arg)
1420 {
1421 	int kf;
1422 	int failure = FALSE;
1423 	struct sf_pkt *cmd;
1424 	struct sf *sf = ADDR2SF(ap);
1425 	struct sf_target *target = ADDR2TARGET(ap);
1426 	struct sf_pkt	*new_cmd = NULL;
1427 	struct fcal_packet	*fpkt;
1428 	fc_frame_header_t	*hp;
1429 	struct fcp_cmd *fcmd;
1430 
1431 
1432 	/*
1433 	 * If we've already allocated a pkt once,
1434 	 * this request is for dma allocation only.
1435 	 */
1436 	if (pkt == NULL) {
1437 
1438 		/*
1439 		 * First step of sf_scsi_init_pkt:  pkt allocation
1440 		 */
1441 		if (cmdlen > FCP_CDB_SIZE) {
1442 			return (NULL);
1443 		}
1444 
1445 		kf = (callback == SLEEP_FUNC)? KM_SLEEP: KM_NOSLEEP;
1446 
1447 		if ((cmd = kmem_cache_alloc(sf->sf_pkt_cache, kf)) != NULL) {
1448 			/*
1449 			 * Selective zeroing of the pkt.
1450 			 */
1451 
1452 			cmd->cmd_flags = 0;
1453 			cmd->cmd_forw = 0;
1454 			cmd->cmd_back = 0;
1455 			cmd->cmd_next = 0;
1456 			cmd->cmd_pkt = (struct scsi_pkt *)((char *)cmd +
1457 			    sizeof (struct sf_pkt) + sizeof (struct
1458 			    fcal_packet));
1459 			cmd->cmd_fp_pkt = (struct fcal_packet *)((char *)cmd +
1460 			    sizeof (struct sf_pkt));
1461 			cmd->cmd_fp_pkt->fcal_pkt_private = (opaque_t)cmd;
1462 			cmd->cmd_state = SF_STATE_IDLE;
1463 			cmd->cmd_pkt->pkt_ha_private = (opaque_t)cmd;
1464 			cmd->cmd_pkt->pkt_scbp = (opaque_t)cmd->cmd_scsi_scb;
1465 			cmd->cmd_pkt->pkt_comp	= NULL;
1466 			cmd->cmd_pkt->pkt_flags	= 0;
1467 			cmd->cmd_pkt->pkt_time	= 0;
1468 			cmd->cmd_pkt->pkt_resid	= 0;
1469 			cmd->cmd_pkt->pkt_reason = 0;
1470 			cmd->cmd_cdblen = (uchar_t)cmdlen;
1471 			cmd->cmd_scblen		= statuslen;
1472 			cmd->cmd_privlen	= tgtlen;
1473 			cmd->cmd_pkt->pkt_address = *ap;
1474 
1475 			/* zero pkt_private */
1476 			(int *)(cmd->cmd_pkt->pkt_private =
1477 			    cmd->cmd_pkt_private);
1478 			bzero((caddr_t)cmd->cmd_pkt->pkt_private,
1479 			    PKT_PRIV_LEN);
1480 		} else {
1481 			failure = TRUE;
1482 		}
1483 
1484 		if (failure ||
1485 		    (tgtlen > PKT_PRIV_LEN) ||
1486 		    (statuslen > EXTCMDS_STATUS_SIZE)) {
1487 			if (!failure) {
1488 				/* need to allocate more space */
1489 				failure = sf_pkt_alloc_extern(sf, cmd,
1490 				    tgtlen, statuslen, kf);
1491 			}
1492 			if (failure) {
1493 				return (NULL);
1494 			}
1495 		}
1496 
1497 		fpkt = cmd->cmd_fp_pkt;
1498 		if (cmd->cmd_block == NULL) {
1499 
1500 			/* allocate cmd/response pool buffers */
1501 			if (sf_cr_alloc(sf, cmd, callback) == DDI_FAILURE) {
1502 				sf_pkt_destroy_extern(sf, cmd);
1503 				return (NULL);
1504 			}
1505 
1506 			/* fill in the FC-AL packet */
1507 			fpkt->fcal_pkt_cookie = sf->sf_socp;
1508 			fpkt->fcal_pkt_comp = sf_cmd_callback;
1509 			fpkt->fcal_pkt_flags = 0;
1510 			fpkt->fcal_magic = FCALP_MAGIC;
1511 			fpkt->fcal_socal_request.sr_soc_hdr.sh_flags =
1512 			    (ushort_t)(SOC_FC_HEADER |
1513 			    sf->sf_sochandle->fcal_portno);
1514 			fpkt->fcal_socal_request.sr_soc_hdr.sh_class = 3;
1515 			fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_count = 1;
1516 			fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_flags = 0;
1517 			fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_seqno = 0;
1518 			fpkt->fcal_socal_request.sr_dataseg[0].fc_base =
1519 			    (uint32_t)cmd->cmd_dmac;
1520 			fpkt->fcal_socal_request.sr_dataseg[0].fc_count =
1521 			    sizeof (struct fcp_cmd);
1522 			fpkt->fcal_socal_request.sr_dataseg[1].fc_base =
1523 			    (uint32_t)cmd->cmd_rsp_dmac;
1524 			fpkt->fcal_socal_request.sr_dataseg[1].fc_count =
1525 			    FCP_MAX_RSP_IU_SIZE;
1526 
1527 			/* Fill in the Fabric Channel Header */
1528 			hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
1529 			hp->r_ctl = R_CTL_COMMAND;
1530 			hp->type = TYPE_SCSI_FCP;
1531 			hp->f_ctl = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ;
1532 			hp->reserved1 = 0;
1533 			hp->seq_id = 0;
1534 			hp->df_ctl  = 0;
1535 			hp->seq_cnt = 0;
1536 			hp->ox_id = 0xffff;
1537 			hp->rx_id = 0xffff;
1538 			hp->ro = 0;
1539 
1540 			/* Establish the LUN */
1541 			bcopy((caddr_t)&target->sft_lun.b,
1542 			    (caddr_t)&cmd->cmd_block->fcp_ent_addr,
1543 			    FCP_LUN_SIZE);
1544 			*((int32_t *)&cmd->cmd_block->fcp_cntl) = 0;
1545 		}
1546 		cmd->cmd_pkt->pkt_cdbp = cmd->cmd_block->fcp_cdb;
1547 
1548 		mutex_enter(&target->sft_pkt_mutex);
1549 
1550 		target->sft_pkt_tail->cmd_forw = cmd;
1551 		cmd->cmd_back = target->sft_pkt_tail;
1552 		cmd->cmd_forw = (struct sf_pkt *)&target->sft_pkt_head;
1553 		target->sft_pkt_tail = cmd;
1554 
1555 		mutex_exit(&target->sft_pkt_mutex);
1556 		new_cmd = cmd;		/* for later cleanup if needed */
1557 	} else {
1558 		/* pkt already exists -- just a request for DMA allocation */
1559 		cmd = PKT2CMD(pkt);
1560 		fpkt = cmd->cmd_fp_pkt;
1561 	}
1562 
1563 	/* zero cdb (bzero is too slow) */
1564 	bzero((caddr_t)cmd->cmd_pkt->pkt_cdbp, cmdlen);
1565 
1566 	/*
1567 	 * Second step of sf_scsi_init_pkt:  dma allocation
1568 	 * Set up dma info
1569 	 */
1570 	if ((bp != NULL) && (bp->b_bcount != 0)) {
1571 		int cmd_flags, dma_flags;
1572 		int rval = 0;
1573 		uint_t dmacookie_count;
1574 
1575 		/* there is a buffer and some data to transfer */
1576 
1577 		/* set up command and DMA flags */
1578 		cmd_flags = cmd->cmd_flags;
1579 		if (bp->b_flags & B_READ) {
1580 			/* a read */
1581 			cmd_flags &= ~CFLAG_DMASEND;
1582 			dma_flags = DDI_DMA_READ;
1583 		} else {
1584 			/* a write */
1585 			cmd_flags |= CFLAG_DMASEND;
1586 			dma_flags = DDI_DMA_WRITE;
1587 		}
1588 		if (flags & PKT_CONSISTENT) {
1589 			cmd_flags |= CFLAG_CMDIOPB;
1590 			dma_flags |= DDI_DMA_CONSISTENT;
1591 		}
1592 
1593 		/* ensure we have a DMA handle */
1594 		if (cmd->cmd_dmahandle == NULL) {
1595 			rval = ddi_dma_alloc_handle(sf->sf_dip,
1596 			    sf->sf_sochandle->fcal_dmaattr, callback, arg,
1597 			    &cmd->cmd_dmahandle);
1598 		}
1599 
1600 		if (rval == 0) {
1601 			/* bind our DMA handle to our buffer */
1602 			rval = ddi_dma_buf_bind_handle(cmd->cmd_dmahandle, bp,
1603 			    dma_flags, callback, arg, &cmd->cmd_dmacookie,
1604 			    &dmacookie_count);
1605 		}
1606 
1607 		if (rval != 0) {
1608 			/* DMA failure */
1609 			SF_DEBUG(2, (sf, CE_CONT, "ddi_dma_buf.. failed\n"));
1610 			switch (rval) {
1611 			case DDI_DMA_NORESOURCES:
1612 				bioerror(bp, 0);
1613 				break;
1614 			case DDI_DMA_BADATTR:
1615 			case DDI_DMA_NOMAPPING:
1616 				bioerror(bp, EFAULT);
1617 				break;
1618 			case DDI_DMA_TOOBIG:
1619 			default:
1620 				bioerror(bp, EINVAL);
1621 				break;
1622 			}
1623 			/* clear valid flag */
1624 			cmd->cmd_flags = cmd_flags & ~CFLAG_DMAVALID;
1625 			if (new_cmd != NULL) {
1626 				/* destroy packet if we just created it */
1627 				sf_scsi_destroy_pkt(ap, new_cmd->cmd_pkt);
1628 			}
1629 			return (NULL);
1630 		}
1631 
1632 		ASSERT(dmacookie_count == 1);
1633 		/* set up amt to transfer and set valid flag */
1634 		cmd->cmd_dmacount = bp->b_bcount;
1635 		cmd->cmd_flags = cmd_flags | CFLAG_DMAVALID;
1636 
1637 		ASSERT(cmd->cmd_dmahandle != NULL);
1638 	}
1639 
1640 	/* set up FC-AL packet */
1641 	fcmd = cmd->cmd_block;
1642 
1643 	if (cmd->cmd_flags & CFLAG_DMAVALID) {
1644 		if (cmd->cmd_flags & CFLAG_DMASEND) {
1645 			/* DMA write */
1646 			fcmd->fcp_cntl.cntl_read_data = 0;
1647 			fcmd->fcp_cntl.cntl_write_data = 1;
1648 			fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type =
1649 			    CQ_TYPE_IO_WRITE;
1650 		} else {
1651 			/* DMA read */
1652 			fcmd->fcp_cntl.cntl_read_data = 1;
1653 			fcmd->fcp_cntl.cntl_write_data = 0;
1654 			fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type =
1655 			    CQ_TYPE_IO_READ;
1656 		}
1657 		fpkt->fcal_socal_request.sr_dataseg[2].fc_base =
1658 		    (uint32_t)cmd->cmd_dmacookie.dmac_address;
1659 		fpkt->fcal_socal_request.sr_dataseg[2].fc_count =
1660 		    cmd->cmd_dmacookie.dmac_size;
1661 		fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 3;
1662 		fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt =
1663 		    cmd->cmd_dmacookie.dmac_size;
1664 		fcmd->fcp_data_len = cmd->cmd_dmacookie.dmac_size;
1665 	} else {
1666 		/* not a read or write */
1667 		fcmd->fcp_cntl.cntl_read_data = 0;
1668 		fcmd->fcp_cntl.cntl_write_data = 0;
1669 		fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type = CQ_TYPE_SIMPLE;
1670 		fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 2;
1671 		fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt =
1672 		    sizeof (struct fcp_cmd);
1673 		fcmd->fcp_data_len = 0;
1674 	}
1675 	fcmd->fcp_cntl.cntl_qtype = FCP_QTYPE_SIMPLE;
1676 
1677 	return (cmd->cmd_pkt);
1678 }
1679 
1680 
1681 /*
1682  * destroy a SCSI packet -- called internally and by the transport
1683  */
1684 static void
1685 sf_scsi_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1686 {
1687 	struct sf_pkt *cmd = PKT2CMD(pkt);
1688 	struct sf *sf = ADDR2SF(ap);
1689 	struct sf_target *target = ADDR2TARGET(ap);
1690 	struct fcal_packet	*fpkt = cmd->cmd_fp_pkt;
1691 
1692 
1693 	if (cmd->cmd_flags & CFLAG_DMAVALID) {
1694 		/* DMA was set up -- clean up */
1695 		(void) ddi_dma_unbind_handle(cmd->cmd_dmahandle);
1696 		cmd->cmd_flags ^= CFLAG_DMAVALID;
1697 	}
1698 
1699 	/* take this packet off the doubly-linked list */
1700 	mutex_enter(&target->sft_pkt_mutex);
1701 	cmd->cmd_back->cmd_forw = cmd->cmd_forw;
1702 	cmd->cmd_forw->cmd_back = cmd->cmd_back;
1703 	mutex_exit(&target->sft_pkt_mutex);
1704 
1705 	fpkt->fcal_pkt_flags = 0;
1706 	/* free the packet */
1707 	if ((cmd->cmd_flags &
1708 	    (CFLAG_FREE | CFLAG_PRIVEXTERN | CFLAG_SCBEXTERN)) == 0) {
1709 		/* just a regular packet */
1710 		ASSERT(cmd->cmd_state != SF_STATE_ISSUED);
1711 		cmd->cmd_flags = CFLAG_FREE;
1712 		kmem_cache_free(sf->sf_pkt_cache, (void *)cmd);
1713 	} else {
1714 		/* a packet with extra memory */
1715 		sf_pkt_destroy_extern(sf, cmd);
1716 	}
1717 }
1718 
1719 
1720 /*
1721  * called by transport to unbind DMA handle
1722  */
1723 /* ARGSUSED */
1724 static void
1725 sf_scsi_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt)
1726 {
1727 	struct sf_pkt *cmd = PKT2CMD(pkt);
1728 
1729 
1730 	if (cmd->cmd_flags & CFLAG_DMAVALID) {
1731 		(void) ddi_dma_unbind_handle(cmd->cmd_dmahandle);
1732 		cmd->cmd_flags ^= CFLAG_DMAVALID;
1733 	}
1734 
1735 }
1736 
1737 
1738 /*
1739  * called by transport to synchronize CPU and I/O views of memory
1740  */
1741 /* ARGSUSED */
1742 static void
1743 sf_scsi_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt)
1744 {
1745 	struct sf_pkt *cmd = PKT2CMD(pkt);
1746 
1747 
1748 	if (cmd->cmd_flags & CFLAG_DMAVALID) {
1749 		if (ddi_dma_sync(cmd->cmd_dmahandle, (off_t)0, (size_t)0,
1750 		    (cmd->cmd_flags & CFLAG_DMASEND) ?
1751 		    DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU) !=
1752 		    DDI_SUCCESS) {
1753 			cmn_err(CE_WARN, "sf: sync pkt failed");
1754 		}
1755 	}
1756 }
1757 
1758 
1759 /*
1760  * routine for reset notification setup, to register or cancel. -- called
1761  * by transport
1762  */
1763 static int
1764 sf_scsi_reset_notify(struct scsi_address *ap, int flag,
1765     void (*callback)(caddr_t), caddr_t arg)
1766 {
1767 	struct sf	*sf = ADDR2SF(ap);
1768 
1769 	return (scsi_hba_reset_notify_setup(ap, flag, callback, arg,
1770 	    &sf->sf_mutex, &sf->sf_reset_notify_listf));
1771 }
1772 
1773 
1774 /*
1775  * called by transport to get port WWN property (except sun4u)
1776  */
1777 /* ARGSUSED */
1778 static int
1779 sf_scsi_get_name(struct scsi_device *sd, char *name, int len)
1780 {
1781 	char tbuf[(FC_WWN_SIZE*2)+1];
1782 	unsigned char wwn[FC_WWN_SIZE];
1783 	int i, lun;
1784 	dev_info_t *tgt_dip;
1785 
1786 	tgt_dip = sd->sd_dev;
1787 	i = sizeof (wwn);
1788 	if (ddi_prop_op(DDI_DEV_T_ANY, tgt_dip, PROP_LEN_AND_VAL_BUF,
1789 	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, PORT_WWN_PROP,
1790 	    (caddr_t)&wwn, &i) != DDI_SUCCESS) {
1791 		name[0] = '\0';
1792 		return (0);
1793 	}
1794 	i = sizeof (lun);
1795 	if (ddi_prop_op(DDI_DEV_T_ANY, tgt_dip, PROP_LEN_AND_VAL_BUF,
1796 	    DDI_PROP_DONTPASS | DDI_PROP_CANSLEEP, "lun",
1797 	    (caddr_t)&lun, &i) != DDI_SUCCESS) {
1798 		name[0] = '\0';
1799 		return (0);
1800 	}
1801 	for (i = 0; i < FC_WWN_SIZE; i++)
1802 		(void) sprintf(&tbuf[i << 1], "%02x", wwn[i]);
1803 	(void) sprintf(name, "w%s,%x", tbuf, lun);
1804 	return (1);
1805 }
1806 
1807 
1808 /*
1809  * called by transport to get target soft AL-PA (except sun4u)
1810  */
1811 /* ARGSUSED */
1812 static int
1813 sf_scsi_get_bus_addr(struct scsi_device *sd, char *name, int len)
1814 {
1815 	struct sf_target *target = ADDR2TARGET(&sd->sd_address);
1816 
1817 	if (target == NULL)
1818 		return (0);
1819 
1820 	(void) sprintf(name, "%x", target->sft_al_pa);
1821 	return (1);
1822 }
1823 
1824 
1825 /*
1826  * add to the command/response buffer pool for this sf instance
1827  */
1828 static int
1829 sf_add_cr_pool(struct sf *sf)
1830 {
1831 	int		cmd_buf_size;
1832 	size_t		real_cmd_buf_size;
1833 	int		rsp_buf_size;
1834 	size_t		real_rsp_buf_size;
1835 	uint_t		i, ccount;
1836 	struct sf_cr_pool	*ptr;
1837 	struct sf_cr_free_elem *cptr;
1838 	caddr_t	dptr, eptr;
1839 	ddi_dma_cookie_t	cmd_cookie;
1840 	ddi_dma_cookie_t	rsp_cookie;
1841 	int		cmd_bound = FALSE, rsp_bound = FALSE;
1842 
1843 
1844 	/* allocate room for the pool */
1845 	if ((ptr = kmem_zalloc(sizeof (struct sf_cr_pool), KM_NOSLEEP)) ==
1846 	    NULL) {
1847 		return (DDI_FAILURE);
1848 	}
1849 
1850 	/* allocate a DMA handle for the command pool */
1851 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
1852 	    DDI_DMA_DONTWAIT, NULL, &ptr->cmd_dma_handle) != DDI_SUCCESS) {
1853 		goto fail;
1854 	}
1855 
1856 	/*
1857 	 * Get a piece of memory in which to put commands
1858 	 */
1859 	cmd_buf_size = (sizeof (struct fcp_cmd) * SF_ELEMS_IN_POOL + 7) & ~7;
1860 	if (ddi_dma_mem_alloc(ptr->cmd_dma_handle, cmd_buf_size,
1861 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
1862 	    DDI_DMA_DONTWAIT, NULL, (caddr_t *)&ptr->cmd_base,
1863 	    &real_cmd_buf_size, &ptr->cmd_acc_handle) != DDI_SUCCESS) {
1864 		goto fail;
1865 	}
1866 
1867 	/* bind the DMA handle to an address */
1868 	if (ddi_dma_addr_bind_handle(ptr->cmd_dma_handle, NULL,
1869 	    ptr->cmd_base, real_cmd_buf_size,
1870 	    DDI_DMA_WRITE | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
1871 	    NULL, &cmd_cookie, &ccount) != DDI_DMA_MAPPED) {
1872 		goto fail;
1873 	}
1874 	cmd_bound = TRUE;
1875 	/* ensure only one cookie was allocated */
1876 	if (ccount != 1) {
1877 		goto fail;
1878 	}
1879 
1880 	/* allocate a DMA handle for the response pool */
1881 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
1882 	    DDI_DMA_DONTWAIT, NULL, &ptr->rsp_dma_handle) != DDI_SUCCESS) {
1883 		goto fail;
1884 	}
1885 
1886 	/*
1887 	 * Get a piece of memory in which to put responses
1888 	 */
1889 	rsp_buf_size = FCP_MAX_RSP_IU_SIZE * SF_ELEMS_IN_POOL;
1890 	if (ddi_dma_mem_alloc(ptr->rsp_dma_handle, rsp_buf_size,
1891 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
1892 	    DDI_DMA_DONTWAIT, NULL, (caddr_t *)&ptr->rsp_base,
1893 	    &real_rsp_buf_size, &ptr->rsp_acc_handle) != DDI_SUCCESS) {
1894 		goto fail;
1895 	}
1896 
1897 	/* bind the DMA handle to an address */
1898 	if (ddi_dma_addr_bind_handle(ptr->rsp_dma_handle, NULL,
1899 	    ptr->rsp_base, real_rsp_buf_size,
1900 	    DDI_DMA_READ | DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
1901 	    NULL, &rsp_cookie, &ccount) != DDI_DMA_MAPPED) {
1902 		goto fail;
1903 	}
1904 	rsp_bound = TRUE;
1905 	/* ensure only one cookie was allocated */
1906 	if (ccount != 1) {
1907 		goto fail;
1908 	}
1909 
1910 	/*
1911 	 * Generate a (cmd/rsp structure) free list
1912 	 */
1913 	/* ensure ptr points to start of long word (8-byte block) */
1914 	dptr = (caddr_t)((uintptr_t)(ptr->cmd_base) + 7 & ~7);
1915 	/* keep track of actual size after moving pointer */
1916 	real_cmd_buf_size -= (dptr - ptr->cmd_base);
1917 	eptr = ptr->rsp_base;
1918 
1919 	/* set actual total number of entries */
1920 	ptr->ntot = min((real_cmd_buf_size / sizeof (struct fcp_cmd)),
1921 	    (real_rsp_buf_size / FCP_MAX_RSP_IU_SIZE));
1922 	ptr->nfree = ptr->ntot;
1923 	ptr->free = (struct sf_cr_free_elem *)ptr->cmd_base;
1924 	ptr->sf = sf;
1925 
1926 	/* set up DMA for each pair of entries */
1927 	i = 0;
1928 	while (i < ptr->ntot) {
1929 		cptr = (struct sf_cr_free_elem *)dptr;
1930 		dptr += sizeof (struct fcp_cmd);
1931 
1932 		cptr->next = (struct sf_cr_free_elem *)dptr;
1933 		cptr->rsp = eptr;
1934 
1935 		cptr->cmd_dmac = cmd_cookie.dmac_address +
1936 		    (uint32_t)((caddr_t)cptr - ptr->cmd_base);
1937 
1938 		cptr->rsp_dmac = rsp_cookie.dmac_address +
1939 		    (uint32_t)((caddr_t)eptr - ptr->rsp_base);
1940 
1941 		eptr += FCP_MAX_RSP_IU_SIZE;
1942 		i++;
1943 	}
1944 
1945 	/* terminate the list */
1946 	cptr->next = NULL;
1947 
1948 	/* add this list at front of current one */
1949 	mutex_enter(&sf->sf_cr_mutex);
1950 	ptr->next = sf->sf_cr_pool;
1951 	sf->sf_cr_pool = ptr;
1952 	sf->sf_cr_pool_cnt++;
1953 	mutex_exit(&sf->sf_cr_mutex);
1954 
1955 	return (DDI_SUCCESS);
1956 
1957 fail:
1958 	/* we failed so clean up */
1959 	if (ptr->cmd_dma_handle != NULL) {
1960 		if (cmd_bound) {
1961 			(void) ddi_dma_unbind_handle(ptr->cmd_dma_handle);
1962 		}
1963 		ddi_dma_free_handle(&ptr->cmd_dma_handle);
1964 	}
1965 
1966 	if (ptr->rsp_dma_handle != NULL) {
1967 		if (rsp_bound) {
1968 			(void) ddi_dma_unbind_handle(ptr->rsp_dma_handle);
1969 		}
1970 		ddi_dma_free_handle(&ptr->rsp_dma_handle);
1971 	}
1972 
1973 	if (ptr->cmd_base != NULL) {
1974 		ddi_dma_mem_free(&ptr->cmd_acc_handle);
1975 	}
1976 
1977 	if (ptr->rsp_base != NULL) {
1978 		ddi_dma_mem_free(&ptr->rsp_acc_handle);
1979 	}
1980 
1981 	kmem_free((caddr_t)ptr, sizeof (struct sf_cr_pool));
1982 	return (DDI_FAILURE);
1983 }
1984 
1985 
1986 /*
1987  * allocate a command/response buffer from the pool, allocating more
1988  * in the pool as needed
1989  */
1990 static int
1991 sf_cr_alloc(struct sf *sf, struct sf_pkt *cmd, int (*func)())
1992 {
1993 	struct sf_cr_pool *ptr;
1994 	struct sf_cr_free_elem *cptr;
1995 
1996 
1997 	mutex_enter(&sf->sf_cr_mutex);
1998 
1999 try_again:
2000 
2001 	/* find a free buffer in the existing pool */
2002 	ptr = sf->sf_cr_pool;
2003 	while (ptr != NULL) {
2004 		if (ptr->nfree != 0) {
2005 			ptr->nfree--;
2006 			break;
2007 		} else {
2008 			ptr = ptr->next;
2009 		}
2010 	}
2011 
2012 	/* did we find a free buffer ? */
2013 	if (ptr != NULL) {
2014 		/* we found a free buffer -- take it off the free list */
2015 		cptr = ptr->free;
2016 		ptr->free = cptr->next;
2017 		mutex_exit(&sf->sf_cr_mutex);
2018 		/* set up the command to use the buffer pair */
2019 		cmd->cmd_block = (struct fcp_cmd *)cptr;
2020 		cmd->cmd_dmac = cptr->cmd_dmac;
2021 		cmd->cmd_rsp_dmac = cptr->rsp_dmac;
2022 		cmd->cmd_rsp_block = (struct fcp_rsp *)cptr->rsp;
2023 		cmd->cmd_cr_pool = ptr;
2024 		return (DDI_SUCCESS);		/* success */
2025 	}
2026 
2027 	/* no free buffer available -- can we allocate more ? */
2028 	if (sf->sf_cr_pool_cnt < SF_CR_POOL_MAX) {
2029 		/* we need to allocate more buffer pairs */
2030 		if (sf->sf_cr_flag) {
2031 			/* somebody already allocating for this instance */
2032 			if (func == SLEEP_FUNC) {
2033 				/* user wants to wait */
2034 				cv_wait(&sf->sf_cr_cv, &sf->sf_cr_mutex);
2035 				/* we've been woken so go try again */
2036 				goto try_again;
2037 			}
2038 			/* user does not want to wait */
2039 			mutex_exit(&sf->sf_cr_mutex);
2040 			sf->sf_stats.cralloc_failures++;
2041 			return (DDI_FAILURE);	/* give up */
2042 		}
2043 		/* set flag saying we're allocating */
2044 		sf->sf_cr_flag = 1;
2045 		mutex_exit(&sf->sf_cr_mutex);
2046 		/* add to our pool */
2047 		if (sf_add_cr_pool(sf) != DDI_SUCCESS) {
2048 			/* couldn't add to our pool for some reason */
2049 			mutex_enter(&sf->sf_cr_mutex);
2050 			sf->sf_cr_flag = 0;
2051 			cv_broadcast(&sf->sf_cr_cv);
2052 			mutex_exit(&sf->sf_cr_mutex);
2053 			sf->sf_stats.cralloc_failures++;
2054 			return (DDI_FAILURE);	/* give up */
2055 		}
2056 		/*
2057 		 * clear flag saying we're allocating and tell all other
2058 		 * that care
2059 		 */
2060 		mutex_enter(&sf->sf_cr_mutex);
2061 		sf->sf_cr_flag = 0;
2062 		cv_broadcast(&sf->sf_cr_cv);
2063 		/* now that we have more buffers try again */
2064 		goto try_again;
2065 	}
2066 
2067 	/* we don't have room to allocate any more buffers */
2068 	mutex_exit(&sf->sf_cr_mutex);
2069 	sf->sf_stats.cralloc_failures++;
2070 	return (DDI_FAILURE);			/* give up */
2071 }
2072 
2073 
2074 /*
2075  * free a cmd/response buffer pair in our pool
2076  */
2077 static void
2078 sf_cr_free(struct sf_cr_pool *cp, struct sf_pkt *cmd)
2079 {
2080 	struct sf *sf = cp->sf;
2081 	struct sf_cr_free_elem *elem;
2082 
2083 	elem = (struct sf_cr_free_elem *)cmd->cmd_block;
2084 	elem->rsp = (caddr_t)cmd->cmd_rsp_block;
2085 	elem->cmd_dmac = cmd->cmd_dmac;
2086 	elem->rsp_dmac = cmd->cmd_rsp_dmac;
2087 
2088 	mutex_enter(&sf->sf_cr_mutex);
2089 	cp->nfree++;
2090 	ASSERT(cp->nfree <= cp->ntot);
2091 
2092 	elem->next = cp->free;
2093 	cp->free = elem;
2094 	mutex_exit(&sf->sf_cr_mutex);
2095 }
2096 
2097 
2098 /*
2099  * free our pool of cmd/response buffers
2100  */
2101 static void
2102 sf_crpool_free(struct sf *sf)
2103 {
2104 	struct sf_cr_pool *cp, *prev;
2105 
2106 	prev = NULL;
2107 	mutex_enter(&sf->sf_cr_mutex);
2108 	cp = sf->sf_cr_pool;
2109 	while (cp != NULL) {
2110 		if (cp->nfree == cp->ntot) {
2111 			if (prev != NULL) {
2112 				prev->next = cp->next;
2113 			} else {
2114 				sf->sf_cr_pool = cp->next;
2115 			}
2116 			sf->sf_cr_pool_cnt--;
2117 			mutex_exit(&sf->sf_cr_mutex);
2118 
2119 			(void) ddi_dma_unbind_handle(cp->cmd_dma_handle);
2120 			ddi_dma_free_handle(&cp->cmd_dma_handle);
2121 			(void) ddi_dma_unbind_handle(cp->rsp_dma_handle);
2122 			ddi_dma_free_handle(&cp->rsp_dma_handle);
2123 			ddi_dma_mem_free(&cp->cmd_acc_handle);
2124 			ddi_dma_mem_free(&cp->rsp_acc_handle);
2125 			kmem_free((caddr_t)cp, sizeof (struct sf_cr_pool));
2126 			return;
2127 		}
2128 		prev = cp;
2129 		cp = cp->next;
2130 	}
2131 	mutex_exit(&sf->sf_cr_mutex);
2132 }
2133 
2134 
2135 /* ARGSUSED */
2136 static int
2137 sf_kmem_cache_constructor(void *buf, void *arg, int size)
2138 {
2139 	struct sf_pkt *cmd = buf;
2140 
2141 	mutex_init(&cmd->cmd_abort_mutex, NULL, MUTEX_DRIVER, NULL);
2142 	cmd->cmd_block = NULL;
2143 	cmd->cmd_dmahandle = NULL;
2144 	return (0);
2145 }
2146 
2147 
2148 /* ARGSUSED */
2149 static void
2150 sf_kmem_cache_destructor(void *buf, void *size)
2151 {
2152 	struct sf_pkt *cmd = buf;
2153 
2154 	if (cmd->cmd_dmahandle != NULL) {
2155 		ddi_dma_free_handle(&cmd->cmd_dmahandle);
2156 	}
2157 
2158 	if (cmd->cmd_block != NULL) {
2159 		sf_cr_free(cmd->cmd_cr_pool, cmd);
2160 	}
2161 	mutex_destroy(&cmd->cmd_abort_mutex);
2162 }
2163 
2164 
2165 /*
2166  * called by transport when a state change occurs
2167  */
2168 static void
2169 sf_statec_callback(void *arg, int msg)
2170 {
2171 	struct sf *sf = (struct sf *)arg;
2172 	struct sf_target	*target;
2173 	int i;
2174 	struct sf_pkt *cmd;
2175 	struct scsi_pkt *pkt;
2176 
2177 
2178 
2179 	switch (msg) {
2180 
2181 	case FCAL_STATUS_LOOP_ONLINE: {
2182 		uchar_t		al_pa;		/* to save AL-PA */
2183 		int		ret;		/* ret value from getmap */
2184 		int		lip_cnt;	/* to save current count */
2185 		int		cnt;		/* map length */
2186 
2187 		/*
2188 		 * the loop has gone online
2189 		 */
2190 		SF_DEBUG(1, (sf, CE_CONT, "sf%d: loop online\n",
2191 		    ddi_get_instance(sf->sf_dip)));
2192 		mutex_enter(&sf->sf_mutex);
2193 		sf->sf_lip_cnt++;
2194 		sf->sf_state = SF_STATE_ONLINING;
2195 		mutex_exit(&sf->sf_mutex);
2196 
2197 		/* scan each target hash queue */
2198 		for (i = 0; i < SF_NUM_HASH_QUEUES; i++) {
2199 			target = sf->sf_wwn_lists[i];
2200 			while (target != NULL) {
2201 				/*
2202 				 * foreach target, if it's not offline then
2203 				 * mark it as busy
2204 				 */
2205 				mutex_enter(&target->sft_mutex);
2206 				if (!(target->sft_state & SF_TARGET_OFFLINE))
2207 					target->sft_state |= (SF_TARGET_BUSY
2208 					    | SF_TARGET_MARK);
2209 #ifdef DEBUG
2210 				/*
2211 				 * for debugging, print out info on any
2212 				 * pending commands (left hanging)
2213 				 */
2214 				cmd = target->sft_pkt_head;
2215 				while (cmd != (struct sf_pkt *)&target->
2216 				    sft_pkt_head) {
2217 					if (cmd->cmd_state ==
2218 					    SF_STATE_ISSUED) {
2219 						SF_DEBUG(1, (sf, CE_CONT,
2220 						    "cmd 0x%p pending "
2221 						    "after lip\n",
2222 						    (void *)cmd->cmd_fp_pkt));
2223 					}
2224 					cmd = cmd->cmd_forw;
2225 				}
2226 #endif
2227 				mutex_exit(&target->sft_mutex);
2228 				target = target->sft_next;
2229 			}
2230 		}
2231 
2232 		/*
2233 		 * since the loop has just gone online get a new map from
2234 		 * the transport
2235 		 */
2236 		if ((ret = soc_get_lilp_map(sf->sf_sochandle, sf->sf_socp,
2237 		    sf->sf_sochandle->fcal_portno, (uint32_t)sf->
2238 		    sf_lilp_dmacookie.dmac_address, 1)) != FCAL_SUCCESS) {
2239 			if (sf_core && (sf_core & SF_CORE_LILP_FAILED)) {
2240 				(void) soc_take_core(sf->sf_sochandle,
2241 				    sf->sf_socp);
2242 				sf_core = 0;
2243 			}
2244 			sf_log(sf, CE_WARN,
2245 			    "!soc lilp map failed status=0x%x\n", ret);
2246 			mutex_enter(&sf->sf_mutex);
2247 			sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
2248 			sf->sf_lip_cnt++;
2249 			sf->sf_state = SF_STATE_OFFLINE;
2250 			mutex_exit(&sf->sf_mutex);
2251 			return;
2252 		}
2253 
2254 		/* ensure consistent view of DMA memory */
2255 		(void) ddi_dma_sync(sf->sf_lilp_dmahandle, (off_t)0, (size_t)0,
2256 		    DDI_DMA_SYNC_FORKERNEL);
2257 
2258 		/* how many entries in map ? */
2259 		cnt = sf->sf_lilp_map->lilp_length;
2260 		if (cnt >= SF_MAX_LILP_ENTRIES) {
2261 			sf_log(sf, CE_WARN, "invalid lilp map\n");
2262 			return;
2263 		}
2264 
2265 		mutex_enter(&sf->sf_mutex);
2266 		sf->sf_device_count = cnt - 1;
2267 		sf->sf_al_pa = sf->sf_lilp_map->lilp_myalpa;
2268 		lip_cnt = sf->sf_lip_cnt;
2269 		al_pa = sf->sf_al_pa;
2270 
2271 		SF_DEBUG(1, (sf, CE_CONT,
2272 		    "!lilp map has %d entries, al_pa is %x\n", cnt, al_pa));
2273 
2274 		/*
2275 		 * since the last entry of the map may be mine (common) check
2276 		 * for that, and if it is we have one less entry to look at
2277 		 */
2278 		if (sf->sf_lilp_map->lilp_alpalist[cnt-1] == al_pa) {
2279 			cnt--;
2280 		}
2281 		/* If we didn't get a valid loop map enable all targets */
2282 		if (sf->sf_lilp_map->lilp_magic == FCAL_BADLILP_MAGIC) {
2283 			for (i = 0; i < sizeof (sf_switch_to_alpa); i++)
2284 				sf->sf_lilp_map->lilp_alpalist[i] =
2285 				    sf_switch_to_alpa[i];
2286 			cnt = i;
2287 			sf->sf_device_count = cnt - 1;
2288 		}
2289 		if (sf->sf_device_count == 0) {
2290 			sf_finish_init(sf, lip_cnt);
2291 			mutex_exit(&sf->sf_mutex);
2292 			break;
2293 		}
2294 		mutex_exit(&sf->sf_mutex);
2295 
2296 		SF_DEBUG(2, (sf, CE_WARN,
2297 		    "!statec_callback: starting with %d targets\n",
2298 		    sf->sf_device_count));
2299 
2300 		/* scan loop map, logging into all ports (except mine) */
2301 		for (i = 0; i < cnt; i++) {
2302 			SF_DEBUG(1, (sf, CE_CONT,
2303 			    "!lilp map entry %d = %x,%x\n", i,
2304 			    sf->sf_lilp_map->lilp_alpalist[i],
2305 			    sf_alpa_to_switch[
2306 			    sf->sf_lilp_map->lilp_alpalist[i]]));
2307 			/* is this entry for somebody else ? */
2308 			if (sf->sf_lilp_map->lilp_alpalist[i] != al_pa) {
2309 				/* do a PLOGI to this port */
2310 				if (!sf_login(sf, LA_ELS_PLOGI,
2311 				    sf->sf_lilp_map->lilp_alpalist[i],
2312 				    sf->sf_lilp_map->lilp_alpalist[cnt-1],
2313 				    lip_cnt)) {
2314 					/* a problem logging in */
2315 					mutex_enter(&sf->sf_mutex);
2316 					if (lip_cnt == sf->sf_lip_cnt) {
2317 						/*
2318 						 * problem not from a new LIP
2319 						 */
2320 						sf->sf_device_count--;
2321 						ASSERT(sf->sf_device_count
2322 						    >= 0);
2323 						if (sf->sf_device_count == 0) {
2324 							sf_finish_init(sf,
2325 							    lip_cnt);
2326 						}
2327 					}
2328 					mutex_exit(&sf->sf_mutex);
2329 				}
2330 			}
2331 		}
2332 		break;
2333 	}
2334 
2335 	case FCAL_STATUS_ERR_OFFLINE:
2336 		/*
2337 		 * loop has gone offline due to an error
2338 		 */
2339 		SF_DEBUG(1, (sf, CE_CONT, "sf%d: loop offline\n",
2340 		    ddi_get_instance(sf->sf_dip)));
2341 		mutex_enter(&sf->sf_mutex);
2342 		sf->sf_lip_cnt++;
2343 		sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
2344 		if (!sf->sf_online_timer) {
2345 			sf->sf_online_timer = sf_watchdog_time +
2346 			    SF_ONLINE_TIMEOUT;
2347 		}
2348 		/*
2349 		 * if we are suspended, preserve the SF_STATE_SUSPENDED flag,
2350 		 * since throttling logic in sf_watch() depends on
2351 		 * preservation of this flag while device is suspended
2352 		 */
2353 		if (sf->sf_state & SF_STATE_SUSPENDED) {
2354 			sf->sf_state |= SF_STATE_OFFLINE;
2355 			SF_DEBUG(1, (sf, CE_CONT,
2356 			    "sf_statec_callback, sf%d: "
2357 			    "got FCAL_STATE_OFFLINE during DDI_SUSPEND\n",
2358 			    ddi_get_instance(sf->sf_dip)));
2359 		} else {
2360 			sf->sf_state = SF_STATE_OFFLINE;
2361 		}
2362 
2363 		/* scan each possible target on the loop */
2364 		for (i = 0; i < sf_max_targets; i++) {
2365 			target = sf->sf_targets[i];
2366 			while (target != NULL) {
2367 				mutex_enter(&target->sft_mutex);
2368 				if (!(target->sft_state & SF_TARGET_OFFLINE))
2369 					target->sft_state |= (SF_TARGET_BUSY
2370 					    | SF_TARGET_MARK);
2371 				mutex_exit(&target->sft_mutex);
2372 				target = target->sft_next_lun;
2373 			}
2374 		}
2375 		mutex_exit(&sf->sf_mutex);
2376 		break;
2377 
2378 	case FCAL_STATE_RESET: {
2379 		struct sf_els_hdr	*privp;	/* ptr to private list */
2380 		struct sf_els_hdr	*tmpp1;	/* tmp prev hdr ptr */
2381 		struct sf_els_hdr	*tmpp2;	/* tmp next hdr ptr */
2382 		struct sf_els_hdr	*head;	/* to save our private list */
2383 		struct fcal_packet	*fpkt;	/* ptr to pkt in hdr */
2384 
2385 		/*
2386 		 * a transport reset
2387 		 */
2388 		SF_DEBUG(1, (sf, CE_CONT, "!sf%d: soc reset\n",
2389 		    ddi_get_instance(sf->sf_dip)));
2390 		tmpp1 = head = NULL;
2391 		mutex_enter(&sf->sf_mutex);
2392 		sf->sf_lip_cnt++;
2393 		sf->sf_timer = sf_watchdog_time + SF_RESET_TIMEOUT;
2394 		/*
2395 		 * if we are suspended, preserve the SF_STATE_SUSPENDED flag,
2396 		 * since throttling logic in sf_watch() depends on
2397 		 * preservation of this flag while device is suspended
2398 		 */
2399 		if (sf->sf_state & SF_STATE_SUSPENDED) {
2400 			sf->sf_state |= SF_STATE_OFFLINE;
2401 			SF_DEBUG(1, (sf, CE_CONT,
2402 			    "sf_statec_callback, sf%d: "
2403 			    "got FCAL_STATE_RESET during DDI_SUSPEND\n",
2404 			    ddi_get_instance(sf->sf_dip)));
2405 		} else {
2406 			sf->sf_state = SF_STATE_OFFLINE;
2407 		}
2408 
2409 		/*
2410 		 * scan each possible target on the loop, looking for targets
2411 		 * that need callbacks ran
2412 		 */
2413 		for (i = 0; i < sf_max_targets; i++) {
2414 			target = sf->sf_targets[i];
2415 			while (target != NULL) {
2416 				if (!(target->sft_state & SF_TARGET_OFFLINE)) {
2417 					target->sft_state |= (SF_TARGET_BUSY
2418 					    | SF_TARGET_MARK);
2419 					mutex_exit(&sf->sf_mutex);
2420 					/*
2421 					 * run remove event callbacks for lun
2422 					 *
2423 					 * We have a nasty race condition here
2424 					 * 'cause we're dropping this mutex to
2425 					 * run the callback and expect the
2426 					 * linked list to be the same.
2427 					 */
2428 					(void) ndi_event_retrieve_cookie(
2429 					    sf->sf_event_hdl, target->sft_dip,
2430 					    FCAL_REMOVE_EVENT, &sf_remove_eid,
2431 					    NDI_EVENT_NOPASS);
2432 					(void) ndi_event_run_callbacks(
2433 					    sf->sf_event_hdl,
2434 					    target->sft_dip,
2435 					    sf_remove_eid, NULL);
2436 					mutex_enter(&sf->sf_mutex);
2437 				}
2438 				target = target->sft_next_lun;
2439 			}
2440 		}
2441 
2442 		/*
2443 		 * scan for ELS commands that are in transport, not complete,
2444 		 * and have a valid timeout, building a private list
2445 		 */
2446 		privp = sf->sf_els_list;
2447 		while (privp != NULL) {
2448 			fpkt = privp->fpkt;
2449 			if ((fpkt->fcal_cmd_state & FCAL_CMD_IN_TRANSPORT) &&
2450 			    (!(fpkt->fcal_cmd_state & FCAL_CMD_COMPLETE)) &&
2451 			    (privp->timeout != SF_INVALID_TIMEOUT)) {
2452 				/*
2453 				 * cmd in transport && not complete &&
2454 				 * timeout valid
2455 				 *
2456 				 * move this entry from ELS input list to our
2457 				 * private list
2458 				 */
2459 
2460 				tmpp2 = privp->next; /* save ptr to next */
2461 
2462 				/* push this on private list head */
2463 				privp->next = head;
2464 				head = privp;
2465 
2466 				/* remove this entry from input list */
2467 				if (tmpp1 != NULL) {
2468 					/*
2469 					 * remove this entry from somewhere in
2470 					 * the middle of the list
2471 					 */
2472 					tmpp1->next = tmpp2;
2473 					if (tmpp2 != NULL) {
2474 						tmpp2->prev = tmpp1;
2475 					}
2476 				} else {
2477 					/*
2478 					 * remove this entry from the head
2479 					 * of the list
2480 					 */
2481 					sf->sf_els_list = tmpp2;
2482 					if (tmpp2 != NULL) {
2483 						tmpp2->prev = NULL;
2484 					}
2485 				}
2486 				privp = tmpp2;	/* skip to next entry */
2487 			} else {
2488 				tmpp1 = privp;	/* save ptr to prev entry */
2489 				privp = privp->next; /* skip to next entry */
2490 			}
2491 		}
2492 
2493 		mutex_exit(&sf->sf_mutex);
2494 
2495 		/*
2496 		 * foreach cmd in our list free the ELS packet associated
2497 		 * with it
2498 		 */
2499 		privp = head;
2500 		while (privp != NULL) {
2501 			fpkt = privp->fpkt;
2502 			privp = privp->next;
2503 			sf_els_free(fpkt);
2504 		}
2505 
2506 		/*
2507 		 * scan for commands from each possible target
2508 		 */
2509 		for (i = 0; i < sf_max_targets; i++) {
2510 			target = sf->sf_targets[i];
2511 			while (target != NULL) {
2512 				/*
2513 				 * scan all active commands for this target,
2514 				 * looking for commands that have been issued,
2515 				 * are in transport, and are not yet complete
2516 				 * (so we can terminate them because of the
2517 				 * reset)
2518 				 */
2519 				mutex_enter(&target->sft_pkt_mutex);
2520 				cmd = target->sft_pkt_head;
2521 				while (cmd != (struct sf_pkt *)&target->
2522 				    sft_pkt_head) {
2523 					fpkt = cmd->cmd_fp_pkt;
2524 					mutex_enter(&cmd->cmd_abort_mutex);
2525 					if ((cmd->cmd_state ==
2526 					    SF_STATE_ISSUED) &&
2527 					    (fpkt->fcal_cmd_state &
2528 					    FCAL_CMD_IN_TRANSPORT) &&
2529 					    (!(fpkt->fcal_cmd_state &
2530 					    FCAL_CMD_COMPLETE))) {
2531 						/* a command to be reset */
2532 						pkt = cmd->cmd_pkt;
2533 						pkt->pkt_reason = CMD_RESET;
2534 						pkt->pkt_statistics |=
2535 						    STAT_BUS_RESET;
2536 						cmd->cmd_state = SF_STATE_IDLE;
2537 						mutex_exit(&cmd->
2538 						    cmd_abort_mutex);
2539 						mutex_exit(&target->
2540 						    sft_pkt_mutex);
2541 						if (pkt->pkt_comp != NULL) {
2542 							(*pkt->pkt_comp)(pkt);
2543 						}
2544 						mutex_enter(&target->
2545 						    sft_pkt_mutex);
2546 						cmd = target->sft_pkt_head;
2547 					} else {
2548 						mutex_exit(&cmd->
2549 						    cmd_abort_mutex);
2550 						/* get next command */
2551 						cmd = cmd->cmd_forw;
2552 					}
2553 				}
2554 				mutex_exit(&target->sft_pkt_mutex);
2555 				target = target->sft_next_lun;
2556 			}
2557 		}
2558 
2559 		/*
2560 		 * get packet queue for this target, resetting all remaining
2561 		 * commands
2562 		 */
2563 		mutex_enter(&sf->sf_mutex);
2564 		cmd = sf->sf_pkt_head;
2565 		sf->sf_pkt_head = NULL;
2566 		mutex_exit(&sf->sf_mutex);
2567 
2568 		while (cmd != NULL) {
2569 			pkt = cmd->cmd_pkt;
2570 			cmd = cmd->cmd_next;
2571 			pkt->pkt_reason = CMD_RESET;
2572 			pkt->pkt_statistics |= STAT_BUS_RESET;
2573 			if (pkt->pkt_comp != NULL) {
2574 				(*pkt->pkt_comp)(pkt);
2575 			}
2576 		}
2577 		break;
2578 	}
2579 
2580 	default:
2581 		break;
2582 	}
2583 }
2584 
2585 
2586 /*
2587  * called to send a PLOGI (N_port login) ELS request to a destination ID,
2588  * returning TRUE upon success, else returning FALSE
2589  */
2590 static int
2591 sf_login(struct sf *sf, uchar_t els_code, uchar_t dest_id, uint_t arg1,
2592     int lip_cnt)
2593 {
2594 	struct la_els_logi	*logi;
2595 	struct	sf_els_hdr	*privp;
2596 
2597 
2598 	if (sf_els_alloc(sf, dest_id, sizeof (struct sf_els_hdr),
2599 	    sizeof (union sf_els_cmd), sizeof (union sf_els_rsp),
2600 	    (caddr_t *)&privp, (caddr_t *)&logi) == NULL) {
2601 		sf_log(sf, CE_WARN, "Cannot allocate PLOGI for target %x "
2602 		    "due to DVMA shortage.\n", sf_alpa_to_switch[dest_id]);
2603 		return (FALSE);
2604 	}
2605 
2606 	privp->lip_cnt = lip_cnt;
2607 	if (els_code == LA_ELS_PLOGI) {
2608 		bcopy((caddr_t)sf->sf_sochandle->fcal_loginparms,
2609 		    (caddr_t)&logi->common_service, sizeof (struct la_els_logi)
2610 		    - 4);
2611 		bcopy((caddr_t)&sf->sf_sochandle->fcal_p_wwn,
2612 		    (caddr_t)&logi->nport_ww_name, sizeof (la_wwn_t));
2613 		bcopy((caddr_t)&sf->sf_sochandle->fcal_n_wwn,
2614 		    (caddr_t)&logi->node_ww_name, sizeof (la_wwn_t));
2615 		bzero((caddr_t)&logi->reserved, 16);
2616 	} else if (els_code == LA_ELS_LOGO) {
2617 		bcopy((caddr_t)&sf->sf_sochandle->fcal_p_wwn,
2618 		    (caddr_t)&(((struct la_els_logo *)logi)->nport_ww_name), 8);
2619 		((struct la_els_logo	*)logi)->reserved = 0;
2620 		((struct la_els_logo	*)logi)->nport_id[0] = 0;
2621 		((struct la_els_logo	*)logi)->nport_id[1] = 0;
2622 		((struct la_els_logo	*)logi)->nport_id[2] = arg1;
2623 	}
2624 
2625 	privp->els_code = els_code;
2626 	logi->ls_code = els_code;
2627 	logi->mbz[0] = 0;
2628 	logi->mbz[1] = 0;
2629 	logi->mbz[2] = 0;
2630 
2631 	privp->timeout = sf_watchdog_time + SF_ELS_TIMEOUT;
2632 	return (sf_els_transport(sf, privp));
2633 }
2634 
2635 
2636 /*
2637  * send an ELS IU via the transport,
2638  * returning TRUE upon success, else returning FALSE
2639  */
2640 static int
2641 sf_els_transport(struct sf *sf, struct sf_els_hdr *privp)
2642 {
2643 	struct fcal_packet *fpkt = privp->fpkt;
2644 
2645 
2646 	(void) ddi_dma_sync(privp->cmd_dma_handle, (off_t)0, (size_t)0,
2647 	    DDI_DMA_SYNC_FORDEV);
2648 	privp->prev = NULL;
2649 	mutex_enter(&sf->sf_mutex);
2650 	privp->next = sf->sf_els_list;
2651 	if (sf->sf_els_list != NULL) {
2652 		sf->sf_els_list->prev = privp;
2653 	}
2654 	sf->sf_els_list = privp;
2655 	mutex_exit(&sf->sf_mutex);
2656 
2657 	/* call the transport to send a packet */
2658 	if (soc_transport(sf->sf_sochandle, fpkt, FCAL_NOSLEEP,
2659 	    CQ_REQUEST_1) != FCAL_TRANSPORT_SUCCESS) {
2660 		mutex_enter(&sf->sf_mutex);
2661 		if (privp->prev != NULL) {
2662 			privp->prev->next = privp->next;
2663 		}
2664 		if (privp->next != NULL) {
2665 			privp->next->prev = privp->prev;
2666 		}
2667 		if (sf->sf_els_list == privp) {
2668 			sf->sf_els_list = privp->next;
2669 		}
2670 		mutex_exit(&sf->sf_mutex);
2671 		sf_els_free(fpkt);
2672 		return (FALSE);			/* failure */
2673 	}
2674 	return (TRUE);				/* success */
2675 }
2676 
2677 
2678 /*
2679  * called as the pkt_comp routine for ELS FC packets
2680  */
2681 static void
2682 sf_els_callback(struct fcal_packet *fpkt)
2683 {
2684 	struct sf_els_hdr *privp = fpkt->fcal_pkt_private;
2685 	struct sf *sf = privp->sf;
2686 	struct sf *tsf;
2687 	int tgt_id;
2688 	struct la_els_logi *ptr = (struct la_els_logi *)privp->rsp;
2689 	struct la_els_adisc *adisc = (struct la_els_adisc *)ptr;
2690 	struct	sf_target *target;
2691 	short	ncmds;
2692 	short	free_pkt = TRUE;
2693 
2694 
2695 	/*
2696 	 * we've received an ELS callback, i.e. an ELS packet has arrived
2697 	 */
2698 
2699 	/* take the current packet off of the queue */
2700 	mutex_enter(&sf->sf_mutex);
2701 	if (privp->timeout == SF_INVALID_TIMEOUT) {
2702 		mutex_exit(&sf->sf_mutex);
2703 		return;
2704 	}
2705 	if (privp->prev != NULL) {
2706 		privp->prev->next = privp->next;
2707 	}
2708 	if (privp->next != NULL) {
2709 		privp->next->prev = privp->prev;
2710 	}
2711 	if (sf->sf_els_list == privp) {
2712 		sf->sf_els_list = privp->next;
2713 	}
2714 	privp->prev = privp->next = NULL;
2715 	mutex_exit(&sf->sf_mutex);
2716 
2717 	/* get # pkts in this callback */
2718 	ncmds = fpkt->fcal_ncmds;
2719 	ASSERT(ncmds >= 0);
2720 	mutex_enter(&sf->sf_cmd_mutex);
2721 	sf->sf_ncmds = ncmds;
2722 	mutex_exit(&sf->sf_cmd_mutex);
2723 
2724 	/* sync idea of memory */
2725 	(void) ddi_dma_sync(privp->rsp_dma_handle, (off_t)0, (size_t)0,
2726 	    DDI_DMA_SYNC_FORKERNEL);
2727 
2728 	/* was this an OK ACC msg ?? */
2729 	if ((fpkt->fcal_pkt_status == FCAL_STATUS_OK) &&
2730 	    (ptr->ls_code == LA_ELS_ACC)) {
2731 
2732 		/*
2733 		 * this was an OK ACC pkt
2734 		 */
2735 
2736 		switch (privp->els_code) {
2737 		case LA_ELS_PLOGI:
2738 			/*
2739 			 * was able to to an N_port login
2740 			 */
2741 			SF_DEBUG(2, (sf, CE_CONT,
2742 			    "!PLOGI to al_pa %x succeeded, wwn %x%x\n",
2743 			    privp->dest_nport_id,
2744 			    *((int *)&ptr->nport_ww_name.raw_wwn[0]),
2745 			    *((int *)&ptr->nport_ww_name.raw_wwn[4])));
2746 			/* try to do a process login */
2747 			if (!sf_do_prli(sf, privp, ptr)) {
2748 				free_pkt = FALSE;
2749 				goto fail;	/* PRLI failed */
2750 			}
2751 			break;
2752 		case LA_ELS_PRLI:
2753 			/*
2754 			 * was able to do a process login
2755 			 */
2756 			SF_DEBUG(2, (sf, CE_CONT,
2757 			    "!PRLI to al_pa %x succeeded\n",
2758 			    privp->dest_nport_id));
2759 			/* try to do address discovery */
2760 			if (sf_do_adisc(sf, privp) != 1) {
2761 				free_pkt = FALSE;
2762 				goto fail;	/* ADISC failed */
2763 			}
2764 			break;
2765 		case LA_ELS_ADISC:
2766 			/*
2767 			 * found a target via ADISC
2768 			 */
2769 
2770 			SF_DEBUG(2, (sf, CE_CONT,
2771 			    "!ADISC to al_pa %x succeeded\n",
2772 			    privp->dest_nport_id));
2773 
2774 			/* create the target info */
2775 			if ((target = sf_create_target(sf, privp,
2776 			    sf_alpa_to_switch[(uchar_t)adisc->hard_address],
2777 			    (int64_t)0))
2778 			    == NULL) {
2779 				goto fail;	/* can't create target */
2780 			}
2781 
2782 			/*
2783 			 * ensure address discovered matches what we thought
2784 			 * it would be
2785 			 */
2786 			if ((uchar_t)adisc->hard_address !=
2787 			    privp->dest_nport_id) {
2788 				sf_log(sf, CE_WARN,
2789 				    "target 0x%x, AL-PA 0x%x and "
2790 				    "hard address 0x%x don't match\n",
2791 				    sf_alpa_to_switch[
2792 				    (uchar_t)privp->dest_nport_id],
2793 				    privp->dest_nport_id,
2794 				    (uchar_t)adisc->hard_address);
2795 				mutex_enter(&sf->sf_mutex);
2796 				sf_offline_target(sf, target);
2797 				mutex_exit(&sf->sf_mutex);
2798 				goto fail;	/* addr doesn't match */
2799 			}
2800 			/*
2801 			 * get inquiry data from the target
2802 			 */
2803 			if (!sf_do_reportlun(sf, privp, target)) {
2804 				mutex_enter(&sf->sf_mutex);
2805 				sf_offline_target(sf, target);
2806 				mutex_exit(&sf->sf_mutex);
2807 				free_pkt = FALSE;
2808 				goto fail;	/* inquiry failed */
2809 			}
2810 			break;
2811 		default:
2812 			SF_DEBUG(2, (sf, CE_CONT,
2813 			    "!ELS %x to al_pa %x succeeded\n",
2814 			    privp->els_code, privp->dest_nport_id));
2815 			sf_els_free(fpkt);
2816 			break;
2817 		}
2818 
2819 	} else {
2820 
2821 		/*
2822 		 * oh oh -- this was not an OK ACC packet
2823 		 */
2824 
2825 		/* get target ID from dest loop address */
2826 		tgt_id = sf_alpa_to_switch[(uchar_t)privp->dest_nport_id];
2827 
2828 		/* keep track of failures */
2829 		sf->sf_stats.tstats[tgt_id].els_failures++;
2830 		if (++(privp->retries) < sf_els_retries &&
2831 		    fpkt->fcal_pkt_status != FCAL_STATUS_OPEN_FAIL) {
2832 			if (fpkt->fcal_pkt_status ==
2833 			    FCAL_STATUS_MAX_XCHG_EXCEEDED)  {
2834 				tsf = sf->sf_sibling;
2835 				if (tsf != NULL) {
2836 					mutex_enter(&tsf->sf_cmd_mutex);
2837 					tsf->sf_flag = 1;
2838 					tsf->sf_throttle = SF_DECR_DELTA;
2839 					mutex_exit(&tsf->sf_cmd_mutex);
2840 				}
2841 			}
2842 			privp->timeout = sf_watchdog_time + SF_ELS_TIMEOUT;
2843 			privp->prev = NULL;
2844 
2845 			mutex_enter(&sf->sf_mutex);
2846 
2847 			if (privp->lip_cnt == sf->sf_lip_cnt) {
2848 				SF_DEBUG(1, (sf, CE_WARN,
2849 				    "!ELS %x to al_pa %x failed, retrying",
2850 				    privp->els_code, privp->dest_nport_id));
2851 				privp->next = sf->sf_els_list;
2852 				if (sf->sf_els_list != NULL) {
2853 					sf->sf_els_list->prev = privp;
2854 				}
2855 
2856 				sf->sf_els_list = privp;
2857 
2858 				mutex_exit(&sf->sf_mutex);
2859 				/* device busy?  wait a bit ... */
2860 				if (fpkt->fcal_pkt_status ==
2861 				    FCAL_STATUS_MAX_XCHG_EXCEEDED)  {
2862 					privp->delayed_retry = 1;
2863 					return;
2864 				}
2865 				/* call the transport to send a pkt */
2866 				if (soc_transport(sf->sf_sochandle, fpkt,
2867 				    FCAL_NOSLEEP, CQ_REQUEST_1) !=
2868 				    FCAL_TRANSPORT_SUCCESS) {
2869 					mutex_enter(&sf->sf_mutex);
2870 					if (privp->prev != NULL) {
2871 						privp->prev->next =
2872 						    privp->next;
2873 					}
2874 					if (privp->next != NULL) {
2875 						privp->next->prev =
2876 						    privp->prev;
2877 					}
2878 					if (sf->sf_els_list == privp) {
2879 						sf->sf_els_list = privp->next;
2880 					}
2881 					mutex_exit(&sf->sf_mutex);
2882 					goto fail;
2883 				} else
2884 					return;
2885 			} else {
2886 				mutex_exit(&sf->sf_mutex);
2887 				goto fail;
2888 			}
2889 		} else {
2890 #ifdef	DEBUG
2891 			if (fpkt->fcal_pkt_status != 0x36 || sfdebug > 4) {
2892 			SF_DEBUG(2, (sf, CE_NOTE, "ELS %x to al_pa %x failed",
2893 			    privp->els_code, privp->dest_nport_id));
2894 			if (fpkt->fcal_pkt_status == FCAL_STATUS_OK) {
2895 				SF_DEBUG(2, (sf, CE_NOTE,
2896 				    "els reply code = %x", ptr->ls_code));
2897 				if (ptr->ls_code == LA_ELS_RJT)
2898 					SF_DEBUG(1, (sf, CE_CONT,
2899 					    "LS_RJT reason = %x\n",
2900 					    *(((uint_t *)ptr) + 1)));
2901 			} else
2902 				SF_DEBUG(2, (sf, CE_NOTE,
2903 				    "fc packet status = %x",
2904 				    fpkt->fcal_pkt_status));
2905 			}
2906 #endif
2907 			goto fail;
2908 		}
2909 	}
2910 	return;					/* success */
2911 fail:
2912 	mutex_enter(&sf->sf_mutex);
2913 	if (sf->sf_lip_cnt == privp->lip_cnt) {
2914 		sf->sf_device_count--;
2915 		ASSERT(sf->sf_device_count >= 0);
2916 		if (sf->sf_device_count == 0) {
2917 			sf_finish_init(sf, privp->lip_cnt);
2918 		}
2919 	}
2920 	mutex_exit(&sf->sf_mutex);
2921 	if (free_pkt) {
2922 		sf_els_free(fpkt);
2923 	}
2924 }
2925 
2926 
2927 /*
2928  * send a PRLI (process login) ELS IU via the transport,
2929  * returning TRUE upon success, else returning FALSE
2930  */
2931 static int
2932 sf_do_prli(struct sf *sf, struct sf_els_hdr *privp, struct la_els_logi *ptr)
2933 {
2934 	struct la_els_prli	*prli = (struct la_els_prli *)privp->cmd;
2935 	struct fcp_prli		*fprli;
2936 	struct  fcal_packet	*fpkt = privp->fpkt;
2937 
2938 
2939 	fpkt->fcal_socal_request.sr_dataseg[0].fc_count =
2940 	    sizeof (struct la_els_prli);
2941 	privp->els_code = LA_ELS_PRLI;
2942 	fprli = (struct fcp_prli *)prli->service_params;
2943 	prli->ls_code = LA_ELS_PRLI;
2944 	prli->page_length = 0x10;
2945 	prli->payload_length = sizeof (struct la_els_prli);
2946 	fprli->type = 0x08;			/* no define here? */
2947 	fprli->resvd1 = 0;
2948 	fprli->orig_process_assoc_valid = 0;
2949 	fprli->resp_process_assoc_valid = 0;
2950 	fprli->establish_image_pair = 1;
2951 	fprli->resvd2 = 0;
2952 	fprli->resvd3 = 0;
2953 	fprli->data_overlay_allowed = 0;
2954 	fprli->initiator_fn = 1;
2955 	fprli->target_fn = 0;
2956 	fprli->cmd_data_mixed = 0;
2957 	fprli->data_resp_mixed = 0;
2958 	fprli->read_xfer_rdy_disabled = 1;
2959 	fprli->write_xfer_rdy_disabled = 0;
2960 
2961 	bcopy((caddr_t)&ptr->nport_ww_name, (caddr_t)&privp->port_wwn,
2962 	    sizeof (privp->port_wwn));
2963 	bcopy((caddr_t)&ptr->node_ww_name, (caddr_t)&privp->node_wwn,
2964 	    sizeof (privp->node_wwn));
2965 
2966 	privp->timeout = sf_watchdog_time + SF_ELS_TIMEOUT;
2967 	return (sf_els_transport(sf, privp));
2968 }
2969 
2970 
2971 /*
2972  * send an ADISC (address discovery) ELS IU via the transport,
2973  * returning TRUE upon success, else returning FALSE
2974  */
2975 static int
2976 sf_do_adisc(struct sf *sf, struct sf_els_hdr *privp)
2977 {
2978 	struct la_els_adisc	*adisc = (struct la_els_adisc *)privp->cmd;
2979 	struct	fcal_packet	*fpkt = privp->fpkt;
2980 
2981 	privp->els_code = LA_ELS_ADISC;
2982 	adisc->ls_code = LA_ELS_ADISC;
2983 	adisc->mbz[0] = 0;
2984 	adisc->mbz[1] = 0;
2985 	adisc->mbz[2] = 0;
2986 	adisc->hard_address = 0; /* ??? */
2987 	fpkt->fcal_socal_request.sr_dataseg[0].fc_count =
2988 	    sizeof (struct la_els_adisc);
2989 	bcopy((caddr_t)&sf->sf_sochandle->fcal_p_wwn,
2990 	    (caddr_t)&adisc->port_wwn, sizeof (adisc->port_wwn));
2991 	bcopy((caddr_t)&sf->sf_sochandle->fcal_n_wwn,
2992 	    (caddr_t)&adisc->node_wwn, sizeof (adisc->node_wwn));
2993 	adisc->nport_id = sf->sf_al_pa;
2994 
2995 	privp->timeout = sf_watchdog_time + SF_ELS_TIMEOUT;
2996 	return (sf_els_transport(sf, privp));
2997 }
2998 
2999 
3000 static struct fcal_packet *
3001 sf_els_alloc(struct sf *sf, uchar_t dest_id, int priv_size, int cmd_size,
3002     int rsp_size, caddr_t *rprivp, caddr_t *cmd_buf)
3003 {
3004 	struct	fcal_packet	*fpkt;
3005 	ddi_dma_cookie_t	pcookie;
3006 	ddi_dma_cookie_t	rcookie;
3007 	struct	sf_els_hdr	*privp;
3008 	ddi_dma_handle_t	cmd_dma_handle = NULL;
3009 	ddi_dma_handle_t	rsp_dma_handle = NULL;
3010 	ddi_acc_handle_t	cmd_acc_handle = NULL;
3011 	ddi_acc_handle_t	rsp_acc_handle = NULL;
3012 	size_t			real_size;
3013 	uint_t			ccount;
3014 	fc_frame_header_t	*hp;
3015 	int			cmd_bound = FALSE, rsp_bound = FALSE;
3016 	caddr_t			cmd = NULL;
3017 	caddr_t			rsp = NULL;
3018 
3019 	if ((fpkt = (struct fcal_packet *)kmem_zalloc(
3020 	    sizeof (struct fcal_packet), KM_NOSLEEP)) == NULL) {
3021 		SF_DEBUG(1, (sf, CE_WARN,
3022 			"Could not allocate fcal_packet for ELS\n"));
3023 		return (NULL);
3024 	}
3025 
3026 	if ((privp = (struct sf_els_hdr *)kmem_zalloc(priv_size,
3027 	    KM_NOSLEEP)) == NULL) {
3028 		SF_DEBUG(1, (sf, CE_WARN,
3029 		    "Could not allocate sf_els_hdr for ELS\n"));
3030 		goto fail;
3031 	}
3032 
3033 	privp->size = priv_size;
3034 	fpkt->fcal_pkt_private = (caddr_t)privp;
3035 
3036 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
3037 	    DDI_DMA_DONTWAIT, NULL, &cmd_dma_handle) != DDI_SUCCESS) {
3038 		SF_DEBUG(1, (sf, CE_WARN,
3039 		    "Could not allocate DMA handle for ELS\n"));
3040 		goto fail;
3041 	}
3042 
3043 	if (ddi_dma_mem_alloc(cmd_dma_handle, cmd_size,
3044 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
3045 	    DDI_DMA_DONTWAIT, NULL, &cmd,
3046 	    &real_size, &cmd_acc_handle) != DDI_SUCCESS) {
3047 		SF_DEBUG(1, (sf, CE_WARN,
3048 		    "Could not allocate DMA memory for ELS\n"));
3049 		goto fail;
3050 	}
3051 
3052 	if (real_size < cmd_size) {
3053 		SF_DEBUG(1, (sf, CE_WARN,
3054 		    "DMA memory too small for ELS\n"));
3055 		goto fail;
3056 	}
3057 
3058 	if (ddi_dma_addr_bind_handle(cmd_dma_handle, NULL,
3059 	    cmd, real_size, DDI_DMA_WRITE | DDI_DMA_CONSISTENT,
3060 	    DDI_DMA_DONTWAIT, NULL, &pcookie, &ccount) != DDI_DMA_MAPPED) {
3061 		SF_DEBUG(1, (sf, CE_WARN,
3062 		    "Could not bind DMA memory for ELS\n"));
3063 		goto fail;
3064 	}
3065 	cmd_bound = TRUE;
3066 
3067 	if (ccount != 1) {
3068 		SF_DEBUG(1, (sf, CE_WARN,
3069 		    "Wrong cookie count for ELS\n"));
3070 		goto fail;
3071 	}
3072 
3073 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
3074 	    DDI_DMA_DONTWAIT, NULL, &rsp_dma_handle) != DDI_SUCCESS) {
3075 		SF_DEBUG(1, (sf, CE_WARN,
3076 		    "Could not allocate DMA handle for ELS rsp\n"));
3077 		goto fail;
3078 	}
3079 	if (ddi_dma_mem_alloc(rsp_dma_handle, rsp_size,
3080 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
3081 	    DDI_DMA_DONTWAIT, NULL, &rsp,
3082 	    &real_size, &rsp_acc_handle) != DDI_SUCCESS) {
3083 		SF_DEBUG(1, (sf, CE_WARN,
3084 		    "Could not allocate DMA memory for ELS rsp\n"));
3085 		goto fail;
3086 	}
3087 
3088 	if (real_size < rsp_size) {
3089 		SF_DEBUG(1, (sf, CE_WARN,
3090 		    "DMA memory too small for ELS rsp\n"));
3091 		goto fail;
3092 	}
3093 
3094 	if (ddi_dma_addr_bind_handle(rsp_dma_handle, NULL,
3095 	    rsp, real_size, DDI_DMA_READ | DDI_DMA_CONSISTENT,
3096 	    DDI_DMA_DONTWAIT, NULL, &rcookie, &ccount) != DDI_DMA_MAPPED) {
3097 		SF_DEBUG(1, (sf, CE_WARN,
3098 		    "Could not bind DMA memory for ELS rsp\n"));
3099 		goto fail;
3100 	}
3101 	rsp_bound = TRUE;
3102 
3103 	if (ccount != 1) {
3104 		SF_DEBUG(1, (sf, CE_WARN,
3105 		    "Wrong cookie count for ELS rsp\n"));
3106 		goto fail;
3107 	}
3108 
3109 	privp->cmd = cmd;
3110 	privp->sf = sf;
3111 	privp->cmd_dma_handle = cmd_dma_handle;
3112 	privp->cmd_acc_handle = cmd_acc_handle;
3113 	privp->rsp = rsp;
3114 	privp->rsp_dma_handle = rsp_dma_handle;
3115 	privp->rsp_acc_handle = rsp_acc_handle;
3116 	privp->dest_nport_id = dest_id;
3117 	privp->fpkt = fpkt;
3118 
3119 	fpkt->fcal_pkt_cookie = sf->sf_socp;
3120 	fpkt->fcal_pkt_comp = sf_els_callback;
3121 	fpkt->fcal_magic = FCALP_MAGIC;
3122 	fpkt->fcal_pkt_flags = 0;
3123 	fpkt->fcal_socal_request.sr_soc_hdr.sh_flags =
3124 	    (ushort_t)(SOC_FC_HEADER | sf->sf_sochandle->fcal_portno);
3125 	fpkt->fcal_socal_request.sr_soc_hdr.sh_class = 3;
3126 	fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 2;
3127 	fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt = cmd_size;
3128 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_count = 1;
3129 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_flags = 0;
3130 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_seqno = 0;
3131 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type = CQ_TYPE_SIMPLE;
3132 	fpkt->fcal_socal_request.sr_dataseg[0].fc_base = (uint32_t)
3133 	    pcookie.dmac_address;
3134 	fpkt->fcal_socal_request.sr_dataseg[0].fc_count = cmd_size;
3135 	fpkt->fcal_socal_request.sr_dataseg[1].fc_base = (uint32_t)
3136 	    rcookie.dmac_address;
3137 	fpkt->fcal_socal_request.sr_dataseg[1].fc_count = rsp_size;
3138 
3139 	/* Fill in the Fabric Channel Header */
3140 	hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
3141 	hp->r_ctl = R_CTL_ELS_REQ;
3142 	hp->d_id = dest_id;
3143 	hp->s_id = sf->sf_al_pa;
3144 	hp->type = TYPE_EXTENDED_LS;
3145 	hp->reserved1 = 0;
3146 	hp->f_ctl = F_CTL_SEQ_INITIATIVE | F_CTL_FIRST_SEQ;
3147 	hp->seq_id = 0;
3148 	hp->df_ctl  = 0;
3149 	hp->seq_cnt = 0;
3150 	hp->ox_id = 0xffff;
3151 	hp->rx_id = 0xffff;
3152 	hp->ro = 0;
3153 
3154 	*rprivp = (caddr_t)privp;
3155 	*cmd_buf = cmd;
3156 	return (fpkt);
3157 
3158 fail:
3159 	if (cmd_dma_handle != NULL) {
3160 		if (cmd_bound) {
3161 			(void) ddi_dma_unbind_handle(cmd_dma_handle);
3162 		}
3163 		ddi_dma_free_handle(&cmd_dma_handle);
3164 		privp->cmd_dma_handle = NULL;
3165 	}
3166 	if (rsp_dma_handle != NULL) {
3167 		if (rsp_bound) {
3168 			(void) ddi_dma_unbind_handle(rsp_dma_handle);
3169 		}
3170 		ddi_dma_free_handle(&rsp_dma_handle);
3171 		privp->rsp_dma_handle = NULL;
3172 	}
3173 	sf_els_free(fpkt);
3174 	return (NULL);
3175 }
3176 
3177 
3178 static void
3179 sf_els_free(struct fcal_packet *fpkt)
3180 {
3181 	struct	sf_els_hdr	*privp = fpkt->fcal_pkt_private;
3182 
3183 	if (privp != NULL) {
3184 		if (privp->cmd_dma_handle != NULL) {
3185 			(void) ddi_dma_unbind_handle(privp->cmd_dma_handle);
3186 			ddi_dma_free_handle(&privp->cmd_dma_handle);
3187 		}
3188 		if (privp->cmd != NULL) {
3189 			ddi_dma_mem_free(&privp->cmd_acc_handle);
3190 		}
3191 
3192 		if (privp->rsp_dma_handle != NULL) {
3193 			(void) ddi_dma_unbind_handle(privp->rsp_dma_handle);
3194 			ddi_dma_free_handle(&privp->rsp_dma_handle);
3195 		}
3196 
3197 		if (privp->rsp != NULL) {
3198 			ddi_dma_mem_free(&privp->rsp_acc_handle);
3199 		}
3200 		if (privp->data_dma_handle) {
3201 			(void) ddi_dma_unbind_handle(privp->data_dma_handle);
3202 			ddi_dma_free_handle(&privp->data_dma_handle);
3203 		}
3204 		if (privp->data_buf) {
3205 			ddi_dma_mem_free(&privp->data_acc_handle);
3206 		}
3207 		kmem_free(privp, privp->size);
3208 	}
3209 	kmem_free(fpkt, sizeof (struct fcal_packet));
3210 }
3211 
3212 
3213 static struct sf_target *
3214 sf_create_target(struct sf *sf, struct sf_els_hdr *privp, int tnum, int64_t lun)
3215 {
3216 	struct sf_target *target, *ntarget, *otarget, *ptarget;
3217 	int hash;
3218 #ifdef RAID_LUNS
3219 	int64_t orig_lun = lun;
3220 
3221 	/* XXXX Work around SCSA limitations. */
3222 	lun = *((short *)&lun);
3223 #endif
3224 	ntarget = kmem_zalloc(sizeof (struct sf_target), KM_NOSLEEP);
3225 	mutex_enter(&sf->sf_mutex);
3226 	if (sf->sf_lip_cnt != privp->lip_cnt) {
3227 		mutex_exit(&sf->sf_mutex);
3228 		if (ntarget != NULL)
3229 			kmem_free(ntarget, sizeof (struct sf_target));
3230 		return (NULL);
3231 	}
3232 
3233 	target = sf_lookup_target(sf, privp->port_wwn, lun);
3234 	if (lun != 0) {
3235 		/*
3236 		 * Since LUNs != 0 are queued up after LUN == 0, find LUN == 0
3237 		 * and enqueue the new LUN.
3238 		 */
3239 		if ((ptarget = sf_lookup_target(sf, privp->port_wwn,
3240 		    (int64_t)0)) ==	NULL) {
3241 			/*
3242 			 * Yeep -- no LUN 0?
3243 			 */
3244 			mutex_exit(&sf->sf_mutex);
3245 			sf_log(sf, CE_WARN, "target 0x%x "
3246 			    "lun %" PRIx64 ": No LUN 0\n", tnum, lun);
3247 			if (ntarget != NULL)
3248 				kmem_free(ntarget, sizeof (struct sf_target));
3249 			return (NULL);
3250 		}
3251 		mutex_enter(&ptarget->sft_mutex);
3252 		if (target != NULL && ptarget->sft_lip_cnt == sf->sf_lip_cnt &&
3253 		    ptarget->sft_state&SF_TARGET_OFFLINE) {
3254 			/* LUN 0 already finished, duplicate its state */
3255 			mutex_exit(&ptarget->sft_mutex);
3256 			sf_offline_target(sf, target);
3257 			mutex_exit(&sf->sf_mutex);
3258 			if (ntarget != NULL)
3259 				kmem_free(ntarget, sizeof (struct sf_target));
3260 			return (target);
3261 		} else if (target != NULL) {
3262 			/*
3263 			 * LUN 0 online or not examined yet.
3264 			 * Try to bring the LUN back online
3265 			 */
3266 			mutex_exit(&ptarget->sft_mutex);
3267 			mutex_enter(&target->sft_mutex);
3268 			target->sft_lip_cnt = privp->lip_cnt;
3269 			target->sft_state |= SF_TARGET_BUSY;
3270 			target->sft_state &= ~(SF_TARGET_OFFLINE|
3271 			    SF_TARGET_MARK);
3272 			target->sft_al_pa = (uchar_t)privp->dest_nport_id;
3273 			target->sft_hard_address = sf_switch_to_alpa[tnum];
3274 			mutex_exit(&target->sft_mutex);
3275 			mutex_exit(&sf->sf_mutex);
3276 			if (ntarget != NULL)
3277 				kmem_free(ntarget, sizeof (struct sf_target));
3278 			return (target);
3279 		}
3280 		mutex_exit(&ptarget->sft_mutex);
3281 		if (ntarget == NULL) {
3282 			mutex_exit(&sf->sf_mutex);
3283 			return (NULL);
3284 		}
3285 		/* Initialize new target structure */
3286 		bcopy((caddr_t)&privp->node_wwn,
3287 		    (caddr_t)&ntarget->sft_node_wwn, sizeof (privp->node_wwn));
3288 		bcopy((caddr_t)&privp->port_wwn,
3289 		    (caddr_t)&ntarget->sft_port_wwn, sizeof (privp->port_wwn));
3290 		ntarget->sft_lun.l = lun;
3291 #ifdef RAID_LUNS
3292 		ntarget->sft_lun.l = orig_lun;
3293 		ntarget->sft_raid_lun = (uint_t)lun;
3294 #endif
3295 		mutex_init(&ntarget->sft_mutex, NULL, MUTEX_DRIVER, NULL);
3296 		mutex_init(&ntarget->sft_pkt_mutex, NULL, MUTEX_DRIVER, NULL);
3297 		/* Don't let anyone use this till we finishup init. */
3298 		mutex_enter(&ntarget->sft_mutex);
3299 		mutex_enter(&ntarget->sft_pkt_mutex);
3300 
3301 		hash = SF_HASH(privp->port_wwn, lun);
3302 		ntarget->sft_next = sf->sf_wwn_lists[hash];
3303 		sf->sf_wwn_lists[hash] = ntarget;
3304 
3305 		ntarget->sft_lip_cnt = privp->lip_cnt;
3306 		ntarget->sft_al_pa = (uchar_t)privp->dest_nport_id;
3307 		ntarget->sft_hard_address = sf_switch_to_alpa[tnum];
3308 		ntarget->sft_device_type = DTYPE_UNKNOWN;
3309 		ntarget->sft_state = SF_TARGET_BUSY;
3310 		ntarget->sft_pkt_head = (struct sf_pkt *)&ntarget->
3311 		    sft_pkt_head;
3312 		ntarget->sft_pkt_tail = (struct sf_pkt *)&ntarget->
3313 		    sft_pkt_head;
3314 
3315 		mutex_enter(&ptarget->sft_mutex);
3316 		/* Traverse the list looking for this target */
3317 		for (target = ptarget; target->sft_next_lun;
3318 		    target = target->sft_next_lun) {
3319 			otarget = target->sft_next_lun;
3320 		}
3321 		ntarget->sft_next_lun = target->sft_next_lun;
3322 		target->sft_next_lun = ntarget;
3323 		mutex_exit(&ptarget->sft_mutex);
3324 		mutex_exit(&ntarget->sft_pkt_mutex);
3325 		mutex_exit(&ntarget->sft_mutex);
3326 		mutex_exit(&sf->sf_mutex);
3327 		return (ntarget);
3328 
3329 	}
3330 	if (target != NULL && target->sft_lip_cnt == sf->sf_lip_cnt) {
3331 		/* It's been touched this LIP -- duplicate WWNs */
3332 		sf_offline_target(sf, target); /* And all the baby targets */
3333 		mutex_exit(&sf->sf_mutex);
3334 		sf_log(sf, CE_WARN, "target 0x%x, duplicate port wwns\n",
3335 		    tnum);
3336 		if (ntarget != NULL) {
3337 			kmem_free(ntarget, sizeof (struct sf_target));
3338 		}
3339 		return (NULL);
3340 	}
3341 
3342 	if ((otarget = sf->sf_targets[tnum]) != NULL) {
3343 		/* Someone else is in our slot */
3344 		mutex_enter(&otarget->sft_mutex);
3345 		if (otarget->sft_lip_cnt == sf->sf_lip_cnt) {
3346 			mutex_exit(&otarget->sft_mutex);
3347 			sf_offline_target(sf, otarget);
3348 			if (target != NULL)
3349 				sf_offline_target(sf, target);
3350 			mutex_exit(&sf->sf_mutex);
3351 			sf_log(sf, CE_WARN,
3352 			    "target 0x%x, duplicate switch settings\n", tnum);
3353 			if (ntarget != NULL)
3354 				kmem_free(ntarget, sizeof (struct sf_target));
3355 			return (NULL);
3356 		}
3357 		mutex_exit(&otarget->sft_mutex);
3358 		if (bcmp((caddr_t)&privp->port_wwn, (caddr_t)&otarget->
3359 		    sft_port_wwn, sizeof (privp->port_wwn))) {
3360 			sf_offline_target(sf, otarget);
3361 			mutex_exit(&sf->sf_mutex);
3362 			sf_log(sf, CE_WARN, "wwn changed on target 0x%x\n",
3363 			    tnum);
3364 			bzero((caddr_t)&sf->sf_stats.tstats[tnum],
3365 			    sizeof (struct sf_target_stats));
3366 			mutex_enter(&sf->sf_mutex);
3367 		}
3368 	}
3369 
3370 	sf->sf_targets[tnum] = target;
3371 	if ((target = sf->sf_targets[tnum]) == NULL) {
3372 		if (ntarget == NULL) {
3373 			mutex_exit(&sf->sf_mutex);
3374 			return (NULL);
3375 		}
3376 		bcopy((caddr_t)&privp->node_wwn,
3377 		    (caddr_t)&ntarget->sft_node_wwn, sizeof (privp->node_wwn));
3378 		bcopy((caddr_t)&privp->port_wwn,
3379 		    (caddr_t)&ntarget->sft_port_wwn, sizeof (privp->port_wwn));
3380 		ntarget->sft_lun.l = lun;
3381 #ifdef RAID_LUNS
3382 		ntarget->sft_lun.l = orig_lun;
3383 		ntarget->sft_raid_lun = (uint_t)lun;
3384 #endif
3385 		mutex_init(&ntarget->sft_mutex, NULL, MUTEX_DRIVER, NULL);
3386 		mutex_init(&ntarget->sft_pkt_mutex, NULL, MUTEX_DRIVER, NULL);
3387 		mutex_enter(&ntarget->sft_mutex);
3388 		mutex_enter(&ntarget->sft_pkt_mutex);
3389 		hash = SF_HASH(privp->port_wwn, lun); /* lun 0 */
3390 		ntarget->sft_next = sf->sf_wwn_lists[hash];
3391 		sf->sf_wwn_lists[hash] = ntarget;
3392 
3393 		target = ntarget;
3394 		target->sft_lip_cnt = privp->lip_cnt;
3395 		target->sft_al_pa = (uchar_t)privp->dest_nport_id;
3396 		target->sft_hard_address = sf_switch_to_alpa[tnum];
3397 		target->sft_device_type = DTYPE_UNKNOWN;
3398 		target->sft_state = SF_TARGET_BUSY;
3399 		target->sft_pkt_head = (struct sf_pkt *)&target->
3400 		    sft_pkt_head;
3401 		target->sft_pkt_tail = (struct sf_pkt *)&target->
3402 		    sft_pkt_head;
3403 		sf->sf_targets[tnum] = target;
3404 		mutex_exit(&ntarget->sft_mutex);
3405 		mutex_exit(&ntarget->sft_pkt_mutex);
3406 		mutex_exit(&sf->sf_mutex);
3407 	} else {
3408 		mutex_enter(&target->sft_mutex);
3409 		target->sft_lip_cnt = privp->lip_cnt;
3410 		target->sft_state |= SF_TARGET_BUSY;
3411 		target->sft_state &= ~(SF_TARGET_OFFLINE|SF_TARGET_MARK);
3412 		target->sft_al_pa = (uchar_t)privp->dest_nport_id;
3413 		target->sft_hard_address = sf_switch_to_alpa[tnum];
3414 		mutex_exit(&target->sft_mutex);
3415 		mutex_exit(&sf->sf_mutex);
3416 		if (ntarget != NULL)
3417 			kmem_free(ntarget, sizeof (struct sf_target));
3418 	}
3419 	return (target);
3420 }
3421 
3422 
3423 /*
3424  * find the target for a given sf instance
3425  */
3426 /* ARGSUSED */
3427 static struct sf_target *
3428 #ifdef RAID_LUNS
3429 sf_lookup_target(struct sf *sf, uchar_t *wwn, int lun)
3430 #else
3431 sf_lookup_target(struct sf *sf, uchar_t *wwn, int64_t lun)
3432 #endif
3433 {
3434 	int hash;
3435 	struct sf_target *target;
3436 
3437 	ASSERT(mutex_owned(&sf->sf_mutex));
3438 	hash = SF_HASH(wwn, lun);
3439 
3440 	target = sf->sf_wwn_lists[hash];
3441 	while (target != NULL) {
3442 
3443 #ifndef	RAID_LUNS
3444 		if (bcmp((caddr_t)wwn, (caddr_t)&target->sft_port_wwn,
3445 		    sizeof (target->sft_port_wwn)) == 0 &&
3446 			target->sft_lun.l == lun)
3447 			break;
3448 #else
3449 		if (bcmp((caddr_t)wwn, (caddr_t)&target->sft_port_wwn,
3450 		    sizeof (target->sft_port_wwn)) == 0 &&
3451 			target->sft_raid_lun == lun)
3452 			break;
3453 #endif
3454 		target = target->sft_next;
3455 	}
3456 
3457 	return (target);
3458 }
3459 
3460 
3461 /*
3462  * Send out a REPORT_LUNS command.
3463  */
3464 static int
3465 sf_do_reportlun(struct sf *sf, struct sf_els_hdr *privp,
3466     struct sf_target *target)
3467 {
3468 	struct	fcal_packet	*fpkt = privp->fpkt;
3469 	ddi_dma_cookie_t	pcookie;
3470 	ddi_dma_handle_t	lun_dma_handle = NULL;
3471 	ddi_acc_handle_t	lun_acc_handle;
3472 	uint_t			ccount;
3473 	size_t			real_size;
3474 	caddr_t			lun_buf = NULL;
3475 	int			handle_bound = 0;
3476 	fc_frame_header_t	*hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
3477 	struct fcp_cmd		*reportlun = (struct fcp_cmd *)privp->cmd;
3478 	char			*msg = "Transport";
3479 
3480 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
3481 	    DDI_DMA_DONTWAIT, NULL, &lun_dma_handle) != DDI_SUCCESS) {
3482 		msg = "ddi_dma_alloc_handle()";
3483 		goto fail;
3484 	}
3485 
3486 	if (ddi_dma_mem_alloc(lun_dma_handle, REPORT_LUNS_SIZE,
3487 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
3488 	    DDI_DMA_DONTWAIT, NULL, &lun_buf,
3489 	    &real_size, &lun_acc_handle) != DDI_SUCCESS) {
3490 		msg = "ddi_dma_mem_alloc()";
3491 		goto fail;
3492 	}
3493 
3494 	if (real_size < REPORT_LUNS_SIZE) {
3495 		msg = "DMA mem < REPORT_LUNS_SIZE";
3496 		goto fail;
3497 	}
3498 
3499 	if (ddi_dma_addr_bind_handle(lun_dma_handle, NULL,
3500 	    lun_buf, real_size, DDI_DMA_READ |
3501 	    DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT,
3502 	    NULL, &pcookie, &ccount) != DDI_DMA_MAPPED) {
3503 		msg = "ddi_dma_addr_bind_handle()";
3504 		goto fail;
3505 	}
3506 	handle_bound = 1;
3507 
3508 	if (ccount != 1) {
3509 		msg = "ccount != 1";
3510 		goto fail;
3511 	}
3512 	privp->els_code = 0;
3513 	privp->target = target;
3514 	privp->data_dma_handle = lun_dma_handle;
3515 	privp->data_acc_handle = lun_acc_handle;
3516 	privp->data_buf = lun_buf;
3517 
3518 	fpkt->fcal_pkt_comp = sf_reportlun_callback;
3519 	fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 3;
3520 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type = CQ_TYPE_IO_READ;
3521 	fpkt->fcal_socal_request.sr_dataseg[0].fc_count =
3522 	    sizeof (struct fcp_cmd);
3523 	fpkt->fcal_socal_request.sr_dataseg[2].fc_base =
3524 	    (uint32_t)pcookie.dmac_address;
3525 	fpkt->fcal_socal_request.sr_dataseg[2].fc_count = pcookie.dmac_size;
3526 	fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt = pcookie.dmac_size;
3527 	hp->r_ctl = R_CTL_COMMAND;
3528 	hp->type = TYPE_SCSI_FCP;
3529 	bzero((caddr_t)reportlun, sizeof (struct fcp_cmd));
3530 	((union scsi_cdb *)reportlun->fcp_cdb)->scc_cmd = SCMD_REPORT_LUNS;
3531 	/* Now set the buffer size.  If DDI gave us extra, that's O.K. */
3532 	((union scsi_cdb *)reportlun->fcp_cdb)->scc5_count0 =
3533 	    (real_size&0x0ff);
3534 	((union scsi_cdb *)reportlun->fcp_cdb)->scc5_count1 =
3535 	    (real_size>>8)&0x0ff;
3536 	((union scsi_cdb *)reportlun->fcp_cdb)->scc5_count2 =
3537 	    (real_size>>16)&0x0ff;
3538 	((union scsi_cdb *)reportlun->fcp_cdb)->scc5_count3 =
3539 	    (real_size>>24)&0x0ff;
3540 	reportlun->fcp_cntl.cntl_read_data = 1;
3541 	reportlun->fcp_cntl.cntl_write_data = 0;
3542 	reportlun->fcp_data_len = pcookie.dmac_size;
3543 	reportlun->fcp_cntl.cntl_qtype = FCP_QTYPE_SIMPLE;
3544 
3545 	(void) ddi_dma_sync(lun_dma_handle, 0, 0, DDI_DMA_SYNC_FORDEV);
3546 	/* We know he's there, so this should be fast */
3547 	privp->timeout = sf_watchdog_time + SF_FCP_TIMEOUT;
3548 	if (sf_els_transport(sf, privp) == 1)
3549 		return (1);
3550 
3551 fail:
3552 	sf_log(sf, CE_WARN,
3553 	    "%s failure for REPORTLUN to target 0x%x\n",
3554 	    msg, sf_alpa_to_switch[privp->dest_nport_id]);
3555 	sf_els_free(fpkt);
3556 	if (lun_dma_handle != NULL) {
3557 		if (handle_bound)
3558 			(void) ddi_dma_unbind_handle(lun_dma_handle);
3559 		ddi_dma_free_handle(&lun_dma_handle);
3560 	}
3561 	if (lun_buf != NULL) {
3562 		ddi_dma_mem_free(&lun_acc_handle);
3563 	}
3564 	return (0);
3565 }
3566 
3567 /*
3568  * Handle the results of a REPORT_LUNS command:
3569  *	Create additional targets if necessary
3570  *	Initiate INQUIRYs on all LUNs.
3571  */
3572 static void
3573 sf_reportlun_callback(struct fcal_packet *fpkt)
3574 {
3575 	struct sf_els_hdr *privp = (struct sf_els_hdr *)fpkt->
3576 	    fcal_pkt_private;
3577 	struct scsi_report_luns *ptr =
3578 	    (struct scsi_report_luns *)privp->data_buf;
3579 	struct sf *sf = privp->sf;
3580 	struct sf_target *target = privp->target;
3581 	struct fcp_rsp *rsp = NULL;
3582 	int delayed_retry = 0;
3583 	int tid = sf_alpa_to_switch[target->sft_hard_address];
3584 	int i, free_pkt = 1;
3585 	short	ncmds;
3586 
3587 	mutex_enter(&sf->sf_mutex);
3588 	/* use as temporary state variable */
3589 	if (privp->timeout == SF_INVALID_TIMEOUT) {
3590 		mutex_exit(&sf->sf_mutex);
3591 		return;
3592 	}
3593 	if (privp->prev)
3594 		privp->prev->next = privp->next;
3595 	if (privp->next)
3596 		privp->next->prev = privp->prev;
3597 	if (sf->sf_els_list == privp)
3598 		sf->sf_els_list = privp->next;
3599 	privp->prev = privp->next = NULL;
3600 	mutex_exit(&sf->sf_mutex);
3601 	ncmds = fpkt->fcal_ncmds;
3602 	ASSERT(ncmds >= 0);
3603 	mutex_enter(&sf->sf_cmd_mutex);
3604 	sf->sf_ncmds = ncmds;
3605 	mutex_exit(&sf->sf_cmd_mutex);
3606 
3607 	if (fpkt->fcal_pkt_status == FCAL_STATUS_OK) {
3608 		(void) ddi_dma_sync(privp->rsp_dma_handle, 0,
3609 		    0, DDI_DMA_SYNC_FORKERNEL);
3610 
3611 		rsp = (struct fcp_rsp *)privp->rsp;
3612 	}
3613 	SF_DEBUG(1, (sf, CE_CONT,
3614 	    "!REPORTLUN to al_pa %x pkt status %x scsi status %x\n",
3615 	    privp->dest_nport_id,
3616 	    fpkt->fcal_pkt_status,
3617 	    rsp?rsp->fcp_u.fcp_status.scsi_status:0));
3618 
3619 		/* See if target simply does not support REPORT_LUNS. */
3620 	if (rsp && rsp->fcp_u.fcp_status.scsi_status == STATUS_CHECK &&
3621 	    rsp->fcp_u.fcp_status.sense_len_set &&
3622 	    rsp->fcp_sense_len >=
3623 		offsetof(struct scsi_extended_sense, es_qual_code)) {
3624 			struct scsi_extended_sense *sense;
3625 			sense = (struct scsi_extended_sense *)
3626 			((caddr_t)rsp + sizeof (struct fcp_rsp)
3627 				+ rsp->fcp_response_len);
3628 			if (sense->es_key == KEY_ILLEGAL_REQUEST) {
3629 				if (sense->es_add_code == 0x20) {
3630 					/* Fake LUN 0 */
3631 				SF_DEBUG(1, (sf, CE_CONT,
3632 					"!REPORTLUN Faking good "
3633 					"completion for alpa %x\n",
3634 					privp->dest_nport_id));
3635 					ptr->lun_list_len = FCP_LUN_SIZE;
3636 					ptr->lun[0] = 0;
3637 					rsp->fcp_u.fcp_status.scsi_status =
3638 						STATUS_GOOD;
3639 				} else if (sense->es_add_code == 0x25) {
3640 					SF_DEBUG(1, (sf, CE_CONT,
3641 					    "!REPORTLUN device alpa %x "
3642 					    "key %x code %x\n",
3643 					    privp->dest_nport_id,
3644 					    sense->es_key, sense->es_add_code));
3645 					    goto fail;
3646 				}
3647 			} else if (sense->es_key ==
3648 				KEY_UNIT_ATTENTION &&
3649 				sense->es_add_code == 0x29) {
3650 				SF_DEBUG(1, (sf, CE_CONT,
3651 					"!REPORTLUN device alpa %x was reset\n",
3652 					privp->dest_nport_id));
3653 			} else {
3654 				SF_DEBUG(1, (sf, CE_CONT,
3655 					"!REPORTLUN device alpa %x "
3656 					"key %x code %x\n",
3657 					privp->dest_nport_id,
3658 					sense->es_key, sense->es_add_code));
3659 /* XXXXXX The following is here to handle broken targets -- remove it later */
3660 				if (sf_reportlun_forever &&
3661 					sense->es_key == KEY_UNIT_ATTENTION)
3662 					goto retry;
3663 /* XXXXXX */
3664 				if (sense->es_key == KEY_NOT_READY)
3665 					delayed_retry = 1;
3666 				}
3667 		}
3668 
3669 	if (rsp && rsp->fcp_u.fcp_status.scsi_status == STATUS_GOOD) {
3670 		struct fcp_rsp_info *bep;
3671 
3672 		bep = (struct fcp_rsp_info *)(&rsp->
3673 		    fcp_response_len + 1);
3674 		if (!rsp->fcp_u.fcp_status.rsp_len_set ||
3675 		    bep->rsp_code == FCP_NO_FAILURE) {
3676 			(void) ddi_dma_sync(privp->data_dma_handle,
3677 			    0, 0, DDI_DMA_SYNC_FORKERNEL);
3678 
3679 			/* Convert from #bytes to #ints */
3680 			ptr->lun_list_len = ptr->lun_list_len >> 3;
3681 			SF_DEBUG(2, (sf, CE_CONT,
3682 			    "!REPORTLUN to al_pa %x succeeded: %d LUNs\n",
3683 			    privp->dest_nport_id, ptr->lun_list_len));
3684 			if (!ptr->lun_list_len) {
3685 				/* No LUNs? Ya gotta be kidding... */
3686 				sf_log(sf, CE_WARN,
3687 				    "SCSI violation -- "
3688 				    "target 0x%x reports no LUNs\n",
3689 				    sf_alpa_to_switch[
3690 				    privp->dest_nport_id]);
3691 				ptr->lun_list_len = 1;
3692 				ptr->lun[0] = 0;
3693 			}
3694 
3695 			mutex_enter(&sf->sf_mutex);
3696 			if (sf->sf_lip_cnt == privp->lip_cnt) {
3697 				sf->sf_device_count += ptr->lun_list_len - 1;
3698 			}
3699 
3700 			mutex_exit(&sf->sf_mutex);
3701 			for (i = 0; i < ptr->lun_list_len && privp->lip_cnt ==
3702 			    sf->sf_lip_cnt; i++) {
3703 				struct sf_els_hdr *nprivp;
3704 				struct fcal_packet *nfpkt;
3705 
3706 				/* LUN 0 is already in `target' */
3707 				if (ptr->lun[i] != 0) {
3708 					target = sf_create_target(sf,
3709 					    privp, tid, ptr->lun[i]);
3710 				}
3711 				nprivp = NULL;
3712 				nfpkt = NULL;
3713 				if (target) {
3714 					nfpkt = sf_els_alloc(sf,
3715 					    target->sft_al_pa,
3716 					    sizeof (struct sf_els_hdr),
3717 					    sizeof (union sf_els_cmd),
3718 					    sizeof (union sf_els_rsp),
3719 					    (caddr_t *)&nprivp,
3720 					    (caddr_t *)&rsp);
3721 					if (nprivp)
3722 						nprivp->lip_cnt =
3723 						    privp->lip_cnt;
3724 				}
3725 				if (nfpkt && nprivp &&
3726 				    (sf_do_inquiry(sf, nprivp, target) ==
3727 				    0)) {
3728 					mutex_enter(&sf->sf_mutex);
3729 					if (sf->sf_lip_cnt == privp->
3730 					    lip_cnt) {
3731 						sf->sf_device_count --;
3732 					}
3733 					sf_offline_target(sf, target);
3734 					mutex_exit(&sf->sf_mutex);
3735 				}
3736 			}
3737 			sf_els_free(fpkt);
3738 			return;
3739 		} else {
3740 			SF_DEBUG(1, (sf, CE_CONT,
3741 			    "!REPORTLUN al_pa %x fcp failure, "
3742 			    "fcp_rsp_code %x scsi status %x\n",
3743 			    privp->dest_nport_id, bep->rsp_code,
3744 			    rsp ? rsp->fcp_u.fcp_status.scsi_status:0));
3745 			goto fail;
3746 		}
3747 	}
3748 	if (rsp && ((rsp->fcp_u.fcp_status.scsi_status == STATUS_BUSY) ||
3749 	    (rsp->fcp_u.fcp_status.scsi_status == STATUS_QFULL))) {
3750 		delayed_retry = 1;
3751 	}
3752 
3753 	if (++(privp->retries) < sf_els_retries ||
3754 	    (delayed_retry && privp->retries < SF_BSY_RETRIES)) {
3755 /* XXXXXX The following is here to handle broken targets -- remove it later */
3756 retry:
3757 /* XXXXXX */
3758 		if (delayed_retry) {
3759 			privp->retries--;
3760 			privp->timeout = sf_watchdog_time + SF_BSY_TIMEOUT;
3761 			privp->delayed_retry = 1;
3762 		} else {
3763 			privp->timeout = sf_watchdog_time + SF_FCP_TIMEOUT;
3764 		}
3765 
3766 		privp->prev = NULL;
3767 		mutex_enter(&sf->sf_mutex);
3768 		if (privp->lip_cnt == sf->sf_lip_cnt) {
3769 			if (!delayed_retry)
3770 				SF_DEBUG(1, (sf, CE_WARN,
3771 				    "!REPORTLUN to al_pa %x failed, retrying\n",
3772 				    privp->dest_nport_id));
3773 			privp->next = sf->sf_els_list;
3774 			if (sf->sf_els_list != NULL)
3775 				sf->sf_els_list->prev = privp;
3776 			sf->sf_els_list = privp;
3777 			mutex_exit(&sf->sf_mutex);
3778 			if (!delayed_retry && soc_transport(sf->sf_sochandle,
3779 			    fpkt, FCAL_NOSLEEP, CQ_REQUEST_1) !=
3780 			    FCAL_TRANSPORT_SUCCESS) {
3781 				mutex_enter(&sf->sf_mutex);
3782 				if (privp->prev)
3783 					privp->prev->next = privp->next;
3784 				if (privp->next)
3785 					privp->next->prev = privp->prev;
3786 				if (sf->sf_els_list == privp)
3787 					sf->sf_els_list = privp->next;
3788 				mutex_exit(&sf->sf_mutex);
3789 				goto fail;
3790 			} else
3791 				return;
3792 		} else {
3793 			mutex_exit(&sf->sf_mutex);
3794 		}
3795 	} else {
3796 fail:
3797 
3798 		/* REPORT_LUN failed -- try inquiry */
3799 		if (sf_do_inquiry(sf, privp, target) != 0) {
3800 			return;
3801 		} else {
3802 			free_pkt = 0;
3803 		}
3804 		mutex_enter(&sf->sf_mutex);
3805 		if (sf->sf_lip_cnt == privp->lip_cnt) {
3806 			sf_log(sf, CE_WARN,
3807 			    "!REPORTLUN to target 0x%x failed\n",
3808 			    sf_alpa_to_switch[privp->dest_nport_id]);
3809 			sf_offline_target(sf, target);
3810 			sf->sf_device_count--;
3811 			ASSERT(sf->sf_device_count >= 0);
3812 			if (sf->sf_device_count == 0)
3813 			sf_finish_init(sf, privp->lip_cnt);
3814 		}
3815 		mutex_exit(&sf->sf_mutex);
3816 	}
3817 	if (free_pkt) {
3818 		sf_els_free(fpkt);
3819 	}
3820 }
3821 
3822 static int
3823 sf_do_inquiry(struct sf *sf, struct sf_els_hdr *privp,
3824     struct sf_target *target)
3825 {
3826 	struct	fcal_packet	*fpkt = privp->fpkt;
3827 	ddi_dma_cookie_t	pcookie;
3828 	ddi_dma_handle_t	inq_dma_handle = NULL;
3829 	ddi_acc_handle_t	inq_acc_handle;
3830 	uint_t			ccount;
3831 	size_t			real_size;
3832 	caddr_t			inq_buf = NULL;
3833 	int			handle_bound = FALSE;
3834 	fc_frame_header_t *hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
3835 	struct fcp_cmd		*inq = (struct fcp_cmd *)privp->cmd;
3836 	char			*msg = "Transport";
3837 
3838 
3839 	if (ddi_dma_alloc_handle(sf->sf_dip, sf->sf_sochandle->fcal_dmaattr,
3840 	    DDI_DMA_DONTWAIT, NULL, &inq_dma_handle) != DDI_SUCCESS) {
3841 		msg = "ddi_dma_alloc_handle()";
3842 		goto fail;
3843 	}
3844 
3845 	if (ddi_dma_mem_alloc(inq_dma_handle, SUN_INQSIZE,
3846 	    sf->sf_sochandle->fcal_accattr, DDI_DMA_CONSISTENT,
3847 	    DDI_DMA_DONTWAIT, NULL, &inq_buf,
3848 	    &real_size, &inq_acc_handle) != DDI_SUCCESS) {
3849 		msg = "ddi_dma_mem_alloc()";
3850 		goto fail;
3851 	}
3852 
3853 	if (real_size < SUN_INQSIZE) {
3854 		msg = "DMA mem < inquiry size";
3855 		goto fail;
3856 	}
3857 
3858 	if (ddi_dma_addr_bind_handle(inq_dma_handle, NULL,
3859 	    inq_buf, real_size, DDI_DMA_READ | DDI_DMA_CONSISTENT,
3860 	    DDI_DMA_DONTWAIT, NULL, &pcookie, &ccount) != DDI_DMA_MAPPED) {
3861 		msg = "ddi_dma_addr_bind_handle()";
3862 		goto fail;
3863 	}
3864 	handle_bound = TRUE;
3865 
3866 	if (ccount != 1) {
3867 		msg = "ccount != 1";
3868 		goto fail;
3869 	}
3870 	privp->els_code = 0;			/* not an ELS command */
3871 	privp->target = target;
3872 	privp->data_dma_handle = inq_dma_handle;
3873 	privp->data_acc_handle = inq_acc_handle;
3874 	privp->data_buf = inq_buf;
3875 	fpkt->fcal_pkt_comp = sf_inq_callback;
3876 	fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 3;
3877 	fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type = CQ_TYPE_IO_READ;
3878 	fpkt->fcal_socal_request.sr_dataseg[0].fc_count =
3879 	    sizeof (struct fcp_cmd);
3880 	fpkt->fcal_socal_request.sr_dataseg[2].fc_base =
3881 	    (uint32_t)pcookie.dmac_address;
3882 	fpkt->fcal_socal_request.sr_dataseg[2].fc_count = pcookie.dmac_size;
3883 	fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt = pcookie.dmac_size;
3884 	hp->r_ctl = R_CTL_COMMAND;
3885 	hp->type = TYPE_SCSI_FCP;
3886 	bzero((caddr_t)inq, sizeof (struct fcp_cmd));
3887 	((union scsi_cdb *)inq->fcp_cdb)->scc_cmd = SCMD_INQUIRY;
3888 	((union scsi_cdb *)inq->fcp_cdb)->g0_count0 = SUN_INQSIZE;
3889 	bcopy((caddr_t)&target->sft_lun.b, (caddr_t)&inq->fcp_ent_addr,
3890 	    FCP_LUN_SIZE);
3891 	inq->fcp_cntl.cntl_read_data = 1;
3892 	inq->fcp_cntl.cntl_write_data = 0;
3893 	inq->fcp_data_len = pcookie.dmac_size;
3894 	inq->fcp_cntl.cntl_qtype = FCP_QTYPE_SIMPLE;
3895 
3896 	(void) ddi_dma_sync(inq_dma_handle, (off_t)0, (size_t)0,
3897 	    DDI_DMA_SYNC_FORDEV);
3898 	privp->timeout = sf_watchdog_time + SF_FCP_TIMEOUT;
3899 	SF_DEBUG(5, (sf, CE_WARN,
3900 	    "!Sending INQUIRY to al_pa %x lun %" PRIx64 "\n",
3901 	    privp->dest_nport_id,
3902 	    SCSA_LUN(target)));
3903 	return (sf_els_transport(sf, privp));
3904 
3905 fail:
3906 	sf_log(sf, CE_WARN,
3907 	    "%s failure for INQUIRY to target 0x%x\n",
3908 	    msg, sf_alpa_to_switch[privp->dest_nport_id]);
3909 	sf_els_free(fpkt);
3910 	if (inq_dma_handle != NULL) {
3911 		if (handle_bound) {
3912 			(void) ddi_dma_unbind_handle(inq_dma_handle);
3913 		}
3914 		ddi_dma_free_handle(&inq_dma_handle);
3915 	}
3916 	if (inq_buf != NULL) {
3917 		ddi_dma_mem_free(&inq_acc_handle);
3918 	}
3919 	return (FALSE);
3920 }
3921 
3922 
3923 /*
3924  * called as the pkt_comp routine for INQ packets
3925  */
3926 static void
3927 sf_inq_callback(struct fcal_packet *fpkt)
3928 {
3929 	struct sf_els_hdr *privp = (struct sf_els_hdr *)fpkt->
3930 	    fcal_pkt_private;
3931 	struct scsi_inquiry *prt = (struct scsi_inquiry *)privp->data_buf;
3932 	struct sf *sf = privp->sf;
3933 	struct sf *tsf;
3934 	struct sf_target *target = privp->target;
3935 	struct fcp_rsp *rsp;
3936 	int delayed_retry = FALSE;
3937 	short	ncmds;
3938 
3939 
3940 	mutex_enter(&sf->sf_mutex);
3941 	/* use as temporary state variable */
3942 	if (privp->timeout == SF_INVALID_TIMEOUT) {
3943 		mutex_exit(&sf->sf_mutex);
3944 		return;
3945 	}
3946 	if (privp->prev != NULL) {
3947 		privp->prev->next = privp->next;
3948 	}
3949 	if (privp->next != NULL) {
3950 		privp->next->prev = privp->prev;
3951 	}
3952 	if (sf->sf_els_list == privp) {
3953 		sf->sf_els_list = privp->next;
3954 	}
3955 	privp->prev = privp->next = NULL;
3956 	mutex_exit(&sf->sf_mutex);
3957 	ncmds = fpkt->fcal_ncmds;
3958 	ASSERT(ncmds >= 0);
3959 	mutex_enter(&sf->sf_cmd_mutex);
3960 	sf->sf_ncmds = ncmds;
3961 	mutex_exit(&sf->sf_cmd_mutex);
3962 
3963 	if (fpkt->fcal_pkt_status == FCAL_STATUS_OK) {
3964 
3965 		(void) ddi_dma_sync(privp->rsp_dma_handle, (off_t)0,
3966 		    (size_t)0, DDI_DMA_SYNC_FORKERNEL);
3967 
3968 		rsp = (struct fcp_rsp *)privp->rsp;
3969 		SF_DEBUG(2, (sf, CE_CONT,
3970 		    "!INQUIRY to al_pa %x scsi status %x",
3971 		    privp->dest_nport_id, rsp->fcp_u.fcp_status.scsi_status));
3972 
3973 		if ((rsp->fcp_u.fcp_status.scsi_status == STATUS_GOOD) &&
3974 		    !rsp->fcp_u.fcp_status.resid_over &&
3975 		    (!rsp->fcp_u.fcp_status.resid_under ||
3976 		    ((SUN_INQSIZE - rsp->fcp_resid) >= SUN_MIN_INQLEN))) {
3977 			struct fcp_rsp_info *bep;
3978 
3979 			bep = (struct fcp_rsp_info *)(&rsp->
3980 			    fcp_response_len + 1);
3981 
3982 			if (!rsp->fcp_u.fcp_status.rsp_len_set ||
3983 			    (bep->rsp_code == FCP_NO_FAILURE)) {
3984 
3985 				SF_DEBUG(2, (sf, CE_CONT,
3986 				    "!INQUIRY to al_pa %x lun %" PRIx64
3987 				    " succeeded\n",
3988 				    privp->dest_nport_id, SCSA_LUN(target)));
3989 
3990 				(void) ddi_dma_sync(privp->data_dma_handle,
3991 				    (off_t)0, (size_t)0,
3992 				    DDI_DMA_SYNC_FORKERNEL);
3993 
3994 				mutex_enter(&sf->sf_mutex);
3995 
3996 				if (sf->sf_lip_cnt == privp->lip_cnt) {
3997 					mutex_enter(&target->sft_mutex);
3998 					target->sft_device_type =
3999 					    prt->inq_dtype;
4000 					bcopy(prt, &target->sft_inq,
4001 					    sizeof (*prt));
4002 					mutex_exit(&target->sft_mutex);
4003 					sf->sf_device_count--;
4004 					ASSERT(sf->sf_device_count >= 0);
4005 					if (sf->sf_device_count == 0) {
4006 						sf_finish_init(sf,
4007 						    privp->lip_cnt);
4008 					}
4009 				}
4010 				mutex_exit(&sf->sf_mutex);
4011 				sf_els_free(fpkt);
4012 				return;
4013 			}
4014 		} else if ((rsp->fcp_u.fcp_status.scsi_status ==
4015 		    STATUS_BUSY) ||
4016 		    (rsp->fcp_u.fcp_status.scsi_status == STATUS_QFULL) ||
4017 		    (rsp->fcp_u.fcp_status.scsi_status == STATUS_CHECK)) {
4018 			delayed_retry = TRUE;
4019 		}
4020 	} else {
4021 		SF_DEBUG(2, (sf, CE_CONT, "!INQUIRY to al_pa %x fc status %x",
4022 		    privp->dest_nport_id, fpkt->fcal_pkt_status));
4023 	}
4024 
4025 	if (++(privp->retries) < sf_els_retries ||
4026 	    (delayed_retry && privp->retries < SF_BSY_RETRIES)) {
4027 		if (fpkt->fcal_pkt_status == FCAL_STATUS_MAX_XCHG_EXCEEDED)  {
4028 			tsf = sf->sf_sibling;
4029 			if (tsf != NULL) {
4030 				mutex_enter(&tsf->sf_cmd_mutex);
4031 				tsf->sf_flag = 1;
4032 				tsf->sf_throttle = SF_DECR_DELTA;
4033 				mutex_exit(&tsf->sf_cmd_mutex);
4034 			}
4035 			delayed_retry = 1;
4036 		}
4037 		if (delayed_retry) {
4038 			privp->retries--;
4039 			privp->timeout = sf_watchdog_time + SF_BSY_TIMEOUT;
4040 			privp->delayed_retry = TRUE;
4041 		} else {
4042 			privp->timeout = sf_watchdog_time + SF_FCP_TIMEOUT;
4043 		}
4044 
4045 		privp->prev = NULL;
4046 		mutex_enter(&sf->sf_mutex);
4047 		if (privp->lip_cnt == sf->sf_lip_cnt) {
4048 			if (!delayed_retry) {
4049 				SF_DEBUG(1, (sf, CE_WARN,
4050 				    "INQUIRY to al_pa %x failed, retrying",
4051 				    privp->dest_nport_id));
4052 			}
4053 			privp->next = sf->sf_els_list;
4054 			if (sf->sf_els_list != NULL) {
4055 				sf->sf_els_list->prev = privp;
4056 			}
4057 			sf->sf_els_list = privp;
4058 			mutex_exit(&sf->sf_mutex);
4059 			/* if not delayed call transport to send a pkt */
4060 			if (!delayed_retry &&
4061 			    (soc_transport(sf->sf_sochandle, fpkt,
4062 			    FCAL_NOSLEEP, CQ_REQUEST_1) !=
4063 			    FCAL_TRANSPORT_SUCCESS)) {
4064 				mutex_enter(&sf->sf_mutex);
4065 				if (privp->prev != NULL) {
4066 					privp->prev->next = privp->next;
4067 				}
4068 				if (privp->next != NULL) {
4069 					privp->next->prev = privp->prev;
4070 				}
4071 				if (sf->sf_els_list == privp) {
4072 					sf->sf_els_list = privp->next;
4073 				}
4074 				mutex_exit(&sf->sf_mutex);
4075 				goto fail;
4076 			}
4077 			return;
4078 		}
4079 		mutex_exit(&sf->sf_mutex);
4080 	} else {
4081 fail:
4082 		mutex_enter(&sf->sf_mutex);
4083 		if (sf->sf_lip_cnt == privp->lip_cnt) {
4084 			sf_offline_target(sf, target);
4085 			sf_log(sf, CE_NOTE,
4086 			    "INQUIRY to target 0x%x lun %" PRIx64 " failed. "
4087 			    "Retry Count: %d\n",
4088 			    sf_alpa_to_switch[privp->dest_nport_id],
4089 			    SCSA_LUN(target),
4090 			    privp->retries);
4091 			sf->sf_device_count--;
4092 			ASSERT(sf->sf_device_count >= 0);
4093 			if (sf->sf_device_count == 0) {
4094 				sf_finish_init(sf, privp->lip_cnt);
4095 			}
4096 		}
4097 		mutex_exit(&sf->sf_mutex);
4098 	}
4099 	sf_els_free(fpkt);
4100 }
4101 
4102 
4103 static void
4104 sf_finish_init(struct sf *sf, int lip_cnt)
4105 {
4106 	int			i;		/* loop index */
4107 	int			cflag;
4108 	struct sf_target	*target;	/* current target */
4109 	dev_info_t		*dip;
4110 	struct sf_hp_elem	*elem;		/* hotplug element created */
4111 
4112 	SF_DEBUG(1, (sf, CE_WARN, "!sf_finish_init\n"));
4113 	ASSERT(mutex_owned(&sf->sf_mutex));
4114 
4115 	/* scan all hash queues */
4116 	for (i = 0; i < SF_NUM_HASH_QUEUES; i++) {
4117 		target = sf->sf_wwn_lists[i];
4118 		while (target != NULL) {
4119 			mutex_enter(&target->sft_mutex);
4120 
4121 			/* see if target is not offline */
4122 			if ((target->sft_state & SF_TARGET_OFFLINE)) {
4123 				/*
4124 				 * target already offline
4125 				 */
4126 				mutex_exit(&target->sft_mutex);
4127 				goto next_entry;
4128 			}
4129 
4130 			/*
4131 			 * target is not already offline -- see if it has
4132 			 * already been marked as ready to go offline
4133 			 */
4134 			if (target->sft_state & SF_TARGET_MARK) {
4135 				/*
4136 				 * target already marked, so take it offline
4137 				 */
4138 				mutex_exit(&target->sft_mutex);
4139 				sf_offline_target(sf, target);
4140 				goto next_entry;
4141 			}
4142 
4143 			/* clear target busy flag */
4144 			target->sft_state &= ~SF_TARGET_BUSY;
4145 
4146 			/* is target init not yet done ?? */
4147 			cflag = !(target->sft_state & SF_TARGET_INIT_DONE);
4148 
4149 			/* get pointer to target dip */
4150 			dip = target->sft_dip;
4151 
4152 			mutex_exit(&target->sft_mutex);
4153 			mutex_exit(&sf->sf_mutex);
4154 
4155 			if (cflag && (dip == NULL)) {
4156 				/*
4157 				 * target init not yet done &&
4158 				 * devinfo not yet created
4159 				 */
4160 				sf_create_devinfo(sf, target, lip_cnt);
4161 				mutex_enter(&sf->sf_mutex);
4162 				goto next_entry;
4163 			}
4164 
4165 			/*
4166 			 * target init already done || devinfo already created
4167 			 */
4168 			ASSERT(dip != NULL);
4169 			if (!sf_create_props(dip, target, lip_cnt)) {
4170 				/* a problem creating properties */
4171 				mutex_enter(&sf->sf_mutex);
4172 				goto next_entry;
4173 			}
4174 
4175 			/* create a new element for the hotplug list */
4176 			if ((elem = kmem_zalloc(sizeof (struct sf_hp_elem),
4177 			    KM_NOSLEEP)) != NULL) {
4178 
4179 				/* fill in the new element */
4180 				elem->dip = dip;
4181 				elem->target = target;
4182 				elem->what = SF_ONLINE;
4183 
4184 				/* add the new element into the hotplug list */
4185 				mutex_enter(&sf->sf_hp_daemon_mutex);
4186 				if (sf->sf_hp_elem_tail != NULL) {
4187 					sf->sf_hp_elem_tail->next = elem;
4188 					sf->sf_hp_elem_tail = elem;
4189 				} else {
4190 					/* this is the first element in list */
4191 					sf->sf_hp_elem_head =
4192 					    sf->sf_hp_elem_tail =
4193 					    elem;
4194 				}
4195 				cv_signal(&sf->sf_hp_daemon_cv);
4196 				mutex_exit(&sf->sf_hp_daemon_mutex);
4197 			} else {
4198 				/* could not allocate memory for element ?? */
4199 				(void) ndi_devi_online_async(dip, 0);
4200 			}
4201 
4202 			mutex_enter(&sf->sf_mutex);
4203 
4204 next_entry:
4205 			/* ensure no new LIPs have occurred */
4206 			if (sf->sf_lip_cnt != lip_cnt) {
4207 				return;
4208 			}
4209 			target = target->sft_next;
4210 		}
4211 
4212 		/* done scanning all targets in this queue */
4213 	}
4214 
4215 	/* done with all hash queues */
4216 
4217 	sf->sf_state = SF_STATE_ONLINE;
4218 	sf->sf_online_timer = 0;
4219 }
4220 
4221 
4222 /*
4223  * create devinfo node
4224  */
4225 static void
4226 sf_create_devinfo(struct sf *sf, struct sf_target *target, int lip_cnt)
4227 {
4228 	dev_info_t		*cdip = NULL;
4229 	char			*nname = NULL;
4230 	char			**compatible = NULL;
4231 	int			ncompatible;
4232 	struct scsi_inquiry	*inq = &target->sft_inq;
4233 	char			*scsi_binding_set;
4234 
4235 	/* get the 'scsi-binding-set' property */
4236 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, sf->sf_dip,
4237 	    DDI_PROP_NOTPROM | DDI_PROP_DONTPASS, "scsi-binding-set",
4238 	    &scsi_binding_set) != DDI_PROP_SUCCESS)
4239 		scsi_binding_set = NULL;
4240 
4241 	/* determine the node name and compatible */
4242 	scsi_hba_nodename_compatible_get(inq, scsi_binding_set,
4243 	    inq->inq_dtype, NULL, &nname, &compatible, &ncompatible);
4244 	if (scsi_binding_set)
4245 		ddi_prop_free(scsi_binding_set);
4246 
4247 	/* if nodename can't be determined then print a message and skip it */
4248 	if (nname == NULL) {
4249 #ifndef	RAID_LUNS
4250 		sf_log(sf, CE_WARN, "%s%d: no driver for device "
4251 		    "@w%02x%02x%02x%02x%02x%02x%02x%02x,%x\n"
4252 		    "    compatible: %s",
4253 		    ddi_driver_name(sf->sf_dip), ddi_get_instance(sf->sf_dip),
4254 		    target->sft_port_wwn[0], target->sft_port_wwn[1],
4255 		    target->sft_port_wwn[2], target->sft_port_wwn[3],
4256 		    target->sft_port_wwn[4], target->sft_port_wwn[5],
4257 		    target->sft_port_wwn[6], target->sft_port_wwn[7],
4258 		    target->sft_lun.l, *compatible);
4259 #else
4260 		sf_log(sf, CE_WARN, "%s%d: no driver for device "
4261 		    "@w%02x%02x%02x%02x%02x%02x%02x%02x,%x\n"
4262 		    "    compatible: %s",
4263 		    ddi_driver_name(sf->sf_dip), ddi_get_instance(sf->sf_dip),
4264 		    target->sft_port_wwn[0], target->sft_port_wwn[1],
4265 		    target->sft_port_wwn[2], target->sft_port_wwn[3],
4266 		    target->sft_port_wwn[4], target->sft_port_wwn[5],
4267 		    target->sft_port_wwn[6], target->sft_port_wwn[7],
4268 		    target->sft_raid_lun, *compatible);
4269 #endif
4270 		goto fail;
4271 	}
4272 
4273 	/* allocate the node */
4274 	if (ndi_devi_alloc(sf->sf_dip, nname,
4275 	    DEVI_SID_NODEID, &cdip) != NDI_SUCCESS) {
4276 		goto fail;
4277 	}
4278 
4279 	/* decorate the node with compatible */
4280 	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, cdip,
4281 	    "compatible", compatible, ncompatible) != DDI_PROP_SUCCESS) {
4282 		goto fail;
4283 	}
4284 
4285 	/* add addressing properties to the node */
4286 	if (sf_create_props(cdip, target, lip_cnt) != 1) {
4287 		goto fail;
4288 	}
4289 
4290 	mutex_enter(&target->sft_mutex);
4291 	if (target->sft_dip != NULL) {
4292 		mutex_exit(&target->sft_mutex);
4293 		goto fail;
4294 	}
4295 	target->sft_dip = cdip;
4296 	mutex_exit(&target->sft_mutex);
4297 
4298 	if (ndi_devi_online_async(cdip, 0) != DDI_SUCCESS) {
4299 		goto fail;
4300 	}
4301 
4302 	scsi_hba_nodename_compatible_free(nname, compatible);
4303 	return;
4304 
4305 fail:
4306 	scsi_hba_nodename_compatible_free(nname, compatible);
4307 	if (cdip != NULL) {
4308 		(void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, NODE_WWN_PROP);
4309 		(void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, PORT_WWN_PROP);
4310 		(void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, LIP_CNT_PROP);
4311 		(void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, TARGET_PROP);
4312 		(void) ndi_prop_remove(DDI_DEV_T_NONE, cdip, LUN_PROP);
4313 		if (ndi_devi_free(cdip) != NDI_SUCCESS) {
4314 			sf_log(sf, CE_WARN, "ndi_devi_free failed\n");
4315 		} else {
4316 			mutex_enter(&target->sft_mutex);
4317 			if (cdip == target->sft_dip) {
4318 				target->sft_dip = NULL;
4319 			}
4320 			mutex_exit(&target->sft_mutex);
4321 		}
4322 	}
4323 }
4324 
4325 /*
4326  * create required properties, returning TRUE iff we succeed, else
4327  * returning FALSE
4328  */
4329 static int
4330 sf_create_props(dev_info_t *cdip, struct sf_target *target, int lip_cnt)
4331 {
4332 	int tgt_id = sf_alpa_to_switch[target->sft_al_pa];
4333 
4334 
4335 	if (ndi_prop_update_byte_array(DDI_DEV_T_NONE,
4336 	    cdip, NODE_WWN_PROP, target->sft_node_wwn, FC_WWN_SIZE) !=
4337 	    DDI_PROP_SUCCESS) {
4338 		return (FALSE);
4339 	}
4340 
4341 	if (ndi_prop_update_byte_array(DDI_DEV_T_NONE,
4342 	    cdip, PORT_WWN_PROP, target->sft_port_wwn, FC_WWN_SIZE) !=
4343 	    DDI_PROP_SUCCESS) {
4344 		return (FALSE);
4345 	}
4346 
4347 	if (ndi_prop_update_int(DDI_DEV_T_NONE,
4348 	    cdip, LIP_CNT_PROP, lip_cnt) != DDI_PROP_SUCCESS) {
4349 		return (FALSE);
4350 	}
4351 
4352 	if (ndi_prop_update_int(DDI_DEV_T_NONE,
4353 	    cdip, TARGET_PROP, tgt_id) != DDI_PROP_SUCCESS) {
4354 		return (FALSE);
4355 	}
4356 
4357 #ifndef	RAID_LUNS
4358 	if (ndi_prop_update_int(DDI_DEV_T_NONE,
4359 	    cdip, LUN_PROP, target->sft_lun.l) != DDI_PROP_SUCCESS) {
4360 		return (0);
4361 	}
4362 #else
4363 	if (ndi_prop_update_int(DDI_DEV_T_NONE,
4364 	    cdip, LUN_PROP, target->sft_raid_lun) != DDI_PROP_SUCCESS) {
4365 		return (0);
4366 	}
4367 #endif
4368 
4369 	return (TRUE);
4370 }
4371 
4372 
4373 /*
4374  * called by the transport to offline a target
4375  */
4376 /* ARGSUSED */
4377 static void
4378 sf_offline_target(struct sf *sf, struct sf_target *target)
4379 {
4380 	dev_info_t *dip;
4381 	struct sf_target *next_target = NULL;
4382 	struct sf_hp_elem	*elem;
4383 
4384 	ASSERT(mutex_owned(&sf->sf_mutex));
4385 
4386 	if (sf_core && (sf_core & SF_CORE_OFFLINE_TARGET)) {
4387 		(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
4388 		sf_core = 0;
4389 	}
4390 
4391 	while (target != NULL) {
4392 		sf_log(sf, CE_NOTE,
4393 		    "!target 0x%x al_pa 0x%x lun %" PRIx64 " offlined\n",
4394 		    sf_alpa_to_switch[target->sft_al_pa],
4395 		    target->sft_al_pa, SCSA_LUN(target));
4396 		mutex_enter(&target->sft_mutex);
4397 		target->sft_state &= ~(SF_TARGET_BUSY|SF_TARGET_MARK);
4398 		target->sft_state |= SF_TARGET_OFFLINE;
4399 		mutex_exit(&target->sft_mutex);
4400 		mutex_exit(&sf->sf_mutex);
4401 
4402 		/* XXXX if this is LUN 0, offline all other LUNs */
4403 		if (next_target || target->sft_lun.l == 0)
4404 			next_target = target->sft_next_lun;
4405 
4406 		/* abort all cmds for this target */
4407 		sf_abort_all(sf, target, FALSE, sf->sf_lip_cnt, FALSE);
4408 
4409 		mutex_enter(&sf->sf_mutex);
4410 		mutex_enter(&target->sft_mutex);
4411 		if (target->sft_state & SF_TARGET_INIT_DONE) {
4412 			dip = target->sft_dip;
4413 			mutex_exit(&target->sft_mutex);
4414 			mutex_exit(&sf->sf_mutex);
4415 			(void) ndi_prop_remove(DDI_DEV_T_NONE, dip,
4416 			    TARGET_PROP);
4417 			(void) ndi_event_retrieve_cookie(sf->sf_event_hdl,
4418 			    dip, FCAL_REMOVE_EVENT, &sf_remove_eid,
4419 			    NDI_EVENT_NOPASS);
4420 			(void) ndi_event_run_callbacks(sf->sf_event_hdl,
4421 			    target->sft_dip, sf_remove_eid, NULL);
4422 
4423 			elem = kmem_zalloc(sizeof (struct sf_hp_elem),
4424 			    KM_NOSLEEP);
4425 			if (elem != NULL) {
4426 				elem->dip = dip;
4427 				elem->target = target;
4428 				elem->what = SF_OFFLINE;
4429 				mutex_enter(&sf->sf_hp_daemon_mutex);
4430 				if (sf->sf_hp_elem_tail != NULL) {
4431 					sf->sf_hp_elem_tail->next = elem;
4432 					sf->sf_hp_elem_tail = elem;
4433 				} else {
4434 					sf->sf_hp_elem_head =
4435 					    sf->sf_hp_elem_tail =
4436 					    elem;
4437 				}
4438 				cv_signal(&sf->sf_hp_daemon_cv);
4439 				mutex_exit(&sf->sf_hp_daemon_mutex);
4440 			} else {
4441 				/* don't do NDI_DEVI_REMOVE for now */
4442 				if (ndi_devi_offline(dip, 0) != NDI_SUCCESS) {
4443 					SF_DEBUG(1, (sf, CE_WARN,
4444 					    "target %x lun %" PRIx64 ", "
4445 					    "device offline failed",
4446 					    sf_alpa_to_switch[target->
4447 					    sft_al_pa],
4448 					    SCSA_LUN(target)));
4449 				} else {
4450 					SF_DEBUG(1, (sf, CE_NOTE,
4451 					    "target %x, lun %" PRIx64 ", "
4452 					    "device offline succeeded\n",
4453 					    sf_alpa_to_switch[target->
4454 					    sft_al_pa],
4455 					    SCSA_LUN(target)));
4456 				}
4457 			}
4458 			mutex_enter(&sf->sf_mutex);
4459 		} else {
4460 			mutex_exit(&target->sft_mutex);
4461 		}
4462 		target = next_target;
4463 	}
4464 }
4465 
4466 
4467 /*
4468  * routine to get/set a capability
4469  *
4470  * returning:
4471  *	1 (TRUE)	boolean capability is true (on get)
4472  *	0 (FALSE)	invalid capability, can't set capability (on set),
4473  *			or boolean capability is false (on get)
4474  *	-1 (UNDEFINED)	can't find capability (SCSA) or unsupported capability
4475  *	3		when getting SCSI version number
4476  *	AL_PA		when getting port initiator ID
4477  */
4478 static int
4479 sf_commoncap(struct scsi_address *ap, char *cap,
4480     int val, int tgtonly, int doset)
4481 {
4482 	struct sf *sf = ADDR2SF(ap);
4483 	int cidx;
4484 	int rval = FALSE;
4485 
4486 
4487 	if (cap == NULL) {
4488 		SF_DEBUG(3, (sf, CE_WARN, "sf_commoncap: invalid arg"));
4489 		return (rval);
4490 	}
4491 
4492 	/* get index of capability string */
4493 	if ((cidx = scsi_hba_lookup_capstr(cap)) == -1) {
4494 		/* can't find capability */
4495 		return (UNDEFINED);
4496 	}
4497 
4498 	if (doset) {
4499 		/*
4500 		 * Process setcap request.
4501 		 */
4502 
4503 		/*
4504 		 * At present, we can only set binary (0/1) values
4505 		 */
4506 		switch (cidx) {
4507 		case SCSI_CAP_ARQ:	/* can't set this capability */
4508 			break;
4509 		default:
4510 			SF_DEBUG(3, (sf, CE_WARN,
4511 			    "sf_setcap: unsupported %d", cidx));
4512 			rval = UNDEFINED;
4513 			break;
4514 		}
4515 
4516 		SF_DEBUG(4, (sf, CE_NOTE,
4517 		    "set cap: cap=%s,val=0x%x,tgtonly=0x%x"
4518 		    ",doset=0x%x,rval=%d\n",
4519 		    cap, val, tgtonly, doset, rval));
4520 
4521 	} else {
4522 		/*
4523 		 * Process getcap request.
4524 		 */
4525 		switch (cidx) {
4526 		case SCSI_CAP_DMA_MAX:
4527 			break;		/* don't' have this capability */
4528 		case SCSI_CAP_INITIATOR_ID:
4529 			rval = sf->sf_al_pa;
4530 			break;
4531 		case SCSI_CAP_ARQ:
4532 			rval = TRUE;	/* do have this capability */
4533 			break;
4534 		case SCSI_CAP_RESET_NOTIFICATION:
4535 		case SCSI_CAP_TAGGED_QING:
4536 			rval = TRUE;	/* do have this capability */
4537 			break;
4538 		case SCSI_CAP_SCSI_VERSION:
4539 			rval = 3;
4540 			break;
4541 		case SCSI_CAP_INTERCONNECT_TYPE:
4542 			rval = INTERCONNECT_FIBRE;
4543 			break;
4544 		default:
4545 			SF_DEBUG(4, (sf, CE_WARN,
4546 			    "sf_scsi_getcap: unsupported"));
4547 			rval = UNDEFINED;
4548 			break;
4549 		}
4550 		SF_DEBUG(4, (sf, CE_NOTE,
4551 		    "get cap: cap=%s,val=0x%x,tgtonly=0x%x,"
4552 		    "doset=0x%x,rval=%d\n",
4553 		    cap, val, tgtonly, doset, rval));
4554 	}
4555 
4556 	return (rval);
4557 }
4558 
4559 
4560 /*
4561  * called by the transport to get a capability
4562  */
4563 static int
4564 sf_getcap(struct scsi_address *ap, char *cap, int whom)
4565 {
4566 	return (sf_commoncap(ap, cap, 0, whom, FALSE));
4567 }
4568 
4569 
4570 /*
4571  * called by the transport to set a capability
4572  */
4573 static int
4574 sf_setcap(struct scsi_address *ap, char *cap, int value, int whom)
4575 {
4576 	return (sf_commoncap(ap, cap, value, whom, TRUE));
4577 }
4578 
4579 
4580 /*
4581  * called by the transport to abort a target
4582  */
4583 static int
4584 sf_abort(struct scsi_address *ap, struct scsi_pkt *pkt)
4585 {
4586 	struct sf *sf = ADDR2SF(ap);
4587 	struct sf_target *target = ADDR2TARGET(ap);
4588 	struct sf_pkt *cmd, *ncmd, *pcmd;
4589 	struct fcal_packet *fpkt;
4590 	int	rval = 0, t, my_rval = FALSE;
4591 	int	old_target_state;
4592 	int	lip_cnt;
4593 	int	tgt_id;
4594 	fc_frame_header_t	*hp;
4595 	int	deferred_destroy;
4596 
4597 	deferred_destroy = 0;
4598 
4599 	if (pkt != NULL) {
4600 		cmd = PKT2CMD(pkt);
4601 		fpkt = cmd->cmd_fp_pkt;
4602 		SF_DEBUG(2, (sf, CE_NOTE, "sf_abort packet %p\n",
4603 		    (void *)fpkt));
4604 		pcmd = NULL;
4605 		mutex_enter(&sf->sf_cmd_mutex);
4606 		ncmd = sf->sf_pkt_head;
4607 		while (ncmd != NULL) {
4608 			if (ncmd == cmd) {
4609 				if (pcmd != NULL) {
4610 					pcmd->cmd_next = cmd->cmd_next;
4611 				} else {
4612 					sf->sf_pkt_head = cmd->cmd_next;
4613 				}
4614 				cmd->cmd_flags &= ~CFLAG_IN_QUEUE;
4615 				cmd->cmd_state = SF_STATE_IDLE;
4616 				pkt->pkt_reason = CMD_ABORTED;
4617 				pkt->pkt_statistics |= STAT_ABORTED;
4618 				my_rval = TRUE;
4619 				break;
4620 			} else {
4621 				pcmd = ncmd;
4622 				ncmd = ncmd->cmd_next;
4623 			}
4624 		}
4625 		mutex_exit(&sf->sf_cmd_mutex);
4626 		if (ncmd == NULL) {
4627 			mutex_enter(&cmd->cmd_abort_mutex);
4628 			if (cmd->cmd_state == SF_STATE_ISSUED) {
4629 				cmd->cmd_state = SF_STATE_ABORTING;
4630 				cmd->cmd_timeout = sf_watchdog_time + 20;
4631 				mutex_exit(&cmd->cmd_abort_mutex);
4632 				/* call transport to abort command */
4633 				if (((rval = soc_abort(sf->sf_sochandle,
4634 				    sf->sf_socp, sf->sf_sochandle->fcal_portno,
4635 				    fpkt, 1)) == FCAL_ABORTED) ||
4636 				    (rval == FCAL_ABORT_FAILED)) {
4637 					my_rval = TRUE;
4638 					pkt->pkt_reason = CMD_ABORTED;
4639 					pkt->pkt_statistics |= STAT_ABORTED;
4640 					cmd->cmd_state = SF_STATE_IDLE;
4641 				} else if (rval == FCAL_BAD_ABORT) {
4642 					cmd->cmd_timeout = sf_watchdog_time
4643 					    + 20;
4644 					my_rval = FALSE;
4645 				} else {
4646 					SF_DEBUG(1, (sf, CE_NOTE,
4647 					    "Command Abort failed\n"));
4648 				}
4649 			} else {
4650 				mutex_exit(&cmd->cmd_abort_mutex);
4651 			}
4652 		}
4653 	} else {
4654 		SF_DEBUG(2, (sf, CE_NOTE, "sf_abort target\n"));
4655 		mutex_enter(&sf->sf_mutex);
4656 		lip_cnt = sf->sf_lip_cnt;
4657 		mutex_enter(&target->sft_mutex);
4658 		if (target->sft_state & (SF_TARGET_BUSY |
4659 		    SF_TARGET_OFFLINE)) {
4660 			mutex_exit(&target->sft_mutex);
4661 			return (rval);
4662 		}
4663 		old_target_state = target->sft_state;
4664 		target->sft_state |= SF_TARGET_BUSY;
4665 		mutex_exit(&target->sft_mutex);
4666 		mutex_exit(&sf->sf_mutex);
4667 
4668 		if ((pkt = sf_scsi_init_pkt(ap, NULL, NULL, 0,
4669 		    0, 0, 0, NULL, 0)) != NULL) {
4670 
4671 			cmd = PKT2CMD(pkt);
4672 			cmd->cmd_block->fcp_cntl.cntl_abort_tsk = 1;
4673 			cmd->cmd_fp_pkt->fcal_pkt_comp = NULL;
4674 			cmd->cmd_pkt->pkt_flags |= FLAG_NOINTR;
4675 
4676 			/* prepare the packet for transport */
4677 			if (sf_prepare_pkt(sf, cmd, target) == TRAN_ACCEPT) {
4678 
4679 				cmd->cmd_state = SF_STATE_ISSUED;
4680 				/*
4681 				 * call transport to send a pkt polled
4682 				 *
4683 				 * if that fails call the transport to abort it
4684 				 */
4685 				if (soc_transport_poll(sf->sf_sochandle,
4686 				    cmd->cmd_fp_pkt, SF_ABORT_TIMEOUT,
4687 				    CQ_REQUEST_1) == FCAL_TRANSPORT_SUCCESS) {
4688 					(void) ddi_dma_sync(
4689 					    cmd->cmd_cr_pool->rsp_dma_handle,
4690 					    (off_t)
4691 					    ((caddr_t)cmd->cmd_rsp_block -
4692 					    cmd->cmd_cr_pool->rsp_base),
4693 					    FCP_MAX_RSP_IU_SIZE,
4694 					    DDI_DMA_SYNC_FORKERNEL);
4695 					if (((struct fcp_rsp_info *)
4696 					    (&cmd->cmd_rsp_block->
4697 					    fcp_response_len + 1))->
4698 					    rsp_code == FCP_NO_FAILURE) {
4699 						/* abort cmds for this targ */
4700 						sf_abort_all(sf, target, TRUE,
4701 						    lip_cnt, TRUE);
4702 					} else {
4703 						hp = &cmd->cmd_fp_pkt->
4704 						    fcal_socal_request.
4705 						    sr_fc_frame_hdr;
4706 						tgt_id = sf_alpa_to_switch[
4707 						    (uchar_t)hp->d_id];
4708 						sf->sf_stats.tstats[tgt_id].
4709 						    task_mgmt_failures++;
4710 						SF_DEBUG(1, (sf, CE_NOTE,
4711 						    "Target %d Abort Task "
4712 						    "Set failed\n", hp->d_id));
4713 					}
4714 				} else {
4715 					mutex_enter(&cmd->cmd_abort_mutex);
4716 					if (cmd->cmd_state == SF_STATE_ISSUED) {
4717 					cmd->cmd_state = SF_STATE_ABORTING;
4718 					cmd->cmd_timeout = sf_watchdog_time
4719 					    + 20;
4720 					mutex_exit(&cmd->cmd_abort_mutex);
4721 					if ((t = soc_abort(sf->sf_sochandle,
4722 					    sf->sf_socp, sf->sf_sochandle->
4723 					    fcal_portno, cmd->cmd_fp_pkt, 1)) !=
4724 					    FCAL_ABORTED &&
4725 					    (t != FCAL_ABORT_FAILED)) {
4726 						sf_log(sf, CE_NOTE,
4727 						    "sf_abort failed, "
4728 						    "initiating LIP\n");
4729 						sf_force_lip(sf);
4730 						deferred_destroy = 1;
4731 					}
4732 					} else {
4733 					mutex_exit(&cmd->cmd_abort_mutex);
4734 					}
4735 				}
4736 			}
4737 			if (!deferred_destroy) {
4738 				cmd->cmd_fp_pkt->fcal_pkt_comp =
4739 				    sf_cmd_callback;
4740 				cmd->cmd_block->fcp_cntl.cntl_abort_tsk = 0;
4741 				sf_scsi_destroy_pkt(ap, pkt);
4742 				my_rval = TRUE;
4743 			}
4744 		}
4745 		mutex_enter(&sf->sf_mutex);
4746 		if (lip_cnt == sf->sf_lip_cnt) {
4747 			mutex_enter(&target->sft_mutex);
4748 			target->sft_state = old_target_state;
4749 			mutex_exit(&target->sft_mutex);
4750 		}
4751 		mutex_exit(&sf->sf_mutex);
4752 	}
4753 	return (my_rval);
4754 }
4755 
4756 
4757 /*
4758  * called by the transport and internally to reset a target
4759  */
4760 static int
4761 sf_reset(struct scsi_address *ap, int level)
4762 {
4763 	struct scsi_pkt *pkt;
4764 	struct fcal_packet *fpkt;
4765 	struct sf *sf = ADDR2SF(ap);
4766 	struct sf_target *target = ADDR2TARGET(ap), *ntarget;
4767 	struct sf_pkt *cmd;
4768 	int	rval = FALSE, t;
4769 	int	lip_cnt;
4770 	int	tgt_id, ret;
4771 	fc_frame_header_t	*hp;
4772 	int	deferred_destroy;
4773 
4774 	/* We don't support RESET_LUN yet. */
4775 	if (level == RESET_TARGET) {
4776 		struct sf_reset_list *p;
4777 
4778 		if ((p = kmem_alloc(sizeof (struct sf_reset_list), KM_NOSLEEP))
4779 		    == NULL)
4780 			return (rval);
4781 
4782 		SF_DEBUG(2, (sf, CE_NOTE, "sf_reset target\n"));
4783 		mutex_enter(&sf->sf_mutex);
4784 		/* All target resets go to LUN 0 */
4785 		if (target->sft_lun.l) {
4786 			target = sf_lookup_target(sf, target->sft_port_wwn, 0);
4787 		}
4788 		mutex_enter(&target->sft_mutex);
4789 		if (target->sft_state & (SF_TARGET_BUSY |
4790 		    SF_TARGET_OFFLINE)) {
4791 			mutex_exit(&target->sft_mutex);
4792 			mutex_exit(&sf->sf_mutex);
4793 			kmem_free(p, sizeof (struct sf_reset_list));
4794 			return (rval);
4795 		}
4796 		lip_cnt = sf->sf_lip_cnt;
4797 		target->sft_state |= SF_TARGET_BUSY;
4798 		for (ntarget = target->sft_next_lun;
4799 		    ntarget;
4800 		    ntarget = ntarget->sft_next_lun) {
4801 			mutex_enter(&ntarget->sft_mutex);
4802 			/*
4803 			 * XXXX If we supported RESET_LUN we should check here
4804 			 * to see if any LUN were being reset and somehow fail
4805 			 * that operation.
4806 			 */
4807 			ntarget->sft_state |= SF_TARGET_BUSY;
4808 			mutex_exit(&ntarget->sft_mutex);
4809 		}
4810 		mutex_exit(&target->sft_mutex);
4811 		mutex_exit(&sf->sf_mutex);
4812 
4813 		deferred_destroy = 0;
4814 		if ((pkt = sf_scsi_init_pkt(ap, NULL, NULL, 0,
4815 		    0, 0, 0, NULL, 0)) != NULL) {
4816 			cmd = PKT2CMD(pkt);
4817 			cmd->cmd_block->fcp_cntl.cntl_reset = 1;
4818 			cmd->cmd_fp_pkt->fcal_pkt_comp = NULL;
4819 			cmd->cmd_pkt->pkt_flags |= FLAG_NOINTR;
4820 
4821 			/* prepare the packet for transport */
4822 			if (sf_prepare_pkt(sf, cmd, target) == TRAN_ACCEPT) {
4823 				/* call transport to send a pkt polled */
4824 				cmd->cmd_state = SF_STATE_ISSUED;
4825 				if ((ret = soc_transport_poll(sf->sf_sochandle,
4826 				    cmd->cmd_fp_pkt, SF_ABORT_TIMEOUT,
4827 				    CQ_REQUEST_1)) == FCAL_TRANSPORT_SUCCESS) {
4828 					(void) ddi_dma_sync(cmd->cmd_cr_pool->
4829 					    rsp_dma_handle, (caddr_t)cmd->
4830 					    cmd_rsp_block - cmd->cmd_cr_pool->
4831 					    rsp_base, FCP_MAX_RSP_IU_SIZE,
4832 					    DDI_DMA_SYNC_FORKERNEL);
4833 					fpkt = cmd->cmd_fp_pkt;
4834 					if ((fpkt->fcal_pkt_status ==
4835 					    FCAL_STATUS_OK) &&
4836 					    (((struct fcp_rsp_info *)
4837 					    (&cmd->cmd_rsp_block->
4838 					    fcp_response_len + 1))->
4839 					    rsp_code == FCP_NO_FAILURE)) {
4840 						sf_log(sf, CE_NOTE,
4841 						    "!sf%d: Target 0x%x Reset "
4842 						    "successful\n",
4843 						    ddi_get_instance(\
4844 						    sf->sf_dip),
4845 						    sf_alpa_to_switch[
4846 						    target->sft_al_pa]);
4847 						rval = TRUE;
4848 					} else {
4849 						hp = &cmd->cmd_fp_pkt->
4850 						    fcal_socal_request.
4851 						    sr_fc_frame_hdr;
4852 						tgt_id = sf_alpa_to_switch[
4853 						    (uchar_t)hp->d_id];
4854 						sf->sf_stats.tstats[tgt_id].
4855 						    task_mgmt_failures++;
4856 						sf_log(sf, CE_NOTE,
4857 						    "!sf%d: Target 0x%x "
4858 						    "Reset failed."
4859 						    "Status code 0x%x "
4860 						    "Resp code 0x%x\n",
4861 						    ddi_get_instance(\
4862 						    sf->sf_dip),
4863 						    tgt_id,
4864 						    fpkt->fcal_pkt_status,
4865 						    ((struct fcp_rsp_info *)
4866 						    (&cmd->cmd_rsp_block->
4867 						    fcp_response_len + 1))->
4868 						    rsp_code);
4869 					}
4870 				} else {
4871 					sf_log(sf, CE_NOTE, "!sf%d: Target "
4872 					    "0x%x Reset Failed. Ret=%x\n",
4873 					    ddi_get_instance(sf->sf_dip),
4874 					    sf_alpa_to_switch[
4875 					    target->sft_al_pa], ret);
4876 					mutex_enter(&cmd->cmd_abort_mutex);
4877 					if (cmd->cmd_state == SF_STATE_ISSUED) {
4878 					/* call the transport to abort a cmd */
4879 					cmd->cmd_timeout = sf_watchdog_time
4880 					    + 20;
4881 					cmd->cmd_state = SF_STATE_ABORTING;
4882 					mutex_exit(&cmd->cmd_abort_mutex);
4883 					if (((t = soc_abort(sf->sf_sochandle,
4884 					    sf->sf_socp,
4885 					    sf->sf_sochandle->fcal_portno,
4886 					    cmd->cmd_fp_pkt, 1)) !=
4887 					    FCAL_ABORTED) &&
4888 					    (t != FCAL_ABORT_FAILED)) {
4889 						sf_log(sf, CE_NOTE,
4890 						    "!sf%d: Target 0x%x Reset "
4891 						    "failed. Abort Failed, "
4892 						    "forcing LIP\n",
4893 						    ddi_get_instance(
4894 						    sf->sf_dip),
4895 						    sf_alpa_to_switch[
4896 						    target->sft_al_pa]);
4897 						sf_force_lip(sf);
4898 						rval = TRUE;
4899 						deferred_destroy = 1;
4900 					}
4901 					} else {
4902 						mutex_exit
4903 						    (&cmd->cmd_abort_mutex);
4904 					}
4905 				}
4906 			}
4907 			/*
4908 			 * Defer releasing the packet if we abort returned with
4909 			 * a BAD_ABORT or timed out, because there is a
4910 			 * possibility that the ucode might return it.
4911 			 * We wait for at least 20s and let it be released
4912 			 * by the sf_watch thread
4913 			 */
4914 			if (!deferred_destroy) {
4915 				cmd->cmd_block->fcp_cntl.cntl_reset = 0;
4916 				cmd->cmd_fp_pkt->fcal_pkt_comp =
4917 				    sf_cmd_callback;
4918 				cmd->cmd_state = SF_STATE_IDLE;
4919 				/* for cache */
4920 				sf_scsi_destroy_pkt(ap, pkt);
4921 			}
4922 		} else {
4923 			cmn_err(CE_WARN, "!sf%d: Target 0x%x Reset Failed. "
4924 			    "Resource allocation error.\n",
4925 			    ddi_get_instance(sf->sf_dip),
4926 			    sf_alpa_to_switch[target->sft_al_pa]);
4927 		}
4928 		mutex_enter(&sf->sf_mutex);
4929 		if ((rval == TRUE) && (lip_cnt == sf->sf_lip_cnt)) {
4930 			p->target = target;
4931 			p->lip_cnt = lip_cnt;
4932 			p->timeout = ddi_get_lbolt() +
4933 			    drv_usectohz(SF_TARGET_RESET_DELAY);
4934 			p->next = sf->sf_reset_list;
4935 			sf->sf_reset_list = p;
4936 			mutex_exit(&sf->sf_mutex);
4937 			mutex_enter(&sf_global_mutex);
4938 			if (sf_reset_timeout_id == 0) {
4939 				sf_reset_timeout_id = timeout(
4940 				    sf_check_reset_delay, NULL,
4941 				    drv_usectohz(SF_TARGET_RESET_DELAY));
4942 			}
4943 			mutex_exit(&sf_global_mutex);
4944 		} else {
4945 			if (lip_cnt == sf->sf_lip_cnt) {
4946 				mutex_enter(&target->sft_mutex);
4947 				target->sft_state &= ~SF_TARGET_BUSY;
4948 				for (ntarget = target->sft_next_lun;
4949 				    ntarget;
4950 				    ntarget = ntarget->sft_next_lun) {
4951 					mutex_enter(&ntarget->sft_mutex);
4952 					ntarget->sft_state &= ~SF_TARGET_BUSY;
4953 					mutex_exit(&ntarget->sft_mutex);
4954 				}
4955 				mutex_exit(&target->sft_mutex);
4956 			}
4957 			mutex_exit(&sf->sf_mutex);
4958 			kmem_free(p, sizeof (struct sf_reset_list));
4959 		}
4960 	} else {
4961 		mutex_enter(&sf->sf_mutex);
4962 		if ((sf->sf_state == SF_STATE_OFFLINE) &&
4963 		    (sf_watchdog_time < sf->sf_timer)) {
4964 			/*
4965 			 * We are currently in a lip, so let this one
4966 			 * finish before forcing another one.
4967 			 */
4968 			mutex_exit(&sf->sf_mutex);
4969 			return (TRUE);
4970 		}
4971 		mutex_exit(&sf->sf_mutex);
4972 		sf_log(sf, CE_NOTE, "!sf:Target driver initiated lip\n");
4973 		sf_force_lip(sf);
4974 		rval = TRUE;
4975 	}
4976 	return (rval);
4977 }
4978 
4979 
4980 /*
4981  * abort all commands for a target
4982  *
4983  * if try_abort is set then send an abort
4984  * if abort is set then this is abort, else this is a reset
4985  */
4986 static void
4987 sf_abort_all(struct sf *sf, struct sf_target *target, int abort, int
4988     lip_cnt, int try_abort)
4989 {
4990 	struct sf_target *ntarget;
4991 	struct sf_pkt *cmd, *head = NULL, *tail = NULL, *pcmd = NULL, *tcmd;
4992 	struct fcal_packet *fpkt;
4993 	struct scsi_pkt *pkt;
4994 	int rval = FCAL_ABORTED;
4995 
4996 	/*
4997 	 * First pull all commands for all LUNs on this target out of the
4998 	 * overflow list.  We can tell it's the same target by comparing
4999 	 * the node WWN.
5000 	 */
5001 	mutex_enter(&sf->sf_mutex);
5002 	if (lip_cnt == sf->sf_lip_cnt) {
5003 		mutex_enter(&sf->sf_cmd_mutex);
5004 		cmd = sf->sf_pkt_head;
5005 		while (cmd != NULL) {
5006 			ntarget = ADDR2TARGET(&cmd->cmd_pkt->
5007 			    pkt_address);
5008 			if (ntarget == target) {
5009 				if (pcmd != NULL)
5010 					pcmd->cmd_next = cmd->cmd_next;
5011 				else
5012 					sf->sf_pkt_head = cmd->cmd_next;
5013 				if (sf->sf_pkt_tail == cmd) {
5014 					sf->sf_pkt_tail = pcmd;
5015 					if (pcmd != NULL)
5016 						pcmd->cmd_next = NULL;
5017 				}
5018 				tcmd = cmd->cmd_next;
5019 				if (head == NULL) {
5020 					head = cmd;
5021 					tail = cmd;
5022 				} else {
5023 					tail->cmd_next = cmd;
5024 					tail = cmd;
5025 				}
5026 				cmd->cmd_next = NULL;
5027 				cmd = tcmd;
5028 			} else {
5029 				pcmd = cmd;
5030 				cmd = cmd->cmd_next;
5031 			}
5032 		}
5033 		mutex_exit(&sf->sf_cmd_mutex);
5034 	}
5035 	mutex_exit(&sf->sf_mutex);
5036 
5037 	/*
5038 	 * Now complete all the commands on our list.  In the process,
5039 	 * the completion routine may take the commands off the target
5040 	 * lists.
5041 	 */
5042 	cmd = head;
5043 	while (cmd != NULL) {
5044 		pkt = cmd->cmd_pkt;
5045 		if (abort) {
5046 			pkt->pkt_reason = CMD_ABORTED;
5047 			pkt->pkt_statistics |= STAT_ABORTED;
5048 		} else {
5049 			pkt->pkt_reason = CMD_RESET;
5050 			pkt->pkt_statistics |= STAT_DEV_RESET;
5051 		}
5052 		cmd->cmd_flags &= ~CFLAG_IN_QUEUE;
5053 		cmd->cmd_state = SF_STATE_IDLE;
5054 		cmd = cmd->cmd_next;
5055 		/*
5056 		 * call the packet completion routine only for
5057 		 * non-polled commands. Ignore the polled commands as
5058 		 * they timeout and will be handled differently
5059 		 */
5060 		if ((pkt->pkt_comp) && !(pkt->pkt_flags & FLAG_NOINTR))
5061 			(*pkt->pkt_comp)(pkt);
5062 
5063 	}
5064 
5065 	/*
5066 	 * Finally get all outstanding commands for each LUN, and abort them if
5067 	 * they've been issued, and call the completion routine.
5068 	 * For the case where sf_offline_target is called from sf_watch
5069 	 * due to a Offline Timeout, it is quite possible that the soc+
5070 	 * ucode is hosed and therefore  cannot return the commands.
5071 	 * Clear up all the issued commands as well.
5072 	 * Try_abort will be false only if sf_abort_all is coming from
5073 	 * sf_target_offline.
5074 	 */
5075 
5076 	if (try_abort || sf->sf_state == SF_STATE_OFFLINE) {
5077 		mutex_enter(&target->sft_pkt_mutex);
5078 		cmd = tcmd = target->sft_pkt_head;
5079 		while (cmd != (struct sf_pkt *)&target->sft_pkt_head) {
5080 			fpkt = cmd->cmd_fp_pkt;
5081 			pkt = cmd->cmd_pkt;
5082 			mutex_enter(&cmd->cmd_abort_mutex);
5083 			if ((cmd->cmd_state == SF_STATE_ISSUED) &&
5084 			    (fpkt->fcal_cmd_state &
5085 			    FCAL_CMD_IN_TRANSPORT) &&
5086 			    ((fpkt->fcal_cmd_state & FCAL_CMD_COMPLETE) ==
5087 			    0) && !(pkt->pkt_flags & FLAG_NOINTR)) {
5088 				cmd->cmd_state = SF_STATE_ABORTING;
5089 				cmd->cmd_timeout = sf_watchdog_time +
5090 				    cmd->cmd_pkt->pkt_time + 20;
5091 				mutex_exit(&cmd->cmd_abort_mutex);
5092 				mutex_exit(&target->sft_pkt_mutex);
5093 				if (try_abort) {
5094 					/* call the transport to abort a pkt */
5095 					rval = soc_abort(sf->sf_sochandle,
5096 					    sf->sf_socp,
5097 					    sf->sf_sochandle->fcal_portno,
5098 					    fpkt, 1);
5099 				}
5100 				if ((rval == FCAL_ABORTED) ||
5101 				    (rval == FCAL_ABORT_FAILED)) {
5102 					if (abort) {
5103 						pkt->pkt_reason = CMD_ABORTED;
5104 						pkt->pkt_statistics |=
5105 						    STAT_ABORTED;
5106 					} else {
5107 						pkt->pkt_reason = CMD_RESET;
5108 						pkt->pkt_statistics |=
5109 						    STAT_DEV_RESET;
5110 					}
5111 					cmd->cmd_state = SF_STATE_IDLE;
5112 					if (pkt->pkt_comp)
5113 						(*pkt->pkt_comp)(pkt);
5114 				}
5115 				mutex_enter(&sf->sf_mutex);
5116 				if (lip_cnt != sf->sf_lip_cnt) {
5117 					mutex_exit(&sf->sf_mutex);
5118 					return;
5119 				}
5120 				mutex_exit(&sf->sf_mutex);
5121 				mutex_enter(&target->sft_pkt_mutex);
5122 				cmd = target->sft_pkt_head;
5123 			} else {
5124 				mutex_exit(&cmd->cmd_abort_mutex);
5125 				cmd = cmd->cmd_forw;
5126 			}
5127 		}
5128 		mutex_exit(&target->sft_pkt_mutex);
5129 	}
5130 }
5131 
5132 
5133 /*
5134  * called by the transport to start a packet
5135  */
5136 static int
5137 sf_start(struct scsi_address *ap, struct scsi_pkt *pkt)
5138 {
5139 	struct sf *sf = ADDR2SF(ap);
5140 	struct sf_target *target = ADDR2TARGET(ap);
5141 	struct sf_pkt *cmd = PKT2CMD(pkt);
5142 	int rval;
5143 
5144 
5145 	SF_DEBUG(6, (sf, CE_NOTE, "sf_start\n"));
5146 
5147 	if (cmd->cmd_state == SF_STATE_ISSUED) {
5148 		cmn_err(CE_PANIC, "sf: issuing packet twice 0x%p\n",
5149 		    (void *)cmd);
5150 	}
5151 
5152 	/* prepare the packet for transport */
5153 	if ((rval = sf_prepare_pkt(sf, cmd, target)) != TRAN_ACCEPT) {
5154 		return (rval);
5155 	}
5156 
5157 	if (target->sft_state & (SF_TARGET_BUSY|SF_TARGET_OFFLINE)) {
5158 		if (target->sft_state & SF_TARGET_OFFLINE) {
5159 			return (TRAN_FATAL_ERROR);
5160 		}
5161 		if (pkt->pkt_flags & FLAG_NOINTR) {
5162 			return (TRAN_BUSY);
5163 		}
5164 		mutex_enter(&sf->sf_cmd_mutex);
5165 		sf->sf_use_lock = TRUE;
5166 		goto enque;
5167 	}
5168 
5169 
5170 	/* if no interrupts then do polled I/O */
5171 	if (pkt->pkt_flags & FLAG_NOINTR) {
5172 		return (sf_dopoll(sf, cmd));
5173 	}
5174 
5175 	/* regular interrupt-driven I/O */
5176 
5177 	if (!sf->sf_use_lock) {
5178 
5179 		/* locking no needed */
5180 
5181 		cmd->cmd_timeout = cmd->cmd_pkt->pkt_time ?
5182 		    sf_watchdog_time + cmd->cmd_pkt->pkt_time : 0;
5183 		cmd->cmd_state = SF_STATE_ISSUED;
5184 
5185 		/* call the transport to send a pkt */
5186 		if (soc_transport(sf->sf_sochandle, cmd->cmd_fp_pkt,
5187 		    FCAL_NOSLEEP, CQ_REQUEST_1) != FCAL_TRANSPORT_SUCCESS) {
5188 			cmd->cmd_state = SF_STATE_IDLE;
5189 			return (TRAN_BADPKT);
5190 		}
5191 		return (TRAN_ACCEPT);
5192 	}
5193 
5194 	/* regular I/O using locking */
5195 
5196 	mutex_enter(&sf->sf_cmd_mutex);
5197 	if ((sf->sf_ncmds >= sf->sf_throttle) ||
5198 	    (sf->sf_pkt_head != NULL)) {
5199 enque:
5200 		/*
5201 		 * either we're throttling back or there are already commands
5202 		 * on the queue, so enqueue this one for later
5203 		 */
5204 		cmd->cmd_flags |= CFLAG_IN_QUEUE;
5205 		if (sf->sf_pkt_head != NULL) {
5206 			/* add to the queue */
5207 			sf->sf_pkt_tail->cmd_next = cmd;
5208 			cmd->cmd_next = NULL;
5209 			sf->sf_pkt_tail = cmd;
5210 		} else {
5211 			/* this is the first entry in the queue */
5212 			sf->sf_pkt_head = sf->sf_pkt_tail = cmd;
5213 			cmd->cmd_next = NULL;
5214 		}
5215 		mutex_exit(&sf->sf_cmd_mutex);
5216 		return (TRAN_ACCEPT);
5217 	}
5218 
5219 	/*
5220 	 * start this packet now
5221 	 */
5222 
5223 	/* still have cmd mutex */
5224 	return (sf_start_internal(sf, cmd));
5225 }
5226 
5227 
5228 /*
5229  * internal routine to start a packet from the queue now
5230  *
5231  * enter with cmd mutex held and leave with it released
5232  */
5233 static int
5234 sf_start_internal(struct sf *sf, struct sf_pkt *cmd)
5235 {
5236 	/* we have the cmd mutex */
5237 	sf->sf_ncmds++;
5238 	mutex_exit(&sf->sf_cmd_mutex);
5239 
5240 	ASSERT(cmd->cmd_state != SF_STATE_ISSUED);
5241 	SF_DEBUG(6, (sf, CE_NOTE, "sf_start_internal\n"));
5242 
5243 	cmd->cmd_timeout = cmd->cmd_pkt->pkt_time ? sf_watchdog_time +
5244 	    cmd->cmd_pkt->pkt_time : 0;
5245 	cmd->cmd_state = SF_STATE_ISSUED;
5246 
5247 	/* call transport to send the pkt */
5248 	if (soc_transport(sf->sf_sochandle, cmd->cmd_fp_pkt, FCAL_NOSLEEP,
5249 	    CQ_REQUEST_1) != FCAL_TRANSPORT_SUCCESS) {
5250 		cmd->cmd_state = SF_STATE_IDLE;
5251 		mutex_enter(&sf->sf_cmd_mutex);
5252 		sf->sf_ncmds--;
5253 		mutex_exit(&sf->sf_cmd_mutex);
5254 		return (TRAN_BADPKT);
5255 	}
5256 	return (TRAN_ACCEPT);
5257 }
5258 
5259 
5260 /*
5261  * prepare a packet for transport
5262  */
5263 static int
5264 sf_prepare_pkt(struct sf *sf, struct sf_pkt *cmd, struct sf_target *target)
5265 {
5266 	struct fcp_cmd *fcmd = cmd->cmd_block;
5267 
5268 /* XXXX Need to set the LUN ? */
5269 	bcopy((caddr_t)&target->sft_lun.b,
5270 	    (caddr_t)&fcmd->fcp_ent_addr,
5271 	    FCP_LUN_SIZE);
5272 	cmd->cmd_pkt->pkt_reason = CMD_CMPLT;
5273 	cmd->cmd_pkt->pkt_state = 0;
5274 	cmd->cmd_pkt->pkt_statistics = 0;
5275 
5276 
5277 	if ((cmd->cmd_pkt->pkt_comp == NULL) &&
5278 	    ((cmd->cmd_pkt->pkt_flags & FLAG_NOINTR) == 0)) {
5279 		return (TRAN_BADPKT);
5280 	}
5281 
5282 	/* invalidate imp field(s) of rsp block */
5283 	cmd->cmd_rsp_block->fcp_u.i_fcp_status = SF_BAD_DMA_MAGIC;
5284 
5285 	/* set up amt of I/O to do */
5286 	if (cmd->cmd_flags & CFLAG_DMAVALID) {
5287 		cmd->cmd_pkt->pkt_resid = cmd->cmd_dmacount;
5288 		if (cmd->cmd_flags & CFLAG_CMDIOPB) {
5289 			(void) ddi_dma_sync(cmd->cmd_dmahandle, 0, 0,
5290 			    DDI_DMA_SYNC_FORDEV);
5291 		}
5292 	} else {
5293 		cmd->cmd_pkt->pkt_resid = 0;
5294 	}
5295 
5296 	/* set up the Tagged Queuing type */
5297 	if (cmd->cmd_pkt->pkt_flags & FLAG_HTAG) {
5298 		fcmd->fcp_cntl.cntl_qtype = FCP_QTYPE_HEAD_OF_Q;
5299 	} else if (cmd->cmd_pkt->pkt_flags & FLAG_OTAG) {
5300 		fcmd->fcp_cntl.cntl_qtype = FCP_QTYPE_ORDERED;
5301 	}
5302 
5303 	/*
5304 	 * Sync the cmd segment
5305 	 */
5306 	(void) ddi_dma_sync(cmd->cmd_cr_pool->cmd_dma_handle,
5307 	    (caddr_t)fcmd - cmd->cmd_cr_pool->cmd_base,
5308 	    sizeof (struct fcp_cmd), DDI_DMA_SYNC_FORDEV);
5309 
5310 	sf_fill_ids(sf, cmd, target);
5311 	return (TRAN_ACCEPT);
5312 }
5313 
5314 
5315 /*
5316  * fill in packet hdr source and destination IDs and hdr byte count
5317  */
5318 static void
5319 sf_fill_ids(struct sf *sf, struct sf_pkt *cmd, struct sf_target *target)
5320 {
5321 	struct fcal_packet *fpkt = cmd->cmd_fp_pkt;
5322 	fc_frame_header_t	*hp;
5323 
5324 
5325 	hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
5326 	hp->d_id = target->sft_al_pa;
5327 	hp->s_id = sf->sf_al_pa;
5328 	fpkt->fcal_socal_request.sr_soc_hdr.sh_byte_cnt =
5329 	    cmd->cmd_dmacookie.dmac_size;
5330 }
5331 
5332 
5333 /*
5334  * do polled I/O using transport
5335  */
5336 static int
5337 sf_dopoll(struct sf *sf, struct sf_pkt *cmd)
5338 {
5339 	int timeout;
5340 	int rval;
5341 
5342 
5343 	mutex_enter(&sf->sf_cmd_mutex);
5344 	sf->sf_ncmds++;
5345 	mutex_exit(&sf->sf_cmd_mutex);
5346 
5347 	timeout = cmd->cmd_pkt->pkt_time ? cmd->cmd_pkt->pkt_time
5348 	    : SF_POLL_TIMEOUT;
5349 	cmd->cmd_timeout = 0;
5350 	cmd->cmd_fp_pkt->fcal_pkt_comp = NULL;
5351 	cmd->cmd_state = SF_STATE_ISSUED;
5352 
5353 	/* call transport to send a pkt polled */
5354 	rval = soc_transport_poll(sf->sf_sochandle, cmd->cmd_fp_pkt,
5355 	    timeout*1000000, CQ_REQUEST_1);
5356 	mutex_enter(&cmd->cmd_abort_mutex);
5357 	cmd->cmd_fp_pkt->fcal_pkt_comp = sf_cmd_callback;
5358 	if (rval != FCAL_TRANSPORT_SUCCESS) {
5359 		if (rval == FCAL_TRANSPORT_TIMEOUT) {
5360 			cmd->cmd_state = SF_STATE_ABORTING;
5361 			mutex_exit(&cmd->cmd_abort_mutex);
5362 			(void) sf_target_timeout(sf, cmd);
5363 		} else {
5364 			mutex_exit(&cmd->cmd_abort_mutex);
5365 		}
5366 		cmd->cmd_state = SF_STATE_IDLE;
5367 		cmd->cmd_fp_pkt->fcal_pkt_comp = sf_cmd_callback;
5368 		mutex_enter(&sf->sf_cmd_mutex);
5369 		sf->sf_ncmds--;
5370 		mutex_exit(&sf->sf_cmd_mutex);
5371 		return (TRAN_BADPKT);
5372 	}
5373 	mutex_exit(&cmd->cmd_abort_mutex);
5374 	cmd->cmd_fp_pkt->fcal_pkt_comp = sf_cmd_callback;
5375 	sf_cmd_callback(cmd->cmd_fp_pkt);
5376 	return (TRAN_ACCEPT);
5377 }
5378 
5379 
5380 /* a shortcut for defining debug messages below */
5381 #ifdef	DEBUG
5382 #define	SF_DMSG1(s)		msg1 = s
5383 #else
5384 #define	SF_DMSG1(s)		/* do nothing */
5385 #endif
5386 
5387 
5388 /*
5389  * the pkt_comp callback for command packets
5390  */
5391 static void
5392 sf_cmd_callback(struct fcal_packet *fpkt)
5393 {
5394 	struct sf_pkt *cmd = (struct sf_pkt *)fpkt->fcal_pkt_private;
5395 	struct scsi_pkt *pkt = cmd->cmd_pkt;
5396 	struct sf *sf = ADDR2SF(&pkt->pkt_address);
5397 	struct sf_target *target = ADDR2TARGET(&pkt->pkt_address);
5398 	struct fcp_rsp *rsp;
5399 	char *msg1 = NULL;
5400 	char *msg2 = NULL;
5401 	short ncmds;
5402 	int tgt_id;
5403 	int good_scsi_status = TRUE;
5404 
5405 
5406 
5407 	if (cmd->cmd_state == SF_STATE_IDLE) {
5408 		cmn_err(CE_PANIC, "sf: completing idle packet 0x%p\n",
5409 		    (void *)cmd);
5410 	}
5411 
5412 	mutex_enter(&cmd->cmd_abort_mutex);
5413 	if (cmd->cmd_state == SF_STATE_ABORTING) {
5414 		/* cmd already being aborted -- nothing to do */
5415 		mutex_exit(&cmd->cmd_abort_mutex);
5416 		return;
5417 	}
5418 
5419 	cmd->cmd_state = SF_STATE_IDLE;
5420 	mutex_exit(&cmd->cmd_abort_mutex);
5421 
5422 	if (fpkt->fcal_pkt_status == FCAL_STATUS_OK) {
5423 
5424 		(void) ddi_dma_sync(cmd->cmd_cr_pool->rsp_dma_handle,
5425 		    (caddr_t)cmd->cmd_rsp_block - cmd->cmd_cr_pool->rsp_base,
5426 		    FCP_MAX_RSP_IU_SIZE, DDI_DMA_SYNC_FORKERNEL);
5427 
5428 		rsp = (struct fcp_rsp *)cmd->cmd_rsp_block;
5429 
5430 		if (rsp->fcp_u.i_fcp_status == SF_BAD_DMA_MAGIC) {
5431 
5432 			if (sf_core && (sf_core & SF_CORE_BAD_DMA)) {
5433 				sf_token = (int *)(uintptr_t)
5434 				    fpkt->fcal_socal_request.\
5435 				    sr_soc_hdr.sh_request_token;
5436 				(void) soc_take_core(sf->sf_sochandle,
5437 				    sf->sf_socp);
5438 			}
5439 
5440 			pkt->pkt_reason = CMD_INCOMPLETE;
5441 			pkt->pkt_state = STATE_GOT_BUS;
5442 			pkt->pkt_statistics |= STAT_ABORTED;
5443 
5444 		} else {
5445 
5446 			pkt->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
5447 			    STATE_SENT_CMD | STATE_GOT_STATUS;
5448 			pkt->pkt_resid = 0;
5449 			if (cmd->cmd_flags & CFLAG_DMAVALID) {
5450 				pkt->pkt_state |= STATE_XFERRED_DATA;
5451 			}
5452 
5453 			if ((pkt->pkt_scbp != NULL) &&
5454 			    ((*(pkt->pkt_scbp) =
5455 			    rsp->fcp_u.fcp_status.scsi_status)
5456 			    != STATUS_GOOD)) {
5457 				good_scsi_status = FALSE;
5458 			/*
5459 			 * The next two checks make sure that if there
5460 			 * is no sense data or a valid response and
5461 			 * the command came back with check condition,
5462 			 * the command should be retried
5463 			 */
5464 				if (!rsp->fcp_u.fcp_status.rsp_len_set &&
5465 				    !rsp->fcp_u.fcp_status.sense_len_set) {
5466 					pkt->pkt_state &= ~STATE_XFERRED_DATA;
5467 					pkt->pkt_resid = cmd->cmd_dmacount;
5468 				}
5469 			}
5470 
5471 			if ((cmd->cmd_flags & CFLAG_CMDIOPB) &&
5472 			    (pkt->pkt_state & STATE_XFERRED_DATA)) {
5473 				(void) ddi_dma_sync(cmd->cmd_dmahandle, 0,
5474 				    (uint_t)0, DDI_DMA_SYNC_FORCPU);
5475 			}
5476 			/*
5477 			 * Update the transfer resid, if appropriate
5478 			 */
5479 			if (rsp->fcp_u.fcp_status.resid_over ||
5480 			    rsp->fcp_u.fcp_status.resid_under)
5481 				pkt->pkt_resid = rsp->fcp_resid;
5482 
5483 			/*
5484 			 * Check to see if the SCSI command failed.
5485 			 *
5486 			 */
5487 
5488 			/*
5489 			 * First see if we got a FCP protocol error.
5490 			 */
5491 			if (rsp->fcp_u.fcp_status.rsp_len_set) {
5492 				struct fcp_rsp_info *bep;
5493 
5494 				bep = (struct fcp_rsp_info *)
5495 				    (&rsp->fcp_response_len + 1);
5496 				if (bep->rsp_code != FCP_NO_FAILURE) {
5497 						pkt->pkt_reason = CMD_TRAN_ERR;
5498 					tgt_id = pkt->pkt_address.a_target;
5499 					switch (bep->rsp_code) {
5500 					case FCP_CMND_INVALID:
5501 						SF_DMSG1("FCP_RSP FCP_CMND "
5502 						    "fields invalid");
5503 						break;
5504 					case FCP_TASK_MGMT_NOT_SUPPTD:
5505 						SF_DMSG1("FCP_RSP Task"
5506 						    "Management Function"
5507 						    "Not Supported");
5508 						break;
5509 					case FCP_TASK_MGMT_FAILED:
5510 						SF_DMSG1("FCP_RSP Task "
5511 						    "Management Function"
5512 						    "Failed");
5513 						sf->sf_stats.tstats[tgt_id].
5514 						    task_mgmt_failures++;
5515 						break;
5516 					case FCP_DATA_RO_MISMATCH:
5517 						SF_DMSG1("FCP_RSP FCP_DATA RO "
5518 						    "mismatch with "
5519 						    "FCP_XFER_RDY DATA_RO");
5520 						sf->sf_stats.tstats[tgt_id].
5521 						    data_ro_mismatches++;
5522 						break;
5523 					case FCP_DL_LEN_MISMATCH:
5524 						SF_DMSG1("FCP_RSP FCP_DATA "
5525 						    "length "
5526 						    "different than BURST_LEN");
5527 						sf->sf_stats.tstats[tgt_id].
5528 						    dl_len_mismatches++;
5529 						break;
5530 					default:
5531 						SF_DMSG1("FCP_RSP invalid "
5532 						    "RSP_CODE");
5533 						break;
5534 					}
5535 				}
5536 			}
5537 
5538 			/*
5539 			 * See if we got a SCSI error with sense data
5540 			 */
5541 			if (rsp->fcp_u.fcp_status.sense_len_set) {
5542 				uchar_t rqlen = min(rsp->fcp_sense_len,
5543 				    sizeof (struct scsi_extended_sense));
5544 				caddr_t sense = (caddr_t)rsp +
5545 				    sizeof (struct fcp_rsp) +
5546 				    rsp->fcp_response_len;
5547 				struct scsi_arq_status *arq;
5548 				struct scsi_extended_sense *sensep =
5549 				    (struct scsi_extended_sense *)sense;
5550 
5551 				if (rsp->fcp_u.fcp_status.scsi_status !=
5552 				    STATUS_GOOD) {
5553 				if (rsp->fcp_u.fcp_status.scsi_status
5554 				    == STATUS_CHECK) {
5555 					if (sensep->es_key ==
5556 					    KEY_RECOVERABLE_ERROR)
5557 						good_scsi_status = 1;
5558 					if (sensep->es_key ==
5559 					    KEY_UNIT_ATTENTION &&
5560 					    sensep->es_add_code == 0x3f &&
5561 					    sensep->es_qual_code == 0x0e) {
5562 						/* REPORT_LUNS_HAS_CHANGED */
5563 						sf_log(sf, CE_NOTE,
5564 						"!REPORT_LUNS_HAS_CHANGED\n");
5565 						sf_force_lip(sf);
5566 					}
5567 				}
5568 				}
5569 
5570 				if ((pkt->pkt_scbp != NULL) &&
5571 				    (cmd->cmd_scblen >=
5572 					sizeof (struct scsi_arq_status))) {
5573 
5574 				pkt->pkt_state |= STATE_ARQ_DONE;
5575 
5576 				arq = (struct scsi_arq_status *)pkt->pkt_scbp;
5577 				/*
5578 				 * copy out sense information
5579 				 */
5580 				bcopy(sense, (caddr_t)&arq->sts_sensedata,
5581 				    rqlen);
5582 				arq->sts_rqpkt_resid =
5583 				    sizeof (struct scsi_extended_sense) -
5584 					rqlen;
5585 				*((uchar_t *)&arq->sts_rqpkt_status) =
5586 				    STATUS_GOOD;
5587 				arq->sts_rqpkt_reason = 0;
5588 				arq->sts_rqpkt_statistics = 0;
5589 				arq->sts_rqpkt_state = STATE_GOT_BUS |
5590 				    STATE_GOT_TARGET | STATE_SENT_CMD |
5591 				    STATE_GOT_STATUS | STATE_ARQ_DONE |
5592 				    STATE_XFERRED_DATA;
5593 			    }
5594 				target->sft_alive = TRUE;
5595 			}
5596 
5597 			/*
5598 			 * The firmware returns the number of bytes actually
5599 			 * xfered into/out of host. Compare this with what
5600 			 * we asked and if it is different, we lost frames ?
5601 			 */
5602 			if ((pkt->pkt_reason == 0) && (pkt->pkt_resid == 0) &&
5603 			    (good_scsi_status) &&
5604 			    (pkt->pkt_state & STATE_XFERRED_DATA) &&
5605 			    (!(cmd->cmd_flags & CFLAG_CMDIOPB)) &&
5606 			    (target->sft_device_type != DTYPE_ESI)) {
5607 				int byte_cnt =
5608 				    fpkt->fcal_socal_request.
5609 				    sr_soc_hdr.sh_byte_cnt;
5610 				if (cmd->cmd_flags & CFLAG_DMASEND) {
5611 					if (byte_cnt != 0) {
5612 					sf_log(sf, CE_NOTE,
5613 					    "!sf_cmd_callback: Lost Frame: "
5614 					    "(write) received 0x%x expected"
5615 					    " 0x%x target 0x%x\n",
5616 					    byte_cnt, cmd->cmd_dmacount,
5617 					    sf_alpa_to_switch[
5618 					    target->sft_al_pa]);
5619 					pkt->pkt_reason = CMD_INCOMPLETE;
5620 					pkt->pkt_statistics |= STAT_ABORTED;
5621 					}
5622 				} else if (byte_cnt < cmd->cmd_dmacount) {
5623 					sf_log(sf, CE_NOTE,
5624 					    "!sf_cmd_callback: "
5625 					    "Lost Frame: (read) "
5626 					    "received 0x%x expected 0x%x "
5627 					    "target 0x%x\n", byte_cnt,
5628 					    cmd->cmd_dmacount,
5629 					    sf_alpa_to_switch[
5630 					    target->sft_al_pa]);
5631 					pkt->pkt_reason = CMD_INCOMPLETE;
5632 					pkt->pkt_statistics |= STAT_ABORTED;
5633 				}
5634 			}
5635 		}
5636 
5637 	} else {
5638 
5639 		/* pkt status was not ok */
5640 
5641 		switch (fpkt->fcal_pkt_status) {
5642 
5643 		case FCAL_STATUS_ERR_OFFLINE:
5644 			SF_DMSG1("Fibre Channel Offline");
5645 			mutex_enter(&target->sft_mutex);
5646 			if (!(target->sft_state & SF_TARGET_OFFLINE)) {
5647 				target->sft_state |= (SF_TARGET_BUSY
5648 				    | SF_TARGET_MARK);
5649 			}
5650 			mutex_exit(&target->sft_mutex);
5651 			(void) ndi_event_retrieve_cookie(sf->sf_event_hdl,
5652 			    target->sft_dip, FCAL_REMOVE_EVENT,
5653 			    &sf_remove_eid, NDI_EVENT_NOPASS);
5654 			(void) ndi_event_run_callbacks(sf->sf_event_hdl,
5655 			    target->sft_dip, sf_remove_eid, NULL);
5656 			pkt->pkt_reason = CMD_TRAN_ERR;
5657 			pkt->pkt_statistics |= STAT_BUS_RESET;
5658 			break;
5659 
5660 		case FCAL_STATUS_MAX_XCHG_EXCEEDED:
5661 			sf_throttle(sf);
5662 			sf->sf_use_lock = TRUE;
5663 			pkt->pkt_reason = CMD_TRAN_ERR;
5664 			pkt->pkt_state = STATE_GOT_BUS;
5665 			pkt->pkt_statistics |= STAT_ABORTED;
5666 			break;
5667 
5668 		case FCAL_STATUS_TIMEOUT:
5669 			SF_DMSG1("Fibre Channel Timeout");
5670 			pkt->pkt_reason = CMD_TIMEOUT;
5671 			break;
5672 
5673 		case FCAL_STATUS_ERR_OVERRUN:
5674 			SF_DMSG1("CMD_DATA_OVR");
5675 			pkt->pkt_reason = CMD_DATA_OVR;
5676 			break;
5677 
5678 		case FCAL_STATUS_UNKNOWN_CQ_TYPE:
5679 			SF_DMSG1("Unknown CQ type");
5680 			pkt->pkt_reason = CMD_TRAN_ERR;
5681 			break;
5682 
5683 		case FCAL_STATUS_BAD_SEG_CNT:
5684 			SF_DMSG1("Bad SEG CNT");
5685 			pkt->pkt_reason = CMD_TRAN_ERR;
5686 			break;
5687 
5688 		case FCAL_STATUS_BAD_XID:
5689 			SF_DMSG1("Fibre Channel Invalid X_ID");
5690 			pkt->pkt_reason = CMD_TRAN_ERR;
5691 			break;
5692 
5693 		case FCAL_STATUS_XCHG_BUSY:
5694 			SF_DMSG1("Fibre Channel Exchange Busy");
5695 			pkt->pkt_reason = CMD_TRAN_ERR;
5696 			break;
5697 
5698 		case FCAL_STATUS_INSUFFICIENT_CQES:
5699 			SF_DMSG1("Insufficient CQEs");
5700 			pkt->pkt_reason = CMD_TRAN_ERR;
5701 			break;
5702 
5703 		case FCAL_STATUS_ALLOC_FAIL:
5704 			SF_DMSG1("ALLOC FAIL");
5705 			pkt->pkt_reason = CMD_TRAN_ERR;
5706 			break;
5707 
5708 		case FCAL_STATUS_BAD_SID:
5709 			SF_DMSG1("Fibre Channel Invalid S_ID");
5710 			pkt->pkt_reason = CMD_TRAN_ERR;
5711 			break;
5712 
5713 		case FCAL_STATUS_INCOMPLETE_DMA_ERR:
5714 			if (sf_core && (sf_core & SF_CORE_INCOMPLETE_DMA)) {
5715 				sf_token = (int *)(uintptr_t)
5716 				    fpkt->fcal_socal_request.\
5717 				    sr_soc_hdr.sh_request_token;
5718 				(void) soc_take_core(sf->sf_sochandle,
5719 				    sf->sf_socp);
5720 				sf_core = 0;
5721 			}
5722 			msg2 =
5723 			"INCOMPLETE DMA XFER due to bad SOC+ card, replace HBA";
5724 			pkt->pkt_reason = CMD_INCOMPLETE;
5725 			pkt->pkt_state = STATE_GOT_BUS;
5726 			pkt->pkt_statistics |= STAT_ABORTED;
5727 			break;
5728 
5729 		case FCAL_STATUS_CRC_ERR:
5730 			msg2 = "Fibre Channel CRC Error on frames";
5731 			pkt->pkt_reason = CMD_INCOMPLETE;
5732 			pkt->pkt_state = STATE_GOT_BUS;
5733 			pkt->pkt_statistics |= STAT_ABORTED;
5734 			break;
5735 
5736 		case FCAL_STATUS_NO_SEQ_INIT:
5737 			SF_DMSG1("Fibre Channel Seq Init Error");
5738 			pkt->pkt_reason = CMD_TRAN_ERR;
5739 			break;
5740 
5741 		case  FCAL_STATUS_OPEN_FAIL:
5742 			pkt->pkt_reason = CMD_TRAN_ERR;
5743 			SF_DMSG1("Fibre Channel Open Failure");
5744 			if ((target->sft_state & (SF_TARGET_BUSY |
5745 			    SF_TARGET_MARK | SF_TARGET_OFFLINE)) == 0) {
5746 				sf_log(sf, CE_NOTE,
5747 				    "!Open failure to target 0x%x "
5748 				    "forcing LIP\n",
5749 				    sf_alpa_to_switch[target->sft_al_pa]);
5750 				sf_force_lip(sf);
5751 			}
5752 			break;
5753 
5754 
5755 		case FCAL_STATUS_ONLINE_TIMEOUT:
5756 			SF_DMSG1("Fibre Channel Online Timeout");
5757 			pkt->pkt_reason = CMD_TRAN_ERR;
5758 			break;
5759 
5760 		default:
5761 			SF_DMSG1("Unknown FC Status");
5762 			pkt->pkt_reason = CMD_TRAN_ERR;
5763 			break;
5764 		}
5765 	}
5766 
5767 #ifdef	DEBUG
5768 	/*
5769 	 * msg1 will be non-NULL if we've detected some sort of error
5770 	 */
5771 	if (msg1 != NULL && sfdebug >= 4) {
5772 		sf_log(sf, CE_WARN,
5773 		    "!Transport error on cmd=0x%p target=0x%x:  %s\n",
5774 		    (void *)fpkt, pkt->pkt_address.a_target, msg1);
5775 	}
5776 #endif
5777 
5778 	if (msg2 != NULL) {
5779 		sf_log(sf, CE_WARN, "!Transport error on target=0x%x:  %s\n",
5780 		    pkt->pkt_address.a_target, msg2);
5781 	}
5782 
5783 	ncmds = fpkt->fcal_ncmds;
5784 	ASSERT(ncmds >= 0);
5785 	if (ncmds >= (sf->sf_throttle - SF_HI_CMD_DELTA)) {
5786 #ifdef DEBUG
5787 		if (!sf->sf_use_lock) {
5788 			SF_DEBUG(4, (sf, CE_NOTE, "use lock flag on\n"));
5789 		}
5790 #endif
5791 		sf->sf_use_lock = TRUE;
5792 	}
5793 
5794 	mutex_enter(&sf->sf_cmd_mutex);
5795 	sf->sf_ncmds = ncmds;
5796 	sf_throttle_start(sf);
5797 	mutex_exit(&sf->sf_cmd_mutex);
5798 
5799 	if (!msg1 && !msg2)
5800 		SF_DEBUG(6, (sf, CE_NOTE, "Completing pkt 0x%p\n",
5801 		    (void *)pkt));
5802 	if (pkt->pkt_comp != NULL) {
5803 		(*pkt->pkt_comp)(pkt);
5804 	}
5805 }
5806 
5807 #undef	SF_DMSG1
5808 
5809 
5810 
5811 /*
5812  * start throttling for this instance
5813  */
5814 static void
5815 sf_throttle_start(struct sf *sf)
5816 {
5817 	struct sf_pkt *cmd, *prev_cmd = NULL;
5818 	struct scsi_pkt *pkt;
5819 	struct sf_target *target;
5820 
5821 
5822 	ASSERT(mutex_owned(&sf->sf_cmd_mutex));
5823 
5824 	cmd = sf->sf_pkt_head;
5825 	while ((cmd != NULL) &&
5826 	    (sf->sf_state == SF_STATE_ONLINE) &&
5827 	    (sf->sf_ncmds < sf->sf_throttle)) {
5828 
5829 		pkt = CMD2PKT(cmd);
5830 
5831 		target = ADDR2TARGET(&pkt->pkt_address);
5832 		if (target->sft_state & SF_TARGET_BUSY) {
5833 			/* this command is busy -- go to next */
5834 			ASSERT(cmd->cmd_state != SF_STATE_ISSUED);
5835 			prev_cmd = cmd;
5836 			cmd = cmd->cmd_next;
5837 			continue;
5838 		}
5839 
5840 		ASSERT(cmd->cmd_state != SF_STATE_ISSUED);
5841 
5842 		/* this cmd not busy and not issued */
5843 
5844 		/* remove this packet from the queue */
5845 		if (sf->sf_pkt_head == cmd) {
5846 			/* this was the first packet */
5847 			sf->sf_pkt_head = cmd->cmd_next;
5848 		} else if (sf->sf_pkt_tail == cmd) {
5849 			/* this was the last packet */
5850 			sf->sf_pkt_tail = prev_cmd;
5851 			if (prev_cmd != NULL) {
5852 				prev_cmd->cmd_next = NULL;
5853 			}
5854 		} else {
5855 			/* some packet in the middle of the queue */
5856 			ASSERT(prev_cmd != NULL);
5857 			prev_cmd->cmd_next = cmd->cmd_next;
5858 		}
5859 		cmd->cmd_flags &= ~CFLAG_IN_QUEUE;
5860 
5861 		if (target->sft_state & SF_TARGET_OFFLINE) {
5862 			mutex_exit(&sf->sf_cmd_mutex);
5863 			pkt->pkt_reason = CMD_TRAN_ERR;
5864 			if (pkt->pkt_comp != NULL) {
5865 				(*pkt->pkt_comp)(cmd->cmd_pkt);
5866 			}
5867 		} else {
5868 			sf_fill_ids(sf, cmd, target);
5869 			if (sf_start_internal(sf, cmd) != TRAN_ACCEPT) {
5870 				pkt->pkt_reason = CMD_TRAN_ERR;
5871 				if (pkt->pkt_comp != NULL) {
5872 					(*pkt->pkt_comp)(cmd->cmd_pkt);
5873 				}
5874 			}
5875 		}
5876 		mutex_enter(&sf->sf_cmd_mutex);
5877 		cmd = sf->sf_pkt_head;
5878 		prev_cmd = NULL;
5879 	}
5880 }
5881 
5882 
5883 /*
5884  * called when the max exchange value is exceeded to throttle back commands
5885  */
5886 static void
5887 sf_throttle(struct sf *sf)
5888 {
5889 	int cmdmax = sf->sf_sochandle->fcal_cmdmax;
5890 
5891 
5892 	mutex_enter(&sf->sf_cmd_mutex);
5893 
5894 	sf->sf_flag = TRUE;
5895 
5896 	if (sf->sf_ncmds > (cmdmax / 2)) {
5897 		sf->sf_throttle = cmdmax / 2;
5898 	} else {
5899 		if (sf->sf_ncmds > SF_DECR_DELTA) {
5900 			sf->sf_throttle = sf->sf_ncmds - SF_DECR_DELTA;
5901 		} else {
5902 			/*
5903 			 * This case is just a safeguard, should not really
5904 			 * happen(ncmds < SF_DECR_DELTA and MAX_EXCHG exceed
5905 			 */
5906 			sf->sf_throttle = SF_DECR_DELTA;
5907 		}
5908 	}
5909 	mutex_exit(&sf->sf_cmd_mutex);
5910 
5911 	sf = sf->sf_sibling;
5912 	if (sf != NULL) {
5913 		mutex_enter(&sf->sf_cmd_mutex);
5914 		sf->sf_flag = TRUE;
5915 		if (sf->sf_ncmds >= (cmdmax / 2)) {
5916 			sf->sf_throttle = cmdmax / 2;
5917 		} else {
5918 			if (sf->sf_ncmds > SF_DECR_DELTA) {
5919 				sf->sf_throttle = sf->sf_ncmds - SF_DECR_DELTA;
5920 			} else {
5921 				sf->sf_throttle = SF_DECR_DELTA;
5922 			}
5923 		}
5924 
5925 		mutex_exit(&sf->sf_cmd_mutex);
5926 	}
5927 }
5928 
5929 
5930 /*
5931  * sf watchdog routine, called for a timeout
5932  */
5933 /*ARGSUSED*/
5934 static void
5935 sf_watch(void *arg)
5936 {
5937 	struct sf *sf;
5938 	struct sf_els_hdr	*privp;
5939 	static int count = 0, pscan_count = 0;
5940 	int cmdmax, i, mescount = 0;
5941 	struct sf_target *target;
5942 
5943 
5944 	sf_watchdog_time += sf_watchdog_timeout;
5945 	count++;
5946 	pscan_count++;
5947 
5948 	mutex_enter(&sf_global_mutex);
5949 	sf_watch_running = 1;
5950 	for (sf = sf_head; sf != NULL; sf = sf->sf_next) {
5951 
5952 		mutex_exit(&sf_global_mutex);
5953 
5954 		/* disable throttling while we're suspended */
5955 		mutex_enter(&sf->sf_mutex);
5956 		if (sf->sf_state & SF_STATE_SUSPENDED) {
5957 			mutex_exit(&sf->sf_mutex);
5958 			SF_DEBUG(1, (sf, CE_CONT,
5959 			    "sf_watch, sf%d:throttle disabled "
5960 			    "due to DDI_SUSPEND\n",
5961 			    ddi_get_instance(sf->sf_dip)));
5962 			mutex_enter(&sf_global_mutex);
5963 			continue;
5964 		}
5965 		mutex_exit(&sf->sf_mutex);
5966 
5967 		cmdmax = sf->sf_sochandle->fcal_cmdmax;
5968 
5969 		if (sf->sf_take_core) {
5970 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
5971 		}
5972 
5973 		mutex_enter(&sf->sf_cmd_mutex);
5974 
5975 		if (!sf->sf_flag) {
5976 			if (sf->sf_throttle < (cmdmax / 2)) {
5977 				sf->sf_throttle = cmdmax / 2;
5978 			} else if ((sf->sf_throttle += SF_INCR_DELTA) >
5979 			    cmdmax) {
5980 				sf->sf_throttle = cmdmax;
5981 			}
5982 		} else {
5983 			sf->sf_flag = FALSE;
5984 		}
5985 
5986 		sf->sf_ncmds_exp_avg = (sf->sf_ncmds + sf->sf_ncmds_exp_avg)
5987 		    >> 2;
5988 		if ((sf->sf_ncmds <= (sf->sf_throttle - SF_LO_CMD_DELTA)) &&
5989 		    (sf->sf_pkt_head == NULL)) {
5990 #ifdef DEBUG
5991 			if (sf->sf_use_lock) {
5992 				SF_DEBUG(4, (sf, CE_NOTE,
5993 				    "use lock flag off\n"));
5994 			}
5995 #endif
5996 			sf->sf_use_lock = FALSE;
5997 		}
5998 
5999 		if (sf->sf_state == SF_STATE_ONLINE && sf->sf_pkt_head &&
6000 		    sf->sf_ncmds < sf->sf_throttle) {
6001 			sf_throttle_start(sf);
6002 		}
6003 
6004 		mutex_exit(&sf->sf_cmd_mutex);
6005 
6006 		if (pscan_count >= sf_pool_scan_cnt) {
6007 			if (sf->sf_ncmds_exp_avg < (sf->sf_cr_pool_cnt <<
6008 			    SF_LOG2_ELEMS_IN_POOL) - SF_FREE_CR_EPSILON) {
6009 				sf_crpool_free(sf);
6010 			}
6011 		}
6012 		mutex_enter(&sf->sf_mutex);
6013 
6014 		privp = sf->sf_els_list;
6015 		while (privp != NULL) {
6016 			if (privp->timeout < sf_watchdog_time) {
6017 				/* timeout this command */
6018 				privp = sf_els_timeout(sf, privp);
6019 			} else if ((privp->timeout == SF_INVALID_TIMEOUT) &&
6020 			    (privp->lip_cnt != sf->sf_lip_cnt)) {
6021 				if (privp->prev != NULL) {
6022 					privp->prev->next = privp->next;
6023 				}
6024 				if (sf->sf_els_list == privp) {
6025 					sf->sf_els_list = privp->next;
6026 				}
6027 				if (privp->next != NULL) {
6028 					privp->next->prev = privp->prev;
6029 				}
6030 				mutex_exit(&sf->sf_mutex);
6031 				sf_els_free(privp->fpkt);
6032 				mutex_enter(&sf->sf_mutex);
6033 				privp = sf->sf_els_list;
6034 			} else {
6035 				privp = privp->next;
6036 			}
6037 		}
6038 
6039 		if (sf->sf_online_timer && sf->sf_online_timer <
6040 		    sf_watchdog_time) {
6041 			for (i = 0; i < sf_max_targets; i++) {
6042 				target = sf->sf_targets[i];
6043 				if (target != NULL) {
6044 					if (!mescount && target->sft_state &
6045 					    SF_TARGET_BUSY) {
6046 						sf_log(sf, CE_WARN, "!Loop "
6047 						    "Unstable: Failed to bring "
6048 						    "Loop Online\n");
6049 						mescount = 1;
6050 					}
6051 					target->sft_state |= SF_TARGET_MARK;
6052 				}
6053 			}
6054 			sf_finish_init(sf, sf->sf_lip_cnt);
6055 			sf->sf_state = SF_STATE_INIT;
6056 			sf->sf_online_timer = 0;
6057 		}
6058 
6059 		if (sf->sf_state == SF_STATE_ONLINE) {
6060 			mutex_exit(&sf->sf_mutex);
6061 			if (count >= sf_pkt_scan_cnt) {
6062 				sf_check_targets(sf);
6063 			}
6064 		} else if ((sf->sf_state == SF_STATE_OFFLINE) &&
6065 		    (sf->sf_timer < sf_watchdog_time)) {
6066 			for (i = 0; i < sf_max_targets; i++) {
6067 				target = sf->sf_targets[i];
6068 				if ((target != NULL) &&
6069 				    (target->sft_state &
6070 				    SF_TARGET_BUSY)) {
6071 					sf_log(sf, CE_WARN,
6072 					    "!Offline Timeout\n");
6073 					if (sf_core && (sf_core &
6074 					    SF_CORE_OFFLINE_TIMEOUT)) {
6075 						(void) soc_take_core(
6076 						    sf->sf_sochandle,
6077 						    sf->sf_socp);
6078 						sf_core = 0;
6079 					}
6080 					break;
6081 				}
6082 			}
6083 			sf_finish_init(sf, sf->sf_lip_cnt);
6084 			sf->sf_state = SF_STATE_INIT;
6085 			mutex_exit(&sf->sf_mutex);
6086 		} else {
6087 			mutex_exit(&sf->sf_mutex);
6088 		}
6089 		mutex_enter(&sf_global_mutex);
6090 	}
6091 	mutex_exit(&sf_global_mutex);
6092 	if (count >= sf_pkt_scan_cnt) {
6093 		count = 0;
6094 	}
6095 	if (pscan_count >= sf_pool_scan_cnt) {
6096 		pscan_count = 0;
6097 	}
6098 
6099 	/* reset timeout */
6100 	sf_watchdog_id = timeout(sf_watch, (caddr_t)0, sf_watchdog_tick);
6101 
6102 	/* signal waiting thread */
6103 	mutex_enter(&sf_global_mutex);
6104 	sf_watch_running = 0;
6105 	cv_broadcast(&sf_watch_cv);
6106 	mutex_exit(&sf_global_mutex);
6107 }
6108 
6109 
6110 /*
6111  * called during a timeout to check targets
6112  */
6113 static void
6114 sf_check_targets(struct sf *sf)
6115 {
6116 	struct sf_target *target;
6117 	int i;
6118 	struct sf_pkt *cmd;
6119 	struct scsi_pkt *pkt;
6120 	int lip_cnt;
6121 
6122 	mutex_enter(&sf->sf_mutex);
6123 	lip_cnt = sf->sf_lip_cnt;
6124 	mutex_exit(&sf->sf_mutex);
6125 
6126 	/* check scan all possible targets */
6127 	for (i = 0; i < sf_max_targets; i++) {
6128 		target = sf->sf_targets[i];
6129 		while (target != NULL) {
6130 			mutex_enter(&target->sft_pkt_mutex);
6131 			if (target->sft_alive && target->sft_scan_count !=
6132 			    sf_target_scan_cnt) {
6133 				target->sft_alive = 0;
6134 				target->sft_scan_count++;
6135 				mutex_exit(&target->sft_pkt_mutex);
6136 				return;
6137 			}
6138 			target->sft_alive = 0;
6139 			target->sft_scan_count = 0;
6140 			cmd = target->sft_pkt_head;
6141 			while (cmd != (struct sf_pkt *)&target->sft_pkt_head) {
6142 				mutex_enter(&cmd->cmd_abort_mutex);
6143 				if (cmd->cmd_state == SF_STATE_ISSUED &&
6144 				    ((cmd->cmd_timeout && sf_watchdog_time >
6145 #ifdef	DEBUG
6146 				    cmd->cmd_timeout) || sf_abort_flag)) {
6147 					sf_abort_flag = 0;
6148 #else
6149 					cmd->cmd_timeout))) {
6150 #endif
6151 					cmd->cmd_timeout = 0;
6152 	/* prevent reset from getting at this packet */
6153 					cmd->cmd_state = SF_STATE_ABORTING;
6154 					mutex_exit(&cmd->cmd_abort_mutex);
6155 					mutex_exit(&target->sft_pkt_mutex);
6156 					sf->sf_stats.tstats[i].timeouts++;
6157 					if (sf_target_timeout(sf, cmd))
6158 						return;
6159 					else {
6160 						if (lip_cnt != sf->sf_lip_cnt) {
6161 							return;
6162 						} else {
6163 							mutex_enter(&target->
6164 							    sft_pkt_mutex);
6165 							cmd = target->
6166 							    sft_pkt_head;
6167 						}
6168 					}
6169 	/*
6170 	 * if the abort and lip fail, a reset will be carried out.
6171 	 * But the reset will ignore this packet. We have waited at least
6172 	 * 20 seconds after the initial timeout. Now, complete it here.
6173 	 * This also takes care of spurious bad aborts.
6174 	 */
6175 				} else if ((cmd->cmd_state ==
6176 				    SF_STATE_ABORTING) && (cmd->cmd_timeout
6177 				    <= sf_watchdog_time)) {
6178 					cmd->cmd_state = SF_STATE_IDLE;
6179 					mutex_exit(&cmd->cmd_abort_mutex);
6180 					mutex_exit(&target->sft_pkt_mutex);
6181 					SF_DEBUG(1, (sf, CE_NOTE,
6182 					    "Command 0x%p to sft 0x%p"
6183 					    " delayed release\n",
6184 					    (void *)cmd, (void *)target));
6185 					pkt = cmd->cmd_pkt;
6186 					pkt->pkt_statistics |=
6187 					    (STAT_TIMEOUT|STAT_ABORTED);
6188 					pkt->pkt_reason = CMD_TIMEOUT;
6189 					if (pkt->pkt_comp) {
6190 						scsi_hba_pkt_comp(pkt);
6191 					/* handle deferred_destroy case */
6192 					} else {
6193 						if ((cmd->cmd_block->fcp_cntl.
6194 						    cntl_reset == 1) ||
6195 						    (cmd->cmd_block->
6196 						    fcp_cntl.cntl_abort_tsk ==
6197 						    1)) {
6198 							cmd->cmd_block->
6199 							    fcp_cntl.
6200 							    cntl_reset = 0;
6201 							cmd->cmd_block->
6202 							    fcp_cntl.
6203 							    cntl_abort_tsk = 0;
6204 							cmd->cmd_fp_pkt->
6205 							    fcal_pkt_comp =
6206 							    sf_cmd_callback;
6207 							/* for cache */
6208 							sf_scsi_destroy_pkt
6209 							    (&pkt->pkt_address,
6210 							    pkt);
6211 						}
6212 					}
6213 					mutex_enter(&target->sft_pkt_mutex);
6214 					cmd = target->sft_pkt_head;
6215 				} else {
6216 					mutex_exit(&cmd->cmd_abort_mutex);
6217 					cmd = cmd->cmd_forw;
6218 				}
6219 			}
6220 			mutex_exit(&target->sft_pkt_mutex);
6221 			target = target->sft_next_lun;
6222 		}
6223 	}
6224 }
6225 
6226 
6227 /*
6228  * a command to a target has timed out
6229  * return TRUE iff cmd abort failed or timed out, else return FALSE
6230  */
6231 static int
6232 sf_target_timeout(struct sf *sf, struct sf_pkt *cmd)
6233 {
6234 	int rval;
6235 	struct scsi_pkt *pkt;
6236 	struct fcal_packet *fpkt;
6237 	int tgt_id;
6238 	int retval = FALSE;
6239 
6240 
6241 	SF_DEBUG(1, (sf, CE_NOTE, "Command 0x%p to target %x timed out\n",
6242 	    (void *)cmd->cmd_fp_pkt, cmd->cmd_pkt->pkt_address.a_target));
6243 
6244 	fpkt = cmd->cmd_fp_pkt;
6245 
6246 	if (sf_core && (sf_core & SF_CORE_CMD_TIMEOUT)) {
6247 		sf_token = (int *)(uintptr_t)
6248 		    fpkt->fcal_socal_request.sr_soc_hdr.\
6249 		    sh_request_token;
6250 		(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6251 		sf_core = 0;
6252 	}
6253 
6254 	/* call the transport to abort a command */
6255 	rval = soc_abort(sf->sf_sochandle, sf->sf_socp,
6256 	    sf->sf_sochandle->fcal_portno, fpkt, 1);
6257 
6258 	switch (rval) {
6259 	case FCAL_ABORTED:
6260 		SF_DEBUG(1, (sf, CE_NOTE, "Command Abort succeeded\n"));
6261 		pkt = cmd->cmd_pkt;
6262 		cmd->cmd_state = SF_STATE_IDLE;
6263 		pkt->pkt_statistics |= (STAT_TIMEOUT|STAT_ABORTED);
6264 		pkt->pkt_reason = CMD_TIMEOUT;
6265 		if (pkt->pkt_comp != NULL) {
6266 			(*pkt->pkt_comp)(pkt);
6267 		}
6268 		break;				/* success */
6269 
6270 	case FCAL_ABORT_FAILED:
6271 		SF_DEBUG(1, (sf, CE_NOTE, "Command Abort failed at target\n"));
6272 		pkt = cmd->cmd_pkt;
6273 		cmd->cmd_state = SF_STATE_IDLE;
6274 		pkt->pkt_reason = CMD_TIMEOUT;
6275 		pkt->pkt_statistics |= STAT_TIMEOUT;
6276 		tgt_id = pkt->pkt_address.a_target;
6277 		sf->sf_stats.tstats[tgt_id].abts_failures++;
6278 		if (pkt->pkt_comp != NULL) {
6279 			(*pkt->pkt_comp)(pkt);
6280 		}
6281 		break;
6282 
6283 	case FCAL_BAD_ABORT:
6284 		if (sf_core && (sf_core & SF_CORE_BAD_ABORT)) {
6285 			sf_token = (int *)(uintptr_t)fpkt->fcal_socal_request.\
6286 			    sr_soc_hdr.sh_request_token;
6287 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6288 			sf_core = 0;
6289 		}
6290 		SF_DEBUG(1, (sf, CE_NOTE, "Command Abort bad abort\n"));
6291 		cmd->cmd_timeout = sf_watchdog_time + cmd->cmd_pkt->pkt_time
6292 		    + 20;
6293 		break;
6294 
6295 	case FCAL_TIMEOUT:
6296 		retval = TRUE;
6297 		break;
6298 
6299 	default:
6300 		pkt = cmd->cmd_pkt;
6301 		tgt_id = pkt->pkt_address.a_target;
6302 		sf_log(sf, CE_WARN,
6303 		"Command Abort failed target 0x%x, forcing a LIP\n", tgt_id);
6304 		if (sf_core && (sf_core & SF_CORE_ABORT_TIMEOUT)) {
6305 			sf_token = (int *)(uintptr_t)fpkt->fcal_socal_request.\
6306 			    sr_soc_hdr.sh_request_token;
6307 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6308 			sf_core = 0;
6309 		}
6310 		sf_force_lip(sf);
6311 		retval = TRUE;
6312 		break;
6313 	}
6314 
6315 	return (retval);
6316 }
6317 
6318 
6319 /*
6320  * an ELS command has timed out
6321  * return ???
6322  */
6323 static struct sf_els_hdr *
6324 sf_els_timeout(struct sf *sf, struct sf_els_hdr *privp)
6325 {
6326 	struct fcal_packet *fpkt;
6327 	int rval, dflag, timeout = SF_ELS_TIMEOUT;
6328 	uint_t lip_cnt = privp->lip_cnt;
6329 	uchar_t els_code = privp->els_code;
6330 	struct sf_target *target = privp->target;
6331 	char what[64];
6332 
6333 	fpkt = privp->fpkt;
6334 	dflag = privp->delayed_retry;
6335 	/* use as temporary state variable */
6336 	privp->timeout = SF_INVALID_TIMEOUT;
6337 	mutex_exit(&sf->sf_mutex);
6338 
6339 	if (privp->fpkt->fcal_pkt_comp == sf_els_callback) {
6340 		/*
6341 		 * take socal core if required. Timeouts for IB and hosts
6342 		 * are not very interesting, so we take socal core only
6343 		 * if the timeout is *not* for a IB or host.
6344 		 */
6345 		if (sf_core && (sf_core & SF_CORE_ELS_TIMEOUT) &&
6346 		    ((sf_alpa_to_switch[privp->dest_nport_id] &
6347 		    0x0d) != 0x0d) && ((privp->dest_nport_id != 1) ||
6348 		    (privp->dest_nport_id != 2) ||
6349 		    (privp->dest_nport_id != 4) ||
6350 		    (privp->dest_nport_id != 8) ||
6351 		    (privp->dest_nport_id != 0xf))) {
6352 			sf_token = (int *)(uintptr_t)fpkt->fcal_socal_request.\
6353 			    sr_soc_hdr.sh_request_token;
6354 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6355 			sf_core = 0;
6356 		}
6357 		(void) sprintf(what, "ELS 0x%x", privp->els_code);
6358 	} else if (privp->fpkt->fcal_pkt_comp == sf_reportlun_callback) {
6359 		if (sf_core && (sf_core & SF_CORE_REPORTLUN_TIMEOUT)) {
6360 			sf_token = (int *)(uintptr_t)fpkt->fcal_socal_request.\
6361 			    sr_soc_hdr.sh_request_token;
6362 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6363 			sf_core = 0;
6364 		}
6365 		timeout = SF_FCP_TIMEOUT;
6366 		(void) sprintf(what, "REPORT_LUNS");
6367 	} else if (privp->fpkt->fcal_pkt_comp == sf_inq_callback) {
6368 		if (sf_core && (sf_core & SF_CORE_INQUIRY_TIMEOUT)) {
6369 			sf_token = (int *)(uintptr_t)
6370 			    fpkt->fcal_socal_request.\
6371 			    sr_soc_hdr.sh_request_token;
6372 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6373 			sf_core = 0;
6374 		}
6375 		timeout = SF_FCP_TIMEOUT;
6376 		(void) sprintf(what, "INQUIRY to LUN 0x%lx",
6377 		    (long)SCSA_LUN(target));
6378 	} else {
6379 		(void) sprintf(what, "UNKNOWN OPERATION");
6380 	}
6381 
6382 	if (dflag) {
6383 		/* delayed retry */
6384 		SF_DEBUG(2, (sf, CE_CONT,
6385 		    "!sf%d: %s to target %x delayed retry\n",
6386 		    ddi_get_instance(sf->sf_dip), what,
6387 		    sf_alpa_to_switch[privp->dest_nport_id]));
6388 		privp->delayed_retry = FALSE;
6389 		goto try_again;
6390 	}
6391 
6392 	sf_log(sf, CE_NOTE, "!%s to target 0x%x alpa 0x%x timed out\n",
6393 	    what, sf_alpa_to_switch[privp->dest_nport_id],
6394 	    privp->dest_nport_id);
6395 
6396 	rval = soc_abort(sf->sf_sochandle, sf->sf_socp, sf->sf_sochandle
6397 	    ->fcal_portno, fpkt, 1);
6398 	if (rval == FCAL_ABORTED || rval == FCAL_ABORT_FAILED) {
6399 	SF_DEBUG(1, (sf, CE_NOTE, "!%s abort to al_pa %x succeeded\n",
6400 	    what, privp->dest_nport_id));
6401 try_again:
6402 
6403 		mutex_enter(&sf->sf_mutex);
6404 		if (privp->prev != NULL) {
6405 			privp->prev->next = privp->next;
6406 		}
6407 		if (sf->sf_els_list == privp) {
6408 			sf->sf_els_list = privp->next;
6409 		}
6410 		if (privp->next != NULL) {
6411 			privp->next->prev = privp->prev;
6412 		}
6413 		privp->prev = privp->next = NULL;
6414 		if (lip_cnt == sf->sf_lip_cnt) {
6415 			privp->timeout = sf_watchdog_time + timeout;
6416 			if ((++(privp->retries) < sf_els_retries) ||
6417 			    (dflag && (privp->retries < SF_BSY_RETRIES))) {
6418 				mutex_exit(&sf->sf_mutex);
6419 				sf_log(sf, CE_NOTE,
6420 				    "!%s to target 0x%x retrying\n",
6421 				    what,
6422 				    sf_alpa_to_switch[privp->dest_nport_id]);
6423 				if (sf_els_transport(sf, privp) == 1) {
6424 					mutex_enter(&sf->sf_mutex);
6425 					return (sf->sf_els_list); /* success */
6426 				}
6427 				mutex_enter(&sf->sf_mutex);
6428 				fpkt = NULL;
6429 			}
6430 			if ((lip_cnt == sf->sf_lip_cnt) &&
6431 			    (els_code != LA_ELS_LOGO)) {
6432 				if (target != NULL) {
6433 					sf_offline_target(sf, target);
6434 				}
6435 				if (sf->sf_lip_cnt == lip_cnt) {
6436 					sf->sf_device_count--;
6437 					ASSERT(sf->sf_device_count >= 0);
6438 					if (sf->sf_device_count == 0) {
6439 						sf_finish_init(sf,
6440 						    sf->sf_lip_cnt);
6441 					}
6442 				}
6443 			}
6444 			privp = sf->sf_els_list;
6445 			mutex_exit(&sf->sf_mutex);
6446 			if (fpkt != NULL) {
6447 				sf_els_free(fpkt);
6448 			}
6449 		} else {
6450 			mutex_exit(&sf->sf_mutex);
6451 			sf_els_free(privp->fpkt);
6452 			privp = NULL;
6453 		}
6454 	} else {
6455 		if (sf_core && (sf_core & SF_CORE_ELS_FAILED)) {
6456 			sf_token = (int *)(uintptr_t)
6457 			    fpkt->fcal_socal_request.\
6458 			    sr_soc_hdr.sh_request_token;
6459 			(void) soc_take_core(sf->sf_sochandle, sf->sf_socp);
6460 			sf_core = 0;
6461 		}
6462 		sf_log(sf, CE_NOTE, "%s abort to target 0x%x failed. "
6463 		    "status=0x%x, forcing LIP\n", what,
6464 		    sf_alpa_to_switch[privp->dest_nport_id], rval);
6465 		privp = NULL;
6466 		if (sf->sf_lip_cnt == lip_cnt) {
6467 			sf_force_lip(sf);
6468 		}
6469 	}
6470 
6471 	mutex_enter(&sf->sf_mutex);
6472 	return (privp);
6473 }
6474 
6475 
6476 /*
6477  * called by timeout when a reset times out
6478  */
6479 /*ARGSUSED*/
6480 static void
6481 sf_check_reset_delay(void *arg)
6482 {
6483 	struct sf *sf;
6484 	struct sf_target *target;
6485 	struct sf_reset_list *rp, *tp;
6486 	uint_t lip_cnt, reset_timeout_flag = FALSE;
6487 	clock_t lb;
6488 
6489 	lb = ddi_get_lbolt();
6490 
6491 	mutex_enter(&sf_global_mutex);
6492 
6493 	sf_reset_timeout_id = 0;
6494 
6495 	for (sf = sf_head; sf != NULL; sf = sf->sf_next) {
6496 
6497 		mutex_exit(&sf_global_mutex);
6498 		mutex_enter(&sf->sf_mutex);
6499 
6500 		/* is this type cast needed? */
6501 		tp = (struct sf_reset_list *)&sf->sf_reset_list;
6502 
6503 		rp = sf->sf_reset_list;
6504 		while (rp != NULL) {
6505 			if (((rp->timeout - lb) < 0) &&
6506 			    (rp->lip_cnt == sf->sf_lip_cnt)) {
6507 				tp->next = rp->next;
6508 				mutex_exit(&sf->sf_mutex);
6509 				target = rp->target;
6510 				lip_cnt = rp->lip_cnt;
6511 				kmem_free(rp, sizeof (struct sf_reset_list));
6512 				/* abort all cmds for this target */
6513 				while (target) {
6514 					sf_abort_all(sf, target, FALSE,
6515 					    lip_cnt, TRUE);
6516 					mutex_enter(&target->sft_mutex);
6517 					if (lip_cnt == sf->sf_lip_cnt) {
6518 						target->sft_state &=
6519 						    ~SF_TARGET_BUSY;
6520 					}
6521 					mutex_exit(&target->sft_mutex);
6522 					target = target->sft_next_lun;
6523 				}
6524 				mutex_enter(&sf->sf_mutex);
6525 				tp = (struct sf_reset_list *)
6526 				    &sf->sf_reset_list;
6527 				rp = sf->sf_reset_list;
6528 				lb = ddi_get_lbolt();
6529 			} else if (rp->lip_cnt != sf->sf_lip_cnt) {
6530 				tp->next = rp->next;
6531 				kmem_free(rp, sizeof (struct sf_reset_list));
6532 				rp = tp->next;
6533 			} else {
6534 				reset_timeout_flag = TRUE;
6535 				tp = rp;
6536 				rp = rp->next;
6537 			}
6538 		}
6539 		mutex_exit(&sf->sf_mutex);
6540 		mutex_enter(&sf_global_mutex);
6541 	}
6542 
6543 	if (reset_timeout_flag && (sf_reset_timeout_id == 0)) {
6544 		sf_reset_timeout_id = timeout(sf_check_reset_delay,
6545 		    NULL, drv_usectohz(SF_TARGET_RESET_DELAY));
6546 	}
6547 
6548 	mutex_exit(&sf_global_mutex);
6549 }
6550 
6551 
6552 /*
6553  * called to "reset the bus", i.e. force loop initialization (and address
6554  * re-negotiation)
6555  */
6556 static void
6557 sf_force_lip(struct sf *sf)
6558 {
6559 	int i;
6560 	struct sf_target *target;
6561 
6562 
6563 	/* disable restart of lip if we're suspended */
6564 	mutex_enter(&sf->sf_mutex);
6565 	if (sf->sf_state & SF_STATE_SUSPENDED) {
6566 		mutex_exit(&sf->sf_mutex);
6567 		SF_DEBUG(1, (sf, CE_CONT,
6568 		    "sf_force_lip, sf%d: lip restart disabled "
6569 		    "due to DDI_SUSPEND\n",
6570 		    ddi_get_instance(sf->sf_dip)));
6571 		return;
6572 	}
6573 
6574 	sf_log(sf, CE_NOTE, "Forcing lip\n");
6575 
6576 	for (i = 0; i < sf_max_targets; i++) {
6577 		target = sf->sf_targets[i];
6578 		while (target != NULL) {
6579 			mutex_enter(&target->sft_mutex);
6580 			if (!(target->sft_state & SF_TARGET_OFFLINE))
6581 				target->sft_state |= SF_TARGET_BUSY;
6582 			mutex_exit(&target->sft_mutex);
6583 			target = target->sft_next_lun;
6584 		}
6585 	}
6586 
6587 	sf->sf_lip_cnt++;
6588 	sf->sf_timer = sf_watchdog_time + SF_OFFLINE_TIMEOUT;
6589 	sf->sf_state = SF_STATE_OFFLINE;
6590 	mutex_exit(&sf->sf_mutex);
6591 	sf->sf_stats.lip_count++;		/* no mutex for this? */
6592 
6593 #ifdef DEBUG
6594 	/* are we allowing LIPs ?? */
6595 	if (sf_lip_flag != 0) {
6596 #endif
6597 		/* call the transport to force loop initialization */
6598 		if (((i = soc_force_lip(sf->sf_sochandle, sf->sf_socp,
6599 		    sf->sf_sochandle->fcal_portno, 1,
6600 		    FCAL_FORCE_LIP)) != FCAL_SUCCESS) &&
6601 		    (i != FCAL_TIMEOUT)) {
6602 			/* force LIP failed */
6603 			if (sf_core && (sf_core & SF_CORE_LIP_FAILED)) {
6604 				(void) soc_take_core(sf->sf_sochandle,
6605 				    sf->sf_socp);
6606 				sf_core = 0;
6607 			}
6608 #ifdef DEBUG
6609 			/* are we allowing reset after LIP failed ?? */
6610 			if (sf_reset_flag != 0) {
6611 #endif
6612 				/* restart socal after resetting it */
6613 				sf_log(sf, CE_NOTE,
6614 				    "!Force lip failed Status code 0x%x."
6615 				    " Reseting\n", i);
6616 				/* call transport to force a reset */
6617 				soc_force_reset(sf->sf_sochandle, sf->sf_socp,
6618 				    sf->sf_sochandle->fcal_portno, 1);
6619 #ifdef	DEBUG
6620 			}
6621 #endif
6622 		}
6623 #ifdef	DEBUG
6624 	}
6625 #endif
6626 }
6627 
6628 
6629 /*
6630  * called by the transport when an unsolicited ELS is received
6631  */
6632 static void
6633 sf_unsol_els_callback(void *arg, soc_response_t *srp, caddr_t payload)
6634 {
6635 	struct sf *sf = (struct sf *)arg;
6636 	els_payload_t	*els = (els_payload_t *)payload;
6637 	struct la_els_rjt *rsp;
6638 	int	i, tgt_id;
6639 	uchar_t dest_id;
6640 	struct fcal_packet *fpkt;
6641 	fc_frame_header_t *hp;
6642 	struct sf_els_hdr *privp;
6643 
6644 
6645 	if ((els == NULL) || ((i = srp->sr_soc_hdr.sh_byte_cnt) == 0)) {
6646 		return;
6647 	}
6648 
6649 	if (i > SOC_CQE_PAYLOAD) {
6650 		i = SOC_CQE_PAYLOAD;
6651 	}
6652 
6653 	dest_id = (uchar_t)srp->sr_fc_frame_hdr.s_id;
6654 	tgt_id = sf_alpa_to_switch[dest_id];
6655 
6656 	switch (els->els_cmd.c.ls_command) {
6657 
6658 	case LA_ELS_LOGO:
6659 		/*
6660 		 * logout received -- log the fact
6661 		 */
6662 		sf->sf_stats.tstats[tgt_id].logouts_recvd++;
6663 		sf_log(sf, CE_NOTE, "!LOGO recvd from target %x, %s\n",
6664 		    tgt_id,
6665 		    sf_lip_on_plogo ? "Forcing LIP...." : "");
6666 		if (sf_lip_on_plogo) {
6667 			sf_force_lip(sf);
6668 		}
6669 		break;
6670 
6671 	default:  /* includes LA_ELS_PLOGI */
6672 		/*
6673 		 * something besides a logout received -- we don't handle
6674 		 * this so send back a reject saying its unsupported
6675 		 */
6676 
6677 		sf_log(sf, CE_NOTE, "!ELS 0x%x recvd from target 0x%x\n",
6678 		    els->els_cmd.c.ls_command, tgt_id);
6679 
6680 
6681 		/* allocate room for a response */
6682 		if (sf_els_alloc(sf, dest_id, sizeof (struct sf_els_hdr),
6683 		    sizeof (struct la_els_rjt), sizeof (union sf_els_rsp),
6684 		    (caddr_t *)&privp, (caddr_t *)&rsp) == NULL) {
6685 			break;
6686 		}
6687 
6688 		fpkt = privp->fpkt;
6689 
6690 		/* fill in pkt header */
6691 		hp = &fpkt->fcal_socal_request.sr_fc_frame_hdr;
6692 		hp->r_ctl = R_CTL_ELS_RSP;
6693 		hp->f_ctl = F_CTL_LAST_SEQ | F_CTL_XCHG_CONTEXT;
6694 		hp->ox_id = srp->sr_fc_frame_hdr.ox_id;
6695 		hp->rx_id = srp->sr_fc_frame_hdr.rx_id;
6696 		fpkt->fcal_socal_request.sr_cqhdr.cq_hdr_type =
6697 		    CQ_TYPE_OUTBOUND;
6698 
6699 		fpkt->fcal_socal_request.sr_soc_hdr.sh_seg_cnt = 1;
6700 
6701 		/* fill in response */
6702 		rsp->ls_code = LA_ELS_RJT;	/* reject this ELS */
6703 		rsp->mbz[0] = 0;
6704 		rsp->mbz[1] = 0;
6705 		rsp->mbz[2] = 0;
6706 		((struct la_els_logi *)privp->rsp)->ls_code = LA_ELS_ACC;
6707 		*((int *)&rsp->reserved) = 0;
6708 		rsp->reason_code = RJT_UNSUPPORTED;
6709 		privp->retries = sf_els_retries;
6710 		privp->els_code = LA_ELS_RJT;
6711 		privp->timeout = (unsigned)0xffffffff;
6712 		(void) sf_els_transport(sf, privp);
6713 		break;
6714 	}
6715 }
6716 
6717 
6718 /*
6719  * Error logging, printing, and debug print routines
6720  */
6721 
6722 /*PRINTFLIKE3*/
6723 static void
6724 sf_log(struct sf *sf, int level, const char *fmt, ...)
6725 {
6726 	char buf[256];
6727 	dev_info_t *dip;
6728 	va_list ap;
6729 
6730 	if (sf != NULL) {
6731 		dip = sf->sf_dip;
6732 	} else {
6733 		dip = NULL;
6734 	}
6735 
6736 	va_start(ap, fmt);
6737 	(void) vsprintf(buf, fmt, ap);
6738 	va_end(ap);
6739 	scsi_log(dip, "sf", level, buf);
6740 }
6741 
6742 
6743 /*
6744  * called to get some sf kstats -- return 0 on success else return errno
6745  */
6746 static int
6747 sf_kstat_update(kstat_t *ksp, int rw)
6748 {
6749 	struct sf *sf;
6750 
6751 	if (rw == KSTAT_WRITE) {
6752 		/* can't write */
6753 		return (EACCES);
6754 	}
6755 
6756 	sf = ksp->ks_private;
6757 	sf->sf_stats.ncmds = sf->sf_ncmds;
6758 	sf->sf_stats.throttle_limit = sf->sf_throttle;
6759 	sf->sf_stats.cr_pool_size = sf->sf_cr_pool_cnt;
6760 
6761 	return (0);				/* success */
6762 }
6763 
6764 
6765 /*
6766  * Unix Entry Points
6767  */
6768 
6769 /*
6770  * driver entry point for opens on control device
6771  */
6772 /* ARGSUSED */
6773 static int
6774 sf_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
6775 {
6776 	dev_t dev = *dev_p;
6777 	struct sf *sf;
6778 
6779 
6780 	/* just ensure soft state exists for this device */
6781 	sf = ddi_get_soft_state(sf_state, SF_MINOR2INST(getminor(dev)));
6782 	if (sf == NULL) {
6783 		return (ENXIO);
6784 	}
6785 
6786 	++(sf->sf_check_n_close);
6787 
6788 	return (0);
6789 }
6790 
6791 
6792 /*
6793  * driver entry point for last close on control device
6794  */
6795 /* ARGSUSED */
6796 static int
6797 sf_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
6798 {
6799 	struct sf *sf;
6800 
6801 	sf = ddi_get_soft_state(sf_state, SF_MINOR2INST(getminor(dev)));
6802 	if (sf == NULL) {
6803 		return (ENXIO);
6804 	}
6805 
6806 	if (!sf->sf_check_n_close) { /* if this flag is zero */
6807 		cmn_err(CE_WARN, "sf%d: trying to close unopened instance",
6808 		    SF_MINOR2INST(getminor(dev)));
6809 		return (ENODEV);
6810 	} else {
6811 		--(sf->sf_check_n_close);
6812 	}
6813 	return (0);
6814 }
6815 
6816 
6817 /*
6818  * driver entry point for sf ioctl commands
6819  */
6820 /* ARGSUSED */
6821 static int
6822 sf_ioctl(dev_t dev,
6823     int cmd, intptr_t arg, int mode, cred_t *cred_p, int *rval_p)
6824 {
6825 	struct sf *sf;
6826 	struct sf_target *target;
6827 	uchar_t al_pa;
6828 	struct sf_al_map map;
6829 	int cnt, i;
6830 	int	retval;				/* return value */
6831 	struct devctl_iocdata *dcp;
6832 	dev_info_t *cdip;
6833 	struct scsi_address ap;
6834 	scsi_hba_tran_t *tran;
6835 
6836 
6837 	sf = ddi_get_soft_state(sf_state, SF_MINOR2INST(getminor(dev)));
6838 	if (sf == NULL) {
6839 		return (ENXIO);
6840 	}
6841 
6842 	/* handle all ioctls */
6843 	switch (cmd) {
6844 
6845 	/*
6846 	 * We can use the generic implementation for these ioctls
6847 	 */
6848 	case DEVCTL_DEVICE_GETSTATE:
6849 	case DEVCTL_DEVICE_ONLINE:
6850 	case DEVCTL_DEVICE_OFFLINE:
6851 	case DEVCTL_BUS_GETSTATE:
6852 		return (ndi_devctl_ioctl(sf->sf_dip, cmd, arg, mode, 0));
6853 
6854 	/*
6855 	 * return FC map
6856 	 */
6857 	case SFIOCGMAP:
6858 		if ((sf->sf_lilp_map->lilp_magic != FCAL_LILP_MAGIC &&
6859 		    sf->sf_lilp_map->lilp_magic != FCAL_BADLILP_MAGIC) ||
6860 		    sf->sf_state != SF_STATE_ONLINE) {
6861 			retval = ENOENT;
6862 			goto dun;
6863 		}
6864 		mutex_enter(&sf->sf_mutex);
6865 		if (sf->sf_lilp_map->lilp_magic == FCAL_BADLILP_MAGIC) {
6866 			int i, j = 0;
6867 
6868 			/* Need to generate a fake lilp map */
6869 			for (i = 0; i < sf_max_targets; i++) {
6870 				if (sf->sf_targets[i])
6871 					sf->sf_lilp_map->lilp_alpalist[j++] =
6872 					    sf->sf_targets[i]->
6873 					    sft_hard_address;
6874 			}
6875 			sf->sf_lilp_map->lilp_length = (uchar_t)j;
6876 		}
6877 		cnt = sf->sf_lilp_map->lilp_length;
6878 		map.sf_count = (short)cnt;
6879 		bcopy((caddr_t)&sf->sf_sochandle->fcal_n_wwn,
6880 		    (caddr_t)&map.sf_hba_addr.sf_node_wwn,
6881 		    sizeof (la_wwn_t));
6882 		bcopy((caddr_t)&sf->sf_sochandle->fcal_p_wwn,
6883 		    (caddr_t)&map.sf_hba_addr.sf_port_wwn,
6884 		    sizeof (la_wwn_t));
6885 		map.sf_hba_addr.sf_al_pa = sf->sf_al_pa;
6886 		map.sf_hba_addr.sf_hard_address = 0;
6887 		map.sf_hba_addr.sf_inq_dtype = DTYPE_UNKNOWN;
6888 		for (i = 0; i < cnt; i++) {
6889 			al_pa = sf->sf_lilp_map->lilp_alpalist[i];
6890 			map.sf_addr_pair[i].sf_al_pa = al_pa;
6891 			if (al_pa == sf->sf_al_pa) {
6892 				(void) bcopy((caddr_t)&sf->sf_sochandle
6893 				    ->fcal_n_wwn, (caddr_t)&map.
6894 				    sf_addr_pair[i].sf_node_wwn,
6895 				    sizeof (la_wwn_t));
6896 				(void) bcopy((caddr_t)&sf->sf_sochandle
6897 				    ->fcal_p_wwn, (caddr_t)&map.
6898 				    sf_addr_pair[i].sf_port_wwn,
6899 				    sizeof (la_wwn_t));
6900 				map.sf_addr_pair[i].sf_hard_address =
6901 				    al_pa;
6902 				map.sf_addr_pair[i].sf_inq_dtype =
6903 				    DTYPE_PROCESSOR;
6904 				continue;
6905 			}
6906 			target = sf->sf_targets[sf_alpa_to_switch[
6907 			    al_pa]];
6908 			if (target != NULL) {
6909 				mutex_enter(&target->sft_mutex);
6910 				if (!(target->sft_state &
6911 				    (SF_TARGET_OFFLINE |
6912 				    SF_TARGET_BUSY))) {
6913 					bcopy((caddr_t)&target->
6914 					    sft_node_wwn,
6915 					    (caddr_t)&map.sf_addr_pair
6916 					    [i].sf_node_wwn,
6917 					    sizeof (la_wwn_t));
6918 					bcopy((caddr_t)&target->
6919 					    sft_port_wwn,
6920 					    (caddr_t)&map.sf_addr_pair
6921 					    [i].sf_port_wwn,
6922 					    sizeof (la_wwn_t));
6923 					map.sf_addr_pair[i].
6924 					    sf_hard_address
6925 					    = target->sft_hard_address;
6926 					map.sf_addr_pair[i].
6927 					    sf_inq_dtype
6928 					    = target->sft_device_type;
6929 					mutex_exit(&target->sft_mutex);
6930 					continue;
6931 				}
6932 				mutex_exit(&target->sft_mutex);
6933 			}
6934 			bzero((caddr_t)&map.sf_addr_pair[i].
6935 			    sf_node_wwn, sizeof (la_wwn_t));
6936 			bzero((caddr_t)&map.sf_addr_pair[i].
6937 			    sf_port_wwn, sizeof (la_wwn_t));
6938 			map.sf_addr_pair[i].sf_inq_dtype =
6939 			    DTYPE_UNKNOWN;
6940 		}
6941 		mutex_exit(&sf->sf_mutex);
6942 		if (ddi_copyout((caddr_t)&map, (caddr_t)arg,
6943 		    sizeof (struct sf_al_map), mode) != 0) {
6944 			retval = EFAULT;
6945 			goto dun;
6946 		}
6947 		break;
6948 
6949 	/*
6950 	 * handle device control ioctls
6951 	 */
6952 	case DEVCTL_DEVICE_RESET:
6953 		if (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS) {
6954 			retval = EFAULT;
6955 			goto dun;
6956 		}
6957 		if ((ndi_dc_getname(dcp) == NULL) ||
6958 		    (ndi_dc_getaddr(dcp) == NULL)) {
6959 			ndi_dc_freehdl(dcp);
6960 			retval = EINVAL;
6961 			goto dun;
6962 		}
6963 		cdip = ndi_devi_find(sf->sf_dip,
6964 		    ndi_dc_getname(dcp), ndi_dc_getaddr(dcp));
6965 		ndi_dc_freehdl(dcp);
6966 
6967 		if (cdip == NULL) {
6968 			retval = ENXIO;
6969 			goto dun;
6970 		}
6971 
6972 		if ((target = sf_get_target_from_dip(sf, cdip)) == NULL) {
6973 			retval = ENXIO;
6974 			goto dun;
6975 		}
6976 		mutex_enter(&target->sft_mutex);
6977 		if (!(target->sft_state & SF_TARGET_INIT_DONE)) {
6978 			mutex_exit(&target->sft_mutex);
6979 			retval = ENXIO;
6980 			goto dun;
6981 		}
6982 
6983 		/* This is ugly */
6984 		tran = kmem_zalloc(scsi_hba_tran_size(), KM_SLEEP);
6985 		bcopy(target->sft_tran, tran, scsi_hba_tran_size());
6986 		mutex_exit(&target->sft_mutex);
6987 		ap.a_hba_tran = tran;
6988 		ap.a_target = sf_alpa_to_switch[target->sft_al_pa];
6989 		if (sf_reset(&ap, RESET_TARGET) == FALSE) {
6990 			retval = EIO;
6991 		} else {
6992 			retval = 0;
6993 		}
6994 		kmem_free(tran, scsi_hba_tran_size());
6995 		goto dun;
6996 
6997 	case DEVCTL_BUS_QUIESCE:
6998 	case DEVCTL_BUS_UNQUIESCE:
6999 		retval = ENOTSUP;
7000 		goto dun;
7001 
7002 	case DEVCTL_BUS_RESET:
7003 	case DEVCTL_BUS_RESETALL:
7004 		sf_force_lip(sf);
7005 		break;
7006 
7007 	default:
7008 		retval = ENOTTY;
7009 		goto dun;
7010 	}
7011 
7012 	retval = 0;				/* success */
7013 
7014 dun:
7015 	return (retval);
7016 }
7017 
7018 
7019 /*
7020  * get the target given a DIP
7021  */
7022 static struct sf_target *
7023 sf_get_target_from_dip(struct sf *sf, dev_info_t *dip)
7024 {
7025 	int i;
7026 	struct sf_target *target;
7027 
7028 
7029 	/* scan each hash queue for the DIP in question */
7030 	for (i = 0; i < SF_NUM_HASH_QUEUES; i++) {
7031 		target = sf->sf_wwn_lists[i];
7032 		while (target != NULL) {
7033 			if (target->sft_dip == dip) {
7034 				return (target); /* success: target found */
7035 			}
7036 			target = target->sft_next;
7037 		}
7038 	}
7039 	return (NULL);				/* failure: target not found */
7040 }
7041 
7042 
7043 /*
7044  * called by the transport to get an event cookie
7045  */
7046 static int
7047 sf_bus_get_eventcookie(dev_info_t *dip, dev_info_t *rdip, char *name,
7048     ddi_eventcookie_t *event_cookiep)
7049 {
7050 	struct sf *sf;
7051 
7052 	sf = ddi_get_soft_state(sf_state, ddi_get_instance(dip));
7053 	if (sf == NULL) {
7054 		/* can't find instance for this device */
7055 		return (DDI_FAILURE);
7056 	}
7057 
7058 	return (ndi_event_retrieve_cookie(sf->sf_event_hdl, rdip, name,
7059 	    event_cookiep, NDI_EVENT_NOPASS));
7060 
7061 }
7062 
7063 
7064 /*
7065  * called by the transport to add an event callback
7066  */
7067 static int
7068 sf_bus_add_eventcall(dev_info_t *dip, dev_info_t *rdip,
7069     ddi_eventcookie_t eventid, void (*callback)(dev_info_t *dip,
7070     ddi_eventcookie_t event, void *arg, void *impl_data), void *arg,
7071     ddi_callback_id_t *cb_id)
7072 {
7073 	struct sf *sf;
7074 
7075 	sf = ddi_get_soft_state(sf_state, ddi_get_instance(dip));
7076 	if (sf == NULL) {
7077 		/* can't find instance for this device */
7078 		return (DDI_FAILURE);
7079 	}
7080 
7081 	return (ndi_event_add_callback(sf->sf_event_hdl, rdip,
7082 	    eventid, callback, arg, NDI_SLEEP, cb_id));
7083 
7084 }
7085 
7086 
7087 /*
7088  * called by the transport to remove an event callback
7089  */
7090 static int
7091 sf_bus_remove_eventcall(dev_info_t *devi, ddi_callback_id_t cb_id)
7092 {
7093 	struct sf *sf;
7094 
7095 	sf = ddi_get_soft_state(sf_state, ddi_get_instance(devi));
7096 	if (sf == NULL) {
7097 		/* can't find instance for this device */
7098 		return (DDI_FAILURE);
7099 	}
7100 
7101 	return (ndi_event_remove_callback(sf->sf_event_hdl, cb_id));
7102 }
7103 
7104 
7105 /*
7106  * called by the transport to post an event
7107  */
7108 static int
7109 sf_bus_post_event(dev_info_t *dip, dev_info_t *rdip,
7110     ddi_eventcookie_t eventid, void *impldata)
7111 {
7112 	ddi_eventcookie_t remove_cookie, cookie;
7113 
7114 	/* is this a remove event ?? */
7115 	struct sf *sf = ddi_get_soft_state(sf_state, ddi_get_instance(dip));
7116 	remove_cookie = ndi_event_tag_to_cookie(sf->sf_event_hdl,
7117 	    SF_EVENT_TAG_REMOVE);
7118 
7119 	if (remove_cookie == eventid) {
7120 		struct sf_target *target;
7121 
7122 		/* handle remove event */
7123 
7124 		if (sf == NULL) {
7125 			/* no sf instance for this device */
7126 			return (NDI_FAILURE);
7127 		}
7128 
7129 		/* get the target for this event */
7130 		if ((target = sf_get_target_from_dip(sf, rdip)) != NULL) {
7131 			/*
7132 			 * clear device info for this target and mark as
7133 			 * not done
7134 			 */
7135 			mutex_enter(&target->sft_mutex);
7136 			target->sft_dip = NULL;
7137 			target->sft_state &= ~SF_TARGET_INIT_DONE;
7138 			mutex_exit(&target->sft_mutex);
7139 			return (NDI_SUCCESS); /* event handled */
7140 		}
7141 
7142 		/* no target for this event */
7143 		return (NDI_FAILURE);
7144 	}
7145 
7146 	/* an insertion event */
7147 	if (ndi_busop_get_eventcookie(dip, rdip, FCAL_INSERT_EVENT, &cookie)
7148 	    != NDI_SUCCESS) {
7149 		return (NDI_FAILURE);
7150 	}
7151 
7152 	return (ndi_post_event(dip, rdip, cookie, impldata));
7153 }
7154 
7155 
7156 /*
7157  * the sf hotplug daemon, one thread per sf instance
7158  */
7159 static void
7160 sf_hp_daemon(void *arg)
7161 {
7162 	struct sf *sf = (struct sf *)arg;
7163 	struct sf_hp_elem *elem;
7164 	struct sf_target *target;
7165 	int tgt_id;
7166 	callb_cpr_t cprinfo;
7167 
7168 	CALLB_CPR_INIT(&cprinfo, &sf->sf_hp_daemon_mutex,
7169 	    callb_generic_cpr, "sf_hp_daemon");
7170 
7171 	mutex_enter(&sf->sf_hp_daemon_mutex);
7172 
7173 	do {
7174 		while (sf->sf_hp_elem_head != NULL) {
7175 
7176 			/* save ptr to head of list */
7177 			elem = sf->sf_hp_elem_head;
7178 
7179 			/* take element off of list */
7180 			if (sf->sf_hp_elem_head == sf->sf_hp_elem_tail) {
7181 				/* element only one in list -- list now empty */
7182 				sf->sf_hp_elem_head = NULL;
7183 				sf->sf_hp_elem_tail = NULL;
7184 			} else {
7185 				/* remove element from head of list */
7186 				sf->sf_hp_elem_head = sf->sf_hp_elem_head->next;
7187 			}
7188 
7189 			mutex_exit(&sf->sf_hp_daemon_mutex);
7190 
7191 			switch (elem->what) {
7192 			case SF_ONLINE:
7193 				/* online this target */
7194 				target = elem->target;
7195 				(void) ndi_devi_online(elem->dip, 0);
7196 				(void) ndi_event_retrieve_cookie(
7197 				    sf->sf_event_hdl,
7198 				    target->sft_dip, FCAL_INSERT_EVENT,
7199 				    &sf_insert_eid, NDI_EVENT_NOPASS);
7200 				(void) ndi_event_run_callbacks(sf->sf_event_hdl,
7201 				    target->sft_dip, sf_insert_eid, NULL);
7202 				break;
7203 			case SF_OFFLINE:
7204 				/* offline this target */
7205 				target = elem->target;
7206 				tgt_id = sf_alpa_to_switch[target->sft_al_pa];
7207 				/* don't do NDI_DEVI_REMOVE for now */
7208 				if (ndi_devi_offline(elem->dip, 0) !=
7209 				    NDI_SUCCESS) {
7210 					SF_DEBUG(1, (sf, CE_WARN, "target %x, "
7211 					    "device offline failed", tgt_id));
7212 				} else {
7213 					SF_DEBUG(1, (sf, CE_NOTE, "target %x, "
7214 					    "device offline succeeded\n",
7215 					    tgt_id));
7216 				}
7217 				break;
7218 			}
7219 			kmem_free(elem, sizeof (struct sf_hp_elem));
7220 			mutex_enter(&sf->sf_hp_daemon_mutex);
7221 		}
7222 
7223 		/* if exit is not already signaled */
7224 		if (sf->sf_hp_exit == 0) {
7225 			/* wait to be signaled by work or exit */
7226 			CALLB_CPR_SAFE_BEGIN(&cprinfo);
7227 			cv_wait(&sf->sf_hp_daemon_cv, &sf->sf_hp_daemon_mutex);
7228 			CALLB_CPR_SAFE_END(&cprinfo, &sf->sf_hp_daemon_mutex);
7229 		}
7230 	} while (sf->sf_hp_exit == 0);
7231 
7232 	/* sf_hp_daemon_mutex is dropped by CALLB_CPR_EXIT */
7233 	CALLB_CPR_EXIT(&cprinfo);
7234 	thread_exit();			/* no more hotplug thread */
7235 	/* NOTREACHED */
7236 }
7237