xref: /freebsd/sys/dev/mpt/mpt.c (revision 1d79ca0e46dd80a0e480b08159a31cfcb081015d)
1098ca2bdSWarner Losh /*-
20b80d21bSMatt Jacob  * Generic routines for LSI Fusion adapters.
39b631363SMatt Jacob  * FreeBSD Version.
49b631363SMatt Jacob  *
59b631363SMatt Jacob  * Copyright (c) 2000, 2001 by Greg Ansley
69b631363SMatt Jacob  *
79b631363SMatt Jacob  * Redistribution and use in source and binary forms, with or without
89b631363SMatt Jacob  * modification, are permitted provided that the following conditions
99b631363SMatt Jacob  * are met:
109b631363SMatt Jacob  * 1. Redistributions of source code must retain the above copyright
119b631363SMatt Jacob  *    notice immediately at the beginning of the file, without modification,
129b631363SMatt Jacob  *    this list of conditions, and the following disclaimer.
139b631363SMatt Jacob  * 2. The name of the author may not be used to endorse or promote products
149b631363SMatt Jacob  *    derived from this software without specific prior written permission.
159b631363SMatt Jacob  *
169b631363SMatt Jacob  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
179b631363SMatt Jacob  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
189b631363SMatt Jacob  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
199b631363SMatt Jacob  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
209b631363SMatt Jacob  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
219b631363SMatt Jacob  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
229b631363SMatt Jacob  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
239b631363SMatt Jacob  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
249b631363SMatt Jacob  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
259b631363SMatt Jacob  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
269b631363SMatt Jacob  * SUCH DAMAGE.
279b631363SMatt Jacob  */
280b80d21bSMatt Jacob /*-
290b80d21bSMatt Jacob  * Copyright (c) 2002, 2006 by Matthew Jacob
300b80d21bSMatt Jacob  * All rights reserved.
310b80d21bSMatt Jacob  *
320b80d21bSMatt Jacob  * Redistribution and use in source and binary forms, with or without
330b80d21bSMatt Jacob  * modification, are permitted provided that the following conditions are
340b80d21bSMatt Jacob  * met:
350b80d21bSMatt Jacob  * 1. Redistributions of source code must retain the above copyright
360b80d21bSMatt Jacob  *    notice, this list of conditions and the following disclaimer.
370b80d21bSMatt Jacob  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
380b80d21bSMatt Jacob  *    substantially similar to the "NO WARRANTY" disclaimer below
390b80d21bSMatt Jacob  *    ("Disclaimer") and any redistribution must be conditioned upon including
400b80d21bSMatt Jacob  *    a substantially similar Disclaimer requirement for further binary
410b80d21bSMatt Jacob  *    redistribution.
420b80d21bSMatt Jacob  * 3. Neither the names of the above listed copyright holders nor the names
430b80d21bSMatt Jacob  *    of any contributors may be used to endorse or promote products derived
440b80d21bSMatt Jacob  *    from this software without specific prior written permission.
450b80d21bSMatt Jacob  *
460b80d21bSMatt Jacob  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
470b80d21bSMatt Jacob  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
480b80d21bSMatt Jacob  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
490b80d21bSMatt Jacob  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
500b80d21bSMatt Jacob  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
510b80d21bSMatt Jacob  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
520b80d21bSMatt Jacob  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
530b80d21bSMatt Jacob  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
540b80d21bSMatt Jacob  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
550b80d21bSMatt Jacob  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT
560b80d21bSMatt Jacob  * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
570b80d21bSMatt Jacob  *
580b80d21bSMatt Jacob  * Support from Chris Ellsworth in order to make SAS adapters work
590b80d21bSMatt Jacob  * is gratefully acknowledged.
600b80d21bSMatt Jacob  */
610b80d21bSMatt Jacob /*-
62b0a2fdeeSScott Long  * Copyright (c) 2004, Avid Technology, Inc. and its contributors.
63b0a2fdeeSScott Long  * Copyright (c) 2005, WHEEL Sp. z o.o.
64b0a2fdeeSScott Long  * Copyright (c) 2004, 2005 Justin T. Gibbs
65b0a2fdeeSScott Long  * All rights reserved.
66b0a2fdeeSScott Long  *
67b0a2fdeeSScott Long  * Redistribution and use in source and binary forms, with or without
68b0a2fdeeSScott Long  * modification, are permitted provided that the following conditions are
69b0a2fdeeSScott Long  * met:
70b0a2fdeeSScott Long  * 1. Redistributions of source code must retain the above copyright
71b0a2fdeeSScott Long  *    notice, this list of conditions and the following disclaimer.
72b0a2fdeeSScott Long  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
73b0a2fdeeSScott Long  *    substantially similar to the "NO WARRANTY" disclaimer below
74b0a2fdeeSScott Long  *    ("Disclaimer") and any redistribution must be conditioned upon including
75b0a2fdeeSScott Long  *    a substantially similar Disclaimer requirement for further binary
76b0a2fdeeSScott Long  *    redistribution.
77286e947fSJustin T. Gibbs  * 3. Neither the names of the above listed copyright holders nor the names
78286e947fSJustin T. Gibbs  *    of any contributors may be used to endorse or promote products derived
79286e947fSJustin T. Gibbs  *    from this software without specific prior written permission.
80b0a2fdeeSScott Long  *
81b0a2fdeeSScott Long  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
82b0a2fdeeSScott Long  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
83b0a2fdeeSScott Long  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
84b0a2fdeeSScott Long  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
85b0a2fdeeSScott Long  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
86b0a2fdeeSScott Long  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
87b0a2fdeeSScott Long  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
88b0a2fdeeSScott Long  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
89b0a2fdeeSScott Long  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
90b0a2fdeeSScott Long  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT
91b0a2fdeeSScott Long  * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
929b631363SMatt Jacob  */
939b631363SMatt Jacob 
949295c6c5SDavid E. O'Brien #include <sys/cdefs.h>
959295c6c5SDavid E. O'Brien __FBSDID("$FreeBSD$");
969295c6c5SDavid E. O'Brien 
97b0a2fdeeSScott Long #include <dev/mpt/mpt.h>
98b0a2fdeeSScott Long #include <dev/mpt/mpt_cam.h> /* XXX For static handler registration */
99b0a2fdeeSScott Long #include <dev/mpt/mpt_raid.h> /* XXX For static handler registration */
100b0a2fdeeSScott Long 
101b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi.h>
102b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi_ioc.h>
103c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_fc.h>
104c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_targ.h>
105b0a2fdeeSScott Long 
106b0a2fdeeSScott Long #include <sys/sysctl.h>
1077104aeefSMatt Jacob 
1089b631363SMatt Jacob #define MPT_MAX_TRYS 3
1099b631363SMatt Jacob #define MPT_MAX_WAIT 300000
1109b631363SMatt Jacob 
1119b631363SMatt Jacob static int maxwait_ack = 0;
1129b631363SMatt Jacob static int maxwait_int = 0;
1139b631363SMatt Jacob static int maxwait_state = 0;
1149b631363SMatt Jacob 
115b0a2fdeeSScott Long TAILQ_HEAD(, mpt_softc)	mpt_tailq = TAILQ_HEAD_INITIALIZER(mpt_tailq);
116b0a2fdeeSScott Long mpt_reply_handler_t *mpt_reply_handlers[MPT_NUM_REPLY_HANDLERS];
1179b631363SMatt Jacob 
118b0a2fdeeSScott Long static mpt_reply_handler_t mpt_default_reply_handler;
119b0a2fdeeSScott Long static mpt_reply_handler_t mpt_config_reply_handler;
120b0a2fdeeSScott Long static mpt_reply_handler_t mpt_handshake_reply_handler;
121b0a2fdeeSScott Long static mpt_reply_handler_t mpt_event_reply_handler;
122b0a2fdeeSScott Long static void mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req,
123b0a2fdeeSScott Long 			       MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context);
124444dd2b6SMatt Jacob static int mpt_send_event_request(struct mpt_softc *mpt, int onoff);
125b0a2fdeeSScott Long static int mpt_soft_reset(struct mpt_softc *mpt);
126b0a2fdeeSScott Long static void mpt_hard_reset(struct mpt_softc *mpt);
127b0a2fdeeSScott Long static int mpt_configure_ioc(struct mpt_softc *mpt);
128c87e3f83SMatt Jacob static int mpt_enable_ioc(struct mpt_softc *mpt, int);
129b0a2fdeeSScott Long 
130b0a2fdeeSScott Long /************************* Personality Module Support *************************/
131b0a2fdeeSScott Long /*
132b0a2fdeeSScott Long  * We include one extra entry that is guaranteed to be NULL
133b0a2fdeeSScott Long  * to simplify our itterator.
134b0a2fdeeSScott Long  */
135b0a2fdeeSScott Long static struct mpt_personality *mpt_personalities[MPT_MAX_PERSONALITIES + 1];
136b0a2fdeeSScott Long static __inline struct mpt_personality*
137b0a2fdeeSScott Long 	mpt_pers_find(struct mpt_softc *, u_int);
138b0a2fdeeSScott Long static __inline struct mpt_personality*
139b0a2fdeeSScott Long 	mpt_pers_find_reverse(struct mpt_softc *, u_int);
140b0a2fdeeSScott Long 
141b0a2fdeeSScott Long static __inline struct mpt_personality *
142b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *mpt, u_int start_at)
143b0a2fdeeSScott Long {
144b0a2fdeeSScott Long 	KASSERT(start_at <= MPT_MAX_PERSONALITIES,
145b0a2fdeeSScott Long 		("mpt_pers_find: starting position out of range\n"));
146b0a2fdeeSScott Long 
147b0a2fdeeSScott Long 	while (start_at < MPT_MAX_PERSONALITIES
148b0a2fdeeSScott Long 	    && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) {
149b0a2fdeeSScott Long 		start_at++;
150b0a2fdeeSScott Long 	}
151b0a2fdeeSScott Long 	return (mpt_personalities[start_at]);
152b0a2fdeeSScott Long }
153b0a2fdeeSScott Long 
154b0a2fdeeSScott Long /*
155c87e3f83SMatt Jacob  * Used infrequently, so no need to optimize like a forward
156b0a2fdeeSScott Long  * traversal where we use the MAX+1 is guaranteed to be NULL
157b0a2fdeeSScott Long  * trick.
158b0a2fdeeSScott Long  */
159b0a2fdeeSScott Long static __inline struct mpt_personality *
160b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *mpt, u_int start_at)
161b0a2fdeeSScott Long {
162b0a2fdeeSScott Long 	while (start_at < MPT_MAX_PERSONALITIES
163b0a2fdeeSScott Long 	    && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) {
164b0a2fdeeSScott Long 		start_at--;
165b0a2fdeeSScott Long 	}
166b0a2fdeeSScott Long 	if (start_at < MPT_MAX_PERSONALITIES)
167b0a2fdeeSScott Long 		return (mpt_personalities[start_at]);
168b0a2fdeeSScott Long 	return (NULL);
169b0a2fdeeSScott Long }
170b0a2fdeeSScott Long 
171b0a2fdeeSScott Long #define MPT_PERS_FOREACH(mpt, pers)				\
172b0a2fdeeSScott Long 	for (pers = mpt_pers_find(mpt, /*start_at*/0);		\
173b0a2fdeeSScott Long 	     pers != NULL;					\
174b0a2fdeeSScott Long 	     pers = mpt_pers_find(mpt, /*start_at*/pers->id+1))
175b0a2fdeeSScott Long 
176b0a2fdeeSScott Long #define MPT_PERS_FOREACH_REVERSE(mpt, pers)				\
177b0a2fdeeSScott Long 	for (pers = mpt_pers_find_reverse(mpt, MPT_MAX_PERSONALITIES-1);\
178b0a2fdeeSScott Long 	     pers != NULL;						\
179b0a2fdeeSScott Long 	     pers = mpt_pers_find_reverse(mpt, /*start_at*/pers->id-1))
180b0a2fdeeSScott Long 
181b0a2fdeeSScott Long static mpt_load_handler_t      mpt_stdload;
182b0a2fdeeSScott Long static mpt_probe_handler_t     mpt_stdprobe;
183b0a2fdeeSScott Long static mpt_attach_handler_t    mpt_stdattach;
184c87e3f83SMatt Jacob static mpt_enable_handler_t    mpt_stdenable;
185b0a2fdeeSScott Long static mpt_event_handler_t     mpt_stdevent;
186b0a2fdeeSScott Long static mpt_reset_handler_t     mpt_stdreset;
187b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_stdshutdown;
188b0a2fdeeSScott Long static mpt_detach_handler_t    mpt_stddetach;
189b0a2fdeeSScott Long static mpt_unload_handler_t    mpt_stdunload;
190b0a2fdeeSScott Long static struct mpt_personality mpt_default_personality =
191b0a2fdeeSScott Long {
192b0a2fdeeSScott Long 	.load		= mpt_stdload,
193b0a2fdeeSScott Long 	.probe		= mpt_stdprobe,
194b0a2fdeeSScott Long 	.attach		= mpt_stdattach,
195c87e3f83SMatt Jacob 	.enable		= mpt_stdenable,
196b0a2fdeeSScott Long 	.event		= mpt_stdevent,
197b0a2fdeeSScott Long 	.reset		= mpt_stdreset,
198b0a2fdeeSScott Long 	.shutdown	= mpt_stdshutdown,
199b0a2fdeeSScott Long 	.detach		= mpt_stddetach,
200b0a2fdeeSScott Long 	.unload		= mpt_stdunload
201b0a2fdeeSScott Long };
202b0a2fdeeSScott Long 
203b0a2fdeeSScott Long static mpt_load_handler_t      mpt_core_load;
204b0a2fdeeSScott Long static mpt_attach_handler_t    mpt_core_attach;
205c87e3f83SMatt Jacob static mpt_enable_handler_t    mpt_core_enable;
206b0a2fdeeSScott Long static mpt_reset_handler_t     mpt_core_ioc_reset;
207b0a2fdeeSScott Long static mpt_event_handler_t     mpt_core_event;
208b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_core_shutdown;
209b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_core_detach;
210b0a2fdeeSScott Long static mpt_unload_handler_t    mpt_core_unload;
211b0a2fdeeSScott Long static struct mpt_personality mpt_core_personality =
212b0a2fdeeSScott Long {
213b0a2fdeeSScott Long 	.name		= "mpt_core",
214b0a2fdeeSScott Long 	.load		= mpt_core_load,
215b0a2fdeeSScott Long 	.attach		= mpt_core_attach,
216c87e3f83SMatt Jacob 	.enable		= mpt_core_enable,
217b0a2fdeeSScott Long 	.event		= mpt_core_event,
218b0a2fdeeSScott Long 	.reset		= mpt_core_ioc_reset,
219b0a2fdeeSScott Long 	.shutdown	= mpt_core_shutdown,
220b0a2fdeeSScott Long 	.detach		= mpt_core_detach,
221b0a2fdeeSScott Long 	.unload		= mpt_core_unload,
222b0a2fdeeSScott Long };
223b0a2fdeeSScott Long 
224b0a2fdeeSScott Long /*
225b0a2fdeeSScott Long  * Manual declaration so that DECLARE_MPT_PERSONALITY doesn't need
226b0a2fdeeSScott Long  * ordering information.  We want the core to always register FIRST.
227b0a2fdeeSScott Long  * other modules are set to SI_ORDER_SECOND.
228b0a2fdeeSScott Long  */
229b0a2fdeeSScott Long static moduledata_t mpt_core_mod = {
230b0a2fdeeSScott Long 	"mpt_core", mpt_modevent, &mpt_core_personality
231b0a2fdeeSScott Long };
232b0a2fdeeSScott Long DECLARE_MODULE(mpt_core, mpt_core_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
233b0a2fdeeSScott Long MODULE_VERSION(mpt_core, 1);
234b0a2fdeeSScott Long 
235c87e3f83SMatt Jacob #define MPT_PERS_ATTACHED(pers, mpt) ((mpt)->mpt_pers_mask & (0x1 << pers->id))
236b0a2fdeeSScott Long 
237b0a2fdeeSScott Long 
238b0a2fdeeSScott Long int
239b0a2fdeeSScott Long mpt_modevent(module_t mod, int type, void *data)
240b0a2fdeeSScott Long {
241b0a2fdeeSScott Long 	struct mpt_personality *pers;
242b0a2fdeeSScott Long 	int error;
243b0a2fdeeSScott Long 
244b0a2fdeeSScott Long 	pers = (struct mpt_personality *)data;
245b0a2fdeeSScott Long 
246b0a2fdeeSScott Long 	error = 0;
247b0a2fdeeSScott Long 	switch (type) {
248b0a2fdeeSScott Long 	case MOD_LOAD:
249b0a2fdeeSScott Long 	{
250b0a2fdeeSScott Long 		mpt_load_handler_t **def_handler;
251b0a2fdeeSScott Long 		mpt_load_handler_t **pers_handler;
252b0a2fdeeSScott Long 		int i;
253b0a2fdeeSScott Long 
254b0a2fdeeSScott Long 		for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
255b0a2fdeeSScott Long 			if (mpt_personalities[i] == NULL)
256b0a2fdeeSScott Long 				break;
257b0a2fdeeSScott Long 		}
258b0a2fdeeSScott Long 		if (i >= MPT_MAX_PERSONALITIES) {
259b0a2fdeeSScott Long 			error = ENOMEM;
260b0a2fdeeSScott Long 			break;
261b0a2fdeeSScott Long 		}
262b0a2fdeeSScott Long 		pers->id = i;
263b0a2fdeeSScott Long 		mpt_personalities[i] = pers;
264b0a2fdeeSScott Long 
265b0a2fdeeSScott Long 		/* Install standard/noop handlers for any NULL entries. */
266b0a2fdeeSScott Long 		def_handler = MPT_PERS_FIRST_HANDLER(&mpt_default_personality);
267b0a2fdeeSScott Long 		pers_handler = MPT_PERS_FIRST_HANDLER(pers);
268b0a2fdeeSScott Long 		while (pers_handler <= MPT_PERS_LAST_HANDLER(pers)) {
269b0a2fdeeSScott Long 			if (*pers_handler == NULL)
270b0a2fdeeSScott Long 				*pers_handler = *def_handler;
271b0a2fdeeSScott Long 			pers_handler++;
272b0a2fdeeSScott Long 			def_handler++;
273b0a2fdeeSScott Long 		}
274b0a2fdeeSScott Long 
275b0a2fdeeSScott Long 		error = (pers->load(pers));
276b0a2fdeeSScott Long 		if (error != 0)
277b0a2fdeeSScott Long 			mpt_personalities[i] = NULL;
278b0a2fdeeSScott Long 		break;
279b0a2fdeeSScott Long 	}
280b0a2fdeeSScott Long 	case MOD_SHUTDOWN:
281b0a2fdeeSScott Long 		break;
282c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000
283b0a2fdeeSScott Long 	case MOD_QUIESCE:
284b0a2fdeeSScott Long 		break;
285c87e3f83SMatt Jacob #endif
286b0a2fdeeSScott Long 	case MOD_UNLOAD:
287b0a2fdeeSScott Long 		error = pers->unload(pers);
288b0a2fdeeSScott Long 		mpt_personalities[pers->id] = NULL;
289b0a2fdeeSScott Long 		break;
290b0a2fdeeSScott Long 	default:
291b0a2fdeeSScott Long 		error = EINVAL;
292b0a2fdeeSScott Long 		break;
293b0a2fdeeSScott Long 	}
294b0a2fdeeSScott Long 	return (error);
295b0a2fdeeSScott Long }
296b0a2fdeeSScott Long 
297b0a2fdeeSScott Long int
298b0a2fdeeSScott Long mpt_stdload(struct mpt_personality *pers)
299b0a2fdeeSScott Long {
300b0a2fdeeSScott Long 	/* Load is always successfull. */
301b0a2fdeeSScott Long 	return (0);
302b0a2fdeeSScott Long }
303b0a2fdeeSScott Long 
304b0a2fdeeSScott Long int
305b0a2fdeeSScott Long mpt_stdprobe(struct mpt_softc *mpt)
306b0a2fdeeSScott Long {
307b0a2fdeeSScott Long 	/* Probe is always successfull. */
308b0a2fdeeSScott Long 	return (0);
309b0a2fdeeSScott Long }
310b0a2fdeeSScott Long 
311b0a2fdeeSScott Long int
312b0a2fdeeSScott Long mpt_stdattach(struct mpt_softc *mpt)
313b0a2fdeeSScott Long {
314b0a2fdeeSScott Long 	/* Attach is always successfull. */
315b0a2fdeeSScott Long 	return (0);
316b0a2fdeeSScott Long }
317b0a2fdeeSScott Long 
318b0a2fdeeSScott Long int
319c87e3f83SMatt Jacob mpt_stdenable(struct mpt_softc *mpt)
320c87e3f83SMatt Jacob {
321c87e3f83SMatt Jacob 	/* Enable is always successfull. */
322c87e3f83SMatt Jacob 	return (0);
323c87e3f83SMatt Jacob }
324c87e3f83SMatt Jacob 
325c87e3f83SMatt Jacob int
326444dd2b6SMatt Jacob mpt_stdevent(struct mpt_softc *mpt, request_t *req, MSG_EVENT_NOTIFY_REPLY *msg)
327b0a2fdeeSScott Long {
328444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_stdevent: 0x%x\n", msg->Event & 0xFF);
329b0a2fdeeSScott Long 	/* Event was not for us. */
330b0a2fdeeSScott Long 	return (0);
331b0a2fdeeSScott Long }
332b0a2fdeeSScott Long 
333b0a2fdeeSScott Long void
334b0a2fdeeSScott Long mpt_stdreset(struct mpt_softc *mpt, int type)
335b0a2fdeeSScott Long {
336b0a2fdeeSScott Long }
337b0a2fdeeSScott Long 
338b0a2fdeeSScott Long void
339b0a2fdeeSScott Long mpt_stdshutdown(struct mpt_softc *mpt)
340b0a2fdeeSScott Long {
341b0a2fdeeSScott Long }
342b0a2fdeeSScott Long 
343b0a2fdeeSScott Long void
344b0a2fdeeSScott Long mpt_stddetach(struct mpt_softc *mpt)
345b0a2fdeeSScott Long {
346b0a2fdeeSScott Long }
347b0a2fdeeSScott Long 
348b0a2fdeeSScott Long int
349b0a2fdeeSScott Long mpt_stdunload(struct mpt_personality *pers)
350b0a2fdeeSScott Long {
351b0a2fdeeSScott Long 	/* Unload is always successfull. */
352b0a2fdeeSScott Long 	return (0);
353b0a2fdeeSScott Long }
354b0a2fdeeSScott Long 
355b0a2fdeeSScott Long /******************************* Bus DMA Support ******************************/
356b0a2fdeeSScott Long void
357b0a2fdeeSScott Long mpt_map_rquest(void *arg, bus_dma_segment_t *segs, int nseg, int error)
358b0a2fdeeSScott Long {
359b0a2fdeeSScott Long 	struct mpt_map_info *map_info;
360b0a2fdeeSScott Long 
361b0a2fdeeSScott Long 	map_info = (struct mpt_map_info *)arg;
362b0a2fdeeSScott Long 	map_info->error = error;
363b0a2fdeeSScott Long 	map_info->phys = segs->ds_addr;
364b0a2fdeeSScott Long }
365b0a2fdeeSScott Long 
366b0a2fdeeSScott Long /**************************** Reply/Event Handling ****************************/
367b0a2fdeeSScott Long int
368b0a2fdeeSScott Long mpt_register_handler(struct mpt_softc *mpt, mpt_handler_type type,
369b0a2fdeeSScott Long 		     mpt_handler_t handler, uint32_t *phandler_id)
370b0a2fdeeSScott Long {
371b0a2fdeeSScott Long 
372b0a2fdeeSScott Long 	switch (type) {
373b0a2fdeeSScott Long 	case MPT_HANDLER_REPLY:
374b0a2fdeeSScott Long 	{
375b0a2fdeeSScott Long 		u_int cbi;
376b0a2fdeeSScott Long 		u_int free_cbi;
377b0a2fdeeSScott Long 
378b0a2fdeeSScott Long 		if (phandler_id == NULL)
379b0a2fdeeSScott Long 			return (EINVAL);
380b0a2fdeeSScott Long 
381b0a2fdeeSScott Long 		free_cbi = MPT_HANDLER_ID_NONE;
382b0a2fdeeSScott Long 		for (cbi = 0; cbi < MPT_NUM_REPLY_HANDLERS; cbi++) {
383b0a2fdeeSScott Long 			/*
384b0a2fdeeSScott Long 			 * If the same handler is registered multiple
385b0a2fdeeSScott Long 			 * times, don't error out.  Just return the
386b0a2fdeeSScott Long 			 * index of the original registration.
387b0a2fdeeSScott Long 			 */
388b0a2fdeeSScott Long 			if (mpt_reply_handlers[cbi] == handler.reply_handler) {
389b0a2fdeeSScott Long 				*phandler_id = MPT_CBI_TO_HID(cbi);
390b0a2fdeeSScott Long 				return (0);
391b0a2fdeeSScott Long 			}
392b0a2fdeeSScott Long 
393b0a2fdeeSScott Long 			/*
394b0a2fdeeSScott Long 			 * Fill from the front in the hope that
395b0a2fdeeSScott Long 			 * all registered handlers consume only a
396b0a2fdeeSScott Long 			 * single cache line.
397b0a2fdeeSScott Long 			 *
398b0a2fdeeSScott Long 			 * We don't break on the first empty slot so
399b0a2fdeeSScott Long 			 * that the full table is checked to see if
400b0a2fdeeSScott Long 			 * this handler was previously registered.
401b0a2fdeeSScott Long 			 */
402c87e3f83SMatt Jacob 			if (free_cbi == MPT_HANDLER_ID_NONE &&
403c87e3f83SMatt Jacob 			    (mpt_reply_handlers[cbi]
404b0a2fdeeSScott Long 			  == mpt_default_reply_handler))
405b0a2fdeeSScott Long 				free_cbi = cbi;
406b0a2fdeeSScott Long 		}
407c87e3f83SMatt Jacob 		if (free_cbi == MPT_HANDLER_ID_NONE) {
408b0a2fdeeSScott Long 			return (ENOMEM);
409c87e3f83SMatt Jacob 		}
410b0a2fdeeSScott Long 		mpt_reply_handlers[free_cbi] = handler.reply_handler;
411b0a2fdeeSScott Long 		*phandler_id = MPT_CBI_TO_HID(free_cbi);
412b0a2fdeeSScott Long 		break;
413b0a2fdeeSScott Long 	}
414b0a2fdeeSScott Long 	default:
415b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_register_handler unknown type %d\n", type);
416b0a2fdeeSScott Long 		return (EINVAL);
417b0a2fdeeSScott Long 	}
418b0a2fdeeSScott Long 	return (0);
419b0a2fdeeSScott Long }
420b0a2fdeeSScott Long 
421b0a2fdeeSScott Long int
422b0a2fdeeSScott Long mpt_deregister_handler(struct mpt_softc *mpt, mpt_handler_type type,
423b0a2fdeeSScott Long 		       mpt_handler_t handler, uint32_t handler_id)
424b0a2fdeeSScott Long {
425b0a2fdeeSScott Long 
426b0a2fdeeSScott Long 	switch (type) {
427b0a2fdeeSScott Long 	case MPT_HANDLER_REPLY:
428b0a2fdeeSScott Long 	{
429b0a2fdeeSScott Long 		u_int cbi;
430b0a2fdeeSScott Long 
431b0a2fdeeSScott Long 		cbi = MPT_CBI(handler_id);
432b0a2fdeeSScott Long 		if (cbi >= MPT_NUM_REPLY_HANDLERS
433b0a2fdeeSScott Long 		 || mpt_reply_handlers[cbi] != handler.reply_handler)
434b0a2fdeeSScott Long 			return (ENOENT);
435b0a2fdeeSScott Long 		mpt_reply_handlers[cbi] = mpt_default_reply_handler;
436b0a2fdeeSScott Long 		break;
437b0a2fdeeSScott Long 	}
438b0a2fdeeSScott Long 	default:
439b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_deregister_handler unknown type %d\n", type);
440b0a2fdeeSScott Long 		return (EINVAL);
441b0a2fdeeSScott Long 	}
442b0a2fdeeSScott Long 	return (0);
443b0a2fdeeSScott Long }
444b0a2fdeeSScott Long 
445b0a2fdeeSScott Long static int
446b0a2fdeeSScott Long mpt_default_reply_handler(struct mpt_softc *mpt, request_t *req,
447c87e3f83SMatt Jacob 	uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
448b0a2fdeeSScott Long {
449c87e3f83SMatt Jacob 	mpt_prt(mpt,
450c87e3f83SMatt Jacob 	    "Default Handler Called: req=%p:%u reply_descriptor=%x frame=%p\n",
451c87e3f83SMatt Jacob 	    req, req->serno, reply_desc, reply_frame);
452b0a2fdeeSScott Long 
453b0a2fdeeSScott Long 	if (reply_frame != NULL)
454b0a2fdeeSScott Long 		mpt_dump_reply_frame(mpt, reply_frame);
455b0a2fdeeSScott Long 
456c87e3f83SMatt Jacob 	mpt_prt(mpt, "Reply Frame Ignored\n");
457b0a2fdeeSScott Long 
458b0a2fdeeSScott Long 	return (/*free_reply*/TRUE);
459b0a2fdeeSScott Long }
460b0a2fdeeSScott Long 
461b0a2fdeeSScott Long static int
462b0a2fdeeSScott Long mpt_config_reply_handler(struct mpt_softc *mpt, request_t *req,
463c87e3f83SMatt Jacob  uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
464b0a2fdeeSScott Long {
465b0a2fdeeSScott Long 	if (req != NULL) {
466b0a2fdeeSScott Long 
467b0a2fdeeSScott Long 		if (reply_frame != NULL) {
468b0a2fdeeSScott Long 			MSG_CONFIG *cfgp;
469b0a2fdeeSScott Long 			MSG_CONFIG_REPLY *reply;
470b0a2fdeeSScott Long 
471b0a2fdeeSScott Long 			cfgp = (MSG_CONFIG *)req->req_vbuf;
472b0a2fdeeSScott Long 			reply = (MSG_CONFIG_REPLY *)reply_frame;
473b0a2fdeeSScott Long 			req->IOCStatus = le16toh(reply_frame->IOCStatus);
474b0a2fdeeSScott Long 			bcopy(&reply->Header, &cfgp->Header,
475b0a2fdeeSScott Long 			      sizeof(cfgp->Header));
476b0a2fdeeSScott Long 		}
477b0a2fdeeSScott Long 		req->state &= ~REQ_STATE_QUEUED;
478b0a2fdeeSScott Long 		req->state |= REQ_STATE_DONE;
479b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_pending_list, req, links);
4805e073106SMatt Jacob 		if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) {
481b0a2fdeeSScott Long 			wakeup(req);
482b0a2fdeeSScott Long 		}
4835e073106SMatt Jacob 	}
484b0a2fdeeSScott Long 
4855e073106SMatt Jacob 	return (TRUE);
486b0a2fdeeSScott Long }
487b0a2fdeeSScott Long 
488b0a2fdeeSScott Long static int
489b0a2fdeeSScott Long mpt_handshake_reply_handler(struct mpt_softc *mpt, request_t *req,
490c87e3f83SMatt Jacob  uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
491b0a2fdeeSScott Long {
492b0a2fdeeSScott Long 	/* Nothing to be done. */
4935e073106SMatt Jacob 	return (TRUE);
494b0a2fdeeSScott Long }
495b0a2fdeeSScott Long 
496b0a2fdeeSScott Long static int
497b0a2fdeeSScott Long mpt_event_reply_handler(struct mpt_softc *mpt, request_t *req,
498c87e3f83SMatt Jacob     uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
499b0a2fdeeSScott Long {
500b0a2fdeeSScott Long 	int free_reply;
501b0a2fdeeSScott Long 
5025e073106SMatt Jacob 	KASSERT(reply_frame != NULL, ("null reply in mpt_event_reply_handler"));
5035e073106SMatt Jacob 	KASSERT(req != NULL, ("null request in mpt_event_reply_handler"));
504b0a2fdeeSScott Long 
505b0a2fdeeSScott Long 	free_reply = TRUE;
506b0a2fdeeSScott Long 	switch (reply_frame->Function) {
507b0a2fdeeSScott Long 	case MPI_FUNCTION_EVENT_NOTIFICATION:
508b0a2fdeeSScott Long 	{
509b0a2fdeeSScott Long 		MSG_EVENT_NOTIFY_REPLY *msg;
510b0a2fdeeSScott Long 		struct mpt_personality *pers;
511b0a2fdeeSScott Long 		u_int handled;
512b0a2fdeeSScott Long 
513b0a2fdeeSScott Long 		handled = 0;
514b0a2fdeeSScott Long 		msg = (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
515b0a2fdeeSScott Long 		MPT_PERS_FOREACH(mpt, pers)
516b0a2fdeeSScott Long 			handled += pers->event(mpt, req, msg);
517b0a2fdeeSScott Long 
518444dd2b6SMatt Jacob 		if (handled == 0 && mpt->mpt_pers_mask == 0) {
5191977cbd6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_INFO,
520444dd2b6SMatt Jacob 				"No Handlers For Any Event Notify Frames. "
521444dd2b6SMatt Jacob 				"Event %#x (ACK %sequired).\n",
522444dd2b6SMatt Jacob 				msg->Event, msg->AckRequired? "r" : "not r");
523444dd2b6SMatt Jacob 		} else if (handled == 0) {
5241977cbd6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_WARN,
525444dd2b6SMatt Jacob 				"Unhandled Event Notify Frame. Event %#x "
526444dd2b6SMatt Jacob 				"(ACK %sequired).\n",
527444dd2b6SMatt Jacob 				msg->Event, msg->AckRequired? "r" : "not r");
528444dd2b6SMatt Jacob 		}
529b0a2fdeeSScott Long 
530b0a2fdeeSScott Long 		if (msg->AckRequired) {
531b0a2fdeeSScott Long 			request_t *ack_req;
532b0a2fdeeSScott Long 			uint32_t context;
533b0a2fdeeSScott Long 
534b0a2fdeeSScott Long 			context = htole32(req->index|MPT_REPLY_HANDLER_EVENTS);
5355e073106SMatt Jacob 			ack_req = mpt_get_request(mpt, FALSE);
536b0a2fdeeSScott Long 			if (ack_req == NULL) {
537b0a2fdeeSScott Long 				struct mpt_evtf_record *evtf;
538b0a2fdeeSScott Long 
539b0a2fdeeSScott Long 				evtf = (struct mpt_evtf_record *)reply_frame;
540b0a2fdeeSScott Long 				evtf->context = context;
541b0a2fdeeSScott Long 				LIST_INSERT_HEAD(&mpt->ack_frames, evtf, links);
542b0a2fdeeSScott Long 				free_reply = FALSE;
543b0a2fdeeSScott Long 				break;
544b0a2fdeeSScott Long 			}
545b0a2fdeeSScott Long 			mpt_send_event_ack(mpt, ack_req, msg, context);
5465e073106SMatt Jacob 			/*
5475e073106SMatt Jacob 			 * Don't check for CONTINUATION_REPLY here
5485e073106SMatt Jacob 			 */
5495e073106SMatt Jacob 			return (free_reply);
550b0a2fdeeSScott Long 		}
551b0a2fdeeSScott Long 		break;
552b0a2fdeeSScott Long 	}
553b0a2fdeeSScott Long 	case MPI_FUNCTION_PORT_ENABLE:
554b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG , "enable port reply\n");
555b0a2fdeeSScott Long 		break;
556b0a2fdeeSScott Long 	case MPI_FUNCTION_EVENT_ACK:
557b0a2fdeeSScott Long 		break;
558b0a2fdeeSScott Long 	default:
5595e073106SMatt Jacob 		mpt_prt(mpt, "unknown event function: %x\n",
560b0a2fdeeSScott Long 			reply_frame->Function);
561b0a2fdeeSScott Long 		break;
562b0a2fdeeSScott Long 	}
563b0a2fdeeSScott Long 
5645e073106SMatt Jacob 	/*
5655e073106SMatt Jacob 	 * I'm not sure that this continuation stuff works as it should.
5665e073106SMatt Jacob 	 *
5675e073106SMatt Jacob 	 * I've had FC async events occur that free the frame up because
5685e073106SMatt Jacob 	 * the continuation bit isn't set, and then additional async events
5695e073106SMatt Jacob 	 * then occur using the same context. As you might imagine, this
5705e073106SMatt Jacob 	 * leads to Very Bad Thing.
5715e073106SMatt Jacob 	 *
5725e073106SMatt Jacob 	 *  Let's just be safe for now and not free them up until we figure
5735e073106SMatt Jacob 	 * out what's actually happening here.
5745e073106SMatt Jacob 	 */
5755e073106SMatt Jacob #if	0
5765e073106SMatt Jacob 	if ((reply_frame->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) == 0) {
577b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_pending_list, req, links);
578b0a2fdeeSScott Long 		mpt_free_request(mpt, req);
5795e073106SMatt Jacob 		mpt_prt(mpt, "event_reply %x for req %p:%u NOT a continuation",
5805e073106SMatt Jacob 		    reply_frame->Function, req, req->serno);
5815e073106SMatt Jacob 		if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) {
5825e073106SMatt Jacob 			MSG_EVENT_NOTIFY_REPLY *msg =
5835e073106SMatt Jacob 			    (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
5845e073106SMatt Jacob 			mpt_prtc(mpt, " Event=0x%x AckReq=%d",
5855e073106SMatt Jacob 			    msg->Event, msg->AckRequired);
586b0a2fdeeSScott Long 		}
5875e073106SMatt Jacob 	} else {
5885e073106SMatt Jacob 		mpt_prt(mpt, "event_reply %x for %p:%u IS a continuation",
5895e073106SMatt Jacob 		    reply_frame->Function, req, req->serno);
5905e073106SMatt Jacob 		if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) {
5915e073106SMatt Jacob 			MSG_EVENT_NOTIFY_REPLY *msg =
5925e073106SMatt Jacob 			    (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
5935e073106SMatt Jacob 			mpt_prtc(mpt, " Event=0x%x AckReq=%d",
5945e073106SMatt Jacob 			    msg->Event, msg->AckRequired);
5955e073106SMatt Jacob 		}
5965e073106SMatt Jacob 		mpt_prtc(mpt, "\n");
5975e073106SMatt Jacob 	}
5985e073106SMatt Jacob #endif
599b0a2fdeeSScott Long 	return (free_reply);
600b0a2fdeeSScott Long }
601b0a2fdeeSScott Long 
602b0a2fdeeSScott Long /*
603b0a2fdeeSScott Long  * Process an asynchronous event from the IOC.
604b0a2fdeeSScott Long  */
605b0a2fdeeSScott Long static int
606b0a2fdeeSScott Long mpt_core_event(struct mpt_softc *mpt, request_t *req,
607b0a2fdeeSScott Long 	       MSG_EVENT_NOTIFY_REPLY *msg)
608b0a2fdeeSScott Long {
609444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_core_event: 0x%x\n",
610444dd2b6SMatt Jacob                  msg->Event & 0xFF);
611b0a2fdeeSScott Long 	switch(msg->Event & 0xFF) {
612b0a2fdeeSScott Long 	case MPI_EVENT_NONE:
613b0a2fdeeSScott Long 		break;
614b0a2fdeeSScott Long 	case MPI_EVENT_LOG_DATA:
615b0a2fdeeSScott Long 	{
616b0a2fdeeSScott Long 		int i;
617b0a2fdeeSScott Long 
618b0a2fdeeSScott Long 		/* Some error occured that LSI wants logged */
619b0a2fdeeSScott Long 		mpt_prt(mpt, "EvtLogData: IOCLogInfo: 0x%08x\n",
620b0a2fdeeSScott Long 			msg->IOCLogInfo);
621b0a2fdeeSScott Long 		mpt_prt(mpt, "\tEvtLogData: Event Data:");
622b0a2fdeeSScott Long 		for (i = 0; i < msg->EventDataLength; i++)
623b0a2fdeeSScott Long 			mpt_prtc(mpt, "  %08x", msg->Data[i]);
624b0a2fdeeSScott Long 		mpt_prtc(mpt, "\n");
625b0a2fdeeSScott Long 		break;
626b0a2fdeeSScott Long 	}
627b0a2fdeeSScott Long 	case MPI_EVENT_EVENT_CHANGE:
628b0a2fdeeSScott Long 		/*
629b0a2fdeeSScott Long 		 * This is just an acknowledgement
630b0a2fdeeSScott Long 		 * of our mpt_send_event_request.
631b0a2fdeeSScott Long 		 */
632b0a2fdeeSScott Long 		break;
633444dd2b6SMatt Jacob 	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
634444dd2b6SMatt Jacob 		break;
635b0a2fdeeSScott Long 	default:
6365e073106SMatt Jacob 		return (0);
637b0a2fdeeSScott Long 		break;
638b0a2fdeeSScott Long 	}
6395e073106SMatt Jacob 	return (1);
640b0a2fdeeSScott Long }
641b0a2fdeeSScott Long 
642b0a2fdeeSScott Long static void
643b0a2fdeeSScott Long mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req,
644b0a2fdeeSScott Long 		   MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context)
645b0a2fdeeSScott Long {
646b0a2fdeeSScott Long 	MSG_EVENT_ACK *ackp;
647b0a2fdeeSScott Long 
648b0a2fdeeSScott Long 	ackp = (MSG_EVENT_ACK *)ack_req->req_vbuf;
6495e073106SMatt Jacob 	memset(ackp, 0, sizeof (*ackp));
650b0a2fdeeSScott Long 	ackp->Function = MPI_FUNCTION_EVENT_ACK;
651b0a2fdeeSScott Long 	ackp->Event = msg->Event;
652b0a2fdeeSScott Long 	ackp->EventContext = msg->EventContext;
653b0a2fdeeSScott Long 	ackp->MsgContext = context;
654b0a2fdeeSScott Long 	mpt_check_doorbell(mpt);
655b0a2fdeeSScott Long 	mpt_send_cmd(mpt, ack_req);
656b0a2fdeeSScott Long }
657b0a2fdeeSScott Long 
658b0a2fdeeSScott Long /***************************** Interrupt Handling *****************************/
659b0a2fdeeSScott Long void
660b0a2fdeeSScott Long mpt_intr(void *arg)
661b0a2fdeeSScott Long {
662b0a2fdeeSScott Long 	struct mpt_softc *mpt;
663b0a2fdeeSScott Long 	uint32_t reply_desc;
664c87e3f83SMatt Jacob 	int ntrips = 0;
665b0a2fdeeSScott Long 
666b0a2fdeeSScott Long 	mpt = (struct mpt_softc *)arg;
6675089bd63SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG2, "enter mpt_intr\n");
668b0a2fdeeSScott Long 	while ((reply_desc = mpt_pop_reply_queue(mpt)) != MPT_REPLY_EMPTY) {
669b0a2fdeeSScott Long 		request_t	  *req;
670b0a2fdeeSScott Long 		MSG_DEFAULT_REPLY *reply_frame;
671b0a2fdeeSScott Long 		uint32_t	   reply_baddr;
672c87e3f83SMatt Jacob 		uint32_t           ctxt_idx;
673b0a2fdeeSScott Long 		u_int		   cb_index;
674b0a2fdeeSScott Long 		u_int		   req_index;
675b0a2fdeeSScott Long 		int		   free_rf;
676b0a2fdeeSScott Long 
677b0a2fdeeSScott Long 		req = NULL;
678b0a2fdeeSScott Long 		reply_frame = NULL;
679b0a2fdeeSScott Long 		reply_baddr = 0;
680b0a2fdeeSScott Long 		if ((reply_desc & MPI_ADDRESS_REPLY_A_BIT) != 0) {
681b0a2fdeeSScott Long 			u_int offset;
682b0a2fdeeSScott Long 			/*
683b0a2fdeeSScott Long 			 * Insure that the reply frame is coherent.
684b0a2fdeeSScott Long 			 */
6855e073106SMatt Jacob 			reply_baddr = MPT_REPLY_BADDR(reply_desc);
686b0a2fdeeSScott Long 			offset = reply_baddr - (mpt->reply_phys & 0xFFFFFFFF);
687c87e3f83SMatt Jacob 			bus_dmamap_sync_range(mpt->reply_dmat,
688c87e3f83SMatt Jacob 			    mpt->reply_dmap, offset, MPT_REPLY_SIZE,
689b0a2fdeeSScott Long 			    BUS_DMASYNC_POSTREAD);
690b0a2fdeeSScott Long 			reply_frame = MPT_REPLY_OTOV(mpt, offset);
691c87e3f83SMatt Jacob 			ctxt_idx = le32toh(reply_frame->MsgContext);
692c87e3f83SMatt Jacob 		} else {
693c87e3f83SMatt Jacob 			uint32_t type;
694b0a2fdeeSScott Long 
695c87e3f83SMatt Jacob 			type = MPI_GET_CONTEXT_REPLY_TYPE(reply_desc);
696c87e3f83SMatt Jacob 			ctxt_idx = reply_desc;
697c87e3f83SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_DEBUG1, "Context Reply: 0x%08x\n",
698c87e3f83SMatt Jacob 				    reply_desc);
699c87e3f83SMatt Jacob 
700c87e3f83SMatt Jacob 			switch (type) {
701c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
702c87e3f83SMatt Jacob 				ctxt_idx &= MPI_CONTEXT_REPLY_CONTEXT_MASK;
703c87e3f83SMatt Jacob 				break;
704c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
705c87e3f83SMatt Jacob 				ctxt_idx = GET_IO_INDEX(reply_desc);
706c87e3f83SMatt Jacob 				if (mpt->tgt_cmd_ptrs == NULL) {
707c87e3f83SMatt Jacob 					mpt_prt(mpt,
708c87e3f83SMatt Jacob 					    "mpt_intr: no target cmd ptrs\n");
709c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
710c87e3f83SMatt Jacob 					break;
711c87e3f83SMatt Jacob 				}
712c87e3f83SMatt Jacob 				if (ctxt_idx >= mpt->tgt_cmds_allocated) {
713c87e3f83SMatt Jacob 					mpt_prt(mpt,
714c87e3f83SMatt Jacob 					    "mpt_intr: bad tgt cmd ctxt %u\n",
715c87e3f83SMatt Jacob 					    ctxt_idx);
716c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
717c87e3f83SMatt Jacob 					ntrips = 1000;
718c87e3f83SMatt Jacob 					break;
719c87e3f83SMatt Jacob 				}
720c87e3f83SMatt Jacob 				req = mpt->tgt_cmd_ptrs[ctxt_idx];
721c87e3f83SMatt Jacob 				if (req == NULL) {
722c87e3f83SMatt Jacob 					mpt_prt(mpt, "no request backpointer "
723c87e3f83SMatt Jacob 					    "at index %u", ctxt_idx);
724c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
725c87e3f83SMatt Jacob 					ntrips = 1000;
726c87e3f83SMatt Jacob 					break;
727c87e3f83SMatt Jacob 				}
728c87e3f83SMatt Jacob 				/*
729c87e3f83SMatt Jacob 				 * Reformulate ctxt_idx to be just as if
730c87e3f83SMatt Jacob 				 * it were another type of context reply
731c87e3f83SMatt Jacob 				 * so the code below will find the request
732c87e3f83SMatt Jacob 				 * via indexing into the pool.
733c87e3f83SMatt Jacob 				 */
734c87e3f83SMatt Jacob 				ctxt_idx =
735c87e3f83SMatt Jacob 				    req->index | mpt->scsi_tgt_handler_id;
736c87e3f83SMatt Jacob 				req = NULL;
737c87e3f83SMatt Jacob 				break;
738c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_LAN:
739c87e3f83SMatt Jacob 				mpt_prt(mpt, "LAN CONTEXT REPLY: 0x%08x\n",
740c87e3f83SMatt Jacob 				    reply_desc);
741c87e3f83SMatt Jacob 				reply_desc = MPT_REPLY_EMPTY;
742c87e3f83SMatt Jacob 				break;
743c87e3f83SMatt Jacob 			default:
744c87e3f83SMatt Jacob 				mpt_prt(mpt, "Context Reply 0x%08x?\n", type);
745c87e3f83SMatt Jacob 				reply_desc = MPT_REPLY_EMPTY;
746c87e3f83SMatt Jacob 				break;
747c87e3f83SMatt Jacob 			}
748c87e3f83SMatt Jacob 			if (reply_desc == MPT_REPLY_EMPTY) {
749c87e3f83SMatt Jacob 				if (ntrips++ > 1000) {
750c87e3f83SMatt Jacob 					break;
751c87e3f83SMatt Jacob 				}
752c87e3f83SMatt Jacob 				continue;
753c87e3f83SMatt Jacob 			}
754c87e3f83SMatt Jacob 		}
755c87e3f83SMatt Jacob 
756c87e3f83SMatt Jacob 		cb_index = MPT_CONTEXT_TO_CBI(ctxt_idx);
757c87e3f83SMatt Jacob 		req_index = MPT_CONTEXT_TO_REQI(ctxt_idx);
758c87e3f83SMatt Jacob 		if (req_index < MPT_MAX_REQUESTS(mpt)) {
759c87e3f83SMatt Jacob 			req = &mpt->request_pool[req_index];
7605e073106SMatt Jacob 		} else {
7615e073106SMatt Jacob 			mpt_prt(mpt, "WARN: mpt_intr index == %d (reply_desc =="
7625e073106SMatt Jacob 			    " 0x%x)\n", req_index, reply_desc);
763c87e3f83SMatt Jacob 		}
764c87e3f83SMatt Jacob 
765c87e3f83SMatt Jacob 		free_rf = mpt_reply_handlers[cb_index](mpt, req,
766c87e3f83SMatt Jacob 		    reply_desc, reply_frame);
767b0a2fdeeSScott Long 
7685e073106SMatt Jacob 		if (reply_frame != NULL && free_rf) {
769b0a2fdeeSScott Long 			mpt_free_reply(mpt, reply_baddr);
7705e073106SMatt Jacob 		}
771c87e3f83SMatt Jacob 
772c87e3f83SMatt Jacob 		/*
773c87e3f83SMatt Jacob 		 * If we got ourselves disabled, don't get stuck in a loop
774c87e3f83SMatt Jacob 		 */
775c87e3f83SMatt Jacob 		if (mpt->disabled) {
776c87e3f83SMatt Jacob 			mpt_disable_ints(mpt);
777c87e3f83SMatt Jacob 			break;
778c87e3f83SMatt Jacob 		}
779c87e3f83SMatt Jacob 		if (ntrips++ > 1000) {
780c87e3f83SMatt Jacob 			break;
781c87e3f83SMatt Jacob 		}
782b0a2fdeeSScott Long 	}
7835089bd63SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG2, "exit mpt_intr\n");
784b0a2fdeeSScott Long }
785b0a2fdeeSScott Long 
786b0a2fdeeSScott Long /******************************* Error Recovery *******************************/
787b0a2fdeeSScott Long void
788b0a2fdeeSScott Long mpt_complete_request_chain(struct mpt_softc *mpt, struct req_queue *chain,
789b0a2fdeeSScott Long 			    u_int iocstatus)
790b0a2fdeeSScott Long {
791b0a2fdeeSScott Long 	MSG_DEFAULT_REPLY  ioc_status_frame;
792b0a2fdeeSScott Long 	request_t	  *req;
793b0a2fdeeSScott Long 
7945e073106SMatt Jacob 	memset(&ioc_status_frame, 0, sizeof(ioc_status_frame));
795b0a2fdeeSScott Long 	ioc_status_frame.MsgLength = roundup2(sizeof(ioc_status_frame), 4);
796b0a2fdeeSScott Long 	ioc_status_frame.IOCStatus = iocstatus;
797b0a2fdeeSScott Long 	while((req = TAILQ_FIRST(chain)) != NULL) {
798b0a2fdeeSScott Long 		MSG_REQUEST_HEADER *msg_hdr;
799b0a2fdeeSScott Long 		u_int		    cb_index;
8005e073106SMatt Jacob 
8019b7de735SMatt Jacob 		TAILQ_REMOVE(chain, req, links);
802b0a2fdeeSScott Long 		msg_hdr = (MSG_REQUEST_HEADER *)req->req_vbuf;
803b0a2fdeeSScott Long 		ioc_status_frame.Function = msg_hdr->Function;
804b0a2fdeeSScott Long 		ioc_status_frame.MsgContext = msg_hdr->MsgContext;
805b0a2fdeeSScott Long 		cb_index = MPT_CONTEXT_TO_CBI(le32toh(msg_hdr->MsgContext));
806c87e3f83SMatt Jacob 		mpt_reply_handlers[cb_index](mpt, req, msg_hdr->MsgContext,
807c87e3f83SMatt Jacob 		    &ioc_status_frame);
808b0a2fdeeSScott Long 	}
809b0a2fdeeSScott Long }
810b0a2fdeeSScott Long 
811b0a2fdeeSScott Long /********************************* Diagnostics ********************************/
812b0a2fdeeSScott Long /*
813b0a2fdeeSScott Long  * Perform a diagnostic dump of a reply frame.
814b0a2fdeeSScott Long  */
815b0a2fdeeSScott Long void
816b0a2fdeeSScott Long mpt_dump_reply_frame(struct mpt_softc *mpt, MSG_DEFAULT_REPLY *reply_frame)
817b0a2fdeeSScott Long {
818b0a2fdeeSScott Long 	mpt_prt(mpt, "Address Reply:\n");
819b0a2fdeeSScott Long 	mpt_print_reply(reply_frame);
820b0a2fdeeSScott Long }
821b0a2fdeeSScott Long 
822b0a2fdeeSScott Long /******************************* Doorbell Access ******************************/
823b0a2fdeeSScott Long static __inline uint32_t mpt_rd_db(struct mpt_softc *mpt);
824b0a2fdeeSScott Long static __inline  uint32_t mpt_rd_intr(struct mpt_softc *mpt);
825b0a2fdeeSScott Long 
826b0a2fdeeSScott Long static __inline uint32_t
827b0a2fdeeSScott Long mpt_rd_db(struct mpt_softc *mpt)
8289b631363SMatt Jacob {
8299b631363SMatt Jacob 	return mpt_read(mpt, MPT_OFFSET_DOORBELL);
8309b631363SMatt Jacob }
8319b631363SMatt Jacob 
832b0a2fdeeSScott Long static __inline uint32_t
833b0a2fdeeSScott Long mpt_rd_intr(struct mpt_softc *mpt)
8349b631363SMatt Jacob {
8359b631363SMatt Jacob 	return mpt_read(mpt, MPT_OFFSET_INTR_STATUS);
8369b631363SMatt Jacob }
8379b631363SMatt Jacob 
8389b631363SMatt Jacob /* Busy wait for a door bell to be read by IOC */
8399b631363SMatt Jacob static int
840b0a2fdeeSScott Long mpt_wait_db_ack(struct mpt_softc *mpt)
8419b631363SMatt Jacob {
8429b631363SMatt Jacob 	int i;
8439b631363SMatt Jacob 	for (i=0; i < MPT_MAX_WAIT; i++) {
8449b631363SMatt Jacob 		if (!MPT_DB_IS_BUSY(mpt_rd_intr(mpt))) {
8459b631363SMatt Jacob 			maxwait_ack = i > maxwait_ack ? i : maxwait_ack;
846c87e3f83SMatt Jacob 			return (MPT_OK);
8479b631363SMatt Jacob 		}
848c87e3f83SMatt Jacob 		DELAY(200);
8499b631363SMatt Jacob 	}
850c87e3f83SMatt Jacob 	return (MPT_FAIL);
8519b631363SMatt Jacob }
8529b631363SMatt Jacob 
8539b631363SMatt Jacob /* Busy wait for a door bell interrupt */
8549b631363SMatt Jacob static int
855b0a2fdeeSScott Long mpt_wait_db_int(struct mpt_softc *mpt)
8569b631363SMatt Jacob {
8579b631363SMatt Jacob 	int i;
8589b631363SMatt Jacob 	for (i=0; i < MPT_MAX_WAIT; i++) {
8599b631363SMatt Jacob 		if (MPT_DB_INTR(mpt_rd_intr(mpt))) {
8609b631363SMatt Jacob 			maxwait_int = i > maxwait_int ? i : maxwait_int;
8619b631363SMatt Jacob 			return MPT_OK;
8629b631363SMatt Jacob 		}
8639b631363SMatt Jacob 		DELAY(100);
8649b631363SMatt Jacob 	}
865c87e3f83SMatt Jacob 	return (MPT_FAIL);
8669b631363SMatt Jacob }
8679b631363SMatt Jacob 
8689b631363SMatt Jacob /* Wait for IOC to transition to a give state */
8699b631363SMatt Jacob void
870b0a2fdeeSScott Long mpt_check_doorbell(struct mpt_softc *mpt)
8719b631363SMatt Jacob {
872b0a2fdeeSScott Long 	uint32_t db = mpt_rd_db(mpt);
8739b631363SMatt Jacob 	if (MPT_STATE(db) != MPT_DB_STATE_RUNNING) {
874b0a2fdeeSScott Long 		mpt_prt(mpt, "Device not running\n");
8759b631363SMatt Jacob 		mpt_print_db(db);
8769b631363SMatt Jacob 	}
8779b631363SMatt Jacob }
8789b631363SMatt Jacob 
8799b631363SMatt Jacob /* Wait for IOC to transition to a give state */
8809b631363SMatt Jacob static int
881b0a2fdeeSScott Long mpt_wait_state(struct mpt_softc *mpt, enum DB_STATE_BITS state)
8829b631363SMatt Jacob {
8839b631363SMatt Jacob 	int i;
8849b631363SMatt Jacob 
8859b631363SMatt Jacob 	for (i = 0; i < MPT_MAX_WAIT; i++) {
886b0a2fdeeSScott Long 		uint32_t db = mpt_rd_db(mpt);
8879b631363SMatt Jacob 		if (MPT_STATE(db) == state) {
8889b631363SMatt Jacob 			maxwait_state = i > maxwait_state ? i : maxwait_state;
8899b631363SMatt Jacob 			return (MPT_OK);
8909b631363SMatt Jacob 		}
8919b631363SMatt Jacob 		DELAY(100);
8929b631363SMatt Jacob 	}
8939b631363SMatt Jacob 	return (MPT_FAIL);
8949b631363SMatt Jacob }
8959b631363SMatt Jacob 
8969b631363SMatt Jacob 
897b0a2fdeeSScott Long /************************* Intialization/Configuration ************************/
898b0a2fdeeSScott Long static int mpt_download_fw(struct mpt_softc *mpt);
899b0a2fdeeSScott Long 
9009b631363SMatt Jacob /* Issue the reset COMMAND to the IOC */
901b0a2fdeeSScott Long static int
902b0a2fdeeSScott Long mpt_soft_reset(struct mpt_softc *mpt)
9039b631363SMatt Jacob {
904b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "soft reset\n");
9059b631363SMatt Jacob 
9069b631363SMatt Jacob 	/* Have to use hard reset if we are not in Running state */
9079b631363SMatt Jacob 	if (MPT_STATE(mpt_rd_db(mpt)) != MPT_DB_STATE_RUNNING) {
908b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: device not running\n");
909c87e3f83SMatt Jacob 		return (MPT_FAIL);
9109b631363SMatt Jacob 	}
9119b631363SMatt Jacob 
9129b631363SMatt Jacob 	/* If door bell is in use we don't have a chance of getting
9139b631363SMatt Jacob 	 * a word in since the IOC probably crashed in message
9149b631363SMatt Jacob 	 * processing. So don't waste our time.
9159b631363SMatt Jacob 	 */
9169b631363SMatt Jacob 	if (MPT_DB_IS_IN_USE(mpt_rd_db(mpt))) {
917b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: doorbell wedged\n");
918c87e3f83SMatt Jacob 		return (MPT_FAIL);
9199b631363SMatt Jacob 	}
9209b631363SMatt Jacob 
9219b631363SMatt Jacob 	/* Send the reset request to the IOC */
9229b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_DOORBELL,
9239b631363SMatt Jacob 	    MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET << MPI_DOORBELL_FUNCTION_SHIFT);
9249b631363SMatt Jacob 	if (mpt_wait_db_ack(mpt) != MPT_OK) {
925b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: ack timeout\n");
926c87e3f83SMatt Jacob 		return (MPT_FAIL);
9279b631363SMatt Jacob 	}
9289b631363SMatt Jacob 
9299b631363SMatt Jacob 	/* Wait for the IOC to reload and come out of reset state */
9309b631363SMatt Jacob 	if (mpt_wait_state(mpt, MPT_DB_STATE_READY) != MPT_OK) {
931b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: device did not restart\n");
932c87e3f83SMatt Jacob 		return (MPT_FAIL);
9339b631363SMatt Jacob 	}
9349b631363SMatt Jacob 
9359b631363SMatt Jacob 	return MPT_OK;
9369b631363SMatt Jacob }
9379b631363SMatt Jacob 
938b0a2fdeeSScott Long static int
939b0a2fdeeSScott Long mpt_enable_diag_mode(struct mpt_softc *mpt)
940b0a2fdeeSScott Long {
941b0a2fdeeSScott Long 	int try;
942b0a2fdeeSScott Long 
943b0a2fdeeSScott Long 	try = 20;
944b0a2fdeeSScott Long 	while (--try) {
945b0a2fdeeSScott Long 
946b0a2fdeeSScott Long 		if ((mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC) & MPI_DIAG_DRWE) != 0)
947b0a2fdeeSScott Long 			break;
948b0a2fdeeSScott Long 
949b0a2fdeeSScott Long 		/* Enable diagnostic registers */
950b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFF);
951b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_1ST_KEY_VALUE);
952b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_2ND_KEY_VALUE);
953b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_3RD_KEY_VALUE);
954b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_4TH_KEY_VALUE);
955b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_5TH_KEY_VALUE);
956b0a2fdeeSScott Long 
957b0a2fdeeSScott Long 		DELAY(100000);
958b0a2fdeeSScott Long 	}
959b0a2fdeeSScott Long 	if (try == 0)
960b0a2fdeeSScott Long 		return (EIO);
961b0a2fdeeSScott Long 	return (0);
962b0a2fdeeSScott Long }
963b0a2fdeeSScott Long 
964b0a2fdeeSScott Long static void
965b0a2fdeeSScott Long mpt_disable_diag_mode(struct mpt_softc *mpt)
966b0a2fdeeSScott Long {
967b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFFFFFFFF);
968b0a2fdeeSScott Long }
969b0a2fdeeSScott Long 
9709b631363SMatt Jacob /* This is a magic diagnostic reset that resets all the ARM
9719b631363SMatt Jacob  * processors in the chip.
9729b631363SMatt Jacob  */
973b0a2fdeeSScott Long static void
974b0a2fdeeSScott Long mpt_hard_reset(struct mpt_softc *mpt)
9759b631363SMatt Jacob {
976b0a2fdeeSScott Long 	int error;
977b0a2fdeeSScott Long 	int wait;
978b0a2fdeeSScott Long 	uint32_t diagreg;
9799b631363SMatt Jacob 
980b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "hard reset\n");
981b0a2fdeeSScott Long 
982b0a2fdeeSScott Long 	error = mpt_enable_diag_mode(mpt);
983b0a2fdeeSScott Long 	if (error) {
984b0a2fdeeSScott Long 		mpt_prt(mpt, "WARNING - Could not enter diagnostic mode !\n");
985b0a2fdeeSScott Long 		mpt_prt(mpt, "Trying to reset anyway.\n");
986b0a2fdeeSScott Long 	}
987b0a2fdeeSScott Long 
988b0a2fdeeSScott Long 	diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
989b0a2fdeeSScott Long 
990b0a2fdeeSScott Long 	/*
991b0a2fdeeSScott Long 	 * This appears to be a workaround required for some
992b0a2fdeeSScott Long 	 * firmware or hardware revs.
993b0a2fdeeSScott Long 	 */
994b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_DISABLE_ARM);
995b0a2fdeeSScott Long 	DELAY(1000);
9969b631363SMatt Jacob 
9979b631363SMatt Jacob 	/* Diag. port is now active so we can now hit the reset bit */
998b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_RESET_ADAPTER);
9999b631363SMatt Jacob 
1000b0a2fdeeSScott Long         /*
1001b0a2fdeeSScott Long          * Ensure that the reset has finished.  We delay 1ms
1002b0a2fdeeSScott Long          * prior to reading the register to make sure the chip
1003b0a2fdeeSScott Long          * has sufficiently completed its reset to handle register
1004b0a2fdeeSScott Long          * accesses.
1005b0a2fdeeSScott Long          */
1006b0a2fdeeSScott Long 	wait = 5000;
1007b0a2fdeeSScott Long 	do {
1008b0a2fdeeSScott Long 		DELAY(1000);
1009b0a2fdeeSScott Long 		diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
1010b0a2fdeeSScott Long 	} while (--wait && (diagreg & MPI_DIAG_RESET_ADAPTER) == 0);
10119b631363SMatt Jacob 
1012b0a2fdeeSScott Long 	if (wait == 0) {
1013b0a2fdeeSScott Long 		mpt_prt(mpt, "WARNING - Failed hard reset! "
1014b0a2fdeeSScott Long 			"Trying to initialize anyway.\n");
10159b631363SMatt Jacob 	}
10169b631363SMatt Jacob 
1017b0a2fdeeSScott Long 	/*
1018b0a2fdeeSScott Long 	 * If we have firmware to download, it must be loaded before
1019b0a2fdeeSScott Long 	 * the controller will become operational.  Do so now.
1020b0a2fdeeSScott Long 	 */
1021b0a2fdeeSScott Long 	if (mpt->fw_image != NULL) {
1022b0a2fdeeSScott Long 
1023b0a2fdeeSScott Long 		error = mpt_download_fw(mpt);
1024b0a2fdeeSScott Long 
1025b0a2fdeeSScott Long 		if (error) {
1026b0a2fdeeSScott Long 			mpt_prt(mpt, "WARNING - Firmware Download Failed!\n");
1027b0a2fdeeSScott Long 			mpt_prt(mpt, "Trying to initialize anyway.\n");
10289b631363SMatt Jacob 		}
1029b0a2fdeeSScott Long 	}
1030b0a2fdeeSScott Long 
1031b0a2fdeeSScott Long 	/*
1032b0a2fdeeSScott Long 	 * Reseting the controller should have disabled write
1033b0a2fdeeSScott Long 	 * access to the diagnostic registers, but disable
1034b0a2fdeeSScott Long 	 * manually to be sure.
1035b0a2fdeeSScott Long 	 */
1036b0a2fdeeSScott Long 	mpt_disable_diag_mode(mpt);
1037b0a2fdeeSScott Long }
1038b0a2fdeeSScott Long 
1039b0a2fdeeSScott Long static void
1040b0a2fdeeSScott Long mpt_core_ioc_reset(struct mpt_softc *mpt, int type)
1041b0a2fdeeSScott Long {
1042b0a2fdeeSScott Long 	/*
1043b0a2fdeeSScott Long 	 * Complete all pending requests with a status
1044b0a2fdeeSScott Long 	 * appropriate for an IOC reset.
1045b0a2fdeeSScott Long 	 */
1046b0a2fdeeSScott Long 	mpt_complete_request_chain(mpt, &mpt->request_pending_list,
1047b0a2fdeeSScott Long 				   MPI_IOCSTATUS_INVALID_STATE);
1048b0a2fdeeSScott Long }
1049b0a2fdeeSScott Long 
10509b631363SMatt Jacob 
10519b631363SMatt Jacob /*
10529b631363SMatt Jacob  * Reset the IOC when needed. Try software command first then if needed
10539b631363SMatt Jacob  * poke at the magic diagnostic reset. Note that a hard reset resets
10549b631363SMatt Jacob  * *both* IOCs on dual function chips (FC929 && LSI1030) as well as
10559b631363SMatt Jacob  * fouls up the PCI configuration registers.
10569b631363SMatt Jacob  */
10579b631363SMatt Jacob int
1058b0a2fdeeSScott Long mpt_reset(struct mpt_softc *mpt, int reinit)
10599b631363SMatt Jacob {
1060b0a2fdeeSScott Long 	struct	mpt_personality *pers;
10619b631363SMatt Jacob 	int	ret;
106229ae59edSMatt Jacob 	int	retry_cnt = 0;
10639b631363SMatt Jacob 
106429ae59edSMatt Jacob 	/*
106529ae59edSMatt Jacob 	 * Try a soft reset. If that fails, get out the big hammer.
106629ae59edSMatt Jacob 	 */
106729ae59edSMatt Jacob  again:
10689b631363SMatt Jacob 	if ((ret = mpt_soft_reset(mpt)) != MPT_OK) {
106929ae59edSMatt Jacob 		int	cnt;
107029ae59edSMatt Jacob 		for (cnt = 0; cnt < 5; cnt++) {
10719b631363SMatt Jacob 			/* Failed; do a hard reset */
10729b631363SMatt Jacob 			mpt_hard_reset(mpt);
10739b631363SMatt Jacob 
107429ae59edSMatt Jacob 			/*
107529ae59edSMatt Jacob 			 * Wait for the IOC to reload
107629ae59edSMatt Jacob 			 * and come out of reset state
107729ae59edSMatt Jacob 			 */
10789b631363SMatt Jacob 			ret = mpt_wait_state(mpt, MPT_DB_STATE_READY);
107929ae59edSMatt Jacob 			if (ret == MPT_OK) {
108029ae59edSMatt Jacob 				break;
108129ae59edSMatt Jacob 			}
108229ae59edSMatt Jacob 			/*
108329ae59edSMatt Jacob 			 * Okay- try to check again...
108429ae59edSMatt Jacob 			 */
108529ae59edSMatt Jacob 			ret = mpt_wait_state(mpt, MPT_DB_STATE_READY);
108629ae59edSMatt Jacob 			if (ret == MPT_OK) {
108729ae59edSMatt Jacob 				break;
108829ae59edSMatt Jacob 			}
108929ae59edSMatt Jacob 			mpt_prt(mpt, "mpt_reset: failed hard reset (%d:%d)\n",
109029ae59edSMatt Jacob 			    retry_cnt, cnt);
109129ae59edSMatt Jacob 		}
10929b631363SMatt Jacob 	}
1093b0a2fdeeSScott Long 
109429ae59edSMatt Jacob 	if (retry_cnt == 0) {
1095b0a2fdeeSScott Long 		/*
1096b0a2fdeeSScott Long 		 * Invoke reset handlers.  We bump the reset count so
1097b0a2fdeeSScott Long 		 * that mpt_wait_req() understands that regardless of
1098b0a2fdeeSScott Long 		 * the specified wait condition, it should stop its wait.
1099b0a2fdeeSScott Long 		 */
1100b0a2fdeeSScott Long 		mpt->reset_cnt++;
1101b0a2fdeeSScott Long 		MPT_PERS_FOREACH(mpt, pers)
1102b0a2fdeeSScott Long 			pers->reset(mpt, ret);
110329ae59edSMatt Jacob 	}
1104b0a2fdeeSScott Long 
11055e073106SMatt Jacob 	if (reinit) {
1106c87e3f83SMatt Jacob 		ret = mpt_enable_ioc(mpt, 1);
110729ae59edSMatt Jacob 		if (ret == MPT_OK) {
110829ae59edSMatt Jacob 			mpt_enable_ints(mpt);
110929ae59edSMatt Jacob 		}
111029ae59edSMatt Jacob 	}
111129ae59edSMatt Jacob 	if (ret != MPT_OK && retry_cnt++ < 2) {
111229ae59edSMatt Jacob 		goto again;
111329ae59edSMatt Jacob 	}
11149b631363SMatt Jacob 	return ret;
11159b631363SMatt Jacob }
11169b631363SMatt Jacob 
11179b631363SMatt Jacob /* Return a command buffer to the free queue */
11189b631363SMatt Jacob void
1119b0a2fdeeSScott Long mpt_free_request(struct mpt_softc *mpt, request_t *req)
11209b631363SMatt Jacob {
1121444dd2b6SMatt Jacob 	request_t *nxt;
1122b0a2fdeeSScott Long 	struct mpt_evtf_record *record;
1123b0a2fdeeSScott Long 	uint32_t reply_baddr;
1124b0a2fdeeSScott Long 
11257dec90bcSMatt Jacob 	if (req == NULL || req != &mpt->request_pool[req->index]) {
11269b631363SMatt Jacob 		panic("mpt_free_request bad req ptr\n");
11279b631363SMatt Jacob 		return;
11289b631363SMatt Jacob 	}
1129444dd2b6SMatt Jacob 	if ((nxt = req->chain) != NULL) {
1130444dd2b6SMatt Jacob 		req->chain = NULL;
1131444dd2b6SMatt Jacob 		mpt_free_request(mpt, nxt);	/* NB: recursion */
1132444dd2b6SMatt Jacob 	}
11335e073106SMatt Jacob 	KASSERT(req->state != REQ_STATE_FREE, ("freeing free request"));
11345e073106SMatt Jacob 	KASSERT(!(req->state & REQ_STATE_LOCKED), ("freeing locked request"));
11355089bd63SMatt Jacob 	KASSERT(MPT_OWNED(mpt), ("mpt_free_request: mpt not locked\n"));
11365089bd63SMatt Jacob 	KASSERT(mpt_req_on_free_list(mpt, req) == 0,
11375089bd63SMatt Jacob 	    ("mpt_free_request: req %p:%u func %x already on freelist",
11385089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
11395089bd63SMatt Jacob 	KASSERT(mpt_req_on_pending_list(mpt, req) == 0,
11405089bd63SMatt Jacob 	    ("mpt_free_request: req %p:%u func %x on pending list",
11415089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
11425089bd63SMatt Jacob #ifdef	INVARIANTS
11435089bd63SMatt Jacob 	mpt_req_not_spcl(mpt, req, "mpt_free_request", __LINE__);
11445089bd63SMatt Jacob #endif
11455e073106SMatt Jacob 
11469b631363SMatt Jacob 	req->ccb = NULL;
1147b0a2fdeeSScott Long 	if (LIST_EMPTY(&mpt->ack_frames)) {
1148c87e3f83SMatt Jacob 		/*
1149c87e3f83SMatt Jacob 		 * Insert free ones at the tail
1150c87e3f83SMatt Jacob 		 */
11515e073106SMatt Jacob 		req->serno = 0;
11525e073106SMatt Jacob 		req->state = REQ_STATE_FREE;
11535089bd63SMatt Jacob #ifdef	INVARIANTS
11545089bd63SMatt Jacob 		memset(req->req_vbuf, 0xff, sizeof (MSG_REQUEST_HEADER));
11555089bd63SMatt Jacob #endif
1156c87e3f83SMatt Jacob 		TAILQ_INSERT_TAIL(&mpt->request_free_list, req, links);
1157b0a2fdeeSScott Long 		if (mpt->getreqwaiter != 0) {
1158b0a2fdeeSScott Long 			mpt->getreqwaiter = 0;
1159b0a2fdeeSScott Long 			wakeup(&mpt->request_free_list);
1160b0a2fdeeSScott Long 		}
1161b0a2fdeeSScott Long 		return;
1162b0a2fdeeSScott Long 	}
1163b0a2fdeeSScott Long 
1164b0a2fdeeSScott Long 	/*
1165b0a2fdeeSScott Long 	 * Process an ack frame deferred due to resource shortage.
1166b0a2fdeeSScott Long 	 */
1167b0a2fdeeSScott Long 	record = LIST_FIRST(&mpt->ack_frames);
1168b0a2fdeeSScott Long 	LIST_REMOVE(record, links);
11695e073106SMatt Jacob 	req->state = REQ_STATE_ALLOCATED;
11705089bd63SMatt Jacob 	mpt_assign_serno(mpt, req);
1171b0a2fdeeSScott Long 	mpt_send_event_ack(mpt, req, &record->reply, record->context);
1172b0a2fdeeSScott Long 	reply_baddr = (uint32_t)((uint8_t *)record - mpt->reply)
1173b0a2fdeeSScott Long 		    + (mpt->reply_phys & 0xFFFFFFFF);
1174b0a2fdeeSScott Long 	mpt_free_reply(mpt, reply_baddr);
11759b631363SMatt Jacob }
11769b631363SMatt Jacob 
11779b631363SMatt Jacob /* Get a command buffer from the free queue */
11789b631363SMatt Jacob request_t *
1179b0a2fdeeSScott Long mpt_get_request(struct mpt_softc *mpt, int sleep_ok)
11809b631363SMatt Jacob {
11819b631363SMatt Jacob 	request_t *req;
1182b0a2fdeeSScott Long 
1183b0a2fdeeSScott Long retry:
11845089bd63SMatt Jacob 	KASSERT(MPT_OWNED(mpt), ("mpt_get_request: mpt not locked\n"));
1185b0a2fdeeSScott Long 	req = TAILQ_FIRST(&mpt->request_free_list);
11869b631363SMatt Jacob 	if (req != NULL) {
1187b0a2fdeeSScott Long 		KASSERT(req == &mpt->request_pool[req->index],
1188b0a2fdeeSScott Long 		    ("mpt_get_request: corrupted request free list\n"));
11895e073106SMatt Jacob 		KASSERT(req->state == REQ_STATE_FREE,
11905089bd63SMatt Jacob 		    ("req %p:%u not free on free list %x index %d function %x",
11915089bd63SMatt Jacob 		    req, req->serno, req->state, req->index,
11925089bd63SMatt Jacob 		    ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
1193b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_free_list, req, links);
1194b0a2fdeeSScott Long 		req->state = REQ_STATE_ALLOCATED;
1195444dd2b6SMatt Jacob 		req->chain = NULL;
11965089bd63SMatt Jacob 		mpt_assign_serno(mpt, req);
1197b0a2fdeeSScott Long 	} else if (sleep_ok != 0) {
1198b0a2fdeeSScott Long 		mpt->getreqwaiter = 1;
1199b0a2fdeeSScott Long 		mpt_sleep(mpt, &mpt->request_free_list, PUSER, "mptgreq", 0);
1200b0a2fdeeSScott Long 		goto retry;
12019b631363SMatt Jacob 	}
12025e073106SMatt Jacob 	return (req);
12039b631363SMatt Jacob }
12049b631363SMatt Jacob 
12059b631363SMatt Jacob /* Pass the command to the IOC */
12069b631363SMatt Jacob void
1207b0a2fdeeSScott Long mpt_send_cmd(struct mpt_softc *mpt, request_t *req)
12089b631363SMatt Jacob {
12091d79ca0eSMatt Jacob 	if (mpt->verbose > MPT_PRT_DEBUG2) {
12101043516dSMatt Jacob 		mpt_dump_request(mpt, req);
1211444dd2b6SMatt Jacob 	}
12129b631363SMatt Jacob 	bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
12139b631363SMatt Jacob 	    BUS_DMASYNC_PREWRITE);
1214b0a2fdeeSScott Long 	req->state |= REQ_STATE_QUEUED;
12155089bd63SMatt Jacob 	KASSERT(mpt_req_on_free_list(mpt, req) == 0,
12165089bd63SMatt Jacob 	    ("req %p:%u func %x on freelist list in mpt_send_cmd",
12175089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
12185089bd63SMatt Jacob 	KASSERT(mpt_req_on_pending_list(mpt, req) == 0,
12195089bd63SMatt Jacob 	    ("req %p:%u func %x already on pending list in mpt_send_cmd",
12205089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
1221b0a2fdeeSScott Long 	TAILQ_INSERT_HEAD(&mpt->request_pending_list, req, links);
1222b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_REQUEST_Q, (uint32_t) req->req_pbuf);
12239b631363SMatt Jacob }
12249b631363SMatt Jacob 
12259b631363SMatt Jacob /*
1226b0a2fdeeSScott Long  * Wait for a request to complete.
1227b0a2fdeeSScott Long  *
1228b0a2fdeeSScott Long  * Inputs:
1229b0a2fdeeSScott Long  *	mpt		softc of controller executing request
1230b0a2fdeeSScott Long  *	req		request to wait for
1231b0a2fdeeSScott Long  *	sleep_ok	nonzero implies may sleep in this context
1232b0a2fdeeSScott Long  *	time_ms		timeout in ms.  0 implies no timeout.
1233b0a2fdeeSScott Long  *
1234b0a2fdeeSScott Long  * Return Values:
1235b0a2fdeeSScott Long  *	0		Request completed
1236b0a2fdeeSScott Long  *	non-0		Timeout fired before request completion.
12379b631363SMatt Jacob  */
1238b0a2fdeeSScott Long int
1239b0a2fdeeSScott Long mpt_wait_req(struct mpt_softc *mpt, request_t *req,
1240b0a2fdeeSScott Long 	     mpt_req_state_t state, mpt_req_state_t mask,
1241b0a2fdeeSScott Long 	     int sleep_ok, int time_ms)
12429b631363SMatt Jacob {
1243b0a2fdeeSScott Long 	int   error;
1244b0a2fdeeSScott Long 	int   timeout;
1245b0a2fdeeSScott Long 	u_int saved_cnt;
12469b631363SMatt Jacob 
1247b0a2fdeeSScott Long 	/*
1248b0a2fdeeSScott Long 	 * timeout is in ms.  0 indicates infinite wait.
1249b0a2fdeeSScott Long 	 * Convert to ticks or 500us units depending on
1250b0a2fdeeSScott Long 	 * our sleep mode.
1251b0a2fdeeSScott Long 	 */
1252c87e3f83SMatt Jacob 	if (sleep_ok != 0) {
1253b0a2fdeeSScott Long 		timeout = (time_ms * hz) / 1000;
1254c87e3f83SMatt Jacob 	} else {
1255b0a2fdeeSScott Long 		timeout = time_ms * 2;
1256c87e3f83SMatt Jacob 	}
1257b0a2fdeeSScott Long 	req->state |= REQ_STATE_NEED_WAKEUP;
1258b0a2fdeeSScott Long 	mask &= ~REQ_STATE_NEED_WAKEUP;
1259444dd2b6SMatt Jacob 	saved_cnt = mpt->reset_cnt;
1260c87e3f83SMatt Jacob 	while ((req->state & mask) != state && mpt->reset_cnt == saved_cnt) {
1261b0a2fdeeSScott Long 		if (sleep_ok != 0) {
1262b0a2fdeeSScott Long 			error = mpt_sleep(mpt, req, PUSER, "mptreq", timeout);
1263b0a2fdeeSScott Long 			if (error == EWOULDBLOCK) {
1264b0a2fdeeSScott Long 				timeout = 0;
1265b0a2fdeeSScott Long 				break;
1266b0a2fdeeSScott Long 			}
1267b0a2fdeeSScott Long 		} else {
1268b0a2fdeeSScott Long 			if (time_ms != 0 && --timeout == 0) {
1269b0a2fdeeSScott Long 				break;
1270b0a2fdeeSScott Long 			}
1271b0a2fdeeSScott Long 			DELAY(500);
1272b0a2fdeeSScott Long 			mpt_intr(mpt);
1273b0a2fdeeSScott Long 		}
1274b0a2fdeeSScott Long 	}
1275b0a2fdeeSScott Long 	req->state &= ~REQ_STATE_NEED_WAKEUP;
1276c87e3f83SMatt Jacob 	if (mpt->reset_cnt != saved_cnt) {
1277b0a2fdeeSScott Long 		return (EIO);
1278c87e3f83SMatt Jacob 	}
1279c87e3f83SMatt Jacob 	if (time_ms && timeout <= 0) {
1280c87e3f83SMatt Jacob 		MSG_REQUEST_HEADER *msg_hdr = req->req_vbuf;
1281c87e3f83SMatt Jacob 		mpt_prt(mpt, "mpt_wait_req(%x) timed out\n", msg_hdr->Function);
1282b0a2fdeeSScott Long 		return (ETIMEDOUT);
1283c87e3f83SMatt Jacob 	}
1284b0a2fdeeSScott Long 	return (0);
12859b631363SMatt Jacob }
12869b631363SMatt Jacob 
12879b631363SMatt Jacob /*
12889b631363SMatt Jacob  * Send a command to the IOC via the handshake register.
12899b631363SMatt Jacob  *
12909b631363SMatt Jacob  * Only done at initialization time and for certain unusual
12919b631363SMatt Jacob  * commands such as device/bus reset as specified by LSI.
12929b631363SMatt Jacob  */
12939b631363SMatt Jacob int
1294b0a2fdeeSScott Long mpt_send_handshake_cmd(struct mpt_softc *mpt, size_t len, void *cmd)
12959b631363SMatt Jacob {
12969b631363SMatt Jacob 	int i;
1297b0a2fdeeSScott Long 	uint32_t data, *data32;
12989b631363SMatt Jacob 
12999b631363SMatt Jacob 	/* Check condition of the IOC */
13009b631363SMatt Jacob 	data = mpt_rd_db(mpt);
1301b0a2fdeeSScott Long 	if ((MPT_STATE(data) != MPT_DB_STATE_READY
1302b0a2fdeeSScott Long 	  && MPT_STATE(data) != MPT_DB_STATE_RUNNING
1303b0a2fdeeSScott Long 	  && MPT_STATE(data) != MPT_DB_STATE_FAULT)
1304b0a2fdeeSScott Long 	 || MPT_DB_IS_IN_USE(data)) {
1305b0a2fdeeSScott Long 		mpt_prt(mpt, "handshake aborted - invalid doorbell state\n");
13069b631363SMatt Jacob 		mpt_print_db(data);
13079b631363SMatt Jacob 		return (EBUSY);
13089b631363SMatt Jacob 	}
13099b631363SMatt Jacob 
13109b631363SMatt Jacob 	/* We move things in 32 bit chunks */
13119b631363SMatt Jacob 	len = (len + 3) >> 2;
13129b631363SMatt Jacob 	data32 = cmd;
13139b631363SMatt Jacob 
13149b631363SMatt Jacob 	/* Clear any left over pending doorbell interupts */
13159b631363SMatt Jacob 	if (MPT_DB_INTR(mpt_rd_intr(mpt)))
13169b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13179b631363SMatt Jacob 
13189b631363SMatt Jacob 	/*
13199b631363SMatt Jacob 	 * Tell the handshake reg. we are going to send a command
13209b631363SMatt Jacob          * and how long it is going to be.
13219b631363SMatt Jacob 	 */
13229b631363SMatt Jacob 	data = (MPI_FUNCTION_HANDSHAKE << MPI_DOORBELL_FUNCTION_SHIFT) |
13239b631363SMatt Jacob 	    (len << MPI_DOORBELL_ADD_DWORDS_SHIFT);
13249b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_DOORBELL, data);
13259b631363SMatt Jacob 
13269b631363SMatt Jacob 	/* Wait for the chip to notice */
13279b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1328b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_handshake_cmd timeout1\n");
1329b0a2fdeeSScott Long 		return (ETIMEDOUT);
13309b631363SMatt Jacob 	}
13319b631363SMatt Jacob 
13329b631363SMatt Jacob 	/* Clear the interrupt */
13339b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13349b631363SMatt Jacob 
13359b631363SMatt Jacob 	if (mpt_wait_db_ack(mpt) != MPT_OK) {
1336b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_handshake_cmd timeout2\n");
1337b0a2fdeeSScott Long 		return (ETIMEDOUT);
13389b631363SMatt Jacob 	}
13399b631363SMatt Jacob 
13409b631363SMatt Jacob 	/* Send the command */
13419b631363SMatt Jacob 	for (i = 0; i < len; i++) {
13429b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_DOORBELL, *data32++);
13439b631363SMatt Jacob 		if (mpt_wait_db_ack(mpt) != MPT_OK) {
1344301472c2SMatt Jacob 			mpt_prt(mpt,
1345b0a2fdeeSScott Long 				"mpt_send_handshake_cmd timeout! index = %d\n",
1346b0a2fdeeSScott Long 				i);
1347b0a2fdeeSScott Long 			return (ETIMEDOUT);
13489b631363SMatt Jacob 		}
13499b631363SMatt Jacob 	}
13509b631363SMatt Jacob 	return MPT_OK;
13519b631363SMatt Jacob }
13529b631363SMatt Jacob 
13539b631363SMatt Jacob /* Get the response from the handshake register */
13549b631363SMatt Jacob int
1355b0a2fdeeSScott Long mpt_recv_handshake_reply(struct mpt_softc *mpt, size_t reply_len, void *reply)
13569b631363SMatt Jacob {
13579b631363SMatt Jacob 	int left, reply_left;
13589b631363SMatt Jacob 	u_int16_t *data16;
13599b631363SMatt Jacob 	MSG_DEFAULT_REPLY *hdr;
13609b631363SMatt Jacob 
13619b631363SMatt Jacob 	/* We move things out in 16 bit chunks */
13629b631363SMatt Jacob 	reply_len >>= 1;
13639b631363SMatt Jacob 	data16 = (u_int16_t *)reply;
13649b631363SMatt Jacob 
13659b631363SMatt Jacob 	hdr = (MSG_DEFAULT_REPLY *)reply;
13669b631363SMatt Jacob 
13679b631363SMatt Jacob 	/* Get first word */
13689b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1369b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout1\n");
13709b631363SMatt Jacob 		return ETIMEDOUT;
13719b631363SMatt Jacob 	}
13729b631363SMatt Jacob 	*data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
13739b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13749b631363SMatt Jacob 
13759b631363SMatt Jacob 	/* Get Second Word */
13769b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1377b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout2\n");
13789b631363SMatt Jacob 		return ETIMEDOUT;
13799b631363SMatt Jacob 	}
13809b631363SMatt Jacob 	*data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
13819b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13829b631363SMatt Jacob 
13835e073106SMatt Jacob 	/*
13845e073106SMatt Jacob 	 * With the second word, we can now look at the length.
13855e073106SMatt Jacob 	 * Warn about a reply that's too short (except for IOC FACTS REPLY)
13865e073106SMatt Jacob 	 */
13875e073106SMatt Jacob 	if ((reply_len >> 1) != hdr->MsgLength &&
13885e073106SMatt Jacob 	    (hdr->Function != MPI_FUNCTION_IOC_FACTS)){
13895e073106SMatt Jacob #if __FreeBSD_version >= 500000
1390301472c2SMatt Jacob 		mpt_prt(mpt, "reply length does not match message length: "
139133f31846SMatt Jacob 			"got %x; expected %zx for function %x\n",
13925e073106SMatt Jacob 			hdr->MsgLength << 2, reply_len << 1, hdr->Function);
13935e073106SMatt Jacob #else
13945e073106SMatt Jacob 		mpt_prt(mpt, "reply length does not match message length: "
139533f31846SMatt Jacob 			"got %x; expected %x for function %x\n",
13965e073106SMatt Jacob 			hdr->MsgLength << 2, reply_len << 1, hdr->Function);
13975e073106SMatt Jacob #endif
13989b631363SMatt Jacob 	}
13999b631363SMatt Jacob 
14009b631363SMatt Jacob 	/* Get rest of the reply; but don't overflow the provided buffer */
14019b631363SMatt Jacob 	left = (hdr->MsgLength << 1) - 2;
14029b631363SMatt Jacob 	reply_left =  reply_len - 2;
14039b631363SMatt Jacob 	while (left--) {
14049b631363SMatt Jacob 		u_int16_t datum;
14059b631363SMatt Jacob 
14069b631363SMatt Jacob 		if (mpt_wait_db_int(mpt) != MPT_OK) {
1407b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_recv_handshake_cmd timeout3\n");
14089b631363SMatt Jacob 			return ETIMEDOUT;
14099b631363SMatt Jacob 		}
14109b631363SMatt Jacob 		datum = mpt_read(mpt, MPT_OFFSET_DOORBELL);
14119b631363SMatt Jacob 
14129b631363SMatt Jacob 		if (reply_left-- > 0)
14139b631363SMatt Jacob 			*data16++ = datum & MPT_DB_DATA_MASK;
14149b631363SMatt Jacob 
14159b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
14169b631363SMatt Jacob 	}
14179b631363SMatt Jacob 
14189b631363SMatt Jacob 	/* One more wait & clear at the end */
14199b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1420b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout4\n");
14219b631363SMatt Jacob 		return ETIMEDOUT;
14229b631363SMatt Jacob 	}
14239b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
14249b631363SMatt Jacob 
14259b631363SMatt Jacob 	if ((hdr->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1426b0a2fdeeSScott Long 		if (mpt->verbose >= MPT_PRT_TRACE)
14279b631363SMatt Jacob 			mpt_print_reply(hdr);
14289b631363SMatt Jacob 		return (MPT_FAIL | hdr->IOCStatus);
14299b631363SMatt Jacob 	}
14309b631363SMatt Jacob 
14319b631363SMatt Jacob 	return (0);
14329b631363SMatt Jacob }
14339b631363SMatt Jacob 
14349b631363SMatt Jacob static int
1435b0a2fdeeSScott Long mpt_get_iocfacts(struct mpt_softc *mpt, MSG_IOC_FACTS_REPLY *freplp)
14369b631363SMatt Jacob {
14379b631363SMatt Jacob 	MSG_IOC_FACTS f_req;
14389b631363SMatt Jacob 	int error;
14399b631363SMatt Jacob 
14405e073106SMatt Jacob 	memset(&f_req, 0, sizeof f_req);
14419b631363SMatt Jacob 	f_req.Function = MPI_FUNCTION_IOC_FACTS;
1442b0a2fdeeSScott Long 	f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14439b631363SMatt Jacob 	error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
14449b631363SMatt Jacob 	if (error)
14459b631363SMatt Jacob 		return(error);
14469b631363SMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
14479b631363SMatt Jacob 	return (error);
14489b631363SMatt Jacob }
14499b631363SMatt Jacob 
14507104aeefSMatt Jacob static int
1451b0a2fdeeSScott Long mpt_get_portfacts(struct mpt_softc *mpt, MSG_PORT_FACTS_REPLY *freplp)
14527104aeefSMatt Jacob {
14537104aeefSMatt Jacob 	MSG_PORT_FACTS f_req;
14547104aeefSMatt Jacob 	int error;
14557104aeefSMatt Jacob 
14567104aeefSMatt Jacob 	/* XXX: Only getting PORT FACTS for Port 0 */
1457b0a2fdeeSScott Long 	memset(&f_req, 0, sizeof f_req);
14587104aeefSMatt Jacob 	f_req.Function = MPI_FUNCTION_PORT_FACTS;
1459b0a2fdeeSScott Long 	f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14607104aeefSMatt Jacob 	error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
14617104aeefSMatt Jacob 	if (error)
14627104aeefSMatt Jacob 		return(error);
14637104aeefSMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
14647104aeefSMatt Jacob 	return (error);
14657104aeefSMatt Jacob }
14667104aeefSMatt Jacob 
14679b631363SMatt Jacob /*
14689b631363SMatt Jacob  * Send the initialization request. This is where we specify how many
14699b631363SMatt Jacob  * SCSI busses and how many devices per bus we wish to emulate.
14709b631363SMatt Jacob  * This is also the command that specifies the max size of the reply
14719b631363SMatt Jacob  * frames from the IOC that we will be allocating.
14729b631363SMatt Jacob  */
14739b631363SMatt Jacob static int
1474b0a2fdeeSScott Long mpt_send_ioc_init(struct mpt_softc *mpt, uint32_t who)
14759b631363SMatt Jacob {
14769b631363SMatt Jacob 	int error = 0;
14779b631363SMatt Jacob 	MSG_IOC_INIT init;
14789b631363SMatt Jacob 	MSG_IOC_INIT_REPLY reply;
14799b631363SMatt Jacob 
14805e073106SMatt Jacob 	memset(&init, 0, sizeof init);
14819b631363SMatt Jacob 	init.WhoInit = who;
14829b631363SMatt Jacob 	init.Function = MPI_FUNCTION_IOC_INIT;
14839b631363SMatt Jacob 	if (mpt->is_fc) {
14849b631363SMatt Jacob 		init.MaxDevices = 255;
1485444dd2b6SMatt Jacob 	} else if (mpt->is_sas) {
1486444dd2b6SMatt Jacob 		init.MaxDevices = mpt->mpt_max_devices;
14879b631363SMatt Jacob 	} else {
14889b631363SMatt Jacob 		init.MaxDevices = 16;
14899b631363SMatt Jacob 	}
14909b631363SMatt Jacob 	init.MaxBuses = 1;
1491444dd2b6SMatt Jacob 
1492444dd2b6SMatt Jacob 	init.MsgVersion = htole16(MPI_VERSION);
1493444dd2b6SMatt Jacob 	init.HeaderVersion = htole16(MPI_HEADER_VERSION);
1494444dd2b6SMatt Jacob 	init.ReplyFrameSize = htole16(MPT_REPLY_SIZE);
1495b0a2fdeeSScott Long 	init.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14969b631363SMatt Jacob 
14979b631363SMatt Jacob 	if ((error = mpt_send_handshake_cmd(mpt, sizeof init, &init)) != 0) {
14989b631363SMatt Jacob 		return(error);
14999b631363SMatt Jacob 	}
15009b631363SMatt Jacob 
15019b631363SMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof reply, &reply);
15029b631363SMatt Jacob 	return (error);
15039b631363SMatt Jacob }
15049b631363SMatt Jacob 
15057104aeefSMatt Jacob 
15067104aeefSMatt Jacob /*
15077104aeefSMatt Jacob  * Utiltity routine to read configuration headers and pages
15087104aeefSMatt Jacob  */
1509b0a2fdeeSScott Long int
1510b0a2fdeeSScott Long mpt_issue_cfg_req(struct mpt_softc *mpt, request_t *req, u_int Action,
1511b0a2fdeeSScott Long 		  u_int PageVersion, u_int PageLength, u_int PageNumber,
1512b0a2fdeeSScott Long 		  u_int PageType, uint32_t PageAddress, bus_addr_t addr,
1513b0a2fdeeSScott Long 		  bus_size_t len, int sleep_ok, int timeout_ms)
15147104aeefSMatt Jacob {
15157104aeefSMatt Jacob 	MSG_CONFIG *cfgp;
1516b0a2fdeeSScott Long 	SGE_SIMPLE32 *se;
15177104aeefSMatt Jacob 
15187104aeefSMatt Jacob 	cfgp = req->req_vbuf;
1519b0a2fdeeSScott Long 	memset(cfgp, 0, sizeof *cfgp);
1520b0a2fdeeSScott Long 	cfgp->Action = Action;
15217104aeefSMatt Jacob 	cfgp->Function = MPI_FUNCTION_CONFIG;
1522b0a2fdeeSScott Long 	cfgp->Header.PageVersion = PageVersion;
1523b0a2fdeeSScott Long 	cfgp->Header.PageLength = PageLength;
1524b0a2fdeeSScott Long 	cfgp->Header.PageNumber = PageNumber;
1525b0a2fdeeSScott Long 	cfgp->Header.PageType = PageType;
15267104aeefSMatt Jacob 	cfgp->PageAddress = PageAddress;
1527b0a2fdeeSScott Long 	se = (SGE_SIMPLE32 *)&cfgp->PageBufferSGE;
1528b0a2fdeeSScott Long 	se->Address = addr;
1529b0a2fdeeSScott Long 	MPI_pSGE_SET_LENGTH(se, len);
1530b0a2fdeeSScott Long 	MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1531b0a2fdeeSScott Long 	    MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER |
1532b0a2fdeeSScott Long 	    MPI_SGE_FLAGS_END_OF_LIST |
1533b0a2fdeeSScott Long 	    ((Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT
1534b0a2fdeeSScott Long 	  || Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM)
1535b0a2fdeeSScott Long 	   ? MPI_SGE_FLAGS_HOST_TO_IOC : MPI_SGE_FLAGS_IOC_TO_HOST)));
1536b0a2fdeeSScott Long 	cfgp->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG);
15377104aeefSMatt Jacob 
15387104aeefSMatt Jacob 	mpt_check_doorbell(mpt);
15397104aeefSMatt Jacob 	mpt_send_cmd(mpt, req);
1540b0a2fdeeSScott Long 	return (mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE,
1541b0a2fdeeSScott Long 			     sleep_ok, timeout_ms));
15427104aeefSMatt Jacob }
15437104aeefSMatt Jacob 
1544b0a2fdeeSScott Long 
1545b0a2fdeeSScott Long int
1546b0a2fdeeSScott Long mpt_read_cfg_header(struct mpt_softc *mpt, int PageType, int PageNumber,
1547b0a2fdeeSScott Long 		    uint32_t PageAddress, CONFIG_PAGE_HEADER *rslt,
1548b0a2fdeeSScott Long 		    int sleep_ok, int timeout_ms)
1549b0a2fdeeSScott Long {
1550b0a2fdeeSScott Long 	request_t  *req;
155129ae59edSMatt Jacob 	MSG_CONFIG *cfgp;
1552b0a2fdeeSScott Long 	int	    error;
1553b0a2fdeeSScott Long 
1554b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1555b0a2fdeeSScott Long 	if (req == NULL) {
1556b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_header: Get request failed!\n");
155729ae59edSMatt Jacob 		return (ENOMEM);
15587104aeefSMatt Jacob 	}
1559b0a2fdeeSScott Long 
1560b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, MPI_CONFIG_ACTION_PAGE_HEADER,
1561b0a2fdeeSScott Long 				  /*PageVersion*/0, /*PageLength*/0, PageNumber,
1562b0a2fdeeSScott Long 				  PageType, PageAddress, /*addr*/0, /*len*/0,
1563b0a2fdeeSScott Long 				  sleep_ok, timeout_ms);
1564b0a2fdeeSScott Long 	if (error != 0) {
156529ae59edSMatt Jacob 		mpt_free_request(mpt, req);
1566b0a2fdeeSScott Long 		mpt_prt(mpt, "read_cfg_header timed out\n");
156729ae59edSMatt Jacob 		return (ETIMEDOUT);
1568b0a2fdeeSScott Long 	}
1569b0a2fdeeSScott Long 
157029ae59edSMatt Jacob         switch (req->IOCStatus & MPI_IOCSTATUS_MASK) {
157129ae59edSMatt Jacob 	case MPI_IOCSTATUS_SUCCESS:
1572b0a2fdeeSScott Long 		cfgp = req->req_vbuf;
1573b0a2fdeeSScott Long 		bcopy(&cfgp->Header, rslt, sizeof(*rslt));
1574b0a2fdeeSScott Long 		error = 0;
157529ae59edSMatt Jacob 		break;
157629ae59edSMatt Jacob 	case MPI_IOCSTATUS_CONFIG_INVALID_PAGE:
157729ae59edSMatt Jacob 		mpt_lprt(mpt, MPT_PRT_DEBUG,
157829ae59edSMatt Jacob 		    "Invalid Page Type %d Number %d Addr 0x%0x\n",
157929ae59edSMatt Jacob 		    PageType, PageNumber, PageAddress);
158029ae59edSMatt Jacob 		error = EINVAL;
158129ae59edSMatt Jacob 		break;
158229ae59edSMatt Jacob 	default:
158329ae59edSMatt Jacob 		mpt_prt(mpt, "mpt_read_cfg_header: Config Info Status %x\n",
158429ae59edSMatt Jacob 			req->IOCStatus);
158529ae59edSMatt Jacob 		error = EIO;
158629ae59edSMatt Jacob 		break;
1587b0a2fdeeSScott Long 	}
15887104aeefSMatt Jacob 	mpt_free_request(mpt, req);
1589b0a2fdeeSScott Long 	return (error);
15907104aeefSMatt Jacob }
15917104aeefSMatt Jacob 
1592ce68dae5SMatt Jacob int
1593b0a2fdeeSScott Long mpt_read_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress,
1594b0a2fdeeSScott Long 		  CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok,
1595b0a2fdeeSScott Long 		  int timeout_ms)
15967104aeefSMatt Jacob {
15977104aeefSMatt Jacob 	request_t    *req;
1598b0a2fdeeSScott Long 	int	      error;
15997104aeefSMatt Jacob 
1600b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1601b0a2fdeeSScott Long 	if (req == NULL) {
1602b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_page: Get request failed!\n");
16037104aeefSMatt Jacob 		return (-1);
16047104aeefSMatt Jacob 	}
16057104aeefSMatt Jacob 
1606b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion,
1607b0a2fdeeSScott Long 				  hdr->PageLength, hdr->PageNumber,
1608b0a2fdeeSScott Long 				  hdr->PageType & MPI_CONFIG_PAGETYPE_MASK,
1609c87e3f83SMatt Jacob 				  PageAddress, req->req_pbuf + MPT_RQSL(mpt),
1610b0a2fdeeSScott Long 				  len, sleep_ok, timeout_ms);
1611b0a2fdeeSScott Long 	if (error != 0) {
1612b0a2fdeeSScott Long 		mpt_prt(mpt, "read_cfg_page(%d) timed out\n", Action);
16137104aeefSMatt Jacob 		return (-1);
16147104aeefSMatt Jacob 	}
1615b0a2fdeeSScott Long 
1616b0a2fdeeSScott Long 	if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1617b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_page: Config Info Status %x\n",
1618b0a2fdeeSScott Long 			req->IOCStatus);
1619b0a2fdeeSScott Long 		mpt_free_request(mpt, req);
1620b0a2fdeeSScott Long 		return (-1);
1621b0a2fdeeSScott Long 	}
16227104aeefSMatt Jacob 	bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
16237104aeefSMatt Jacob 	    BUS_DMASYNC_POSTREAD);
1624c87e3f83SMatt Jacob 	memcpy(hdr, ((uint8_t *)req->req_vbuf)+MPT_RQSL(mpt), len);
16257104aeefSMatt Jacob 	mpt_free_request(mpt, req);
16267104aeefSMatt Jacob 	return (0);
16277104aeefSMatt Jacob }
16287104aeefSMatt Jacob 
1629ce68dae5SMatt Jacob int
1630b0a2fdeeSScott Long mpt_write_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress,
1631b0a2fdeeSScott Long 		   CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok,
1632b0a2fdeeSScott Long 		   int timeout_ms)
16337104aeefSMatt Jacob {
16347104aeefSMatt Jacob 	request_t    *req;
1635b0a2fdeeSScott Long 	u_int	      hdr_attr;
1636b0a2fdeeSScott Long 	int	      error;
16377104aeefSMatt Jacob 
16387104aeefSMatt Jacob 	hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK;
16397104aeefSMatt Jacob 	if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE &&
16407104aeefSMatt Jacob 	    hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) {
1641b0a2fdeeSScott Long 		mpt_prt(mpt, "page type 0x%x not changeable\n",
16427104aeefSMatt Jacob 			hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
16437104aeefSMatt Jacob 		return (-1);
16447104aeefSMatt Jacob 	}
1645b0a2fdeeSScott Long 	hdr->PageType &= MPI_CONFIG_PAGETYPE_MASK,
16467104aeefSMatt Jacob 
1647b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1648b0a2fdeeSScott Long 	if (req == NULL)
1649b0a2fdeeSScott Long 		return (-1);
16507104aeefSMatt Jacob 
1651c87e3f83SMatt Jacob 	memcpy(((caddr_t)req->req_vbuf)+MPT_RQSL(mpt), hdr, len);
1652301472c2SMatt Jacob 	/* Restore stripped out attributes */
1653301472c2SMatt Jacob 	hdr->PageType |= hdr_attr;
16547104aeefSMatt Jacob 
1655b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion,
1656b0a2fdeeSScott Long 				  hdr->PageLength, hdr->PageNumber,
1657b0a2fdeeSScott Long 				  hdr->PageType & MPI_CONFIG_PAGETYPE_MASK,
1658c87e3f83SMatt Jacob 				  PageAddress, req->req_pbuf + MPT_RQSL(mpt),
1659b0a2fdeeSScott Long 				  len, sleep_ok, timeout_ms);
1660b0a2fdeeSScott Long 	if (error != 0) {
1661b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_write_cfg_page timed out\n");
16627104aeefSMatt Jacob 		return (-1);
16637104aeefSMatt Jacob 	}
16647104aeefSMatt Jacob 
1665b0a2fdeeSScott Long         if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1666b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_write_cfg_page: Config Info Status %x\n",
1667b0a2fdeeSScott Long 			req->IOCStatus);
16687104aeefSMatt Jacob 		mpt_free_request(mpt, req);
1669b0a2fdeeSScott Long 		return (-1);
1670b0a2fdeeSScott Long 	}
1671b0a2fdeeSScott Long 	mpt_free_request(mpt, req);
1672b0a2fdeeSScott Long 	return (0);
1673b0a2fdeeSScott Long }
1674b0a2fdeeSScott Long 
1675b0a2fdeeSScott Long /*
1676b0a2fdeeSScott Long  * Read IOC configuration information
1677b0a2fdeeSScott Long  */
1678b0a2fdeeSScott Long static int
1679b0a2fdeeSScott Long mpt_read_config_info_ioc(struct mpt_softc *mpt)
1680b0a2fdeeSScott Long {
1681b0a2fdeeSScott Long 	CONFIG_PAGE_HEADER hdr;
1682b0a2fdeeSScott Long 	struct mpt_raid_volume *mpt_raid;
1683b0a2fdeeSScott Long 	int rv;
1684b0a2fdeeSScott Long 	int i;
1685b0a2fdeeSScott Long 	size_t len;
1686b0a2fdeeSScott Long 
1687b0a2fdeeSScott Long 	rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC,
16881d79ca0eSMatt Jacob 		2, 0, &hdr, FALSE, 5000);
168929ae59edSMatt Jacob 	/*
169029ae59edSMatt Jacob 	 * If it's an invalid page, so what? Not a supported function....
169129ae59edSMatt Jacob 	 */
16921d79ca0eSMatt Jacob 	if (rv == EINVAL) {
169329ae59edSMatt Jacob 		return (0);
16941d79ca0eSMatt Jacob 	}
16951d79ca0eSMatt Jacob 	if (rv) {
169629ae59edSMatt Jacob 		return (rv);
16971d79ca0eSMatt Jacob 	}
1698b0a2fdeeSScott Long 
16995e073106SMatt Jacob #if __FreeBSD_version >= 500000
1700a529c6a2SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG,  "IOC Page 2 Header: ver %x, len %zx, "
1701b0a2fdeeSScott Long 		 "num %x, type %x\n", hdr.PageVersion,
1702b0a2fdeeSScott Long 		 hdr.PageLength * sizeof(uint32_t),
1703b0a2fdeeSScott Long 		 hdr.PageNumber, hdr.PageType);
17045e073106SMatt Jacob #else
17055e073106SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG,  "IOC Page 2 Header: ver %x, len %z, "
17065e073106SMatt Jacob 		 "num %x, type %x\n", hdr.PageVersion,
17075e073106SMatt Jacob 		 hdr.PageLength * sizeof(uint32_t),
17085e073106SMatt Jacob 		 hdr.PageNumber, hdr.PageType);
17095e073106SMatt Jacob #endif
1710b0a2fdeeSScott Long 
1711b0a2fdeeSScott Long 	len = hdr.PageLength * sizeof(uint32_t);
1712a3699bcaSScott Long 	mpt->ioc_page2 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
17131d79ca0eSMatt Jacob 	if (mpt->ioc_page2 == NULL) {
17141d79ca0eSMatt Jacob 		mpt_prt(mpt, "unable to allocate memory for IOC page 2\n");
17151d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
1716b0a2fdeeSScott Long 		return (ENOMEM);
17171d79ca0eSMatt Jacob 	}
1718b0a2fdeeSScott Long 	memcpy(&mpt->ioc_page2->Header, &hdr, sizeof(hdr));
17191d79ca0eSMatt Jacob 	rv = mpt_read_cur_cfg_page(mpt, 0,
17201d79ca0eSMatt Jacob 	    &mpt->ioc_page2->Header, len, FALSE, 5000);
1721b0a2fdeeSScott Long 	if (rv) {
1722b0a2fdeeSScott Long 		mpt_prt(mpt, "failed to read IOC Page 2\n");
17231d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
17241d79ca0eSMatt Jacob 		return (EIO);
17251d79ca0eSMatt Jacob 	}
17261d79ca0eSMatt Jacob 
17271d79ca0eSMatt Jacob 	if (mpt->ioc_page2->CapabilitiesFlags != 0) {
1728b0a2fdeeSScott Long 		uint32_t mask;
1729b0a2fdeeSScott Long 
1730b0a2fdeeSScott Long 		mpt_prt(mpt, "Capabilities: (");
1731b0a2fdeeSScott Long 		for (mask = 1; mask != 0; mask <<= 1) {
17321d79ca0eSMatt Jacob 			if ((mpt->ioc_page2->CapabilitiesFlags & mask) == 0) {
1733b0a2fdeeSScott Long 				continue;
17341d79ca0eSMatt Jacob 			}
1735b0a2fdeeSScott Long 			switch (mask) {
1736b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT:
1737b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-0");
1738b0a2fdeeSScott Long 				break;
1739b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT:
1740b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-1E");
1741b0a2fdeeSScott Long 				break;
1742b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT:
1743b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-1");
1744b0a2fdeeSScott Long 				break;
1745b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_SES_SUPPORT:
1746b0a2fdeeSScott Long 				mpt_prtc(mpt, " SES");
1747b0a2fdeeSScott Long 				break;
1748b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_SAFTE_SUPPORT:
1749b0a2fdeeSScott Long 				mpt_prtc(mpt, " SAFTE");
1750b0a2fdeeSScott Long 				break;
1751b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_CROSS_CHANNEL_SUPPORT:
1752b0a2fdeeSScott Long 				mpt_prtc(mpt, " Multi-Channel-Arrays");
1753b0a2fdeeSScott Long 			default:
1754b0a2fdeeSScott Long 				break;
1755b0a2fdeeSScott Long 			}
1756b0a2fdeeSScott Long 		}
1757b0a2fdeeSScott Long 		mpt_prtc(mpt, " )\n");
1758b0a2fdeeSScott Long 		if ((mpt->ioc_page2->CapabilitiesFlags
1759b0a2fdeeSScott Long 		   & (MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT
1760b0a2fdeeSScott Long 		    | MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT
1761b0a2fdeeSScott Long 		    | MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT)) != 0) {
1762b0a2fdeeSScott Long 			mpt_prt(mpt, "%d Active Volume%s(%d Max)\n",
1763b0a2fdeeSScott Long 				mpt->ioc_page2->NumActiveVolumes,
1764b0a2fdeeSScott Long 				mpt->ioc_page2->NumActiveVolumes != 1
1765b0a2fdeeSScott Long 			      ? "s " : " ",
1766b0a2fdeeSScott Long 				mpt->ioc_page2->MaxVolumes);
1767b0a2fdeeSScott Long 			mpt_prt(mpt, "%d Hidden Drive Member%s(%d Max)\n",
1768b0a2fdeeSScott Long 				mpt->ioc_page2->NumActivePhysDisks,
1769b0a2fdeeSScott Long 				mpt->ioc_page2->NumActivePhysDisks != 1
1770b0a2fdeeSScott Long 			      ? "s " : " ",
1771b0a2fdeeSScott Long 				mpt->ioc_page2->MaxPhysDisks);
1772b0a2fdeeSScott Long 		}
1773b0a2fdeeSScott Long 	}
1774b0a2fdeeSScott Long 
1775b0a2fdeeSScott Long 	len = mpt->ioc_page2->MaxVolumes * sizeof(struct mpt_raid_volume);
17761d79ca0eSMatt Jacob 	mpt->raid_volumes = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1777b0a2fdeeSScott Long 	if (mpt->raid_volumes == NULL) {
1778b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not allocate RAID volume data\n");
17791d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
17801d79ca0eSMatt Jacob 		return (ENOMEM);
1781b0a2fdeeSScott Long 	}
1782b0a2fdeeSScott Long 
1783b0a2fdeeSScott Long 	/*
1784b0a2fdeeSScott Long 	 * Copy critical data out of ioc_page2 so that we can
1785b0a2fdeeSScott Long 	 * safely refresh the page without windows of unreliable
1786b0a2fdeeSScott Long 	 * data.
1787b0a2fdeeSScott Long 	 */
1788b0a2fdeeSScott Long 	mpt->raid_max_volumes =  mpt->ioc_page2->MaxVolumes;
1789b0a2fdeeSScott Long 
17901d79ca0eSMatt Jacob 	len = sizeof(*mpt->raid_volumes->config_page) +
17911d79ca0eSMatt Jacob 	    (sizeof (RAID_VOL0_PHYS_DISK) * (mpt->ioc_page2->MaxPhysDisks - 1));
1792b0a2fdeeSScott Long 	for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) {
1793b0a2fdeeSScott Long 		mpt_raid = &mpt->raid_volumes[i];
17941d79ca0eSMatt Jacob 		mpt_raid->config_page =
17951d79ca0eSMatt Jacob 		    malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1796b0a2fdeeSScott Long 		if (mpt_raid->config_page == NULL) {
1797b0a2fdeeSScott Long 			mpt_prt(mpt, "Could not allocate RAID page data\n");
17981d79ca0eSMatt Jacob 			mpt_raid_free_mem(mpt);
17991d79ca0eSMatt Jacob 			return (ENOMEM);
1800b0a2fdeeSScott Long 		}
1801b0a2fdeeSScott Long 	}
1802b0a2fdeeSScott Long 	mpt->raid_page0_len = len;
1803b0a2fdeeSScott Long 
1804b0a2fdeeSScott Long 	len = mpt->ioc_page2->MaxPhysDisks * sizeof(struct mpt_raid_disk);
18051d79ca0eSMatt Jacob 	mpt->raid_disks = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1806b0a2fdeeSScott Long 	if (mpt->raid_disks == NULL) {
1807b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not allocate RAID disk data\n");
18081d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18091d79ca0eSMatt Jacob 		return (ENOMEM);
1810b0a2fdeeSScott Long 	}
1811b0a2fdeeSScott Long 	mpt->raid_max_disks =  mpt->ioc_page2->MaxPhysDisks;
1812b0a2fdeeSScott Long 
18131d79ca0eSMatt Jacob 	/*
18141d79ca0eSMatt Jacob 	 * Load page 3.
18151d79ca0eSMatt Jacob 	 */
1816b0a2fdeeSScott Long 	rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC,
18171d79ca0eSMatt Jacob 	    3, 0, &hdr, FALSE, 5000);
18181d79ca0eSMatt Jacob 	if (rv) {
18191d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
1820b0a2fdeeSScott Long 		return (EIO);
18211d79ca0eSMatt Jacob 	}
1822b0a2fdeeSScott Long 
1823b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 3 Header: %x %x %x %x\n",
1824b0a2fdeeSScott Long 	    hdr.PageVersion, hdr.PageLength, hdr.PageNumber, hdr.PageType);
1825b0a2fdeeSScott Long 
1826b0a2fdeeSScott Long 	len = hdr.PageLength * sizeof(uint32_t);
1827a3699bcaSScott Long 	mpt->ioc_page3 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
18281d79ca0eSMatt Jacob 	if (mpt->ioc_page3 == NULL) {
18291d79ca0eSMatt Jacob 		mpt_prt(mpt, "unable to allocate memory for IOC page 3\n");
18301d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18311d79ca0eSMatt Jacob 		return (ENOMEM);
1832b0a2fdeeSScott Long 	}
18331d79ca0eSMatt Jacob 	memcpy(&mpt->ioc_page3->Header, &hdr, sizeof(hdr));
18341d79ca0eSMatt Jacob 	rv = mpt_read_cur_cfg_page(mpt, 0,
18351d79ca0eSMatt Jacob 	    &mpt->ioc_page3->Header, len, FALSE, 5000);
18361d79ca0eSMatt Jacob 	if (rv) {
18371d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18381d79ca0eSMatt Jacob 		return (EIO);
18391d79ca0eSMatt Jacob 	}
1840b0a2fdeeSScott Long 	mpt_raid_wakeup(mpt);
18417104aeefSMatt Jacob 	return (0);
18427104aeefSMatt Jacob }
18437104aeefSMatt Jacob 
18447104aeefSMatt Jacob /*
18457104aeefSMatt Jacob  * Enable IOC port
18467104aeefSMatt Jacob  */
18477104aeefSMatt Jacob static int
1848b0a2fdeeSScott Long mpt_send_port_enable(struct mpt_softc *mpt, int port)
18499b631363SMatt Jacob {
18509b631363SMatt Jacob 	request_t	*req;
18519b631363SMatt Jacob 	MSG_PORT_ENABLE *enable_req;
1852b0a2fdeeSScott Long 	int		 error;
18539b631363SMatt Jacob 
1854b0a2fdeeSScott Long 	req = mpt_get_request(mpt, /*sleep_ok*/FALSE);
1855b0a2fdeeSScott Long 	if (req == NULL)
1856b0a2fdeeSScott Long 		return (-1);
18579b631363SMatt Jacob 
18589b631363SMatt Jacob 	enable_req = req->req_vbuf;
18595e073106SMatt Jacob 	memset(enable_req, 0,  MPT_RQSL(mpt));
18609b631363SMatt Jacob 
18619b631363SMatt Jacob 	enable_req->Function   = MPI_FUNCTION_PORT_ENABLE;
1862b0a2fdeeSScott Long 	enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG);
18639b631363SMatt Jacob 	enable_req->PortNumber = port;
18649b631363SMatt Jacob 
18659b631363SMatt Jacob 	mpt_check_doorbell(mpt);
1866b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "enabling port %d\n", port);
18679b631363SMatt Jacob 
1868b0a2fdeeSScott Long 	mpt_send_cmd(mpt, req);
1869b0a2fdeeSScott Long 	error = mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE,
18705089bd63SMatt Jacob 	    FALSE, (mpt->is_sas || mpt->is_fc)? 30000 : 3000);
1871b0a2fdeeSScott Long 	if (error != 0) {
1872c87e3f83SMatt Jacob 		mpt_prt(mpt, "port %d enable timed out\n", port);
18739b631363SMatt Jacob 		return (-1);
18749b631363SMatt Jacob 	}
18759b631363SMatt Jacob 	mpt_free_request(mpt, req);
1876c87e3f83SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "enabled port %d\n", port);
18779b631363SMatt Jacob 	return (0);
18789b631363SMatt Jacob }
18799b631363SMatt Jacob 
18809b631363SMatt Jacob /*
18819b631363SMatt Jacob  * Enable/Disable asynchronous event reporting.
18829b631363SMatt Jacob  */
18839b631363SMatt Jacob static int
1884b0a2fdeeSScott Long mpt_send_event_request(struct mpt_softc *mpt, int onoff)
18859b631363SMatt Jacob {
18869b631363SMatt Jacob 	request_t *req;
18879b631363SMatt Jacob 	MSG_EVENT_NOTIFY *enable_req;
18889b631363SMatt Jacob 
18895e073106SMatt Jacob 	req = mpt_get_request(mpt, FALSE);
18905e073106SMatt Jacob 	if (req == NULL) {
18915e073106SMatt Jacob 		return (ENOMEM);
18925e073106SMatt Jacob 	}
18939b631363SMatt Jacob 	enable_req = req->req_vbuf;
18945e073106SMatt Jacob 	memset(enable_req, 0, sizeof *enable_req);
18959b631363SMatt Jacob 
18969b631363SMatt Jacob 	enable_req->Function   = MPI_FUNCTION_EVENT_NOTIFICATION;
1897b0a2fdeeSScott Long 	enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_EVENTS);
18989b631363SMatt Jacob 	enable_req->Switch     = onoff;
18999b631363SMatt Jacob 
19009b631363SMatt Jacob 	mpt_check_doorbell(mpt);
19015e073106SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "%sabling async events\n",
19025e073106SMatt Jacob 	    onoff ? "en" : "dis");
19035e073106SMatt Jacob 	/*
19045e073106SMatt Jacob 	 * Send the command off, but don't wait for it.
19055e073106SMatt Jacob 	 */
19069b631363SMatt Jacob 	mpt_send_cmd(mpt, req);
19079b631363SMatt Jacob 	return (0);
19089b631363SMatt Jacob }
19099b631363SMatt Jacob 
19109b631363SMatt Jacob /*
19119b631363SMatt Jacob  * Un-mask the interupts on the chip.
19129b631363SMatt Jacob  */
19139b631363SMatt Jacob void
1914b0a2fdeeSScott Long mpt_enable_ints(struct mpt_softc *mpt)
19159b631363SMatt Jacob {
19169b631363SMatt Jacob 	/* Unmask every thing except door bell int */
19179b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_MASK, MPT_INTR_DB_MASK);
19189b631363SMatt Jacob }
19199b631363SMatt Jacob 
19209b631363SMatt Jacob /*
19219b631363SMatt Jacob  * Mask the interupts on the chip.
19229b631363SMatt Jacob  */
19239b631363SMatt Jacob void
1924b0a2fdeeSScott Long mpt_disable_ints(struct mpt_softc *mpt)
19259b631363SMatt Jacob {
19269b631363SMatt Jacob 	/* Mask all interrupts */
19279b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_MASK,
19289b631363SMatt Jacob 	    MPT_INTR_REPLY_MASK | MPT_INTR_DB_MASK);
19299b631363SMatt Jacob }
19309b631363SMatt Jacob 
1931b0a2fdeeSScott Long static void
1932b0a2fdeeSScott Long mpt_sysctl_attach(struct mpt_softc *mpt)
19339b631363SMatt Jacob {
1934c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000
1935b0a2fdeeSScott Long 	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(mpt->dev);
1936b0a2fdeeSScott Long 	struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev);
19379b631363SMatt Jacob 
1938b0a2fdeeSScott Long 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
1939b0a2fdeeSScott Long 		       "debug", CTLFLAG_RW, &mpt->verbose, 0,
1940b0a2fdeeSScott Long 		       "Debugging/Verbose level");
1941c87e3f83SMatt Jacob #endif
19429b631363SMatt Jacob }
19439b631363SMatt Jacob 
1944b0a2fdeeSScott Long int
1945b0a2fdeeSScott Long mpt_attach(struct mpt_softc *mpt)
1946b0a2fdeeSScott Long {
1947b0a2fdeeSScott Long 	struct mpt_personality *pers;
1948c87e3f83SMatt Jacob 	int i;
1949b0a2fdeeSScott Long 	int error;
1950b0a2fdeeSScott Long 
1951c87e3f83SMatt Jacob 	for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
1952b0a2fdeeSScott Long 		pers = mpt_personalities[i];
1953c87e3f83SMatt Jacob 		if (pers == NULL) {
1954b0a2fdeeSScott Long 			continue;
1955c87e3f83SMatt Jacob 		}
1956b0a2fdeeSScott Long 		if (pers->probe(mpt) == 0) {
1957b0a2fdeeSScott Long 			error = pers->attach(mpt);
1958b0a2fdeeSScott Long 			if (error != 0) {
1959b0a2fdeeSScott Long 				mpt_detach(mpt);
1960b0a2fdeeSScott Long 				return (error);
1961b0a2fdeeSScott Long 			}
1962b0a2fdeeSScott Long 			mpt->mpt_pers_mask |= (0x1 << pers->id);
1963b0a2fdeeSScott Long 			pers->use_count++;
1964b0a2fdeeSScott Long 		}
1965b0a2fdeeSScott Long 	}
1966444dd2b6SMatt Jacob 
1967c87e3f83SMatt Jacob 	/*
1968c87e3f83SMatt Jacob 	 * Now that we've attached everything, do the enable function
1969c87e3f83SMatt Jacob 	 * for all of the personalities. This allows the personalities
1970c87e3f83SMatt Jacob 	 * to do setups that are appropriate for them prior to enabling
1971c87e3f83SMatt Jacob 	 * any ports.
1972c87e3f83SMatt Jacob 	 */
1973c87e3f83SMatt Jacob 	for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
1974c87e3f83SMatt Jacob 		pers = mpt_personalities[i];
1975c87e3f83SMatt Jacob 		if (pers != NULL  && MPT_PERS_ATTACHED(pers, mpt) != 0) {
1976c87e3f83SMatt Jacob 			error = pers->enable(mpt);
1977c87e3f83SMatt Jacob 			if (error != 0) {
1978c87e3f83SMatt Jacob 				mpt_prt(mpt, "personality %s attached but would"
1979c87e3f83SMatt Jacob 				    " not enable (%d)\n", pers->name, error);
1980c87e3f83SMatt Jacob 				mpt_detach(mpt);
1981c87e3f83SMatt Jacob 				return (error);
1982c87e3f83SMatt Jacob 			}
1983c87e3f83SMatt Jacob 		}
1984c87e3f83SMatt Jacob 	}
1985b0a2fdeeSScott Long 	return (0);
1986b0a2fdeeSScott Long }
1987b0a2fdeeSScott Long 
1988b0a2fdeeSScott Long int
1989b0a2fdeeSScott Long mpt_shutdown(struct mpt_softc *mpt)
1990b0a2fdeeSScott Long {
1991b0a2fdeeSScott Long 	struct mpt_personality *pers;
1992b0a2fdeeSScott Long 
1993c87e3f83SMatt Jacob 	MPT_PERS_FOREACH_REVERSE(mpt, pers) {
1994b0a2fdeeSScott Long 		pers->shutdown(mpt);
1995c87e3f83SMatt Jacob 	}
1996b0a2fdeeSScott Long 	return (0);
1997b0a2fdeeSScott Long }
1998b0a2fdeeSScott Long 
1999b0a2fdeeSScott Long int
2000b0a2fdeeSScott Long mpt_detach(struct mpt_softc *mpt)
2001b0a2fdeeSScott Long {
2002b0a2fdeeSScott Long 	struct mpt_personality *pers;
2003b0a2fdeeSScott Long 
2004b0a2fdeeSScott Long 	MPT_PERS_FOREACH_REVERSE(mpt, pers) {
2005b0a2fdeeSScott Long 		pers->detach(mpt);
2006b0a2fdeeSScott Long 		mpt->mpt_pers_mask &= ~(0x1 << pers->id);
2007b0a2fdeeSScott Long 		pers->use_count--;
2008b0a2fdeeSScott Long 	}
2009b0a2fdeeSScott Long 
2010b0a2fdeeSScott Long 	return (0);
2011b0a2fdeeSScott Long }
2012b0a2fdeeSScott Long 
2013b0a2fdeeSScott Long int
2014b0a2fdeeSScott Long mpt_core_load(struct mpt_personality *pers)
2015b0a2fdeeSScott Long {
2016b0a2fdeeSScott Long 	int i;
2017b0a2fdeeSScott Long 
2018b0a2fdeeSScott Long 	/*
2019b0a2fdeeSScott Long 	 * Setup core handlers and insert the default handler
2020b0a2fdeeSScott Long 	 * into all "empty slots".
2021b0a2fdeeSScott Long 	 */
2022c87e3f83SMatt Jacob 	for (i = 0; i < MPT_NUM_REPLY_HANDLERS; i++) {
2023b0a2fdeeSScott Long 		mpt_reply_handlers[i] = mpt_default_reply_handler;
2024c87e3f83SMatt Jacob 	}
2025b0a2fdeeSScott Long 
2026b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_EVENTS)] =
2027b0a2fdeeSScott Long 	    mpt_event_reply_handler;
2028b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_CONFIG)] =
2029b0a2fdeeSScott Long 	    mpt_config_reply_handler;
2030b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_HANDSHAKE)] =
2031b0a2fdeeSScott Long 	    mpt_handshake_reply_handler;
2032b0a2fdeeSScott Long 	return (0);
20339b631363SMatt Jacob }
20349b631363SMatt Jacob 
20359b631363SMatt Jacob /*
2036b0a2fdeeSScott Long  * Initialize per-instance driver data and perform
2037b0a2fdeeSScott Long  * initial controller configuration.
20389b631363SMatt Jacob  */
2039b0a2fdeeSScott Long int
2040b0a2fdeeSScott Long mpt_core_attach(struct mpt_softc *mpt)
2041b0a2fdeeSScott Long {
2042b0a2fdeeSScott Long         int val;
2043b0a2fdeeSScott Long 	int error;
2044b0a2fdeeSScott Long 
2045c87e3f83SMatt Jacob 
2046b0a2fdeeSScott Long 	LIST_INIT(&mpt->ack_frames);
2047b0a2fdeeSScott Long 
2048b0a2fdeeSScott Long 	/* Put all request buffers on the free list */
2049b0a2fdeeSScott Long 	TAILQ_INIT(&mpt->request_pending_list);
2050b0a2fdeeSScott Long 	TAILQ_INIT(&mpt->request_free_list);
20515e073106SMatt Jacob 	TAILQ_INIT(&mpt->request_timeout_list);
2052c87e3f83SMatt Jacob 	for (val = 0; val < MPT_MAX_REQUESTS(mpt); val++) {
20535e073106SMatt Jacob 		request_t *req = &mpt->request_pool[val];
20545e073106SMatt Jacob 		req->state = REQ_STATE_ALLOCATED;
20555e073106SMatt Jacob 		mpt_free_request(mpt, req);
2056c87e3f83SMatt Jacob 	}
2057c87e3f83SMatt Jacob 
2058c87e3f83SMatt Jacob 	for (val = 0; val < MPT_MAX_LUNS; val++) {
2059c87e3f83SMatt Jacob 		STAILQ_INIT(&mpt->trt[val].atios);
2060c87e3f83SMatt Jacob 		STAILQ_INIT(&mpt->trt[val].inots);
2061c87e3f83SMatt Jacob 	}
2062c87e3f83SMatt Jacob 	STAILQ_INIT(&mpt->trt_wildcard.atios);
2063c87e3f83SMatt Jacob 	STAILQ_INIT(&mpt->trt_wildcard.inots);
2064c87e3f83SMatt Jacob 
2065c87e3f83SMatt Jacob 	mpt->scsi_tgt_handler_id = MPT_HANDLER_ID_NONE;
2066b0a2fdeeSScott Long 
2067b0a2fdeeSScott Long 	mpt_sysctl_attach(mpt);
2068b0a2fdeeSScott Long 
2069b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "doorbell req = %s\n",
2070b0a2fdeeSScott Long 	    mpt_ioc_diag(mpt_read(mpt, MPT_OFFSET_DOORBELL)));
2071b0a2fdeeSScott Long 
2072b0a2fdeeSScott Long 	error = mpt_configure_ioc(mpt);
2073b0a2fdeeSScott Long 
2074b0a2fdeeSScott Long 	return (error);
20759b631363SMatt Jacob }
20769b631363SMatt Jacob 
2077c87e3f83SMatt Jacob int
2078c87e3f83SMatt Jacob mpt_core_enable(struct mpt_softc *mpt)
2079c87e3f83SMatt Jacob {
2080c87e3f83SMatt Jacob 	/*
2081c87e3f83SMatt Jacob 	 * We enter with the IOC enabled, but async events
2082c87e3f83SMatt Jacob 	 * not enabled, ports not enabled and interrupts
2083c87e3f83SMatt Jacob 	 * not enabled.
2084c87e3f83SMatt Jacob 	 */
2085c87e3f83SMatt Jacob 
2086c87e3f83SMatt Jacob 	/*
2087c87e3f83SMatt Jacob 	 * Enable asynchronous event reporting- all personalities
2088c87e3f83SMatt Jacob 	 * have attached so that they should be able to now field
2089c87e3f83SMatt Jacob 	 * async events.
2090c87e3f83SMatt Jacob 	 */
2091c87e3f83SMatt Jacob 	mpt_send_event_request(mpt, 1);
2092c87e3f83SMatt Jacob 
2093c87e3f83SMatt Jacob 	/*
2094c87e3f83SMatt Jacob 	 * Catch any pending interrupts
2095c87e3f83SMatt Jacob 	 *
2096c87e3f83SMatt Jacob 	 * This seems to be crucial- otherwise
2097c87e3f83SMatt Jacob 	 * the portenable below times out.
2098c87e3f83SMatt Jacob 	 */
2099c87e3f83SMatt Jacob 	mpt_intr(mpt);
2100c87e3f83SMatt Jacob 
2101c87e3f83SMatt Jacob 	/*
2102c87e3f83SMatt Jacob 	 * Enable Interrupts
2103c87e3f83SMatt Jacob 	 */
2104c87e3f83SMatt Jacob 	mpt_enable_ints(mpt);
2105c87e3f83SMatt Jacob 
2106c87e3f83SMatt Jacob 	/*
2107c87e3f83SMatt Jacob 	 * Catch any pending interrupts
2108c87e3f83SMatt Jacob 	 *
2109c87e3f83SMatt Jacob 	 * This seems to be crucial- otherwise
2110c87e3f83SMatt Jacob 	 * the portenable below times out.
2111c87e3f83SMatt Jacob 	 */
2112c87e3f83SMatt Jacob 	mpt_intr(mpt);
2113c87e3f83SMatt Jacob 
2114c87e3f83SMatt Jacob 	/*
21155089bd63SMatt Jacob 	 * Enable the port.
2116c87e3f83SMatt Jacob 	 */
2117c87e3f83SMatt Jacob 	if (mpt_send_port_enable(mpt, 0) != MPT_OK) {
2118c87e3f83SMatt Jacob 		mpt_prt(mpt, "failed to enable port 0\n");
2119c87e3f83SMatt Jacob 		return (ENXIO);
2120c87e3f83SMatt Jacob 	}
2121c87e3f83SMatt Jacob 	return (0);
2122c87e3f83SMatt Jacob }
2123c87e3f83SMatt Jacob 
2124b0a2fdeeSScott Long void
2125b0a2fdeeSScott Long mpt_core_shutdown(struct mpt_softc *mpt)
2126b0a2fdeeSScott Long {
2127c87e3f83SMatt Jacob 	mpt_disable_ints(mpt);
2128b0a2fdeeSScott Long }
2129b0a2fdeeSScott Long 
2130b0a2fdeeSScott Long void
2131b0a2fdeeSScott Long mpt_core_detach(struct mpt_softc *mpt)
2132b0a2fdeeSScott Long {
2133c87e3f83SMatt Jacob 	mpt_disable_ints(mpt);
2134b0a2fdeeSScott Long }
2135b0a2fdeeSScott Long 
2136b0a2fdeeSScott Long int
2137b0a2fdeeSScott Long mpt_core_unload(struct mpt_personality *pers)
2138b0a2fdeeSScott Long {
2139b0a2fdeeSScott Long 	/* Unload is always successfull. */
2140b0a2fdeeSScott Long 	return (0);
2141b0a2fdeeSScott Long }
2142b0a2fdeeSScott Long 
2143b0a2fdeeSScott Long #define FW_UPLOAD_REQ_SIZE				\
2144b0a2fdeeSScott Long 	(sizeof(MSG_FW_UPLOAD) - sizeof(SGE_MPI_UNION)	\
2145b0a2fdeeSScott Long        + sizeof(FW_UPLOAD_TCSGE) + sizeof(SGE_SIMPLE32))
2146b0a2fdeeSScott Long 
2147b0a2fdeeSScott Long static int
2148b0a2fdeeSScott Long mpt_upload_fw(struct mpt_softc *mpt)
2149b0a2fdeeSScott Long {
2150b0a2fdeeSScott Long 	uint8_t fw_req_buf[FW_UPLOAD_REQ_SIZE];
2151b0a2fdeeSScott Long 	MSG_FW_UPLOAD_REPLY fw_reply;
2152b0a2fdeeSScott Long 	MSG_FW_UPLOAD *fw_req;
2153b0a2fdeeSScott Long 	FW_UPLOAD_TCSGE *tsge;
2154b0a2fdeeSScott Long 	SGE_SIMPLE32 *sge;
2155b0a2fdeeSScott Long 	uint32_t flags;
2156b0a2fdeeSScott Long 	int error;
2157b0a2fdeeSScott Long 
2158b0a2fdeeSScott Long 	memset(&fw_req_buf, 0, sizeof(fw_req_buf));
2159b0a2fdeeSScott Long 	fw_req = (MSG_FW_UPLOAD *)fw_req_buf;
2160b0a2fdeeSScott Long 	fw_req->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
2161b0a2fdeeSScott Long 	fw_req->Function = MPI_FUNCTION_FW_UPLOAD;
2162b0a2fdeeSScott Long 	fw_req->MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
2163b0a2fdeeSScott Long 	tsge = (FW_UPLOAD_TCSGE *)&fw_req->SGL;
2164b0a2fdeeSScott Long 	tsge->DetailsLength = 12;
2165b0a2fdeeSScott Long 	tsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
2166b0a2fdeeSScott Long 	tsge->ImageSize = htole32(mpt->fw_image_size);
2167b0a2fdeeSScott Long 	sge = (SGE_SIMPLE32 *)(tsge + 1);
2168b0a2fdeeSScott Long 	flags = (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER
2169b0a2fdeeSScott Long 	      | MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_SIMPLE_ELEMENT
2170b0a2fdeeSScott Long 	      | MPI_SGE_FLAGS_32_BIT_ADDRESSING | MPI_SGE_FLAGS_IOC_TO_HOST);
2171b0a2fdeeSScott Long 	flags <<= MPI_SGE_FLAGS_SHIFT;
2172b0a2fdeeSScott Long 	sge->FlagsLength = htole32(flags | mpt->fw_image_size);
2173b0a2fdeeSScott Long 	sge->Address = htole32(mpt->fw_phys);
2174b0a2fdeeSScott Long 	error = mpt_send_handshake_cmd(mpt, sizeof(fw_req_buf), &fw_req_buf);
2175b0a2fdeeSScott Long 	if (error)
2176b0a2fdeeSScott Long 		return(error);
2177b0a2fdeeSScott Long 	error = mpt_recv_handshake_reply(mpt, sizeof(fw_reply), &fw_reply);
2178b0a2fdeeSScott Long 	return (error);
2179b0a2fdeeSScott Long }
2180b0a2fdeeSScott Long 
2181b0a2fdeeSScott Long static void
2182b0a2fdeeSScott Long mpt_diag_outsl(struct mpt_softc *mpt, uint32_t addr,
2183b0a2fdeeSScott Long 	       uint32_t *data, bus_size_t len)
2184b0a2fdeeSScott Long {
2185b0a2fdeeSScott Long 	uint32_t *data_end;
2186b0a2fdeeSScott Long 
2187b0a2fdeeSScott Long 	data_end = data + (roundup2(len, sizeof(uint32_t)) / 4);
2188444dd2b6SMatt Jacob 	pci_enable_io(mpt->dev, SYS_RES_IOPORT);
2189b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, addr);
2190b0a2fdeeSScott Long 	while (data != data_end) {
2191b0a2fdeeSScott Long 		mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, *data);
2192b0a2fdeeSScott Long 		data++;
2193b0a2fdeeSScott Long 	}
2194444dd2b6SMatt Jacob 	pci_disable_io(mpt->dev, SYS_RES_IOPORT);
2195b0a2fdeeSScott Long }
2196b0a2fdeeSScott Long 
2197b0a2fdeeSScott Long static int
2198b0a2fdeeSScott Long mpt_download_fw(struct mpt_softc *mpt)
2199b0a2fdeeSScott Long {
2200b0a2fdeeSScott Long 	MpiFwHeader_t *fw_hdr;
2201b0a2fdeeSScott Long 	int error;
2202b0a2fdeeSScott Long 	uint32_t ext_offset;
2203b0a2fdeeSScott Long 	uint32_t data;
2204b0a2fdeeSScott Long 
2205b0a2fdeeSScott Long 	mpt_prt(mpt, "Downloading Firmware - Image Size %d\n",
2206b0a2fdeeSScott Long 		mpt->fw_image_size);
2207b0a2fdeeSScott Long 
2208b0a2fdeeSScott Long 	error = mpt_enable_diag_mode(mpt);
2209b0a2fdeeSScott Long 	if (error != 0) {
2210b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not enter diagnostic mode!\n");
2211b0a2fdeeSScott Long 		return (EIO);
2212b0a2fdeeSScott Long 	}
2213b0a2fdeeSScott Long 
2214b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC,
2215b0a2fdeeSScott Long 		  MPI_DIAG_RW_ENABLE|MPI_DIAG_DISABLE_ARM);
2216b0a2fdeeSScott Long 
2217b0a2fdeeSScott Long 	fw_hdr = (MpiFwHeader_t *)mpt->fw_image;
2218b0a2fdeeSScott Long 	mpt_diag_outsl(mpt, fw_hdr->LoadStartAddress, (uint32_t*)fw_hdr,
2219b0a2fdeeSScott Long 		       fw_hdr->ImageSize);
2220b0a2fdeeSScott Long 
2221b0a2fdeeSScott Long 	ext_offset = fw_hdr->NextImageHeaderOffset;
2222b0a2fdeeSScott Long 	while (ext_offset != 0) {
2223b0a2fdeeSScott Long 		MpiExtImageHeader_t *ext;
2224b0a2fdeeSScott Long 
2225b0a2fdeeSScott Long 		ext = (MpiExtImageHeader_t *)((uintptr_t)fw_hdr + ext_offset);
2226b0a2fdeeSScott Long 		ext_offset = ext->NextImageHeaderOffset;
2227b0a2fdeeSScott Long 
2228b0a2fdeeSScott Long 		mpt_diag_outsl(mpt, ext->LoadStartAddress, (uint32_t*)ext,
2229b0a2fdeeSScott Long 			       ext->ImageSize);
2230b0a2fdeeSScott Long 	}
2231b0a2fdeeSScott Long 
2232444dd2b6SMatt Jacob 	pci_enable_io(mpt->dev, SYS_RES_IOPORT);
2233b0a2fdeeSScott Long 	/* Setup the address to jump to on reset. */
2234b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, fw_hdr->IopResetRegAddr);
2235b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, fw_hdr->IopResetVectorValue);
2236b0a2fdeeSScott Long 
2237b0a2fdeeSScott Long 	/*
2238b0a2fdeeSScott Long 	 * The controller sets the "flash bad" status after attempting
2239b0a2fdeeSScott Long 	 * to auto-boot from flash.  Clear the status so that the controller
2240b0a2fdeeSScott Long 	 * will continue the boot process with our newly installed firmware.
2241b0a2fdeeSScott Long 	 */
2242b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE);
2243b0a2fdeeSScott Long 	data = mpt_pio_read(mpt, MPT_OFFSET_DIAG_DATA) | MPT_DIAG_MEM_CFG_BADFL;
2244b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE);
2245b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, data);
2246b0a2fdeeSScott Long 
2247444dd2b6SMatt Jacob 	pci_disable_io(mpt->dev, SYS_RES_IOPORT);
2248444dd2b6SMatt Jacob 
2249b0a2fdeeSScott Long 	/*
2250b0a2fdeeSScott Long 	 * Re-enable the processor and clear the boot halt flag.
2251b0a2fdeeSScott Long 	 */
2252b0a2fdeeSScott Long 	data = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
2253b0a2fdeeSScott Long 	data &= ~(MPI_DIAG_PREVENT_IOC_BOOT|MPI_DIAG_DISABLE_ARM);
2254b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, data);
2255b0a2fdeeSScott Long 
2256b0a2fdeeSScott Long 	mpt_disable_diag_mode(mpt);
2257b0a2fdeeSScott Long 	return (0);
2258b0a2fdeeSScott Long }
2259b0a2fdeeSScott Long 
2260b0a2fdeeSScott Long /*
2261b0a2fdeeSScott Long  * Allocate/Initialize data structures for the controller.  Called
2262b0a2fdeeSScott Long  * once at instance startup.
2263b0a2fdeeSScott Long  */
2264b0a2fdeeSScott Long static int
2265b0a2fdeeSScott Long mpt_configure_ioc(struct mpt_softc *mpt)
2266b0a2fdeeSScott Long {
2267b0a2fdeeSScott Long         MSG_PORT_FACTS_REPLY pfp;
2268b0a2fdeeSScott Long         MSG_IOC_FACTS_REPLY facts;
2269b0a2fdeeSScott Long 	int try;
2270b0a2fdeeSScott Long 	int needreset;
2271444dd2b6SMatt Jacob 	uint32_t max_chain_depth;
2272b0a2fdeeSScott Long 
2273b0a2fdeeSScott Long 	needreset = 0;
22749b631363SMatt Jacob 	for (try = 0; try < MPT_MAX_TRYS; try++) {
2275b0a2fdeeSScott Long 
22769b631363SMatt Jacob 		/*
22779b631363SMatt Jacob 		 * No need to reset if the IOC is already in the READY state.
22789b631363SMatt Jacob 		 *
22799b631363SMatt Jacob 		 * Force reset if initialization failed previously.
22809b631363SMatt Jacob 		 * Note that a hard_reset of the second channel of a '929
22819b631363SMatt Jacob 		 * will stop operation of the first channel.  Hopefully, if the
22829b631363SMatt Jacob 		 * first channel is ok, the second will not require a hard
22839b631363SMatt Jacob 		 * reset.
22849b631363SMatt Jacob 		 */
2285c87e3f83SMatt Jacob 		if (needreset || MPT_STATE(mpt_rd_db(mpt)) !=
22869b631363SMatt Jacob 		    MPT_DB_STATE_READY) {
2287c87e3f83SMatt Jacob 			if (mpt_reset(mpt, FALSE) != MPT_OK) {
22889b631363SMatt Jacob 				continue;
22899b631363SMatt Jacob 			}
2290c87e3f83SMatt Jacob 		}
2291b0a2fdeeSScott Long 		needreset = 0;
22929b631363SMatt Jacob 
22939b631363SMatt Jacob 		if (mpt_get_iocfacts(mpt, &facts) != MPT_OK) {
2294b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_get_iocfacts failed\n");
2295b0a2fdeeSScott Long 			needreset = 1;
22969b631363SMatt Jacob 			continue;
22977104aeefSMatt Jacob 		}
22987104aeefSMatt Jacob 
2299b0a2fdeeSScott Long 		mpt->mpt_global_credits = le16toh(facts.GlobalCredits);
2300b0a2fdeeSScott Long 		mpt->request_frame_size = le16toh(facts.RequestFrameSize);
2301444dd2b6SMatt Jacob 		mpt->ioc_facts_flags = facts.Flags;
2302b0a2fdeeSScott Long 		mpt_prt(mpt, "MPI Version=%d.%d.%d.%d\n",
2303b0a2fdeeSScott Long 			    le16toh(facts.MsgVersion) >> 8,
2304b0a2fdeeSScott Long 			    le16toh(facts.MsgVersion) & 0xFF,
2305b0a2fdeeSScott Long 			    le16toh(facts.HeaderVersion) >> 8,
2306b0a2fdeeSScott Long 			    le16toh(facts.HeaderVersion) & 0xFF);
2307444dd2b6SMatt Jacob 
2308444dd2b6SMatt Jacob 		/*
2309444dd2b6SMatt Jacob 		 * Now that we know request frame size, we can calculate
2310444dd2b6SMatt Jacob 		 * the actual (reasonable) segment limit for read/write I/O.
2311444dd2b6SMatt Jacob 		 *
2312444dd2b6SMatt Jacob 		 * This limit is constrained by:
2313444dd2b6SMatt Jacob 		 *
2314444dd2b6SMatt Jacob 		 *  + The size of each area we allocate per command (and how
2315444dd2b6SMatt Jacob                  *    many chain segments we can fit into it).
2316444dd2b6SMatt Jacob                  *  + The total number of areas we've set up.
2317444dd2b6SMatt Jacob 		 *  + The actual chain depth the card will allow.
2318444dd2b6SMatt Jacob 		 *
2319444dd2b6SMatt Jacob 		 * The first area's segment count is limited by the I/O request
2320444dd2b6SMatt Jacob 		 * at the head of it. We cannot allocate realistically more
2321444dd2b6SMatt Jacob 		 * than MPT_MAX_REQUESTS areas. Therefore, to account for both
2322444dd2b6SMatt Jacob 		 * conditions, we'll just start out with MPT_MAX_REQUESTS-2.
2323444dd2b6SMatt Jacob 		 *
2324444dd2b6SMatt Jacob 		 */
2325444dd2b6SMatt Jacob 		max_chain_depth = facts.MaxChainDepth;
2326444dd2b6SMatt Jacob 
2327444dd2b6SMatt Jacob 		/* total number of request areas we (can) allocate */
2328444dd2b6SMatt Jacob 		mpt->max_seg_cnt = MPT_MAX_REQUESTS(mpt) - 2;
2329444dd2b6SMatt Jacob 
2330444dd2b6SMatt Jacob 		/* converted to the number of chain areas possible */
2331444dd2b6SMatt Jacob 		mpt->max_seg_cnt *= MPT_NRFM(mpt);
2332444dd2b6SMatt Jacob 
2333444dd2b6SMatt Jacob 		/* limited by the number of chain areas the card will support */
2334444dd2b6SMatt Jacob 		if (mpt->max_seg_cnt > max_chain_depth) {
2335444dd2b6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_DEBUG,
2336444dd2b6SMatt Jacob 			    "chain depth limited to %u (from %u)\n",
2337444dd2b6SMatt Jacob 			    max_chain_depth, mpt->max_seg_cnt);
2338444dd2b6SMatt Jacob 			mpt->max_seg_cnt = max_chain_depth;
2339444dd2b6SMatt Jacob 		}
2340444dd2b6SMatt Jacob 
2341444dd2b6SMatt Jacob 		/* converted to the number of simple sges in chain segments. */
2342444dd2b6SMatt Jacob 		mpt->max_seg_cnt *= (MPT_NSGL(mpt) - 1);
2343444dd2b6SMatt Jacob 
2344444dd2b6SMatt Jacob 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2345444dd2b6SMatt Jacob 		    "Maximum Segment Count: %u\n", mpt->max_seg_cnt);
2346b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2347b0a2fdeeSScott Long 			 "MsgLength=%u IOCNumber = %d\n",
2348b0a2fdeeSScott Long 			 facts.MsgLength, facts.IOCNumber);
2349b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2350444dd2b6SMatt Jacob 			 "IOCFACTS: GlobalCredits=%d BlockSize=%u bytes "
2351444dd2b6SMatt Jacob 			 "Request Frame Size %u bytes Max Chain Depth %u\n",
2352444dd2b6SMatt Jacob                          mpt->mpt_global_credits, facts.BlockSize,
2353444dd2b6SMatt Jacob                          mpt->request_frame_size << 2, max_chain_depth);
2354b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2355b0a2fdeeSScott Long 			 "IOCFACTS: Num Ports %d, FWImageSize %d, "
2356b0a2fdeeSScott Long 			 "Flags=%#x\n", facts.NumberOfPorts,
2357b0a2fdeeSScott Long 			 le32toh(facts.FWImageSize), facts.Flags);
2358b0a2fdeeSScott Long 
2359444dd2b6SMatt Jacob 
2360b0a2fdeeSScott Long 		if ((facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT) != 0) {
2361b0a2fdeeSScott Long 			struct mpt_map_info mi;
2362b0a2fdeeSScott Long 			int error;
2363b0a2fdeeSScott Long 
2364b0a2fdeeSScott Long 			/*
2365b0a2fdeeSScott Long 			 * In some configurations, the IOC's firmware is
2366b0a2fdeeSScott Long 			 * stored in a shared piece of system NVRAM that
2367b0a2fdeeSScott Long 			 * is only accessable via the BIOS.  In this
2368b0a2fdeeSScott Long 			 * case, the firmware keeps a copy of firmware in
2369b0a2fdeeSScott Long 			 * RAM until the OS driver retrieves it.  Once
2370b0a2fdeeSScott Long 			 * retrieved, we are responsible for re-downloading
2371b0a2fdeeSScott Long 			 * the firmware after any hard-reset.
2372b0a2fdeeSScott Long 			 */
2373b0a2fdeeSScott Long 			mpt->fw_image_size = le32toh(facts.FWImageSize);
2374b0a2fdeeSScott Long 			error = mpt_dma_tag_create(mpt, mpt->parent_dmat,
2375b0a2fdeeSScott Long 			    /*alignment*/1, /*boundary*/0,
2376b0a2fdeeSScott Long 			    /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2377b0a2fdeeSScott Long 			    /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL,
2378b0a2fdeeSScott Long 			    /*filterarg*/NULL, mpt->fw_image_size,
2379b0a2fdeeSScott Long 			    /*nsegments*/1, /*maxsegsz*/mpt->fw_image_size,
2380b0a2fdeeSScott Long 			    /*flags*/0, &mpt->fw_dmat);
2381b0a2fdeeSScott Long 			if (error != 0) {
2382b0a2fdeeSScott Long 				mpt_prt(mpt, "cannot create fw dma tag\n");
2383b0a2fdeeSScott Long 				return (ENOMEM);
23849b631363SMatt Jacob 			}
2385b0a2fdeeSScott Long 			error = bus_dmamem_alloc(mpt->fw_dmat,
2386b0a2fdeeSScott Long 			    (void **)&mpt->fw_image, BUS_DMA_NOWAIT,
2387b0a2fdeeSScott Long 			    &mpt->fw_dmap);
2388b0a2fdeeSScott Long 			if (error != 0) {
2389b0a2fdeeSScott Long 				mpt_prt(mpt, "cannot allocate fw mem.\n");
2390b0a2fdeeSScott Long 				bus_dma_tag_destroy(mpt->fw_dmat);
2391b0a2fdeeSScott Long 				return (ENOMEM);
2392b0a2fdeeSScott Long 			}
2393b0a2fdeeSScott Long 			mi.mpt = mpt;
2394b0a2fdeeSScott Long 			mi.error = 0;
2395b0a2fdeeSScott Long 			bus_dmamap_load(mpt->fw_dmat, mpt->fw_dmap,
2396b0a2fdeeSScott Long 			    mpt->fw_image, mpt->fw_image_size, mpt_map_rquest,
2397b0a2fdeeSScott Long 			    &mi, 0);
2398b0a2fdeeSScott Long 			mpt->fw_phys = mi.phys;
2399b0a2fdeeSScott Long 
2400b0a2fdeeSScott Long 			error = mpt_upload_fw(mpt);
2401b0a2fdeeSScott Long 			if (error != 0) {
2402b0a2fdeeSScott Long 				mpt_prt(mpt, "fw upload failed.\n");
2403b0a2fdeeSScott Long 				bus_dmamap_unload(mpt->fw_dmat, mpt->fw_dmap);
2404b0a2fdeeSScott Long 				bus_dmamem_free(mpt->fw_dmat, mpt->fw_image,
2405b0a2fdeeSScott Long 				    mpt->fw_dmap);
2406b0a2fdeeSScott Long 				bus_dma_tag_destroy(mpt->fw_dmat);
2407b0a2fdeeSScott Long 				mpt->fw_image = NULL;
2408b0a2fdeeSScott Long 				return (EIO);
2409b0a2fdeeSScott Long 			}
2410b0a2fdeeSScott Long 		}
24119b631363SMatt Jacob 
24127104aeefSMatt Jacob 		if (mpt_get_portfacts(mpt, &pfp) != MPT_OK) {
2413b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_get_portfacts failed\n");
2414b0a2fdeeSScott Long 			needreset = 1;
24157104aeefSMatt Jacob 			continue;
24167104aeefSMatt Jacob 		}
24177104aeefSMatt Jacob 
2418b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
24197dec90bcSMatt Jacob 			 "PORTFACTS: Type %x PFlags %x IID %d MaxDev %d\n",
24207dec90bcSMatt Jacob 			 pfp.PortType, pfp.ProtocolFlags, pfp.PortSCSIID,
24217dec90bcSMatt Jacob 			 pfp.MaxDevices);
24227104aeefSMatt Jacob 
2423b0a2fdeeSScott Long 		mpt->mpt_port_type = pfp.PortType;
2424b0a2fdeeSScott Long 		mpt->mpt_proto_flags = pfp.ProtocolFlags;
24257104aeefSMatt Jacob 		if (pfp.PortType != MPI_PORTFACTS_PORTTYPE_SCSI &&
2426444dd2b6SMatt Jacob 		    pfp.PortType != MPI_PORTFACTS_PORTTYPE_SAS &&
24277104aeefSMatt Jacob 		    pfp.PortType != MPI_PORTFACTS_PORTTYPE_FC) {
2428b0a2fdeeSScott Long 			mpt_prt(mpt, "Unsupported Port Type (%x)\n",
24297104aeefSMatt Jacob 			    pfp.PortType);
24307104aeefSMatt Jacob 			return (ENXIO);
24317104aeefSMatt Jacob 		}
2432c87e3f83SMatt Jacob 		mpt->mpt_max_tgtcmds = le16toh(pfp.MaxPostedCmdBuffers);
2433c87e3f83SMatt Jacob 
24347104aeefSMatt Jacob 		if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_FC) {
24357104aeefSMatt Jacob 			mpt->is_fc = 1;
2436444dd2b6SMatt Jacob 			mpt->is_sas = 0;
2437444dd2b6SMatt Jacob 		} else if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_SAS) {
2438444dd2b6SMatt Jacob 			mpt->is_fc = 0;
2439444dd2b6SMatt Jacob 			mpt->is_sas = 1;
24407104aeefSMatt Jacob 		} else {
24417104aeefSMatt Jacob 			mpt->is_fc = 0;
2442444dd2b6SMatt Jacob 			mpt->is_sas = 0;
24437104aeefSMatt Jacob 		}
24447104aeefSMatt Jacob 		mpt->mpt_ini_id = pfp.PortSCSIID;
2445444dd2b6SMatt Jacob 		mpt->mpt_max_devices = pfp.MaxDevices;
24467104aeefSMatt Jacob 
2447c87e3f83SMatt Jacob 		/*
24485089bd63SMatt Jacob 		 * Set our expected role with what this port supports.
2449c87e3f83SMatt Jacob 		 */
2450c87e3f83SMatt Jacob 
24515089bd63SMatt Jacob 		mpt->role = MPT_ROLE_NONE;
2452c87e3f83SMatt Jacob 		if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
24535089bd63SMatt Jacob 			mpt->role |= MPT_ROLE_INITIATOR;
2454c87e3f83SMatt Jacob 		}
2455c87e3f83SMatt Jacob 		if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
24565089bd63SMatt Jacob 			mpt->role |= MPT_ROLE_TARGET;
2457c87e3f83SMatt Jacob 		}
24585089bd63SMatt Jacob 		if (mpt->role == MPT_ROLE_NONE) {
2459c87e3f83SMatt Jacob 			mpt_prt(mpt, "port does not support either target or "
2460c87e3f83SMatt Jacob 			    "initiator role\n");
2461c87e3f83SMatt Jacob 			return (ENXIO);
2462c87e3f83SMatt Jacob 		}
2463c87e3f83SMatt Jacob 
2464c87e3f83SMatt Jacob 		if (mpt_enable_ioc(mpt, 0) != MPT_OK) {
2465c87e3f83SMatt Jacob 			mpt_prt(mpt, "unable to initialize IOC\n");
2466b0a2fdeeSScott Long 			return (ENXIO);
24677104aeefSMatt Jacob 		}
24687104aeefSMatt Jacob 
2469b0a2fdeeSScott Long 		/*
2470c87e3f83SMatt Jacob 		 * Read IOC configuration information.
24711d79ca0eSMatt Jacob 		 *
24721d79ca0eSMatt Jacob 		 * We need this to determine whether or not we have certain
24731d79ca0eSMatt Jacob 		 * settings for Integrated Mirroring (e.g.).
2474b0a2fdeeSScott Long 		 */
2475b0a2fdeeSScott Long 		mpt_read_config_info_ioc(mpt);
2476b0a2fdeeSScott Long 
2477b0a2fdeeSScott Long 		/* Everything worked */
2478b0a2fdeeSScott Long 		break;
2479b0a2fdeeSScott Long 	}
2480b0a2fdeeSScott Long 
2481b0a2fdeeSScott Long 	if (try >= MPT_MAX_TRYS) {
2482b0a2fdeeSScott Long 		mpt_prt(mpt, "failed to initialize IOC");
2483b0a2fdeeSScott Long 		return (EIO);
2484b0a2fdeeSScott Long 	}
2485b0a2fdeeSScott Long 
2486b0a2fdeeSScott Long 	return (0);
2487b0a2fdeeSScott Long }
2488b0a2fdeeSScott Long 
2489b0a2fdeeSScott Long static int
2490c87e3f83SMatt Jacob mpt_enable_ioc(struct mpt_softc *mpt, int portenable)
2491b0a2fdeeSScott Long {
2492b0a2fdeeSScott Long 	uint32_t pptr;
2493b0a2fdeeSScott Long 	int val;
2494b0a2fdeeSScott Long 
2495444dd2b6SMatt Jacob 	if (mpt_send_ioc_init(mpt, MPI_WHOINIT_HOST_DRIVER) != MPT_OK) {
2496b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_ioc_init failed\n");
2497b0a2fdeeSScott Long 		return (EIO);
2498b0a2fdeeSScott Long 	}
2499b0a2fdeeSScott Long 
2500b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_send_ioc_init ok\n");
25019b631363SMatt Jacob 
25029b631363SMatt Jacob 	if (mpt_wait_state(mpt, MPT_DB_STATE_RUNNING) != MPT_OK) {
2503b0a2fdeeSScott Long 		mpt_prt(mpt, "IOC failed to go to run state\n");
2504b0a2fdeeSScott Long 		return (ENXIO);
25057104aeefSMatt Jacob 	}
2506444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC now at RUNSTATE\n");
25079b631363SMatt Jacob 
25089b631363SMatt Jacob 	/*
25099b631363SMatt Jacob 	 * Give it reply buffers
25109b631363SMatt Jacob 	 *
2511b0a2fdeeSScott Long 	 * Do *not* exceed global credits.
25129b631363SMatt Jacob 	 */
25139b631363SMatt Jacob 	for (val = 0, pptr = mpt->reply_phys;
25149b631363SMatt Jacob 	    (pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE);
25159b631363SMatt Jacob 	     pptr += MPT_REPLY_SIZE) {
25169b631363SMatt Jacob 		mpt_free_reply(mpt, pptr);
25179b631363SMatt Jacob 		if (++val == mpt->mpt_global_credits - 1)
25189b631363SMatt Jacob 			break;
25199b631363SMatt Jacob 	}
25209b631363SMatt Jacob 
2521c87e3f83SMatt Jacob 
2522c87e3f83SMatt Jacob 	/*
25235e073106SMatt Jacob 	 * Enable the port if asked. This is only done if we're resetting
25245e073106SMatt Jacob 	 * the IOC after initial startup.
2525c87e3f83SMatt Jacob 	 */
2526c87e3f83SMatt Jacob 	if (portenable) {
25277104aeefSMatt Jacob 		/*
25287104aeefSMatt Jacob 		 * Enable asynchronous event reporting
25297104aeefSMatt Jacob 		 */
25309b631363SMatt Jacob 		mpt_send_event_request(mpt, 1);
25319b631363SMatt Jacob 
25329b631363SMatt Jacob 		if (mpt_send_port_enable(mpt, 0) != MPT_OK) {
2533b0a2fdeeSScott Long 			mpt_prt(mpt, "failed to enable port 0\n");
2534b0a2fdeeSScott Long 			return (ENXIO);
25357104aeefSMatt Jacob 		}
2536c87e3f83SMatt Jacob 	}
253729ae59edSMatt Jacob 	return (MPT_OK);
25389b631363SMatt Jacob }
2539