xref: /freebsd/sys/dev/mpt/mpt.c (revision b4c618c099443efcc9c2d8ffd4eb115009aa4329)
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.
60ec5fe39dSMatt Jacob  *
61ec5fe39dSMatt Jacob  *
62ec5fe39dSMatt Jacob  * Support from LSI-Logic has also gone a great deal toward making this a
63ec5fe39dSMatt Jacob  * workable subsystem and is gratefully acknowledged.
640b80d21bSMatt Jacob  */
650b80d21bSMatt Jacob /*-
66b0a2fdeeSScott Long  * Copyright (c) 2004, Avid Technology, Inc. and its contributors.
67b0a2fdeeSScott Long  * Copyright (c) 2005, WHEEL Sp. z o.o.
68b0a2fdeeSScott Long  * Copyright (c) 2004, 2005 Justin T. Gibbs
69b0a2fdeeSScott Long  * All rights reserved.
70b0a2fdeeSScott Long  *
71b0a2fdeeSScott Long  * Redistribution and use in source and binary forms, with or without
72b0a2fdeeSScott Long  * modification, are permitted provided that the following conditions are
73b0a2fdeeSScott Long  * met:
74b0a2fdeeSScott Long  * 1. Redistributions of source code must retain the above copyright
75b0a2fdeeSScott Long  *    notice, this list of conditions and the following disclaimer.
76b0a2fdeeSScott Long  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
77b0a2fdeeSScott Long  *    substantially similar to the "NO WARRANTY" disclaimer below
78b0a2fdeeSScott Long  *    ("Disclaimer") and any redistribution must be conditioned upon including
79b0a2fdeeSScott Long  *    a substantially similar Disclaimer requirement for further binary
80b0a2fdeeSScott Long  *    redistribution.
81286e947fSJustin T. Gibbs  * 3. Neither the names of the above listed copyright holders nor the names
82286e947fSJustin T. Gibbs  *    of any contributors may be used to endorse or promote products derived
83286e947fSJustin T. Gibbs  *    from this software without specific prior written permission.
84b0a2fdeeSScott Long  *
85b0a2fdeeSScott Long  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
86b0a2fdeeSScott Long  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
87b0a2fdeeSScott Long  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
88b0a2fdeeSScott Long  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
89b0a2fdeeSScott Long  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
90b0a2fdeeSScott Long  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
91b0a2fdeeSScott Long  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
92b0a2fdeeSScott Long  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
93b0a2fdeeSScott Long  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
94b0a2fdeeSScott Long  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT
95b0a2fdeeSScott Long  * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
969b631363SMatt Jacob  */
979b631363SMatt Jacob 
989295c6c5SDavid E. O'Brien #include <sys/cdefs.h>
999295c6c5SDavid E. O'Brien __FBSDID("$FreeBSD$");
1009295c6c5SDavid E. O'Brien 
101b0a2fdeeSScott Long #include <dev/mpt/mpt.h>
102b0a2fdeeSScott Long #include <dev/mpt/mpt_cam.h> /* XXX For static handler registration */
103b0a2fdeeSScott Long #include <dev/mpt/mpt_raid.h> /* XXX For static handler registration */
104b0a2fdeeSScott Long 
105b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi.h>
106b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi_ioc.h>
107c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_fc.h>
108c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_targ.h>
109b0a2fdeeSScott Long 
110b0a2fdeeSScott Long #include <sys/sysctl.h>
1117104aeefSMatt Jacob 
1129b631363SMatt Jacob #define MPT_MAX_TRYS 3
1139b631363SMatt Jacob #define MPT_MAX_WAIT 300000
1149b631363SMatt Jacob 
1159b631363SMatt Jacob static int maxwait_ack = 0;
1169b631363SMatt Jacob static int maxwait_int = 0;
1179b631363SMatt Jacob static int maxwait_state = 0;
1189b631363SMatt Jacob 
119b0a2fdeeSScott Long TAILQ_HEAD(, mpt_softc)	mpt_tailq = TAILQ_HEAD_INITIALIZER(mpt_tailq);
120b0a2fdeeSScott Long mpt_reply_handler_t *mpt_reply_handlers[MPT_NUM_REPLY_HANDLERS];
1219b631363SMatt Jacob 
122b0a2fdeeSScott Long static mpt_reply_handler_t mpt_default_reply_handler;
123b0a2fdeeSScott Long static mpt_reply_handler_t mpt_config_reply_handler;
124b0a2fdeeSScott Long static mpt_reply_handler_t mpt_handshake_reply_handler;
125b0a2fdeeSScott Long static mpt_reply_handler_t mpt_event_reply_handler;
126b0a2fdeeSScott Long static void mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req,
127b0a2fdeeSScott Long 			       MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context);
128444dd2b6SMatt Jacob static int mpt_send_event_request(struct mpt_softc *mpt, int onoff);
129b0a2fdeeSScott Long static int mpt_soft_reset(struct mpt_softc *mpt);
130b0a2fdeeSScott Long static void mpt_hard_reset(struct mpt_softc *mpt);
131b0a2fdeeSScott Long static int mpt_configure_ioc(struct mpt_softc *mpt);
132c87e3f83SMatt Jacob static int mpt_enable_ioc(struct mpt_softc *mpt, int);
133b0a2fdeeSScott Long 
134b0a2fdeeSScott Long /************************* Personality Module Support *************************/
135b0a2fdeeSScott Long /*
136b0a2fdeeSScott Long  * We include one extra entry that is guaranteed to be NULL
137b0a2fdeeSScott Long  * to simplify our itterator.
138b0a2fdeeSScott Long  */
139b0a2fdeeSScott Long static struct mpt_personality *mpt_personalities[MPT_MAX_PERSONALITIES + 1];
140b0a2fdeeSScott Long static __inline struct mpt_personality*
141b0a2fdeeSScott Long 	mpt_pers_find(struct mpt_softc *, u_int);
142b0a2fdeeSScott Long static __inline struct mpt_personality*
143b0a2fdeeSScott Long 	mpt_pers_find_reverse(struct mpt_softc *, u_int);
144b0a2fdeeSScott Long 
145b0a2fdeeSScott Long static __inline struct mpt_personality *
146b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *mpt, u_int start_at)
147b0a2fdeeSScott Long {
148b0a2fdeeSScott Long 	KASSERT(start_at <= MPT_MAX_PERSONALITIES,
149b0a2fdeeSScott Long 		("mpt_pers_find: starting position out of range\n"));
150b0a2fdeeSScott Long 
151b0a2fdeeSScott Long 	while (start_at < MPT_MAX_PERSONALITIES
152b0a2fdeeSScott Long 	    && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) {
153b0a2fdeeSScott Long 		start_at++;
154b0a2fdeeSScott Long 	}
155b0a2fdeeSScott Long 	return (mpt_personalities[start_at]);
156b0a2fdeeSScott Long }
157b0a2fdeeSScott Long 
158b0a2fdeeSScott Long /*
159c87e3f83SMatt Jacob  * Used infrequently, so no need to optimize like a forward
160b0a2fdeeSScott Long  * traversal where we use the MAX+1 is guaranteed to be NULL
161b0a2fdeeSScott Long  * trick.
162b0a2fdeeSScott Long  */
163b0a2fdeeSScott Long static __inline struct mpt_personality *
164b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *mpt, u_int start_at)
165b0a2fdeeSScott Long {
166b0a2fdeeSScott Long 	while (start_at < MPT_MAX_PERSONALITIES
167b0a2fdeeSScott Long 	    && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) {
168b0a2fdeeSScott Long 		start_at--;
169b0a2fdeeSScott Long 	}
170b0a2fdeeSScott Long 	if (start_at < MPT_MAX_PERSONALITIES)
171b0a2fdeeSScott Long 		return (mpt_personalities[start_at]);
172b0a2fdeeSScott Long 	return (NULL);
173b0a2fdeeSScott Long }
174b0a2fdeeSScott Long 
175b0a2fdeeSScott Long #define MPT_PERS_FOREACH(mpt, pers)				\
176b0a2fdeeSScott Long 	for (pers = mpt_pers_find(mpt, /*start_at*/0);		\
177b0a2fdeeSScott Long 	     pers != NULL;					\
178b0a2fdeeSScott Long 	     pers = mpt_pers_find(mpt, /*start_at*/pers->id+1))
179b0a2fdeeSScott Long 
180b0a2fdeeSScott Long #define MPT_PERS_FOREACH_REVERSE(mpt, pers)				\
181b0a2fdeeSScott Long 	for (pers = mpt_pers_find_reverse(mpt, MPT_MAX_PERSONALITIES-1);\
182b0a2fdeeSScott Long 	     pers != NULL;						\
183b0a2fdeeSScott Long 	     pers = mpt_pers_find_reverse(mpt, /*start_at*/pers->id-1))
184b0a2fdeeSScott Long 
185b0a2fdeeSScott Long static mpt_load_handler_t      mpt_stdload;
186b0a2fdeeSScott Long static mpt_probe_handler_t     mpt_stdprobe;
187b0a2fdeeSScott Long static mpt_attach_handler_t    mpt_stdattach;
188c87e3f83SMatt Jacob static mpt_enable_handler_t    mpt_stdenable;
189b0a2fdeeSScott Long static mpt_event_handler_t     mpt_stdevent;
190b0a2fdeeSScott Long static mpt_reset_handler_t     mpt_stdreset;
191b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_stdshutdown;
192b0a2fdeeSScott Long static mpt_detach_handler_t    mpt_stddetach;
193b0a2fdeeSScott Long static mpt_unload_handler_t    mpt_stdunload;
194b0a2fdeeSScott Long static struct mpt_personality mpt_default_personality =
195b0a2fdeeSScott Long {
196b0a2fdeeSScott Long 	.load		= mpt_stdload,
197b0a2fdeeSScott Long 	.probe		= mpt_stdprobe,
198b0a2fdeeSScott Long 	.attach		= mpt_stdattach,
199c87e3f83SMatt Jacob 	.enable		= mpt_stdenable,
200b0a2fdeeSScott Long 	.event		= mpt_stdevent,
201b0a2fdeeSScott Long 	.reset		= mpt_stdreset,
202b0a2fdeeSScott Long 	.shutdown	= mpt_stdshutdown,
203b0a2fdeeSScott Long 	.detach		= mpt_stddetach,
204b0a2fdeeSScott Long 	.unload		= mpt_stdunload
205b0a2fdeeSScott Long };
206b0a2fdeeSScott Long 
207b0a2fdeeSScott Long static mpt_load_handler_t      mpt_core_load;
208b0a2fdeeSScott Long static mpt_attach_handler_t    mpt_core_attach;
209c87e3f83SMatt Jacob static mpt_enable_handler_t    mpt_core_enable;
210b0a2fdeeSScott Long static mpt_reset_handler_t     mpt_core_ioc_reset;
211b0a2fdeeSScott Long static mpt_event_handler_t     mpt_core_event;
212b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_core_shutdown;
213b0a2fdeeSScott Long static mpt_shutdown_handler_t  mpt_core_detach;
214b0a2fdeeSScott Long static mpt_unload_handler_t    mpt_core_unload;
215b0a2fdeeSScott Long static struct mpt_personality mpt_core_personality =
216b0a2fdeeSScott Long {
217b0a2fdeeSScott Long 	.name		= "mpt_core",
218b0a2fdeeSScott Long 	.load		= mpt_core_load,
219b0a2fdeeSScott Long 	.attach		= mpt_core_attach,
220c87e3f83SMatt Jacob 	.enable		= mpt_core_enable,
221b0a2fdeeSScott Long 	.event		= mpt_core_event,
222b0a2fdeeSScott Long 	.reset		= mpt_core_ioc_reset,
223b0a2fdeeSScott Long 	.shutdown	= mpt_core_shutdown,
224b0a2fdeeSScott Long 	.detach		= mpt_core_detach,
225b0a2fdeeSScott Long 	.unload		= mpt_core_unload,
226b0a2fdeeSScott Long };
227b0a2fdeeSScott Long 
228b0a2fdeeSScott Long /*
229b0a2fdeeSScott Long  * Manual declaration so that DECLARE_MPT_PERSONALITY doesn't need
230b0a2fdeeSScott Long  * ordering information.  We want the core to always register FIRST.
231b0a2fdeeSScott Long  * other modules are set to SI_ORDER_SECOND.
232b0a2fdeeSScott Long  */
233b0a2fdeeSScott Long static moduledata_t mpt_core_mod = {
234b0a2fdeeSScott Long 	"mpt_core", mpt_modevent, &mpt_core_personality
235b0a2fdeeSScott Long };
236b0a2fdeeSScott Long DECLARE_MODULE(mpt_core, mpt_core_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
237b0a2fdeeSScott Long MODULE_VERSION(mpt_core, 1);
238b0a2fdeeSScott Long 
239c87e3f83SMatt Jacob #define MPT_PERS_ATTACHED(pers, mpt) ((mpt)->mpt_pers_mask & (0x1 << pers->id))
240b0a2fdeeSScott Long 
241b0a2fdeeSScott Long 
242b0a2fdeeSScott Long int
243b0a2fdeeSScott Long mpt_modevent(module_t mod, int type, void *data)
244b0a2fdeeSScott Long {
245b0a2fdeeSScott Long 	struct mpt_personality *pers;
246b0a2fdeeSScott Long 	int error;
247b0a2fdeeSScott Long 
248b0a2fdeeSScott Long 	pers = (struct mpt_personality *)data;
249b0a2fdeeSScott Long 
250b0a2fdeeSScott Long 	error = 0;
251b0a2fdeeSScott Long 	switch (type) {
252b0a2fdeeSScott Long 	case MOD_LOAD:
253b0a2fdeeSScott Long 	{
254b0a2fdeeSScott Long 		mpt_load_handler_t **def_handler;
255b0a2fdeeSScott Long 		mpt_load_handler_t **pers_handler;
256b0a2fdeeSScott Long 		int i;
257b0a2fdeeSScott Long 
258b0a2fdeeSScott Long 		for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
259b0a2fdeeSScott Long 			if (mpt_personalities[i] == NULL)
260b0a2fdeeSScott Long 				break;
261b0a2fdeeSScott Long 		}
262b0a2fdeeSScott Long 		if (i >= MPT_MAX_PERSONALITIES) {
263b0a2fdeeSScott Long 			error = ENOMEM;
264b0a2fdeeSScott Long 			break;
265b0a2fdeeSScott Long 		}
266b0a2fdeeSScott Long 		pers->id = i;
267b0a2fdeeSScott Long 		mpt_personalities[i] = pers;
268b0a2fdeeSScott Long 
269b0a2fdeeSScott Long 		/* Install standard/noop handlers for any NULL entries. */
270b0a2fdeeSScott Long 		def_handler = MPT_PERS_FIRST_HANDLER(&mpt_default_personality);
271b0a2fdeeSScott Long 		pers_handler = MPT_PERS_FIRST_HANDLER(pers);
272b0a2fdeeSScott Long 		while (pers_handler <= MPT_PERS_LAST_HANDLER(pers)) {
273b0a2fdeeSScott Long 			if (*pers_handler == NULL)
274b0a2fdeeSScott Long 				*pers_handler = *def_handler;
275b0a2fdeeSScott Long 			pers_handler++;
276b0a2fdeeSScott Long 			def_handler++;
277b0a2fdeeSScott Long 		}
278b0a2fdeeSScott Long 
279b0a2fdeeSScott Long 		error = (pers->load(pers));
280b0a2fdeeSScott Long 		if (error != 0)
281b0a2fdeeSScott Long 			mpt_personalities[i] = NULL;
282b0a2fdeeSScott Long 		break;
283b0a2fdeeSScott Long 	}
284b0a2fdeeSScott Long 	case MOD_SHUTDOWN:
285b0a2fdeeSScott Long 		break;
286c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000
287b0a2fdeeSScott Long 	case MOD_QUIESCE:
288b0a2fdeeSScott Long 		break;
289c87e3f83SMatt Jacob #endif
290b0a2fdeeSScott Long 	case MOD_UNLOAD:
291b0a2fdeeSScott Long 		error = pers->unload(pers);
292b0a2fdeeSScott Long 		mpt_personalities[pers->id] = NULL;
293b0a2fdeeSScott Long 		break;
294b0a2fdeeSScott Long 	default:
295b0a2fdeeSScott Long 		error = EINVAL;
296b0a2fdeeSScott Long 		break;
297b0a2fdeeSScott Long 	}
298b0a2fdeeSScott Long 	return (error);
299b0a2fdeeSScott Long }
300b0a2fdeeSScott Long 
301b0a2fdeeSScott Long int
302b0a2fdeeSScott Long mpt_stdload(struct mpt_personality *pers)
303b0a2fdeeSScott Long {
304b0a2fdeeSScott Long 	/* Load is always successfull. */
305b0a2fdeeSScott Long 	return (0);
306b0a2fdeeSScott Long }
307b0a2fdeeSScott Long 
308b0a2fdeeSScott Long int
309b0a2fdeeSScott Long mpt_stdprobe(struct mpt_softc *mpt)
310b0a2fdeeSScott Long {
311b0a2fdeeSScott Long 	/* Probe is always successfull. */
312b0a2fdeeSScott Long 	return (0);
313b0a2fdeeSScott Long }
314b0a2fdeeSScott Long 
315b0a2fdeeSScott Long int
316b0a2fdeeSScott Long mpt_stdattach(struct mpt_softc *mpt)
317b0a2fdeeSScott Long {
318b0a2fdeeSScott Long 	/* Attach is always successfull. */
319b0a2fdeeSScott Long 	return (0);
320b0a2fdeeSScott Long }
321b0a2fdeeSScott Long 
322b0a2fdeeSScott Long int
323c87e3f83SMatt Jacob mpt_stdenable(struct mpt_softc *mpt)
324c87e3f83SMatt Jacob {
325c87e3f83SMatt Jacob 	/* Enable is always successfull. */
326c87e3f83SMatt Jacob 	return (0);
327c87e3f83SMatt Jacob }
328c87e3f83SMatt Jacob 
329c87e3f83SMatt Jacob int
330444dd2b6SMatt Jacob mpt_stdevent(struct mpt_softc *mpt, request_t *req, MSG_EVENT_NOTIFY_REPLY *msg)
331b0a2fdeeSScott Long {
332444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_stdevent: 0x%x\n", msg->Event & 0xFF);
333b0a2fdeeSScott Long 	/* Event was not for us. */
334b0a2fdeeSScott Long 	return (0);
335b0a2fdeeSScott Long }
336b0a2fdeeSScott Long 
337b0a2fdeeSScott Long void
338b0a2fdeeSScott Long mpt_stdreset(struct mpt_softc *mpt, int type)
339b0a2fdeeSScott Long {
340b0a2fdeeSScott Long }
341b0a2fdeeSScott Long 
342b0a2fdeeSScott Long void
343b0a2fdeeSScott Long mpt_stdshutdown(struct mpt_softc *mpt)
344b0a2fdeeSScott Long {
345b0a2fdeeSScott Long }
346b0a2fdeeSScott Long 
347b0a2fdeeSScott Long void
348b0a2fdeeSScott Long mpt_stddetach(struct mpt_softc *mpt)
349b0a2fdeeSScott Long {
350b0a2fdeeSScott Long }
351b0a2fdeeSScott Long 
352b0a2fdeeSScott Long int
353b0a2fdeeSScott Long mpt_stdunload(struct mpt_personality *pers)
354b0a2fdeeSScott Long {
355b0a2fdeeSScott Long 	/* Unload is always successfull. */
356b0a2fdeeSScott Long 	return (0);
357b0a2fdeeSScott Long }
358b0a2fdeeSScott Long 
359b0a2fdeeSScott Long /******************************* Bus DMA Support ******************************/
360b0a2fdeeSScott Long void
361b0a2fdeeSScott Long mpt_map_rquest(void *arg, bus_dma_segment_t *segs, int nseg, int error)
362b0a2fdeeSScott Long {
363b0a2fdeeSScott Long 	struct mpt_map_info *map_info;
364b0a2fdeeSScott Long 
365b0a2fdeeSScott Long 	map_info = (struct mpt_map_info *)arg;
366b0a2fdeeSScott Long 	map_info->error = error;
367b0a2fdeeSScott Long 	map_info->phys = segs->ds_addr;
368b0a2fdeeSScott Long }
369b0a2fdeeSScott Long 
370b0a2fdeeSScott Long /**************************** Reply/Event Handling ****************************/
371b0a2fdeeSScott Long int
372b0a2fdeeSScott Long mpt_register_handler(struct mpt_softc *mpt, mpt_handler_type type,
373b0a2fdeeSScott Long 		     mpt_handler_t handler, uint32_t *phandler_id)
374b0a2fdeeSScott Long {
375b0a2fdeeSScott Long 
376b0a2fdeeSScott Long 	switch (type) {
377b0a2fdeeSScott Long 	case MPT_HANDLER_REPLY:
378b0a2fdeeSScott Long 	{
379b0a2fdeeSScott Long 		u_int cbi;
380b0a2fdeeSScott Long 		u_int free_cbi;
381b0a2fdeeSScott Long 
382b0a2fdeeSScott Long 		if (phandler_id == NULL)
383b0a2fdeeSScott Long 			return (EINVAL);
384b0a2fdeeSScott Long 
385b0a2fdeeSScott Long 		free_cbi = MPT_HANDLER_ID_NONE;
386b0a2fdeeSScott Long 		for (cbi = 0; cbi < MPT_NUM_REPLY_HANDLERS; cbi++) {
387b0a2fdeeSScott Long 			/*
388b0a2fdeeSScott Long 			 * If the same handler is registered multiple
389b0a2fdeeSScott Long 			 * times, don't error out.  Just return the
390b0a2fdeeSScott Long 			 * index of the original registration.
391b0a2fdeeSScott Long 			 */
392b0a2fdeeSScott Long 			if (mpt_reply_handlers[cbi] == handler.reply_handler) {
393b0a2fdeeSScott Long 				*phandler_id = MPT_CBI_TO_HID(cbi);
394b0a2fdeeSScott Long 				return (0);
395b0a2fdeeSScott Long 			}
396b0a2fdeeSScott Long 
397b0a2fdeeSScott Long 			/*
398b0a2fdeeSScott Long 			 * Fill from the front in the hope that
399b0a2fdeeSScott Long 			 * all registered handlers consume only a
400b0a2fdeeSScott Long 			 * single cache line.
401b0a2fdeeSScott Long 			 *
402b0a2fdeeSScott Long 			 * We don't break on the first empty slot so
403b0a2fdeeSScott Long 			 * that the full table is checked to see if
404b0a2fdeeSScott Long 			 * this handler was previously registered.
405b0a2fdeeSScott Long 			 */
406c87e3f83SMatt Jacob 			if (free_cbi == MPT_HANDLER_ID_NONE &&
407c87e3f83SMatt Jacob 			    (mpt_reply_handlers[cbi]
408b0a2fdeeSScott Long 			  == mpt_default_reply_handler))
409b0a2fdeeSScott Long 				free_cbi = cbi;
410b0a2fdeeSScott Long 		}
411c87e3f83SMatt Jacob 		if (free_cbi == MPT_HANDLER_ID_NONE) {
412b0a2fdeeSScott Long 			return (ENOMEM);
413c87e3f83SMatt Jacob 		}
414b0a2fdeeSScott Long 		mpt_reply_handlers[free_cbi] = handler.reply_handler;
415b0a2fdeeSScott Long 		*phandler_id = MPT_CBI_TO_HID(free_cbi);
416b0a2fdeeSScott Long 		break;
417b0a2fdeeSScott Long 	}
418b0a2fdeeSScott Long 	default:
419b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_register_handler unknown type %d\n", type);
420b0a2fdeeSScott Long 		return (EINVAL);
421b0a2fdeeSScott Long 	}
422b0a2fdeeSScott Long 	return (0);
423b0a2fdeeSScott Long }
424b0a2fdeeSScott Long 
425b0a2fdeeSScott Long int
426b0a2fdeeSScott Long mpt_deregister_handler(struct mpt_softc *mpt, mpt_handler_type type,
427b0a2fdeeSScott Long 		       mpt_handler_t handler, uint32_t handler_id)
428b0a2fdeeSScott Long {
429b0a2fdeeSScott Long 
430b0a2fdeeSScott Long 	switch (type) {
431b0a2fdeeSScott Long 	case MPT_HANDLER_REPLY:
432b0a2fdeeSScott Long 	{
433b0a2fdeeSScott Long 		u_int cbi;
434b0a2fdeeSScott Long 
435b0a2fdeeSScott Long 		cbi = MPT_CBI(handler_id);
436b0a2fdeeSScott Long 		if (cbi >= MPT_NUM_REPLY_HANDLERS
437b0a2fdeeSScott Long 		 || mpt_reply_handlers[cbi] != handler.reply_handler)
438b0a2fdeeSScott Long 			return (ENOENT);
439b0a2fdeeSScott Long 		mpt_reply_handlers[cbi] = mpt_default_reply_handler;
440b0a2fdeeSScott Long 		break;
441b0a2fdeeSScott Long 	}
442b0a2fdeeSScott Long 	default:
443b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_deregister_handler unknown type %d\n", type);
444b0a2fdeeSScott Long 		return (EINVAL);
445b0a2fdeeSScott Long 	}
446b0a2fdeeSScott Long 	return (0);
447b0a2fdeeSScott Long }
448b0a2fdeeSScott Long 
449b0a2fdeeSScott Long static int
450b0a2fdeeSScott Long mpt_default_reply_handler(struct mpt_softc *mpt, request_t *req,
451c87e3f83SMatt Jacob 	uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
452b0a2fdeeSScott Long {
453c87e3f83SMatt Jacob 	mpt_prt(mpt,
454c87e3f83SMatt Jacob 	    "Default Handler Called: req=%p:%u reply_descriptor=%x frame=%p\n",
455c87e3f83SMatt Jacob 	    req, req->serno, reply_desc, reply_frame);
456b0a2fdeeSScott Long 
457b0a2fdeeSScott Long 	if (reply_frame != NULL)
458b0a2fdeeSScott Long 		mpt_dump_reply_frame(mpt, reply_frame);
459b0a2fdeeSScott Long 
460c87e3f83SMatt Jacob 	mpt_prt(mpt, "Reply Frame Ignored\n");
461b0a2fdeeSScott Long 
462b0a2fdeeSScott Long 	return (/*free_reply*/TRUE);
463b0a2fdeeSScott Long }
464b0a2fdeeSScott Long 
465b0a2fdeeSScott Long static int
466b0a2fdeeSScott Long mpt_config_reply_handler(struct mpt_softc *mpt, request_t *req,
467c87e3f83SMatt Jacob  uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
468b0a2fdeeSScott Long {
469b0a2fdeeSScott Long 	if (req != NULL) {
470b0a2fdeeSScott Long 
471b0a2fdeeSScott Long 		if (reply_frame != NULL) {
472b0a2fdeeSScott Long 			MSG_CONFIG *cfgp;
473b0a2fdeeSScott Long 			MSG_CONFIG_REPLY *reply;
474b0a2fdeeSScott Long 
475b0a2fdeeSScott Long 			cfgp = (MSG_CONFIG *)req->req_vbuf;
476b0a2fdeeSScott Long 			reply = (MSG_CONFIG_REPLY *)reply_frame;
477b0a2fdeeSScott Long 			req->IOCStatus = le16toh(reply_frame->IOCStatus);
478b0a2fdeeSScott Long 			bcopy(&reply->Header, &cfgp->Header,
479b0a2fdeeSScott Long 			      sizeof(cfgp->Header));
480b0a2fdeeSScott Long 		}
481b0a2fdeeSScott Long 		req->state &= ~REQ_STATE_QUEUED;
482b0a2fdeeSScott Long 		req->state |= REQ_STATE_DONE;
483b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_pending_list, req, links);
4845e073106SMatt Jacob 		if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) {
485b0a2fdeeSScott Long 			wakeup(req);
486b0a2fdeeSScott Long 		}
4875e073106SMatt Jacob 	}
488b0a2fdeeSScott Long 
4895e073106SMatt Jacob 	return (TRUE);
490b0a2fdeeSScott Long }
491b0a2fdeeSScott Long 
492b0a2fdeeSScott Long static int
493b0a2fdeeSScott Long mpt_handshake_reply_handler(struct mpt_softc *mpt, request_t *req,
494c87e3f83SMatt Jacob  uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
495b0a2fdeeSScott Long {
496b0a2fdeeSScott Long 	/* Nothing to be done. */
4975e073106SMatt Jacob 	return (TRUE);
498b0a2fdeeSScott Long }
499b0a2fdeeSScott Long 
500b0a2fdeeSScott Long static int
501b0a2fdeeSScott Long mpt_event_reply_handler(struct mpt_softc *mpt, request_t *req,
502c87e3f83SMatt Jacob     uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame)
503b0a2fdeeSScott Long {
504b0a2fdeeSScott Long 	int free_reply;
505b0a2fdeeSScott Long 
5065e073106SMatt Jacob 	KASSERT(reply_frame != NULL, ("null reply in mpt_event_reply_handler"));
5075e073106SMatt Jacob 	KASSERT(req != NULL, ("null request in mpt_event_reply_handler"));
508b0a2fdeeSScott Long 
509b0a2fdeeSScott Long 	free_reply = TRUE;
510b0a2fdeeSScott Long 	switch (reply_frame->Function) {
511b0a2fdeeSScott Long 	case MPI_FUNCTION_EVENT_NOTIFICATION:
512b0a2fdeeSScott Long 	{
513b0a2fdeeSScott Long 		MSG_EVENT_NOTIFY_REPLY *msg;
514b0a2fdeeSScott Long 		struct mpt_personality *pers;
515b0a2fdeeSScott Long 		u_int handled;
516b0a2fdeeSScott Long 
517b0a2fdeeSScott Long 		handled = 0;
518b0a2fdeeSScott Long 		msg = (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
519b0a2fdeeSScott Long 		MPT_PERS_FOREACH(mpt, pers)
520b0a2fdeeSScott Long 			handled += pers->event(mpt, req, msg);
521b0a2fdeeSScott Long 
522444dd2b6SMatt Jacob 		if (handled == 0 && mpt->mpt_pers_mask == 0) {
5231977cbd6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_INFO,
524444dd2b6SMatt Jacob 				"No Handlers For Any Event Notify Frames. "
525444dd2b6SMatt Jacob 				"Event %#x (ACK %sequired).\n",
526444dd2b6SMatt Jacob 				msg->Event, msg->AckRequired? "r" : "not r");
527444dd2b6SMatt Jacob 		} else if (handled == 0) {
5281977cbd6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_WARN,
529444dd2b6SMatt Jacob 				"Unhandled Event Notify Frame. Event %#x "
530444dd2b6SMatt Jacob 				"(ACK %sequired).\n",
531444dd2b6SMatt Jacob 				msg->Event, msg->AckRequired? "r" : "not r");
532444dd2b6SMatt Jacob 		}
533b0a2fdeeSScott Long 
534b0a2fdeeSScott Long 		if (msg->AckRequired) {
535b0a2fdeeSScott Long 			request_t *ack_req;
536b0a2fdeeSScott Long 			uint32_t context;
537b0a2fdeeSScott Long 
538b0a2fdeeSScott Long 			context = htole32(req->index|MPT_REPLY_HANDLER_EVENTS);
5395e073106SMatt Jacob 			ack_req = mpt_get_request(mpt, FALSE);
540b0a2fdeeSScott Long 			if (ack_req == NULL) {
541b0a2fdeeSScott Long 				struct mpt_evtf_record *evtf;
542b0a2fdeeSScott Long 
543b0a2fdeeSScott Long 				evtf = (struct mpt_evtf_record *)reply_frame;
544b0a2fdeeSScott Long 				evtf->context = context;
545b0a2fdeeSScott Long 				LIST_INSERT_HEAD(&mpt->ack_frames, evtf, links);
546b0a2fdeeSScott Long 				free_reply = FALSE;
547b0a2fdeeSScott Long 				break;
548b0a2fdeeSScott Long 			}
549b0a2fdeeSScott Long 			mpt_send_event_ack(mpt, ack_req, msg, context);
5505e073106SMatt Jacob 			/*
5515e073106SMatt Jacob 			 * Don't check for CONTINUATION_REPLY here
5525e073106SMatt Jacob 			 */
5535e073106SMatt Jacob 			return (free_reply);
554b0a2fdeeSScott Long 		}
555b0a2fdeeSScott Long 		break;
556b0a2fdeeSScott Long 	}
557b0a2fdeeSScott Long 	case MPI_FUNCTION_PORT_ENABLE:
558b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG , "enable port reply\n");
559b0a2fdeeSScott Long 		break;
560b0a2fdeeSScott Long 	case MPI_FUNCTION_EVENT_ACK:
561b0a2fdeeSScott Long 		break;
562b0a2fdeeSScott Long 	default:
5635e073106SMatt Jacob 		mpt_prt(mpt, "unknown event function: %x\n",
564b0a2fdeeSScott Long 			reply_frame->Function);
565b0a2fdeeSScott Long 		break;
566b0a2fdeeSScott Long 	}
567b0a2fdeeSScott Long 
5685e073106SMatt Jacob 	/*
5695e073106SMatt Jacob 	 * I'm not sure that this continuation stuff works as it should.
5705e073106SMatt Jacob 	 *
5715e073106SMatt Jacob 	 * I've had FC async events occur that free the frame up because
5725e073106SMatt Jacob 	 * the continuation bit isn't set, and then additional async events
5735e073106SMatt Jacob 	 * then occur using the same context. As you might imagine, this
5745e073106SMatt Jacob 	 * leads to Very Bad Thing.
5755e073106SMatt Jacob 	 *
5765e073106SMatt Jacob 	 *  Let's just be safe for now and not free them up until we figure
5775e073106SMatt Jacob 	 * out what's actually happening here.
5785e073106SMatt Jacob 	 */
5795e073106SMatt Jacob #if	0
5805e073106SMatt Jacob 	if ((reply_frame->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) == 0) {
581b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_pending_list, req, links);
582b0a2fdeeSScott Long 		mpt_free_request(mpt, req);
5835e073106SMatt Jacob 		mpt_prt(mpt, "event_reply %x for req %p:%u NOT a continuation",
5845e073106SMatt Jacob 		    reply_frame->Function, req, req->serno);
5855e073106SMatt Jacob 		if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) {
5865e073106SMatt Jacob 			MSG_EVENT_NOTIFY_REPLY *msg =
5875e073106SMatt Jacob 			    (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
5885e073106SMatt Jacob 			mpt_prtc(mpt, " Event=0x%x AckReq=%d",
5895e073106SMatt Jacob 			    msg->Event, msg->AckRequired);
590b0a2fdeeSScott Long 		}
5915e073106SMatt Jacob 	} else {
5925e073106SMatt Jacob 		mpt_prt(mpt, "event_reply %x for %p:%u IS a continuation",
5935e073106SMatt Jacob 		    reply_frame->Function, req, req->serno);
5945e073106SMatt Jacob 		if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) {
5955e073106SMatt Jacob 			MSG_EVENT_NOTIFY_REPLY *msg =
5965e073106SMatt Jacob 			    (MSG_EVENT_NOTIFY_REPLY *)reply_frame;
5975e073106SMatt Jacob 			mpt_prtc(mpt, " Event=0x%x AckReq=%d",
5985e073106SMatt Jacob 			    msg->Event, msg->AckRequired);
5995e073106SMatt Jacob 		}
6005e073106SMatt Jacob 		mpt_prtc(mpt, "\n");
6015e073106SMatt Jacob 	}
6025e073106SMatt Jacob #endif
603b0a2fdeeSScott Long 	return (free_reply);
604b0a2fdeeSScott Long }
605b0a2fdeeSScott Long 
606b0a2fdeeSScott Long /*
607b0a2fdeeSScott Long  * Process an asynchronous event from the IOC.
608b0a2fdeeSScott Long  */
609b0a2fdeeSScott Long static int
610b0a2fdeeSScott Long mpt_core_event(struct mpt_softc *mpt, request_t *req,
611b0a2fdeeSScott Long 	       MSG_EVENT_NOTIFY_REPLY *msg)
612b0a2fdeeSScott Long {
613444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_core_event: 0x%x\n",
614444dd2b6SMatt Jacob                  msg->Event & 0xFF);
615b0a2fdeeSScott Long 	switch(msg->Event & 0xFF) {
616b0a2fdeeSScott Long 	case MPI_EVENT_NONE:
617b0a2fdeeSScott Long 		break;
618b0a2fdeeSScott Long 	case MPI_EVENT_LOG_DATA:
619b0a2fdeeSScott Long 	{
620b0a2fdeeSScott Long 		int i;
621b0a2fdeeSScott Long 
622b0a2fdeeSScott Long 		/* Some error occured that LSI wants logged */
623b0a2fdeeSScott Long 		mpt_prt(mpt, "EvtLogData: IOCLogInfo: 0x%08x\n",
624b0a2fdeeSScott Long 			msg->IOCLogInfo);
625b0a2fdeeSScott Long 		mpt_prt(mpt, "\tEvtLogData: Event Data:");
626b0a2fdeeSScott Long 		for (i = 0; i < msg->EventDataLength; i++)
627b0a2fdeeSScott Long 			mpt_prtc(mpt, "  %08x", msg->Data[i]);
628b0a2fdeeSScott Long 		mpt_prtc(mpt, "\n");
629b0a2fdeeSScott Long 		break;
630b0a2fdeeSScott Long 	}
631b0a2fdeeSScott Long 	case MPI_EVENT_EVENT_CHANGE:
632b0a2fdeeSScott Long 		/*
633b0a2fdeeSScott Long 		 * This is just an acknowledgement
634b0a2fdeeSScott Long 		 * of our mpt_send_event_request.
635b0a2fdeeSScott Long 		 */
636b0a2fdeeSScott Long 		break;
637444dd2b6SMatt Jacob 	case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE:
638444dd2b6SMatt Jacob 		break;
639b0a2fdeeSScott Long 	default:
6405e073106SMatt Jacob 		return (0);
641b0a2fdeeSScott Long 		break;
642b0a2fdeeSScott Long 	}
6435e073106SMatt Jacob 	return (1);
644b0a2fdeeSScott Long }
645b0a2fdeeSScott Long 
646b0a2fdeeSScott Long static void
647b0a2fdeeSScott Long mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req,
648b0a2fdeeSScott Long 		   MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context)
649b0a2fdeeSScott Long {
650b0a2fdeeSScott Long 	MSG_EVENT_ACK *ackp;
651b0a2fdeeSScott Long 
652b0a2fdeeSScott Long 	ackp = (MSG_EVENT_ACK *)ack_req->req_vbuf;
6535e073106SMatt Jacob 	memset(ackp, 0, sizeof (*ackp));
654b0a2fdeeSScott Long 	ackp->Function = MPI_FUNCTION_EVENT_ACK;
655b0a2fdeeSScott Long 	ackp->Event = msg->Event;
656b0a2fdeeSScott Long 	ackp->EventContext = msg->EventContext;
657b0a2fdeeSScott Long 	ackp->MsgContext = context;
658b0a2fdeeSScott Long 	mpt_check_doorbell(mpt);
659b0a2fdeeSScott Long 	mpt_send_cmd(mpt, ack_req);
660b0a2fdeeSScott Long }
661b0a2fdeeSScott Long 
662b0a2fdeeSScott Long /***************************** Interrupt Handling *****************************/
663b0a2fdeeSScott Long void
664b0a2fdeeSScott Long mpt_intr(void *arg)
665b0a2fdeeSScott Long {
666b0a2fdeeSScott Long 	struct mpt_softc *mpt;
667b0a2fdeeSScott Long 	uint32_t reply_desc;
668c87e3f83SMatt Jacob 	int ntrips = 0;
669b0a2fdeeSScott Long 
670b0a2fdeeSScott Long 	mpt = (struct mpt_softc *)arg;
6715089bd63SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG2, "enter mpt_intr\n");
672b0a2fdeeSScott Long 	while ((reply_desc = mpt_pop_reply_queue(mpt)) != MPT_REPLY_EMPTY) {
673b0a2fdeeSScott Long 		request_t	  *req;
674b0a2fdeeSScott Long 		MSG_DEFAULT_REPLY *reply_frame;
675b0a2fdeeSScott Long 		uint32_t	   reply_baddr;
676c87e3f83SMatt Jacob 		uint32_t           ctxt_idx;
677b0a2fdeeSScott Long 		u_int		   cb_index;
678b0a2fdeeSScott Long 		u_int		   req_index;
679b0a2fdeeSScott Long 		int		   free_rf;
680b0a2fdeeSScott Long 
681b0a2fdeeSScott Long 		req = NULL;
682b0a2fdeeSScott Long 		reply_frame = NULL;
683b0a2fdeeSScott Long 		reply_baddr = 0;
684b0a2fdeeSScott Long 		if ((reply_desc & MPI_ADDRESS_REPLY_A_BIT) != 0) {
685b0a2fdeeSScott Long 			u_int offset;
686b0a2fdeeSScott Long 			/*
687b0a2fdeeSScott Long 			 * Insure that the reply frame is coherent.
688b0a2fdeeSScott Long 			 */
6895e073106SMatt Jacob 			reply_baddr = MPT_REPLY_BADDR(reply_desc);
690b0a2fdeeSScott Long 			offset = reply_baddr - (mpt->reply_phys & 0xFFFFFFFF);
691c87e3f83SMatt Jacob 			bus_dmamap_sync_range(mpt->reply_dmat,
692c87e3f83SMatt Jacob 			    mpt->reply_dmap, offset, MPT_REPLY_SIZE,
693b0a2fdeeSScott Long 			    BUS_DMASYNC_POSTREAD);
694b0a2fdeeSScott Long 			reply_frame = MPT_REPLY_OTOV(mpt, offset);
695c87e3f83SMatt Jacob 			ctxt_idx = le32toh(reply_frame->MsgContext);
696c87e3f83SMatt Jacob 		} else {
697c87e3f83SMatt Jacob 			uint32_t type;
698b0a2fdeeSScott Long 
699c87e3f83SMatt Jacob 			type = MPI_GET_CONTEXT_REPLY_TYPE(reply_desc);
700c87e3f83SMatt Jacob 			ctxt_idx = reply_desc;
701c87e3f83SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_DEBUG1, "Context Reply: 0x%08x\n",
702c87e3f83SMatt Jacob 				    reply_desc);
703c87e3f83SMatt Jacob 
704c87e3f83SMatt Jacob 			switch (type) {
705c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT:
706c87e3f83SMatt Jacob 				ctxt_idx &= MPI_CONTEXT_REPLY_CONTEXT_MASK;
707c87e3f83SMatt Jacob 				break;
708c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET:
709c87e3f83SMatt Jacob 				ctxt_idx = GET_IO_INDEX(reply_desc);
710c87e3f83SMatt Jacob 				if (mpt->tgt_cmd_ptrs == NULL) {
711c87e3f83SMatt Jacob 					mpt_prt(mpt,
712c87e3f83SMatt Jacob 					    "mpt_intr: no target cmd ptrs\n");
713c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
714c87e3f83SMatt Jacob 					break;
715c87e3f83SMatt Jacob 				}
716c87e3f83SMatt Jacob 				if (ctxt_idx >= mpt->tgt_cmds_allocated) {
717c87e3f83SMatt Jacob 					mpt_prt(mpt,
718c87e3f83SMatt Jacob 					    "mpt_intr: bad tgt cmd ctxt %u\n",
719c87e3f83SMatt Jacob 					    ctxt_idx);
720c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
721c87e3f83SMatt Jacob 					ntrips = 1000;
722c87e3f83SMatt Jacob 					break;
723c87e3f83SMatt Jacob 				}
724c87e3f83SMatt Jacob 				req = mpt->tgt_cmd_ptrs[ctxt_idx];
725c87e3f83SMatt Jacob 				if (req == NULL) {
726c87e3f83SMatt Jacob 					mpt_prt(mpt, "no request backpointer "
727c87e3f83SMatt Jacob 					    "at index %u", ctxt_idx);
728c87e3f83SMatt Jacob 					reply_desc = MPT_REPLY_EMPTY;
729c87e3f83SMatt Jacob 					ntrips = 1000;
730c87e3f83SMatt Jacob 					break;
731c87e3f83SMatt Jacob 				}
732c87e3f83SMatt Jacob 				/*
733c87e3f83SMatt Jacob 				 * Reformulate ctxt_idx to be just as if
734c87e3f83SMatt Jacob 				 * it were another type of context reply
735c87e3f83SMatt Jacob 				 * so the code below will find the request
736c87e3f83SMatt Jacob 				 * via indexing into the pool.
737c87e3f83SMatt Jacob 				 */
738c87e3f83SMatt Jacob 				ctxt_idx =
739c87e3f83SMatt Jacob 				    req->index | mpt->scsi_tgt_handler_id;
740c87e3f83SMatt Jacob 				req = NULL;
741c87e3f83SMatt Jacob 				break;
742c87e3f83SMatt Jacob 			case MPI_CONTEXT_REPLY_TYPE_LAN:
743c87e3f83SMatt Jacob 				mpt_prt(mpt, "LAN CONTEXT REPLY: 0x%08x\n",
744c87e3f83SMatt Jacob 				    reply_desc);
745c87e3f83SMatt Jacob 				reply_desc = MPT_REPLY_EMPTY;
746c87e3f83SMatt Jacob 				break;
747c87e3f83SMatt Jacob 			default:
748c87e3f83SMatt Jacob 				mpt_prt(mpt, "Context Reply 0x%08x?\n", type);
749c87e3f83SMatt Jacob 				reply_desc = MPT_REPLY_EMPTY;
750c87e3f83SMatt Jacob 				break;
751c87e3f83SMatt Jacob 			}
752c87e3f83SMatt Jacob 			if (reply_desc == MPT_REPLY_EMPTY) {
753c87e3f83SMatt Jacob 				if (ntrips++ > 1000) {
754c87e3f83SMatt Jacob 					break;
755c87e3f83SMatt Jacob 				}
756c87e3f83SMatt Jacob 				continue;
757c87e3f83SMatt Jacob 			}
758c87e3f83SMatt Jacob 		}
759c87e3f83SMatt Jacob 
760c87e3f83SMatt Jacob 		cb_index = MPT_CONTEXT_TO_CBI(ctxt_idx);
761c87e3f83SMatt Jacob 		req_index = MPT_CONTEXT_TO_REQI(ctxt_idx);
762c87e3f83SMatt Jacob 		if (req_index < MPT_MAX_REQUESTS(mpt)) {
763c87e3f83SMatt Jacob 			req = &mpt->request_pool[req_index];
7645e073106SMatt Jacob 		} else {
7655e073106SMatt Jacob 			mpt_prt(mpt, "WARN: mpt_intr index == %d (reply_desc =="
7665e073106SMatt Jacob 			    " 0x%x)\n", req_index, reply_desc);
767c87e3f83SMatt Jacob 		}
768c87e3f83SMatt Jacob 
769c87e3f83SMatt Jacob 		free_rf = mpt_reply_handlers[cb_index](mpt, req,
770c87e3f83SMatt Jacob 		    reply_desc, reply_frame);
771b0a2fdeeSScott Long 
7725e073106SMatt Jacob 		if (reply_frame != NULL && free_rf) {
773b0a2fdeeSScott Long 			mpt_free_reply(mpt, reply_baddr);
7745e073106SMatt Jacob 		}
775c87e3f83SMatt Jacob 
776c87e3f83SMatt Jacob 		/*
777c87e3f83SMatt Jacob 		 * If we got ourselves disabled, don't get stuck in a loop
778c87e3f83SMatt Jacob 		 */
779c87e3f83SMatt Jacob 		if (mpt->disabled) {
780c87e3f83SMatt Jacob 			mpt_disable_ints(mpt);
781c87e3f83SMatt Jacob 			break;
782c87e3f83SMatt Jacob 		}
783c87e3f83SMatt Jacob 		if (ntrips++ > 1000) {
784c87e3f83SMatt Jacob 			break;
785c87e3f83SMatt Jacob 		}
786b0a2fdeeSScott Long 	}
7875089bd63SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG2, "exit mpt_intr\n");
788b0a2fdeeSScott Long }
789b0a2fdeeSScott Long 
790b0a2fdeeSScott Long /******************************* Error Recovery *******************************/
791b0a2fdeeSScott Long void
792b0a2fdeeSScott Long mpt_complete_request_chain(struct mpt_softc *mpt, struct req_queue *chain,
793b0a2fdeeSScott Long 			    u_int iocstatus)
794b0a2fdeeSScott Long {
795b0a2fdeeSScott Long 	MSG_DEFAULT_REPLY  ioc_status_frame;
796b0a2fdeeSScott Long 	request_t	  *req;
797b0a2fdeeSScott Long 
7985e073106SMatt Jacob 	memset(&ioc_status_frame, 0, sizeof(ioc_status_frame));
799b0a2fdeeSScott Long 	ioc_status_frame.MsgLength = roundup2(sizeof(ioc_status_frame), 4);
800b0a2fdeeSScott Long 	ioc_status_frame.IOCStatus = iocstatus;
801b0a2fdeeSScott Long 	while((req = TAILQ_FIRST(chain)) != NULL) {
802b0a2fdeeSScott Long 		MSG_REQUEST_HEADER *msg_hdr;
803b0a2fdeeSScott Long 		u_int		    cb_index;
8045e073106SMatt Jacob 
8059b7de735SMatt Jacob 		TAILQ_REMOVE(chain, req, links);
806b0a2fdeeSScott Long 		msg_hdr = (MSG_REQUEST_HEADER *)req->req_vbuf;
807b0a2fdeeSScott Long 		ioc_status_frame.Function = msg_hdr->Function;
808b0a2fdeeSScott Long 		ioc_status_frame.MsgContext = msg_hdr->MsgContext;
809b0a2fdeeSScott Long 		cb_index = MPT_CONTEXT_TO_CBI(le32toh(msg_hdr->MsgContext));
810c87e3f83SMatt Jacob 		mpt_reply_handlers[cb_index](mpt, req, msg_hdr->MsgContext,
811c87e3f83SMatt Jacob 		    &ioc_status_frame);
812b0a2fdeeSScott Long 	}
813b0a2fdeeSScott Long }
814b0a2fdeeSScott Long 
815b0a2fdeeSScott Long /********************************* Diagnostics ********************************/
816b0a2fdeeSScott Long /*
817b0a2fdeeSScott Long  * Perform a diagnostic dump of a reply frame.
818b0a2fdeeSScott Long  */
819b0a2fdeeSScott Long void
820b0a2fdeeSScott Long mpt_dump_reply_frame(struct mpt_softc *mpt, MSG_DEFAULT_REPLY *reply_frame)
821b0a2fdeeSScott Long {
822b0a2fdeeSScott Long 	mpt_prt(mpt, "Address Reply:\n");
823b0a2fdeeSScott Long 	mpt_print_reply(reply_frame);
824b0a2fdeeSScott Long }
825b0a2fdeeSScott Long 
826b0a2fdeeSScott Long /******************************* Doorbell Access ******************************/
827b0a2fdeeSScott Long static __inline uint32_t mpt_rd_db(struct mpt_softc *mpt);
828b0a2fdeeSScott Long static __inline  uint32_t mpt_rd_intr(struct mpt_softc *mpt);
829b0a2fdeeSScott Long 
830b0a2fdeeSScott Long static __inline uint32_t
831b0a2fdeeSScott Long mpt_rd_db(struct mpt_softc *mpt)
8329b631363SMatt Jacob {
8339b631363SMatt Jacob 	return mpt_read(mpt, MPT_OFFSET_DOORBELL);
8349b631363SMatt Jacob }
8359b631363SMatt Jacob 
836b0a2fdeeSScott Long static __inline uint32_t
837b0a2fdeeSScott Long mpt_rd_intr(struct mpt_softc *mpt)
8389b631363SMatt Jacob {
8399b631363SMatt Jacob 	return mpt_read(mpt, MPT_OFFSET_INTR_STATUS);
8409b631363SMatt Jacob }
8419b631363SMatt Jacob 
8429b631363SMatt Jacob /* Busy wait for a door bell to be read by IOC */
8439b631363SMatt Jacob static int
844b0a2fdeeSScott Long mpt_wait_db_ack(struct mpt_softc *mpt)
8459b631363SMatt Jacob {
8469b631363SMatt Jacob 	int i;
8479b631363SMatt Jacob 	for (i=0; i < MPT_MAX_WAIT; i++) {
8489b631363SMatt Jacob 		if (!MPT_DB_IS_BUSY(mpt_rd_intr(mpt))) {
8499b631363SMatt Jacob 			maxwait_ack = i > maxwait_ack ? i : maxwait_ack;
850c87e3f83SMatt Jacob 			return (MPT_OK);
8519b631363SMatt Jacob 		}
852c87e3f83SMatt Jacob 		DELAY(200);
8539b631363SMatt Jacob 	}
854c87e3f83SMatt Jacob 	return (MPT_FAIL);
8559b631363SMatt Jacob }
8569b631363SMatt Jacob 
8579b631363SMatt Jacob /* Busy wait for a door bell interrupt */
8589b631363SMatt Jacob static int
859b0a2fdeeSScott Long mpt_wait_db_int(struct mpt_softc *mpt)
8609b631363SMatt Jacob {
8619b631363SMatt Jacob 	int i;
8629b631363SMatt Jacob 	for (i=0; i < MPT_MAX_WAIT; i++) {
8639b631363SMatt Jacob 		if (MPT_DB_INTR(mpt_rd_intr(mpt))) {
8649b631363SMatt Jacob 			maxwait_int = i > maxwait_int ? i : maxwait_int;
8659b631363SMatt Jacob 			return MPT_OK;
8669b631363SMatt Jacob 		}
8679b631363SMatt Jacob 		DELAY(100);
8689b631363SMatt Jacob 	}
869c87e3f83SMatt Jacob 	return (MPT_FAIL);
8709b631363SMatt Jacob }
8719b631363SMatt Jacob 
8729b631363SMatt Jacob /* Wait for IOC to transition to a give state */
8739b631363SMatt Jacob void
874b0a2fdeeSScott Long mpt_check_doorbell(struct mpt_softc *mpt)
8759b631363SMatt Jacob {
876b0a2fdeeSScott Long 	uint32_t db = mpt_rd_db(mpt);
8779b631363SMatt Jacob 	if (MPT_STATE(db) != MPT_DB_STATE_RUNNING) {
878b0a2fdeeSScott Long 		mpt_prt(mpt, "Device not running\n");
8799b631363SMatt Jacob 		mpt_print_db(db);
8809b631363SMatt Jacob 	}
8819b631363SMatt Jacob }
8829b631363SMatt Jacob 
8839b631363SMatt Jacob /* Wait for IOC to transition to a give state */
8849b631363SMatt Jacob static int
885b0a2fdeeSScott Long mpt_wait_state(struct mpt_softc *mpt, enum DB_STATE_BITS state)
8869b631363SMatt Jacob {
8879b631363SMatt Jacob 	int i;
8889b631363SMatt Jacob 
8899b631363SMatt Jacob 	for (i = 0; i < MPT_MAX_WAIT; i++) {
890b0a2fdeeSScott Long 		uint32_t db = mpt_rd_db(mpt);
8919b631363SMatt Jacob 		if (MPT_STATE(db) == state) {
8929b631363SMatt Jacob 			maxwait_state = i > maxwait_state ? i : maxwait_state;
8939b631363SMatt Jacob 			return (MPT_OK);
8949b631363SMatt Jacob 		}
8959b631363SMatt Jacob 		DELAY(100);
8969b631363SMatt Jacob 	}
8979b631363SMatt Jacob 	return (MPT_FAIL);
8989b631363SMatt Jacob }
8999b631363SMatt Jacob 
9009b631363SMatt Jacob 
901b0a2fdeeSScott Long /************************* Intialization/Configuration ************************/
902b0a2fdeeSScott Long static int mpt_download_fw(struct mpt_softc *mpt);
903b0a2fdeeSScott Long 
9049b631363SMatt Jacob /* Issue the reset COMMAND to the IOC */
905b0a2fdeeSScott Long static int
906b0a2fdeeSScott Long mpt_soft_reset(struct mpt_softc *mpt)
9079b631363SMatt Jacob {
908b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "soft reset\n");
9099b631363SMatt Jacob 
9109b631363SMatt Jacob 	/* Have to use hard reset if we are not in Running state */
9119b631363SMatt Jacob 	if (MPT_STATE(mpt_rd_db(mpt)) != MPT_DB_STATE_RUNNING) {
912b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: device not running\n");
913c87e3f83SMatt Jacob 		return (MPT_FAIL);
9149b631363SMatt Jacob 	}
9159b631363SMatt Jacob 
9169b631363SMatt Jacob 	/* If door bell is in use we don't have a chance of getting
9179b631363SMatt Jacob 	 * a word in since the IOC probably crashed in message
9189b631363SMatt Jacob 	 * processing. So don't waste our time.
9199b631363SMatt Jacob 	 */
9209b631363SMatt Jacob 	if (MPT_DB_IS_IN_USE(mpt_rd_db(mpt))) {
921b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: doorbell wedged\n");
922c87e3f83SMatt Jacob 		return (MPT_FAIL);
9239b631363SMatt Jacob 	}
9249b631363SMatt Jacob 
9259b631363SMatt Jacob 	/* Send the reset request to the IOC */
9269b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_DOORBELL,
9279b631363SMatt Jacob 	    MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET << MPI_DOORBELL_FUNCTION_SHIFT);
9289b631363SMatt Jacob 	if (mpt_wait_db_ack(mpt) != MPT_OK) {
929b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: ack timeout\n");
930c87e3f83SMatt Jacob 		return (MPT_FAIL);
9319b631363SMatt Jacob 	}
9329b631363SMatt Jacob 
9339b631363SMatt Jacob 	/* Wait for the IOC to reload and come out of reset state */
9349b631363SMatt Jacob 	if (mpt_wait_state(mpt, MPT_DB_STATE_READY) != MPT_OK) {
935b0a2fdeeSScott Long 		mpt_prt(mpt, "soft reset failed: device did not restart\n");
936c87e3f83SMatt Jacob 		return (MPT_FAIL);
9379b631363SMatt Jacob 	}
9389b631363SMatt Jacob 
9399b631363SMatt Jacob 	return MPT_OK;
9409b631363SMatt Jacob }
9419b631363SMatt Jacob 
942b0a2fdeeSScott Long static int
943b0a2fdeeSScott Long mpt_enable_diag_mode(struct mpt_softc *mpt)
944b0a2fdeeSScott Long {
945b0a2fdeeSScott Long 	int try;
946b0a2fdeeSScott Long 
947b0a2fdeeSScott Long 	try = 20;
948b0a2fdeeSScott Long 	while (--try) {
949b0a2fdeeSScott Long 
950b0a2fdeeSScott Long 		if ((mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC) & MPI_DIAG_DRWE) != 0)
951b0a2fdeeSScott Long 			break;
952b0a2fdeeSScott Long 
953b0a2fdeeSScott Long 		/* Enable diagnostic registers */
954b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFF);
955b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_1ST_KEY_VALUE);
956b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_2ND_KEY_VALUE);
957b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_3RD_KEY_VALUE);
958b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_4TH_KEY_VALUE);
959b0a2fdeeSScott Long 		mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_5TH_KEY_VALUE);
960b0a2fdeeSScott Long 
961b0a2fdeeSScott Long 		DELAY(100000);
962b0a2fdeeSScott Long 	}
963b0a2fdeeSScott Long 	if (try == 0)
964b0a2fdeeSScott Long 		return (EIO);
965b0a2fdeeSScott Long 	return (0);
966b0a2fdeeSScott Long }
967b0a2fdeeSScott Long 
968b0a2fdeeSScott Long static void
969b0a2fdeeSScott Long mpt_disable_diag_mode(struct mpt_softc *mpt)
970b0a2fdeeSScott Long {
971b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFFFFFFFF);
972b0a2fdeeSScott Long }
973b0a2fdeeSScott Long 
9749b631363SMatt Jacob /* This is a magic diagnostic reset that resets all the ARM
9759b631363SMatt Jacob  * processors in the chip.
9769b631363SMatt Jacob  */
977b0a2fdeeSScott Long static void
978b0a2fdeeSScott Long mpt_hard_reset(struct mpt_softc *mpt)
9799b631363SMatt Jacob {
980b0a2fdeeSScott Long 	int error;
981b0a2fdeeSScott Long 	int wait;
982b0a2fdeeSScott Long 	uint32_t diagreg;
9839b631363SMatt Jacob 
984b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "hard reset\n");
985b0a2fdeeSScott Long 
986b0a2fdeeSScott Long 	error = mpt_enable_diag_mode(mpt);
987b0a2fdeeSScott Long 	if (error) {
988b0a2fdeeSScott Long 		mpt_prt(mpt, "WARNING - Could not enter diagnostic mode !\n");
989b0a2fdeeSScott Long 		mpt_prt(mpt, "Trying to reset anyway.\n");
990b0a2fdeeSScott Long 	}
991b0a2fdeeSScott Long 
992b0a2fdeeSScott Long 	diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
993b0a2fdeeSScott Long 
994b0a2fdeeSScott Long 	/*
995b0a2fdeeSScott Long 	 * This appears to be a workaround required for some
996b0a2fdeeSScott Long 	 * firmware or hardware revs.
997b0a2fdeeSScott Long 	 */
998b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_DISABLE_ARM);
999b0a2fdeeSScott Long 	DELAY(1000);
10009b631363SMatt Jacob 
10019b631363SMatt Jacob 	/* Diag. port is now active so we can now hit the reset bit */
1002b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_RESET_ADAPTER);
10039b631363SMatt Jacob 
1004b0a2fdeeSScott Long         /*
1005b0a2fdeeSScott Long          * Ensure that the reset has finished.  We delay 1ms
1006b0a2fdeeSScott Long          * prior to reading the register to make sure the chip
1007b0a2fdeeSScott Long          * has sufficiently completed its reset to handle register
1008b0a2fdeeSScott Long          * accesses.
1009b0a2fdeeSScott Long          */
1010b0a2fdeeSScott Long 	wait = 5000;
1011b0a2fdeeSScott Long 	do {
1012b0a2fdeeSScott Long 		DELAY(1000);
1013b0a2fdeeSScott Long 		diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
1014b0a2fdeeSScott Long 	} while (--wait && (diagreg & MPI_DIAG_RESET_ADAPTER) == 0);
10159b631363SMatt Jacob 
1016b0a2fdeeSScott Long 	if (wait == 0) {
1017b0a2fdeeSScott Long 		mpt_prt(mpt, "WARNING - Failed hard reset! "
1018b0a2fdeeSScott Long 			"Trying to initialize anyway.\n");
10199b631363SMatt Jacob 	}
10209b631363SMatt Jacob 
1021b0a2fdeeSScott Long 	/*
1022b0a2fdeeSScott Long 	 * If we have firmware to download, it must be loaded before
1023b0a2fdeeSScott Long 	 * the controller will become operational.  Do so now.
1024b0a2fdeeSScott Long 	 */
1025b0a2fdeeSScott Long 	if (mpt->fw_image != NULL) {
1026b0a2fdeeSScott Long 
1027b0a2fdeeSScott Long 		error = mpt_download_fw(mpt);
1028b0a2fdeeSScott Long 
1029b0a2fdeeSScott Long 		if (error) {
1030b0a2fdeeSScott Long 			mpt_prt(mpt, "WARNING - Firmware Download Failed!\n");
1031b0a2fdeeSScott Long 			mpt_prt(mpt, "Trying to initialize anyway.\n");
10329b631363SMatt Jacob 		}
1033b0a2fdeeSScott Long 	}
1034b0a2fdeeSScott Long 
1035b0a2fdeeSScott Long 	/*
1036b0a2fdeeSScott Long 	 * Reseting the controller should have disabled write
1037b0a2fdeeSScott Long 	 * access to the diagnostic registers, but disable
1038b0a2fdeeSScott Long 	 * manually to be sure.
1039b0a2fdeeSScott Long 	 */
1040b0a2fdeeSScott Long 	mpt_disable_diag_mode(mpt);
1041b0a2fdeeSScott Long }
1042b0a2fdeeSScott Long 
1043b0a2fdeeSScott Long static void
1044b0a2fdeeSScott Long mpt_core_ioc_reset(struct mpt_softc *mpt, int type)
1045b0a2fdeeSScott Long {
1046b0a2fdeeSScott Long 	/*
1047b0a2fdeeSScott Long 	 * Complete all pending requests with a status
1048b0a2fdeeSScott Long 	 * appropriate for an IOC reset.
1049b0a2fdeeSScott Long 	 */
1050b0a2fdeeSScott Long 	mpt_complete_request_chain(mpt, &mpt->request_pending_list,
1051b0a2fdeeSScott Long 				   MPI_IOCSTATUS_INVALID_STATE);
1052b0a2fdeeSScott Long }
1053b0a2fdeeSScott Long 
10549b631363SMatt Jacob 
10559b631363SMatt Jacob /*
10569b631363SMatt Jacob  * Reset the IOC when needed. Try software command first then if needed
10579b631363SMatt Jacob  * poke at the magic diagnostic reset. Note that a hard reset resets
10589b631363SMatt Jacob  * *both* IOCs on dual function chips (FC929 && LSI1030) as well as
10599b631363SMatt Jacob  * fouls up the PCI configuration registers.
10609b631363SMatt Jacob  */
10619b631363SMatt Jacob int
1062b0a2fdeeSScott Long mpt_reset(struct mpt_softc *mpt, int reinit)
10639b631363SMatt Jacob {
1064b0a2fdeeSScott Long 	struct	mpt_personality *pers;
10659b631363SMatt Jacob 	int	ret;
106629ae59edSMatt Jacob 	int	retry_cnt = 0;
10679b631363SMatt Jacob 
106829ae59edSMatt Jacob 	/*
106929ae59edSMatt Jacob 	 * Try a soft reset. If that fails, get out the big hammer.
107029ae59edSMatt Jacob 	 */
107129ae59edSMatt Jacob  again:
10729b631363SMatt Jacob 	if ((ret = mpt_soft_reset(mpt)) != MPT_OK) {
107329ae59edSMatt Jacob 		int	cnt;
107429ae59edSMatt Jacob 		for (cnt = 0; cnt < 5; cnt++) {
10759b631363SMatt Jacob 			/* Failed; do a hard reset */
10769b631363SMatt Jacob 			mpt_hard_reset(mpt);
10779b631363SMatt Jacob 
107829ae59edSMatt Jacob 			/*
107929ae59edSMatt Jacob 			 * Wait for the IOC to reload
108029ae59edSMatt Jacob 			 * and come out of reset state
108129ae59edSMatt Jacob 			 */
10829b631363SMatt Jacob 			ret = mpt_wait_state(mpt, MPT_DB_STATE_READY);
108329ae59edSMatt Jacob 			if (ret == MPT_OK) {
108429ae59edSMatt Jacob 				break;
108529ae59edSMatt Jacob 			}
108629ae59edSMatt Jacob 			/*
108729ae59edSMatt Jacob 			 * Okay- try to check again...
108829ae59edSMatt Jacob 			 */
108929ae59edSMatt Jacob 			ret = mpt_wait_state(mpt, MPT_DB_STATE_READY);
109029ae59edSMatt Jacob 			if (ret == MPT_OK) {
109129ae59edSMatt Jacob 				break;
109229ae59edSMatt Jacob 			}
109329ae59edSMatt Jacob 			mpt_prt(mpt, "mpt_reset: failed hard reset (%d:%d)\n",
109429ae59edSMatt Jacob 			    retry_cnt, cnt);
109529ae59edSMatt Jacob 		}
10969b631363SMatt Jacob 	}
1097b0a2fdeeSScott Long 
109829ae59edSMatt Jacob 	if (retry_cnt == 0) {
1099b0a2fdeeSScott Long 		/*
1100b0a2fdeeSScott Long 		 * Invoke reset handlers.  We bump the reset count so
1101b0a2fdeeSScott Long 		 * that mpt_wait_req() understands that regardless of
1102b0a2fdeeSScott Long 		 * the specified wait condition, it should stop its wait.
1103b0a2fdeeSScott Long 		 */
1104b0a2fdeeSScott Long 		mpt->reset_cnt++;
1105b0a2fdeeSScott Long 		MPT_PERS_FOREACH(mpt, pers)
1106b0a2fdeeSScott Long 			pers->reset(mpt, ret);
110729ae59edSMatt Jacob 	}
1108b0a2fdeeSScott Long 
11095e073106SMatt Jacob 	if (reinit) {
1110c87e3f83SMatt Jacob 		ret = mpt_enable_ioc(mpt, 1);
111129ae59edSMatt Jacob 		if (ret == MPT_OK) {
111229ae59edSMatt Jacob 			mpt_enable_ints(mpt);
111329ae59edSMatt Jacob 		}
111429ae59edSMatt Jacob 	}
111529ae59edSMatt Jacob 	if (ret != MPT_OK && retry_cnt++ < 2) {
111629ae59edSMatt Jacob 		goto again;
111729ae59edSMatt Jacob 	}
11189b631363SMatt Jacob 	return ret;
11199b631363SMatt Jacob }
11209b631363SMatt Jacob 
11219b631363SMatt Jacob /* Return a command buffer to the free queue */
11229b631363SMatt Jacob void
1123b0a2fdeeSScott Long mpt_free_request(struct mpt_softc *mpt, request_t *req)
11249b631363SMatt Jacob {
1125444dd2b6SMatt Jacob 	request_t *nxt;
1126b0a2fdeeSScott Long 	struct mpt_evtf_record *record;
1127b0a2fdeeSScott Long 	uint32_t reply_baddr;
1128b0a2fdeeSScott Long 
11297dec90bcSMatt Jacob 	if (req == NULL || req != &mpt->request_pool[req->index]) {
11309b631363SMatt Jacob 		panic("mpt_free_request bad req ptr\n");
11319b631363SMatt Jacob 		return;
11329b631363SMatt Jacob 	}
1133444dd2b6SMatt Jacob 	if ((nxt = req->chain) != NULL) {
1134444dd2b6SMatt Jacob 		req->chain = NULL;
1135444dd2b6SMatt Jacob 		mpt_free_request(mpt, nxt);	/* NB: recursion */
1136444dd2b6SMatt Jacob 	}
11375e073106SMatt Jacob 	KASSERT(req->state != REQ_STATE_FREE, ("freeing free request"));
11385e073106SMatt Jacob 	KASSERT(!(req->state & REQ_STATE_LOCKED), ("freeing locked request"));
11395089bd63SMatt Jacob 	KASSERT(MPT_OWNED(mpt), ("mpt_free_request: mpt not locked\n"));
11405089bd63SMatt Jacob 	KASSERT(mpt_req_on_free_list(mpt, req) == 0,
11415089bd63SMatt Jacob 	    ("mpt_free_request: req %p:%u func %x already on freelist",
11425089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
11435089bd63SMatt Jacob 	KASSERT(mpt_req_on_pending_list(mpt, req) == 0,
11445089bd63SMatt Jacob 	    ("mpt_free_request: req %p:%u func %x on pending list",
11455089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
11465089bd63SMatt Jacob #ifdef	INVARIANTS
11475089bd63SMatt Jacob 	mpt_req_not_spcl(mpt, req, "mpt_free_request", __LINE__);
11485089bd63SMatt Jacob #endif
11495e073106SMatt Jacob 
11509b631363SMatt Jacob 	req->ccb = NULL;
1151b0a2fdeeSScott Long 	if (LIST_EMPTY(&mpt->ack_frames)) {
1152c87e3f83SMatt Jacob 		/*
1153c87e3f83SMatt Jacob 		 * Insert free ones at the tail
1154c87e3f83SMatt Jacob 		 */
11555e073106SMatt Jacob 		req->serno = 0;
11565e073106SMatt Jacob 		req->state = REQ_STATE_FREE;
11575089bd63SMatt Jacob #ifdef	INVARIANTS
11585089bd63SMatt Jacob 		memset(req->req_vbuf, 0xff, sizeof (MSG_REQUEST_HEADER));
11595089bd63SMatt Jacob #endif
1160c87e3f83SMatt Jacob 		TAILQ_INSERT_TAIL(&mpt->request_free_list, req, links);
1161b0a2fdeeSScott Long 		if (mpt->getreqwaiter != 0) {
1162b0a2fdeeSScott Long 			mpt->getreqwaiter = 0;
1163b0a2fdeeSScott Long 			wakeup(&mpt->request_free_list);
1164b0a2fdeeSScott Long 		}
1165b0a2fdeeSScott Long 		return;
1166b0a2fdeeSScott Long 	}
1167b0a2fdeeSScott Long 
1168b0a2fdeeSScott Long 	/*
1169b0a2fdeeSScott Long 	 * Process an ack frame deferred due to resource shortage.
1170b0a2fdeeSScott Long 	 */
1171b0a2fdeeSScott Long 	record = LIST_FIRST(&mpt->ack_frames);
1172b0a2fdeeSScott Long 	LIST_REMOVE(record, links);
11735e073106SMatt Jacob 	req->state = REQ_STATE_ALLOCATED;
11745089bd63SMatt Jacob 	mpt_assign_serno(mpt, req);
1175b0a2fdeeSScott Long 	mpt_send_event_ack(mpt, req, &record->reply, record->context);
1176b0a2fdeeSScott Long 	reply_baddr = (uint32_t)((uint8_t *)record - mpt->reply)
1177b0a2fdeeSScott Long 		    + (mpt->reply_phys & 0xFFFFFFFF);
1178b0a2fdeeSScott Long 	mpt_free_reply(mpt, reply_baddr);
11799b631363SMatt Jacob }
11809b631363SMatt Jacob 
11819b631363SMatt Jacob /* Get a command buffer from the free queue */
11829b631363SMatt Jacob request_t *
1183b0a2fdeeSScott Long mpt_get_request(struct mpt_softc *mpt, int sleep_ok)
11849b631363SMatt Jacob {
11859b631363SMatt Jacob 	request_t *req;
1186b0a2fdeeSScott Long 
1187b0a2fdeeSScott Long retry:
11885089bd63SMatt Jacob 	KASSERT(MPT_OWNED(mpt), ("mpt_get_request: mpt not locked\n"));
1189b0a2fdeeSScott Long 	req = TAILQ_FIRST(&mpt->request_free_list);
11909b631363SMatt Jacob 	if (req != NULL) {
1191b0a2fdeeSScott Long 		KASSERT(req == &mpt->request_pool[req->index],
1192b0a2fdeeSScott Long 		    ("mpt_get_request: corrupted request free list\n"));
11935e073106SMatt Jacob 		KASSERT(req->state == REQ_STATE_FREE,
11945089bd63SMatt Jacob 		    ("req %p:%u not free on free list %x index %d function %x",
11955089bd63SMatt Jacob 		    req, req->serno, req->state, req->index,
11965089bd63SMatt Jacob 		    ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
1197b0a2fdeeSScott Long 		TAILQ_REMOVE(&mpt->request_free_list, req, links);
1198b0a2fdeeSScott Long 		req->state = REQ_STATE_ALLOCATED;
1199444dd2b6SMatt Jacob 		req->chain = NULL;
12005089bd63SMatt Jacob 		mpt_assign_serno(mpt, req);
1201b0a2fdeeSScott Long 	} else if (sleep_ok != 0) {
1202b0a2fdeeSScott Long 		mpt->getreqwaiter = 1;
1203b0a2fdeeSScott Long 		mpt_sleep(mpt, &mpt->request_free_list, PUSER, "mptgreq", 0);
1204b0a2fdeeSScott Long 		goto retry;
12059b631363SMatt Jacob 	}
12065e073106SMatt Jacob 	return (req);
12079b631363SMatt Jacob }
12089b631363SMatt Jacob 
12099b631363SMatt Jacob /* Pass the command to the IOC */
12109b631363SMatt Jacob void
1211b0a2fdeeSScott Long mpt_send_cmd(struct mpt_softc *mpt, request_t *req)
12129b631363SMatt Jacob {
12131d79ca0eSMatt Jacob 	if (mpt->verbose > MPT_PRT_DEBUG2) {
12141043516dSMatt Jacob 		mpt_dump_request(mpt, req);
1215444dd2b6SMatt Jacob 	}
12169b631363SMatt Jacob 	bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
12179b631363SMatt Jacob 	    BUS_DMASYNC_PREWRITE);
1218b0a2fdeeSScott Long 	req->state |= REQ_STATE_QUEUED;
12195089bd63SMatt Jacob 	KASSERT(mpt_req_on_free_list(mpt, req) == 0,
12205089bd63SMatt Jacob 	    ("req %p:%u func %x on freelist list in mpt_send_cmd",
12215089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
12225089bd63SMatt Jacob 	KASSERT(mpt_req_on_pending_list(mpt, req) == 0,
12235089bd63SMatt Jacob 	    ("req %p:%u func %x already on pending list in mpt_send_cmd",
12245089bd63SMatt Jacob 	    req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function));
1225b0a2fdeeSScott Long 	TAILQ_INSERT_HEAD(&mpt->request_pending_list, req, links);
1226b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_REQUEST_Q, (uint32_t) req->req_pbuf);
12279b631363SMatt Jacob }
12289b631363SMatt Jacob 
12299b631363SMatt Jacob /*
1230b0a2fdeeSScott Long  * Wait for a request to complete.
1231b0a2fdeeSScott Long  *
1232b0a2fdeeSScott Long  * Inputs:
1233b0a2fdeeSScott Long  *	mpt		softc of controller executing request
1234b0a2fdeeSScott Long  *	req		request to wait for
1235b0a2fdeeSScott Long  *	sleep_ok	nonzero implies may sleep in this context
1236b0a2fdeeSScott Long  *	time_ms		timeout in ms.  0 implies no timeout.
1237b0a2fdeeSScott Long  *
1238b0a2fdeeSScott Long  * Return Values:
1239b0a2fdeeSScott Long  *	0		Request completed
1240b0a2fdeeSScott Long  *	non-0		Timeout fired before request completion.
12419b631363SMatt Jacob  */
1242b0a2fdeeSScott Long int
1243b0a2fdeeSScott Long mpt_wait_req(struct mpt_softc *mpt, request_t *req,
1244b0a2fdeeSScott Long 	     mpt_req_state_t state, mpt_req_state_t mask,
1245b0a2fdeeSScott Long 	     int sleep_ok, int time_ms)
12469b631363SMatt Jacob {
1247b0a2fdeeSScott Long 	int   error;
1248b0a2fdeeSScott Long 	int   timeout;
1249b0a2fdeeSScott Long 	u_int saved_cnt;
12509b631363SMatt Jacob 
1251b0a2fdeeSScott Long 	/*
1252b0a2fdeeSScott Long 	 * timeout is in ms.  0 indicates infinite wait.
1253b0a2fdeeSScott Long 	 * Convert to ticks or 500us units depending on
1254b0a2fdeeSScott Long 	 * our sleep mode.
1255b0a2fdeeSScott Long 	 */
1256c87e3f83SMatt Jacob 	if (sleep_ok != 0) {
1257b0a2fdeeSScott Long 		timeout = (time_ms * hz) / 1000;
1258c87e3f83SMatt Jacob 	} else {
1259b0a2fdeeSScott Long 		timeout = time_ms * 2;
1260c87e3f83SMatt Jacob 	}
1261b0a2fdeeSScott Long 	req->state |= REQ_STATE_NEED_WAKEUP;
1262b0a2fdeeSScott Long 	mask &= ~REQ_STATE_NEED_WAKEUP;
1263444dd2b6SMatt Jacob 	saved_cnt = mpt->reset_cnt;
1264c87e3f83SMatt Jacob 	while ((req->state & mask) != state && mpt->reset_cnt == saved_cnt) {
1265b0a2fdeeSScott Long 		if (sleep_ok != 0) {
1266b0a2fdeeSScott Long 			error = mpt_sleep(mpt, req, PUSER, "mptreq", timeout);
1267b0a2fdeeSScott Long 			if (error == EWOULDBLOCK) {
1268b0a2fdeeSScott Long 				timeout = 0;
1269b0a2fdeeSScott Long 				break;
1270b0a2fdeeSScott Long 			}
1271b0a2fdeeSScott Long 		} else {
1272b0a2fdeeSScott Long 			if (time_ms != 0 && --timeout == 0) {
1273b0a2fdeeSScott Long 				break;
1274b0a2fdeeSScott Long 			}
1275b0a2fdeeSScott Long 			DELAY(500);
1276b0a2fdeeSScott Long 			mpt_intr(mpt);
1277b0a2fdeeSScott Long 		}
1278b0a2fdeeSScott Long 	}
1279b0a2fdeeSScott Long 	req->state &= ~REQ_STATE_NEED_WAKEUP;
1280c87e3f83SMatt Jacob 	if (mpt->reset_cnt != saved_cnt) {
1281b0a2fdeeSScott Long 		return (EIO);
1282c87e3f83SMatt Jacob 	}
1283c87e3f83SMatt Jacob 	if (time_ms && timeout <= 0) {
1284c87e3f83SMatt Jacob 		MSG_REQUEST_HEADER *msg_hdr = req->req_vbuf;
1285c87e3f83SMatt Jacob 		mpt_prt(mpt, "mpt_wait_req(%x) timed out\n", msg_hdr->Function);
1286b0a2fdeeSScott Long 		return (ETIMEDOUT);
1287c87e3f83SMatt Jacob 	}
1288b0a2fdeeSScott Long 	return (0);
12899b631363SMatt Jacob }
12909b631363SMatt Jacob 
12919b631363SMatt Jacob /*
12929b631363SMatt Jacob  * Send a command to the IOC via the handshake register.
12939b631363SMatt Jacob  *
12949b631363SMatt Jacob  * Only done at initialization time and for certain unusual
12959b631363SMatt Jacob  * commands such as device/bus reset as specified by LSI.
12969b631363SMatt Jacob  */
12979b631363SMatt Jacob int
1298b0a2fdeeSScott Long mpt_send_handshake_cmd(struct mpt_softc *mpt, size_t len, void *cmd)
12999b631363SMatt Jacob {
13009b631363SMatt Jacob 	int i;
1301b0a2fdeeSScott Long 	uint32_t data, *data32;
13029b631363SMatt Jacob 
13039b631363SMatt Jacob 	/* Check condition of the IOC */
13049b631363SMatt Jacob 	data = mpt_rd_db(mpt);
1305b0a2fdeeSScott Long 	if ((MPT_STATE(data) != MPT_DB_STATE_READY
1306b0a2fdeeSScott Long 	  && MPT_STATE(data) != MPT_DB_STATE_RUNNING
1307b0a2fdeeSScott Long 	  && MPT_STATE(data) != MPT_DB_STATE_FAULT)
1308b0a2fdeeSScott Long 	 || MPT_DB_IS_IN_USE(data)) {
1309b0a2fdeeSScott Long 		mpt_prt(mpt, "handshake aborted - invalid doorbell state\n");
13109b631363SMatt Jacob 		mpt_print_db(data);
13119b631363SMatt Jacob 		return (EBUSY);
13129b631363SMatt Jacob 	}
13139b631363SMatt Jacob 
13149b631363SMatt Jacob 	/* We move things in 32 bit chunks */
13159b631363SMatt Jacob 	len = (len + 3) >> 2;
13169b631363SMatt Jacob 	data32 = cmd;
13179b631363SMatt Jacob 
13189b631363SMatt Jacob 	/* Clear any left over pending doorbell interupts */
13199b631363SMatt Jacob 	if (MPT_DB_INTR(mpt_rd_intr(mpt)))
13209b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13219b631363SMatt Jacob 
13229b631363SMatt Jacob 	/*
13239b631363SMatt Jacob 	 * Tell the handshake reg. we are going to send a command
13249b631363SMatt Jacob          * and how long it is going to be.
13259b631363SMatt Jacob 	 */
13269b631363SMatt Jacob 	data = (MPI_FUNCTION_HANDSHAKE << MPI_DOORBELL_FUNCTION_SHIFT) |
13279b631363SMatt Jacob 	    (len << MPI_DOORBELL_ADD_DWORDS_SHIFT);
13289b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_DOORBELL, data);
13299b631363SMatt Jacob 
13309b631363SMatt Jacob 	/* Wait for the chip to notice */
13319b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1332b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_handshake_cmd timeout1\n");
1333b0a2fdeeSScott Long 		return (ETIMEDOUT);
13349b631363SMatt Jacob 	}
13359b631363SMatt Jacob 
13369b631363SMatt Jacob 	/* Clear the interrupt */
13379b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13389b631363SMatt Jacob 
13399b631363SMatt Jacob 	if (mpt_wait_db_ack(mpt) != MPT_OK) {
1340b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_handshake_cmd timeout2\n");
1341b0a2fdeeSScott Long 		return (ETIMEDOUT);
13429b631363SMatt Jacob 	}
13439b631363SMatt Jacob 
13449b631363SMatt Jacob 	/* Send the command */
13459b631363SMatt Jacob 	for (i = 0; i < len; i++) {
13469b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_DOORBELL, *data32++);
13479b631363SMatt Jacob 		if (mpt_wait_db_ack(mpt) != MPT_OK) {
1348301472c2SMatt Jacob 			mpt_prt(mpt,
1349b0a2fdeeSScott Long 				"mpt_send_handshake_cmd timeout! index = %d\n",
1350b0a2fdeeSScott Long 				i);
1351b0a2fdeeSScott Long 			return (ETIMEDOUT);
13529b631363SMatt Jacob 		}
13539b631363SMatt Jacob 	}
13549b631363SMatt Jacob 	return MPT_OK;
13559b631363SMatt Jacob }
13569b631363SMatt Jacob 
13579b631363SMatt Jacob /* Get the response from the handshake register */
13589b631363SMatt Jacob int
1359b0a2fdeeSScott Long mpt_recv_handshake_reply(struct mpt_softc *mpt, size_t reply_len, void *reply)
13609b631363SMatt Jacob {
13619b631363SMatt Jacob 	int left, reply_left;
13629b631363SMatt Jacob 	u_int16_t *data16;
13639b631363SMatt Jacob 	MSG_DEFAULT_REPLY *hdr;
13649b631363SMatt Jacob 
13659b631363SMatt Jacob 	/* We move things out in 16 bit chunks */
13669b631363SMatt Jacob 	reply_len >>= 1;
13679b631363SMatt Jacob 	data16 = (u_int16_t *)reply;
13689b631363SMatt Jacob 
13699b631363SMatt Jacob 	hdr = (MSG_DEFAULT_REPLY *)reply;
13709b631363SMatt Jacob 
13719b631363SMatt Jacob 	/* Get first word */
13729b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1373b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout1\n");
13749b631363SMatt Jacob 		return ETIMEDOUT;
13759b631363SMatt Jacob 	}
13769b631363SMatt Jacob 	*data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
13779b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13789b631363SMatt Jacob 
13799b631363SMatt Jacob 	/* Get Second Word */
13809b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1381b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout2\n");
13829b631363SMatt Jacob 		return ETIMEDOUT;
13839b631363SMatt Jacob 	}
13849b631363SMatt Jacob 	*data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK;
13859b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
13869b631363SMatt Jacob 
13875e073106SMatt Jacob 	/*
13885e073106SMatt Jacob 	 * With the second word, we can now look at the length.
13895e073106SMatt Jacob 	 * Warn about a reply that's too short (except for IOC FACTS REPLY)
13905e073106SMatt Jacob 	 */
13915e073106SMatt Jacob 	if ((reply_len >> 1) != hdr->MsgLength &&
13925e073106SMatt Jacob 	    (hdr->Function != MPI_FUNCTION_IOC_FACTS)){
13935e073106SMatt Jacob #if __FreeBSD_version >= 500000
1394301472c2SMatt Jacob 		mpt_prt(mpt, "reply length does not match message length: "
139533f31846SMatt Jacob 			"got %x; expected %zx for function %x\n",
13965e073106SMatt Jacob 			hdr->MsgLength << 2, reply_len << 1, hdr->Function);
13975e073106SMatt Jacob #else
13985e073106SMatt Jacob 		mpt_prt(mpt, "reply length does not match message length: "
139933f31846SMatt Jacob 			"got %x; expected %x for function %x\n",
14005e073106SMatt Jacob 			hdr->MsgLength << 2, reply_len << 1, hdr->Function);
14015e073106SMatt Jacob #endif
14029b631363SMatt Jacob 	}
14039b631363SMatt Jacob 
14049b631363SMatt Jacob 	/* Get rest of the reply; but don't overflow the provided buffer */
14059b631363SMatt Jacob 	left = (hdr->MsgLength << 1) - 2;
14069b631363SMatt Jacob 	reply_left =  reply_len - 2;
14079b631363SMatt Jacob 	while (left--) {
14089b631363SMatt Jacob 		u_int16_t datum;
14099b631363SMatt Jacob 
14109b631363SMatt Jacob 		if (mpt_wait_db_int(mpt) != MPT_OK) {
1411b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_recv_handshake_cmd timeout3\n");
14129b631363SMatt Jacob 			return ETIMEDOUT;
14139b631363SMatt Jacob 		}
14149b631363SMatt Jacob 		datum = mpt_read(mpt, MPT_OFFSET_DOORBELL);
14159b631363SMatt Jacob 
14169b631363SMatt Jacob 		if (reply_left-- > 0)
14179b631363SMatt Jacob 			*data16++ = datum & MPT_DB_DATA_MASK;
14189b631363SMatt Jacob 
14199b631363SMatt Jacob 		mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
14209b631363SMatt Jacob 	}
14219b631363SMatt Jacob 
14229b631363SMatt Jacob 	/* One more wait & clear at the end */
14239b631363SMatt Jacob 	if (mpt_wait_db_int(mpt) != MPT_OK) {
1424b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_recv_handshake_cmd timeout4\n");
14259b631363SMatt Jacob 		return ETIMEDOUT;
14269b631363SMatt Jacob 	}
14279b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0);
14289b631363SMatt Jacob 
14299b631363SMatt Jacob 	if ((hdr->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1430b0a2fdeeSScott Long 		if (mpt->verbose >= MPT_PRT_TRACE)
14319b631363SMatt Jacob 			mpt_print_reply(hdr);
14329b631363SMatt Jacob 		return (MPT_FAIL | hdr->IOCStatus);
14339b631363SMatt Jacob 	}
14349b631363SMatt Jacob 
14359b631363SMatt Jacob 	return (0);
14369b631363SMatt Jacob }
14379b631363SMatt Jacob 
14389b631363SMatt Jacob static int
1439b0a2fdeeSScott Long mpt_get_iocfacts(struct mpt_softc *mpt, MSG_IOC_FACTS_REPLY *freplp)
14409b631363SMatt Jacob {
14419b631363SMatt Jacob 	MSG_IOC_FACTS f_req;
14429b631363SMatt Jacob 	int error;
14439b631363SMatt Jacob 
14445e073106SMatt Jacob 	memset(&f_req, 0, sizeof f_req);
14459b631363SMatt Jacob 	f_req.Function = MPI_FUNCTION_IOC_FACTS;
1446b0a2fdeeSScott Long 	f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14479b631363SMatt Jacob 	error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
14489b631363SMatt Jacob 	if (error)
14499b631363SMatt Jacob 		return(error);
14509b631363SMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
14519b631363SMatt Jacob 	return (error);
14529b631363SMatt Jacob }
14539b631363SMatt Jacob 
14547104aeefSMatt Jacob static int
1455b0a2fdeeSScott Long mpt_get_portfacts(struct mpt_softc *mpt, MSG_PORT_FACTS_REPLY *freplp)
14567104aeefSMatt Jacob {
14577104aeefSMatt Jacob 	MSG_PORT_FACTS f_req;
14587104aeefSMatt Jacob 	int error;
14597104aeefSMatt Jacob 
14607104aeefSMatt Jacob 	/* XXX: Only getting PORT FACTS for Port 0 */
1461b0a2fdeeSScott Long 	memset(&f_req, 0, sizeof f_req);
14627104aeefSMatt Jacob 	f_req.Function = MPI_FUNCTION_PORT_FACTS;
1463b0a2fdeeSScott Long 	f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14647104aeefSMatt Jacob 	error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req);
14657104aeefSMatt Jacob 	if (error)
14667104aeefSMatt Jacob 		return(error);
14677104aeefSMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp);
14687104aeefSMatt Jacob 	return (error);
14697104aeefSMatt Jacob }
14707104aeefSMatt Jacob 
14719b631363SMatt Jacob /*
14729b631363SMatt Jacob  * Send the initialization request. This is where we specify how many
14739b631363SMatt Jacob  * SCSI busses and how many devices per bus we wish to emulate.
14749b631363SMatt Jacob  * This is also the command that specifies the max size of the reply
14759b631363SMatt Jacob  * frames from the IOC that we will be allocating.
14769b631363SMatt Jacob  */
14779b631363SMatt Jacob static int
1478b0a2fdeeSScott Long mpt_send_ioc_init(struct mpt_softc *mpt, uint32_t who)
14799b631363SMatt Jacob {
14809b631363SMatt Jacob 	int error = 0;
14819b631363SMatt Jacob 	MSG_IOC_INIT init;
14829b631363SMatt Jacob 	MSG_IOC_INIT_REPLY reply;
14839b631363SMatt Jacob 
14845e073106SMatt Jacob 	memset(&init, 0, sizeof init);
14859b631363SMatt Jacob 	init.WhoInit = who;
14869b631363SMatt Jacob 	init.Function = MPI_FUNCTION_IOC_INIT;
1487444dd2b6SMatt Jacob 	init.MaxDevices = mpt->mpt_max_devices;
14889b631363SMatt Jacob 	init.MaxBuses = 1;
1489444dd2b6SMatt Jacob 
1490444dd2b6SMatt Jacob 	init.MsgVersion = htole16(MPI_VERSION);
1491444dd2b6SMatt Jacob 	init.HeaderVersion = htole16(MPI_HEADER_VERSION);
1492444dd2b6SMatt Jacob 	init.ReplyFrameSize = htole16(MPT_REPLY_SIZE);
1493b0a2fdeeSScott Long 	init.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
14949b631363SMatt Jacob 
14959b631363SMatt Jacob 	if ((error = mpt_send_handshake_cmd(mpt, sizeof init, &init)) != 0) {
14969b631363SMatt Jacob 		return(error);
14979b631363SMatt Jacob 	}
14989b631363SMatt Jacob 
14999b631363SMatt Jacob 	error = mpt_recv_handshake_reply(mpt, sizeof reply, &reply);
15009b631363SMatt Jacob 	return (error);
15019b631363SMatt Jacob }
15029b631363SMatt Jacob 
15037104aeefSMatt Jacob 
15047104aeefSMatt Jacob /*
15057104aeefSMatt Jacob  * Utiltity routine to read configuration headers and pages
15067104aeefSMatt Jacob  */
1507b0a2fdeeSScott Long int
1508b0a2fdeeSScott Long mpt_issue_cfg_req(struct mpt_softc *mpt, request_t *req, u_int Action,
1509b0a2fdeeSScott Long 		  u_int PageVersion, u_int PageLength, u_int PageNumber,
1510b0a2fdeeSScott Long 		  u_int PageType, uint32_t PageAddress, bus_addr_t addr,
1511b0a2fdeeSScott Long 		  bus_size_t len, int sleep_ok, int timeout_ms)
15127104aeefSMatt Jacob {
15137104aeefSMatt Jacob 	MSG_CONFIG *cfgp;
1514b0a2fdeeSScott Long 	SGE_SIMPLE32 *se;
15157104aeefSMatt Jacob 
15167104aeefSMatt Jacob 	cfgp = req->req_vbuf;
1517b0a2fdeeSScott Long 	memset(cfgp, 0, sizeof *cfgp);
1518b0a2fdeeSScott Long 	cfgp->Action = Action;
15197104aeefSMatt Jacob 	cfgp->Function = MPI_FUNCTION_CONFIG;
1520b0a2fdeeSScott Long 	cfgp->Header.PageVersion = PageVersion;
1521b0a2fdeeSScott Long 	cfgp->Header.PageLength = PageLength;
1522b0a2fdeeSScott Long 	cfgp->Header.PageNumber = PageNumber;
1523b0a2fdeeSScott Long 	cfgp->Header.PageType = PageType;
15247104aeefSMatt Jacob 	cfgp->PageAddress = PageAddress;
1525b0a2fdeeSScott Long 	se = (SGE_SIMPLE32 *)&cfgp->PageBufferSGE;
1526b0a2fdeeSScott Long 	se->Address = addr;
1527b0a2fdeeSScott Long 	MPI_pSGE_SET_LENGTH(se, len);
1528b0a2fdeeSScott Long 	MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1529b0a2fdeeSScott Long 	    MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER |
1530b0a2fdeeSScott Long 	    MPI_SGE_FLAGS_END_OF_LIST |
1531b0a2fdeeSScott Long 	    ((Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT
1532b0a2fdeeSScott Long 	  || Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM)
1533b0a2fdeeSScott Long 	   ? MPI_SGE_FLAGS_HOST_TO_IOC : MPI_SGE_FLAGS_IOC_TO_HOST)));
1534b0a2fdeeSScott Long 	cfgp->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG);
15357104aeefSMatt Jacob 
15367104aeefSMatt Jacob 	mpt_check_doorbell(mpt);
15377104aeefSMatt Jacob 	mpt_send_cmd(mpt, req);
1538b0a2fdeeSScott Long 	return (mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE,
1539b0a2fdeeSScott Long 			     sleep_ok, timeout_ms));
15407104aeefSMatt Jacob }
15417104aeefSMatt Jacob 
1542b0a2fdeeSScott Long 
1543b0a2fdeeSScott Long int
1544b0a2fdeeSScott Long mpt_read_cfg_header(struct mpt_softc *mpt, int PageType, int PageNumber,
1545b0a2fdeeSScott Long 		    uint32_t PageAddress, CONFIG_PAGE_HEADER *rslt,
1546b0a2fdeeSScott Long 		    int sleep_ok, int timeout_ms)
1547b0a2fdeeSScott Long {
1548b0a2fdeeSScott Long 	request_t  *req;
154929ae59edSMatt Jacob 	MSG_CONFIG *cfgp;
1550b0a2fdeeSScott Long 	int	    error;
1551b0a2fdeeSScott Long 
1552b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1553b0a2fdeeSScott Long 	if (req == NULL) {
1554b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_header: Get request failed!\n");
155529ae59edSMatt Jacob 		return (ENOMEM);
15567104aeefSMatt Jacob 	}
1557b0a2fdeeSScott Long 
1558b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, MPI_CONFIG_ACTION_PAGE_HEADER,
1559b0a2fdeeSScott Long 				  /*PageVersion*/0, /*PageLength*/0, PageNumber,
1560b0a2fdeeSScott Long 				  PageType, PageAddress, /*addr*/0, /*len*/0,
1561b0a2fdeeSScott Long 				  sleep_ok, timeout_ms);
1562b0a2fdeeSScott Long 	if (error != 0) {
156329ae59edSMatt Jacob 		mpt_free_request(mpt, req);
1564b0a2fdeeSScott Long 		mpt_prt(mpt, "read_cfg_header timed out\n");
156529ae59edSMatt Jacob 		return (ETIMEDOUT);
1566b0a2fdeeSScott Long 	}
1567b0a2fdeeSScott Long 
156829ae59edSMatt Jacob         switch (req->IOCStatus & MPI_IOCSTATUS_MASK) {
156929ae59edSMatt Jacob 	case MPI_IOCSTATUS_SUCCESS:
1570b0a2fdeeSScott Long 		cfgp = req->req_vbuf;
1571b0a2fdeeSScott Long 		bcopy(&cfgp->Header, rslt, sizeof(*rslt));
1572b0a2fdeeSScott Long 		error = 0;
157329ae59edSMatt Jacob 		break;
157429ae59edSMatt Jacob 	case MPI_IOCSTATUS_CONFIG_INVALID_PAGE:
157529ae59edSMatt Jacob 		mpt_lprt(mpt, MPT_PRT_DEBUG,
157629ae59edSMatt Jacob 		    "Invalid Page Type %d Number %d Addr 0x%0x\n",
157729ae59edSMatt Jacob 		    PageType, PageNumber, PageAddress);
157829ae59edSMatt Jacob 		error = EINVAL;
157929ae59edSMatt Jacob 		break;
158029ae59edSMatt Jacob 	default:
158129ae59edSMatt Jacob 		mpt_prt(mpt, "mpt_read_cfg_header: Config Info Status %x\n",
158229ae59edSMatt Jacob 			req->IOCStatus);
158329ae59edSMatt Jacob 		error = EIO;
158429ae59edSMatt Jacob 		break;
1585b0a2fdeeSScott Long 	}
15867104aeefSMatt Jacob 	mpt_free_request(mpt, req);
1587b0a2fdeeSScott Long 	return (error);
15887104aeefSMatt Jacob }
15897104aeefSMatt Jacob 
1590ce68dae5SMatt Jacob int
1591b0a2fdeeSScott Long mpt_read_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress,
1592b0a2fdeeSScott Long 		  CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok,
1593b0a2fdeeSScott Long 		  int timeout_ms)
15947104aeefSMatt Jacob {
15957104aeefSMatt Jacob 	request_t    *req;
1596b0a2fdeeSScott Long 	int	      error;
15977104aeefSMatt Jacob 
1598b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1599b0a2fdeeSScott Long 	if (req == NULL) {
1600b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_page: Get request failed!\n");
16017104aeefSMatt Jacob 		return (-1);
16027104aeefSMatt Jacob 	}
16037104aeefSMatt Jacob 
1604b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion,
1605b0a2fdeeSScott Long 				  hdr->PageLength, hdr->PageNumber,
1606b0a2fdeeSScott Long 				  hdr->PageType & MPI_CONFIG_PAGETYPE_MASK,
1607c87e3f83SMatt Jacob 				  PageAddress, req->req_pbuf + MPT_RQSL(mpt),
1608b0a2fdeeSScott Long 				  len, sleep_ok, timeout_ms);
1609b0a2fdeeSScott Long 	if (error != 0) {
1610b0a2fdeeSScott Long 		mpt_prt(mpt, "read_cfg_page(%d) timed out\n", Action);
16117104aeefSMatt Jacob 		return (-1);
16127104aeefSMatt Jacob 	}
1613b0a2fdeeSScott Long 
1614b0a2fdeeSScott Long 	if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1615b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_read_cfg_page: Config Info Status %x\n",
1616b0a2fdeeSScott Long 			req->IOCStatus);
1617b0a2fdeeSScott Long 		mpt_free_request(mpt, req);
1618b0a2fdeeSScott Long 		return (-1);
1619b0a2fdeeSScott Long 	}
16207104aeefSMatt Jacob 	bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap,
16217104aeefSMatt Jacob 	    BUS_DMASYNC_POSTREAD);
1622c87e3f83SMatt Jacob 	memcpy(hdr, ((uint8_t *)req->req_vbuf)+MPT_RQSL(mpt), len);
16237104aeefSMatt Jacob 	mpt_free_request(mpt, req);
16247104aeefSMatt Jacob 	return (0);
16257104aeefSMatt Jacob }
16267104aeefSMatt Jacob 
1627ce68dae5SMatt Jacob int
1628b0a2fdeeSScott Long mpt_write_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress,
1629b0a2fdeeSScott Long 		   CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok,
1630b0a2fdeeSScott Long 		   int timeout_ms)
16317104aeefSMatt Jacob {
16327104aeefSMatt Jacob 	request_t    *req;
1633b0a2fdeeSScott Long 	u_int	      hdr_attr;
1634b0a2fdeeSScott Long 	int	      error;
16357104aeefSMatt Jacob 
16367104aeefSMatt Jacob 	hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK;
16377104aeefSMatt Jacob 	if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE &&
16387104aeefSMatt Jacob 	    hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) {
1639b0a2fdeeSScott Long 		mpt_prt(mpt, "page type 0x%x not changeable\n",
16407104aeefSMatt Jacob 			hdr->PageType & MPI_CONFIG_PAGETYPE_MASK);
16417104aeefSMatt Jacob 		return (-1);
16427104aeefSMatt Jacob 	}
1643b4c618c0SMatt Jacob 
1644b4c618c0SMatt Jacob #if	0
1645b4c618c0SMatt Jacob 	/*
1646b4c618c0SMatt Jacob 	 * We shouldn't mask off other bits here.
1647b4c618c0SMatt Jacob 	 */
1648b4c618c0SMatt Jacob 	hdr->PageType &= MPI_CONFIG_PAGETYPE_MASK;
1649b4c618c0SMatt Jacob #endif
16507104aeefSMatt Jacob 
1651b0a2fdeeSScott Long 	req = mpt_get_request(mpt, sleep_ok);
1652b0a2fdeeSScott Long 	if (req == NULL)
1653b0a2fdeeSScott Long 		return (-1);
16547104aeefSMatt Jacob 
1655c87e3f83SMatt Jacob 	memcpy(((caddr_t)req->req_vbuf) + MPT_RQSL(mpt), hdr, len);
1656b4c618c0SMatt Jacob 
1657b4c618c0SMatt Jacob 	/*
1658b4c618c0SMatt Jacob 	 * There isn't any point in restoring stripped out attributes
1659b4c618c0SMatt Jacob 	 * if you then mask them going down to issue the request.
1660b4c618c0SMatt Jacob 	 */
1661b4c618c0SMatt Jacob 
1662b4c618c0SMatt Jacob #if	0
1663301472c2SMatt Jacob 	/* Restore stripped out attributes */
1664301472c2SMatt Jacob 	hdr->PageType |= hdr_attr;
16657104aeefSMatt Jacob 
1666b0a2fdeeSScott Long 	error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion,
1667b0a2fdeeSScott Long 				  hdr->PageLength, hdr->PageNumber,
1668b0a2fdeeSScott Long 				  hdr->PageType & MPI_CONFIG_PAGETYPE_MASK,
1669c87e3f83SMatt Jacob 				  PageAddress, req->req_pbuf + MPT_RQSL(mpt),
1670b0a2fdeeSScott Long 				  len, sleep_ok, timeout_ms);
1671b4c618c0SMatt Jacob #else
1672b4c618c0SMatt Jacob 	error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion,
1673b4c618c0SMatt Jacob 				  hdr->PageLength, hdr->PageNumber,
1674b4c618c0SMatt Jacob 				  hdr->PageType, PageAddress,
1675b4c618c0SMatt Jacob 				  req->req_pbuf + MPT_RQSL(mpt),
1676b4c618c0SMatt Jacob 				  len, sleep_ok, timeout_ms);
1677b4c618c0SMatt Jacob #endif
1678b0a2fdeeSScott Long 	if (error != 0) {
1679b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_write_cfg_page timed out\n");
16807104aeefSMatt Jacob 		return (-1);
16817104aeefSMatt Jacob 	}
16827104aeefSMatt Jacob 
1683b0a2fdeeSScott Long         if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) {
1684b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_write_cfg_page: Config Info Status %x\n",
1685b0a2fdeeSScott Long 			req->IOCStatus);
16867104aeefSMatt Jacob 		mpt_free_request(mpt, req);
1687b0a2fdeeSScott Long 		return (-1);
1688b0a2fdeeSScott Long 	}
1689b0a2fdeeSScott Long 	mpt_free_request(mpt, req);
1690b0a2fdeeSScott Long 	return (0);
1691b0a2fdeeSScott Long }
1692b0a2fdeeSScott Long 
1693b0a2fdeeSScott Long /*
1694b0a2fdeeSScott Long  * Read IOC configuration information
1695b0a2fdeeSScott Long  */
1696b0a2fdeeSScott Long static int
1697b0a2fdeeSScott Long mpt_read_config_info_ioc(struct mpt_softc *mpt)
1698b0a2fdeeSScott Long {
1699b0a2fdeeSScott Long 	CONFIG_PAGE_HEADER hdr;
1700b0a2fdeeSScott Long 	struct mpt_raid_volume *mpt_raid;
1701b0a2fdeeSScott Long 	int rv;
1702b0a2fdeeSScott Long 	int i;
1703b0a2fdeeSScott Long 	size_t len;
1704b0a2fdeeSScott Long 
1705b0a2fdeeSScott Long 	rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC,
17061d79ca0eSMatt Jacob 		2, 0, &hdr, FALSE, 5000);
170729ae59edSMatt Jacob 	/*
170829ae59edSMatt Jacob 	 * If it's an invalid page, so what? Not a supported function....
170929ae59edSMatt Jacob 	 */
17101d79ca0eSMatt Jacob 	if (rv == EINVAL) {
171129ae59edSMatt Jacob 		return (0);
17121d79ca0eSMatt Jacob 	}
17131d79ca0eSMatt Jacob 	if (rv) {
171429ae59edSMatt Jacob 		return (rv);
17151d79ca0eSMatt Jacob 	}
1716b0a2fdeeSScott Long 
17175e073106SMatt Jacob #if __FreeBSD_version >= 500000
1718a529c6a2SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG,  "IOC Page 2 Header: ver %x, len %zx, "
1719b0a2fdeeSScott Long 		 "num %x, type %x\n", hdr.PageVersion,
1720b0a2fdeeSScott Long 		 hdr.PageLength * sizeof(uint32_t),
1721b0a2fdeeSScott Long 		 hdr.PageNumber, hdr.PageType);
17225e073106SMatt Jacob #else
17235e073106SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG,  "IOC Page 2 Header: ver %x, len %z, "
17245e073106SMatt Jacob 		 "num %x, type %x\n", hdr.PageVersion,
17255e073106SMatt Jacob 		 hdr.PageLength * sizeof(uint32_t),
17265e073106SMatt Jacob 		 hdr.PageNumber, hdr.PageType);
17275e073106SMatt Jacob #endif
1728b0a2fdeeSScott Long 
1729b0a2fdeeSScott Long 	len = hdr.PageLength * sizeof(uint32_t);
1730a3699bcaSScott Long 	mpt->ioc_page2 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
17311d79ca0eSMatt Jacob 	if (mpt->ioc_page2 == NULL) {
17321d79ca0eSMatt Jacob 		mpt_prt(mpt, "unable to allocate memory for IOC page 2\n");
17331d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
1734b0a2fdeeSScott Long 		return (ENOMEM);
17351d79ca0eSMatt Jacob 	}
1736b0a2fdeeSScott Long 	memcpy(&mpt->ioc_page2->Header, &hdr, sizeof(hdr));
17371d79ca0eSMatt Jacob 	rv = mpt_read_cur_cfg_page(mpt, 0,
17381d79ca0eSMatt Jacob 	    &mpt->ioc_page2->Header, len, FALSE, 5000);
1739b0a2fdeeSScott Long 	if (rv) {
1740b0a2fdeeSScott Long 		mpt_prt(mpt, "failed to read IOC Page 2\n");
17411d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
17421d79ca0eSMatt Jacob 		return (EIO);
17431d79ca0eSMatt Jacob 	}
17441d79ca0eSMatt Jacob 
17451d79ca0eSMatt Jacob 	if (mpt->ioc_page2->CapabilitiesFlags != 0) {
1746b0a2fdeeSScott Long 		uint32_t mask;
1747b0a2fdeeSScott Long 
1748b0a2fdeeSScott Long 		mpt_prt(mpt, "Capabilities: (");
1749b0a2fdeeSScott Long 		for (mask = 1; mask != 0; mask <<= 1) {
17501d79ca0eSMatt Jacob 			if ((mpt->ioc_page2->CapabilitiesFlags & mask) == 0) {
1751b0a2fdeeSScott Long 				continue;
17521d79ca0eSMatt Jacob 			}
1753b0a2fdeeSScott Long 			switch (mask) {
1754b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT:
1755b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-0");
1756b0a2fdeeSScott Long 				break;
1757b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT:
1758b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-1E");
1759b0a2fdeeSScott Long 				break;
1760b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT:
1761b0a2fdeeSScott Long 				mpt_prtc(mpt, " RAID-1");
1762b0a2fdeeSScott Long 				break;
1763b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_SES_SUPPORT:
1764b0a2fdeeSScott Long 				mpt_prtc(mpt, " SES");
1765b0a2fdeeSScott Long 				break;
1766b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_SAFTE_SUPPORT:
1767b0a2fdeeSScott Long 				mpt_prtc(mpt, " SAFTE");
1768b0a2fdeeSScott Long 				break;
1769b0a2fdeeSScott Long 			case MPI_IOCPAGE2_CAP_FLAGS_CROSS_CHANNEL_SUPPORT:
1770b0a2fdeeSScott Long 				mpt_prtc(mpt, " Multi-Channel-Arrays");
1771b0a2fdeeSScott Long 			default:
1772b0a2fdeeSScott Long 				break;
1773b0a2fdeeSScott Long 			}
1774b0a2fdeeSScott Long 		}
1775b0a2fdeeSScott Long 		mpt_prtc(mpt, " )\n");
1776b0a2fdeeSScott Long 		if ((mpt->ioc_page2->CapabilitiesFlags
1777b0a2fdeeSScott Long 		   & (MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT
1778b0a2fdeeSScott Long 		    | MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT
1779b0a2fdeeSScott Long 		    | MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT)) != 0) {
1780b0a2fdeeSScott Long 			mpt_prt(mpt, "%d Active Volume%s(%d Max)\n",
1781b0a2fdeeSScott Long 				mpt->ioc_page2->NumActiveVolumes,
1782b0a2fdeeSScott Long 				mpt->ioc_page2->NumActiveVolumes != 1
1783b0a2fdeeSScott Long 			      ? "s " : " ",
1784b0a2fdeeSScott Long 				mpt->ioc_page2->MaxVolumes);
1785b0a2fdeeSScott Long 			mpt_prt(mpt, "%d Hidden Drive Member%s(%d Max)\n",
1786b0a2fdeeSScott Long 				mpt->ioc_page2->NumActivePhysDisks,
1787b0a2fdeeSScott Long 				mpt->ioc_page2->NumActivePhysDisks != 1
1788b0a2fdeeSScott Long 			      ? "s " : " ",
1789b0a2fdeeSScott Long 				mpt->ioc_page2->MaxPhysDisks);
1790b0a2fdeeSScott Long 		}
1791b0a2fdeeSScott Long 	}
1792b0a2fdeeSScott Long 
1793b0a2fdeeSScott Long 	len = mpt->ioc_page2->MaxVolumes * sizeof(struct mpt_raid_volume);
17941d79ca0eSMatt Jacob 	mpt->raid_volumes = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1795b0a2fdeeSScott Long 	if (mpt->raid_volumes == NULL) {
1796b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not allocate RAID volume data\n");
17971d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
17981d79ca0eSMatt Jacob 		return (ENOMEM);
1799b0a2fdeeSScott Long 	}
1800b0a2fdeeSScott Long 
1801b0a2fdeeSScott Long 	/*
1802b0a2fdeeSScott Long 	 * Copy critical data out of ioc_page2 so that we can
1803b0a2fdeeSScott Long 	 * safely refresh the page without windows of unreliable
1804b0a2fdeeSScott Long 	 * data.
1805b0a2fdeeSScott Long 	 */
1806b0a2fdeeSScott Long 	mpt->raid_max_volumes =  mpt->ioc_page2->MaxVolumes;
1807b0a2fdeeSScott Long 
18081d79ca0eSMatt Jacob 	len = sizeof(*mpt->raid_volumes->config_page) +
18091d79ca0eSMatt Jacob 	    (sizeof (RAID_VOL0_PHYS_DISK) * (mpt->ioc_page2->MaxPhysDisks - 1));
1810b0a2fdeeSScott Long 	for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) {
1811b0a2fdeeSScott Long 		mpt_raid = &mpt->raid_volumes[i];
18121d79ca0eSMatt Jacob 		mpt_raid->config_page =
18131d79ca0eSMatt Jacob 		    malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1814b0a2fdeeSScott Long 		if (mpt_raid->config_page == NULL) {
1815b0a2fdeeSScott Long 			mpt_prt(mpt, "Could not allocate RAID page data\n");
18161d79ca0eSMatt Jacob 			mpt_raid_free_mem(mpt);
18171d79ca0eSMatt Jacob 			return (ENOMEM);
1818b0a2fdeeSScott Long 		}
1819b0a2fdeeSScott Long 	}
1820b0a2fdeeSScott Long 	mpt->raid_page0_len = len;
1821b0a2fdeeSScott Long 
1822b0a2fdeeSScott Long 	len = mpt->ioc_page2->MaxPhysDisks * sizeof(struct mpt_raid_disk);
18231d79ca0eSMatt Jacob 	mpt->raid_disks = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
1824b0a2fdeeSScott Long 	if (mpt->raid_disks == NULL) {
1825b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not allocate RAID disk data\n");
18261d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18271d79ca0eSMatt Jacob 		return (ENOMEM);
1828b0a2fdeeSScott Long 	}
1829b0a2fdeeSScott Long 	mpt->raid_max_disks =  mpt->ioc_page2->MaxPhysDisks;
1830b0a2fdeeSScott Long 
18311d79ca0eSMatt Jacob 	/*
18321d79ca0eSMatt Jacob 	 * Load page 3.
18331d79ca0eSMatt Jacob 	 */
1834b0a2fdeeSScott Long 	rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC,
18351d79ca0eSMatt Jacob 	    3, 0, &hdr, FALSE, 5000);
18361d79ca0eSMatt Jacob 	if (rv) {
18371d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
1838b0a2fdeeSScott Long 		return (EIO);
18391d79ca0eSMatt Jacob 	}
1840b0a2fdeeSScott Long 
1841b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 3 Header: %x %x %x %x\n",
1842b0a2fdeeSScott Long 	    hdr.PageVersion, hdr.PageLength, hdr.PageNumber, hdr.PageType);
1843b0a2fdeeSScott Long 
1844b0a2fdeeSScott Long 	len = hdr.PageLength * sizeof(uint32_t);
1845a3699bcaSScott Long 	mpt->ioc_page3 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO);
18461d79ca0eSMatt Jacob 	if (mpt->ioc_page3 == NULL) {
18471d79ca0eSMatt Jacob 		mpt_prt(mpt, "unable to allocate memory for IOC page 3\n");
18481d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18491d79ca0eSMatt Jacob 		return (ENOMEM);
1850b0a2fdeeSScott Long 	}
18511d79ca0eSMatt Jacob 	memcpy(&mpt->ioc_page3->Header, &hdr, sizeof(hdr));
18521d79ca0eSMatt Jacob 	rv = mpt_read_cur_cfg_page(mpt, 0,
18531d79ca0eSMatt Jacob 	    &mpt->ioc_page3->Header, len, FALSE, 5000);
18541d79ca0eSMatt Jacob 	if (rv) {
18551d79ca0eSMatt Jacob 		mpt_raid_free_mem(mpt);
18561d79ca0eSMatt Jacob 		return (EIO);
18571d79ca0eSMatt Jacob 	}
1858b0a2fdeeSScott Long 	mpt_raid_wakeup(mpt);
18597104aeefSMatt Jacob 	return (0);
18607104aeefSMatt Jacob }
18617104aeefSMatt Jacob 
18627104aeefSMatt Jacob /*
18637104aeefSMatt Jacob  * Enable IOC port
18647104aeefSMatt Jacob  */
18657104aeefSMatt Jacob static int
1866b0a2fdeeSScott Long mpt_send_port_enable(struct mpt_softc *mpt, int port)
18679b631363SMatt Jacob {
18689b631363SMatt Jacob 	request_t	*req;
18699b631363SMatt Jacob 	MSG_PORT_ENABLE *enable_req;
1870b0a2fdeeSScott Long 	int		 error;
18719b631363SMatt Jacob 
1872b0a2fdeeSScott Long 	req = mpt_get_request(mpt, /*sleep_ok*/FALSE);
1873b0a2fdeeSScott Long 	if (req == NULL)
1874b0a2fdeeSScott Long 		return (-1);
18759b631363SMatt Jacob 
18769b631363SMatt Jacob 	enable_req = req->req_vbuf;
18775e073106SMatt Jacob 	memset(enable_req, 0,  MPT_RQSL(mpt));
18789b631363SMatt Jacob 
18799b631363SMatt Jacob 	enable_req->Function   = MPI_FUNCTION_PORT_ENABLE;
1880b0a2fdeeSScott Long 	enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG);
18819b631363SMatt Jacob 	enable_req->PortNumber = port;
18829b631363SMatt Jacob 
18839b631363SMatt Jacob 	mpt_check_doorbell(mpt);
1884b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "enabling port %d\n", port);
18859b631363SMatt Jacob 
1886b0a2fdeeSScott Long 	mpt_send_cmd(mpt, req);
1887b0a2fdeeSScott Long 	error = mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE,
18885089bd63SMatt Jacob 	    FALSE, (mpt->is_sas || mpt->is_fc)? 30000 : 3000);
1889b0a2fdeeSScott Long 	if (error != 0) {
1890c87e3f83SMatt Jacob 		mpt_prt(mpt, "port %d enable timed out\n", port);
18919b631363SMatt Jacob 		return (-1);
18929b631363SMatt Jacob 	}
18939b631363SMatt Jacob 	mpt_free_request(mpt, req);
1894c87e3f83SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "enabled port %d\n", port);
18959b631363SMatt Jacob 	return (0);
18969b631363SMatt Jacob }
18979b631363SMatt Jacob 
18989b631363SMatt Jacob /*
18999b631363SMatt Jacob  * Enable/Disable asynchronous event reporting.
19009b631363SMatt Jacob  */
19019b631363SMatt Jacob static int
1902b0a2fdeeSScott Long mpt_send_event_request(struct mpt_softc *mpt, int onoff)
19039b631363SMatt Jacob {
19049b631363SMatt Jacob 	request_t *req;
19059b631363SMatt Jacob 	MSG_EVENT_NOTIFY *enable_req;
19069b631363SMatt Jacob 
19075e073106SMatt Jacob 	req = mpt_get_request(mpt, FALSE);
19085e073106SMatt Jacob 	if (req == NULL) {
19095e073106SMatt Jacob 		return (ENOMEM);
19105e073106SMatt Jacob 	}
19119b631363SMatt Jacob 	enable_req = req->req_vbuf;
19125e073106SMatt Jacob 	memset(enable_req, 0, sizeof *enable_req);
19139b631363SMatt Jacob 
19149b631363SMatt Jacob 	enable_req->Function   = MPI_FUNCTION_EVENT_NOTIFICATION;
1915b0a2fdeeSScott Long 	enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_EVENTS);
19169b631363SMatt Jacob 	enable_req->Switch     = onoff;
19179b631363SMatt Jacob 
19189b631363SMatt Jacob 	mpt_check_doorbell(mpt);
19195e073106SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "%sabling async events\n",
19205e073106SMatt Jacob 	    onoff ? "en" : "dis");
19215e073106SMatt Jacob 	/*
19225e073106SMatt Jacob 	 * Send the command off, but don't wait for it.
19235e073106SMatt Jacob 	 */
19249b631363SMatt Jacob 	mpt_send_cmd(mpt, req);
19259b631363SMatt Jacob 	return (0);
19269b631363SMatt Jacob }
19279b631363SMatt Jacob 
19289b631363SMatt Jacob /*
19299b631363SMatt Jacob  * Un-mask the interupts on the chip.
19309b631363SMatt Jacob  */
19319b631363SMatt Jacob void
1932b0a2fdeeSScott Long mpt_enable_ints(struct mpt_softc *mpt)
19339b631363SMatt Jacob {
19349b631363SMatt Jacob 	/* Unmask every thing except door bell int */
19359b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_MASK, MPT_INTR_DB_MASK);
19369b631363SMatt Jacob }
19379b631363SMatt Jacob 
19389b631363SMatt Jacob /*
19399b631363SMatt Jacob  * Mask the interupts on the chip.
19409b631363SMatt Jacob  */
19419b631363SMatt Jacob void
1942b0a2fdeeSScott Long mpt_disable_ints(struct mpt_softc *mpt)
19439b631363SMatt Jacob {
19449b631363SMatt Jacob 	/* Mask all interrupts */
19459b631363SMatt Jacob 	mpt_write(mpt, MPT_OFFSET_INTR_MASK,
19469b631363SMatt Jacob 	    MPT_INTR_REPLY_MASK | MPT_INTR_DB_MASK);
19479b631363SMatt Jacob }
19489b631363SMatt Jacob 
1949b0a2fdeeSScott Long static void
1950b0a2fdeeSScott Long mpt_sysctl_attach(struct mpt_softc *mpt)
19519b631363SMatt Jacob {
1952c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000
1953b0a2fdeeSScott Long 	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(mpt->dev);
1954b0a2fdeeSScott Long 	struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev);
19559b631363SMatt Jacob 
1956b0a2fdeeSScott Long 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
1957b0a2fdeeSScott Long 		       "debug", CTLFLAG_RW, &mpt->verbose, 0,
1958b0a2fdeeSScott Long 		       "Debugging/Verbose level");
1959b4c618c0SMatt Jacob 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
1960b4c618c0SMatt Jacob 		       "role", CTLFLAG_RD, &mpt->role, 0,
1961b4c618c0SMatt Jacob 		       "HBA role");
1962c87e3f83SMatt Jacob #endif
19639b631363SMatt Jacob }
19649b631363SMatt Jacob 
1965b0a2fdeeSScott Long int
1966b0a2fdeeSScott Long mpt_attach(struct mpt_softc *mpt)
1967b0a2fdeeSScott Long {
1968b0a2fdeeSScott Long 	struct mpt_personality *pers;
1969c87e3f83SMatt Jacob 	int i;
1970b0a2fdeeSScott Long 	int error;
1971b0a2fdeeSScott Long 
1972c87e3f83SMatt Jacob 	for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
1973b0a2fdeeSScott Long 		pers = mpt_personalities[i];
1974c87e3f83SMatt Jacob 		if (pers == NULL) {
1975b0a2fdeeSScott Long 			continue;
1976c87e3f83SMatt Jacob 		}
1977b0a2fdeeSScott Long 		if (pers->probe(mpt) == 0) {
1978b0a2fdeeSScott Long 			error = pers->attach(mpt);
1979b0a2fdeeSScott Long 			if (error != 0) {
1980b0a2fdeeSScott Long 				mpt_detach(mpt);
1981b0a2fdeeSScott Long 				return (error);
1982b0a2fdeeSScott Long 			}
1983b0a2fdeeSScott Long 			mpt->mpt_pers_mask |= (0x1 << pers->id);
1984b0a2fdeeSScott Long 			pers->use_count++;
1985b0a2fdeeSScott Long 		}
1986b0a2fdeeSScott Long 	}
1987444dd2b6SMatt Jacob 
1988c87e3f83SMatt Jacob 	/*
1989c87e3f83SMatt Jacob 	 * Now that we've attached everything, do the enable function
1990c87e3f83SMatt Jacob 	 * for all of the personalities. This allows the personalities
1991c87e3f83SMatt Jacob 	 * to do setups that are appropriate for them prior to enabling
1992c87e3f83SMatt Jacob 	 * any ports.
1993c87e3f83SMatt Jacob 	 */
1994c87e3f83SMatt Jacob 	for (i = 0; i < MPT_MAX_PERSONALITIES; i++) {
1995c87e3f83SMatt Jacob 		pers = mpt_personalities[i];
1996c87e3f83SMatt Jacob 		if (pers != NULL  && MPT_PERS_ATTACHED(pers, mpt) != 0) {
1997c87e3f83SMatt Jacob 			error = pers->enable(mpt);
1998c87e3f83SMatt Jacob 			if (error != 0) {
1999c87e3f83SMatt Jacob 				mpt_prt(mpt, "personality %s attached but would"
2000c87e3f83SMatt Jacob 				    " not enable (%d)\n", pers->name, error);
2001c87e3f83SMatt Jacob 				mpt_detach(mpt);
2002c87e3f83SMatt Jacob 				return (error);
2003c87e3f83SMatt Jacob 			}
2004c87e3f83SMatt Jacob 		}
2005c87e3f83SMatt Jacob 	}
2006b0a2fdeeSScott Long 	return (0);
2007b0a2fdeeSScott Long }
2008b0a2fdeeSScott Long 
2009b0a2fdeeSScott Long int
2010b0a2fdeeSScott Long mpt_shutdown(struct mpt_softc *mpt)
2011b0a2fdeeSScott Long {
2012b0a2fdeeSScott Long 	struct mpt_personality *pers;
2013b0a2fdeeSScott Long 
2014c87e3f83SMatt Jacob 	MPT_PERS_FOREACH_REVERSE(mpt, pers) {
2015b0a2fdeeSScott Long 		pers->shutdown(mpt);
2016c87e3f83SMatt Jacob 	}
2017b0a2fdeeSScott Long 	return (0);
2018b0a2fdeeSScott Long }
2019b0a2fdeeSScott Long 
2020b0a2fdeeSScott Long int
2021b0a2fdeeSScott Long mpt_detach(struct mpt_softc *mpt)
2022b0a2fdeeSScott Long {
2023b0a2fdeeSScott Long 	struct mpt_personality *pers;
2024b0a2fdeeSScott Long 
2025b0a2fdeeSScott Long 	MPT_PERS_FOREACH_REVERSE(mpt, pers) {
2026b0a2fdeeSScott Long 		pers->detach(mpt);
2027b0a2fdeeSScott Long 		mpt->mpt_pers_mask &= ~(0x1 << pers->id);
2028b0a2fdeeSScott Long 		pers->use_count--;
2029b0a2fdeeSScott Long 	}
2030b0a2fdeeSScott Long 
2031b0a2fdeeSScott Long 	return (0);
2032b0a2fdeeSScott Long }
2033b0a2fdeeSScott Long 
2034b0a2fdeeSScott Long int
2035b0a2fdeeSScott Long mpt_core_load(struct mpt_personality *pers)
2036b0a2fdeeSScott Long {
2037b0a2fdeeSScott Long 	int i;
2038b0a2fdeeSScott Long 
2039b0a2fdeeSScott Long 	/*
2040b0a2fdeeSScott Long 	 * Setup core handlers and insert the default handler
2041b0a2fdeeSScott Long 	 * into all "empty slots".
2042b0a2fdeeSScott Long 	 */
2043c87e3f83SMatt Jacob 	for (i = 0; i < MPT_NUM_REPLY_HANDLERS; i++) {
2044b0a2fdeeSScott Long 		mpt_reply_handlers[i] = mpt_default_reply_handler;
2045c87e3f83SMatt Jacob 	}
2046b0a2fdeeSScott Long 
2047b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_EVENTS)] =
2048b0a2fdeeSScott Long 	    mpt_event_reply_handler;
2049b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_CONFIG)] =
2050b0a2fdeeSScott Long 	    mpt_config_reply_handler;
2051b0a2fdeeSScott Long 	mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_HANDSHAKE)] =
2052b0a2fdeeSScott Long 	    mpt_handshake_reply_handler;
2053b0a2fdeeSScott Long 	return (0);
20549b631363SMatt Jacob }
20559b631363SMatt Jacob 
20569b631363SMatt Jacob /*
2057b0a2fdeeSScott Long  * Initialize per-instance driver data and perform
2058b0a2fdeeSScott Long  * initial controller configuration.
20599b631363SMatt Jacob  */
2060b0a2fdeeSScott Long int
2061b0a2fdeeSScott Long mpt_core_attach(struct mpt_softc *mpt)
2062b0a2fdeeSScott Long {
2063b0a2fdeeSScott Long         int val;
2064b0a2fdeeSScott Long 	int error;
2065b0a2fdeeSScott Long 
2066c87e3f83SMatt Jacob 
2067b0a2fdeeSScott Long 	LIST_INIT(&mpt->ack_frames);
2068b0a2fdeeSScott Long 
2069b0a2fdeeSScott Long 	/* Put all request buffers on the free list */
2070b0a2fdeeSScott Long 	TAILQ_INIT(&mpt->request_pending_list);
2071b0a2fdeeSScott Long 	TAILQ_INIT(&mpt->request_free_list);
20725e073106SMatt Jacob 	TAILQ_INIT(&mpt->request_timeout_list);
2073c87e3f83SMatt Jacob 	for (val = 0; val < MPT_MAX_REQUESTS(mpt); val++) {
20745e073106SMatt Jacob 		request_t *req = &mpt->request_pool[val];
20755e073106SMatt Jacob 		req->state = REQ_STATE_ALLOCATED;
20765e073106SMatt Jacob 		mpt_free_request(mpt, req);
2077c87e3f83SMatt Jacob 	}
2078c87e3f83SMatt Jacob 
2079c87e3f83SMatt Jacob 	for (val = 0; val < MPT_MAX_LUNS; val++) {
2080c87e3f83SMatt Jacob 		STAILQ_INIT(&mpt->trt[val].atios);
2081c87e3f83SMatt Jacob 		STAILQ_INIT(&mpt->trt[val].inots);
2082c87e3f83SMatt Jacob 	}
2083c87e3f83SMatt Jacob 	STAILQ_INIT(&mpt->trt_wildcard.atios);
2084c87e3f83SMatt Jacob 	STAILQ_INIT(&mpt->trt_wildcard.inots);
2085c87e3f83SMatt Jacob 
2086c87e3f83SMatt Jacob 	mpt->scsi_tgt_handler_id = MPT_HANDLER_ID_NONE;
2087b0a2fdeeSScott Long 
2088b0a2fdeeSScott Long 	mpt_sysctl_attach(mpt);
2089b0a2fdeeSScott Long 
2090b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "doorbell req = %s\n",
2091b0a2fdeeSScott Long 	    mpt_ioc_diag(mpt_read(mpt, MPT_OFFSET_DOORBELL)));
2092b0a2fdeeSScott Long 
2093b0a2fdeeSScott Long 	error = mpt_configure_ioc(mpt);
2094b0a2fdeeSScott Long 
2095b0a2fdeeSScott Long 	return (error);
20969b631363SMatt Jacob }
20979b631363SMatt Jacob 
2098c87e3f83SMatt Jacob int
2099c87e3f83SMatt Jacob mpt_core_enable(struct mpt_softc *mpt)
2100c87e3f83SMatt Jacob {
2101c87e3f83SMatt Jacob 	/*
2102c87e3f83SMatt Jacob 	 * We enter with the IOC enabled, but async events
2103c87e3f83SMatt Jacob 	 * not enabled, ports not enabled and interrupts
2104c87e3f83SMatt Jacob 	 * not enabled.
2105c87e3f83SMatt Jacob 	 */
2106c87e3f83SMatt Jacob 
2107c87e3f83SMatt Jacob 	/*
2108c87e3f83SMatt Jacob 	 * Enable asynchronous event reporting- all personalities
2109c87e3f83SMatt Jacob 	 * have attached so that they should be able to now field
2110c87e3f83SMatt Jacob 	 * async events.
2111c87e3f83SMatt Jacob 	 */
2112c87e3f83SMatt Jacob 	mpt_send_event_request(mpt, 1);
2113c87e3f83SMatt Jacob 
2114c87e3f83SMatt Jacob 	/*
2115c87e3f83SMatt Jacob 	 * Catch any pending interrupts
2116c87e3f83SMatt Jacob 	 *
2117c87e3f83SMatt Jacob 	 * This seems to be crucial- otherwise
2118c87e3f83SMatt Jacob 	 * the portenable below times out.
2119c87e3f83SMatt Jacob 	 */
2120c87e3f83SMatt Jacob 	mpt_intr(mpt);
2121c87e3f83SMatt Jacob 
2122c87e3f83SMatt Jacob 	/*
2123c87e3f83SMatt Jacob 	 * Enable Interrupts
2124c87e3f83SMatt Jacob 	 */
2125c87e3f83SMatt Jacob 	mpt_enable_ints(mpt);
2126c87e3f83SMatt Jacob 
2127c87e3f83SMatt Jacob 	/*
2128c87e3f83SMatt Jacob 	 * Catch any pending interrupts
2129c87e3f83SMatt Jacob 	 *
2130c87e3f83SMatt Jacob 	 * This seems to be crucial- otherwise
2131c87e3f83SMatt Jacob 	 * the portenable below times out.
2132c87e3f83SMatt Jacob 	 */
2133c87e3f83SMatt Jacob 	mpt_intr(mpt);
2134c87e3f83SMatt Jacob 
2135c87e3f83SMatt Jacob 	/*
21365089bd63SMatt Jacob 	 * Enable the port.
2137c87e3f83SMatt Jacob 	 */
2138c87e3f83SMatt Jacob 	if (mpt_send_port_enable(mpt, 0) != MPT_OK) {
2139c87e3f83SMatt Jacob 		mpt_prt(mpt, "failed to enable port 0\n");
2140c87e3f83SMatt Jacob 		return (ENXIO);
2141c87e3f83SMatt Jacob 	}
2142c87e3f83SMatt Jacob 	return (0);
2143c87e3f83SMatt Jacob }
2144c87e3f83SMatt Jacob 
2145b0a2fdeeSScott Long void
2146b0a2fdeeSScott Long mpt_core_shutdown(struct mpt_softc *mpt)
2147b0a2fdeeSScott Long {
2148c87e3f83SMatt Jacob 	mpt_disable_ints(mpt);
2149b0a2fdeeSScott Long }
2150b0a2fdeeSScott Long 
2151b0a2fdeeSScott Long void
2152b0a2fdeeSScott Long mpt_core_detach(struct mpt_softc *mpt)
2153b0a2fdeeSScott Long {
2154c87e3f83SMatt Jacob 	mpt_disable_ints(mpt);
2155b0a2fdeeSScott Long }
2156b0a2fdeeSScott Long 
2157b0a2fdeeSScott Long int
2158b0a2fdeeSScott Long mpt_core_unload(struct mpt_personality *pers)
2159b0a2fdeeSScott Long {
2160b0a2fdeeSScott Long 	/* Unload is always successfull. */
2161b0a2fdeeSScott Long 	return (0);
2162b0a2fdeeSScott Long }
2163b0a2fdeeSScott Long 
2164b0a2fdeeSScott Long #define FW_UPLOAD_REQ_SIZE				\
2165b0a2fdeeSScott Long 	(sizeof(MSG_FW_UPLOAD) - sizeof(SGE_MPI_UNION)	\
2166b0a2fdeeSScott Long        + sizeof(FW_UPLOAD_TCSGE) + sizeof(SGE_SIMPLE32))
2167b0a2fdeeSScott Long 
2168b0a2fdeeSScott Long static int
2169b0a2fdeeSScott Long mpt_upload_fw(struct mpt_softc *mpt)
2170b0a2fdeeSScott Long {
2171b0a2fdeeSScott Long 	uint8_t fw_req_buf[FW_UPLOAD_REQ_SIZE];
2172b0a2fdeeSScott Long 	MSG_FW_UPLOAD_REPLY fw_reply;
2173b0a2fdeeSScott Long 	MSG_FW_UPLOAD *fw_req;
2174b0a2fdeeSScott Long 	FW_UPLOAD_TCSGE *tsge;
2175b0a2fdeeSScott Long 	SGE_SIMPLE32 *sge;
2176b0a2fdeeSScott Long 	uint32_t flags;
2177b0a2fdeeSScott Long 	int error;
2178b0a2fdeeSScott Long 
2179b0a2fdeeSScott Long 	memset(&fw_req_buf, 0, sizeof(fw_req_buf));
2180b0a2fdeeSScott Long 	fw_req = (MSG_FW_UPLOAD *)fw_req_buf;
2181b0a2fdeeSScott Long 	fw_req->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM;
2182b0a2fdeeSScott Long 	fw_req->Function = MPI_FUNCTION_FW_UPLOAD;
2183b0a2fdeeSScott Long 	fw_req->MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE);
2184b0a2fdeeSScott Long 	tsge = (FW_UPLOAD_TCSGE *)&fw_req->SGL;
2185b0a2fdeeSScott Long 	tsge->DetailsLength = 12;
2186b0a2fdeeSScott Long 	tsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT;
2187b0a2fdeeSScott Long 	tsge->ImageSize = htole32(mpt->fw_image_size);
2188b0a2fdeeSScott Long 	sge = (SGE_SIMPLE32 *)(tsge + 1);
2189b0a2fdeeSScott Long 	flags = (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER
2190b0a2fdeeSScott Long 	      | MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_SIMPLE_ELEMENT
2191b0a2fdeeSScott Long 	      | MPI_SGE_FLAGS_32_BIT_ADDRESSING | MPI_SGE_FLAGS_IOC_TO_HOST);
2192b0a2fdeeSScott Long 	flags <<= MPI_SGE_FLAGS_SHIFT;
2193b0a2fdeeSScott Long 	sge->FlagsLength = htole32(flags | mpt->fw_image_size);
2194b0a2fdeeSScott Long 	sge->Address = htole32(mpt->fw_phys);
2195b0a2fdeeSScott Long 	error = mpt_send_handshake_cmd(mpt, sizeof(fw_req_buf), &fw_req_buf);
2196b0a2fdeeSScott Long 	if (error)
2197b0a2fdeeSScott Long 		return(error);
2198b0a2fdeeSScott Long 	error = mpt_recv_handshake_reply(mpt, sizeof(fw_reply), &fw_reply);
2199b0a2fdeeSScott Long 	return (error);
2200b0a2fdeeSScott Long }
2201b0a2fdeeSScott Long 
2202b0a2fdeeSScott Long static void
2203b0a2fdeeSScott Long mpt_diag_outsl(struct mpt_softc *mpt, uint32_t addr,
2204b0a2fdeeSScott Long 	       uint32_t *data, bus_size_t len)
2205b0a2fdeeSScott Long {
2206b0a2fdeeSScott Long 	uint32_t *data_end;
2207b0a2fdeeSScott Long 
2208b0a2fdeeSScott Long 	data_end = data + (roundup2(len, sizeof(uint32_t)) / 4);
22099fe6d254SMatt Jacob 	if (mpt->is_sas) {
2210444dd2b6SMatt Jacob 		pci_enable_io(mpt->dev, SYS_RES_IOPORT);
22119fe6d254SMatt Jacob 	}
2212b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, addr);
2213b0a2fdeeSScott Long 	while (data != data_end) {
2214b0a2fdeeSScott Long 		mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, *data);
2215b0a2fdeeSScott Long 		data++;
2216b0a2fdeeSScott Long 	}
22179fe6d254SMatt Jacob 	if (mpt->is_sas) {
2218444dd2b6SMatt Jacob 		pci_disable_io(mpt->dev, SYS_RES_IOPORT);
2219b0a2fdeeSScott Long 	}
22209fe6d254SMatt Jacob }
2221b0a2fdeeSScott Long 
2222b0a2fdeeSScott Long static int
2223b0a2fdeeSScott Long mpt_download_fw(struct mpt_softc *mpt)
2224b0a2fdeeSScott Long {
2225b0a2fdeeSScott Long 	MpiFwHeader_t *fw_hdr;
2226b0a2fdeeSScott Long 	int error;
2227b0a2fdeeSScott Long 	uint32_t ext_offset;
2228b0a2fdeeSScott Long 	uint32_t data;
2229b0a2fdeeSScott Long 
2230b0a2fdeeSScott Long 	mpt_prt(mpt, "Downloading Firmware - Image Size %d\n",
2231b0a2fdeeSScott Long 		mpt->fw_image_size);
2232b0a2fdeeSScott Long 
2233b0a2fdeeSScott Long 	error = mpt_enable_diag_mode(mpt);
2234b0a2fdeeSScott Long 	if (error != 0) {
2235b0a2fdeeSScott Long 		mpt_prt(mpt, "Could not enter diagnostic mode!\n");
2236b0a2fdeeSScott Long 		return (EIO);
2237b0a2fdeeSScott Long 	}
2238b0a2fdeeSScott Long 
2239b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC,
2240b0a2fdeeSScott Long 		  MPI_DIAG_RW_ENABLE|MPI_DIAG_DISABLE_ARM);
2241b0a2fdeeSScott Long 
2242b0a2fdeeSScott Long 	fw_hdr = (MpiFwHeader_t *)mpt->fw_image;
2243b0a2fdeeSScott Long 	mpt_diag_outsl(mpt, fw_hdr->LoadStartAddress, (uint32_t*)fw_hdr,
2244b0a2fdeeSScott Long 		       fw_hdr->ImageSize);
2245b0a2fdeeSScott Long 
2246b0a2fdeeSScott Long 	ext_offset = fw_hdr->NextImageHeaderOffset;
2247b0a2fdeeSScott Long 	while (ext_offset != 0) {
2248b0a2fdeeSScott Long 		MpiExtImageHeader_t *ext;
2249b0a2fdeeSScott Long 
2250b0a2fdeeSScott Long 		ext = (MpiExtImageHeader_t *)((uintptr_t)fw_hdr + ext_offset);
2251b0a2fdeeSScott Long 		ext_offset = ext->NextImageHeaderOffset;
2252b0a2fdeeSScott Long 
2253b0a2fdeeSScott Long 		mpt_diag_outsl(mpt, ext->LoadStartAddress, (uint32_t*)ext,
2254b0a2fdeeSScott Long 			       ext->ImageSize);
2255b0a2fdeeSScott Long 	}
2256b0a2fdeeSScott Long 
22579fe6d254SMatt Jacob 	if (mpt->is_sas) {
2258444dd2b6SMatt Jacob 		pci_enable_io(mpt->dev, SYS_RES_IOPORT);
22599fe6d254SMatt Jacob 	}
2260b0a2fdeeSScott Long 	/* Setup the address to jump to on reset. */
2261b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, fw_hdr->IopResetRegAddr);
2262b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, fw_hdr->IopResetVectorValue);
2263b0a2fdeeSScott Long 
2264b0a2fdeeSScott Long 	/*
2265b0a2fdeeSScott Long 	 * The controller sets the "flash bad" status after attempting
2266b0a2fdeeSScott Long 	 * to auto-boot from flash.  Clear the status so that the controller
2267b0a2fdeeSScott Long 	 * will continue the boot process with our newly installed firmware.
2268b0a2fdeeSScott Long 	 */
2269b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE);
2270b0a2fdeeSScott Long 	data = mpt_pio_read(mpt, MPT_OFFSET_DIAG_DATA) | MPT_DIAG_MEM_CFG_BADFL;
2271b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE);
2272b0a2fdeeSScott Long 	mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, data);
2273b0a2fdeeSScott Long 
22749fe6d254SMatt Jacob 	if (mpt->is_sas) {
2275444dd2b6SMatt Jacob 		pci_disable_io(mpt->dev, SYS_RES_IOPORT);
22769fe6d254SMatt Jacob 	}
2277444dd2b6SMatt Jacob 
2278b0a2fdeeSScott Long 	/*
2279b0a2fdeeSScott Long 	 * Re-enable the processor and clear the boot halt flag.
2280b0a2fdeeSScott Long 	 */
2281b0a2fdeeSScott Long 	data = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC);
2282b0a2fdeeSScott Long 	data &= ~(MPI_DIAG_PREVENT_IOC_BOOT|MPI_DIAG_DISABLE_ARM);
2283b0a2fdeeSScott Long 	mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, data);
2284b0a2fdeeSScott Long 
2285b0a2fdeeSScott Long 	mpt_disable_diag_mode(mpt);
2286b0a2fdeeSScott Long 	return (0);
2287b0a2fdeeSScott Long }
2288b0a2fdeeSScott Long 
2289b0a2fdeeSScott Long /*
2290b0a2fdeeSScott Long  * Allocate/Initialize data structures for the controller.  Called
2291b0a2fdeeSScott Long  * once at instance startup.
2292b0a2fdeeSScott Long  */
2293b0a2fdeeSScott Long static int
2294b0a2fdeeSScott Long mpt_configure_ioc(struct mpt_softc *mpt)
2295b0a2fdeeSScott Long {
2296b0a2fdeeSScott Long         MSG_PORT_FACTS_REPLY pfp;
2297b0a2fdeeSScott Long         MSG_IOC_FACTS_REPLY facts;
2298b0a2fdeeSScott Long 	int try;
2299b0a2fdeeSScott Long 	int needreset;
2300444dd2b6SMatt Jacob 	uint32_t max_chain_depth;
2301b0a2fdeeSScott Long 
2302b0a2fdeeSScott Long 	needreset = 0;
23039b631363SMatt Jacob 	for (try = 0; try < MPT_MAX_TRYS; try++) {
2304b0a2fdeeSScott Long 
23059b631363SMatt Jacob 		/*
23069b631363SMatt Jacob 		 * No need to reset if the IOC is already in the READY state.
23079b631363SMatt Jacob 		 *
23089b631363SMatt Jacob 		 * Force reset if initialization failed previously.
23099b631363SMatt Jacob 		 * Note that a hard_reset of the second channel of a '929
23109b631363SMatt Jacob 		 * will stop operation of the first channel.  Hopefully, if the
23119b631363SMatt Jacob 		 * first channel is ok, the second will not require a hard
23129b631363SMatt Jacob 		 * reset.
23139b631363SMatt Jacob 		 */
2314c87e3f83SMatt Jacob 		if (needreset || MPT_STATE(mpt_rd_db(mpt)) !=
23159b631363SMatt Jacob 		    MPT_DB_STATE_READY) {
2316c87e3f83SMatt Jacob 			if (mpt_reset(mpt, FALSE) != MPT_OK) {
23179b631363SMatt Jacob 				continue;
23189b631363SMatt Jacob 			}
2319c87e3f83SMatt Jacob 		}
2320b0a2fdeeSScott Long 		needreset = 0;
23219b631363SMatt Jacob 
23229b631363SMatt Jacob 		if (mpt_get_iocfacts(mpt, &facts) != MPT_OK) {
2323b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_get_iocfacts failed\n");
2324b0a2fdeeSScott Long 			needreset = 1;
23259b631363SMatt Jacob 			continue;
23267104aeefSMatt Jacob 		}
23277104aeefSMatt Jacob 
2328b0a2fdeeSScott Long 		mpt->mpt_global_credits = le16toh(facts.GlobalCredits);
2329b0a2fdeeSScott Long 		mpt->request_frame_size = le16toh(facts.RequestFrameSize);
2330444dd2b6SMatt Jacob 		mpt->ioc_facts_flags = facts.Flags;
2331b0a2fdeeSScott Long 		mpt_prt(mpt, "MPI Version=%d.%d.%d.%d\n",
2332b0a2fdeeSScott Long 			    le16toh(facts.MsgVersion) >> 8,
2333b0a2fdeeSScott Long 			    le16toh(facts.MsgVersion) & 0xFF,
2334b0a2fdeeSScott Long 			    le16toh(facts.HeaderVersion) >> 8,
2335b0a2fdeeSScott Long 			    le16toh(facts.HeaderVersion) & 0xFF);
2336444dd2b6SMatt Jacob 
2337444dd2b6SMatt Jacob 		/*
2338444dd2b6SMatt Jacob 		 * Now that we know request frame size, we can calculate
2339444dd2b6SMatt Jacob 		 * the actual (reasonable) segment limit for read/write I/O.
2340444dd2b6SMatt Jacob 		 *
2341444dd2b6SMatt Jacob 		 * This limit is constrained by:
2342444dd2b6SMatt Jacob 		 *
2343444dd2b6SMatt Jacob 		 *  + The size of each area we allocate per command (and how
2344444dd2b6SMatt Jacob                  *    many chain segments we can fit into it).
2345444dd2b6SMatt Jacob                  *  + The total number of areas we've set up.
2346444dd2b6SMatt Jacob 		 *  + The actual chain depth the card will allow.
2347444dd2b6SMatt Jacob 		 *
2348444dd2b6SMatt Jacob 		 * The first area's segment count is limited by the I/O request
2349444dd2b6SMatt Jacob 		 * at the head of it. We cannot allocate realistically more
2350444dd2b6SMatt Jacob 		 * than MPT_MAX_REQUESTS areas. Therefore, to account for both
2351444dd2b6SMatt Jacob 		 * conditions, we'll just start out with MPT_MAX_REQUESTS-2.
2352444dd2b6SMatt Jacob 		 *
2353444dd2b6SMatt Jacob 		 */
2354444dd2b6SMatt Jacob 		max_chain_depth = facts.MaxChainDepth;
2355444dd2b6SMatt Jacob 
2356444dd2b6SMatt Jacob 		/* total number of request areas we (can) allocate */
2357444dd2b6SMatt Jacob 		mpt->max_seg_cnt = MPT_MAX_REQUESTS(mpt) - 2;
2358444dd2b6SMatt Jacob 
2359444dd2b6SMatt Jacob 		/* converted to the number of chain areas possible */
2360444dd2b6SMatt Jacob 		mpt->max_seg_cnt *= MPT_NRFM(mpt);
2361444dd2b6SMatt Jacob 
2362444dd2b6SMatt Jacob 		/* limited by the number of chain areas the card will support */
2363444dd2b6SMatt Jacob 		if (mpt->max_seg_cnt > max_chain_depth) {
2364444dd2b6SMatt Jacob 			mpt_lprt(mpt, MPT_PRT_DEBUG,
2365444dd2b6SMatt Jacob 			    "chain depth limited to %u (from %u)\n",
2366444dd2b6SMatt Jacob 			    max_chain_depth, mpt->max_seg_cnt);
2367444dd2b6SMatt Jacob 			mpt->max_seg_cnt = max_chain_depth;
2368444dd2b6SMatt Jacob 		}
2369444dd2b6SMatt Jacob 
2370444dd2b6SMatt Jacob 		/* converted to the number of simple sges in chain segments. */
2371444dd2b6SMatt Jacob 		mpt->max_seg_cnt *= (MPT_NSGL(mpt) - 1);
2372444dd2b6SMatt Jacob 
2373444dd2b6SMatt Jacob 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2374444dd2b6SMatt Jacob 		    "Maximum Segment Count: %u\n", mpt->max_seg_cnt);
2375b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2376b0a2fdeeSScott Long 			 "MsgLength=%u IOCNumber = %d\n",
2377b0a2fdeeSScott Long 			 facts.MsgLength, facts.IOCNumber);
2378b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2379444dd2b6SMatt Jacob 			 "IOCFACTS: GlobalCredits=%d BlockSize=%u bytes "
2380444dd2b6SMatt Jacob 			 "Request Frame Size %u bytes Max Chain Depth %u\n",
2381444dd2b6SMatt Jacob                          mpt->mpt_global_credits, facts.BlockSize,
2382444dd2b6SMatt Jacob                          mpt->request_frame_size << 2, max_chain_depth);
2383b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
2384b0a2fdeeSScott Long 			 "IOCFACTS: Num Ports %d, FWImageSize %d, "
2385b0a2fdeeSScott Long 			 "Flags=%#x\n", facts.NumberOfPorts,
2386b0a2fdeeSScott Long 			 le32toh(facts.FWImageSize), facts.Flags);
2387b0a2fdeeSScott Long 
2388444dd2b6SMatt Jacob 
2389b0a2fdeeSScott Long 		if ((facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT) != 0) {
2390b0a2fdeeSScott Long 			struct mpt_map_info mi;
2391b0a2fdeeSScott Long 			int error;
2392b0a2fdeeSScott Long 
2393b0a2fdeeSScott Long 			/*
2394b0a2fdeeSScott Long 			 * In some configurations, the IOC's firmware is
2395b0a2fdeeSScott Long 			 * stored in a shared piece of system NVRAM that
2396b0a2fdeeSScott Long 			 * is only accessable via the BIOS.  In this
2397b0a2fdeeSScott Long 			 * case, the firmware keeps a copy of firmware in
2398b0a2fdeeSScott Long 			 * RAM until the OS driver retrieves it.  Once
2399b0a2fdeeSScott Long 			 * retrieved, we are responsible for re-downloading
2400b0a2fdeeSScott Long 			 * the firmware after any hard-reset.
2401b0a2fdeeSScott Long 			 */
2402b0a2fdeeSScott Long 			mpt->fw_image_size = le32toh(facts.FWImageSize);
2403b0a2fdeeSScott Long 			error = mpt_dma_tag_create(mpt, mpt->parent_dmat,
2404b0a2fdeeSScott Long 			    /*alignment*/1, /*boundary*/0,
2405b0a2fdeeSScott Long 			    /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
2406b0a2fdeeSScott Long 			    /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL,
2407b0a2fdeeSScott Long 			    /*filterarg*/NULL, mpt->fw_image_size,
2408b0a2fdeeSScott Long 			    /*nsegments*/1, /*maxsegsz*/mpt->fw_image_size,
2409b0a2fdeeSScott Long 			    /*flags*/0, &mpt->fw_dmat);
2410b0a2fdeeSScott Long 			if (error != 0) {
2411b0a2fdeeSScott Long 				mpt_prt(mpt, "cannot create fw dma tag\n");
2412b0a2fdeeSScott Long 				return (ENOMEM);
24139b631363SMatt Jacob 			}
2414b0a2fdeeSScott Long 			error = bus_dmamem_alloc(mpt->fw_dmat,
2415b0a2fdeeSScott Long 			    (void **)&mpt->fw_image, BUS_DMA_NOWAIT,
2416b0a2fdeeSScott Long 			    &mpt->fw_dmap);
2417b0a2fdeeSScott Long 			if (error != 0) {
2418b0a2fdeeSScott Long 				mpt_prt(mpt, "cannot allocate fw mem.\n");
2419b0a2fdeeSScott Long 				bus_dma_tag_destroy(mpt->fw_dmat);
2420b0a2fdeeSScott Long 				return (ENOMEM);
2421b0a2fdeeSScott Long 			}
2422b0a2fdeeSScott Long 			mi.mpt = mpt;
2423b0a2fdeeSScott Long 			mi.error = 0;
2424b0a2fdeeSScott Long 			bus_dmamap_load(mpt->fw_dmat, mpt->fw_dmap,
2425b0a2fdeeSScott Long 			    mpt->fw_image, mpt->fw_image_size, mpt_map_rquest,
2426b0a2fdeeSScott Long 			    &mi, 0);
2427b0a2fdeeSScott Long 			mpt->fw_phys = mi.phys;
2428b0a2fdeeSScott Long 
2429b0a2fdeeSScott Long 			error = mpt_upload_fw(mpt);
2430b0a2fdeeSScott Long 			if (error != 0) {
2431b0a2fdeeSScott Long 				mpt_prt(mpt, "fw upload failed.\n");
2432b0a2fdeeSScott Long 				bus_dmamap_unload(mpt->fw_dmat, mpt->fw_dmap);
2433b0a2fdeeSScott Long 				bus_dmamem_free(mpt->fw_dmat, mpt->fw_image,
2434b0a2fdeeSScott Long 				    mpt->fw_dmap);
2435b0a2fdeeSScott Long 				bus_dma_tag_destroy(mpt->fw_dmat);
2436b0a2fdeeSScott Long 				mpt->fw_image = NULL;
2437b0a2fdeeSScott Long 				return (EIO);
2438b0a2fdeeSScott Long 			}
2439b0a2fdeeSScott Long 		}
24409b631363SMatt Jacob 
24417104aeefSMatt Jacob 		if (mpt_get_portfacts(mpt, &pfp) != MPT_OK) {
2442b0a2fdeeSScott Long 			mpt_prt(mpt, "mpt_get_portfacts failed\n");
2443b0a2fdeeSScott Long 			needreset = 1;
24447104aeefSMatt Jacob 			continue;
24457104aeefSMatt Jacob 		}
24467104aeefSMatt Jacob 
2447b0a2fdeeSScott Long 		mpt_lprt(mpt, MPT_PRT_DEBUG,
24487dec90bcSMatt Jacob 			 "PORTFACTS: Type %x PFlags %x IID %d MaxDev %d\n",
24497dec90bcSMatt Jacob 			 pfp.PortType, pfp.ProtocolFlags, pfp.PortSCSIID,
24507dec90bcSMatt Jacob 			 pfp.MaxDevices);
24517104aeefSMatt Jacob 
2452b0a2fdeeSScott Long 		mpt->mpt_port_type = pfp.PortType;
2453b0a2fdeeSScott Long 		mpt->mpt_proto_flags = pfp.ProtocolFlags;
24547104aeefSMatt Jacob 		if (pfp.PortType != MPI_PORTFACTS_PORTTYPE_SCSI &&
2455444dd2b6SMatt Jacob 		    pfp.PortType != MPI_PORTFACTS_PORTTYPE_SAS &&
24567104aeefSMatt Jacob 		    pfp.PortType != MPI_PORTFACTS_PORTTYPE_FC) {
2457b0a2fdeeSScott Long 			mpt_prt(mpt, "Unsupported Port Type (%x)\n",
24587104aeefSMatt Jacob 			    pfp.PortType);
24597104aeefSMatt Jacob 			return (ENXIO);
24607104aeefSMatt Jacob 		}
2461c87e3f83SMatt Jacob 		mpt->mpt_max_tgtcmds = le16toh(pfp.MaxPostedCmdBuffers);
2462c87e3f83SMatt Jacob 
24637104aeefSMatt Jacob 		if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_FC) {
24647104aeefSMatt Jacob 			mpt->is_fc = 1;
2465444dd2b6SMatt Jacob 			mpt->is_sas = 0;
24665580ce96SMatt Jacob 			mpt->is_spi = 0;
2467444dd2b6SMatt Jacob 		} else if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_SAS) {
2468444dd2b6SMatt Jacob 			mpt->is_fc = 0;
2469444dd2b6SMatt Jacob 			mpt->is_sas = 1;
24705580ce96SMatt Jacob 			mpt->is_spi = 0;
24717104aeefSMatt Jacob 		} else {
24727104aeefSMatt Jacob 			mpt->is_fc = 0;
2473444dd2b6SMatt Jacob 			mpt->is_sas = 0;
24745580ce96SMatt Jacob 			mpt->is_spi = 1;
24757104aeefSMatt Jacob 		}
24767104aeefSMatt Jacob 		mpt->mpt_ini_id = pfp.PortSCSIID;
2477444dd2b6SMatt Jacob 		mpt->mpt_max_devices = pfp.MaxDevices;
24787104aeefSMatt Jacob 
2479c87e3f83SMatt Jacob 		/*
2480b4c618c0SMatt Jacob 		 * Set our role with what this port supports.
2481b4c618c0SMatt Jacob 		 *
2482b4c618c0SMatt Jacob 		 * Note this might be changed later in different modules
2483b4c618c0SMatt Jacob 		 * if this is different from what is wanted.
2484c87e3f83SMatt Jacob 		 */
24855089bd63SMatt Jacob 		mpt->role = MPT_ROLE_NONE;
2486c87e3f83SMatt Jacob 		if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) {
24875089bd63SMatt Jacob 			mpt->role |= MPT_ROLE_INITIATOR;
2488c87e3f83SMatt Jacob 		}
2489c87e3f83SMatt Jacob 		if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) {
24905089bd63SMatt Jacob 			mpt->role |= MPT_ROLE_TARGET;
2491c87e3f83SMatt Jacob 		}
2492c87e3f83SMatt Jacob 		if (mpt_enable_ioc(mpt, 0) != MPT_OK) {
2493c87e3f83SMatt Jacob 			mpt_prt(mpt, "unable to initialize IOC\n");
2494b0a2fdeeSScott Long 			return (ENXIO);
24957104aeefSMatt Jacob 		}
24967104aeefSMatt Jacob 
2497b0a2fdeeSScott Long 		/*
2498c87e3f83SMatt Jacob 		 * Read IOC configuration information.
24991d79ca0eSMatt Jacob 		 *
25001d79ca0eSMatt Jacob 		 * We need this to determine whether or not we have certain
25011d79ca0eSMatt Jacob 		 * settings for Integrated Mirroring (e.g.).
2502b0a2fdeeSScott Long 		 */
2503b0a2fdeeSScott Long 		mpt_read_config_info_ioc(mpt);
2504b0a2fdeeSScott Long 
2505b0a2fdeeSScott Long 		/* Everything worked */
2506b0a2fdeeSScott Long 		break;
2507b0a2fdeeSScott Long 	}
2508b0a2fdeeSScott Long 
2509b0a2fdeeSScott Long 	if (try >= MPT_MAX_TRYS) {
2510b0a2fdeeSScott Long 		mpt_prt(mpt, "failed to initialize IOC");
2511b0a2fdeeSScott Long 		return (EIO);
2512b0a2fdeeSScott Long 	}
2513b0a2fdeeSScott Long 
2514b0a2fdeeSScott Long 	return (0);
2515b0a2fdeeSScott Long }
2516b0a2fdeeSScott Long 
2517b0a2fdeeSScott Long static int
2518c87e3f83SMatt Jacob mpt_enable_ioc(struct mpt_softc *mpt, int portenable)
2519b0a2fdeeSScott Long {
2520b0a2fdeeSScott Long 	uint32_t pptr;
2521b0a2fdeeSScott Long 	int val;
2522b0a2fdeeSScott Long 
2523444dd2b6SMatt Jacob 	if (mpt_send_ioc_init(mpt, MPI_WHOINIT_HOST_DRIVER) != MPT_OK) {
2524b0a2fdeeSScott Long 		mpt_prt(mpt, "mpt_send_ioc_init failed\n");
2525b0a2fdeeSScott Long 		return (EIO);
2526b0a2fdeeSScott Long 	}
2527b0a2fdeeSScott Long 
2528b0a2fdeeSScott Long 	mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_send_ioc_init ok\n");
25299b631363SMatt Jacob 
25309b631363SMatt Jacob 	if (mpt_wait_state(mpt, MPT_DB_STATE_RUNNING) != MPT_OK) {
2531b0a2fdeeSScott Long 		mpt_prt(mpt, "IOC failed to go to run state\n");
2532b0a2fdeeSScott Long 		return (ENXIO);
25337104aeefSMatt Jacob 	}
2534444dd2b6SMatt Jacob 	mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC now at RUNSTATE\n");
25359b631363SMatt Jacob 
25369b631363SMatt Jacob 	/*
25379b631363SMatt Jacob 	 * Give it reply buffers
25389b631363SMatt Jacob 	 *
2539b0a2fdeeSScott Long 	 * Do *not* exceed global credits.
25409b631363SMatt Jacob 	 */
25419b631363SMatt Jacob 	for (val = 0, pptr = mpt->reply_phys;
25429b631363SMatt Jacob 	    (pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE);
25439b631363SMatt Jacob 	     pptr += MPT_REPLY_SIZE) {
25449b631363SMatt Jacob 		mpt_free_reply(mpt, pptr);
25459b631363SMatt Jacob 		if (++val == mpt->mpt_global_credits - 1)
25469b631363SMatt Jacob 			break;
25479b631363SMatt Jacob 	}
25489b631363SMatt Jacob 
2549c87e3f83SMatt Jacob 
2550c87e3f83SMatt Jacob 	/*
25515e073106SMatt Jacob 	 * Enable the port if asked. This is only done if we're resetting
25525e073106SMatt Jacob 	 * the IOC after initial startup.
2553c87e3f83SMatt Jacob 	 */
2554c87e3f83SMatt Jacob 	if (portenable) {
25557104aeefSMatt Jacob 		/*
25567104aeefSMatt Jacob 		 * Enable asynchronous event reporting
25577104aeefSMatt Jacob 		 */
25589b631363SMatt Jacob 		mpt_send_event_request(mpt, 1);
25599b631363SMatt Jacob 
25609b631363SMatt Jacob 		if (mpt_send_port_enable(mpt, 0) != MPT_OK) {
2561b0a2fdeeSScott Long 			mpt_prt(mpt, "failed to enable port 0\n");
2562b0a2fdeeSScott Long 			return (ENXIO);
25637104aeefSMatt Jacob 		}
2564c87e3f83SMatt Jacob 	}
256529ae59edSMatt Jacob 	return (MPT_OK);
25669b631363SMatt Jacob }
2567